| /* |
| * Copyright 1993, 2000 Christopher Seiwald. |
| * |
| * This file is part of Jam - see jam.c for Copyright information. |
| */ |
| |
| /* This file is ALSO: |
| * Copyright 2001-2004 David Abrahams. |
| * Copyright 2005 Reece H. Dunn. |
| * Copyright 2005 Rene Rivera. |
| * Distributed under the Boost Software License, Version 1.0. |
| * (See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt) |
| */ |
| |
| #include "jam.h" |
| #include "lists.h" |
| #include "parse.h" |
| #include "variable.h" |
| #include "expand.h" |
| #include "hash.h" |
| #include "filesys.h" |
| #include "newstr.h" |
| #include "strings.h" |
| #include "pathsys.h" |
| #include <stdlib.h> |
| #include <stdio.h> |
| |
| /* |
| * variable.c - handle Jam multi-element variables. |
| * |
| * External routines: |
| * |
| * var_defines() - load a bunch of variable=value settings. |
| * var_string() - expand a string with variables in it. |
| * var_get() - get value of a user defined symbol. |
| * var_set() - set a variable in jam's user defined symbol table. |
| * var_swap() - swap a variable's value with the given one. |
| * var_done() - free variable tables. |
| * |
| * Internal routines: |
| * |
| * var_enter() - make new var symbol table entry, returning var ptr. |
| * var_dump() - dump a variable to stdout. |
| * |
| * 04/13/94 (seiwald) - added shorthand L0 for null list pointer |
| * 08/23/94 (seiwald) - Support for '+=' (append to variable) |
| * 01/22/95 (seiwald) - split environment variables at blanks or :'s |
| * 05/10/95 (seiwald) - split path variables at SPLITPATH (not :) |
| * 09/11/00 (seiwald) - defunct var_list() removed |
| */ |
| |
| static struct hash *varhash = 0; |
| |
| /* |
| * VARIABLE - a user defined multi-value variable |
| */ |
| |
| typedef struct _variable VARIABLE ; |
| |
| struct _variable |
| { |
| char * symbol; |
| LIST * value; |
| }; |
| |
| static VARIABLE * var_enter( char * symbol ); |
| static void var_dump( char * symbol, LIST * value, char * what ); |
| |
| |
| /* |
| * var_hash_swap() - swap all variable settings with those passed |
| * |
| * Used to implement separate settings spaces for modules |
| */ |
| |
| void var_hash_swap( struct hash * * new_vars ) |
| { |
| struct hash * old = varhash; |
| varhash = *new_vars; |
| *new_vars = old; |
| } |
| |
| |
| /* |
| * var_defines() - load a bunch of variable=value settings |
| * |
| * If preprocess is false, take the value verbatim. |
| * |
| * Otherwise, if the variable value is enclosed in quotes, strip the |
| * quotes. |
| * |
| * Otherwise, if variable name ends in PATH, split value at :'s. |
| * |
| * Otherwise, split the value at blanks. |
| */ |
| |
| void var_defines( char * const * e, int preprocess ) |
| { |
| string buf[1]; |
| |
| string_new( buf ); |
| |
| for ( ; *e; ++e ) |
| { |
| char * val; |
| |
| # ifdef OS_MAC |
| /* On the mac (MPW), the var=val is actually var\0val */ |
| /* Think different. */ |
| |
| if ( ( val = strchr( *e, '=' ) ) || ( val = *e + strlen( *e ) ) ) |
| # else |
| if ( ( val = strchr( *e, '=' ) ) ) |
| # endif |
| { |
| LIST * l = L0; |
| char * pp; |
| char * p; |
| # ifdef OPT_NO_EXTERNAL_VARIABLE_SPLIT |
| char split = '\0'; |
| # else |
| # ifdef OS_MAC |
| char split = ','; |
| # else |
| char split = ' '; |
| # endif |
| # endif |
| size_t len = strlen( val + 1 ); |
| |
| int quoted = ( val[1] == '"' ) && ( val[len] == '"' ) && |
| ( len > 1 ); |
| |
| if ( quoted && preprocess ) |
| { |
| string_append_range( buf, val + 2, val + len ); |
| l = list_new( l, newstr( buf->value ) ); |
| string_truncate( buf, 0 ); |
| } |
| else |
| { |
| /* Split *PATH at :'s, not spaces. */ |
| if ( val - 4 >= *e ) |
| { |
| if ( !strncmp( val - 4, "PATH", 4 ) || |
| !strncmp( val - 4, "Path", 4 ) || |
| !strncmp( val - 4, "path", 4 ) ) |
| split = SPLITPATH; |
| } |
| |
| /* Do the split. */ |
| for |
| ( |
| pp = val + 1; |
| preprocess && ( ( p = strchr( pp, split ) ) != 0 ); |
| pp = p + 1 |
| ) |
| { |
| string_append_range( buf, pp, p ); |
| l = list_new( l, newstr( buf->value ) ); |
| string_truncate( buf, 0 ); |
| } |
| |
| l = list_new( l, newstr( pp ) ); |
| } |
| |
| /* Get name. */ |
| string_append_range( buf, *e, val ); |
| var_set( buf->value, l, VAR_SET ); |
| string_truncate( buf, 0 ); |
| } |
| } |
| string_free( buf ); |
| } |
| |
| |
| /* |
| * var_string() - expand a string with variables in it |
| * |
| * Copies in to out; doesn't modify targets & sources. |
| */ |
| |
| int var_string( char * in, char * out, int outsize, LOL * lol ) |
| { |
| char * out0 = out; |
| char * oute = out + outsize - 1; |
| |
| while ( *in ) |
| { |
| char * lastword; |
| int dollar = 0; |
| |
| /* Copy white space. */ |
| while ( isspace( *in ) ) |
| { |
| if ( out >= oute ) |
| return -1; |
| *out++ = *in++; |
| } |
| |
| lastword = out; |
| |
| /* Copy non-white space, watching for variables. */ |
| while ( *in && !isspace( *in ) ) |
| { |
| if ( out >= oute ) |
| return -1; |
| |
| if ( ( in[ 0 ] == '$' ) && ( in[ 1 ] == '(' ) ) |
| { |
| ++dollar; |
| *out++ = *in++; |
| } |
| #ifdef OPT_AT_FILES |
| else if ( ( in[ 0 ] == '@' ) && ( in[ 1 ] == '(' ) ) |
| { |
| int depth = 1; |
| char * ine = in + 2; |
| char * split = 0; |
| |
| /* Scan the content of the response file @() section. */ |
| while ( *ine && ( depth > 0 ) ) |
| { |
| switch ( *ine ) |
| { |
| case '(': ++depth; break; |
| case ')': --depth; break; |
| case ':': |
| if ( ( depth == 1 ) && ( ine[ 1 ] == 'E' ) && ( ine[ 2 ] == '=' ) ) |
| split = ine; |
| break; |
| } |
| ++ine; |
| } |
| |
| if ( !split ) |
| { |
| /* the @() reference doesn't match the @(foo:E=bar) format. |
| hence we leave it alone by copying directly to output. */ |
| int l = 0; |
| if ( out + 2 >= oute ) return -1; |
| *( out++ ) = '@'; |
| *( out++ ) = '('; |
| l = var_string( in + 2, out, oute - out, lol ); |
| if ( l < 0 ) return -1; |
| out += l; |
| if ( out + 1 >= oute ) return -1; |
| *( out++ ) = ')'; |
| } |
| else if ( depth == 0 ) |
| { |
| string file_name_v; |
| int file_name_l = 0; |
| const char * file_name_s = 0; |
| |
| /* Expand the temporary file name var inline. */ |
| #if 0 |
| string_copy( &file_name_v, "$(" ); |
| string_append_range( &file_name_v, in + 2, split ); |
| string_push_back( &file_name_v, ')' ); |
| #else |
| string_new( &file_name_v ); |
| string_append_range( &file_name_v, in + 2, split ); |
| #endif |
| file_name_l = var_string( file_name_v.value, out, oute - out + 1, lol ); |
| string_free( &file_name_v ); |
| if ( file_name_l < 0 ) return -1; |
| file_name_s = out; |
| |
| /* For stdout/stderr we will create a temp file and generate |
| * a command that outputs the content as needed. |
| */ |
| if ( ( strcmp( "STDOUT", out ) == 0 ) || |
| ( strcmp( "STDERR", out ) == 0 ) ) |
| { |
| int err_redir = strcmp( "STDERR", out ) == 0; |
| out[ 0 ] = '\0'; |
| file_name_s = path_tmpfile(); |
| file_name_l = strlen(file_name_s); |
| #ifdef OS_NT |
| if ( ( out + 7 + file_name_l + ( err_redir ? 5 : 0 ) ) >= oute ) |
| return -1; |
| sprintf( out,"type \"%s\"%s", file_name_s, |
| err_redir ? " 1>&2" : "" ); |
| #else |
| if ( ( out + 6 + file_name_l + ( err_redir ? 5 : 0 ) ) >= oute ) |
| return -1; |
| sprintf( out,"cat \"%s\"%s", file_name_s, |
| err_redir ? " 1>&2" : "" ); |
| #endif |
| /* We also make sure that the temp files created by this |
| * get nuked eventually. |
| */ |
| file_remove_atexit( file_name_s ); |
| } |
| |
| /* Expand the file value into the file reference. */ |
| var_string_to_file( split + 3, ine - split - 4, file_name_s, |
| lol ); |
| |
| /* Continue on with the expansion. */ |
| out += strlen( out ); |
| } |
| |
| /* And continue with the parsing just past the @() reference. */ |
| in = ine; |
| } |
| #endif |
| else |
| { |
| *out++ = *in++; |
| } |
| } |
| |
| /* Add zero to 'out' so that 'lastword' is correctly zero-terminated. */ |
| if ( out >= oute ) |
| return -1; |
| /* Do not increment, intentionally. */ |
| *out = '\0'; |
| |
| /* If a variable encountered, expand it and and embed the |
| * space-separated members of the list in the output. |
| */ |
| if ( dollar ) |
| { |
| LIST * l = var_expand( L0, lastword, out, lol, 0 ); |
| |
| out = lastword; |
| |
| while ( l ) |
| { |
| int so = strlen( l->string ); |
| |
| if ( out + so >= oute ) |
| return -1; |
| |
| strcpy( out, l->string ); |
| out += so; |
| l = list_next( l ); |
| if ( l ) *out++ = ' '; |
| } |
| |
| list_free( l ); |
| } |
| } |
| |
| if ( out >= oute ) |
| return -1; |
| |
| *out++ = '\0'; |
| |
| return out - out0; |
| } |
| |
| |
| void var_string_to_file( const char * in, int insize, const char * out, LOL * lol ) |
| { |
| char const * ine = in + insize; |
| FILE * out_file = 0; |
| int out_debug = DEBUG_EXEC ? 1 : 0; |
| if ( globs.noexec ) |
| { |
| /* out_debug = 1; */ |
| } |
| else if ( strcmp( out, "STDOUT" ) == 0 ) |
| { |
| out_file = stdout; |
| } |
| else if ( strcmp( out, "STDERR" ) == 0 ) |
| { |
| out_file = stderr; |
| } |
| else |
| { |
| /* Handle "path to file" filenames. */ |
| string out_name; |
| if ( ( out[ 0 ] == '"' ) && ( out[ strlen( out ) - 1 ] == '"' ) ) |
| { |
| string_copy( &out_name, out + 1 ); |
| string_truncate( &out_name, out_name.size - 1 ); |
| } |
| else |
| { |
| string_copy( &out_name,out ); |
| } |
| out_file = fopen( out_name.value, "w" ); |
| if ( !out_file ) |
| { |
| printf( "failed to write output file '%s'!\n", out_name.value ); |
| exit( EXITBAD ); |
| } |
| string_free( &out_name ); |
| } |
| |
| if ( out_debug ) printf( "\nfile %s\n", out ); |
| |
| while ( *in && ( in < ine ) ) |
| { |
| int dollar = 0; |
| const char * output_0 = in; |
| const char * output_1 = in; |
| |
| /* Copy white space. */ |
| while ( ( output_1 < ine ) && isspace( *output_1 ) ) |
| ++output_1; |
| |
| if ( output_0 < output_1 ) |
| { |
| if ( out_file ) fwrite( output_0, output_1 - output_0, 1, out_file ); |
| if ( out_debug ) fwrite( output_0, output_1 - output_0, 1, stdout ); |
| } |
| output_0 = output_1; |
| |
| /* Copy non-white space, watching for variables. */ |
| while ( ( output_1 < ine ) && *output_1 && !isspace( *output_1 ) ) |
| { |
| if ( ( output_1[ 0 ] == '$' ) && ( output_1[ 1 ] == '(' ) ) |
| ++dollar; |
| ++output_1; |
| } |
| |
| /* If a variable encountered, expand it and embed the space-separated |
| * members of the list in the output. |
| */ |
| if ( dollar ) |
| { |
| LIST * l = var_expand( L0, (char *)output_0, (char *)output_1, lol, 0 ); |
| |
| while ( l ) |
| { |
| if ( out_file ) fputs( l->string, out_file ); |
| if ( out_debug ) puts( l->string ); |
| l = list_next( l ); |
| if ( l ) |
| { |
| if ( out_file ) fputc( ' ', out_file ); |
| if ( out_debug ) fputc( ' ', stdout ); |
| } |
| } |
| |
| list_free( l ); |
| } |
| else if ( output_0 < output_1 ) |
| { |
| if ( out_file ) |
| { |
| const char * output_n = output_0; |
| while ( output_n < output_1 ) |
| { |
| output_n += fwrite( output_n, 1, output_1-output_n, out_file ); |
| } |
| } |
| if ( out_debug ) |
| { |
| const char * output_n = output_0; |
| while ( output_n < output_1 ) |
| { |
| output_n += fwrite( output_n, 1, output_1-output_n, stdout ); |
| } |
| } |
| } |
| |
| in = output_1; |
| } |
| |
| if ( out_file && ( out_file != stdout ) && ( out_file != stderr ) ) |
| { |
| fflush( out_file ); |
| fclose( out_file ); |
| } |
| |
| if ( out_debug ) fputc( '\n', stdout ); |
| } |
| |
| |
| /* |
| * var_get() - get value of a user defined symbol. |
| * |
| * Returns NULL if symbol unset. |
| */ |
| |
| LIST * var_get( char * symbol ) |
| { |
| LIST * result = 0; |
| #ifdef OPT_AT_FILES |
| /* Some "fixed" variables... */ |
| if ( strcmp( "TMPDIR", symbol ) == 0 ) |
| { |
| result = list_new( L0, newstr( (char *)path_tmpdir() ) ); |
| } |
| else if ( strcmp( "TMPNAME", symbol ) == 0 ) |
| { |
| result = list_new( L0, newstr( (char *)path_tmpnam() ) ); |
| } |
| else if ( strcmp( "TMPFILE", symbol ) == 0 ) |
| { |
| result = list_new( L0, newstr( (char *)path_tmpfile() ) ); |
| } |
| else if ( strcmp( "STDOUT", symbol ) == 0 ) |
| { |
| result = list_new( L0, newstr( "STDOUT" ) ); |
| } |
| else if ( strcmp( "STDERR", symbol ) == 0 ) |
| { |
| result = list_new( L0, newstr( "STDERR" ) ); |
| } |
| else |
| #endif |
| { |
| VARIABLE var; |
| VARIABLE * v = &var; |
| |
| v->symbol = symbol; |
| |
| if ( varhash && hashcheck( varhash, (HASHDATA * *)&v ) ) |
| { |
| if ( DEBUG_VARGET ) |
| var_dump( v->symbol, v->value, "get" ); |
| result = v->value; |
| } |
| } |
| return result; |
| } |
| |
| |
| /* |
| * var_set() - set a variable in Jam's user defined symbol table. |
| * |
| * 'flag' controls the relationship between new and old values of the variable: |
| * SET replaces the old with the new; APPEND appends the new to the old; DEFAULT |
| * only uses the new if the variable was previously unset. |
| * |
| * Copies symbol. Takes ownership of value. |
| */ |
| |
| void var_set( char * symbol, LIST * value, int flag ) |
| { |
| VARIABLE * v = var_enter( symbol ); |
| |
| if ( DEBUG_VARSET ) |
| var_dump( symbol, value, "set" ); |
| |
| switch ( flag ) |
| { |
| case VAR_SET: |
| /* Replace value */ |
| list_free( v->value ); |
| v->value = value; |
| break; |
| |
| case VAR_APPEND: |
| /* Append value */ |
| v->value = list_append( v->value, value ); |
| break; |
| |
| case VAR_DEFAULT: |
| /* Set only if unset */ |
| if ( !v->value ) |
| v->value = value; |
| else |
| list_free( value ); |
| break; |
| } |
| } |
| |
| |
| /* |
| * var_swap() - swap a variable's value with the given one. |
| */ |
| |
| LIST * var_swap( char * symbol, LIST * value ) |
| { |
| VARIABLE * v = var_enter( symbol ); |
| LIST * oldvalue = v->value; |
| if ( DEBUG_VARSET ) |
| var_dump( symbol, value, "set" ); |
| v->value = value; |
| return oldvalue; |
| } |
| |
| |
| /* |
| * var_enter() - make new var symbol table entry, returning var ptr. |
| */ |
| |
| static VARIABLE * var_enter( char * symbol ) |
| { |
| VARIABLE var; |
| VARIABLE * v = &var; |
| |
| if ( !varhash ) |
| varhash = hashinit( sizeof( VARIABLE ), "variables" ); |
| |
| v->symbol = symbol; |
| v->value = 0; |
| |
| if ( hashenter( varhash, (HASHDATA * *)&v ) ) |
| v->symbol = newstr( symbol ); /* never freed */ |
| |
| return v; |
| } |
| |
| |
| /* |
| * var_dump() - dump a variable to stdout. |
| */ |
| |
| static void var_dump( char * symbol, LIST * value, char * what ) |
| { |
| printf( "%s %s = ", what, symbol ); |
| list_print( value ); |
| printf( "\n" ); |
| } |
| |
| |
| /* |
| * var_done() - free variable tables. |
| */ |
| |
| static void delete_var_( void * xvar, void * data ) |
| { |
| VARIABLE * v = (VARIABLE *)xvar; |
| freestr( v->symbol ); |
| list_free( v-> value ); |
| } |
| |
| |
| void var_done() |
| { |
| hashenumerate( varhash, delete_var_, (void *)0 ); |
| hashdone( varhash ); |
| } |
