/*
* 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 );
}