|
version 1.204.2.8.2.8, 2003/04/02 14:16:18
|
version 1.213, 2004/04/06 14:17:17
|
|
Line 24
|
Line 24
|
| #define YYLEX_PARAM pc |
#define YYLEX_PARAM pc |
| #define YYDEBUG 1 |
#define YYDEBUG 1 |
| #define YYERROR_VERBOSE 1 |
#define YYERROR_VERBOSE 1 |
| #define yyerror(msg) real_yyerror((parse_control *)pc, msg) |
#define yyerror(msg) real_yyerror((Parse_control *)pc, msg) |
| #define YYPRINT(file, type, value) yyprint(file, type, value) |
#define YYPRINT(file, type, value) yyprint(file, type, value) |
| |
|
| |
// includes |
| |
|
| #include "compile_tools.h" |
#include "compile_tools.h" |
| #include "pa_value.h" |
#include "pa_value.h" |
| #include "pa_request.h" |
#include "pa_request.h" |
|
Line 36
|
Line 38
|
| #include "pa_vvoid.h" |
#include "pa_vvoid.h" |
| #include "pa_vmethod_frame.h" |
#include "pa_vmethod_frame.h" |
| |
|
| |
// defines |
| |
|
| #define USE_CONTROL_METHOD_NAME "USE" |
#define USE_CONTROL_METHOD_NAME "USE" |
| |
|
| static int real_yyerror(parse_control *pc, char *s); |
// forwards |
| static void yyprint(FILE *file, int type, YYSTYPE value); |
|
| static int yylex(YYSTYPE *lvalp, void *pc); |
|
| |
|
| |
static int real_yyerror(Parse_control* pc, char* s); |
| |
static void yyprint(FILE* file, int type, YYSTYPE value); |
| |
static int yylex(YYSTYPE* lvalp, void* pc); |
| |
|
| // local convinient inplace typecast & var |
// local convinient inplace typecast & var |
| #undef PC |
#undef PC |
| #define PC (*(parse_control *)pc) |
#define PC (*(Parse_control *)pc) |
| #undef POOL |
#undef POOL |
| #define POOL (*PC.pool) |
#define POOL (*PC.pool) |
| #ifndef DOXYGEN |
#ifndef DOXYGEN |
|
Line 61 static int yylex(YYSTYPE *lvalp, void *p
|
Line 66 static int yylex(YYSTYPE *lvalp, void *p
|
| %token BAD_HEX_LITERAL |
%token BAD_HEX_LITERAL |
| %token BAD_METHOD_DECL_START |
%token BAD_METHOD_DECL_START |
| %token BAD_METHOD_PARAMETER_NAME_CHARACTER |
%token BAD_METHOD_PARAMETER_NAME_CHARACTER |
| %token BAD_MATH_OPERATOR_CHARACTER |
%token BAD_NONWHITESPACE_CHARACTER_IN_EXPLICIT_RESULT_MODE |
| |
|
| %token LAND "&&" |
%token LAND "&&" |
| %token LOR "||" |
%token LOR "||" |
|
Line 114 static int yylex(YYSTYPE *lvalp, void *p
|
Line 119 static int yylex(YYSTYPE *lvalp, void *p
|
| %% |
%% |
| all: |
all: |
| one_big_piece { |
one_big_piece { |
| Method& method=*new Method(/*main_method_name, */Method::CT_ANY, |
Method& method=*new Method(Method::CT_ANY, |
| 0, 0, /*min, max numbered_params_count*/ |
0, 0, /*min, max numbered_params_count*/ |
| 0/*param_names*/, 0/*local_names*/, |
0/*param_names*/, 0/*local_names*/, |
| $1/*parser_code*/, 0/*native_code*/); |
$1/*parser_code*/, 0/*native_code*/); |
| PC.cclass->add_method(main_method_name, method); |
PC.cclass->add_method(PC.alias_method(main_method_name), method); |
| } |
} |
| | methods; |
| methods; |
| |
|
|
Line 131 control_method: '@' STRING '\n'
|
Line 136 control_method: '@' STRING '\n'
|
| maybe_control_strings { |
maybe_control_strings { |
| const String& command=*LA2S(*$2); |
const String& command=*LA2S(*$2); |
| YYSTYPE strings_code=$4; |
YYSTYPE strings_code=$4; |
| if(strings_code->count()<1*2) { |
if(strings_code->count()<1*OPERATIONS_PER_OPVALUE) { |
| strcpy(PC.error, "@"); |
strcpy(PC.error, "@"); |
| strcat(PC.error, command.cstr()); |
strcat(PC.error, command.cstr()); |
| strcat(PC.error, " is empty"); |
strcat(PC.error, " is empty"); |
|
Line 144 control_method: '@' STRING '\n'
|
Line 149 control_method: '@' STRING '\n'
|
| strcat(PC.error, "'"); |
strcat(PC.error, "'"); |
| YYERROR; |
YYERROR; |
| } |
} |
| if(strings_code->count()==1*2) { |
if(strings_code->count()==1*OPERATIONS_PER_OPVALUE) { |
| // new class' name |
// new class' name |
| const String& name=*LA2S(*strings_code); |
const String& name=*LA2S(*strings_code); |
| // creating the class |
// creating the class |
|
Line 154 control_method: '@' STRING '\n'
|
Line 159 control_method: '@' STRING '\n'
|
| // append to request's classes |
// append to request's classes |
| PC.request.classes().put(name, cclass); |
PC.request.classes().put(name, cclass); |
| } else { |
} else { |
| strcpy(PC.error, "@"CLASS_NAME" must contain sole name"); |
strcpy(PC.error, "@"CLASS_NAME" must contain only one line with class name (contains more then one)"); |
| YYERROR; |
YYERROR; |
| } |
} |
| } else if(command==USE_CONTROL_METHOD_NAME) { |
} else if(command==USE_CONTROL_METHOD_NAME) { |
| for(size_t i=0; i<strings_code->count(); i+=2) |
for(size_t i=0; i<strings_code->count(); i+=OPERATIONS_PER_OPVALUE) |
| PC.request.use_file(PC.request.main_class, *LA2S(*strings_code, i)); |
PC.request.use_file(PC.request.main_class, *LA2S(*strings_code, i)); |
| } else if(command==BASE_NAME) { |
} else if(command==BASE_NAME) { |
| if(PC.cclass->base_class()) { // already changed from default? |
if(PC.cclass->base_class()) { // already changed from default? |
|
Line 167 control_method: '@' STRING '\n'
|
Line 172 control_method: '@' STRING '\n'
|
| strcat(PC.error, "'"); |
strcat(PC.error, "'"); |
| YYERROR; |
YYERROR; |
| } |
} |
| if(strings_code->count()==1*2) { |
if(strings_code->count()==1*OPERATIONS_PER_OPVALUE) { |
| const String& base_name=*LA2S(*strings_code); |
const String& base_name=*LA2S(*strings_code); |
| if(Value* base_class_value=PC.request.classes().get(base_name)) { |
if(Value* base_class_value=PC.request.classes().get(base_name)) { |
| // @CLASS == @BASE sanity check |
// @CLASS == @BASE sanity check |
|
Line 204 control_strings: control_string | contro
|
Line 209 control_strings: control_string | contro
|
| control_string: maybe_string '\n'; |
control_string: maybe_string '\n'; |
| maybe_string: empty | STRING; |
maybe_string: empty | STRING; |
| |
|
| code_method: '@' STRING bracketed_maybe_strings maybe_bracketed_strings maybe_comment '\n' |
code_method: '@' STRING bracketed_maybe_strings maybe_bracketed_strings maybe_comment '\n' { |
| maybe_codes { |
PC.explicit_result=false; |
| const String& name=*LA2S(*$2); |
const String& name=*LA2S(*$2); |
| |
|
| YYSTYPE params_names_code=$3; |
YYSTYPE params_names_code=$3; |
| ArrayString* params_names=0; |
ArrayString* params_names=0; |
| if(int size=params_names_code->count()) { |
if(int size=params_names_code->count()) { |
| params_names=new ArrayString; |
params_names=new ArrayString; |
| for(int i=0; i<size; i+=2) |
for(int i=0; i<size; i+=OPERATIONS_PER_OPVALUE) |
| *params_names+=LA2S(*params_names_code, i); |
*params_names+=LA2S(*params_names_code, i); |
| } |
} |
| |
|
|
Line 220 code_method: '@' STRING bracketed_maybe_
|
Line 225 code_method: '@' STRING bracketed_maybe_
|
| ArrayString* locals_names=0; |
ArrayString* locals_names=0; |
| if(int size=locals_names_code->count()) { |
if(int size=locals_names_code->count()) { |
| locals_names=new ArrayString; |
locals_names=new ArrayString; |
| for(int i=0; i<size; i+=2) |
for(int i=0; i<size; i+=OPERATIONS_PER_OPVALUE) { |
| *locals_names+=LA2S(*locals_names_code, i); |
const String* local_name=LA2S(*locals_names_code, i); |
| |
if(*local_name==RESULT_VAR_NAME) |
| |
PC.explicit_result=true; |
| |
else |
| |
*locals_names+=local_name; |
| |
} |
| } |
} |
| |
|
| Method& method=*new Method( |
Method* method=new Method( |
| //name, |
//name, |
| Method::CT_ANY, |
Method::CT_ANY, |
| 0, 0/*min,max numbered_params_count*/, |
0, 0/*min,max numbered_params_count*/, |
| params_names, locals_names, |
params_names, locals_names, |
| $7, 0); |
0/*to be filled later in next {} */, 0); |
| PC.cclass->add_method(name, method); |
PC.cclass->add_method(PC.alias_method(name), *method); |
| |
*reinterpret_cast<Method**>(&$$)=method; |
| |
|
| |
// todo: check [][;result;] |
| |
} maybe_codes { |
| |
// fill in the code |
| |
reinterpret_cast<Method*>($7)->parser_code=$8; |
| }; |
}; |
| |
|
| maybe_bracketed_strings: empty | bracketed_maybe_strings; |
maybe_bracketed_strings: empty | bracketed_maybe_strings; |
|
Line 268 name_without_curly_rdive_read: name_with
|
Line 284 name_without_curly_rdive_read: name_with
|
| ArrayOperation* diving_code=$1; |
ArrayOperation* diving_code=$1; |
| const String* first_name=LA2S(*diving_code); |
const String* first_name=LA2S(*diving_code); |
| // self.xxx... -> xxx... |
// self.xxx... -> xxx... |
| // OP_VALUE+string+OP_GET_ELEMENT+... -> OP_WITH_SELF+... |
// OP_VALUE+origin+string+OP_GET_ELEMENT+... -> OP_WITH_SELF+... |
| if(first_name && *first_name==SELF_ELEMENT_NAME) { |
if(first_name && *first_name==SELF_ELEMENT_NAME) { |
| O(*$$, OP_WITH_SELF); /* stack: starting context */ |
O(*yyval, OP_WITH_SELF); /* stack: starting context */ |
| P(*$$, *diving_code, |
P(*yyval, *diving_code, |
| /* skip over... */ |
/* skip over... */ |
| diving_code->count()>=3?3/*OP_VALUE+string+OP_GET_ELEMENTx*/:2/*OP_+string*/); |
diving_code->count()>=4?4/*OP_VALUE+origin+string+OP_GET_ELEMENTx*/:3/*OP_+origin+string*/); |
| } else { |
} else { |
| O(*$$, OP_WITH_READ); /* stack: starting context */ |
O(*yyval, OP_WITH_READ); /* stack: starting context */ |
| |
|
| // ^if ELEMENT -> ^if ELEMENT_OR_OPERATOR |
// ^if ELEMENT -> ^if ELEMENT_OR_OPERATOR |
| // OP_VALUE+string+OP_GET_ELEMENT. -> OP_VALUE+string+OP_GET_ELEMENT_OR_OPERATOR. |
// OP_VALUE+origin+string+OP_GET_ELEMENT. -> OP_VALUE+origin+string+OP_GET_ELEMENT_OR_OPERATOR. |
| if(PC.in_call_value && diving_code->count()==3) |
if(PC.in_call_value && diving_code->count()==4) |
| diving_code->put(2, OP_GET_ELEMENT_OR_OPERATOR); |
diving_code->put(4-1, OP_GET_ELEMENT_OR_OPERATOR); |
| P(*$$, *diving_code); |
P(*$$, *diving_code); |
| } |
} |
| /* diving code; stack: current context */ |
/* diving code; stack: current context */ |
|
Line 303 name_expr_wdive_root: name_expr_dive_cod
|
Line 319 name_expr_wdive_root: name_expr_dive_cod
|
| ArrayOperation* diving_code=$1; |
ArrayOperation* diving_code=$1; |
| const String* first_name=LA2S(*diving_code); |
const String* first_name=LA2S(*diving_code); |
| // $self.xxx... -> $xxx... |
// $self.xxx... -> $xxx... |
| // OP_VALUE+string+OP_GET_ELEMENT+... -> OP_WITH_SELF+... |
// OP_VALUE+origin+string+OP_GET_ELEMENT+... -> OP_WITH_SELF+... |
| if(first_name && *first_name==SELF_ELEMENT_NAME) { |
if(first_name && *first_name==SELF_ELEMENT_NAME) { |
| O(*$$, OP_WITH_SELF); /* stack: starting context */ |
O(*$$, OP_WITH_SELF); /* stack: starting context */ |
| P(*$$, *diving_code, |
P(*$$, *diving_code, |
| /* skip over... */ |
/* skip over... */ |
| diving_code->count()>=3?3/*OP_VALUE+string+OP_GET_ELEMENTx*/:2/*OP_+string*/); |
diving_code->count()>=4?4/*OP_VALUE+origin+string+OP_GET_ELEMENTx*/:3/*OP_+origin+string*/); |
| } else { |
} else { |
| O(*$$, OP_WITH_ROOT); /* stack: starting context */ |
O(*$$, OP_WITH_ROOT); /* stack: starting context */ |
| P(*$$, *diving_code); |
P(*$$, *diving_code); |
|
Line 327 construct:
|
Line 343 construct:
|
| | construct_round |
| construct_round |
| | construct_curly |
| construct_curly |
| ; |
; |
| construct_square: '[' any_constructor_code_value ']' { |
construct_square: '[' { |
| |
// allow $result_or_other_variable[ letters here any time ] |
| |
*reinterpret_cast<bool*>(&$$)=PC.explicit_result; PC.explicit_result=false; |
| |
} any_constructor_code_value { |
| |
PC.explicit_result=*reinterpret_cast<bool*>(&$2); |
| |
} ']' { |
| // stack: context, name |
// stack: context, name |
| $$=$2; // stack: context, name, value |
$$=$3; // stack: context, name, value |
| O(*$$, OP_CONSTRUCT_VALUE); /* value=pop; name=pop; context=pop; construct(context,name,value) */ |
O(*$$, OP_CONSTRUCT_VALUE); /* value=pop; name=pop; context=pop; construct(context,name,value) */ |
| } |
} |
| ; |
; |
|
Line 379 call_value: '^' {
|
Line 400 call_value: '^' {
|
| $$=$3; /* with_xxx,diving code; stack: context,method_junction */ |
$$=$3; /* with_xxx,diving code; stack: context,method_junction */ |
| |
|
| YYSTYPE params_code=$5; |
YYSTYPE params_code=$5; |
| if(params_code->count()==3) { // probably [] case. [OP_VALUE + Void + STORE_PARAM] |
if(params_code->count()==4) { // probably [] case. [OP_VALUE+origin+Void+STORE_PARAM] |
| if(Value* value=LA2V(*params_code)) // it is OP_VALUE + value? |
if(Value* value=LA2V(*params_code)) // it is OP_VALUE+origin+value? |
| if(!value->is_defined()) // value is VVoid? |
if(!value->is_defined()) // value is VVoid? |
| params_code=0; // ^zzz[] case. don't append lone empty param. |
params_code=0; // ^zzz[] case. don't append lone empty param. |
| } |
} |
|
Line 396 store_param:
|
Line 417 store_param:
|
| | store_round_param |
| store_round_param |
| | store_curly_param |
| store_curly_param |
| ; |
; |
| store_square_param: '[' store_code_param_parts ']' {$$=$2}; |
store_square_param: '[' { |
| |
// allow ^call[ letters here any time ] |
| |
*reinterpret_cast<bool*>(&$$)=PC.explicit_result; PC.explicit_result=false; |
| |
} store_code_param_parts { |
| |
PC.explicit_result=*reinterpret_cast<bool*>(&$2); |
| |
} ']' {$$=$3}; |
| store_round_param: '(' store_expr_param_parts ')' {$$=$2}; |
store_round_param: '(' store_expr_param_parts ')' {$$=$2}; |
| store_curly_param: '{' store_curly_param_parts '}' {$$=$2}; |
store_curly_param: '{' store_curly_param_parts '}' {$$=$2}; |
| store_code_param_parts: |
store_code_param_parts: |
|
Line 475 name_expr_with_subvar_value: STRING subv
|
Line 501 name_expr_with_subvar_value: STRING subv
|
| $$=N(); |
$$=N(); |
| OA(*$$, OP_STRING_POOL, code); |
OA(*$$, OP_STRING_POOL, code); |
| }; |
}; |
| name_square_code_value: '[' codes ']' { |
name_square_code_value: '[' { |
| |
// allow $result_or_other_variable[ letters here any time ] |
| |
*reinterpret_cast<bool*>(&$$)=PC.explicit_result; PC.explicit_result=false; |
| |
} codes { |
| |
PC.explicit_result=*reinterpret_cast<bool*>(&$2); |
| |
} ']' { |
| $$=N(); |
$$=N(); |
| OA(*$$, OP_OBJECT_POOL, $2); /* stack: empty write context */ |
OA(*$$, OP_OBJECT_POOL, $3); /* stack: empty write context */ |
| /* some code that writes to that context */ |
/* some code that writes to that context */ |
| /* context=pop; stack: context.value() */ |
/* context=pop; stack: context.value() */ |
| }; |
}; |
|
Line 607 empty: /* empty */ { $$=N() };
|
Line 638 empty: /* empty */ { $$=N() };
|
| 4:[^({]=pop |
4:[^({]=pop |
| */ |
*/ |
| |
|
| static int yylex(YYSTYPE *lvalp, void *pc) { |
inline void ungetc(Parse_control& pc, uint last_line_end_col) { |
| #define lexical_brackets_nestage PC.brackets_nestages[PC.ls_sp] |
pc.source--; |
| |
if(pc.pos.col==0) { |
| |
--pc.pos.line; pc.pos.col=last_line_end_col; |
| |
} else |
| |
--pc.pos.col; |
| |
|
| |
} |
| |
static int yylex(YYSTYPE *lvalp, void *apc) { |
| |
register Parse_control& pc=*static_cast<Parse_control*>(apc); |
| |
|
| |
#define lexical_brackets_nestage pc.brackets_nestages[pc.ls_sp] |
| #define RC {result=c; goto break2; } |
#define RC {result=c; goto break2; } |
| |
|
| register int c; |
register int c; |
| int result; |
int result; |
| |
|
| if(PC.pending_state) { |
if(pc.pending_state) { |
| result=PC.pending_state; |
result=pc.pending_state; |
| PC.pending_state=0; |
pc.pending_state=0; |
| return result; |
return result; |
| } |
} |
| |
|
| const char *begin=PC.source; |
const char *begin=pc.source; |
| |
Pos begin_pos=pc.pos; |
| const char *end; |
const char *end; |
| int begin_line=PC.line; |
|
| int skip_analized=0; |
int skip_analized=0; |
| while(true) { |
while(true) { |
| c=*(end=(PC.source++)); |
c=*(end=(pc.source++)); |
| // fprintf(stderr, "\nchar: %c %02X; nestage: %d, sp=%d", c, c, lexical_brackets_nestage, PC.sp); |
// fprintf(stderr, "\nchar: %c %02X; nestage: %d, sp=%d", c, c, lexical_brackets_nestage, pc.sp); |
| |
|
| if(c=='\n') { |
if(c=='\n') |
| PC.line++; |
pc.pos_next_line(); |
| PC.col=0; |
else |
| } else |
pc.pos_next_c(c); |
| PC.col++; |
// fprintf(stderr, "\nchar: %c file(%d:%d)", c, pc.pos.line, pc.pos.col); |
| |
|
| if(c=='@' && PC.col==0+1) { |
if(pc.pos.col==0+1 && c=='@') { |
| if(PC.ls==LS_DEF_SPECIAL_BODY) { |
if(pc.ls==LS_DEF_SPECIAL_BODY) { |
| // @SPECIAL |
// @SPECIAL |
| // ... |
// ... |
| // @<here = |
// @<here = |
| pop_LS(PC); // exiting from LS_DEF_SPECIAL_BODY state |
pop_LS(pc); // exiting from LS_DEF_SPECIAL_BODY state |
| } // continuing checks |
} // continuing checks |
| if(PC.ls==LS_USER) { |
if(pc.ls==LS_USER) { |
| push_LS(PC, LS_DEF_NAME); |
push_LS(pc, LS_DEF_NAME); |
| RC; |
RC; |
| } else // @ in first column inside some code [when could that be?] |
} else // @ in first column inside some code [when could that be?] |
| result=BAD_METHOD_DECL_START; |
result=BAD_METHOD_DECL_START; |
| goto break2; |
goto break2; |
| } else if(c=='^') { |
} |
| if(PC.ls==LS_METHOD_AFTER) { |
if(c=='^') { |
| |
if(pc.ls==LS_METHOD_AFTER) { |
| // handle after-method situation |
// handle after-method situation |
| pop_LS(PC); |
pop_LS(pc); |
| result=EON; |
result=EON; |
| skip_analized=-1; // return to punctuation afterwards to assure it's literality |
skip_analized=-1; // return to punctuation afterwards to assure it's literality |
| goto break2; |
goto break2; |
| } |
} |
| switch(PC.ls) { |
switch(pc.ls) { |
| case LS_EXPRESSION_VAR_NAME_WITH_COLON: |
case LS_EXPRESSION_VAR_NAME_WITH_COLON: |
| case LS_EXPRESSION_VAR_NAME_WITHOUT_COLON: |
case LS_EXPRESSION_VAR_NAME_WITHOUT_COLON: |
| case LS_VAR_NAME_SIMPLE_WITH_COLON: |
case LS_VAR_NAME_SIMPLE_WITH_COLON: |
|
Line 667 case LS_DEF_COMMENT:
|
Line 709 case LS_DEF_COMMENT:
|
| // no literals in names, please |
// no literals in names, please |
| break; |
break; |
| default: |
default: |
| switch(*PC.source) { |
switch(*pc.source) { |
| // ^escaping some punctuators |
// ^escaping some punctuators |
| case '^': case '$': case ';': |
case '^': case '$': case ';': |
| case '(': case ')': |
case '(': case ')': |
|
Line 675 default:
|
Line 717 default:
|
| case '{': case '}': |
case '{': case '}': |
| case '"': case ':': |
case '"': case ':': |
| if(end!=begin) { |
if(end!=begin) { |
| |
if(!pc.string_start) |
| |
pc.string_start=begin_pos; |
| // append piece till ^ |
// append piece till ^ |
| PC.string.append_strdup(begin, end-begin); |
pc.string.append_strdup_know_length(begin, end-begin); |
| } |
} |
| // reset piece 'begin' position & line |
// reset piece 'begin' position & line |
| begin=PC.source; // ->punctuation |
begin=pc.source; // ->punctuation |
| begin_line=PC.line; |
begin_pos=pc.pos; |
| // skip over _ after ^ |
// skip over _ after ^ |
| PC.source++; PC.col++; |
pc.source++; pc.pos.col++; |
| // skip analysis = forced literal |
// skip analysis = forced literal |
| continue; |
continue; |
| |
|
| // converting ^#HH into char(hex(HH)) |
// converting ^#HH into char(hex(HH)) |
| case '#': |
case '#': |
| if(end!=begin) { |
if(end!=begin) { |
| |
if(!pc.string_start) |
| |
pc.string_start=begin_pos; |
| // append piece till ^ |
// append piece till ^ |
| PC.string.append_strdup(begin, end-begin); |
pc.string.append_strdup_know_length(begin, end-begin); |
| } |
} |
| // #HH ? |
// #HH ? |
| if(PC.source[0]=='#' && PC.source[1] && PC.source[2]) { |
if(pc.source[0]=='#' && pc.source[1] && pc.source[2]) { |
| char c= |
char c= |
| hex_value[(unsigned char)PC.source[1]]*0x10+ |
hex_value[(unsigned char)pc.source[1]]*0x10+ |
| hex_value[(unsigned char)PC.source[2]]; |
hex_value[(unsigned char)pc.source[2]]; |
| if(c==0) { |
if(c==0) { |
| result=BAD_HEX_LITERAL; |
result=BAD_HEX_LITERAL; |
| goto break2; // wrong hex value[no ^#00 chars allowed]: bail out |
goto break2; // wrong hex value[no ^#00 chars allowed]: bail out |
| } |
} |
| // append char(hex(HH)) |
// append char(hex(HH)) |
| PC.string.append(c); |
pc.string.append(c); |
| // skip over ^#HH |
// skip over ^#HH |
| PC.source+=3; |
pc.source+=3; |
| PC.col+=3; |
pc.pos.col+=3; |
| // reset piece 'begin' position & line |
// reset piece 'begin' position & line |
| begin=PC.source; // ->after ^#HH |
begin=pc.source; // ->after ^#HH |
| begin_line=PC.line; |
begin_pos=pc.pos; |
| // skip analysis = forced literal |
// skip analysis = forced literal |
| continue; |
continue; |
| } |
} |
|
Line 718 default:
|
Line 764 default:
|
| } |
} |
| } |
} |
| // #comment start skipping |
// #comment start skipping |
| if(c=='#' && PC.col==1) { |
if(c=='#' && pc.pos.col==1) { |
| if(end!=begin) { |
if(end!=begin) { |
| |
if(!pc.string_start) |
| |
pc.string_start=begin_pos; |
| // append piece till # |
// append piece till # |
| PC.string.append_strdup(begin, end-begin); |
pc.string.append_strdup_know_length(begin, end-begin); |
| } |
} |
| // fall into COMMENT lexical state [wait for \n] |
// fall into COMMENT lexical state [wait for \n] |
| push_LS(PC, LS_USER_COMMENT); |
push_LS(pc, LS_USER_COMMENT); |
| continue; |
continue; |
| } |
} |
| switch(PC.ls) { |
switch(pc.ls) { |
| |
|
| // USER'S = NOT OURS |
// USER'S = NOT OURS |
| case LS_USER: |
case LS_USER: |
| case LS_NAME_SQUARE_PART: // name.[here].xxx |
case LS_NAME_SQUARE_PART: // name.[here].xxx |
| if(PC.trim_bof) |
if(pc.trim_bof) |
| switch(c) { |
switch(c) { |
| case '\n': case ' ': case '\t': |
case '\n': case ' ': case '\t': |
| begin=PC.source; |
begin=pc.source; |
| begin_line=PC.line; |
begin_pos=pc.pos; |
| continue; // skip it |
continue; // skip it |
| default: |
default: |
| PC.trim_bof=false; |
pc.trim_bof=false; |
| } |
} |
| switch(c) { |
switch(c) { |
| case '$': |
case '$': |
| push_LS(PC, LS_VAR_NAME_SIMPLE_WITH_COLON); |
push_LS(pc, LS_VAR_NAME_SIMPLE_WITH_COLON); |
| RC; |
RC; |
| case '^': |
case '^': |
| push_LS(PC, LS_METHOD_NAME); |
push_LS(pc, LS_METHOD_NAME); |
| RC; |
RC; |
| case ']': |
case ']': |
| if(PC.ls==LS_NAME_SQUARE_PART) |
if(pc.ls==LS_NAME_SQUARE_PART) |
| if(--lexical_brackets_nestage==0) {// $name.[co<]?>de<]?> |
if(--lexical_brackets_nestage==0) {// $name.[co<]?>de<]?> |
| pop_LS(PC); // $name.[co<]>de<]!> |
pop_LS(pc); // $name.[co<]>de<]!> |
| RC; |
RC; |
| } |
} |
| break; |
break; |
| case '[': // $name.[co<[>de] |
case '[': // $name.[co<[>de] |
| if(PC.ls==LS_NAME_SQUARE_PART) |
if(pc.ls==LS_NAME_SQUARE_PART) |
| lexical_brackets_nestage++; |
lexical_brackets_nestage++; |
| break; |
break; |
| } |
} |
| |
if(pc.explicit_result && c) |
| |
switch(c) { |
| |
case '\n': case ' ': case '\t': |
| |
begin=pc.source; |
| |
begin_pos=pc.pos; |
| |
continue; // skip it |
| |
default: |
| |
result=BAD_NONWHITESPACE_CHARACTER_IN_EXPLICIT_RESULT_MODE; |
| |
goto break2; |
| |
} |
| break; |
break; |
| |
|
| // #COMMENT |
// #COMMENT |
| case LS_USER_COMMENT: |
case LS_USER_COMMENT: |
| if(c=='\n') { |
if(c=='\n') { |
| // skip comment |
// skip comment |
| begin=PC.source; |
begin=pc.source; |
| begin_line=PC.line; |
begin_pos=pc.pos; |
| |
|
| pop_LS(PC); |
pop_LS(pc); |
| continue; |
continue; |
| } |
} |
| break; |
break; |
|
Line 781 default:
|
Line 839 default:
|
| case '"': |
case '"': |
| case '\'': |
case '\'': |
| if( |
if( |
| PC.ls == LS_EXPRESSION_STRING_QUOTED && c=='"' || |
pc.ls == LS_EXPRESSION_STRING_QUOTED && c=='"' || |
| PC.ls == LS_EXPRESSION_STRING_APOSTROFED && c=='\'') { |
pc.ls == LS_EXPRESSION_STRING_APOSTROFED && c=='\'') { |
| pop_LS(PC); //"abc". | 'abc'. |
pop_LS(pc); //"abc". | 'abc'. |
| RC; |
RC; |
| } |
} |
| break; |
break; |
| case '$': |
case '$': |
| push_LS(PC, LS_VAR_NAME_SIMPLE_WITH_COLON); |
push_LS(pc, LS_VAR_NAME_SIMPLE_WITH_COLON); |
| RC; |
RC; |
| case '^': |
case '^': |
| push_LS(PC, LS_METHOD_NAME); |
push_LS(pc, LS_METHOD_NAME); |
| RC; |
RC; |
| } |
} |
| break; |
break; |
|
Line 800 default:
|
Line 858 default:
|
| case LS_DEF_NAME: |
case LS_DEF_NAME: |
| switch(c) { |
switch(c) { |
| case '[': |
case '[': |
| PC.ls=LS_DEF_PARAMS; |
pc.ls=LS_DEF_PARAMS; |
| RC; |
RC; |
| case '\n': |
case '\n': |
| PC.ls=LS_DEF_SPECIAL_BODY; |
pc.ls=LS_DEF_SPECIAL_BODY; |
| RC; |
RC; |
| } |
} |
| break; |
break; |
|
Line 816 default:
|
Line 874 default:
|
| case ';': |
case ';': |
| RC; |
RC; |
| case ']': |
case ']': |
| PC.ls=*PC.source=='['?LS_DEF_LOCALS:LS_DEF_COMMENT; |
pc.ls=*pc.source=='['?LS_DEF_LOCALS:LS_DEF_COMMENT; |
| RC; |
RC; |
| case '\n': // wrong. bailing out |
case '\n': // wrong. bailing out |
| pop_LS(PC); |
pop_LS(pc); |
| RC; |
RC; |
| } |
} |
| break; |
break; |
|
Line 830 default:
|
Line 888 default:
|
| case ';': |
case ';': |
| RC; |
RC; |
| case ']': |
case ']': |
| PC.ls=LS_DEF_COMMENT; |
pc.ls=LS_DEF_COMMENT; |
| RC; |
RC; |
| case '\n': // wrong. bailing out |
case '\n': // wrong. bailing out |
| pop_LS(PC); |
pop_LS(pc); |
| RC; |
RC; |
| } |
} |
| break; |
break; |
| |
|
| case LS_DEF_COMMENT: |
case LS_DEF_COMMENT: |
| if(c=='\n') { |
if(c=='\n') { |
| pop_LS(PC); |
pop_LS(pc); |
| RC; |
RC; |
| } |
} |
| break; |
break; |
|
Line 856 default:
|
Line 914 default:
|
| switch(c) { |
switch(c) { |
| case ')': |
case ')': |
| if(--lexical_brackets_nestage==0) |
if(--lexical_brackets_nestage==0) |
| if(PC.ls==LS_METHOD_ROUND) // method round param ended |
if(pc.ls==LS_METHOD_ROUND) // method round param ended |
| PC.ls=LS_METHOD_AFTER; // look for method end |
pc.ls=LS_METHOD_AFTER; // look for method end |
| else // PC.ls==LS_VAR_ROUND // variable constructor ended |
else // pc.ls==LS_VAR_ROUND // variable constructor ended |
| pop_LS(PC); // return to normal life |
pop_LS(pc); // return to normal life |
| RC; |
RC; |
| case '#': // comment start skipping |
case '#': // comment start skipping |
| if(end!=begin) { |
if(end!=begin) { |
| |
if(!pc.string_start) |
| |
pc.string_start=begin_pos; |
| // append piece till # |
// append piece till # |
| PC.string.append_strdup(begin, end-begin); |
pc.string.append_strdup_know_length(begin, end-begin); |
| } |
} |
| // fall into COMMENT lexical state [wait for \n] |
// fall into COMMENT lexical state [wait for \n] |
| push_LS(PC, LS_EXPRESSION_COMMENT); |
push_LS(pc, LS_EXPRESSION_COMMENT); |
| lexical_brackets_nestage=1; |
lexical_brackets_nestage=1; |
| continue; |
continue; |
| case '$': |
case '$': |
| push_LS(PC, LS_EXPRESSION_VAR_NAME_WITH_COLON); |
push_LS(pc, LS_EXPRESSION_VAR_NAME_WITH_COLON); |
| RC; |
RC; |
| case '^': |
case '^': |
| push_LS(PC, LS_METHOD_NAME); |
push_LS(pc, LS_METHOD_NAME); |
| RC; |
RC; |
| case '(': |
case '(': |
| lexical_brackets_nestage++; |
lexical_brackets_nestage++; |
| RC; |
RC; |
| case '-': |
case '-': |
| switch(*PC.source) { |
switch(*pc.source) { |
| case 'f': // -f |
case 'f': // -f |
| skip_analized=1; |
skip_analized=1; |
| result=FEXISTS; |
result=FEXISTS; |
|
Line 899 default:
|
Line 959 default:
|
| case ';': |
case ';': |
| RC; |
RC; |
| case '&': case '|': |
case '&': case '|': |
| if(*PC.source==c) { // && || |
if(*pc.source==c) { // && || |
| result=c=='&'?LAND:LOR; |
result=c=='&'?LAND:LOR; |
| skip_analized=1; |
skip_analized=1; |
| } else |
} else |
| result=c; |
result=c; |
| goto break2; |
goto break2; |
| case '!': |
case '!': |
| switch(PC.source[0]) { |
switch(pc.source[0]) { |
| case '|': // !| !|| |
case '|': // !| !|| |
| skip_analized=1; |
skip_analized=1; |
| if(PC.source[1]=='|') { |
if(pc.source[1]=='|') { |
| skip_analized++; |
skip_analized++; |
| result=LXOR; |
result=LXOR; |
| } else |
} else |
|
Line 923 default:
|
Line 983 default:
|
| RC; |
RC; |
| |
|
| case '<': // <<, <=, < |
case '<': // <<, <=, < |
| switch(*PC.source) { |
switch(*pc.source) { |
| case '<': // <[<] |
case '<': // <[<] |
| skip_analized=1; result=NSL; break; |
skip_analized=1; result=NSL; break; |
| case '=': // <[=] |
case '=': // <[=] |
|
Line 933 default:
|
Line 993 default:
|
| } |
} |
| goto break2; |
goto break2; |
| case '>': // >>, >=, > |
case '>': // >>, >=, > |
| switch(*PC.source) { |
switch(*pc.source) { |
| case '>': // >[>] |
case '>': // >[>] |
| skip_analized=1; result=NSR; break; |
skip_analized=1; result=NSR; break; |
| case '=': // >[=] |
case '=': // >[=] |
|
Line 943 default:
|
Line 1003 default:
|
| } |
} |
| goto break2; |
goto break2; |
| case '=': // == |
case '=': // == |
| switch(*PC.source) { |
switch(*pc.source) { |
| case '=': // =[=] |
case '=': // =[=] |
| skip_analized=1; result=NEQ; break; |
skip_analized=1; result=NEQ; break; |
| default: // =[] |
default: // =[] |
|
Line 952 default:
|
Line 1012 default:
|
| goto break2; |
goto break2; |
| |
|
| case '"': |
case '"': |
| push_LS(PC, LS_EXPRESSION_STRING_QUOTED); |
push_LS(pc, LS_EXPRESSION_STRING_QUOTED); |
| RC; |
RC; |
| case '\'': |
case '\'': |
| push_LS(PC, LS_EXPRESSION_STRING_APOSTROFED); |
push_LS(pc, LS_EXPRESSION_STRING_APOSTROFED); |
| RC; |
RC; |
| case 'l': case 'g': case 'e': case 'n': |
case 'l': case 'g': case 'e': case 'n': |
| if(end==begin) // right after whitespace |
if(end==begin) // right after whitespace |
| if(isspace(PC.source[1])) { |
if(isspace(pc.source[1])) { |
| switch(*PC.source) { |
switch(*pc.source) { |
| // case '?': // ok [and bad cases, yacc would bark at them] |
// case '?': // ok [and bad cases, yacc would bark at them] |
| case 't': // lt gt [et nt] |
case 't': // lt gt [et nt] |
| result=c=='l'?SLT:c=='g'?SGT:BAD_STRING_COMPARISON_OPERATOR; |
result=c=='l'?SLT:c=='g'?SGT:BAD_STRING_COMPARISON_OPERATOR; |
|
Line 979 default:
|
Line 1039 default:
|
| break; |
break; |
| case 'i': |
case 'i': |
| if(end==begin) // right after whitespace |
if(end==begin) // right after whitespace |
| if(isspace(PC.source[1])) { |
if(isspace(pc.source[1])) { |
| switch(PC.source[0]) { |
switch(pc.source[0]) { |
| case 'n': // in |
case 'n': // in |
| skip_analized=1; |
skip_analized=1; |
| result=IN; |
result=IN; |
|
Line 994 default:
|
Line 1054 default:
|
| break; |
break; |
| case 'd': |
case 'd': |
| if(end==begin) // right after whitespace |
if(end==begin) // right after whitespace |
| if(PC.source[0]=='e' && PC.source[1]=='f') { // def |
if(pc.source[0]=='e' && pc.source[1]=='f') { // def |
| skip_analized=2; |
skip_analized=2; |
| result=DEF; |
result=DEF; |
| goto break2; |
goto break2; |
|
Line 1008 default:
|
Line 1068 default:
|
| // that's a leading|traling space or after-operator-space |
// that's a leading|traling space or after-operator-space |
| // ignoring it |
// ignoring it |
| // reset piece 'begin' position & line |
// reset piece 'begin' position & line |
| begin=PC.source; // after whitespace char |
begin=pc.source; // after whitespace char |
| begin_line=PC.line; |
begin_pos=pc.pos; |
| continue; |
continue; |
| } |
} |
| break; |
break; |
|
Line 1017 default:
|
Line 1077 default:
|
| if(c=='(') |
if(c=='(') |
| lexical_brackets_nestage++; |
lexical_brackets_nestage++; |
| |
|
| switch(*PC.source) { |
switch(*pc.source) { |
| case '\n': case ')': |
case '\n': case ')': |
| if(*PC.source==')') |
if(*pc.source==')') |
| if(--lexical_brackets_nestage!=0) |
if(--lexical_brackets_nestage!=0) |
| continue; |
continue; |
| |
|
| // skip comment |
// skip comment |
| begin=PC.source; |
begin=pc.source; |
| begin_line=PC.line; |
begin_pos=pc.pos; |
| |
|
| pop_LS(PC); |
pop_LS(pc); |
| continue; |
continue; |
| } |
} |
| break; |
break; |
|
Line 1038 default:
|
Line 1098 default:
|
| case LS_EXPRESSION_VAR_NAME_WITH_COLON: |
case LS_EXPRESSION_VAR_NAME_WITH_COLON: |
| case LS_EXPRESSION_VAR_NAME_WITHOUT_COLON: |
case LS_EXPRESSION_VAR_NAME_WITHOUT_COLON: |
| if( |
if( |
| PC.ls==LS_EXPRESSION_VAR_NAME_WITH_COLON || |
pc.ls==LS_EXPRESSION_VAR_NAME_WITH_COLON || |
| PC.ls==LS_EXPRESSION_VAR_NAME_WITHOUT_COLON) { |
pc.ls==LS_EXPRESSION_VAR_NAME_WITHOUT_COLON) { |
| // name in expr ends also before |
// name in expr ends also before |
| switch(c) { |
switch(c) { |
| // expression minus |
// expression minus |
| case '-': |
case '-': |
| // expression integer division |
// expression integer division |
| case '\\': |
case '\\': |
| pop_LS(PC); |
pop_LS(pc); |
| PC.source--; if(--PC.col<0) { PC.line--; PC.col=-1; } |
pc.ungetc(); |
| result=EON; |
result=EON; |
| goto break2; |
goto break2; |
| } |
} |
| } |
} |
| if( |
if( |
| PC.ls==LS_VAR_NAME_SIMPLE_WITHOUT_COLON || |
pc.ls==LS_VAR_NAME_SIMPLE_WITHOUT_COLON || |
| PC.ls==LS_EXPRESSION_VAR_NAME_WITHOUT_COLON) { |
pc.ls==LS_EXPRESSION_VAR_NAME_WITHOUT_COLON) { |
| // name already has ':', stop before next |
// name already has ':', stop before next |
| switch(c) { |
switch(c) { |
| case ':': |
case ':': |
| pop_LS(PC); |
pop_LS(pc); |
| PC.source--; if(--PC.col<0) { PC.line--; PC.col=-1; } |
pc.ungetc(); |
| result=EON; |
result=EON; |
| goto break2; |
goto break2; |
| } |
} |
|
Line 1078 default:
|
Line 1138 default:
|
| case ',': case '?': case '#': |
case ',': case '?': case '#': |
| // before call |
// before call |
| case '^': |
case '^': |
| pop_LS(PC); |
pop_LS(pc); |
| PC.source--; if(--PC.col<0) { PC.line--; PC.col=-1; } |
pc.ungetc(); |
| result=EON; |
result=EON; |
| goto break2; |
goto break2; |
| case '[': |
case '[': |
| // $name.<[>code] |
// $name.<[>code] |
| if(PC.col>1/*not first column*/ && ( |
if(pc.pos.col>1/*not first column*/ && ( |
| end[-1]=='$'/*was start of get*/ || |
end[-1]=='$'/*was start of get*/ || |
| end[-1]==':'/*was class name delim */ || |
end[-1]==':'/*was class name delim */ || |
| end[-1]=='.'/*was name delim */ |
end[-1]=='.'/*was name delim */ |
| )) { |
)) { |
| push_LS(PC, LS_NAME_SQUARE_PART); |
push_LS(pc, LS_NAME_SQUARE_PART); |
| lexical_brackets_nestage=1; |
lexical_brackets_nestage=1; |
| RC; |
RC; |
| } |
} |
| PC.ls=LS_VAR_SQUARE; |
pc.ls=LS_VAR_SQUARE; |
| lexical_brackets_nestage=1; |
lexical_brackets_nestage=1; |
| RC; |
RC; |
| case '{': |
case '{': |
| if(begin==end) { // ${name}, no need of EON, switching LS |
if(begin==end) { // ${name}, no need of EON, switching LS |
| PC.ls=LS_VAR_NAME_CURLY; |
pc.ls=LS_VAR_NAME_CURLY; |
| } else { |
} else { |
| PC.ls=LS_VAR_CURLY; |
pc.ls=LS_VAR_CURLY; |
| lexical_brackets_nestage=1; |
lexical_brackets_nestage=1; |
| } |
} |
| |
|
| RC; |
RC; |
| case '(': |
case '(': |
| PC.ls=LS_VAR_ROUND; |
pc.ls=LS_VAR_ROUND; |
| lexical_brackets_nestage=1; |
lexical_brackets_nestage=1; |
| RC; |
RC; |
| case '.': // name part delim |
case '.': // name part delim |
| case '$': // name part subvar |
case '$': // name part subvar |
| case ':': // class<:>name |
case ':': // class<:>name |
| // go to _WITHOUT_COLON state variant... |
// go to _WITHOUT_COLON state variant... |
| if(PC.ls==LS_VAR_NAME_SIMPLE_WITH_COLON) |
if(pc.ls==LS_VAR_NAME_SIMPLE_WITH_COLON) |
| PC.ls=LS_VAR_NAME_SIMPLE_WITHOUT_COLON; |
pc.ls=LS_VAR_NAME_SIMPLE_WITHOUT_COLON; |
| else if(PC.ls==LS_EXPRESSION_VAR_NAME_WITH_COLON) |
else if(pc.ls==LS_EXPRESSION_VAR_NAME_WITH_COLON) |
| PC.ls=LS_EXPRESSION_VAR_NAME_WITHOUT_COLON; |
pc.ls=LS_EXPRESSION_VAR_NAME_WITHOUT_COLON; |
| // ...stop before next ':' |
// ...stop before next ':' |
| RC; |
RC; |
| } |
} |
|
Line 1126 default:
|
Line 1186 default:
|
| switch(c) { |
switch(c) { |
| case '[': |
case '[': |
| // ${name.<[>code]} |
// ${name.<[>code]} |
| push_LS(PC, LS_NAME_SQUARE_PART); |
push_LS(pc, LS_NAME_SQUARE_PART); |
| lexical_brackets_nestage=1; |
lexical_brackets_nestage=1; |
| RC; |
RC; |
| case '}': // ${name} finished, restoring LS |
case '}': // ${name} finished, restoring LS |
| pop_LS(PC); |
pop_LS(pc); |
| RC; |
RC; |
| case '.': // name part delim |
case '.': // name part delim |
| case '$': // name part subvar |
case '$': // name part subvar |
|
Line 1142 default:
|
Line 1202 default:
|
| case LS_VAR_SQUARE: |
case LS_VAR_SQUARE: |
| switch(c) { |
switch(c) { |
| case '$': |
case '$': |
| push_LS(PC, LS_VAR_NAME_SIMPLE_WITH_COLON); |
push_LS(pc, LS_VAR_NAME_SIMPLE_WITH_COLON); |
| RC; |
RC; |
| case '^': |
case '^': |
| push_LS(PC, LS_METHOD_NAME); |
push_LS(pc, LS_METHOD_NAME); |
| RC; |
RC; |
| case ']': |
case ']': |
| if(--lexical_brackets_nestage==0) { |
if(--lexical_brackets_nestage==0) { |
| pop_LS(PC); |
pop_LS(pc); |
| RC; |
RC; |
| } |
} |
| break; |
break; |
|
Line 1164 default:
|
Line 1224 default:
|
| case LS_VAR_CURLY: |
case LS_VAR_CURLY: |
| switch(c) { |
switch(c) { |
| case '$': |
case '$': |
| push_LS(PC, LS_VAR_NAME_SIMPLE_WITH_COLON); |
push_LS(pc, LS_VAR_NAME_SIMPLE_WITH_COLON); |
| RC; |
RC; |
| case '^': |
case '^': |
| push_LS(PC, LS_METHOD_NAME); |
push_LS(pc, LS_METHOD_NAME); |
| RC; |
RC; |
| case '}': |
case '}': |
| if(--lexical_brackets_nestage==0) { |
if(--lexical_brackets_nestage==0) { |
| pop_LS(PC); |
pop_LS(pc); |
| RC; |
RC; |
| } |
} |
| break; |
break; |
|
Line 1186 default:
|
Line 1246 default:
|
| switch(c) { |
switch(c) { |
| case '[': |
case '[': |
| // ^name.<[>code].xxx |
// ^name.<[>code].xxx |
| if(PC.col>1/*not first column*/ && ( |
if(pc.pos.col>1/*not first column*/ && ( |
| end[-1]=='^'/*was start of call*/ || // never, ^[ is literal... |
end[-1]=='^'/*was start of call*/ || // never, ^[ is literal... |
| end[-1]==':'/*was class name delim */ || |
end[-1]==':'/*was class name delim */ || |
| end[-1]=='.'/*was name delim */ |
end[-1]=='.'/*was name delim */ |
| )) { |
)) { |
| push_LS(PC, LS_NAME_SQUARE_PART); |
push_LS(pc, LS_NAME_SQUARE_PART); |
| lexical_brackets_nestage=1; |
lexical_brackets_nestage=1; |
| RC; |
RC; |
| } |
} |
| PC.ls=LS_METHOD_SQUARE; |
pc.ls=LS_METHOD_SQUARE; |
| lexical_brackets_nestage=1; |
lexical_brackets_nestage=1; |
| RC; |
RC; |
| case '{': |
case '{': |
| PC.ls=LS_METHOD_CURLY; |
pc.ls=LS_METHOD_CURLY; |
| lexical_brackets_nestage=1; |
lexical_brackets_nestage=1; |
| RC; |
RC; |
| case '(': |
case '(': |
| PC.ls=LS_METHOD_ROUND; |
pc.ls=LS_METHOD_ROUND; |
| lexical_brackets_nestage=1; |
lexical_brackets_nestage=1; |
| RC; |
RC; |
| case '.': // name part delim |
case '.': // name part delim |
|
Line 1211 default:
|
Line 1271 default:
|
| case ':': // ':name' or 'class:name' |
case ':': // ':name' or 'class:name' |
| case '^': // ^abc^xxx wrong. bailing out |
case '^': // ^abc^xxx wrong. bailing out |
| case ']': case '}': case ')': // ^abc]}) wrong. bailing out |
case ']': case '}': case ')': // ^abc]}) wrong. bailing out |
| |
case ' ': // ^if ( wrong. bailing out |
| RC; |
RC; |
| } |
} |
| break; |
break; |
|
Line 1218 default:
|
Line 1279 default:
|
| case LS_METHOD_SQUARE: |
case LS_METHOD_SQUARE: |
| switch(c) { |
switch(c) { |
| case '$': |
case '$': |
| push_LS(PC, LS_VAR_NAME_SIMPLE_WITH_COLON); |
push_LS(pc, LS_VAR_NAME_SIMPLE_WITH_COLON); |
| RC; |
RC; |
| case '^': |
case '^': |
| push_LS(PC, LS_METHOD_NAME); |
push_LS(pc, LS_METHOD_NAME); |
| RC; |
RC; |
| case ';': // param delim |
case ';': // param delim |
| RC; |
RC; |
| case ']': |
case ']': |
| if(--lexical_brackets_nestage==0) { |
if(--lexical_brackets_nestage==0) { |
| PC.ls=LS_METHOD_AFTER; |
pc.ls=LS_METHOD_AFTER; |
| RC; |
RC; |
| } |
} |
| break; |
break; |
|
Line 1240 default:
|
Line 1301 default:
|
| case LS_METHOD_CURLY: |
case LS_METHOD_CURLY: |
| switch(c) { |
switch(c) { |
| case '$': |
case '$': |
| push_LS(PC, LS_VAR_NAME_SIMPLE_WITH_COLON); |
push_LS(pc, LS_VAR_NAME_SIMPLE_WITH_COLON); |
| RC; |
RC; |
| case '^': |
case '^': |
| push_LS(PC, LS_METHOD_NAME); |
push_LS(pc, LS_METHOD_NAME); |
| RC; |
RC; |
| case ';': // param delim |
case ';': // param delim |
| RC; |
RC; |
| case '}': |
case '}': |
| if(--lexical_brackets_nestage==0) { |
if(--lexical_brackets_nestage==0) { |
| PC.ls=LS_METHOD_AFTER; |
pc.ls=LS_METHOD_AFTER; |
| RC; |
RC; |
| } |
} |
| break; |
break; |
|
Line 1257 default:
|
Line 1318 default:
|
| lexical_brackets_nestage++; |
lexical_brackets_nestage++; |
| break; |
break; |
| } |
} |
| |
if(pc.explicit_result && c) |
| |
switch(c) { |
| |
case '\n': case ' ': case '\t': |
| |
begin=pc.source; |
| |
begin_pos=pc.pos; |
| |
continue; // skip it |
| |
default: |
| |
result=BAD_NONWHITESPACE_CHARACTER_IN_EXPLICIT_RESULT_MODE; |
| |
goto break2; |
| |
} |
| break; |
break; |
| |
|
| case LS_METHOD_AFTER: |
case LS_METHOD_AFTER: |
| if(c=='[') {/* ][ }[ )[ */ |
if(c=='[') {/* ][ }[ )[ */ |
| PC.ls=LS_METHOD_SQUARE; |
pc.ls=LS_METHOD_SQUARE; |
| lexical_brackets_nestage=1; |
lexical_brackets_nestage=1; |
| RC; |
RC; |
| } |
} |
| if(c=='{') {/* ]{ }{ ){ */ |
if(c=='{') {/* ]{ }{ ){ */ |
| PC.ls=LS_METHOD_CURLY; |
pc.ls=LS_METHOD_CURLY; |
| lexical_brackets_nestage=1; |
lexical_brackets_nestage=1; |
| RC; |
RC; |
| } |
} |
| if(c=='(') {/* ]( }( )( */ |
if(c=='(') {/* ]( }( )( */ |
| PC.ls=LS_METHOD_ROUND; |
pc.ls=LS_METHOD_ROUND; |
| lexical_brackets_nestage=1; |
lexical_brackets_nestage=1; |
| RC; |
RC; |
| } |
} |
| pop_LS(PC); |
pop_LS(pc); |
| PC.source--; if(--PC.col<0) { PC.line--; PC.col=-1; } |
pc.ungetc(); |
| result=EON; |
result=EON; |
| goto break2; |
goto break2; |
| } |
} |
|
Line 1294 break2:
|
Line 1365 break2:
|
| if(end!=begin && end[-1]=='\n') // allow one empty line before LS_DEF_NAME |
if(end!=begin && end[-1]=='\n') // allow one empty line before LS_DEF_NAME |
| end--; |
end--; |
| } |
} |
| if(end!=begin && PC.ls!=LS_USER_COMMENT) { // last piece still alive and not comment? |
if(end!=begin && pc.ls!=LS_USER_COMMENT) { // last piece still alive and not comment? |
| |
if(!pc.string_start) |
| |
pc.string_start=begin_pos; |
| // append it |
// append it |
| PC.string.append_strdup(begin, end-begin); |
pc.string.append_strdup_know_length(begin, end-begin); |
| } |
} |
| } |
} |
| if(!PC.string.is_empty()) { // something accumulated? |
if(!pc.string.is_empty()) { // something accumulated? |
| // create STRING value: array of OP_VALUE+vstring |
// create STRING value: array of OP_VALUE+origin+vstring |
| *lvalp=VL( |
*lvalp=VL( |
| new VString(*new String(PC.string, String::L_CLEAN)), |
new VString(*new String(pc.string, String::L_CLEAN)), |
| PC.file_no, PC.line, PC.col); |
pc.file_no, pc.string_start.line, pc.string_start.col); |
| // new pieces storage |
// new pieces storage |
| PC.string.clear(); |
pc.string.clear(); |
| |
pc.string_start.clear(); |
| // make current result be pending for next call, return STRING for now |
// make current result be pending for next call, return STRING for now |
| PC.pending_state=result; result=STRING; |
pc.pending_state=result; result=STRING; |
| } |
} |
| if(skip_analized) { |
if(skip_analized) { |
| PC.source+=skip_analized; PC.col+=skip_analized; |
pc.source+=skip_analized; pc.pos.col+=skip_analized; |
| } |
} |
| return result; |
return result; |
| } |
} |
| |
|
| static int real_yyerror(parse_control *pc, char *s) { // Called by yyparse on error |
static int real_yyerror(Parse_control *pc, char *s) { // Called by yyparse on error |
| strncpy(PC.error, s, MAX_STRING); |
strncpy(PC.error, s, MAX_STRING); |
| return 1; |
return 1; |
| } |
} |
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to compile.y CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [parser3project] / parser3 / src / main