http://git-wip-us.apache.org/repos/asf/incubator-joshua/blob/6da3961b/ext/kenlm/jam-files/engine/function.c ---------------------------------------------------------------------- diff --git a/ext/kenlm b/ext/kenlm new file mode 160000 index 0000000..56fdb5c --- /dev/null +++ b/ext/kenlm @@ -0,0 +1 @@ +Subproject commit 56fdb5c44fca34d5a2e07d96139c28fb163983c5 diff --git a/ext/kenlm/jam-files/engine/function.c b/ext/kenlm/jam-files/engine/function.c deleted file mode 100644 index 690855e..0000000 --- a/ext/kenlm/jam-files/engine/function.c +++ /dev/null @@ -1,4870 +0,0 @@ -/* - * Copyright 2011 Steven Watanabe - * Distributed under the Boost Software License, Version 1.0. - * (See accompanying file LICENSE_1_0.txt or copy at - * http://www.boost.org/LICENSE_1_0.txt) - */ - -#include "jam.h" -#include "function.h" - -#include "class.h" -#include "compile.h" -#include "constants.h" -#include "filesys.h" -#include "frames.h" -#include "lists.h" -#include "mem.h" -#include "pathsys.h" -#include "rules.h" -#include "search.h" -#include "variable.h" - -#include <assert.h> -#include <stdio.h> -#include <stdlib.h> -#include <string.h> - -#ifdef OS_CYGWIN -# include <cygwin/version.h> -# include <sys/cygwin.h> -# ifdef CYGWIN_VERSION_CYGWIN_CONV -# include <errno.h> -# endif -# include <windows.h> -#endif - -int glob( char const * s, char const * c ); -void backtrace( FRAME * ); -void backtrace_line( FRAME * ); - -#define INSTR_PUSH_EMPTY 0 -#define INSTR_PUSH_CONSTANT 1 -#define INSTR_PUSH_ARG 2 -#define INSTR_PUSH_VAR 3 -#define INSTR_PUSH_VAR_FIXED 57 -#define INSTR_PUSH_GROUP 4 -#define INSTR_PUSH_RESULT 5 -#define INSTR_PUSH_APPEND 6 -#define INSTR_SWAP 7 - -#define INSTR_JUMP_EMPTY 8 -#define INSTR_JUMP_NOT_EMPTY 9 - -#define INSTR_JUMP 10 -#define INSTR_JUMP_LT 11 -#define INSTR_JUMP_LE 12 -#define INSTR_JUMP_GT 13 -#define INSTR_JUMP_GE 14 -#define INSTR_JUMP_EQ 15 -#define INSTR_JUMP_NE 16 -#define INSTR_JUMP_IN 17 -#define INSTR_JUMP_NOT_IN 18 - -#define INSTR_JUMP_NOT_GLOB 19 - -#define INSTR_FOR_INIT 56 -#define INSTR_FOR_LOOP 20 - -#define INSTR_SET_RESULT 21 -#define INSTR_RETURN 22 -#define INSTR_POP 23 - -#define INSTR_PUSH_LOCAL 24 -#define INSTR_POP_LOCAL 25 -#define INSTR_SET 26 -#define INSTR_APPEND 27 -#define INSTR_DEFAULT 28 - -#define INSTR_PUSH_LOCAL_FIXED 58 -#define INSTR_POP_LOCAL_FIXED 59 -#define INSTR_SET_FIXED 60 -#define INSTR_APPEND_FIXED 61 -#define INSTR_DEFAULT_FIXED 62 - -#define INSTR_PUSH_LOCAL_GROUP 29 -#define INSTR_POP_LOCAL_GROUP 30 -#define INSTR_SET_GROUP 31 -#define INSTR_APPEND_GROUP 32 -#define INSTR_DEFAULT_GROUP 33 - -#define INSTR_PUSH_ON 34 -#define INSTR_POP_ON 35 -#define INSTR_SET_ON 36 -#define INSTR_APPEND_ON 37 -#define INSTR_DEFAULT_ON 38 -#define INSTR_GET_ON 65 - -#define INSTR_CALL_RULE 39 -#define INSTR_CALL_MEMBER_RULE 66 - -#define INSTR_APPLY_MODIFIERS 40 -#define INSTR_APPLY_INDEX 41 -#define INSTR_APPLY_INDEX_MODIFIERS 42 -#define INSTR_APPLY_MODIFIERS_GROUP 43 -#define INSTR_APPLY_INDEX_GROUP 44 -#define INSTR_APPLY_INDEX_MODIFIERS_GROUP 45 -#define INSTR_COMBINE_STRINGS 46 -#define INSTR_GET_GRIST 64 - -#define INSTR_INCLUDE 47 -#define INSTR_RULE 48 -#define INSTR_ACTIONS 49 -#define INSTR_PUSH_MODULE 50 -#define INSTR_POP_MODULE 51 -#define INSTR_CLASS 52 -#define INSTR_BIND_MODULE_VARIABLES 63 - -#define INSTR_APPEND_STRINGS 53 -#define INSTR_WRITE_FILE 54 -#define INSTR_OUTPUT_STRINGS 55 - -typedef struct instruction -{ - unsigned int op_code; - int arg; -} instruction; - -typedef struct _subfunction -{ - OBJECT * name; - FUNCTION * code; - int local; -} SUBFUNCTION; - -typedef struct _subaction -{ - OBJECT * name; - FUNCTION * command; - int flags; -} SUBACTION; - -#define FUNCTION_BUILTIN 0 -#define FUNCTION_JAM 1 - -struct argument -{ - int flags; -#define ARG_ONE 0 -#define ARG_OPTIONAL 1 -#define ARG_PLUS 2 -#define ARG_STAR 3 -#define ARG_VARIADIC 4 - OBJECT * type_name; - OBJECT * arg_name; - int index; -}; - -struct arg_list -{ - int size; - struct argument * args; -}; - -struct _function -{ - int type; - int reference_count; - OBJECT * rulename; - struct arg_list * formal_arguments; - int num_formal_arguments; -}; - -typedef struct _builtin_function -{ - FUNCTION base; - LIST * ( * func )( FRAME *, int flags ); - int flags; -} BUILTIN_FUNCTION; - -typedef struct _jam_function -{ - FUNCTION base; - int code_size; - instruction * code; - int num_constants; - OBJECT * * constants; - int num_subfunctions; - SUBFUNCTION * functions; - int num_subactions; - SUBACTION * actions; - FUNCTION * generic; - OBJECT * file; - int line; -} JAM_FUNCTION; - - -#ifdef HAVE_PYTHON - -#define FUNCTION_PYTHON 2 - -typedef struct _python_function -{ - FUNCTION base; - PyObject * python_function; -} PYTHON_FUNCTION; - -static LIST * call_python_function( PYTHON_FUNCTION *, FRAME * ); - -#endif - - -struct _stack -{ - void * data; -}; - -static void * stack; - -STACK * stack_global() -{ - static STACK result; - if ( !stack ) - { - int const size = 1 << 21; - stack = BJAM_MALLOC( size ); - result.data = (char *)stack + size; - } - return &result; -} - -static void check_alignment( STACK * s ) -{ - assert( (size_t)s->data % sizeof( LIST * ) == 0 ); -} - -void * stack_allocate( STACK * s, int size ) -{ - check_alignment( s ); - s->data = (char *)s->data - size; - check_alignment( s ); - return s->data; -} - -void stack_deallocate( STACK * s, int size ) -{ - check_alignment( s ); - s->data = (char *)s->data + size; - check_alignment( s ); -} - -void stack_push( STACK * s, LIST * l ) -{ - *(LIST * *)stack_allocate( s, sizeof( LIST * ) ) = l; -} - -LIST * stack_pop( STACK * s ) -{ - LIST * const result = *(LIST * *)s->data; - stack_deallocate( s, sizeof( LIST * ) ); - return result; -} - -LIST * stack_top( STACK * s ) -{ - check_alignment( s ); - return *(LIST * *)s->data; -} - -LIST * stack_at( STACK * s, int n ) -{ - check_alignment( s ); - return *( (LIST * *)s->data + n ); -} - -void stack_set( STACK * s, int n, LIST * value ) -{ - check_alignment( s ); - *((LIST * *)s->data + n) = value; -} - -void * stack_get( STACK * s ) -{ - check_alignment( s ); - return s->data; -} - -LIST * frame_get_local( FRAME * frame, int idx ) -{ - /* The only local variables are the arguments. */ - return list_copy( lol_get( frame->args, idx ) ); -} - -static OBJECT * function_get_constant( JAM_FUNCTION * function, int idx ) -{ - return function->constants[ idx ]; -} - -static LIST * function_get_variable( JAM_FUNCTION * function, FRAME * frame, - int idx ) -{ - return list_copy( var_get( frame->module, function->constants[ idx ] ) ); -} - -static void function_set_variable( JAM_FUNCTION * function, FRAME * frame, - int idx, LIST * value ) -{ - var_set( frame->module, function->constants[ idx ], value, VAR_SET ); -} - -static LIST * function_swap_variable( JAM_FUNCTION * function, FRAME * frame, - int idx, LIST * value ) -{ - return var_swap( frame->module, function->constants[ idx ], value ); -} - -static void function_append_variable( JAM_FUNCTION * function, FRAME * frame, - int idx, LIST * value ) -{ - var_set( frame->module, function->constants[ idx ], value, VAR_APPEND ); -} - -static void function_default_variable( JAM_FUNCTION * function, FRAME * frame, - int idx, LIST * value ) -{ - var_set( frame->module, function->constants[ idx ], value, VAR_DEFAULT ); -} - -static void function_set_rule( JAM_FUNCTION * function, FRAME * frame, - STACK * s, int idx ) -{ - SUBFUNCTION * sub = function->functions + idx; - new_rule_body( frame->module, sub->name, sub->code, !sub->local ); -} - -static void function_set_actions( JAM_FUNCTION * function, FRAME * frame, - STACK * s, int idx ) -{ - SUBACTION * sub = function->actions + idx; - LIST * bindlist = stack_pop( s ); - new_rule_actions( frame->module, sub->name, sub->command, bindlist, - sub->flags ); -} - - -/* - * Returns the index if name is "<", ">", "1", "2", ... or "19" otherwise - * returns -1. - */ - -static int get_argument_index( char const * s ) -{ - if ( s[ 0 ] != '\0') - { - if ( s[ 1 ] == '\0' ) - { - switch ( s[ 0 ] ) - { - case '<': return 0; - case '>': return 1; - - case '1': - case '2': - case '3': - case '4': - case '5': - case '6': - case '7': - case '8': - case '9': - return s[ 0 ] - '1'; - } - } - else if ( s[ 0 ] == '1' && s[ 2 ] == '\0' ) - { - switch( s[ 1 ] ) - { - case '0': - case '1': - case '2': - case '3': - case '4': - case '5': - case '6': - case '7': - case '8': - case '9': - return s[ 1 ] - '0' + 10 - 1; - } - } - } - return -1; -} - -static LIST * function_get_named_variable( JAM_FUNCTION * function, - FRAME * frame, OBJECT * name ) -{ - int const idx = get_argument_index( object_str( name ) ); - return idx == -1 - ? list_copy( var_get( frame->module, name ) ) - : list_copy( lol_get( frame->args, idx ) ); -} - -static void function_set_named_variable( JAM_FUNCTION * function, FRAME * frame, - OBJECT * name, LIST * value) -{ - var_set( frame->module, name, value, VAR_SET ); -} - -static LIST * function_swap_named_variable( JAM_FUNCTION * function, - FRAME * frame, OBJECT * name, LIST * value ) -{ - return var_swap( frame->module, name, value ); -} - -static void function_append_named_variable( JAM_FUNCTION * function, - FRAME * frame, OBJECT * name, LIST * value) -{ - var_set( frame->module, name, value, VAR_APPEND ); -} - -static void function_default_named_variable( JAM_FUNCTION * function, - FRAME * frame, OBJECT * name, LIST * value ) -{ - var_set( frame->module, name, value, VAR_DEFAULT ); -} - -static LIST * function_call_rule( JAM_FUNCTION * function, FRAME * frame, - STACK * s, int n_args, char const * unexpanded, OBJECT * file, int line ) -{ - FRAME inner[ 1 ]; - int i; - LIST * first = stack_pop( s ); - LIST * result = L0; - OBJECT * rulename; - LIST * trailing; - - frame->file = file; - frame->line = line; - - if ( list_empty( first ) ) - { - backtrace_line( frame ); - printf( "warning: rulename %s expands to empty string\n", unexpanded ); - backtrace( frame ); - list_free( first ); - for ( i = 0; i < n_args; ++i ) - list_free( stack_pop( s ) ); - return result; - } - - rulename = object_copy( list_front( first ) ); - - frame_init( inner ); - inner->prev = frame; - inner->prev_user = frame->module->user_module ? frame : frame->prev_user; - inner->module = frame->module; /* This gets fixed up in evaluate_rule(). */ - - for ( i = 0; i < n_args; ++i ) - lol_add( inner->args, stack_at( s, n_args - i - 1 ) ); - - for ( i = 0; i < n_args; ++i ) - stack_pop( s ); - - trailing = list_pop_front( first ); - if ( trailing ) - { - if ( inner->args->count == 0 ) - lol_add( inner->args, trailing ); - else - { - LIST * * const l = &inner->args->list[ 0 ]; - *l = list_append( trailing, *l ); - } - } - - result = evaluate_rule( bindrule( rulename, inner->module ), rulename, inner ); - frame_free( inner ); - object_free( rulename ); - return result; -} - -static LIST * function_call_member_rule( JAM_FUNCTION * function, FRAME * frame, STACK * s, int n_args, OBJECT * rulename, OBJECT * file, int line ) -{ - FRAME inner[ 1 ]; - int i; - LIST * first = stack_pop( s ); - LIST * result = L0; - LIST * trailing; - RULE * rule; - module_t * module; - OBJECT * real_rulename = 0; - - frame->file = file; - frame->line = line; - - if ( list_empty( first ) ) - { - backtrace_line( frame ); - printf( "warning: object is empty\n" ); - backtrace( frame ); - - list_free( first ); - - for( i = 0; i < n_args; ++i ) - { - list_free( stack_pop( s ) ); - } - - return result; - } - - /* FIXME: handle generic case */ - assert( list_length( first ) == 1 ); - - module = bindmodule( list_front( first ) ); - if ( module->class_module ) - { - rule = bindrule( rulename, module ); - real_rulename = object_copy( function_rulename( rule->procedure ) ); - } - else - { - string buf[ 1 ]; - string_new( buf ); - string_append( buf, object_str( list_front( first ) ) ); - string_push_back( buf, '.' ); - string_append( buf, object_str( rulename ) ); - real_rulename = object_new( buf->value ); - string_free( buf ); - rule = bindrule( real_rulename, frame->module ); - } - - frame_init( inner ); - - inner->prev = frame; - inner->prev_user = frame->module->user_module ? frame : frame->prev_user; - inner->module = frame->module; /* This gets fixed up in evaluate_rule(), below. */ - - for( i = 0; i < n_args; ++i ) - { - lol_add( inner->args, stack_at( s, n_args - i - 1 ) ); - } - - for( i = 0; i < n_args; ++i ) - { - stack_pop( s ); - } - - if ( list_length( first ) > 1 ) - { - string buf[ 1 ]; - LIST * trailing = L0; - LISTITER iter = list_begin( first ), end = list_end( first ); - iter = list_next( iter ); - string_new( buf ); - for ( ; iter != end; iter = list_next( iter ) ) - { - string_append( buf, object_str( list_item( iter ) ) ); - string_push_back( buf, '.' ); - string_append( buf, object_str( rulename ) ); - trailing = list_push_back( trailing, object_new( buf->value ) ); - string_truncate( buf, 0 ); - } - string_free( buf ); - if ( inner->args->count == 0 ) - lol_add( inner->args, trailing ); - else - { - LIST * * const l = &inner->args->list[ 0 ]; - *l = list_append( trailing, *l ); - } - } - - result = evaluate_rule( rule, real_rulename, inner ); - frame_free( inner ); - object_free( rulename ); - object_free( real_rulename ); - return result; -} - - -/* Variable expansion */ - -typedef struct -{ - int sub1; - int sub2; -} subscript_t; - -typedef struct -{ - PATHNAME f; /* :GDBSMR -- pieces */ - char parent; /* :P -- go to parent directory */ - char filemods; /* one of the above applied */ - char downshift; /* :L -- downshift result */ - char upshift; /* :U -- upshift result */ - char to_slashes; /* :T -- convert "\" to "/" */ - char to_windows; /* :W -- convert cygwin to native paths */ - PATHPART empty; /* :E -- default for empties */ - PATHPART join; /* :J -- join list with char */ -} VAR_EDITS; - -static LIST * apply_modifiers_impl( LIST * result, string * buf, - VAR_EDITS * edits, int n, LISTITER iter, LISTITER end ); -static void get_iters( subscript_t const subscript, LISTITER * const first, - LISTITER * const last, int const length ); - - -/* - * var_edit_parse() - parse : modifiers into PATHNAME structure - * - * The : modifiers in a $(varname:modifier) currently support replacing or - * omitting elements of a filename, and so they are parsed into a PATHNAME - * structure (which contains pointers into the original string). - * - * Modifiers of the form "X=value" replace the component X with the given value. - * Modifiers without the "=value" cause everything but the component X to be - * omitted. X is one of: - * - * G <grist> - * D directory name - * B base name - * S .suffix - * M (member) - * R root directory - prepended to whole path - * - * This routine sets: - * - * f->f_xxx.ptr = 0 - * f->f_xxx.len = 0 - * -> leave the original component xxx - * - * f->f_xxx.ptr = string - * f->f_xxx.len = strlen( string ) - * -> replace component xxx with string - * - * f->f_xxx.ptr = "" - * f->f_xxx.len = 0 - * -> omit component xxx - * - * var_edit_file() below and path_build() obligingly follow this convention. - */ - -static int var_edit_parse( char const * mods, VAR_EDITS * edits, int havezeroed - ) -{ - while ( *mods ) - { - PATHPART * fp; - - switch ( *mods++ ) - { - case 'L': edits->downshift = 1; continue; - case 'U': edits->upshift = 1; continue; - case 'P': edits->parent = edits->filemods = 1; continue; - case 'E': fp = &edits->empty; goto strval; - case 'J': fp = &edits->join; goto strval; - case 'G': fp = &edits->f.f_grist; goto fileval; - case 'R': fp = &edits->f.f_root; goto fileval; - case 'D': fp = &edits->f.f_dir; goto fileval; - case 'B': fp = &edits->f.f_base; goto fileval; - case 'S': fp = &edits->f.f_suffix; goto fileval; - case 'M': fp = &edits->f.f_member; goto fileval; - case 'T': edits->to_slashes = 1; continue; - case 'W': edits->to_windows = 1; continue; - default: - continue; /* Should complain, but so what... */ - } - - fileval: - /* Handle :CHARS, where each char (without a following =) selects a - * particular file path element. On the first such char, we deselect all - * others (by setting ptr = "", len = 0) and for each char we select - * that element (by setting ptr = 0). - */ - edits->filemods = 1; - - if ( *mods != '=' ) - { - if ( !havezeroed++ ) - { - int i; - for ( i = 0; i < 6; ++i ) - { - edits->f.part[ i ].len = 0; - edits->f.part[ i ].ptr = ""; - } - } - - fp->ptr = 0; - continue; - } - - strval: - /* Handle :X=value, or :X */ - if ( *mods != '=' ) - { - fp->ptr = ""; - fp->len = 0; - } - else - { - fp->ptr = ++mods; - fp->len = strlen( mods ); - mods += fp->len; - } - } - - return havezeroed; -} - - -/* - * var_edit_file() - copy input target name to output, modifying filename. - */ - -static void var_edit_file( char const * in, string * out, VAR_EDITS * edits ) -{ - if ( edits->filemods ) - { - PATHNAME pathname; - - /* Parse apart original filename, putting parts into "pathname". */ - path_parse( in, &pathname ); - - /* Replace any pathname with edits->f */ - if ( edits->f.f_grist .ptr ) pathname.f_grist = edits->f.f_grist; - if ( edits->f.f_root .ptr ) pathname.f_root = edits->f.f_root; - if ( edits->f.f_dir .ptr ) pathname.f_dir = edits->f.f_dir; - if ( edits->f.f_base .ptr ) pathname.f_base = edits->f.f_base; - if ( edits->f.f_suffix.ptr ) pathname.f_suffix = edits->f.f_suffix; - if ( edits->f.f_member.ptr ) pathname.f_member = edits->f.f_member; - - /* If requested, modify pathname to point to parent. */ - if ( edits->parent ) - path_parent( &pathname ); - - /* Put filename back together. */ - path_build( &pathname, out ); - } - else - string_append( out, in ); -} - -/* - * var_edit_cyg2win() - conversion of a cygwin to a Windows path. - * - * FIXME: skip grist - */ - -#ifdef OS_CYGWIN -static void var_edit_cyg2win( string * out, size_t pos, VAR_EDITS * edits ) -{ - if ( edits->to_windows ) - { - #ifdef CYGWIN_VERSION_CYGWIN_CONV - /* Use new Cygwin API added with Cygwin 1.7. Old one had no error - * handling and has been deprecated. - */ - char * dynamicBuffer = 0; - char buffer[ MAX_PATH + 1001 ]; - char const * result = buffer; - cygwin_conv_path_t const conv_type = CCP_POSIX_TO_WIN_A | CCP_RELATIVE; - ssize_t const apiResult = cygwin_conv_path( conv_type, out->value + pos, - buffer, sizeof( buffer ) / sizeof( *buffer ) ); - assert( apiResult == 0 || apiResult == -1 ); - assert( apiResult || strlen( result ) < sizeof( buffer ) / sizeof( - *buffer ) ); - if ( apiResult ) - { - result = 0; - if ( errno == ENOSPC ) - { - ssize_t const size = cygwin_conv_path( conv_type, out->value + - pos, NULL, 0 ); - assert( size >= -1 ); - if ( size > 0 ) - { - dynamicBuffer = (char *)BJAM_MALLOC_ATOMIC( size ); - if ( dynamicBuffer ) - { - ssize_t const apiResult = cygwin_conv_path( conv_type, - out->value + pos, dynamicBuffer, size ); - assert( apiResult == 0 || apiResult == -1 ); - if ( !apiResult ) - { - result = dynamicBuffer; - assert( strlen( result ) < size ); - } - } - } - } - } - #else /* CYGWIN_VERSION_CYGWIN_CONV */ - /* Use old Cygwin API deprecated with Cygwin 1.7. */ - char result[ MAX_PATH + 1 ]; - cygwin_conv_to_win32_path( out->value + pos, result ); - assert( strlen( result ) <= MAX_PATH ); - #endif /* CYGWIN_VERSION_CYGWIN_CONV */ - if ( result ) - { - string_truncate( out, pos ); - string_append( out, result ); - edits->to_slashes = 0; - } - #ifdef CYGWIN_VERSION_CYGWIN_CONV - if ( dynamicBuffer ) - BJAM_FREE( dynamicBuffer ); - #endif - } -} -#endif /* OS_CYGWIN */ - - -/* - * var_edit_shift() - do upshift/downshift & other mods. - */ - -static void var_edit_shift( string * out, size_t pos, VAR_EDITS * edits ) -{ -#ifdef OS_CYGWIN - var_edit_cyg2win( out, pos, edits ); -#endif - - if ( edits->upshift || edits->downshift || edits->to_slashes ) - { - /* Handle upshifting, downshifting and slash translation now. */ - char * p; - for ( p = out->value + pos; *p; ++p ) - { - if ( edits->upshift ) - *p = toupper( *p ); - else if ( edits->downshift ) - *p = tolower( *p ); - if ( edits->to_slashes && ( *p == '\\' ) ) - *p = '/'; - } - } -} - - -/* - * Reads n LISTs from the top of the STACK and combines them to form VAR_EDITS. - * Returns the number of VAR_EDITS pushed onto the STACK. - */ - -static int expand_modifiers( STACK * s, int n ) -{ - int i; - int total = 1; - LIST * * args = stack_get( s ); - for ( i = 0; i < n; ++i ) - total *= list_length( args[ i ] ); - - if ( total != 0 ) - { - VAR_EDITS * out = stack_allocate( s, total * sizeof( VAR_EDITS ) ); - LISTITER * iter = stack_allocate( s, n * sizeof( LIST * ) ); - for ( i = 0; i < n; ++i ) - iter[ i ] = list_begin( args[ i ] ); - i = 0; - { - int havezeroed; - loop: - memset( out, 0, sizeof( *out ) ); - havezeroed = 0; - for ( i = 0; i < n; ++i ) - havezeroed = var_edit_parse( object_str( list_item( iter[ i ] ) - ), out, havezeroed ); - ++out; - while ( --i >= 0 ) - { - if ( list_next( iter[ i ] ) != list_end( args[ i ] ) ) - { - iter[ i ] = list_next( iter[ i ] ); - goto loop; - } - iter[ i ] = list_begin( args[ i ] ); - } - } - stack_deallocate( s, n * sizeof( LIST * ) ); - } - return total; -} - -static LIST * apply_modifiers( STACK * s, int n ) -{ - LIST * value = stack_top( s ); - LIST * result = L0; - VAR_EDITS * const edits = (VAR_EDITS *)( (LIST * *)stack_get( s ) + 1 ); - string buf[ 1 ]; - string_new( buf ); - result = apply_modifiers_impl( result, buf, edits, n, list_begin( value ), - list_end( value ) ); - string_free( buf ); - return result; -} - - -/* - * Parse a string of the form "1-2", "-2--1", "2-" and return the two - * subscripts. - */ - -subscript_t parse_subscript( char const * s ) -{ - subscript_t result; - result.sub1 = 0; - result.sub2 = 0; - do /* so we can use "break" */ - { - /* Allow negative subscripts. */ - if ( !isdigit( *s ) && ( *s != '-' ) ) - { - result.sub2 = 0; - break; - } - result.sub1 = atoi( s ); - - /* Skip over the first symbol, which is either a digit or dash. */ - ++s; - while ( isdigit( *s ) ) ++s; - - if ( *s == '\0' ) - { - result.sub2 = result.sub1; - break; - } - - if ( *s != '-' ) - { - result.sub2 = 0; - break; - } - - ++s; - - if ( *s == '\0' ) - { - result.sub2 = -1; - break; - } - - if ( !isdigit( *s ) && ( *s != '-' ) ) - { - result.sub2 = 0; - break; - } - - /* First, compute the index of the last element. */ - result.sub2 = atoi( s ); - while ( isdigit( *++s ) ); - - if ( *s != '\0' ) - result.sub2 = 0; - - } while ( 0 ); - return result; -} - -static LIST * apply_subscript( STACK * s ) -{ - LIST * value = stack_top( s ); - LIST * indices = stack_at( s, 1 ); - LIST * result = L0; - int length = list_length( value ); - string buf[ 1 ]; - LISTITER indices_iter = list_begin( indices ); - LISTITER const indices_end = list_end( indices ); - string_new( buf ); - for ( ; indices_iter != indices_end; indices_iter = list_next( indices_iter - ) ) - { - LISTITER iter = list_begin( value ); - LISTITER end = list_end( value ); - subscript_t const subscript = parse_subscript( object_str( list_item( - indices_iter ) ) ); - get_iters( subscript, &iter, &end, length ); - for ( ; iter != end; iter = list_next( iter ) ) - result = list_push_back( result, object_copy( list_item( iter ) ) ); - } - string_free( buf ); - return result; -} - - -/* - * Reads the LIST from first and applies subscript to it. The results are - * written to *first and *last. - */ - -static void get_iters( subscript_t const subscript, LISTITER * const first, - LISTITER * const last, int const length ) -{ - int start; - int size; - LISTITER iter; - LISTITER end; - { - - if ( subscript.sub1 < 0 ) - start = length + subscript.sub1; - else if ( subscript.sub1 > length ) - start = length; - else - start = subscript.sub1 - 1; - - size = subscript.sub2 < 0 - ? length + 1 + subscript.sub2 - start - : subscript.sub2 - start; - - /* - * HACK: When the first subscript is before the start of the list, it - * magically becomes the beginning of the list. This is inconsistent, - * but needed for backwards compatibility. - */ - if ( start < 0 ) - start = 0; - - /* The "sub2 < 0" test handles the semantic error of sub2 < sub1. */ - if ( size < 0 ) - size = 0; - - if ( start + size > length ) - size = length - start; - } - - iter = *first; - while ( start-- > 0 ) - iter = list_next( iter ); - - end = iter; - while ( size-- > 0 ) - end = list_next( end ); - - *first = iter; - *last = end; -} - -static LIST * apply_modifiers_empty( LIST * result, string * buf, - VAR_EDITS * edits, int n ) -{ - int i; - for ( i = 0; i < n; ++i ) - { - if ( edits[ i ].empty.ptr ) - { - /** FIXME: is empty.ptr always null-terminated? */ - var_edit_file( edits[ i ].empty.ptr, buf, edits + i ); - var_edit_shift( buf, 0, edits + i ); - result = list_push_back( result, object_new( buf->value ) ); - string_truncate( buf, 0 ); - } - } - return result; -} - -static LIST * apply_modifiers_non_empty( LIST * result, string * buf, - VAR_EDITS * edits, int n, LISTITER begin, LISTITER end ) -{ - int i; - LISTITER iter; - for ( i = 0; i < n; ++i ) - { - if ( edits[ i ].join.ptr ) - { - var_edit_file( object_str( list_item( begin ) ), buf, edits + i ); - var_edit_shift( buf, 0, edits + i ); - for ( iter = list_next( begin ); iter != end; iter = list_next( iter - ) ) - { - size_t size; - string_append( buf, edits[ i ].join.ptr ); - size = buf->size; - var_edit_file( object_str( list_item( iter ) ), buf, edits + i - ); - var_edit_shift( buf, size, edits + i ); - } - result = list_push_back( result, object_new( buf->value ) ); - string_truncate( buf, 0 ); - } - else - { - for ( iter = begin; iter != end; iter = list_next( iter ) ) - { - var_edit_file( object_str( list_item( iter ) ), buf, edits + i ); - var_edit_shift( buf, 0, edits + i ); - result = list_push_back( result, object_new( buf->value ) ); - string_truncate( buf, 0 ); - } - } - } - return result; -} - -static LIST * apply_modifiers_impl( LIST * result, string * buf, - VAR_EDITS * edits, int n, LISTITER iter, LISTITER end ) -{ - return iter == end - ? apply_modifiers_empty( result, buf, edits, n ) - : apply_modifiers_non_empty( result, buf, edits, n, iter, end ); -} - -static LIST * apply_subscript_and_modifiers( STACK * s, int n ) -{ - LIST * const value = stack_top( s ); - LIST * const indices = stack_at( s, 1 ); - LIST * result = L0; - VAR_EDITS * const edits = (VAR_EDITS *)((LIST * *)stack_get( s ) + 2); - int const length = list_length( value ); - string buf[ 1 ]; - LISTITER indices_iter = list_begin( indices ); - LISTITER const indices_end = list_end( indices ); - string_new( buf ); - for ( ; indices_iter != indices_end; indices_iter = list_next( indices_iter - ) ) - { - LISTITER iter = list_begin( value ); - LISTITER end = list_end( value ); - subscript_t const sub = parse_subscript( object_str( list_item( - indices_iter ) ) ); - get_iters( sub, &iter, &end, length ); - result = apply_modifiers_impl( result, buf, edits, n, iter, end ); - } - string_free( buf ); - return result; -} - - -/* - * expand() - expands a list of concatenated strings and variable refereces - * - * Takes a list of expansion items - each representing one element to be - * concatenated and each containing a list of its values. Returns a list of all - * possible values constructed by selecting a single value from each of the - * elements and concatenating them together. - * - * For example, in the following code: - * - * local a = one two three four ; - * local b = foo bar ; - * ECHO /$(a)/$(b)/$(a)/ ; - * - * When constructing the result of /$(a)/$(b)/ this function would get called - * with the following 7 expansion items: - * 1. / - * 2. one two three four - * 3. / - * 4. foo bar - * 5. / - * 6. one two three four - * 7. / - * - * And would result in a list containing 32 values: - * 1. /one/foo/one/ - * 2. /one/foo/two/ - * 3. /one/foo/three/ - * 4. /one/foo/four/ - * 5. /one/bar/one/ - * ... - * - */ - -typedef struct expansion_item -{ - /* Item's value list initialized prior to calling expand(). */ - LIST * values; - - /* Internal data initialized and used inside expand(). */ - LISTITER current; /* Currently used value. */ - int size; /* Concatenated string length prior to concatenating the - * item's current value. - */ -} expansion_item; - -static LIST * expand( expansion_item * items, int const length ) -{ - LIST * result = L0; - string buf[ 1 ]; - int size = 0; - int i; - - assert( length > 0 ); - for ( i = 0; i < length; ++i ) - { - LISTITER iter = list_begin( items[ i ].values ); - LISTITER const end = list_end( items[ i ].values ); - - /* If any of the items has no values - the result is an empty list. */ - if ( iter == end ) return L0; - - /* Set each item's 'current' to its first listed value. This indicates - * each item's next value to be used when constructing the list of all - * possible concatenated values. - */ - items[ i ].current = iter; - - /* Calculate the longest concatenated string length - to know how much - * memory we need to allocate as a buffer for holding the concatenated - * strings. - */ - { - int max = 0; - for ( ; iter != end; iter = list_next( iter ) ) - { - int const len = strlen( object_str( list_item( iter ) ) ); - if ( len > max ) max = len; - } - size += max; - } - } - - string_new( buf ); - string_reserve( buf, size ); - - i = 0; - while ( i >= 0 ) - { - for ( ; i < length; ++i ) - { - items[ i ].size = buf->size; - string_append( buf, object_str( list_item( items[ i ].current ) ) ); - } - result = list_push_back( result, object_new( buf->value ) ); - while ( --i >= 0 ) - { - if ( list_next( items[ i ].current ) != list_end( items[ i ].values - ) ) - { - items[ i ].current = list_next( items[ i ].current ); - string_truncate( buf, items[ i ].size ); - break; - } - else - items[ i ].current = list_begin( items[ i ].values ); - } - } - - string_free( buf ); - return result; -} - -static void combine_strings( STACK * s, int n, string * out ) -{ - int i; - for ( i = 0; i < n; ++i ) - { - LIST * const values = stack_pop( s ); - LISTITER iter = list_begin( values ); - LISTITER const end = list_end( values ); - if ( iter != end ) - { - string_append( out, object_str( list_item( iter ) ) ); - for ( iter = list_next( iter ); iter != end; iter = list_next( iter - ) ) - { - string_push_back( out, ' ' ); - string_append( out, object_str( list_item( iter ) ) ); - } - list_free( values ); - } - } -} - -struct dynamic_array -{ - int size; - int capacity; - void * data; -}; - -static void dynamic_array_init( struct dynamic_array * array ) -{ - array->size = 0; - array->capacity = 0; - array->data = 0; -} - -static void dynamic_array_free( struct dynamic_array * array ) -{ - BJAM_FREE( array->data ); -} - -static void dynamic_array_push_impl( struct dynamic_array * const array, - void const * const value, int const unit_size ) -{ - if ( array->capacity == 0 ) - { - array->capacity = 2; - array->data = BJAM_MALLOC( array->capacity * unit_size ); - } - else if ( array->capacity == array->size ) - { - void * new_data; - array->capacity *= 2; - new_data = BJAM_MALLOC( array->capacity * unit_size ); - memcpy( new_data, array->data, array->size * unit_size ); - BJAM_FREE( array->data ); - array->data = new_data; - } - memcpy( (char *)array->data + array->size * unit_size, value, unit_size ); - ++array->size; -} - -#define dynamic_array_push( array, value ) (dynamic_array_push_impl(array, &value, sizeof(value))) -#define dynamic_array_at( type, array, idx ) (((type *)(array)->data)[idx]) - - -/* - * struct compiler - */ - -struct label_info -{ - int absolute_position; - struct dynamic_array uses[ 1 ]; -}; - -struct stored_rule -{ - OBJECT * name; - PARSE * parse; - int num_arguments; - struct arg_list * arguments; - int local; -}; - -typedef struct compiler -{ - struct dynamic_array code[ 1 ]; - struct dynamic_array constants[ 1 ]; - struct dynamic_array labels[ 1 ]; - struct dynamic_array rules[ 1 ]; - struct dynamic_array actions[ 1 ]; -} compiler; - -static void compiler_init( compiler * c ) -{ - dynamic_array_init( c->code ); - dynamic_array_init( c->constants ); - dynamic_array_init( c->labels ); - dynamic_array_init( c->rules ); - dynamic_array_init( c->actions ); -} - -static void compiler_free( compiler * c ) -{ - int i; - dynamic_array_free( c->actions ); - dynamic_array_free( c->rules ); - for ( i = 0; i < c->labels->size; ++i ) - dynamic_array_free( dynamic_array_at( struct label_info, c->labels, i - ).uses ); - dynamic_array_free( c->labels ); - dynamic_array_free( c->constants ); - dynamic_array_free( c->code ); -} - -static void compile_emit_instruction( compiler * c, instruction instr ) -{ - dynamic_array_push( c->code, instr ); -} - -static int compile_new_label( compiler * c ) -{ - int result = c->labels->size; - struct label_info info; - info.absolute_position = -1; - dynamic_array_init( info.uses ); - dynamic_array_push( c->labels, info ); - return result; -} - -static void compile_set_label( compiler * c, int label ) -{ - struct label_info * const l = &dynamic_array_at( struct label_info, - c->labels, label ); - int const pos = c->code->size; - int i; - assert( l->absolute_position == -1 ); - l->absolute_position = pos; - for ( i = 0; i < l->uses->size; ++i ) - { - int id = dynamic_array_at( int, l->uses, i ); - int offset = (int)( pos - id - 1 ); - dynamic_array_at( instruction, c->code, id ).arg = offset; - } -} - -static void compile_emit( compiler * c, unsigned int op_code, int arg ) -{ - instruction instr; - instr.op_code = op_code; - instr.arg = arg; - compile_emit_instruction( c, instr ); -} - -static void compile_emit_branch( compiler * c, unsigned int op_code, int label ) -{ - struct label_info * const l = &dynamic_array_at( struct label_info, - c->labels, label ); - int const pos = c->code->size; - instruction instr; - instr.op_code = op_code; - if ( l->absolute_position == -1 ) - { - instr.arg = 0; - dynamic_array_push( l->uses, pos ); - } - else - instr.arg = (int)( l->absolute_position - pos - 1 ); - compile_emit_instruction( c, instr ); -} - -static int compile_emit_constant( compiler * c, OBJECT * value ) -{ - OBJECT * copy = object_copy( value ); - dynamic_array_push( c->constants, copy ); - return c->constants->size - 1; -} - -static int compile_emit_rule( compiler * c, OBJECT * name, PARSE * parse, - int num_arguments, struct arg_list * arguments, int local ) -{ - struct stored_rule rule; - rule.name = object_copy( name ); - rule.parse = parse; - rule.num_arguments = num_arguments; - rule.arguments = arguments; - rule.local = local; - dynamic_array_push( c->rules, rule ); - return (int)( c->rules->size - 1 ); -} - -static int compile_emit_actions( compiler * c, PARSE * parse ) -{ - SUBACTION a; - a.name = object_copy( parse->string ); - a.command = function_compile_actions( object_str( parse->string1 ), - parse->file, parse->line ); - a.flags = parse->num; - dynamic_array_push( c->actions, a ); - return (int)( c->actions->size - 1 ); -} - -static JAM_FUNCTION * compile_to_function( compiler * c ) -{ - JAM_FUNCTION * const result = BJAM_MALLOC( sizeof( JAM_FUNCTION ) ); - int i; - result->base.type = FUNCTION_JAM; - result->base.reference_count = 1; - result->base.formal_arguments = 0; - result->base.num_formal_arguments = 0; - - result->base.rulename = 0; - - result->code_size = c->code->size; - result->code = BJAM_MALLOC( c->code->size * sizeof( instruction ) ); - memcpy( result->code, c->code->data, c->code->size * sizeof( instruction ) ); - - result->constants = BJAM_MALLOC( c->constants->size * sizeof( OBJECT * ) ); - memcpy( result->constants, c->constants->data, c->constants->size * sizeof( - OBJECT * ) ); - result->num_constants = c->constants->size; - - result->num_subfunctions = c->rules->size; - result->functions = BJAM_MALLOC( c->rules->size * sizeof( SUBFUNCTION ) ); - for ( i = 0; i < c->rules->size; ++i ) - { - struct stored_rule * const rule = &dynamic_array_at( struct stored_rule, - c->rules, i ); - result->functions[ i ].name = rule->name; - result->functions[ i ].code = function_compile( rule->parse ); - result->functions[ i ].code->num_formal_arguments = rule->num_arguments; - result->functions[ i ].code->formal_arguments = rule->arguments; - result->functions[ i ].local = rule->local; - } - - result->actions = BJAM_MALLOC( c->actions->size * sizeof( SUBACTION ) ); - memcpy( result->actions, c->actions->data, c->actions->size * sizeof( - SUBACTION ) ); - result->num_subactions = c->actions->size; - - result->generic = 0; - - result->file = 0; - result->line = -1; - - return result; -} - - -/* - * Parsing of variable expansions - */ - -typedef struct VAR_PARSE_GROUP -{ - struct dynamic_array elems[ 1 ]; -} VAR_PARSE_GROUP; - -typedef struct VAR_PARSE_ACTIONS -{ - struct dynamic_array elems[ 1 ]; -} VAR_PARSE_ACTIONS; - -#define VAR_PARSE_TYPE_VAR 0 -#define VAR_PARSE_TYPE_STRING 1 -#define VAR_PARSE_TYPE_FILE 2 - -typedef struct _var_parse -{ - int type; /* string, variable or file */ -} VAR_PARSE; - -typedef struct -{ - VAR_PARSE base; - VAR_PARSE_GROUP * name; - VAR_PARSE_GROUP * subscript; - struct dynamic_array modifiers[ 1 ]; -} VAR_PARSE_VAR; - -typedef struct -{ - VAR_PARSE base; - OBJECT * s; -} VAR_PARSE_STRING; - -typedef struct -{ - VAR_PARSE base; - struct dynamic_array filename[ 1 ]; - struct dynamic_array contents[ 1 ]; -} VAR_PARSE_FILE; - -static void var_parse_free( VAR_PARSE * ); - - -/* - * VAR_PARSE_GROUP - */ - -static VAR_PARSE_GROUP * var_parse_group_new() -{ - VAR_PARSE_GROUP * const result = BJAM_MALLOC( sizeof( VAR_PARSE_GROUP ) ); - dynamic_array_init( result->elems ); - return result; -} - -static void var_parse_group_free( VAR_PARSE_GROUP * group ) -{ - int i; - for ( i = 0; i < group->elems->size; ++i ) - var_parse_free( dynamic_array_at( VAR_PARSE *, group->elems, i ) ); - dynamic_array_free( group->elems ); - BJAM_FREE( group ); -} - -static void var_parse_group_add( VAR_PARSE_GROUP * group, VAR_PARSE * elem ) -{ - dynamic_array_push( group->elems, elem ); -} - -static void var_parse_group_maybe_add_constant( VAR_PARSE_GROUP * group, - char const * start, char const * end ) -{ - if ( start != end ) - { - string buf[ 1 ]; - VAR_PARSE_STRING * const value = (VAR_PARSE_STRING *)BJAM_MALLOC( - sizeof(VAR_PARSE_STRING) ); - value->base.type = VAR_PARSE_TYPE_STRING; - string_new( buf ); - string_append_range( buf, start, end ); - value->s = object_new( buf->value ); - string_free( buf ); - var_parse_group_add( group, (VAR_PARSE *)value ); - } -} - -VAR_PARSE_STRING * var_parse_group_as_literal( VAR_PARSE_GROUP * group ) -{ - if ( group->elems->size == 1 ) - { - VAR_PARSE * result = dynamic_array_at( VAR_PARSE *, group->elems, 0 ); - if ( result->type == VAR_PARSE_TYPE_STRING ) - return (VAR_PARSE_STRING *)result; - } - return 0; -} - - -/* - * VAR_PARSE_ACTIONS - */ - -static VAR_PARSE_ACTIONS * var_parse_actions_new() -{ - VAR_PARSE_ACTIONS * const result = (VAR_PARSE_ACTIONS *)BJAM_MALLOC( - sizeof(VAR_PARSE_ACTIONS) ); - dynamic_array_init( result->elems ); - return result; -} - -static void var_parse_actions_free( VAR_PARSE_ACTIONS * actions ) -{ - int i; - for ( i = 0; i < actions->elems->size; ++i ) - var_parse_group_free( dynamic_array_at( VAR_PARSE_GROUP *, - actions->elems, i ) ); - dynamic_array_free( actions->elems ); - BJAM_FREE( actions ); -} - - -/* - * VAR_PARSE_VAR - */ - -static VAR_PARSE_VAR * var_parse_var_new() -{ - VAR_PARSE_VAR * result = BJAM_MALLOC( sizeof( VAR_PARSE_VAR ) ); - result->base.type = VAR_PARSE_TYPE_VAR; - result->name = var_parse_group_new(); - result->subscript = 0; - dynamic_array_init( result->modifiers ); - return result; -} - -static void var_parse_var_free( VAR_PARSE_VAR * var ) -{ - int i; - var_parse_group_free( var->name ); - if ( var->subscript ) - var_parse_group_free( var->subscript ); - for ( i = 0; i < var->modifiers->size; ++i ) - var_parse_group_free( dynamic_array_at( VAR_PARSE_GROUP *, - var->modifiers, i ) ); - dynamic_array_free( var->modifiers ); - BJAM_FREE( var ); -} - -static VAR_PARSE_GROUP * var_parse_var_new_modifier( VAR_PARSE_VAR * var ) -{ - VAR_PARSE_GROUP * result = var_parse_group_new(); - dynamic_array_push( var->modifiers, result ); - return result; -} - - -/* - * VAR_PARSE_STRING - */ - -static void var_parse_string_free( VAR_PARSE_STRING * string ) -{ - object_free( string->s ); - BJAM_FREE( string ); -} - - -/* - * VAR_PARSE_FILE - */ - -static VAR_PARSE_FILE * var_parse_file_new( void ) -{ - VAR_PARSE_FILE * const result = (VAR_PARSE_FILE *)BJAM_MALLOC( sizeof( - VAR_PARSE_FILE ) ); - result->base.type = VAR_PARSE_TYPE_FILE; - dynamic_array_init( result->filename ); - dynamic_array_init( result->contents ); - return result; -} - -static void var_parse_file_free( VAR_PARSE_FILE * file ) -{ - int i; - for ( i = 0; i < file->filename->size; ++i ) - var_parse_group_free( dynamic_array_at( VAR_PARSE_GROUP *, - file->filename, i ) ); - dynamic_array_free( file->filename ); - for ( i = 0; i < file->contents->size; ++i ) - var_parse_group_free( dynamic_array_at( VAR_PARSE_GROUP *, - file->contents, i ) ); - dynamic_array_free( file->contents ); - BJAM_FREE( file ); -} - - -/* - * VAR_PARSE - */ - -static void var_parse_free( VAR_PARSE * parse ) -{ - switch ( parse->type ) - { - case VAR_PARSE_TYPE_VAR: - var_parse_var_free( (VAR_PARSE_VAR *)parse ); - break; - - case VAR_PARSE_TYPE_STRING: - var_parse_string_free( (VAR_PARSE_STRING *)parse ); - break; - - case VAR_PARSE_TYPE_FILE: - var_parse_file_free( (VAR_PARSE_FILE *)parse ); - break; - - default: - assert( !"Invalid type" ); - } -} - - -/* - * Compile VAR_PARSE - */ - -static void var_parse_group_compile( VAR_PARSE_GROUP const * parse, - compiler * c ); - -static void var_parse_var_compile( VAR_PARSE_VAR const * parse, compiler * c ) -{ - int expand_name = 0; - int is_get_grist = 0; - int has_modifiers = 0; - /* Special case common modifiers */ - if ( parse->modifiers->size == 1 ) - { - VAR_PARSE_GROUP * mod = dynamic_array_at( VAR_PARSE_GROUP *, parse->modifiers, 0 ); - if ( mod->elems->size == 1 ) - { - VAR_PARSE * mod1 = dynamic_array_at( VAR_PARSE *, mod->elems, 0 ); - if ( mod1->type == VAR_PARSE_TYPE_STRING ) - { - OBJECT * s = ( (VAR_PARSE_STRING *)mod1 )->s; - if ( ! strcmp ( object_str( s ), "G" ) ) - { - is_get_grist = 1; - } - } - } - } - /* If there are modifiers, emit them in reverse order. */ - if ( parse->modifiers->size > 0 && !is_get_grist ) - { - int i; - has_modifiers = 1; - for ( i = 0; i < parse->modifiers->size; ++i ) - var_parse_group_compile( dynamic_array_at( VAR_PARSE_GROUP *, - parse->modifiers, parse->modifiers->size - i - 1 ), c ); - } - - /* If there is a subscript, emit it. */ - if ( parse->subscript ) - var_parse_group_compile( parse->subscript, c ); - - /* If the variable name is empty, look it up. */ - if ( parse->name->elems->size == 0 ) - compile_emit( c, INSTR_PUSH_VAR, compile_emit_constant( c, - constant_empty ) ); - /* If the variable name does not need to be expanded, look it up. */ - else if ( parse->name->elems->size == 1 && dynamic_array_at( VAR_PARSE *, - parse->name->elems, 0 )->type == VAR_PARSE_TYPE_STRING ) - { - OBJECT * const name = ( (VAR_PARSE_STRING *)dynamic_array_at( - VAR_PARSE *, parse->name->elems, 0 ) )->s; - int const idx = get_argument_index( object_str( name ) ); - if ( idx != -1 ) - compile_emit( c, INSTR_PUSH_ARG, idx ); - else - compile_emit( c, INSTR_PUSH_VAR, compile_emit_constant( c, name ) ); - } - /* Otherwise, push the var names and use the group instruction. */ - else - { - var_parse_group_compile( parse->name, c ); - expand_name = 1; - } - - /** Select the instruction for expanding the variable. */ - if ( !has_modifiers && !parse->subscript && !expand_name ) - ; - else if ( !has_modifiers && !parse->subscript && expand_name ) - compile_emit( c, INSTR_PUSH_GROUP, 0 ); - else if ( !has_modifiers && parse->subscript && !expand_name ) - compile_emit( c, INSTR_APPLY_INDEX, 0 ); - else if ( !has_modifiers && parse->subscript && expand_name ) - compile_emit( c, INSTR_APPLY_INDEX_GROUP, 0 ); - else if ( has_modifiers && !parse->subscript && !expand_name ) - compile_emit( c, INSTR_APPLY_MODIFIERS, parse->modifiers->size ); - else if ( has_modifiers && !parse->subscript && expand_name ) - compile_emit( c, INSTR_APPLY_MODIFIERS_GROUP, parse->modifiers->size ); - else if ( has_modifiers && parse->subscript && !expand_name ) - compile_emit( c, INSTR_APPLY_INDEX_MODIFIERS, parse->modifiers->size ); - else if ( has_modifiers && parse->subscript && expand_name ) - compile_emit( c, INSTR_APPLY_INDEX_MODIFIERS_GROUP, - parse->modifiers->size ); - - /* Now apply any special modifiers */ - if ( is_get_grist ) - { - compile_emit( c, INSTR_GET_GRIST, 0 ); - } -} - -static void var_parse_string_compile( VAR_PARSE_STRING const * parse, - compiler * c ) -{ - compile_emit( c, INSTR_PUSH_CONSTANT, compile_emit_constant( c, parse->s ) - ); -} - -static void var_parse_file_compile( VAR_PARSE_FILE const * parse, compiler * c ) -{ - int i; - for ( i = 0; i < parse->filename->size; ++i ) - var_parse_group_compile( dynamic_array_at( VAR_PARSE_GROUP *, - parse->filename, parse->filename->size - i - 1 ), c ); - compile_emit( c, INSTR_APPEND_STRINGS, parse->filename->size ); - for ( i = 0; i < parse->contents->size; ++i ) - var_parse_group_compile( dynamic_array_at( VAR_PARSE_GROUP *, - parse->contents, parse->contents->size - i - 1 ), c ); - compile_emit( c, INSTR_WRITE_FILE, parse->contents->size ); -} - -static void var_parse_compile( VAR_PARSE const * parse, compiler * c ) -{ - switch ( parse->type ) - { - case VAR_PARSE_TYPE_VAR: - var_parse_var_compile( (VAR_PARSE_VAR const *)parse, c ); - break; - - case VAR_PARSE_TYPE_STRING: - var_parse_string_compile( (VAR_PARSE_STRING const *)parse, c ); - break; - - case VAR_PARSE_TYPE_FILE: - var_parse_file_compile( (VAR_PARSE_FILE const *)parse, c ); - break; - - default: - assert( !"Unknown var parse type." ); - } -} - -static void var_parse_group_compile( VAR_PARSE_GROUP const * parse, compiler * c - ) -{ - /* Emit the elements in reverse order. */ - int i; - for ( i = 0; i < parse->elems->size; ++i ) - var_parse_compile( dynamic_array_at( VAR_PARSE *, parse->elems, - parse->elems->size - i - 1 ), c ); - /* If there are no elements, emit an empty string. */ - if ( parse->elems->size == 0 ) - compile_emit( c, INSTR_PUSH_CONSTANT, compile_emit_constant( c, - constant_empty ) ); - /* If there is more than one element, combine them. */ - if ( parse->elems->size > 1 ) - compile_emit( c, INSTR_COMBINE_STRINGS, parse->elems->size ); -} - -static void var_parse_actions_compile( VAR_PARSE_ACTIONS const * actions, - compiler * c ) -{ - int i; - for ( i = 0; i < actions->elems->size; ++i ) - var_parse_group_compile( dynamic_array_at( VAR_PARSE_GROUP *, - actions->elems, actions->elems->size - i - 1 ), c ); - compile_emit( c, INSTR_OUTPUT_STRINGS, actions->elems->size ); -} - - -/* - * Parse VAR_PARSE_VAR - */ - -static VAR_PARSE * parse_at_file( char const * start, char const * mid, - char const * end ); -static VAR_PARSE * parse_variable( char const * * string ); -static int try_parse_variable( char const * * s_, char const * * string, - VAR_PARSE_GROUP * out ); -static void balance_parentheses( char const * * s_, char const * * string, - VAR_PARSE_GROUP * out ); -static void parse_var_string( char const * first, char const * last, - struct dynamic_array * out ); - - -/* - * Parses a string that can contain variables to expand. - */ - -static VAR_PARSE_GROUP * parse_expansion( char const * * string ) -{ - VAR_PARSE_GROUP * result = var_parse_group_new(); - char const * s = *string; - for ( ; ; ) - { - if ( try_parse_variable( &s, string, result ) ) {} - else if ( s[ 0 ] == '\0' ) - { - var_parse_group_maybe_add_constant( result, *string, s ); - return result; - } - else - ++s; - } -} - -static VAR_PARSE_ACTIONS * parse_actions( char const * string ) -{ - VAR_PARSE_ACTIONS * const result = var_parse_actions_new(); - parse_var_string( string, string + strlen( string ), result->elems ); - return result; -} - -/* - * Checks whether the string a *s_ starts with a variable expansion "$(". - * *string should point to the first unemitted character before *s. If *s_ - * starts with variable expansion, appends elements to out up to the closing - * ")", and adjusts *s_ and *string to point to next character. Returns 1 if s_ - * starts with a variable, 0 otherwise. - */ - -static int try_parse_variable( char const * * s_, char const * * string, - VAR_PARSE_GROUP * out ) -{ - char const * s = *s_; - if ( s[ 0 ] == '$' && s[ 1 ] == '(' ) - { - var_parse_group_maybe_add_constant( out, *string, s ); - s += 2; - var_parse_group_add( out, parse_variable( &s ) ); - *string = s; - *s_ = s; - return 1; - } - if ( s[ 0 ] == '@' && s[ 1 ] == '(' ) - { - int depth = 1; - char const * ine; - char const * split = 0; - var_parse_group_maybe_add_constant( out, *string, s ); - s += 2; - ine = s; - - /* 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 || depth ) - return 0; - - var_parse_group_add( out, parse_at_file( s, split, ine - 1 ) ); - *string = ine; - *s_ = ine; - return 1; - } - return 0; -} - - -static char const * current_file = ""; -static int current_line; - -static void parse_error( char const * message ) -{ - printf( "%s:%d: %s\n", current_file, current_line, message ); -} - - -/* - * Parses a single variable up to the closing ")" and adjusts *string to point - * to the next character. *string should point to the character immediately - * after the initial "$(". - */ - -static VAR_PARSE * parse_variable( char const * * string ) -{ - VAR_PARSE_VAR * const result = var_parse_var_new(); - VAR_PARSE_GROUP * const name = result->name; - char const * s = *string; - for ( ; ; ) - { - if ( try_parse_variable( &s, string, name ) ) {} - else if ( s[ 0 ] == ':' ) - { - VAR_PARSE_GROUP * mod; - var_parse_group_maybe_add_constant( name, *string, s ); - ++s; - *string = s; - mod = var_parse_var_new_modifier( result ); - for ( ; ; ) - { - if ( try_parse_variable( &s, string, mod ) ) {} - else if ( s[ 0 ] == ')' ) - { - var_parse_group_maybe_add_constant( mod, *string, s ); - *string = ++s; - return (VAR_PARSE *)result; - } - else if ( s[ 0 ] == '(' ) - { - ++s; - balance_parentheses( &s, string, mod ); - } - else if ( s[ 0 ] == ':' ) - { - var_parse_group_maybe_add_constant( mod, *string, s ); - *string = ++s; - mod = var_parse_var_new_modifier( result ); - } - else if ( s[ 0 ] == '[' ) - { - parse_error("unexpected subscript"); - ++s; - } - else if ( s[ 0 ] == '\0' ) - { - parse_error( "unbalanced parentheses" ); - var_parse_group_maybe_add_constant( mod, *string, s ); - *string = s; - return (VAR_PARSE *)result; - } - else - ++s; - } - } - else if ( s[ 0 ] == '[' ) - { - VAR_PARSE_GROUP * subscript = var_parse_group_new(); - result->subscript = subscript; - var_parse_group_maybe_add_constant( name, *string, s ); - *string = ++s; - for ( ; ; ) - { - if ( try_parse_variable( &s, string, subscript ) ) {} - else if ( s[ 0 ] == ']' ) - { - var_parse_group_maybe_add_constant( subscript, *string, s ); - *string = ++s; - if ( s[ 0 ] != ')' && s[ 0 ] != ':' && s[ 0 ] != '\0' ) - parse_error( "unexpected text following []" ); - break; - } - else if ( isdigit( s[ 0 ] ) || s[ 0 ] == '-' ) - { - ++s; - } - else if ( s[ 0 ] == '\0' ) - { - parse_error( "malformed subscript" ); - break; - } - else - { - parse_error( "malformed subscript" ); - ++s; - } - } - } - else if ( s[ 0 ] == ')' ) - { - var_parse_group_maybe_add_constant( name, *string, s ); - *string = ++s; - return (VAR_PARSE *)result; - } - else if ( s[ 0 ] == '(' ) - { - ++s; - balance_parentheses( &s, string, name ); - } - else if ( s[ 0 ] == '\0' ) - { - parse_error( "unbalanced parentheses" ); - var_parse_group_maybe_add_constant( name, *string, s ); - *string = s; - return (VAR_PARSE *)result; - } - else - ++s; - } -} - -static void parse_var_string( char const * first, char const * last, - struct dynamic_array * out ) -{ - char const * saved = first; - while ( first != last ) - { - /* Handle whitespace. */ - while ( first != last && isspace( *first ) ) ++first; - if ( saved != first ) - { - VAR_PARSE_GROUP * const group = var_parse_group_new(); - var_parse_group_maybe_add_constant( group, saved, first ); - saved = first; - dynamic_array_push( out, group ); - } - if ( first == last ) break; - - /* Handle non-whitespace */ - { - VAR_PARSE_GROUP * group = var_parse_group_new(); - for ( ; ; ) - { - if ( first == last || isspace( *first ) ) - { - var_parse_group_maybe_add_constant( group, saved, first ); - saved = first; - break; - } - if ( try_parse_variable( &first, &saved, group ) ) - assert( first <= last ); - else - ++first; - } - dynamic_array_push( out, group ); - } - } -} - -/* - * start should point to the character immediately following the opening "@(", - * mid should point to the ":E=", and end should point to the closing ")". - */ - -static VAR_PARSE * parse_at_file( char const * start, char const * mid, - char const * end ) -{ - VAR_PARSE_FILE * result = var_parse_file_new(); - parse_var_string( start, mid, result->filename ); - parse_var_string( mid + 3, end, result->contents ); - return (VAR_PARSE *)result; -} - -/* - * Given that *s_ points to the character after a "(", parses up to the matching - * ")". *string should point to the first unemitted character before *s_. - * - * When the function returns, *s_ will point to the character after the ")", and - * *string will point to the first unemitted character before *s_. The range - * from *string to *s_ does not contain any variables that need to be expanded. - */ - -void balance_parentheses( char const * * s_, char const * * string, - VAR_PARSE_GROUP * out) -{ - int depth = 1; - char const * s = *s_; - for ( ; ; ) - { - if ( try_parse_variable( &s, string, out ) ) { } - else if ( s[ 0 ] == ':' || s[ 0 ] == '[' ) - { - parse_error( "unbalanced parentheses" ); - ++s; - } - else if ( s[ 0 ] == '\0' ) - { - parse_error( "unbalanced parentheses" ); - break; - } - else if ( s[ 0 ] == ')' ) - { - ++s; - if ( --depth == 0 ) break; - } - else if ( s[ 0 ] == '(' ) - { - ++depth; - ++s; - } - else - ++s; - } - *s_ = s; -} - - -/* - * Main compile. - */ - -#define RESULT_STACK 0 -#define RESULT_RETURN 1 -#define RESULT_NONE 2 - -static void compile_parse( PARSE * parse, compiler * c, int result_location ); -static struct arg_list * arg_list_compile( PARSE * parse, int * num_arguments ); - -static void compile_condition( PARSE * parse, compiler * c, int branch_true, int label ) -{ - assert( parse->type == PARSE_EVAL ); - switch ( parse->num ) - { - case EXPR_EXISTS: - compile_parse( parse->left, c, RESULT_STACK ); - if ( branch_true ) - compile_emit_branch( c, INSTR_JUMP_NOT_EMPTY, label ); - else - compile_emit_branch( c, INSTR_JUMP_EMPTY, label ); - break; - - case EXPR_EQUALS: - compile_parse( parse->left, c, RESULT_STACK ); - compile_parse( parse->right, c, RESULT_STACK ); - if ( branch_true ) - compile_emit_branch( c, INSTR_JUMP_EQ, label ); - else - compile_emit_branch( c, INSTR_JUMP_NE, label ); - break; - - case EXPR_NOTEQ: - compile_parse( parse->left, c, RESULT_STACK ); - compile_parse( parse->right, c, RESULT_STACK ); - if ( branch_true ) - compile_emit_branch( c, INSTR_JUMP_NE, label ); - else - compile_emit_branch( c, INSTR_JUMP_EQ, label ); - break; - - case EXPR_LESS: - compile_parse( parse->left, c, RESULT_STACK ); - compile_parse( parse->right, c, RESULT_STACK ); - if ( branch_true ) - compile_emit_branch( c, INSTR_JUMP_LT, label ); - else - compile_emit_branch( c, INSTR_JUMP_GE, label ); - break; - - case EXPR_LESSEQ: - compile_parse( parse->left, c, RESULT_STACK ); - compile_parse( parse->right, c, RESULT_STACK ); - if ( branch_true ) - compile_emit_branch( c, INSTR_JUMP_LE, label ); - else - compile_emit_branch( c, INSTR_JUMP_GT, label ); - break; - - case EXPR_MORE: - compile_parse( parse->left, c, RESULT_STACK ); - compile_parse( parse->right, c, RESULT_STACK ); - if ( branch_true ) - compile_emit_branch( c, INSTR_JUMP_GT, label ); - else - compile_emit_branch( c, INSTR_JUMP_LE, label ); - break; - - case EXPR_MOREEQ: - compile_parse( parse->left, c, RESULT_STACK ); - compile_parse( parse->right, c, RESULT_STACK ); - if ( branch_true ) - compile_emit_branch( c, INSTR_JUMP_GE, label ); - else - compile_emit_branch( c, INSTR_JUMP_LT, label ); - break; - - case EXPR_IN: - compile_parse( parse->left, c, RESULT_STACK ); - compile_parse( parse->right, c, RESULT_STACK ); - if ( branch_true ) - compile_emit_branch( c, INSTR_JUMP_IN, label ); - else - compile_emit_branch( c, INSTR_JUMP_NOT_IN, label ); - break; - - case EXPR_AND: - if ( branch_true ) - { - int f = compile_new_label( c ); - compile_condition( parse->left, c, 0, f ); - compile_condition( parse->right, c, 1, label ); - compile_set_label( c, f ); - } - else - { - compile_condition( parse->left, c, 0, label ); - compile_condition( parse->right, c, 0, label ); - } - break; - - case EXPR_OR: - if ( branch_true ) - { - compile_condition( parse->left, c, 1, label ); - compile_condition( parse->right, c, 1, label ); - } - else - { - int t = compile_new_label( c ); - compile_condition( parse->left, c, 1, t ); - compile_condition( parse->right, c, 0, label ); - compile_set_label( c, t ); - } - break; - - case EXPR_NOT: - compile_condition( parse->left, c, !branch_true, label ); - break; - } -} - -static void adjust_result( compiler * c, int actual_location, - int desired_location ) -{ - if ( actual_location == desired_location ) - ; - else if ( actual_location == RESULT_STACK && desired_location == RESULT_RETURN ) - compile_emit( c, INSTR_SET_RESULT, 0 ); - else if ( actual_location == RESULT_STACK && desired_location == RESULT_NONE ) - compile_emit( c, INSTR_POP, 0 ); - else if ( actual_location == RESULT_RETURN && desired_location == RESULT_STACK ) - compile_emit( c, INSTR_PUSH_RESULT, 0 ); - else if ( actual_location == RESULT_RETURN && desired_location == RESULT_NONE ) - ; - else if ( actual_location == RESULT_NONE && desired_location == RESULT_STACK ) - compile_emit( c, INSTR_PUSH_EMPTY, 0 ); - else if ( actual_location == RESULT_NONE && desired_location == RESULT_RETURN ) - { - compile_emit( c, INSTR_PUSH_EMPTY, 0 ); - compile_emit( c, INSTR_SET_RESULT, 0 ); - } - else - assert( !"invalid result location" ); -} - -static char const * parse_type( PARSE * parse ) -{ - switch ( parse->type ) - { - case PARSE_APPEND: return "append"; - case PARSE_EVAL: return "eval"; - case PARSE_RULES: return "rules"; - default: return "unknown"; - } -} - -static void compile_append_chain( PARSE * parse, compiler * c ) -{ - assert( parse->type == PARSE_APPEND ); - if ( parse->left->type == PARSE_NULL ) - compile_parse( parse->right, c, RESULT_STACK ); - else - { - if ( parse->left->type == PARSE_APPEND ) - compile_append_chain( parse->left, c ); - else - compile_parse( parse->left, c, RESULT_STACK ); - compile_parse( parse->right, c, RESULT_STACK ); - compile_emit( c, INSTR_PUSH_APPEND, 0 ); - } -} - -static void compile_parse( PARSE * parse, compiler * c, int result_location ) -{ - if ( parse->type == PARSE_APPEND ) - { - compile_append_chain( parse, c ); - adjust_result( c, RESULT_STACK, result_location ); - } - else if ( parse->type == PARSE_EVAL ) - { - /* FIXME: This is only needed because of the bizarre parsing of - * conditions. - */ - if ( parse->num == EXPR_EXISTS ) - compile_parse( parse->left, c, result_location ); - else - { - int f = compile_new_label( c ); - int end = compile_new_label( c ); - - printf( "%s:%d: Conditional used as list (check operator " - "precedence).\n", object_str( parse->file ), parse->line ); - - /* Emit the condition */ - compile_condition( parse, c, 0, f ); - compile_emit( c, INSTR_PUSH_CONSTANT, compile_emit_constant( c, - constant_true ) ); - compile_emit_branch( c, INSTR_JUMP, end ); - compile_set_label( c, f ); - compile_emit( c, INSTR_PUSH_EMPTY, 0 ); - compile_set_label( c, end ); - adjust_result( c, RESULT_STACK, result_location ); - } - } - else if ( parse->type == PARSE_FOREACH ) - { - int var = compile_emit_constant( c, parse->string ); - int top = compile_new_label( c ); - int end = compile_new_label( c ); - - /* - * Evaluate the list. - */ - compile_parse( parse->left, c, RESULT_STACK ); - - /* Localize the loop variable */ - if ( parse->num ) - { - compile_emit( c, INSTR_PUSH_EMPTY, 0 ); - compile_emit( c, INSTR_PUSH_LOCAL, var ); - compile_emit( c, INSTR_SWAP, 1 ); - } - - compile_emit( c, INSTR_FOR_INIT, 0 ); - compile_set_label( c, top ); - compile_emit_branch( c, INSTR_FOR_LOOP, end ); - compile_emit( c, INSTR_SET, var ); - - /* Run the loop body */ - compile_parse( parse->right, c, RESULT_NONE ); - - compile_emit_branch( c, INSTR_JUMP, top ); - compile_set_label( c, end ); - - if ( parse->num ) - compile_emit( c, INSTR_POP_LOCAL, var ); - - adjust_result( c, RESULT_NONE, result_location); - } - else if ( parse->type == PARSE_IF ) - { - int f = compile_new_label( c ); - /* Emit the condition */ - compile_condition( parse->left, c, 0, f ); - /* Emit the if block */ - compile_parse( parse->right, c, result_location ); - if ( parse->third->type != PARSE_NULL || result_location != RESULT_NONE ) - { - /* Emit the else block */ - int end = compile_new_label( c ); - compile_emit_branch( c, INSTR_JUMP, end ); - compile_set_label( c, f ); - compile_parse( parse->third, c, result_location ); - compile_set_label( c, end ); - } - else - compile_set_label( c, f ); - - } - else if ( parse->type == PARSE_WHILE ) - { - int nested_result = result_location == RESULT_NONE - ? RESULT_NONE - : RESULT_RETURN; - int test = compile_new_label( c ); - int top = compile_new_label( c ); - /* Make sure that we return an empty list if the loop runs zero times. - */ - adjust_result( c, RESULT_NONE, nested_result ); - /* Jump to the loop test. */ - compile_emit_branch( c, INSTR_JUMP, test ); - compile_set_label( c, top ); - /* Emit the loop body. */ - compile_parse( parse->right, c, nested_result ); - /* Emit the condition. */ - compile_set_label( c, test ); - compile_condition( parse->left, c, 1, top ); - - adjust_result( c, nested_result, result_location ); - } - else if ( parse->type == PARSE_INCLUDE ) - { - compile_parse( parse->left, c, RESULT_STACK ); - compile_emit( c, INSTR_INCLUDE, 0 ); - compile_emit( c, INSTR_BIND_MODULE_VARIABLES, 0 ); - adjust_result( c, RESULT_NONE, result_location ); - } - else if ( parse->type == PARSE_MODULE ) - { - int const nested_result = result_location == RESULT_NONE - ? RESULT_NONE - : RESULT_RETURN; - compile_parse( parse->left, c, RESULT_STACK ); - compile_emit( c, INSTR_PUSH_MODULE, 0 ); - compile_parse( parse->right, c, nested_result ); - compile_emit( c, INSTR_POP_MODULE, 0 ); - adjust_result( c, nested_result, result_location ); - } - else if ( parse->type == PARSE_CLASS ) - { - /* Evaluate the class name. */ - compile_parse( parse->left->right, c, RESULT_STACK ); - /* Evaluate the base classes. */ - if ( parse->left->left ) - compile_parse( parse->left->left->right, c, RESULT_STACK ); - else - compile_emit( c, INSTR_PUSH_EMPTY, 0 ); - compile_emit( c, INSTR_CLASS, 0 ); - compile_parse( parse->right, c, RESULT_NONE ); - compile_emit( c, INSTR_BIND_MODULE_VARIABLES, 0 ); - compile_emit( c, INSTR_POP_MODULE, 0 ); - - adjust_result( c, RESULT_NONE, result_location ); - } - else if ( parse->type == PARSE_LIST ) - { - OBJECT * const o = parse->string; - char const * s = object_str( o ); - VAR_PARSE_GROUP * group; - current_file = object_str( parse->file ); - current_line = parse->line; - group = parse_expansion( &s ); - var_parse_group_compile( group, c ); - var_parse_group_free( group ); - adjust_result( c, RESULT_STACK, result_location ); - } - else if ( parse->type == PARSE_LOCAL ) - { - int nested_result = result_location == RESULT_NONE - ? RESULT_NONE - : RESULT_RETURN; - /* This should be left recursive group of compile_appends. */ - PARSE * vars = parse->left; - - /* Special case an empty list of vars */ - if ( vars->type == PARSE_NULL ) - { - compile_parse( parse->right, c, RESULT_NONE ); - compile_parse( parse->third, c, result_location ); - nested_result = result_location; - } - /* Check whether there is exactly one variable with a constant name. */ - else if ( vars->left->type == PARSE_NULL && - vars->right->type == PARSE_LIST ) - { - char const * s = object_str( vars->right->string ); - VAR_PARSE_GROUP * group; - current_file = object_str( parse->file ); - current_line = parse->line; - group = parse_expansion( &s ); - if ( group->elems->size == 1 && dynamic_array_at( VAR_PARSE *, - group->elems, 0 )->type == VAR_PARSE_TYPE_STRING ) - { - int const name = compile_emit_constant( c, ( - (VAR_PARSE_STRING *)dynamic_array_at( VAR_PARSE *, - group->elems, 0 ) )->s ); - var_parse_group_free( group ); - compile_parse( parse->right, c, RESULT_STACK ); - compile_emit( c, INSTR_PUSH_LOCAL, name ); - compile_parse( parse->third, c, nested_result ); - compile_emit( c, INSTR_POP_LOCAL, name ); - } - else - { - var_parse_group_compile( group, c ); - var_parse_group_free( group ); - compile_parse( parse->right, c, RESULT_STACK ); - compile_emit( c, INSTR_PUSH_LOCAL_GROUP, 0 ); - compile_parse( parse->third, c, nested_result ); - compile_emit( c, INSTR_POP_LOCAL_GROUP, 0 ); - } - } - else - { - compile_parse( parse->left, c, RESULT_STACK ); - compile_parse( parse->right, c, RESULT_STACK ); - compile_emit( c, INSTR_PUSH_LOCAL_GROUP, 0 ); - compile_parse( parse->third, c, nested_result ); - compile_emit( c, INSTR_POP_LOCAL_GROUP, 0 ); - } - adjust_result( c, nested_result, result_location ); - } - else if ( parse->type == PARSE_ON ) - { - if ( parse->right->type == PARSE_APPEND && - parse->right->left->type == PARSE_NULL && - parse->right->right->type == PARSE_LIST ) - { - /* [ on $(target) return $(variable) ] */ - PARSE * value = parse->right->right; - OBJECT * const o = value->string; - char const * s = object_str( o ); - VAR_PARSE_GROUP * group; - OBJECT * varname = 0; - current_file = object_str( value->file ); - current_line = value->line; - group = parse_expansion( &s ); - if ( group->elems->size == 1 ) - { - VAR_PARSE * one = dynamic_array_at( VAR_PARSE *, group->elems, 0 ); - if ( one->type == VAR_PARSE_TYPE_VAR ) - { - VAR_PARSE_VAR * var = ( VAR_PARSE_VAR * )one; - if ( var->modifiers->size == 0 && !var->subscript && var->name->elems->size == 1 ) - { - VAR_PARSE * name = dynamic_array_at( VAR_PARSE *, var->name->elems, 0 ); - if ( name->type == VAR_PARSE_TYPE_STRING ) - { - varname = ( ( VAR_PARSE_STRING * )name )->s; - } - } - } - } - if ( varname ) - { - /* We have one variable with a fixed name and no modifiers. */ - compile_parse( parse->left, c, RESULT_STACK ); - compile_emit( c, INSTR_GET_ON, compile_emit_constant( c, varname ) ); - } - else - { - /* Too complex. Fall back on push/pop. */ - int end = compile_new_label( c ); - compile_parse( parse->left, c, RESULT_STACK ); - compile_emit_branch( c, INSTR_PUSH_ON, end ); - var_parse_group_compile( group, c ); - compile_emit( c, INSTR_POP_ON, 0 ); - compile_set_label( c, end ); - } - var_parse_group_free( group ); - } - else - { - int end = compile_new_label( c ); - compile_parse( parse->left, c, RESULT_STACK ); - compile_emit_branch( c, INSTR_PUSH_ON, end ); - compile_parse( parse->right, c, RESULT_STACK ); - compile_emit( c, INSTR_POP_ON, 0 ); - compile_set_label( c, end ); - } - adjust_result( c, RESULT_STACK, result_location ); - } - else if ( parse->type == PARSE_RULE ) - { - PARSE * p; - int n = 0; - VAR_PARSE_GROUP * group; - char const * s = object_str( parse->string ); - - if ( parse->left->left || parse->left->right->type != PARSE_NULL ) - for ( p = parse->left; p; p = p->left ) - { - compile_parse( p->right, c, RESULT_STACK ); - ++n; - } - - current_file = object_str( parse->file ); - current_line = parse->line; - group = parse_expansion( &s ); - - if ( group->elems->size == 2 && - dynamic_array_at( VAR_PARSE *, group->elems, 0 )->type == VAR_PARSE_TYPE_VAR && - dynamic_array_at( VAR_PARSE *, group->elems, 1 )->type == VAR_PARSE_TYPE_STRING && - ( object_str( ( (VAR_PARSE_STRING *)dynamic_array_at( VAR_PARSE *, group->elems, 1 ) )->s )[ 0 ] == '.' ) ) - { - VAR_PARSE_STRING * access = (VAR_PARSE_STRING *)dynamic_array_at( VAR_PARSE *, group->elems, 1 ); - OBJECT * member = object_new( object_str( access->s ) + 1 ); - /* Emit the object */ - var_parse_var_compile( (VAR_PARSE_VAR *)dynamic_array_at( VAR_PARSE *, group->elems, 0 ), c ); - var_parse_group_free( group ); - compile_emit( c, INSTR_CALL_MEMBER_RULE, n ); - compile_emit( c, compile_emit_constant( c, member ), parse->line ); - object_free( member ); - } - else - { - var_parse_group_compile( group, c ); - var_parse_group_free( group ); - compile_emit( c, INSTR_CALL_RULE, n ); - compile_emit( c, compile_emit_constant( c, parse->string ), parse->line ); - } - - adjust_result( c, RESULT_STACK, result_location ); - } - else if ( parse->type == PARSE_RULES ) - { - do compile_parse( parse->left, c, RESULT_NONE ); - while ( ( parse = parse->right )->type == PARSE_RULES ); - compile_parse( parse, c, result_location ); - } - else if ( parse->type == PARSE_SET ) - { - PARSE * vars = parse->left; - unsigned int op_code; - unsigned int op_code_group; - - switch ( parse->num ) - { - case ASSIGN_APPEND: op_code = INSTR_APPEND; op_code_group = INSTR_APPEND_GROUP; break; - case ASSIGN_DEFAULT: op_code = INSTR_DEFAULT; op_code_group = INSTR_DEFAULT_GROUP; break; - default: op_code = INSTR_SET; op_code_group = INSTR_SET_GROUP; break; - } - - /* Check whether there is exactly one variable with a constant name. */ - if ( vars->type == PARSE_LIST ) - { - char const * s = object_str( vars->string ); - VAR_PARSE_GROUP * group; - current_file = object_str( parse->file ); - current_line = parse->line; - group = parse_expansion( &s ); - if ( group->elems->size == 1 && dynamic_array_at( VAR_PARSE *, - group->elems, 0 )->type == VAR_PARSE_TYPE_STRING ) - { - int const name = compile_emit_constant( c, ( - (VAR_PARSE_STRING *)dynamic_array_at( VAR_PARSE *, - group->elems, 0 ) )->s ); - var_parse_group_free( group ); - compile_parse( parse->right, c, RESULT_STACK ); - if ( result_location != RESULT_NONE ) - { - compile_emit( c, INSTR_SET_RESULT, 1 ); - } - compile_emit( c, op_code, name ); - } - else - { - var_parse_group_compile( group, c ); - var_parse_group_free( group ); - compile_parse( parse->right, c, RESULT_STACK ); - if ( result_location != RESULT_NONE ) - { - compile_emit( c, INSTR_SET_RESULT, 1 ); - } - compile_emit( c, op_code_group, 0 ); - } - } - else - { - compile_parse( parse->left, c, RESULT_STACK ); - compile_parse( parse->right, c, RESULT_STACK ); - if ( result_location != RESULT_NONE ) - { - compile_emit( c, INSTR_SET_RESULT, 1 ); - } - compile_emit( c, op_code_group, 0 ); - } - if ( result_location != RESULT_NONE ) - { - adjust_result( c, RESULT_RETURN, result_location ); - } - } - else if ( parse->type == PARSE_SETCOMP ) - { - int n_args; - struct arg_list * args = arg_list_compile( parse->right, &n_args ); - int const rule_id = compile_emit_rule( c, parse->string, parse->left, - n_args, args, parse->num ); - compile_emit( c, INSTR_RULE, rule_id ); - adjust_result( c, RESULT_NONE, result_location ); - } - else if ( parse->type == PARSE_SETEXEC ) - { - int const actions_id = compile_emit_actions( c, parse ); - compile_parse( parse->left, c, RESULT_STACK ); - compile_emit( c, INSTR_ACTIONS, actions_id ); - adjust_result( c, RESULT_NONE, result_location ); - } - else if ( parse->type == PARSE_SETTINGS ) - { - compile_parse( parse->left, c, RESULT_STACK ); - compile_parse( parse->third, c, RESULT_STACK ); - compile_parse( parse->right, c, RESULT_STACK ); - - switch ( parse->num ) - { - case ASSIGN_APPEND: compile_emit( c, INSTR_APPEND_ON, 0 ); break; - case ASSIGN_DEFAULT: compile_emit( c, INSTR_DEFAULT_ON, 0 ); break; - default: compile_emit( c, INSTR_SET_ON, 0 ); break; - } - - adjust_result( c, RESULT_STACK, result_location ); - } - else if ( parse->type == PARSE_SWITCH ) - { - int const switch_end = compile_new_label( c ); - compile_parse( parse->left, c, RESULT_STACK ); - - for ( parse = parse->right; parse; parse = parse->right ) - { - int const id = compile_emit_constant( c, parse->left->string ); - int const next_case = compile_new_label( c ); - compile_emit( c, INSTR_PUSH_CONSTANT, id ); - compile_emit_branch( c, INSTR_JUMP_NOT_GLOB, next_case ); - compile_parse( parse->left->left, c, result_location ); - compile_emit_branch( c, INSTR_JUMP, switch_end ); - compile_set_label( c, next_case ); - } - compile_emit( c, INSTR_POP, 0 ); - adjust_result( c, RESULT_NONE, result_location ); - compile_set_label( c, switch_end ); - } - else if ( parse->type == PARSE_NULL ) - adjust_result( c, RESULT_NONE, result_location ); - else - assert( !"unknown PARSE type." ); -} - -OBJECT * function_rulename( FUNCTION * function ) -{ - return function->rulename; -} - -void function_set_rulename( FUNCTION * function, OBJECT * rulename ) -{ - function->rulename = rulename; -} - -void function_location( FUNCTION * function_, OBJECT * * file, int * line ) -{ - if ( function_->type == FUNCTION_BUILTIN ) - { - *file = constant_builtin; - *line = -1; - } -#ifdef HAVE_PYTHON - if ( function_->type == FUNCTION_PYTHON ) - { - *file = constant_builtin; - *line = -1; - } -#endif - else - { - JAM_FUNCTION * function = (JAM_FUNCTION *)function_; - assert( function_->type == FUNCTION_JAM ); - *file = function->file; - *line = function->line; - } -} - -static struct arg_list * arg_list_compile_builtin( char const * * args, - int * num_arguments ); - -F
<TRUNCATED>
