| /* |
| * 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; |
| } |
| |
| struct list_alignment_helper |
| { |
| char ch; |
| LIST * l; |
| }; |
| |
| #define LISTPTR_ALIGN_BASE ( sizeof( struct list_alignment_helper ) - sizeof( LIST * ) ) |
| #define LISTPTR_ALIGN ( ( LISTPTR_ALIGN_BASE > sizeof( LIST * ) ) ? sizeof( LIST * ) : LISTPTR_ALIGN_BASE ) |
| |
| static void check_alignment( STACK * s ) |
| { |
| assert( (size_t)s->data % LISTPTR_ALIGN == 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 ); |
| |
| FUNCTION * function_builtin( LIST * ( * func )( FRAME * frame, int flags ), |
| int flags, char const * * args ) |
| { |
| BUILTIN_FUNCTION * result = BJAM_MALLOC( sizeof( BUILTIN_FUNCTION ) ); |
| result->base.type = FUNCTION_BUILTIN; |
| result->base.reference_count = 1; |
| result->base.rulename = 0; |
| result->base.formal_arguments = arg_list_compile_builtin( args, |
| &result->base.num_formal_arguments ); |
| result->func = func; |
| result->flags = flags; |
| return (FUNCTION *)result; |
| } |
| |
| FUNCTION * function_compile( PARSE * parse ) |
| { |
| compiler c[ 1 ]; |
| JAM_FUNCTION * result; |
| compiler_init( c ); |
| compile_parse( parse, c, RESULT_RETURN ); |
| compile_emit( c, INSTR_RETURN, 0 ); |
| result = compile_to_function( c ); |
| compiler_free( c ); |
| result->file = object_copy( parse->file ); |
| result->line = parse->line; |
| return (FUNCTION *)result; |
| } |
| |
| FUNCTION * function_compile_actions( char const * actions, OBJECT * file, |
| int line ) |
| { |
| compiler c[ 1 ]; |
| JAM_FUNCTION * result; |
| VAR_PARSE_ACTIONS * parse; |
| current_file = object_str( file ); |
| current_line = line; |
| parse = parse_actions( actions ); |
| compiler_init( c ); |
| var_parse_actions_compile( parse, c ); |
| var_parse_actions_free( parse ); |
| compile_emit( c, INSTR_RETURN, 0 ); |
| result = compile_to_function( c ); |
| compiler_free( c ); |
| result->file = object_copy( file ); |
| result->line = line; |
| return (FUNCTION *)result; |
| } |
| |
| static void argument_list_print( struct arg_list * args, int num_args ); |
| |
| |
| /* Define delimiters for type check elements in argument lists (and return type |
| * specifications, eventually). |
| */ |
| # define TYPE_OPEN_DELIM '[' |
| # define TYPE_CLOSE_DELIM ']' |
| |
| /* |
| * is_type_name() - true iff the given string represents a type check |
| * specification. |
| */ |
| |
| int is_type_name( char const * s ) |
| { |
| return s[ 0 ] == TYPE_OPEN_DELIM && s[ strlen( s ) - 1 ] == |
| TYPE_CLOSE_DELIM; |
| } |
| |
| static void argument_error( char const * message, FUNCTION * procedure, |
| FRAME * frame, OBJECT * arg ) |
| { |
| extern void print_source_line( FRAME * ); |
| LOL * actual = frame->args; |
| backtrace_line( frame->prev ); |
| printf( "*** argument error\n* rule %s ( ", frame->rulename ); |
| argument_list_print( procedure->formal_arguments, |
| procedure->num_formal_arguments ); |
| printf( " )\n* called with: ( " ); |
| lol_print( actual ); |
| printf( " )\n* %s %s\n", message, arg ? object_str ( arg ) : "" ); |
| function_location( procedure, &frame->file, &frame->line ); |
| print_source_line( frame ); |
| printf( "see definition of rule '%s' being called\n", frame->rulename ); |
| backtrace( frame->prev ); |
| exit( 1 ); |
| } |
| |
| static void type_check_range( OBJECT * type_name, LISTITER iter, LISTITER end, |
| FRAME * caller, FUNCTION * called, OBJECT * arg_name ) |
| { |
| static module_t * typecheck = 0; |
| |
| /* If nothing to check, bail now. */ |
| if ( iter == end || !type_name ) |
| return; |
| |
| if ( !typecheck ) |
| typecheck = bindmodule( constant_typecheck ); |
| |
| /* If the checking rule can not be found, also bail. */ |
| if ( !typecheck->rules || !hash_find( typecheck->rules, type_name ) ) |
| return; |
| |
| for ( ; iter != end; iter = list_next( iter ) ) |
| { |
| LIST * error; |
| FRAME frame[ 1 ]; |
| frame_init( frame ); |
| frame->module = typecheck; |
| frame->prev = caller; |
| frame->prev_user = caller->module->user_module |
| ? caller |
| : caller->prev_user; |
| |
| /* Prepare the argument list */ |
| lol_add( frame->args, list_new( object_copy( list_item( iter ) ) ) ); |
| error = evaluate_rule( bindrule( type_name, frame->module ), type_name, frame ); |
| |
| if ( !list_empty( error ) ) |
| argument_error( object_str( list_front( error ) ), called, caller, |
| arg_name ); |
| |
| frame_free( frame ); |
| } |
| } |
| |
| static void type_check( OBJECT * type_name, LIST * values, FRAME * caller, |
| FUNCTION * called, OBJECT * arg_name ) |
| { |
| type_check_range( type_name, list_begin( values ), list_end( values ), |
| caller, called, arg_name ); |
| } |
| |
| void argument_list_check( struct arg_list * formal, int formal_count, |
| FUNCTION * function, FRAME * frame ) |
| { |
| LOL * all_actual = frame->args; |
| int i; |
| |
| for ( i = 0; i < formal_count; ++i ) |
| { |
| LIST * actual = lol_get( all_actual, i ); |
| LISTITER actual_iter = list_begin( actual ); |
| LISTITER const actual_end = list_end( actual ); |
| int j; |
| for ( j = 0; j < formal[ i ].size; ++j ) |
| { |
| struct argument * formal_arg = &formal[ i ].args[ j ]; |
| LIST * value; |
| |
| switch ( formal_arg->flags ) |
| { |
| case ARG_ONE: |
| if ( actual_iter == actual_end ) |
| argument_error( "missing argument", function, frame, |
| formal_arg->arg_name ); |
| type_check_range( formal_arg->type_name, actual_iter, |
| list_next( actual_iter ), frame, function, |
| formal_arg->arg_name ); |
| actual_iter = list_next( actual_iter ); |
| break; |
| case ARG_OPTIONAL: |
| if ( actual_iter == actual_end ) |
| value = L0; |
| else |
| { |
| type_check_range( formal_arg->type_name, actual_iter, |
| list_next( actual_iter ), frame, function, |
| formal_arg->arg_name ); |
| actual_iter = list_next( actual_iter ); |
| } |
| break; |
| case ARG_PLUS: |
| if ( actual_iter == actual_end ) |
| argument_error( "missing argument", function, frame, |
| formal_arg->arg_name ); |
| /* fallthrough */ |
| case ARG_STAR: |
| type_check_range( formal_arg->type_name, actual_iter, |
| actual_end, frame, function, formal_arg->arg_name ); |
| actual_iter = actual_end; |
| break; |
| case ARG_VARIADIC: |
| return; |
| } |
| } |
| |
| if ( actual_iter != actual_end ) |
| argument_error( "extra argument", function, frame, list_item( |
| actual_iter ) ); |
| } |
| |
| for ( ; i < all_actual->count; ++i ) |
| { |
| LIST * actual = lol_get( all_actual, i ); |
| if ( !list_empty( actual ) ) |
| argument_error( "extra argument", function, frame, list_front( |
| actual ) ); |
| } |
| } |
| |
| void argument_list_push( struct arg_list * formal, int formal_count, |
| FUNCTION * function, FRAME * frame, STACK * s ) |
| { |
| LOL * all_actual = frame->args; |
| int i; |
| |
| for ( i = 0; i < formal_count; ++i ) |
| { |
| LIST * actual = lol_get( all_actual, i ); |
| LISTITER actual_iter = list_begin( actual ); |
| LISTITER const actual_end = list_end( actual ); |
| int j; |
| for ( j = 0; j < formal[ i ].size; ++j ) |
| { |
| struct argument * formal_arg = &formal[ i ].args[ j ]; |
| LIST * value; |
| |
| switch ( formal_arg->flags ) |
| { |
| case ARG_ONE: |
| if ( actual_iter == actual_end ) |
| argument_error( "missing argument", function, frame, |
| formal_arg->arg_name ); |
| value = list_new( object_copy( list_item( actual_iter ) ) ); |
| actual_iter = list_next( actual_iter ); |
| break; |
| case ARG_OPTIONAL: |
| if ( actual_iter == actual_end ) |
| value = L0; |
| else |
| { |
| value = list_new( object_copy( list_item( actual_iter ) ) ); |
| actual_iter = list_next( actual_iter ); |
| } |
| break; |
| case ARG_PLUS: |
| if ( actual_iter == actual_end ) |
| argument_error( "missing argument", function, frame, |
| formal_arg->arg_name ); |
| /* fallthrough */ |
| case ARG_STAR: |
| value = list_copy_range( actual, actual_iter, actual_end ); |
| actual_iter = actual_end; |
| break; |
| case ARG_VARIADIC: |
| return; |
| } |
| |
| type_check( formal_arg->type_name, value, frame, function, |
| formal_arg->arg_name ); |
| |
| if ( formal_arg->index != -1 ) |
| { |
| LIST * * const old = &frame->module->fixed_variables[ |
| formal_arg->index ]; |
| stack_push( s, *old ); |
| *old = value; |
| } |
| else |
| stack_push( s, var_swap( frame->module, formal_arg->arg_name, |
| value ) ); |
| } |
| |
| if ( actual_iter != actual_end ) |
| argument_error( "extra argument", function, frame, list_item( |
| actual_iter ) ); |
| } |
| |
| for ( ; i < all_actual->count; ++i ) |
| { |
| LIST * const actual = lol_get( all_actual, i ); |
| if ( !list_empty( actual ) ) |
| argument_error( "extra argument", function, frame, list_front( |
| actual ) ); |
| } |
| } |
| |
| void argument_list_pop( struct arg_list * formal, int formal_count, |
| FRAME * frame, STACK * s ) |
| { |
| int i; |
| for ( i = formal_count - 1; i >= 0; --i ) |
| { |
| int j; |
| for ( j = formal[ i ].size - 1; j >= 0 ; --j ) |
| { |
| struct argument * formal_arg = &formal[ i ].args[ j ]; |
| |
| if ( formal_arg->flags == ARG_VARIADIC ) |
| continue; |
| if ( formal_arg->index != -1 ) |
| { |
| LIST * const old = stack_pop( s ); |
| LIST * * const pos = &frame->module->fixed_variables[ |
| formal_arg->index ]; |
| list_free( *pos ); |
| *pos = old; |
| } |
| else |
| var_set( frame->module, formal_arg->arg_name, stack_pop( s ), |
| VAR_SET ); |
| } |
| } |
| } |
| |
| |
| struct argument_compiler |
| { |
| struct dynamic_array args[ 1 ]; |
| struct argument arg; |
| int state; |
| #define ARGUMENT_COMPILER_START 0 |
| #define ARGUMENT_COMPILER_FOUND_TYPE 1 |
| #define ARGUMENT_COMPILER_FOUND_OBJECT 2 |
| #define ARGUMENT_COMPILER_DONE 3 |
| }; |
| |
| |
| static void argument_compiler_init( struct argument_compiler * c ) |
| { |
| dynamic_array_init( c->args ); |
| c->state = ARGUMENT_COMPILER_START; |
| } |
| |
| static void argument_compiler_free( struct argument_compiler * c ) |
| { |
| dynamic_array_free( c->args ); |
| } |
| |
| static void argument_compiler_add( struct argument_compiler * c, OBJECT * arg, |
| OBJECT * file, int line ) |
| { |
| switch ( c->state ) |
| { |
| case ARGUMENT_COMPILER_FOUND_OBJECT: |
| |
| if ( object_equal( arg, constant_question_mark ) ) |
| { |
| c->arg.flags = ARG_OPTIONAL; |
| } |
| else if ( object_equal( arg, constant_plus ) ) |
| { |
| c->arg.flags = ARG_PLUS; |
| } |
| else if ( object_equal( arg, constant_star ) ) |
| { |
| c->arg.flags = ARG_STAR; |
| } |
| |
| dynamic_array_push( c->args, c->arg ); |
| c->state = ARGUMENT_COMPILER_START; |
| |
| if ( c->arg.flags != ARG_ONE ) |
| break; |
| /* fall-through */ |
| |
| case ARGUMENT_COMPILER_START: |
| |
| c->arg.type_name = 0; |
| c->arg.index = -1; |
| c->arg.flags = ARG_ONE; |
| |
| if ( is_type_name( object_str( arg ) ) ) |
| { |
| c->arg.type_name = object_copy( arg ); |
| c->state = ARGUMENT_COMPILER_FOUND_TYPE; |
| break; |
| } |
| /* fall-through */ |
| |
| case ARGUMENT_COMPILER_FOUND_TYPE: |
| |
| if ( is_type_name( object_str( arg ) ) ) |
| { |
| printf( "%s:%d: missing argument name before type name: %s\n", |
| object_str( file ), line, object_str( arg ) ); |
| exit( 1 ); |
| } |
| |
| c->arg.arg_name = object_copy( arg ); |
| if ( object_equal( arg, constant_star ) ) |
| { |
| c->arg.flags = ARG_VARIADIC; |
| dynamic_array_push( c->args, c->arg ); |
| c->state = ARGUMENT_COMPILER_DONE; |
| } |
| else |
| { |
| c->state = ARGUMENT_COMPILER_FOUND_OBJECT; |
| } |
| break; |
| |
| case ARGUMENT_COMPILER_DONE: |
| break; |
| } |
| } |
| |
| static void argument_compiler_recurse( struct argument_compiler * c, |
| PARSE * parse ) |
| { |
| if ( parse->type == PARSE_APPEND ) |
| { |
| argument_compiler_recurse( c, parse->left ); |
| argument_compiler_recurse( c, parse->right ); |
| } |
| else if ( parse->type != PARSE_NULL ) |
| { |
| assert( parse->type == PARSE_LIST ); |
| argument_compiler_add( c, parse->string, parse->file, parse->line ); |
| } |
| } |
| |
| static struct arg_list arg_compile_impl( struct argument_compiler * c, |
| OBJECT * file, int line ) |
| { |
| struct arg_list result; |
| switch ( c->state ) |
| { |
| case ARGUMENT_COMPILER_START: |
| case ARGUMENT_COMPILER_DONE: |
| break; |
| case ARGUMENT_COMPILER_FOUND_TYPE: |
| printf( "%s:%d: missing argument name after type name: %s\n", |
| object_str( file ), line, object_str( c->arg.type_name ) ); |
| exit( 1 ); |
| case ARGUMENT_COMPILER_FOUND_OBJECT: |
| dynamic_array_push( c->args, c->arg ); |
| break; |
| } |
| result.size = c->args->size; |
| result.args = BJAM_MALLOC( c->args->size * sizeof( struct argument ) ); |
| memcpy( result.args, c->args->data, c->args->size * sizeof( struct argument |
| ) ); |
| return result; |
| } |
| |
| static struct arg_list arg_compile( PARSE * parse ) |
| { |
| struct argument_compiler c[ 1 ]; |
| struct arg_list result; |
| argument_compiler_init( c ); |
| argument_compiler_recurse( c, parse ); |
| result = arg_compile_impl( c, parse->file, parse->line ); |
| argument_compiler_free( c ); |
| return result; |
| } |
| |
| struct argument_list_compiler |
| { |
| struct dynamic_array args[ 1 ]; |
| }; |
| |
| static void argument_list_compiler_init( struct argument_list_compiler * c ) |
| { |
| dynamic_array_init( c->args ); |
| } |
| |
| static void argument_list_compiler_free( struct argument_list_compiler * c ) |
| { |
| dynamic_array_free( c->args ); |
| } |
| |
| static void argument_list_compiler_add( struct argument_list_compiler * c, |
| PARSE * parse ) |
| { |
| struct arg_list args = arg_compile( parse ); |
| dynamic_array_push( c->args, args ); |
| } |
| |
| static void argument_list_compiler_recurse( struct argument_list_compiler * c, |
| PARSE * parse ) |
| { |
| if ( parse ) |
| { |
| argument_list_compiler_add( c, parse->right ); |
| argument_list_compiler_recurse( c, parse->left ); |
| } |
| } |
| |
| static struct arg_list * arg_list_compile( PARSE * parse, int * num_arguments ) |
| { |
| if ( parse ) |
| { |
| struct argument_list_compiler c[ 1 ]; |
| struct arg_list * result; |
| argument_list_compiler_init( c ); |
| argument_list_compiler_recurse( c, parse ); |
| *num_arguments = c->args->size; |
| result = BJAM_MALLOC( c->args->size * sizeof( struct arg_list ) ); |
| memcpy( result, c->args->data, c->args->size * sizeof( struct arg_list ) |
| ); |
| argument_list_compiler_free( c ); |
| return result; |
| } |
| *num_arguments = 0; |
| return 0; |
| } |
| |
| static struct arg_list * arg_list_compile_builtin( char const * * args, |
| int * num_arguments ) |
| { |
| if ( args ) |
| { |
| struct argument_list_compiler c[ 1 ]; |
| struct arg_list * result; |
| argument_list_compiler_init( c ); |
| while ( *args ) |
| { |
| struct argument_compiler arg_comp[ 1 ]; |
| struct arg_list arg; |
| argument_compiler_init( arg_comp ); |
| for ( ; *args; ++args ) |
| { |
| OBJECT * token; |
| if ( strcmp( *args, ":" ) == 0 ) |
| { |
| ++args; |
| break; |
| } |
| token = object_new( *args ); |
| argument_compiler_add( arg_comp, token, constant_builtin, -1 ); |
| object_free( token ); |
| } |
| arg = arg_compile_impl( arg_comp, constant_builtin, -1 ); |
| dynamic_array_push( c->args, arg ); |
| argument_compiler_free( arg_comp ); |
| } |
| *num_arguments = c->args->size; |
| result = BJAM_MALLOC( c->args->size * sizeof( struct arg_list ) ); |
| memcpy( result, c->args->data, c->args->size * sizeof( struct arg_list ) |
| ); |
| argument_list_compiler_free( c ); |
| return result; |
| } |
| *num_arguments = 0; |
| return 0; |
| } |
| |
| static void argument_list_print( struct arg_list * args, int num_args ) |
| { |
| if ( args ) |
| { |
| int i; |
| for ( i = 0; i < num_args; ++i ) |
| { |
| int j; |
| if ( i ) printf( " : " ); |
| for ( j = 0; j < args[ i ].size; ++j ) |
| { |
| struct argument * formal_arg = &args[ i ].args[ j ]; |
| if ( j ) printf( " " ); |
| if ( formal_arg->type_name ) |
| printf( "%s ", object_str( formal_arg->type_name ) ); |
| printf( "%s", object_str( formal_arg->arg_name ) ); |
| switch ( formal_arg->flags ) |
| { |
| case ARG_OPTIONAL: printf( " ?" ); break; |
| case ARG_PLUS: printf( " +" ); break; |
| case ARG_STAR: printf( " *" ); break; |
| } |
| } |
| } |
| } |
| } |
| |
| |
| struct arg_list * argument_list_bind_variables( struct arg_list * formal, |
| int formal_count, module_t * module, int * counter ) |
| { |
| if ( formal ) |
| { |
| struct arg_list * result = (struct arg_list *)BJAM_MALLOC( sizeof( |
| struct arg_list ) * formal_count ); |
| int i; |
| |
| for ( i = 0; i < formal_count; ++i ) |
| { |
| int j; |
| struct argument * args = (struct argument *)BJAM_MALLOC( sizeof( |
| struct argument ) * formal[ i ].size ); |
| for ( j = 0; j < formal[ i ].size; ++j ) |
| { |
| args[ j ] = formal[ i ].args[ j ]; |
| if ( args[ j ].type_name ) |
| args[ j ].type_name = object_copy( args[ j ].type_name ); |
| args[ j ].arg_name = object_copy( args[ j ].arg_name ); |
| if ( args[ j ].flags != ARG_VARIADIC ) |
| args[ j ].index = module_add_fixed_var( module, |
| args[ j ].arg_name, counter ); |
| } |
| result[ i ].args = args; |
| result[ i ].size = formal[ i ].size; |
| } |
| |
| return result; |
| } |
| return 0; |
| } |
| |
| |
| void argument_list_free( struct arg_list * args, int args_count ) |
| { |
| int i; |
| for ( i = 0; i < args_count; ++i ) |
| { |
| int j; |
| for ( j = 0; j < args[ i ].size; ++j ) |
| { |
| if ( args[ i ].args[ j ].type_name ) |
| object_free( args[ i ].args[ j ].type_name ); |
| object_free( args[ i ].args[ j ].arg_name ); |
| } |
| BJAM_FREE( args[ i ].args ); |
| } |
| BJAM_FREE( args ); |
| } |
| |
| |
| FUNCTION * function_unbind_variables( FUNCTION * f ) |
| { |
| if ( f->type == FUNCTION_JAM ) |
| { |
| JAM_FUNCTION * const func = (JAM_FUNCTION *)f; |
| return func->generic ? func->generic : f; |
| } |
| #ifdef HAVE_PYTHON |
| if ( f->type == FUNCTION_PYTHON ) |
| return f; |
| #endif |
| assert( f->type == FUNCTION_BUILTIN ); |
| return f; |
| } |
| |
| FUNCTION * function_bind_variables( FUNCTION * f, module_t * module, |
| int * counter ) |
| { |
| if ( f->type == FUNCTION_BUILTIN ) |
| return f; |
| #ifdef HAVE_PYTHON |
| if ( f->type == FUNCTION_PYTHON ) |
| return f; |
| #endif |
| { |
| JAM_FUNCTION * func = (JAM_FUNCTION *)f; |
| JAM_FUNCTION * new_func = BJAM_MALLOC( sizeof( JAM_FUNCTION ) ); |
| instruction * code; |
| int i; |
| assert( f->type == FUNCTION_JAM ); |
| memcpy( new_func, func, sizeof( JAM_FUNCTION ) ); |
| new_func->base.reference_count = 1; |
| new_func->base.formal_arguments = argument_list_bind_variables( |
| f->formal_arguments, f->num_formal_arguments, module, counter ); |
| new_func->code = BJAM_MALLOC( func->code_size * sizeof( instruction ) ); |
| memcpy( new_func->code, func->code, func->code_size * sizeof( |
| instruction ) ); |
| new_func->generic = (FUNCTION *)func; |
| func = new_func; |
| for ( i = 0; ; ++i ) |
| { |
| OBJECT * key; |
| int op_code; |
| code = func->code + i; |
| switch ( code->op_code ) |
| { |
| case INSTR_PUSH_VAR: op_code = INSTR_PUSH_VAR_FIXED; break; |
| case INSTR_PUSH_LOCAL: op_code = INSTR_PUSH_LOCAL_FIXED; break; |
| case INSTR_POP_LOCAL: op_code = INSTR_POP_LOCAL_FIXED; break; |
| case INSTR_SET: op_code = INSTR_SET_FIXED; break; |
| case INSTR_APPEND: op_code = INSTR_APPEND_FIXED; break; |
| case INSTR_DEFAULT: op_code = INSTR_DEFAULT_FIXED; break; |
| case INSTR_RETURN: return (FUNCTION *)new_func; |
| case INSTR_CALL_MEMBER_RULE: |
| case INSTR_CALL_RULE: ++i; continue; |
| case INSTR_PUSH_MODULE: |
| { |
| int depth = 1; |
| ++i; |
| while ( depth > 0 ) |
| { |
| code = func->code + i; |
| switch ( code->op_code ) |
| { |
| case INSTR_PUSH_MODULE: |
| case INSTR_CLASS: |
| ++depth; |
| break; |
| case INSTR_POP_MODULE: |
| --depth; |
| break; |
| case INSTR_CALL_RULE: |
| ++i; |
| break; |
| } |
| ++i; |
| } |
| --i; |
| } |
| default: continue; |
| } |
| key = func->constants[ code->arg ]; |
| if ( !( object_equal( key, constant_TMPDIR ) || |
| object_equal( key, constant_TMPNAME ) || |
| object_equal( key, constant_TMPFILE ) || |
| object_equal( key, constant_STDOUT ) || |
| object_equal( key, constant_STDERR ) ) ) |
| { |
| code->op_code = op_code; |
| code->arg = module_add_fixed_var( module, key, counter ); |
| } |
| } |
| } |
| } |
| |
| void function_refer( FUNCTION * func ) |
| { |
| ++func->reference_count; |
| } |
| |
| void function_free( FUNCTION * function_ ) |
| { |
| int i; |
| |
| if ( --function_->reference_count != 0 ) |
| return; |
| |
| if ( function_->formal_arguments ) |
| argument_list_free( function_->formal_arguments, |
| function_->num_formal_arguments ); |
| |
| if ( function_->type == FUNCTION_JAM ) |
| { |
| JAM_FUNCTION * func = (JAM_FUNCTION *)function_; |
| |
| BJAM_FREE( func->code ); |
| |
| if ( func->generic ) |
| function_free( func->generic ); |
| else |
| { |
| if ( function_->rulename ) object_free( function_->rulename ); |
| |
| for ( i = 0; i < func->num_constants; ++i ) |
| object_free( func->constants[ i ] ); |
| BJAM_FREE( func->constants ); |
| |
| for ( i = 0; i < func->num_subfunctions; ++i ) |
| { |
| object_free( func->functions[ i ].name ); |
| function_free( func->functions[ i ].code ); |
| } |
| BJAM_FREE( func->functions ); |
| |
| for ( i = 0; i < func->num_subactions; ++i ) |
| { |
| object_free( func->actions[ i ].name ); |
| function_free( func->actions[ i ].command ); |
| } |
| BJAM_FREE( func->actions ); |
| |
| object_free( func->file ); |
| } |
| } |
| #ifdef HAVE_PYTHON |
| else if ( function_->type == FUNCTION_PYTHON ) |
| { |
| PYTHON_FUNCTION * func = (PYTHON_FUNCTION *)function_; |
| Py_DECREF( func->python_function ); |
| if ( function_->rulename ) object_free( function_->rulename ); |
| } |
| #endif |
| else |
| { |
| assert( function_->type == FUNCTION_BUILTIN ); |
| if ( function_->rulename ) object_free( function_->rulename ); |
| } |
| |
| BJAM_FREE( function_ ); |
| } |
| |
| |
| /* Alignment check for stack */ |
| |
| struct align_var_edits |
| { |
| char ch; |
| VAR_EDITS e; |
| }; |
| |
| struct align_expansion_item |
| { |
| char ch; |
| expansion_item e; |
| }; |
| |
| static char check_align_var_edits[ sizeof(struct align_var_edits) <= sizeof(VAR_EDITS) + sizeof(void *) ? 1 : -1 ]; |
| static char check_align_expansion_item[ sizeof(struct align_expansion_item) <= sizeof(expansion_item) + sizeof(void *) ? 1 : -1 ]; |
| |
| static char check_ptr_size1[ sizeof(LIST *) <= sizeof(void *) ? 1 : -1 ]; |
| static char check_ptr_size2[ sizeof(char *) <= sizeof(void *) ? 1 : -1 ]; |
| |
| void function_run_actions( FUNCTION * function, FRAME * frame, STACK * s, |
| string * out ) |
| { |
| *(string * *)stack_allocate( s, sizeof( string * ) ) = out; |
| list_free( function_run( function, frame, s ) ); |
| stack_deallocate( s, sizeof( string * ) ); |
| } |
| |
| /* |
| * WARNING: The instruction set is tuned for Jam and is not really generic. Be |
| * especially careful about stack push/pop. |
| */ |
| |
| LIST * function_run( FUNCTION * function_, FRAME * frame, STACK * s ) |
| { |
| JAM_FUNCTION * function; |
| instruction * code; |
| LIST * l; |
| LIST * r; |
| LIST * result = L0; |
| void * saved_stack = s->data; |
| |
| if ( function_->type == FUNCTION_BUILTIN ) |
| { |
| BUILTIN_FUNCTION const * const f = (BUILTIN_FUNCTION *)function_; |
| if ( function_->formal_arguments ) |
| argument_list_check( function_->formal_arguments, |
| function_->num_formal_arguments, function_, frame ); |
| return f->func( frame, f->flags ); |
| } |
| |
| #ifdef HAVE_PYTHON |
| else if ( function_->type == FUNCTION_PYTHON ) |
| { |
| PYTHON_FUNCTION * f = (PYTHON_FUNCTION *)function_; |
| return call_python_function( f, frame ); |
| } |
| #endif |
| |
| assert( function_->type == FUNCTION_JAM ); |
| |
| if ( function_->formal_arguments ) |
| argument_list_push( function_->formal_arguments, |
| function_->num_formal_arguments, function_, frame, s ); |
| |
| function = (JAM_FUNCTION *)function_; |
| code = function->code; |
| for ( ; ; ) |
| { |
| switch ( code->op_code ) |
| { |
| |
| /* |
| * Basic stack manipulation |
| */ |
| |
| case INSTR_PUSH_EMPTY: |
| stack_push( s, L0 ); |
| break; |
| |
| case INSTR_PUSH_CONSTANT: |
| { |
| OBJECT * value = function_get_constant( function, code->arg ); |
| stack_push( s, list_new( object_copy( value ) ) ); |
| break; |
| } |
| |
| case INSTR_PUSH_ARG: |
| stack_push( s, frame_get_local( frame, code->arg ) ); |
| break; |
| |
| case INSTR_PUSH_VAR: |
| stack_push( s, function_get_variable( function, frame, code->arg ) ); |
| break; |
| |
| case INSTR_PUSH_VAR_FIXED: |
| stack_push( s, list_copy( frame->module->fixed_variables[ code->arg |
| ] ) ); |
| break; |
| |
| case INSTR_PUSH_GROUP: |
| { |
| LIST * value = L0; |
| LISTITER iter; |
| LISTITER end; |
| l = stack_pop( s ); |
| for ( iter = list_begin( l ), end = list_end( l ); iter != end; |
| iter = list_next( iter ) ) |
| value = list_append( value, function_get_named_variable( |
| function, frame, list_item( iter ) ) ); |
| list_free( l ); |
| stack_push( s, value ); |
| break; |
| } |
| |
| case INSTR_PUSH_APPEND: |
| r = stack_pop( s ); |
| l = stack_pop( s ); |
| stack_push( s, list_append( l, r ) ); |
| break; |
| |
| case INSTR_SWAP: |
| l = stack_top( s ); |
| stack_set( s, 0, stack_at( s, code->arg ) ); |
| stack_set( s, code->arg, l ); |
| break; |
| |
| case INSTR_POP: |
| list_free( stack_pop( s ) ); |
| break; |
| |
| /* |
| * Branch instructions |
| */ |
| |
| case INSTR_JUMP: |
| code += code->arg; |
| break; |
| |
| case INSTR_JUMP_EMPTY: |
| l = stack_pop( s ); |
| if ( !list_cmp( l, L0 ) ) code += code->arg; |
| list_free( l ); |
| break; |
| |
| case INSTR_JUMP_NOT_EMPTY: |
| l = stack_pop( s ); |
| if ( list_cmp( l, L0 ) ) code += code->arg; |
| list_free( l ); |
| break; |
| |
| case INSTR_JUMP_LT: |
| r = stack_pop( s ); |
| l = stack_pop( s ); |
| if ( list_cmp( l, r ) < 0 ) code += code->arg; |
| list_free( l ); |
| list_free( r ); |
| break; |
| |
| case INSTR_JUMP_LE: |
| r = stack_pop( s ); |
| l = stack_pop( s ); |
| if ( list_cmp( l, r ) <= 0 ) code += code->arg; |
| list_free( l ); |
| list_free( r ); |
| break; |
| |
| case INSTR_JUMP_GT: |
| r = stack_pop( s ); |
| l = stack_pop( s ); |
| if ( list_cmp( l, r ) > 0 ) code += code->arg; |
| list_free( l ); |
| list_free( r ); |
| break; |
| |
| case INSTR_JUMP_GE: |
| r = stack_pop( s ); |
| l = stack_pop( s ); |
| if ( list_cmp( l, r ) >= 0 ) code += code->arg; |
| list_free( l ); |
| list_free( r ); |
| break; |
| |
| case INSTR_JUMP_EQ: |
| r = stack_pop( s ); |
| l = stack_pop( s ); |
| if ( list_cmp( l, r ) == 0 ) code += code->arg; |
| list_free( l ); |
| list_free( r ); |
| break; |
| |
| case INSTR_JUMP_NE: |
| r = stack_pop(s); |
| l = stack_pop(s); |
| if ( list_cmp(l, r) != 0 ) code += code->arg; |
| list_free(l); |
| list_free(r); |
| break; |
| |
| case INSTR_JUMP_IN: |
| r = stack_pop(s); |
| l = stack_pop(s); |
| if ( list_is_sublist( l, r ) ) code += code->arg; |
| list_free(l); |
| list_free(r); |
| break; |
| |
| case INSTR_JUMP_NOT_IN: |
| r = stack_pop( s ); |
| l = stack_pop( s ); |
| if ( !list_is_sublist( l, r ) ) code += code->arg; |
| list_free( l ); |
| list_free( r ); |
| break; |
| |
| /* |
| * For |
| */ |
| |
| case INSTR_FOR_INIT: |
| l = stack_top( s ); |
| *(LISTITER *)stack_allocate( s, sizeof( LISTITER ) ) = |
| list_begin( l ); |
| break; |
| |
| case INSTR_FOR_LOOP: |
| { |
| LISTITER iter = *(LISTITER *)stack_get( s ); |
| stack_deallocate( s, sizeof( LISTITER ) ); |
| l = stack_top( s ); |
| if ( iter == list_end( l ) ) |
| { |
| list_free( stack_pop( s ) ); |
| code += code->arg; |
| } |
| else |
| { |
| r = list_new( object_copy( list_item( iter ) ) ); |
| iter = list_next( iter ); |
| *(LISTITER *)stack_allocate( s, sizeof( LISTITER ) ) = iter; |
| stack_push( s, r ); |
| } |
| break; |
| } |
| |
| /* |
| * Switch |
| */ |
| |
| case INSTR_JUMP_NOT_GLOB: |
| { |
| char const * pattern; |
| char const * match; |
| l = stack_pop( s ); |
| r = stack_top( s ); |
| pattern = list_empty( l ) ? "" : object_str( list_front( l ) ); |
| match = list_empty( r ) ? "" : object_str( list_front( r ) ); |
| if ( glob( pattern, match ) ) |
| code += code->arg; |
| else |
| list_free( stack_pop( s ) ); |
| list_free( l ); |
| break; |
| } |
| |
| /* |
| * Return |
| */ |
| |
| case INSTR_SET_RESULT: |
| list_free( result ); |
| if ( !code->arg ) |
| result = stack_pop( s ); |
| else |
| result = list_copy( stack_top( s ) ); |
| break; |
| |
| case INSTR_PUSH_RESULT: |
| stack_push( s, result ); |
| result = L0; |
| break; |
| |
| case INSTR_RETURN: |
| { |
| if ( function_->formal_arguments ) |
| argument_list_pop( function_->formal_arguments, |
| function_->num_formal_arguments, frame, s ); |
| #ifndef NDEBUG |
| if ( !( saved_stack == s->data ) ) |
| { |
| frame->file = function->file; |
| frame->line = function->line; |
| backtrace_line( frame ); |
| printf( "error: stack check failed.\n" ); |
| backtrace( frame ); |
| assert( saved_stack == s->data ); |
| } |
| #endif |
| assert( saved_stack == s->data ); |
| return result; |
| } |
| |
| /* |
| * Local variables |
| */ |
| |
| case INSTR_PUSH_LOCAL: |
| { |
| LIST * value = stack_pop( s ); |
| stack_push( s, function_swap_variable( function, frame, code->arg, |
| value ) ); |
| break; |
| } |
| |
| case INSTR_POP_LOCAL: |
| function_set_variable( function, frame, code->arg, stack_pop( s ) ); |
| break; |
| |
| case INSTR_PUSH_LOCAL_FIXED: |
| { |
| LIST * value = stack_pop( s ); |
| LIST * * ptr = &frame->module->fixed_variables[ code->arg ]; |
| assert( code->arg < frame->module->num_fixed_variables ); |
| stack_push( s, *ptr ); |
| *ptr = value; |
| break; |
| } |
| |
| case INSTR_POP_LOCAL_FIXED: |
| { |
| LIST * value = stack_pop( s ); |
| LIST * * ptr = &frame->module->fixed_variables[ code->arg ]; |
| assert( code->arg < frame->module->num_fixed_variables ); |
| list_free( *ptr ); |
| *ptr = value; |
| break; |
| } |
| |
| case INSTR_PUSH_LOCAL_GROUP: |
| { |
| LIST * const value = stack_pop( s ); |
| LISTITER iter; |
| LISTITER end; |
| l = stack_pop( s ); |
| for ( iter = list_begin( l ), end = list_end( l ); iter != end; |
| iter = list_next( iter ) ) |
| stack_push( s, function_swap_named_variable( function, frame, |
| list_item( iter ), list_copy( value ) ) ); |
| list_free( value ); |
| stack_push( s, l ); |
| break; |
| } |
| |
| case INSTR_POP_LOCAL_GROUP: |
| { |
| LISTITER iter; |
| LISTITER end; |
| r = stack_pop( s ); |
| l = list_reverse( r ); |
| list_free( r ); |
| for ( iter = list_begin( l ), end = list_end( l ); iter != end; |
| iter = list_next( iter ) ) |
| function_set_named_variable( function, frame, list_item( iter ), |
| stack_pop( s ) ); |
| list_free( l ); |
| break; |
| } |
| |
| /* |
| * on $(TARGET) variables |
| */ |
| |
| case INSTR_PUSH_ON: |
| { |
| LIST * targets = stack_top( s ); |
| if ( !list_empty( targets ) ) |
| { |
| /* FIXME: push the state onto the stack instead of using |
| * pushsettings. |
| */ |
| TARGET * t = bindtarget( list_front( targets ) ); |
| pushsettings( frame->module, t->settings ); |
| } |
| else |
| { |
| /* [ on $(TARGET) ... ] is ignored if $(TARGET) is empty. */ |
| list_free( stack_pop( s ) ); |
| stack_push( s, L0 ); |
| code += code->arg; |
| } |
| break; |
| } |
| |
| case INSTR_POP_ON: |
| { |
| LIST * result = stack_pop( s ); |
| LIST * targets = stack_pop( s ); |
| if ( !list_empty( targets ) ) |
| { |
| TARGET * t = bindtarget( list_front( targets ) ); |
| popsettings( frame->module, t->settings ); |
| } |
| list_free( targets ); |
| stack_push( s, result ); |
| break; |
| } |
| |
| case INSTR_SET_ON: |
| { |
| LIST * targets = stack_pop( s ); |
| LIST * value = stack_pop( s ); |
| LIST * vars = stack_pop( s ); |
| LISTITER iter = list_begin( targets ); |
| LISTITER const end = list_end( targets ); |
| for ( ; iter != end; iter = list_next( iter ) ) |
| { |
| TARGET * t = bindtarget( list_item( iter ) ); |
| LISTITER vars_iter = list_begin( vars ); |
| LISTITER const vars_end = list_end( vars ); |
| for ( ; vars_iter != vars_end; vars_iter = list_next( vars_iter |
| ) ) |
| t->settings = addsettings( t->settings, VAR_SET, list_item( |
| vars_iter ), list_copy( value ) ); |
| } |
| list_free( vars ); |
| list_free( targets ); |
| stack_push( s, value ); |
| break; |
| } |
| |
| case INSTR_APPEND_ON: |
| { |
| LIST * targets = stack_pop( s ); |
| LIST * value = stack_pop( s ); |
| LIST * vars = stack_pop( s ); |
| LISTITER iter = list_begin( targets ); |
| LISTITER const end = list_end( targets ); |
| for ( ; iter != end; iter = list_next( iter ) ) |
| { |
| TARGET * const t = bindtarget( list_item( iter ) ); |
| LISTITER vars_iter = list_begin( vars ); |
| LISTITER const vars_end = list_end( vars ); |
| for ( ; vars_iter != vars_end; vars_iter = list_next( vars_iter |
| ) ) |
| t->settings = addsettings( t->settings, VAR_APPEND, |
| list_item( vars_iter ), list_copy( value ) ); |
| } |
| list_free( vars ); |
| list_free( targets ); |
| stack_push( s, value ); |
| break; |
| } |
| |
| case INSTR_DEFAULT_ON: |
| { |
| LIST * targets = stack_pop( s ); |
| LIST * value = stack_pop( s ); |
| LIST * vars = stack_pop( s ); |
| LISTITER iter = list_begin( targets ); |
| LISTITER const end = list_end( targets ); |
| for ( ; iter != end; iter = list_next( iter ) ) |
| { |
| TARGET * t = bindtarget( list_item( iter ) ); |
| LISTITER vars_iter = list_begin( vars ); |
| LISTITER const vars_end = list_end( vars ); |
| for ( ; vars_iter != vars_end; vars_iter = list_next( vars_iter |
| ) ) |
| t->settings = addsettings( t->settings, VAR_DEFAULT, |
| list_item( vars_iter ), list_copy( value ) ); |
| } |
| list_free( vars ); |
| list_free( targets ); |
| stack_push( s, value ); |
| break; |
| } |
| |
| /* [ on $(target) return $(variable) ] */ |
| case INSTR_GET_ON: |
| { |
| LIST * targets = stack_pop( s ); |
| LIST * result = L0; |
| if ( !list_empty( targets ) ) |
| { |
| OBJECT * varname = function->constants[ code->arg ]; |
| TARGET * t = bindtarget( list_front( targets ) ); |
| SETTINGS * s = t->settings; |
| int found = 0; |
| for ( ; s != 0; s = s->next ) |
| { |
| if ( object_equal( s->symbol, varname ) ) |
| { |
| result = s->value; |
| found = 1; |
| break; |
| } |
| } |
| if ( !found ) |
| { |
| result = var_get( frame->module, varname ) ; |
| } |
| } |
| stack_push( s, list_copy( result ) ); |
| break; |
| } |
| |
| /* |
| * Variable setting |
| */ |
| |
| case INSTR_SET: |
| function_set_variable( function, frame, code->arg, |
| stack_pop( s ) ); |
| break; |
| |
| case INSTR_APPEND: |
| function_append_variable( function, frame, code->arg, |
| stack_pop( s ) ); |
| break; |
| |
| case INSTR_DEFAULT: |
| function_default_variable( function, frame, code->arg, |
| stack_pop( s ) ); |
| break; |
| |
| case INSTR_SET_FIXED: |
| { |
| LIST * * ptr = &frame->module->fixed_variables[ code->arg ]; |
| assert( code->arg < frame->module->num_fixed_variables ); |
| list_free( *ptr ); |
| *ptr = stack_pop( s ); |
| break; |
| } |
| |
| case INSTR_APPEND_FIXED: |
| { |
| LIST * * ptr = &frame->module->fixed_variables[ code->arg ]; |
| assert( code->arg < frame->module->num_fixed_variables ); |
| *ptr = list_append( *ptr, stack_pop( s ) ); |
| break; |
| } |
| |
| case INSTR_DEFAULT_FIXED: |
| { |
| LIST * * ptr = &frame->module->fixed_variables[ code->arg ]; |
| LIST * value = stack_pop( s ); |
| assert( code->arg < frame->module->num_fixed_variables ); |
| if ( list_empty( *ptr ) ) |
| *ptr = value; |
| else |
| list_free( value ); |
| break; |
| } |
| |
| case INSTR_SET_GROUP: |
| { |
| LIST * value = stack_pop( s ); |
| LIST * vars = stack_pop( s ); |
| LISTITER iter = list_begin( vars ); |
| LISTITER const end = list_end( vars ); |
| for ( ; iter != end; iter = list_next( iter ) ) |
| function_set_named_variable( function, frame, list_item( iter ), |
| list_copy( value ) ); |
| list_free( vars ); |
| list_free( value ); |
| break; |
| } |
| |
| case INSTR_APPEND_GROUP: |
| { |
| LIST * value = stack_pop( s ); |
| LIST * vars = stack_pop( s ); |
| LISTITER iter = list_begin( vars ); |
| LISTITER const end = list_end( vars ); |
| for ( ; iter != end; iter = list_next( iter ) ) |
| function_append_named_variable( function, frame, list_item( iter |
| ), list_copy( value ) ); |
| list_free( vars ); |
| list_free( value ); |
| break; |
| } |
| |
| case INSTR_DEFAULT_GROUP: |
| { |
| LIST * value = stack_pop( s ); |
| LIST * vars = stack_pop( s ); |
| LISTITER iter = list_begin( vars ); |
| LISTITER const end = list_end( vars ); |
| for ( ; iter != end; iter = list_next( iter ) ) |
| function_default_named_variable( function, frame, list_item( |
| iter ), list_copy( value ) ); |
| list_free( vars ); |
| list_free( value ); |
| break; |
| } |
| |
| /* |
| * Rules |
| */ |
| |
| case INSTR_CALL_RULE: |
| { |
| char const * unexpanded = object_str( function_get_constant( |
| function, code[ 1 ].op_code ) ); |
| LIST * result = function_call_rule( function, frame, s, code->arg, |
| unexpanded, function->file, code[ 1 ].arg ); |
| stack_push( s, result ); |
| ++code; |
| break; |
| } |
| |
| case INSTR_CALL_MEMBER_RULE: |
| { |
| OBJECT * rule_name = function_get_constant( function, code[1].op_code ); |
| LIST * result = function_call_member_rule( function, frame, s, code->arg, rule_name, function->file, code[1].arg ); |
| stack_push( s, result ); |
| ++code; |
| break; |
| } |
| |
| case INSTR_RULE: |
| function_set_rule( function, frame, s, code->arg ); |
| break; |
| |
| case INSTR_ACTIONS: |
| function_set_actions( function, frame, s, code->arg ); |
| break; |
| |
| /* |
| * Variable expansion |
| */ |
| |
| case INSTR_APPLY_MODIFIERS: |
| { |
| int n; |
| int i; |
| l = stack_pop( s ); |
| n = expand_modifiers( s, code->arg ); |
| stack_push( s, l ); |
| l = apply_modifiers( s, n ); |
| list_free( stack_pop( s ) ); |
| stack_deallocate( s, n * sizeof( VAR_EDITS ) ); |
| for ( i = 0; i < code->arg; ++i ) |
| list_free( stack_pop( s ) ); /* pop modifiers */ |
| stack_push( s, l ); |
| break; |
| } |
| |
| case INSTR_APPLY_INDEX: |
| l = apply_subscript( s ); |
| list_free( stack_pop( s ) ); |
| list_free( stack_pop( s ) ); |
| stack_push( s, l ); |
| break; |
| |
| case INSTR_APPLY_INDEX_MODIFIERS: |
| { |
| int i; |
| int n; |
| l = stack_pop( s ); |
| r = stack_pop( s ); |
| n = expand_modifiers( s, code->arg ); |
| stack_push( s, r ); |
| stack_push( s, l ); |
| l = apply_subscript_and_modifiers( s, n ); |
| list_free( stack_pop( s ) ); |
| list_free( stack_pop( s ) ); |
| stack_deallocate( s, n * sizeof( VAR_EDITS ) ); |
| for ( i = 0; i < code->arg; ++i ) |
| list_free( stack_pop( s ) ); /* pop modifiers */ |
| stack_push( s, l ); |
| break; |
| } |
| |
| case INSTR_APPLY_MODIFIERS_GROUP: |
| { |
| int i; |
| LIST * const vars = stack_pop( s ); |
| int const n = expand_modifiers( s, code->arg ); |
| LIST * result = L0; |
| LISTITER iter = list_begin( vars ); |
| LISTITER const end = list_end( vars ); |
| for ( ; iter != end; iter = list_next( iter ) ) |
| { |
| stack_push( s, function_get_named_variable( function, frame, |
| list_item( iter ) ) ); |
| result = list_append( result, apply_modifiers( s, n ) ); |
| list_free( stack_pop( s ) ); |
| } |
| list_free( vars ); |
| stack_deallocate( s, n * sizeof( VAR_EDITS ) ); |
| for ( i = 0; i < code->arg; ++i ) |
| list_free( stack_pop( s ) ); /* pop modifiers */ |
| stack_push( s, result ); |
| break; |
| } |
| |
| case INSTR_APPLY_INDEX_GROUP: |
| { |
| LIST * vars = stack_pop( s ); |
| LIST * result = L0; |
| LISTITER iter = list_begin( vars ); |
| LISTITER const end = list_end( vars ); |
| for ( ; iter != end; iter = list_next( iter ) ) |
| { |
| stack_push( s, function_get_named_variable( function, frame, |
| list_item( iter ) ) ); |
| result = list_append( result, apply_subscript( s ) ); |
| list_free( stack_pop( s ) ); |
| } |
| list_free( vars ); |
| list_free( stack_pop( s ) ); |
| stack_push( s, result ); |
| break; |
| } |
| |
| case INSTR_APPLY_INDEX_MODIFIERS_GROUP: |
| { |
| int i; |
| LIST * const vars = stack_pop( s ); |
| LIST * const r = stack_pop( s ); |
| int const n = expand_modifiers( s, code->arg ); |
| LIST * result = L0; |
| LISTITER iter = list_begin( vars ); |
| LISTITER const end = list_end( vars ); |
| stack_push( s, r ); |
| for ( ; iter != end; iter = list_next( iter ) ) |
| { |
| stack_push( s, function_get_named_variable( function, frame, |
| list_item( iter ) ) ); |
| result = list_append( result, apply_subscript_and_modifiers( s, |
| n ) ); |
| list_free( stack_pop( s ) ); |
| } |
| list_free( stack_pop( s ) ); |
| list_free( vars ); |
| stack_deallocate( s, n * sizeof( VAR_EDITS ) ); |
| for ( i = 0; i < code->arg; ++i ) |
| list_free( stack_pop( s ) ); /* pop modifiers */ |
| stack_push( s, result ); |
| break; |
| } |
| |
| case INSTR_COMBINE_STRINGS: |
| { |
| size_t const buffer_size = code->arg * sizeof( expansion_item ); |
| LIST * * const stack_pos = stack_get( s ); |
| expansion_item * items = stack_allocate( s, buffer_size ); |
| LIST * result; |
| int i; |
| for ( i = 0; i < code->arg; ++i ) |
| items[ i ].values = stack_pos[ i ]; |
| result = expand( items, code->arg ); |
| stack_deallocate( s, buffer_size ); |
| for ( i = 0; i < code->arg; ++i ) |
| list_free( stack_pop( s ) ); |
| stack_push( s, result ); |
| break; |
| } |
| |
| case INSTR_GET_GRIST: |
| { |
| LIST * vals = stack_pop( s ); |
| LIST * result = L0; |
| LISTITER iter, end; |
| |
| for ( iter = list_begin( vals ), end = list_end( vals ); iter != end; ++iter ) |
| { |
| OBJECT * new_object; |
| const char * value = object_str( list_item( iter ) ); |
| const char * p; |
| if ( value[ 0 ] == '<' && ( p = strchr( value, '>' ) ) ) |
| { |
| if( p[ 1 ] ) |
| new_object = object_new_range( value, p - value + 1 ); |
| else |
| new_object = object_copy( list_item( iter ) ); |
| } |
| else |
| { |
| new_object = object_copy( constant_empty ); |
| } |
| result = list_push_back( result, new_object ); |
| } |
| |
| list_free( vals ); |
| stack_push( s, result ); |
| break; |
| } |
| |
| case INSTR_INCLUDE: |
| { |
| LIST * nt = stack_pop( s ); |
| if ( !list_empty( nt ) ) |
| { |
| TARGET * const t = bindtarget( list_front( nt ) ); |
| list_free( nt ); |
| |
| /* DWA 2001/10/22 - Perforce Jam cleared the arguments here, |
| * which prevented an included file from being treated as part |
| * of the body of a rule. I did not see any reason to do that, |
| * so I lifted the restriction. |
| */ |
| |
| /* Bind the include file under the influence of "on-target" |
| * variables. Though they are targets, include files are not |
| * built with make(). |
| */ |
| |
| pushsettings( root_module(), t->settings ); |
| /* We do not expect that a file to be included is generated by |
| * some action. Therefore, pass 0 as third argument. If the name |
| * resolves to a directory, let it error out. |
| */ |
| object_free( t->boundname ); |
| t->boundname = search( t->name, &t->time, 0, 0 ); |
| popsettings( root_module(), t->settings ); |
| |
| parse_file( t->boundname, frame ); |
| } |
| break; |
| } |
| |
| /* |
| * Classes and modules |
| */ |
| |
| case INSTR_PUSH_MODULE: |
| { |
| LIST * const module_name = stack_pop( s ); |
| module_t * const outer_module = frame->module; |
| frame->module = !list_empty( module_name ) |
| ? bindmodule( list_front( module_name ) ) |
| : root_module(); |
| list_free( module_name ); |
| *(module_t * *)stack_allocate( s, sizeof( module_t * ) ) = |
| outer_module; |
| break; |
| } |
| |
| case INSTR_POP_MODULE: |
| { |
| module_t * const outer_module = *(module_t * *)stack_get( s ); |
| stack_deallocate( s, sizeof( module_t * ) ); |
| frame->module = outer_module; |
| break; |
| } |
| |
| case INSTR_CLASS: |
| { |
| LIST * bases = stack_pop( s ); |
| LIST * name = stack_pop( s ); |
| OBJECT * class_module = make_class_module( name, bases, frame ); |
| |
| module_t * const outer_module = frame->module; |
| frame->module = bindmodule( class_module ); |
| object_free( class_module ); |
| |
| *(module_t * *)stack_allocate( s, sizeof( module_t * ) ) = |
| outer_module; |
| break; |
| } |
| |
| case INSTR_BIND_MODULE_VARIABLES: |
| module_bind_variables( frame->module ); |
| break; |
| |
| case INSTR_APPEND_STRINGS: |
| { |
| string buf[ 1 ]; |
| string_new( buf ); |
| combine_strings( s, code->arg, buf ); |
| stack_push( s, list_new( object_new( buf->value ) ) ); |
| string_free( buf ); |
| break; |
| } |
| |
| case INSTR_WRITE_FILE: |
| { |
| string buf[ 1 ]; |
| char const * out; |
| OBJECT * tmp_filename = 0; |
| int out_debug = DEBUG_EXEC ? 1 : 0; |
| FILE * out_file = 0; |
| string_new( buf ); |
| combine_strings( s, code->arg, buf ); |
| out = object_str( list_front( stack_top( s ) ) ); |
| |
| /* 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; |
| string result[ 1 ]; |
| tmp_filename = path_tmpfile(); |
| string_new( result ); |
| #ifdef OS_NT |
| string_append( result, "type \"" ); |
| #else |
| string_append( result, "cat \"" ); |
| #endif |
| string_append( result, object_str( tmp_filename ) ); |
| string_push_back( result, '\"' ); |
| if ( err_redir ) |
| string_append( result, " 1>&2" ); |
| |
| /* Replace STDXXX with the temporary file. */ |
| list_free( stack_pop( s ) ); |
| stack_push( s, list_new( object_new( result->value ) ) ); |
| out = object_str( tmp_filename ); |
| |
| string_free( result ); |
| |
| /* Make sure temp files created by this get nuked eventually. */ |
| file_remove_atexit( tmp_filename ); |
| } |
| |
| if ( !globs.noexec ) |
| { |
| string out_name[ 1 ]; |
| /* Handle "path to file" filenames. */ |
| 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 ); |
| if ( out_file ) fputs( buf->value, out_file ); |
| if ( out_debug ) fputs( buf->value, stdout ); |
| if ( out_file ) |
| { |
| fflush( out_file ); |
| fclose( out_file ); |
| } |
| string_free( buf ); |
| if ( tmp_filename ) |
| object_free( tmp_filename ); |
| |
| if ( out_debug ) fputc( '\n', stdout ); |
| break; |
| } |
| |
| case INSTR_OUTPUT_STRINGS: |
| { |
| string * const buf = *(string * *)( (char *)stack_get( s ) + ( |
| code->arg * sizeof( LIST * ) ) ); |
| combine_strings( s, code->arg, buf ); |
| break; |
| } |
| |
| } |
| ++code; |
| } |
| } |
| |
| |
| #ifdef HAVE_PYTHON |
| |
| static struct arg_list * arg_list_compile_python( PyObject * bjam_signature, |
| int * num_arguments ) |
| { |
| if ( bjam_signature ) |
| { |
| struct argument_list_compiler c[ 1 ]; |
| struct arg_list * result; |
| Py_ssize_t s; |
| Py_ssize_t i; |
| argument_list_compiler_init( c ); |
| |
| s = PySequence_Size( bjam_signature ); |
| for ( i = 0; i < s; ++i ) |
| { |
| struct argument_compiler arg_comp[ 1 ]; |
| struct arg_list arg; |
| PyObject * v = PySequence_GetItem( bjam_signature, i ); |
| Py_ssize_t j; |
| Py_ssize_t inner; |
| argument_compiler_init( arg_comp ); |
| |
| inner = PySequence_Size( v ); |
| for ( j = 0; j < inner; ++j ) |
| argument_compiler_add( arg_comp, object_new( PyString_AsString( |
| PySequence_GetItem( v, j ) ) ), constant_builtin, -1 ); |
| |
| arg = arg_compile_impl( arg_comp, constant_builtin, -1 ); |
| dynamic_array_push( c->args, arg ); |
| argument_compiler_free( arg_comp ); |
| Py_DECREF( v ); |
| } |
| |
| *num_arguments = c->args->size; |
| result = BJAM_MALLOC( c->args->size * sizeof( struct arg_list ) ); |
| memcpy( result, c->args->data, c->args->size * sizeof( struct arg_list ) |
| ); |
| argument_list_compiler_free( c ); |
| return result; |
| } |
| *num_arguments = 0; |
| return 0; |
| } |
| |
| FUNCTION * function_python( PyObject * function, PyObject * bjam_signature ) |
| { |
| PYTHON_FUNCTION * result = BJAM_MALLOC( sizeof( PYTHON_FUNCTION ) ); |
| |
| result->base.type = FUNCTION_PYTHON; |
| result->base.reference_count = 1; |
| result->base.rulename = 0; |
| result->base.formal_arguments = arg_list_compile_python( bjam_signature, |
| &result->base.num_formal_arguments ); |
| Py_INCREF( function ); |
| result->python_function = function; |
| |
| return (FUNCTION *)result; |
| } |
| |
| |
| static void argument_list_to_python( struct arg_list * formal, int formal_count, |
| FUNCTION * function, FRAME * frame, PyObject * kw ) |
| { |
| LOL * all_actual = frame->args; |
| int i; |
| |
| for ( i = 0; i < formal_count; ++i ) |
| { |
| LIST * actual = lol_get( all_actual, i ); |
| LISTITER actual_iter = list_begin( actual ); |
| LISTITER const actual_end = list_end( actual ); |
| int j; |
| for ( j = 0; j < formal[ i ].size; ++j ) |
| { |
| struct argument * formal_arg = &formal[ i ].args[ j ]; |
| PyObject * value; |
| LIST * l; |
| |
| switch ( formal_arg->flags ) |
| { |
| case ARG_ONE: |
| if ( actual_iter == actual_end ) |
| argument_error( "missing argument", function, frame, |
| formal_arg->arg_name ); |
| type_check_range( formal_arg->type_name, actual_iter, list_next( |
| actual_iter ), frame, function, formal_arg->arg_name ); |
| value = PyString_FromString( object_str( list_item( actual_iter |
| ) ) ); |
| actual_iter = list_next( actual_iter ); |
| break; |
| case ARG_OPTIONAL: |
| if ( actual_iter == actual_end ) |
| value = 0; |
| else |
| { |
| type_check_range( formal_arg->type_name, actual_iter, |
| list_next( actual_iter ), frame, function, |
| formal_arg->arg_name ); |
| value = PyString_FromString( object_str( list_item( |
| actual_iter ) ) ); |
| actual_iter = list_next( actual_iter ); |
| } |
| break; |
| case ARG_PLUS: |
| if ( actual_iter == actual_end ) |
| argument_error( "missing argument", function, frame, |
| formal_arg->arg_name ); |
| /* fallthrough */ |
| case ARG_STAR: |
| type_check_range( formal_arg->type_name, actual_iter, |
| actual_end, frame, function, formal_arg->arg_name ); |
| l = list_copy_range( actual, actual_iter, actual_end ); |
| value = list_to_python( l ); |
| list_free( l ); |
| actual_iter = actual_end; |
| break; |
| case ARG_VARIADIC: |
| return; |
| } |
| |
| if ( value ) |
| { |
| PyObject * key = PyString_FromString( object_str( |
| formal_arg->arg_name ) ); |
| PyDict_SetItem( kw, key, value ); |
| Py_DECREF( key ); |
| Py_DECREF( value ); |
| } |
| } |
| |
| if ( actual_iter != actual_end ) |
| argument_error( "extra argument", function, frame, list_item( |
| actual_iter ) ); |
| } |
| |
| for ( ; i < all_actual->count; ++i ) |
| { |
| LIST * const actual = lol_get( all_actual, i ); |
| if ( !list_empty( actual ) ) |
| argument_error( "extra argument", function, frame, list_front( |
| actual ) ); |
| } |
| } |
| |
| |
| /* Given a Python object, return a string to use in Jam code instead of the said |
| * object. |
| * |
| * If the object is a string, use the string value. |
| * If the object implemenets __jam_repr__ method, use that. |
| * Otherwise return 0. |
| */ |
| |
| OBJECT * python_to_string( PyObject * value ) |
| { |
| if ( PyString_Check( value ) ) |
| return object_new( PyString_AS_STRING( value ) ); |
| |
| /* See if this instance defines the special __jam_repr__ method. */ |
| if ( PyInstance_Check( value ) |
| && PyObject_HasAttrString( value, "__jam_repr__" ) ) |
| { |
| PyObject * repr = PyObject_GetAttrString( value, "__jam_repr__" ); |
| if ( repr ) |
| { |
| PyObject * arguments2 = PyTuple_New( 0 ); |
| PyObject * value2 = PyObject_Call( repr, arguments2, 0 ); |
| Py_DECREF( repr ); |
| Py_DECREF( arguments2 ); |
| if ( PyString_Check( value2 ) ) |
| return object_new( PyString_AS_STRING( value2 ) ); |
| Py_DECREF( value2 ); |
| } |
| } |
| return 0; |
| } |
| |
| |
| static module_t * python_module() |
| { |
| static module_t * python = 0; |
| if ( !python ) |
| python = bindmodule( constant_python ); |
| return python; |
| } |
| |
| |
| static LIST * call_python_function( PYTHON_FUNCTION * function, FRAME * frame ) |
| { |
| LIST * result = 0; |
| PyObject * arguments = 0; |
| PyObject * kw = NULL; |
| int i; |
| PyObject * py_result; |
| FRAME * prev_frame_before_python_call; |
| |
| if ( function->base.formal_arguments ) |
| { |
| arguments = PyTuple_New( 0 ); |
| kw = PyDict_New(); |
| argument_list_to_python( function->base.formal_arguments, |
| function->base.num_formal_arguments, &function->base, frame, kw ); |
| } |
| else |
| { |
| arguments = PyTuple_New( frame->args->count ); |
| for ( i = 0; i < frame->args->count; ++i ) |
| PyTuple_SetItem( arguments, i, list_to_python( lol_get( frame->args, |
| i ) ) ); |
| } |
| |
| frame->module = python_module(); |
| |
| prev_frame_before_python_call = frame_before_python_call; |
| frame_before_python_call = frame; |
| py_result = PyObject_Call( function->python_function, arguments, kw ); |
| frame_before_python_call = prev_frame_before_python_call; |
| Py_DECREF( arguments ); |
| Py_XDECREF( kw ); |
| if ( py_result != NULL ) |
| { |
| if ( PyList_Check( py_result ) ) |
| { |
| int size = PyList_Size( py_result ); |
| int i; |
| for ( i = 0; i < size; ++i ) |
| { |
| OBJECT * s = python_to_string( PyList_GetItem( py_result, i ) ); |
| if ( !s ) |
| fprintf( stderr, |
| "Non-string object returned by Python call.\n" ); |
| else |
| result = list_push_back( result, s ); |
| } |
| } |
| else if ( py_result == Py_None ) |
| { |
| result = L0; |
| } |
| else |
| { |
| OBJECT * const s = python_to_string( py_result ); |
| if ( s ) |
| result = list_new( s ); |
| else |
| /* We have tried all we could. Return empty list. There are |
| * cases, e.g. feature.feature function that should return a |
| * value for the benefit of Python code and which also can be |
| * called by Jam code, where no sensible value can be returned. |
| * We cannot even emit a warning, since there would be a pile of |
| * them. |
| */ |
| result = L0; |
| } |
| |
| Py_DECREF( py_result ); |
| } |
| else |
| { |
| PyErr_Print(); |
| fprintf( stderr, "Call failed\n" ); |
| } |
| |
| return result; |
| } |
| |
| #endif |
| |
| |
| void function_done( void ) |
| { |
| BJAM_FREE( stack ); |
| } |