|
version 1.9, 2001/02/21 13:18:31
|
version 1.275, 2016/04/01 16:27:31
|
|
Line 1
|
Line 1
|
| %{ |
%{ |
| #define YYSTYPE Array/*<op>*/ * |
/** @file |
| #define YYPARSE_PARAM pc |
Parser: compiler(lexical parser and grammar). |
| #define YYLEX_PARAM pc |
|
| |
Copyright (c) 2001-2015 Art. Lebedev Studio (http://www.artlebedev.com) |
| |
Author: Alexander Petrosyan <paf@design.ru> (http://design.ru/paf) |
| |
|
| |
|
| |
*/ |
| |
|
| |
volatile const char * IDENT_COMPILE_Y = "$Id$"; |
| |
|
| |
/** |
| |
@todo parser4: |
| |
- cache compiled code from request to request. to do that... |
| |
-#: make method definitions, @CLASS, @BASE, @USE instructions, |
| |
which would be executed afterwards, and actions |
| |
now performed at compile time would be delayed to run time. |
| |
-#: make cache expiration on time and on disk-change of class source |
| |
-#: in apache use subpools for compiled class storage |
| |
-#: in iis make up specialized Pool object for that |
| |
*/ |
| |
|
| |
#define YYSTYPE ArrayOperation* |
| #define YYDEBUG 1 |
#define YYDEBUG 1 |
| #define YYERROR_VERBOSE |
#define YYERROR_VERBOSE 1 |
| #define yyerror(msg) real_yyerror((parse_control *)pc, msg) |
#define yyerror(pc, msg) real_yyerror(pc, msg) |
| #define YYPRINT(file, type, value) yyprint(file, type, value) |
#define YYPRINT(file, type, value) yyprint(file, type, value) |
| |
#define YYMALLOC pa_malloc |
| |
#define YYFREE pa_free |
| |
|
| #include <stdio.h> |
// includes |
| #include <string.h> |
|
| #include <stdlib.h> |
|
| |
|
| #include "compile_tools.h" |
#include "compile_tools.h" |
| #include "pa_value.h" |
#include "pa_value.h" |
| |
#include "pa_request.h" |
| int real_yyerror(parse_control *pc, char *s); |
#include "pa_vobject.h" |
| static void yyprint(FILE *file, int type, YYSTYPE value); |
#include "pa_vdouble.h" |
| int yylex(YYSTYPE *lvalp, void *pc); |
#include "pa_globals.h" |
| |
#include "pa_vmethod_frame.h" |
| |
|
| |
// defines |
| |
|
| |
#define USE_CONTROL_METHOD_NAME "USE" |
| |
#define OPTIONS_CONTROL_METHOD_NAME "OPTIONS" |
| |
#define OPTION_ALL_VARS_LOCAL_NAME "locals" |
| |
#define OPTION_PARTIAL_CLASS "partial" |
| |
#define REM_OPERATOR_NAME "rem" |
| |
|
| |
// forwards |
| |
|
| |
static int real_yyerror(Parse_control* pc, const char* s); |
| |
static void yyprint(FILE* file, int type, YYSTYPE value); |
| |
static int yylex(YYSTYPE* lvalp, void* pc); |
| |
|
| |
static const VBool vfalse(false); |
| |
static const VBool vtrue(true); |
| |
static const VString vempty; |
| |
|
| // local convinient inplace typecast & var |
// local convinient inplace typecast & var |
| #define PC ((parse_control *)pc) |
#undef PC |
| #define pool *PC->pool |
#define PC (*pc) |
| |
#undef POOL |
| |
#define POOL (*PC.pool) |
| |
#ifndef DOXYGEN |
| |
|
| |
#define CLASS_ADD if(PC.class_add()){ \ |
| |
strncpy(PC.error, PC.cclass->type(), MAX_STRING/2); \ |
| |
strcat(PC.error, " - class is already defined"); \ |
| |
YYERROR; \ |
| |
} |
| |
|
| %} |
%} |
| |
|
| %pure_parser |
%pure-parser |
| |
%lex-param {Parse_control* pc} |
| |
%parse-param {Parse_control* pc} |
| |
|
| %token END_OF_NAME |
%token EON |
| %token STRING |
%token STRING |
| %token BOGUS |
%token BOGUS |
| |
|
| |
%token BAD_STRING_COMPARISON_OPERATOR |
| |
%token BAD_HEX_LITERAL |
| |
%token BAD_METHOD_DECL_START |
| |
%token BAD_METHOD_PARAMETER_NAME_CHARACTER |
| |
%token BAD_NONWHITESPACE_CHARACTER_IN_EXPLICIT_RESULT_MODE |
| |
|
| |
%token LAND "&&" |
| |
%token LOR "||" |
| |
%token LXOR "!||" |
| |
%token NXOR "!|" |
| |
|
| |
%token NLE "<=" |
| |
%token NGE ">=" |
| |
%token NEQ "==" |
| |
%token NNE "!=" |
| |
%token NSL "<<" |
| |
%token NSR ">>" |
| |
|
| |
%token SLT "lt" |
| |
%token SGT "gt" |
| |
%token SLE "le" |
| |
%token SGE "ge" |
| |
%token SEQ "eq" |
| |
%token SNE "ne" |
| |
|
| |
%token DEF "def" |
| |
%token IN "in" |
| |
%token FEXISTS "-f" |
| |
%token DEXISTS "-d" |
| |
%token IS "is" |
| |
|
| |
%token LITERAL_TRUE "true" |
| |
%token LITERAL_FALSE "false" |
| |
|
| |
/* logical */ |
| |
%left "!||" |
| |
%left "||" |
| |
%left "&&" |
| |
%left '<' '>' "<=" ">=" "lt" "gt" "le" "ge" |
| |
%left "==" "!=" "eq" "ne" |
| |
%left "is" "def" "in" "-f" "-d" |
| |
|
| |
/* bitwise */ |
| |
%left "!|" |
| |
%left '|' |
| |
%left '&' |
| |
%left "<<" ">>" |
| |
|
| |
/* numerical */ |
| |
%left '+' '-' |
| |
%left '*' '/' '\\' '%' |
| |
%left NUNARY /* unary - + */ |
| |
|
| |
/* out-of-group */ |
| |
%left '~' /* bitwise */ |
| |
%left '!' /* logical */ |
| |
|
| %% |
%% |
| |
all: |
| |
one_big_piece { |
| |
Method* method=new Method(Method::CT_ANY, |
| |
0, 0, /*min, max numbered_params_count*/ |
| |
0/*param_names*/, 0/*local_names*/, |
| |
$1/*parser_code*/, 0/*native_code*/); |
| |
PC.cclass->set_method(PC.alias_method(main_method_name), method); |
| |
} |
| |
| methods; |
| |
|
| |
methods: method | methods method; |
| |
one_big_piece: maybe_codes; |
| |
|
| |
method: control_method | code_method; |
| |
|
| result: input { |
control_method: '@' STRING '\n' |
| String& name_main=*new(pool) String(pool); |
maybe_control_strings { |
| name_main.APPEND_CONST("main"); |
const String& command=LA2S(*$2)->trim(String::TRIM_END); |
| Array& param_names=*new(pool) Array(pool); |
YYSTYPE strings_code=$4; |
| Array& local_names=*new(pool) Array(pool); |
if(strings_code->count()<1*OPERATIONS_PER_OPVALUE) { |
| Method *method=new(pool) Method(pool, name_main, param_names, local_names, *$1); |
strcpy(PC.error, "@"); |
| *PC->methods+=method; |
strcat(PC.error, command.cstr()); |
| |
strcat(PC.error, " is empty"); |
| |
YYERROR; |
| |
} |
| |
if(command==CLASS_NAME) { |
| |
if(strings_code->count()==1*OPERATIONS_PER_OPVALUE) { |
| |
CLASS_ADD; |
| |
// new class' name |
| |
const String& name=LA2S(*strings_code)->trim(String::TRIM_END); |
| |
// creating the class |
| |
VStateless_class* cclass=new VClass; |
| |
PC.cclass_new=cclass; |
| |
PC.cclass_new->set_type(name.cstr()); |
| |
PC.append=false; |
| |
} else { |
| |
strcpy(PC.error, "@" CLASS_NAME " must contain only one line with class name (contains more then one)"); |
| |
YYERROR; |
| |
} |
| |
} else if(command==USE_CONTROL_METHOD_NAME) { |
| |
CLASS_ADD; |
| |
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)->trim(String::TRIM_END), |
| |
PC.request.get_used_filename(PC.file_no), strings_code->get(i+1).origin); |
| |
} |
| |
} else if(command==BASE_NAME) { |
| |
if(PC.append){ |
| |
strcpy(PC.error, "can't set base while appending methods to class '"); |
| |
strncat(PC.error, PC.cclass->type(), MAX_STRING/2); |
| |
strcat(PC.error, "'"); |
| |
YYERROR; |
| |
} |
| |
CLASS_ADD; |
| |
if(PC.cclass->base_class()) { // already changed from default? |
| |
strcpy(PC.error, "class already have a base '"); |
| |
strncat(PC.error, PC.cclass->base_class()->type(), MAX_STRING/2); |
| |
strcat(PC.error, "'"); |
| |
YYERROR; |
| |
} |
| |
if(strings_code->count()==1*OPERATIONS_PER_OPVALUE) { |
| |
const String& base_name=LA2S(*strings_code)->trim(String::TRIM_END); |
| |
if(Value* base_class_value=PC.request.get_class(base_name)) { |
| |
// @CLASS == @BASE sanity check |
| |
if(VStateless_class *base_class=base_class_value->get_class()) { |
| |
if(PC.cclass==base_class) { |
| |
strcpy(PC.error, "@" CLASS_NAME " equals @" BASE_NAME); |
| |
YYERROR; |
| |
} |
| |
PC.cclass->get_class()->set_base(base_class); |
| |
} else { // they asked to derive from a class without methods ['env' & co] |
| |
strcpy(PC.error, base_name.cstr()); |
| |
strcat(PC.error, ": you can not derive from this class in @" BASE_NAME); |
| |
YYERROR; |
| |
} |
| |
} else { |
| |
strcpy(PC.error, base_name.cstr()); |
| |
strcat(PC.error, ": undefined class in @" BASE_NAME); |
| |
YYERROR; |
| |
} |
| |
} else { |
| |
strcpy(PC.error, "@" BASE_NAME " must contain sole name"); |
| |
YYERROR; |
| |
} |
| |
} else if(command==OPTIONS_CONTROL_METHOD_NAME) { |
| |
for(size_t i=0; i<strings_code->count(); i+=OPERATIONS_PER_OPVALUE) { |
| |
const String& option=LA2S(*strings_code, i)->trim(String::TRIM_END); |
| |
if(option==OPTION_ALL_VARS_LOCAL_NAME){ |
| |
PC.set_all_vars_local(); |
| |
} else if(option==OPTION_PARTIAL_CLASS){ |
| |
if(PC.cclass_new){ |
| |
if(VStateless_class* existed=PC.get_existed_class(PC.cclass_new)){ |
| |
if(!PC.reuse_existed_class(existed)){ |
| |
strcpy(PC.error, "can't append methods to '"); |
| |
strncat(PC.error, PC.cclass_new->type(), MAX_STRING/2); |
| |
strcat(PC.error, "' - the class wasn't marked as partial"); |
| |
YYERROR; |
| |
} |
| |
} else { |
| |
// marks the new class as partial. we will be able to add methods here later. |
| |
PC.cclass_new->set_partial(); |
| |
} |
| |
} else { |
| |
strcpy(PC.error, "'" OPTION_PARTIAL_CLASS "' option should be used straight after @" CLASS_NAME); |
| |
YYERROR; |
| |
} |
| |
} else if(option==method_call_type_static){ |
| |
PC.set_methods_call_type(Method::CT_STATIC); |
| |
} else if(option==method_call_type_dynamic){ |
| |
PC.set_methods_call_type(Method::CT_DYNAMIC); |
| |
} else { |
| |
strcpy(PC.error, "'"); |
| |
strncat(PC.error, option.cstr(), MAX_STRING/2); |
| |
strcat(PC.error, "' invalid option. valid options are " |
| |
"'" OPTION_PARTIAL_CLASS "', '" OPTION_ALL_VARS_LOCAL_NAME "'" |
| |
", '" METHOD_CALL_TYPE_STATIC "' and '" METHOD_CALL_TYPE_DYNAMIC "'" |
| |
); |
| |
YYERROR; |
| |
} |
| |
} |
| |
} else { |
| |
strcpy(PC.error, "'"); |
| |
strncat(PC.error, command.cstr(), MAX_STRING/2); |
| |
strcat(PC.error, "' invalid special name. valid names are " |
| |
"'" CLASS_NAME "', '" USE_CONTROL_METHOD_NAME "', '" BASE_NAME "' and '" OPTIONS_CONTROL_METHOD_NAME "'."); |
| |
YYERROR; |
| |
} |
| }; |
}; |
| input: empty | codes; |
maybe_control_strings: empty | control_strings; |
| |
control_strings: control_string | control_strings control_string { $$=$1; P(*$$, *$2); }; |
| |
control_string: maybe_string '\n'; |
| |
maybe_string: empty | STRING; |
| |
|
| |
code_method: '@' STRING bracketed_maybe_strings maybe_bracketed_strings maybe_comment '\n' { |
| |
CLASS_ADD; |
| |
PC.explicit_result=false; |
| |
|
| |
YYSTYPE params_names_code=$3; |
| |
ArrayString* params_names=0; |
| |
if(int size=params_names_code->count()) { |
| |
params_names=new ArrayString; |
| |
for(int i=0; i<size; i+=OPERATIONS_PER_OPVALUE) |
| |
*params_names+=LA2S(*params_names_code, i); |
| |
} |
| |
|
| /* codes */ |
YYSTYPE locals_names_code=$4; |
| |
ArrayString* locals_names=0; |
| |
bool all_vars_local=false; |
| |
if(int size=locals_names_code->count()) { |
| |
locals_names=new ArrayString; |
| |
for(int i=0; i<size; i+=OPERATIONS_PER_OPVALUE) { |
| |
const String* local_name=LA2S(*locals_names_code, i); |
| |
if(*local_name==RESULT_VAR_NAME) |
| |
PC.explicit_result=true; |
| |
else if(*local_name==OPTION_ALL_VARS_LOCAL_NAME) |
| |
all_vars_local=true; |
| |
else |
| |
*locals_names+=local_name; |
| |
} |
| |
} |
| |
if(!all_vars_local && PC.cclass && PC.cclass->is_vars_local()) |
| |
all_vars_local=true; |
| |
|
| codes: code | codes code { |
Method* method=new Method( |
| $$=$1; |
//name, |
| P($$, $2); |
GetMethodCallType(PC, *$2), |
| |
0, 0/*min,max numbered_params_count*/, |
| |
params_names, locals_names, |
| |
0/*to be filled later in next {} */, 0, all_vars_local); |
| |
|
| |
*reinterpret_cast<Method**>(&$$)=method; |
| |
} maybe_codes { |
| |
Method* method=reinterpret_cast<Method*>($7); |
| |
// fill in the code |
| |
method->parser_code=$8; |
| |
|
| |
// register in class |
| |
const String& name=*LA2S(*$2); |
| |
PC.cclass->set_method(PC.alias_method(name), method); |
| }; |
}; |
| code: write_str_literal | action; |
|
| action: get | put | with | call; |
maybe_bracketed_strings: empty | bracketed_maybe_strings; |
| |
bracketed_maybe_strings: '[' maybe_strings ']' {$$=$2;}; |
| |
maybe_strings: empty | strings; |
| |
strings: STRING | strings ';' STRING { $$=$1; P(*$$, *$3); }; |
| |
|
| |
maybe_comment: empty | STRING; |
| |
|
| |
/* codes */ |
| |
|
| |
maybe_codes: empty | codes; |
| |
|
| |
codes: code | codes code { $$=$1; P(*$$, *$2); }; |
| |
code: write_string | action; |
| |
action: get | put | call; |
| |
|
| /* get */ |
/* get */ |
| |
|
| get: '$' any_name { |
get: get_value { |
| $$=$2; /* stack: resulting value */ |
$$=N(); |
| OP($$, OP_WRITE); /* value=pop; write(value) */ |
YYSTYPE code=$1; |
| }; |
size_t count=code->count(); |
| |
|
| any_name: name_without_curly_rdive END_OF_NAME | name_in_curly_rdive; |
#ifdef OPTIMIZE_BYTECODE_GET_ELEMENT |
| |
if( |
| name_in_curly_rdive: '{' name_without_curly_rdive '}' { $$=$2 }; |
count!=3 |
| name_without_curly_rdive: name_rdive { |
|| !change_first(*code, OP::OP_VALUE__GET_ELEMENT, /*=>*/OP::OP_VALUE__GET_ELEMENT__WRITE) |
| /* |
) |
| TODO: подсмотреть в $1, и если там в первом элементе первая буква ":" |
#endif |
| то выкинуть её и делать не OP_WITH_READ, а WITH_ROOT |
|
| TODO: подсмотреть в $1, и если там первым элементом self, |
#ifdef OPTIMIZE_BYTECODE_GET_SELF_ELEMENT |
| то выкинуть его и делать не OP_WITH_READ, а WITH_SELF |
if( |
| */ |
count!=3 |
| $$=N(pool); OP($$, OP_WITH_READ); /* stack: starting context */ |
|| !change_first(*code, OP::OP_WITH_SELF__VALUE__GET_ELEMENT, /*=>*/OP::OP_WITH_SELF__VALUE__GET_ELEMENT__WRITE) |
| P($$, $1); /* diving code; stack: current context */ |
) |
| |
#endif |
| |
|
| |
#ifdef OPTIMIZE_BYTECODE_GET_OBJECT_ELEMENT |
| |
if( |
| |
count!=5 |
| |
|| !change_first(*code, OP::OP_GET_OBJECT_ELEMENT, /*=>*/OP::OP_GET_OBJECT_ELEMENT__WRITE) |
| |
) |
| |
#endif |
| |
|
| |
#ifdef OPTIMIZE_BYTECODE_GET_OBJECT_VAR_ELEMENT |
| |
if( |
| |
count!=5 |
| |
|| !change_first(*code, OP::OP_GET_OBJECT_VAR_ELEMENT, /*=>*/OP::OP_GET_OBJECT_VAR_ELEMENT__WRITE) |
| |
) |
| |
#endif |
| |
|
| |
#ifdef OPTIMIZE_BYTECODE_GET_ELEMENT__SPECIAL |
| |
if( |
| |
!change(*code, count-1/* last */, OP::OP_GET_ELEMENT__SPECIAL, /*=>*/OP::OP_GET_ELEMENT__SPECIAL__WRITE) |
| |
) |
| |
#endif |
| |
|
| |
{ |
| |
change_or_append(*code, count-1 /* last */, |
| |
OP::OP_GET_ELEMENT, /*=>*/OP::OP_GET_ELEMENT__WRITE, |
| |
/*or */OP::OP_WRITE_VALUE |
| |
); /* value=pop; wcontext.write(value) */ |
| |
} |
| |
|
| |
P(*$$, *code); |
| |
}; |
| |
get_value: '$' get_name_value { $$=$2; }; |
| |
get_name_value: name_without_curly_rdive EON | name_in_curly_rdive; |
| |
name_in_curly_rdive: '{' name_without_curly_rdive '}' { $$=$2; }; |
| |
name_without_curly_rdive: |
| |
name_without_curly_rdive_read |
| |
| name_without_curly_rdive_class; |
| |
name_without_curly_rdive_read: name_without_curly_rdive_code { |
| |
$$=N(); |
| |
YYSTYPE diving_code=$1; |
| |
size_t count=diving_code->count(); |
| |
|
| |
if(maybe_make_self(*$$, *diving_code, count)) { |
| |
// $self. |
| |
} else |
| |
|
| |
#ifdef OPTIMIZE_BYTECODE_GET_OBJECT_ELEMENT |
| |
if(maybe_make_get_object_element(*$$, *diving_code, count)){ |
| |
// optimization for $object.field + ^object.method[ |
| |
} else |
| |
#endif |
| |
|
| |
#ifdef OPTIMIZE_BYTECODE_GET_OBJECT_VAR_ELEMENT |
| |
if(maybe_make_get_object_var_element(*$$, *diving_code, count)){ |
| |
// optimization for $object.$var |
| |
} else |
| |
#endif |
| |
|
| |
#ifdef OPTIMIZE_BYTECODE_GET_ELEMENT |
| |
if( |
| |
count>=4 |
| |
&& (*diving_code)[0].code==OP::OP_VALUE |
| |
&& (*diving_code)[3].code==OP::OP_GET_ELEMENT |
| |
){ |
| |
// optimization |
| |
O(*$$, |
| |
(PC.in_call_value && count==4) |
| |
? OP::OP_VALUE__GET_ELEMENT_OR_OPERATOR // ^object[ : OP_VALUE+origin+string+OP_GET_ELEMENT => OP_VALUE__GET_ELEMENT_OR_OPERATOR+origin+string |
| |
: OP::OP_VALUE__GET_ELEMENT // $object : OP_VALUE+origin+string+OP_GET_ELEMENT => OP_VALUE__GET_ELEMENT+origin+string |
| |
); |
| |
P(*$$, *diving_code, 1/*offset*/, 2/*limit*/); // copy origin+value |
| |
if(count>4) |
| |
P(*$$, *diving_code, 4); // copy tail |
| |
} else { |
| |
O(*$$, OP::OP_WITH_READ); /* stack: starting context */ |
| |
P(*$$, *diving_code); |
| |
} |
| |
#else |
| |
{ |
| |
O(*$$, OP::OP_WITH_READ); /* stack: starting context */ |
| |
|
| |
// ^if OP_ELEMENT => ^if OP_ELEMENT_OR_OPERATOR |
| |
// optimized OP_VALUE+origin+string+OP_GET_ELEMENT. => OP_VALUE+origin+string+OP_GET_ELEMENT_OR_OPERATOR. |
| |
if(PC.in_call_value && count==4) |
| |
diving_code->put(count-1, OP::OP_GET_ELEMENT_OR_OPERATOR); |
| |
P(*$$, *diving_code); |
| |
} |
| |
#endif |
| |
/* diving code; stack: current context */ |
| }; |
}; |
| name_rdive: name_advance2 | name_path name_advance2 { $$=$1; P($$, $2) } |
name_without_curly_rdive_class: class_prefix name_without_curly_rdive_code { $$=$1; P(*$$, *$2); }; |
| |
name_without_curly_rdive_code: name_advance2 | name_path name_advance2 { $$=$1; P(*$$, *$2); }; |
| |
|
| /* put */ |
/* put */ |
| |
|
| put: '$' name_expr_dive '(' constructor_value ')' { |
put: '$' name_expr_wdive construct { |
| /* |
$$=N(); |
| TODO: подсмотреть в $3, и если там в первом элементе первая буква ":" |
#ifdef OPTIMIZE_BYTECODE_CONSTRUCT |
| то выкинуть её и делать не OP_WITH_OP_WRITE, а WITH_ROOT |
if(maybe_optimize_construct(*$$, *$2, *$3)){ |
| TODO: подсмотреть в $3, и если там первым элементом self, |
// $a(expr), $.a(expr), $a[value], $.a[value], $self.a[value], $self.a(expr) |
| то выкинуть его и делать не OP_WITH_OP_WRITE, а WITH_SELF |
} else |
| если ничего не осталось - $self(xxx) |
#endif |
| обругать |
{ |
| */ |
P(*$$, *$2); /* stack: context,name */ |
| $$=N(pool); |
P(*$$, *$3); /* stack: context,name,constructor_value */ |
| OP($$, OP_WITH_WRITE); /* stack: starting context */ |
} |
| P($$, $2); /* diving code; stack: context,name */ |
}; |
| P($$, $4); /* stack: context,name,constructor_value */ |
name_expr_wdive: |
| OP($$, OP_CONSTRUCT); /* value=pop; name=pop; context=pop; construct(context,name,value) */ |
name_expr_wdive_root |
| }; |
| name_expr_wdive_write |
| constructor_value: |
| name_expr_wdive_class; |
| constructor_one_param_value |
name_expr_wdive_root: name_expr_dive_code { |
| | constructor_two_params_value /* $var(=;2*2) $var(%d;2*2) $var(+;1) */ |
$$=N(); |
| ; |
YYSTYPE diving_code=$1; |
| constructor_one_param_value: |
size_t count=diving_code->count(); |
| empty_value /* optimized $var() case */ |
|
| | STRING /* optimized $var(STRING) case */ |
if(maybe_make_self(*$$, *diving_code, count)) { |
| | complex_constructor_param_value /* $var(something complex) */ |
// $self. |
| ; |
} else |
| empty_value: empty; |
#ifdef OPTIMIZE_BYTECODE_GET_ELEMENT |
| complex_constructor_param_value: complex_constructor_param_body { |
if( |
| $$=N(pool); |
count>=4 |
| OP($$, OP_CREATE_EWPOOL); /* stack: empty write context */ |
&& (*diving_code)[0].code==OP::OP_VALUE |
| P($$, $1); /* some codes to that context */ |
&& (*diving_code)[3].code==OP::OP_GET_ELEMENT |
| OP($$, OP_REDUCE_EWPOOL); /* context=pop; stack: context.value() */ |
){ |
| }; |
O(*$$, OP::OP_WITH_ROOT__VALUE__GET_ELEMENT); |
| complex_constructor_param_body: |
P(*$$, *diving_code, 1/*offset*/, 2/*limit*/); // copy origin+value |
| codes__excluding_sole_str_literal |
if(count>4) |
| | codes__str__followed_by__excluding_sole_str_literal |
P(*$$, *diving_code, 4); // tail |
| ; |
} else |
| constructor_two_params_value: STRING ';' constructor_one_param_value { |
#endif |
| char *operator_or_fmt=LA2S($1)->cstr(); |
{ |
| $$=N(pool); |
O(*$$, OP::OP_WITH_ROOT); /* stack: starting context */ |
| P($$, $1); /* stack: ncontext name operator_or_fmt */ |
P(*$$, *diving_code); |
| P($$, $3); /* stack: ncontext name operator_or_fmt expr */ |
|
| switch(operator_or_fmt[0]) { |
|
| case '=': case '%': |
|
| OP($$, OP_EXPRESSION_EVAL); |
|
| break; |
|
| case '+': case '-': case '*': case '/': |
|
| OP($$, OP_MODIFY_EVAL); |
|
| break; |
|
| default: |
|
| strcpy(PC->error, "invalid modification operator"); |
|
| YYERROR; |
|
| } |
} |
| /* stack: ncontext name value */ |
/* diving code; stack: current context */ |
| |
}; |
| |
name_expr_wdive_write: '.' name_expr_dive_code { |
| |
$$=N(); |
| |
O(*$$, OP::OP_WITH_WRITE); /* stack: starting context */ |
| |
P(*$$, *$2); /* diving code; stack: context,name */ |
| |
}; |
| |
name_expr_wdive_class: class_prefix name_expr_dive_code { $$=$1; P(*$$, *$2); }; |
| |
|
| |
construct: |
| |
construct_square |
| |
| construct_round |
| |
| construct_curly |
| |
; |
| |
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 |
| |
$$=$3; // stack: context, name, value |
| |
O(*$$, OP::OP_CONSTRUCT_VALUE); /* value=pop; name=pop; context=pop; construct(context,name,value) */ |
| |
} |
| |
; |
| |
construct_round: '(' expr_value ')' { |
| |
$$=N(); |
| |
O(*$$, OP::OP_PREPARE_TO_EXPRESSION); |
| |
// stack: context, name |
| |
P(*$$, *$2); // stack: context, name, value |
| |
O(*$$, OP::OP_CONSTRUCT_EXPR); /* value=pop->as_expr_result; name=pop; context=pop; construct(context,name,value) */ |
| |
} |
| |
; |
| |
construct_curly: '{' maybe_codes '}' { |
| |
// stack: context, name |
| |
$$=N(); |
| |
OA(*$$, OP::OP_CURLY_CODE__CONSTRUCT, $2); /* code=pop; name=pop; context=pop; construct(context,name,junction(code)) */ |
| }; |
}; |
| |
|
| |
any_constructor_code_value: |
| |
empty_value /* optimized $var[] case */ |
| |
| STRING /* optimized $var[STRING] case */ |
| |
| constructor_code_value /* $var[something complex] */ |
| |
; |
| |
constructor_code_value: constructor_code { |
| |
$$=N(); |
| |
OA(*$$, OP::OP_OBJECT_POOL, $1); /* stack: empty write context */ |
| |
/* some code that writes to that context */ |
| |
/* context=pop; stack: context.value() */ |
| |
}; |
| |
constructor_code: codes__excluding_sole_str_literal; |
| |
codes__excluding_sole_str_literal: action | code codes { $$=$1; P(*$$, *$2); }; |
| |
|
| /* call */ |
/* call */ |
| |
|
| call: '^' name_expr_dive store_params END_OF_NAME { /* ^field.$method{vasya} */ |
call: call_value { |
| /* |
size_t count=$1->count(); |
| TODO: подсмотреть в $3, и если там в первом элементе первая буква ":" |
#ifdef OPTIMIZE_BYTECODE_CUT_REM_OPERATOR |
| то выкинуть её и делать не OP_WITH_READ, а WITH_ROOT |
if(count) |
| TODO: подсмотреть в $3, и если там первым элементом self, |
#endif |
| то выкинуть его и делать не OP_WITH_READ, а WITH_SELF |
{ |
| TODO: |
$$=$1; /* stack: value */ |
| если первым в $3 идёт result |
if(!change_first(*$$, OP::OP_CONSTRUCT_OBJECT, /*=>*/OP::OP_CONSTRUCT_OBJECT__WRITE)) |
| то |
change_or_append(*$$, count-2 /* second last */, |
| выкинуть его |
OP::OP_CALL, /*=>*/ OP::OP_CALL__WRITE, |
| если там ещё что-то осталось, |
/*or */OP::OP_WRITE_VALUE); /* value=pop; wcontext.write(value) */ |
| то |
} |
| не OP_WITH_READ, а WITH_RESULT |
}; |
| иначе // ^result(value) |
call_value: '^' { |
| обругать безобразие |
PC.in_call_value=true; |
| */ |
} |
| $$=N(pool); |
call_name { |
| OP($$, OP_WITH_READ); /* stack: starting context */ |
PC.in_call_value=false; |
| P($$, $2); /* diving code; stack: context,method_name */ |
} |
| OP($$, OP_GET_METHOD_FRAME); /* stack: context,method_frame */ |
store_params EON { /* ^field.$method{vasya} */ |
| P($$, $3); /* filling method_frame.store_params */ |
#ifdef OPTIMIZE_BYTECODE_CUT_REM_OPERATOR |
| OP($$, OP_CALL); /* method_frame=pop; ncontext=pop; call(ncontext,method_frame) */ |
#ifdef OPTIMIZE_BYTECODE_GET_ELEMENT |
| |
const String* operator_name=LA2S(*$3, 0, OP::OP_VALUE__GET_ELEMENT_OR_OPERATOR); |
| |
#else |
| |
const String* operator_name=LA2S(*$3, 1); |
| |
#endif |
| |
if(operator_name && *operator_name==REM_OPERATOR_NAME){ |
| |
$$=N(); |
| |
} else |
| |
#endif |
| |
{ |
| |
YYSTYPE params_code=$5; |
| |
if(params_code->count()==3) { // probably [] case. [OP::OP_VALUE+origin+Void] |
| |
if(Value* value=LA2V(*params_code)) // it is OP_VALUE+origin+value? |
| |
if(const String * string=value->get_string()) |
| |
if(string->is_empty()) // value is empty string? |
| |
params_code=0; // ^zzz[] case. don't append lone empty param. |
| |
} |
| |
/* stack: context, method_junction */ |
| |
|
| |
YYSTYPE var_code=$3; |
| |
if( |
| |
var_code->count()==8 |
| |
&& (*var_code)[0].code==OP::OP_VALUE__GET_CLASS |
| |
&& (*var_code)[3].code==OP::OP_PREPARE_TO_CONSTRUCT_OBJECT |
| |
&& (*var_code)[4].code==OP::OP_VALUE |
| |
#ifdef FEATURE_GET_ELEMENT4CALL |
| |
&& (*var_code)[7].code==OP::OP_GET_ELEMENT4CALL |
| |
#else |
| |
&& (*var_code)[7].code==OP::OP_GET_ELEMENT |
| |
#endif |
| |
){ |
| |
$$=N(); |
| |
O(*$$, OP::OP_CONSTRUCT_OBJECT); |
| |
P(*$$, *var_code, 1/*offset*/, 2/*limit*/); // class name |
| |
P(*$$, *var_code, 5/*offset*/, 2/*limit*/); // constructor name |
| |
OA(*$$, params_code); |
| |
} else |
| |
{ |
| |
$$=var_code; /* with_xxx,diving code; stack: context,method_junction */ |
| |
OA(*$$, OP::OP_CALL, params_code); // method_frame=make frame(pop junction); ncontext=pop; call(ncontext,method_frame) stack: value |
| |
} |
| |
} |
| |
}; |
| |
|
| |
call_name: name_without_curly_rdive { |
| |
#ifdef FEATURE_GET_ELEMENT4CALL |
| |
size_t count=$1->count(); |
| |
if(count){ |
| |
$$=$1; |
| |
#ifdef OPTIMIZE_BYTECODE_GET_OBJECT_ELEMENT |
| |
!(count==5 && change_first(*$$, OP::OP_GET_OBJECT_ELEMENT, OP::OP_GET_OBJECT_ELEMENT4CALL)) && |
| |
#endif |
| |
#ifdef OPTIMIZE_BYTECODE_GET_OBJECT_VAR_ELEMENT |
| |
!(count==5 && change_first(*$$, OP::OP_GET_OBJECT_VAR_ELEMENT, OP::OP_GET_OBJECT_VAR_ELEMENT4CALL)) && |
| |
#endif |
| |
!change(*$$, count-1, OP::OP_GET_ELEMENT, OP::OP_GET_ELEMENT4CALL); |
| |
} |
| |
#endif |
| }; |
}; |
| |
|
| store_params: store_param | store_params store_param { $$=$1; P($$, $2) }; |
store_params: store_param | store_params store_param { $$=$1; P(*$$, *$2); }; |
| store_param: store_round_param | store_curly_param; |
store_param: |
| store_round_param: '(' store_param_parts ')' {$$=$2}; |
store_square_param |
| store_param_parts: store_param_part | store_param_parts ';' store_param_part { $$=$1; P($$, $3) }; |
| store_round_param |
| store_param_part: constructor_one_param_value { |
| store_curly_param |
| |
; |
| |
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_curly_param: '{' store_curly_param_parts '}' {$$=$2;}; |
| |
store_code_param_parts: |
| |
store_code_param_part |
| |
| store_code_param_parts ';' store_code_param_part { $$=$1; P(*$$, *$3); } |
| |
; |
| |
store_expr_param_parts: |
| |
store_expr_param_part |
| |
| store_expr_param_parts ';' store_expr_param_part { $$=$1; P(*$$, *$3); } |
| |
; |
| |
store_curly_param_parts: |
| |
store_curly_param_part |
| |
| store_curly_param_parts ';' store_curly_param_part { $$=$1; P(*$$, *$3); } |
| |
; |
| |
store_code_param_part: code_param_value { |
| $$=$1; |
$$=$1; |
| OP($$, OP_STORE_PARAM); |
|
| } |
|
| store_curly_param: '{' input '}' { |
|
| $$=N(pool); |
|
| OP($$, OP_CODE_ARRAY); |
|
| AA($$, $2); |
|
| OP($$, OP_CREATE_JUNCTION); |
|
| OP($$, OP_STORE_PARAM); |
|
| }; |
}; |
| |
store_expr_param_part: expr_value { |
| |
YYSTYPE expr_code=$1; |
| |
if(expr_code->count()==3 |
| |
&& (*expr_code)[0].code==OP::OP_VALUE) { // optimizing (double/bool/incidently 'string' too) case. [OP::OP_VALUE+origin+Double]. no evaluating |
| |
$$=expr_code; |
| |
} else { |
| |
YYSTYPE code=N(); |
| |
O(*code, OP::OP_PREPARE_TO_EXPRESSION); |
| |
P(*code, *expr_code); |
| |
O(*code, OP::OP_WRITE_EXPR_RESULT); |
| |
$$=N(); |
| |
OA(*$$, OP::OP_EXPR_CODE__STORE_PARAM, code); |
| |
} |
| |
}; |
| |
store_curly_param_part: maybe_codes { |
| |
$$=N(); |
| |
OA(*$$, OP::OP_CURLY_CODE__STORE_PARAM, $1); |
| |
}; |
| |
code_param_value: |
| |
empty_value /* optimized [;...] case */ |
| |
| STRING /* optimized [STRING] case */ |
| |
| constructor_code_value /* [something complex] */ |
| |
; |
| |
|
| /* name */ |
/* name */ |
| |
|
| name_expr_dive: name_expr_value | name_path name_expr_value { $$=$1; P($$, $2) }; |
name_expr_dive_code: name_expr_value | name_path name_expr_value { $$=$1; P(*$$, *$2); }; |
| |
|
| name_path: name_step | name_path name_step { $$=$1; P($$, $2) }; |
name_path: name_step | name_path name_step { $$=$1; P(*$$, *$2); }; |
| name_step: name_advance1 '.'; |
name_step: name_advance1 '.'; |
| name_advance1: name_expr_value { |
name_advance1: name_expr_value { |
| |
// we know that name_advance1 not called from ^xxx context |
| |
// so we'll not check for operator call possibility as we do in name_advance2 |
| |
|
| /* stack: context */ |
/* stack: context */ |
| $$=$1; /* stack: context,name */ |
$$=$1; /* stack: context,name */ |
| OP($$, OP_GET_ELEMENT); /* name=pop; context=pop; stack: context.get_element(name) */ |
#ifdef OPTIMIZE_BYTECODE_GET_ELEMENT__SPECIAL |
| |
O(*$$, is_special_element(*$$) ? OP::OP_GET_ELEMENT__SPECIAL : OP::OP_GET_ELEMENT); |
| |
#else |
| |
O(*$$, OP::OP_GET_ELEMENT); /* name=pop; context=pop; stack: context.get_element(name) */ |
| |
#endif |
| }; |
}; |
| name_advance2: name_expr_value { |
name_advance2: name_expr_value { |
| /* stack: context */ |
/* stack: context */ |
| $$=$1; /* stack: context,name */ |
$$=$1; /* stack: context,name */ |
| OP($$, OP_GET_ELEMENT); /* name=pop; context=pop; stack: context.get_element(name) */ |
#ifdef OPTIMIZE_BYTECODE_GET_ELEMENT__SPECIAL |
| |
O(*$$, is_special_element(*$$) ? OP::OP_GET_ELEMENT__SPECIAL : OP::OP_GET_ELEMENT); |
| |
#else |
| |
O(*$$, OP::OP_GET_ELEMENT); /* name=pop; context=pop; stack: context.get_element(name) */ |
| |
#endif |
| } |
} |
| | STRING BOGUS |
| STRING BOGUS |
| ; |
; |
| name_expr_value: |
name_expr_value: |
| STRING /* subname_is_const */ |
STRING /* subname_is_const */ |
| | name_expr_subvar_value /* $subname_is_var_value */ |
| name_expr_subvar_value /* $subname_is_var_value */ |
| | name_expr_with_subvar_value /* xxx$part_of_subname_is_var_value[$...] */ |
| name_expr_with_subvar_value /* xxx$part_of_subname_is_var_value */ |
| |
| name_square_code_value /* [codes] */ |
| ; |
; |
| name_expr_subvar_value: '$' subvar_ref_name_rdive { |
name_expr_subvar_value: '$' subvar_ref_name_rdive { |
| $$=$2; |
$$=$2; |
| OP($$, OP_GET_ELEMENT); |
O(*$$, OP::OP_GET_ELEMENT); |
| }; |
}; |
| name_expr_with_subvar_value: STRING subvar_get_writes { |
name_expr_with_subvar_value: STRING subvar_get_writes { |
| $$=N(pool); |
YYSTYPE code; |
| OP($$, OP_CREATE_EWPOOL); |
{ |
| P($$, $1); |
change_string_literal_to_write_string_literal(*(code=$1)); |
| OP($$, OP_WRITE); |
P(*code, *$2); |
| P($$, $2); |
} |
| OP($$, OP_REDUCE_EWPOOL); |
$$=N(); |
| |
OA(*$$, OP::OP_STRING_POOL, code); |
| |
}; |
| |
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(); |
| |
#ifdef OPTIMIZE_BYTECODE_GET_ELEMENT__SPECIAL |
| |
if(!maybe_append_simple_diving_code(*$$, *$3)) |
| |
#endif |
| |
{ |
| |
OA(*$$, OP::OP_OBJECT_POOL, $3); /* stack: empty write context */ |
| |
/* some code that writes to that context */ |
| |
/* context=pop; stack: context.value() */ |
| |
} |
| }; |
}; |
| subvar_ref_name_rdive: STRING { |
subvar_ref_name_rdive: STRING { |
| /* |
$$=N(); |
| TODO: подсмотреть в $1, и если там в первом элементе первая буква ":" |
O(*$$, OP::OP_WITH_READ); |
| то выкинуть её и делать не OP_WITH_READ, а WITH_ROOT |
P(*$$, *$1); |
| */ |
|
| $$=N(pool); OP($$, OP_WITH_READ); |
|
| P($$, $1); |
|
| }; |
}; |
| subvar_get_writes: subvar__get_write | subvar_get_writes subvar__get_write { $$=$1; P($$, $2) }; |
subvar_get_writes: subvar__get_write | subvar_get_writes subvar__get_write { $$=$1; P(*$$, *$2); }; |
| subvar__get_write: '$' subvar_ref_name_rdive { |
subvar__get_write: '$' subvar_ref_name_rdive { |
| $$=$2; |
$$=$2; |
| OP($$, OP_GET_ELEMENT__WRITE); |
O(*$$, OP::OP_GET_ELEMENT__WRITE); |
| |
}; |
| |
|
| |
class_prefix: |
| |
class_static_prefix |
| |
| class_constructor_prefix |
| |
; |
| |
class_static_prefix: STRING ':' { |
| |
$$=$1; // stack: class name string |
| |
if(*LA2S(*$$) == BASE_NAME) { // pseudo BASE class |
| |
if(VStateless_class* base=PC.cclass->base_class()) { |
| |
change_string_literal_value(*$$, *new String(base->type())); |
| |
} else { |
| |
strcpy(PC.error, "no base class declared"); |
| |
YYERROR; |
| |
} |
| |
} |
| |
// optimized OP_VALUE+origin+string+OP_GET_CLASS => OP_VALUE__GET_CLASS+origin+string |
| |
change_first(*$$, OP::OP_VALUE, OP::OP_VALUE__GET_CLASS); |
| |
}; |
| |
class_constructor_prefix: class_static_prefix ':' { |
| |
$$=$1; |
| |
if(!PC.in_call_value) { |
| |
strcpy(PC.error, ":: not allowed here"); |
| |
YYERROR; |
| |
} |
| |
O(*$$, OP::OP_PREPARE_TO_CONSTRUCT_OBJECT); |
| }; |
}; |
| |
|
| |
|
| /* with */ |
/* expr */ |
| |
|
| with: '$' name_without_curly_rdive '{' codes '}' { |
expr_value: expr; |
| $$=$2; |
expr: |
| OP($$, OP_CREATE_RWPOOL); |
double_or_STRING |
| P($$, $4); |
| true_value |
| OP($$, OP_REDUCE_RWPOOL); |
| false_value |
| OP($$, OP_WRITE); |
| get_value |
| |
| call_value |
| |
| '"' string_inside_quotes_value '"' { $$ = $2; } |
| |
| '\'' string_inside_quotes_value '\'' { $$ = $2; } |
| |
| '(' expr ')' { $$ = $2; } |
| |
/* stack: operand // stack: @operand */ |
| |
| '-' expr %prec NUNARY { $$=$2; O(*$$, OP::OP_NEG); } |
| |
| '+' expr %prec NUNARY { $$=$2; } |
| |
| '~' expr { $$=$2; O(*$$, OP::OP_INV); } |
| |
| '!' expr { $$=$2; O(*$$, OP::OP_NOT); } |
| |
| "def" expr { $$=$2; O(*$$, OP::OP_DEF); } |
| |
| "in" expr { $$=$2; O(*$$, OP::OP_IN); } |
| |
| "-f" expr { $$=$2; O(*$$, OP::OP_FEXISTS); } |
| |
| "-d" expr { $$=$2; O(*$$, OP::OP_DEXISTS); } |
| |
/* stack: a,b // stack: a@b */ |
| |
| expr '-' expr { $$=$1; P(*$$, *$3); O(*$$, OP::OP_SUB); } |
| |
| expr '+' expr { $$=$1; P(*$$, *$3); O(*$$, OP::OP_ADD); } |
| |
| expr '*' expr { $$=$1; P(*$$, *$3); O(*$$, OP::OP_MUL); } |
| |
| expr '/' expr { $$=$1; P(*$$, *$3); O(*$$, OP::OP_DIV); } |
| |
| expr '%' expr { $$=$1; P(*$$, *$3); O(*$$, OP::OP_MOD); } |
| |
| expr '\\' expr { $$=$1; P(*$$, *$3); O(*$$, OP::OP_INTDIV); } |
| |
| expr "<<" expr { $$=$1; P(*$$, *$3); O(*$$, OP::OP_BIN_SL); } |
| |
| expr ">>" expr { $$=$1; P(*$$, *$3); O(*$$, OP::OP_BIN_SR); } |
| |
| expr '&' expr { $$=$1; P(*$$, *$3); O(*$$, OP::OP_BIN_AND); } |
| |
| expr '|' expr { $$=$1; P(*$$, *$3); O(*$$, OP::OP_BIN_OR); } |
| |
| expr "!|" expr { $$=$1; P(*$$, *$3); O(*$$, OP::OP_BIN_XOR); } |
| |
| expr "&&" expr { $$=$1; OA(*$$, OP::OP_NESTED_CODE, $3); O(*$$, OP::OP_LOG_AND); } |
| |
| expr "||" expr { $$=$1; OA(*$$, OP::OP_NESTED_CODE, $3); O(*$$, OP::OP_LOG_OR); } |
| |
| expr "!||" expr { $$=$1; P(*$$, *$3); O(*$$, OP::OP_LOG_XOR); } |
| |
| expr '<' expr { $$=$1; P(*$$, *$3); O(*$$, OP::OP_NUM_LT); } |
| |
| expr '>' expr { $$=$1; P(*$$, *$3); O(*$$, OP::OP_NUM_GT); } |
| |
| expr "<=" expr { $$=$1; P(*$$, *$3); O(*$$, OP::OP_NUM_LE); } |
| |
| expr ">=" expr { $$=$1; P(*$$, *$3); O(*$$, OP::OP_NUM_GE); } |
| |
| expr "==" expr { $$=$1; P(*$$, *$3); O(*$$, OP::OP_NUM_EQ); } |
| |
| expr "!=" expr { $$=$1; P(*$$, *$3); O(*$$, OP::OP_NUM_NE); } |
| |
| expr "lt" expr { $$=$1; P(*$$, *$3); O(*$$, OP::OP_STR_LT); } |
| |
| expr "gt" expr { $$=$1; P(*$$, *$3); O(*$$, OP::OP_STR_GT); } |
| |
| expr "le" expr { $$=$1; P(*$$, *$3); O(*$$, OP::OP_STR_LE); } |
| |
| expr "ge" expr { $$=$1; P(*$$, *$3); O(*$$, OP::OP_STR_GE); } |
| |
| expr "eq" expr { $$=$1; P(*$$, *$3); O(*$$, OP::OP_STR_EQ); } |
| |
| expr "ne" expr { $$=$1; P(*$$, *$3); O(*$$, OP::OP_STR_NE); } |
| |
| expr "is" expr { $$=$1; P(*$$, *$3); O(*$$, OP::OP_IS); } |
| |
; |
| |
|
| |
double_or_STRING: STRING { |
| |
// optimized OP_STRING => OP_VALUE for doubles |
| |
maybe_change_string_literal_to_double_literal(*($$=$1)); |
| }; |
}; |
| |
|
| /* codes_in_brackets */ |
string_inside_quotes_value: maybe_codes { |
| |
#ifdef OPTIMIZE_BYTECODE_STRING_POOL |
| |
// it brakes ^if(" 09 "){...} |
| |
YYSTYPE code=$1; |
| |
$$=N(); |
| |
if(code->count()==3 && change_first(*code, OP::OP_STRING__WRITE, OP::OP_VALUE)){ |
| |
// optimized OP_STRING__WRITE+origin+value => OP_VALUE+origin+value without starting OP_STRING_POOL |
| |
P(*$$, *code); |
| |
} else { |
| |
OA(*$$, OP::OP_STRING_POOL, code); /* stack: empty write context */ |
| |
} |
| |
#else |
| |
$$=N(); |
| |
OA(*$$, OP::OP_STRING_POOL, $1); /* stack: empty write context */ |
| |
#endif |
| |
/* some code that writes to that context */ |
| |
/* context=pop; stack: context.get_string() */ |
| |
}; |
| |
|
| codes__str__followed_by__excluding_sole_str_literal: |
/* basics */ |
| write_str_literal codes__excluding_sole_str_literal { |
|
| $$=$1; |
write_string: STRING { |
| P($$, $2); |
// optimized OP_STRING+OP_WRITE_VALUE => OP_STRING__WRITE |
| } |
change_string_literal_to_write_string_literal(*($$=$1)); |
| ; |
|
| codes__excluding_sole_str_literal: |
|
| action |
|
| | codes__excluding_sole_str_literal write_str_literal { |
|
| $$=$1; |
|
| P($$, $2); |
|
| } |
|
| ; |
|
| write_str_literal: STRING { |
|
| $$=$1; |
|
| OP($$, OP_WRITE); |
|
| }; |
}; |
| |
|
| /* */ |
empty_value: /* empty */ { $$=VL(/*we know that we will not change it*/const_cast<VString*>(&vempty), 0, 0, 0); } |
| |
true_value: "true" { $$ = VL(/*we know that we will not change it*/const_cast<VBool*>(&vtrue), 0, 0, 0); } |
| |
false_value: "false" { $$ = VL(/*we know that we will not change it*/const_cast<VBool*>(&vfalse), 0, 0, 0); } |
| |
|
| empty: /* empty */ { $$=N(pool) }; |
empty: /* empty */ { $$=N(); }; |
| |
|
| %% |
%% |
| |
#endif |
| |
|
| /* |
/* |
| 000$111(2222)00 |
000$111(2222)00 |
|
Line 274 empty: /* empty */ { $$=N(pool) };
|
Line 885 empty: /* empty */ { $$=N(pool) };
|
| 4:[^({]=pop |
4:[^({]=pop |
| */ |
*/ |
| |
|
| 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->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; } |
| |
|
| 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; |
| } |
} |
| |
|
| char *begin=PC->source; |
const char *begin=pc.source; |
| char *end; |
Pos begin_pos=pc.pos; |
| int begin_line=PC->line; |
const char *end; |
| while(1) { |
int skip_analized=0; |
| c=*(end=(PC->source++)); |
while(true) { |
| |
c=*(end=(pc.source++)); |
| if(c=='\n') { |
// fprintf(stderr, "\nchar: %c %02X; nestage: %d, sp=%d", c, c, lexical_brackets_nestage, pc.sp); |
| PC->line++; |
|
| PC->col=0; |
if(c=='\n') |
| |
pc.pos_next_line(); |
| |
else |
| |
pc.pos_next_c(c); |
| |
// fprintf(stderr, "\nchar: %c file(%d:%d)", c, pc.pos.line, pc.pos.col); |
| |
|
| |
if(pc.pos.col==0+1 && c=='@') { |
| |
if(pc.ls==LS_DEF_SPECIAL_BODY) { |
| |
// @SPECIAL |
| |
// ... |
| |
// @<here = |
| |
pop_LS(pc); // exiting from LS_DEF_SPECIAL_BODY state |
| |
} // continuing checks |
| |
if(pc.ls==LS_USER) { |
| |
push_LS(pc, LS_DEF_NAME); |
| |
RC; |
| |
} else // @ in first column inside some code [when could that be?] |
| |
result=BAD_METHOD_DECL_START; |
| |
goto break2; |
| } |
} |
| PC->col++; |
|
| |
|
| /* escaping: ^^ ^$ ^; ^) ^} ^( ^{ */ |
|
| if(c=='^') { |
if(c=='^') { |
| char pending_c=*PC->source; |
if(pc.ls==LS_METHOD_AFTER) { |
| |
// handle after-method situation |
| |
pop_LS(pc); |
| |
result=EON; |
| |
skip_analized=-1; // return to punctuation afterwards to assure it's literality |
| |
goto break2; |
| |
} |
| |
switch(pc.ls) { |
| |
case LS_EXPRESSION_VAR_NAME_WITH_COLON: |
| |
case LS_EXPRESSION_VAR_NAME_WITHOUT_COLON: |
| |
case LS_VAR_NAME_SIMPLE_WITH_COLON: |
| |
case LS_VAR_NAME_SIMPLE_WITHOUT_COLON: |
| |
case LS_VAR_NAME_CURLY: |
| |
case LS_METHOD_NAME: |
| |
case LS_USER_COMMENT: |
| |
case LS_DEF_COMMENT: |
| |
// no literals in names, please |
| |
break; |
| |
default: |
| |
switch(*pc.source) { |
| |
// ^escaping some punctuators |
| |
case '^': case '$': case ';': case '@': |
| |
case '(': case ')': |
| |
case '[': case ']': |
| |
case '{': case '}': |
| |
case '"': case ':': |
| |
if(end!=begin) { |
| |
if(!pc.string_start) |
| |
pc.string_start=begin_pos; |
| |
// append piece till ^ |
| |
pc.string.append_strdup_know_length(begin, end-begin); |
| |
} |
| |
// reset piece 'begin' position & line |
| |
begin=pc.source; // ->punctuation |
| |
begin_pos=pc.pos; |
| |
// skip over _ after ^ |
| |
pc.source++; pc.pos.col++; |
| |
// skip analysis = forced literal |
| |
continue; |
| |
|
| if(pending_c=='^' || pending_c=='$' || pending_c==';' || |
// converting ^#HH into char(hex(HH)) |
| pending_c=='(' || pending_c==')' || |
case '#': |
| pending_c=='{' || pending_c=='}') { |
if(end!=begin) { |
| /* append piece till ^ */ |
if(!pc.string_start) |
| PC->string->APPEND(begin, end-begin, PC->file, begin_line); |
pc.string_start=begin_pos; |
| /* reset piece 'start' position & line */ |
// append piece till ^ |
| begin=PC->source/*^*/; |
pc.string.append_strdup_know_length(begin, end-begin); |
| begin_line=PC->line; |
} |
| /* skip over ^ and _ */ |
// #HH ? |
| PC->source+=2; |
if(pc.source[1] && isxdigit(pc.source[1]) && pc.source[2] && isxdigit(pc.source[2])) { |
| /* skip analysis = forced literal */ |
char c=(char)( |
| |
hex_value[(unsigned char)pc.source[1]]*0x10+ |
| |
hex_value[(unsigned char)pc.source[2]]); |
| |
if(c==0) { |
| |
result=BAD_HEX_LITERAL; |
| |
goto break2; // wrong hex value[no ^#00 chars allowed]: bail out |
| |
} |
| |
// append char(hex(HH)) |
| |
pc.string.append(c); |
| |
// skip over ^#HH |
| |
pc.source+=3; |
| |
pc.pos.col+=3; |
| |
// reset piece 'begin' position & line |
| |
begin=pc.source; // ->after ^#HH |
| |
begin_pos=pc.pos; |
| |
// skip analysis = forced literal |
| |
continue; |
| |
} |
| |
// just escaped char |
| |
// reset piece 'begin' position & line |
| |
begin=pc.source; |
| |
begin_pos=pc.pos; |
| |
// skip over _ after ^ |
| |
pc.source++; pc.pos.col++; |
| |
// skip analysis = forced literal |
| continue; |
continue; |
| } |
} |
| |
break; |
| |
} |
| } |
} |
| switch(PC->ls) { |
// #comment start skipping |
| |
if(c=='#' && pc.pos.col==1) { |
| |
if(end!=begin) { |
| |
if(!pc.string_start) |
| |
pc.string_start=begin_pos; |
| |
// append piece till # |
| |
pc.string.append_strdup_know_length(begin, end-begin); |
| |
} |
| |
// fall into COMMENT lexical state [wait for \n] |
| |
push_LS(pc, LS_USER_COMMENT); |
| |
continue; |
| |
} |
| |
switch(pc.ls) { |
| |
|
| |
// USER'S = NOT OURS |
| case LS_USER: |
case LS_USER: |
| if(c=='$') { |
case LS_NAME_SQUARE_PART: // name.[here].xxx |
| push_LS(PC); PC->ls=LS_VAR_NAME_SIMPLE; |
if(pc.trim_bof) |
| result=c; |
switch(c) { |
| goto break2; |
case '\n': case ' ': case '\t': |
| |
begin=pc.source; |
| |
begin_pos=pc.pos; |
| |
continue; // skip it |
| |
default: |
| |
pc.trim_bof=false; |
| |
} |
| |
switch(c) { |
| |
case '$': |
| |
push_LS(pc, LS_VAR_NAME_SIMPLE_WITH_COLON); |
| |
RC; |
| |
case '^': |
| |
push_LS(pc, LS_METHOD_NAME); |
| |
RC; |
| |
case ']': |
| |
if(pc.ls==LS_NAME_SQUARE_PART) |
| |
if(--lexical_brackets_nestage==0) {// $name.[co<]?>de<]?> |
| |
pop_LS(pc); // $name.[co<]>de<]!> |
| |
RC; |
| |
} |
| |
break; |
| |
case '[': // $name.[co<[>de] |
| |
if(pc.ls==LS_NAME_SQUARE_PART) |
| |
lexical_brackets_nestage++; |
| |
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; |
| |
|
| |
// #COMMENT |
| |
case LS_USER_COMMENT: |
| |
if(c=='\n') { |
| |
// skip comment |
| |
begin=pc.source; |
| |
begin_pos=pc.pos; |
| |
|
| |
pop_LS(pc); |
| |
continue; |
| } |
} |
| if(c=='^') { |
break; |
| push_LS(PC); PC->ls=LS_METHOD_NAME; |
|
| result=c; |
// STRING IN EXPRESSION |
| goto break2; |
case LS_EXPRESSION_STRING_QUOTED: |
| |
case LS_EXPRESSION_STRING_APOSTROFED: |
| |
switch(c) { |
| |
case '"': |
| |
case '\'': |
| |
if( |
| |
(pc.ls == LS_EXPRESSION_STRING_QUOTED && c=='"') || |
| |
(pc.ls == LS_EXPRESSION_STRING_APOSTROFED && c=='\'') ) { |
| |
pop_LS(pc); //"abc". | 'abc'. |
| |
RC; |
| |
} |
| |
break; |
| |
case '$': |
| |
push_LS(pc, LS_VAR_NAME_SIMPLE_WITH_COLON); |
| |
RC; |
| |
case '^': |
| |
push_LS(pc, LS_METHOD_NAME); |
| |
RC; |
| } |
} |
| break; |
break; |
| |
|
| /* VAR */ |
// METHOD DEFINITION |
| case LS_VAR_NAME_SIMPLE: |
case LS_DEF_NAME: |
| if(c==0 || |
switch(c) { |
| c==' '|| c=='\t' || c=='\n' || |
case '[': |
| c==')' || c=='}') { |
pc.ls=LS_DEF_PARAMS; |
| pop_LS(PC); |
RC; |
| PC->source--; PC->col--; |
case '\n': |
| result=END_OF_NAME; |
pc.ls=LS_DEF_SPECIAL_BODY; |
| goto break2; |
RC; |
| } |
} |
| if(begin==end && c=='{') { /* ${name}, no need of END_OF_NAME, switching LS */ |
break; |
| PC->ls=LS_VAR_NAME_CURLY; |
|
| result=c; |
case LS_DEF_PARAMS: |
| goto break2; |
switch(c) { |
| |
case '$': // common error |
| |
result=BAD_METHOD_PARAMETER_NAME_CHARACTER; |
| |
goto break2; |
| |
case ';': |
| |
RC; |
| |
case ']': |
| |
pc.ls=*pc.source=='['?LS_DEF_LOCALS:LS_DEF_COMMENT; |
| |
RC; |
| |
case '\n': // wrong. bailing out |
| |
pop_LS(pc); |
| |
RC; |
| } |
} |
| if(c=='(') { |
break; |
| PC->ls=LS_VAR_ROUND; |
|
| lexical_brackets_nestage=1; |
case LS_DEF_LOCALS: |
| result=c; |
switch(c) { |
| goto break2; |
case '[': |
| |
case ';': |
| |
RC; |
| |
case ']': |
| |
pc.ls=LS_DEF_COMMENT; |
| |
RC; |
| |
case '\n': // wrong. bailing out |
| |
pop_LS(pc); |
| |
RC; |
| |
} |
| |
break; |
| |
|
| |
case LS_DEF_COMMENT: |
| |
if(c=='\n') { |
| |
pop_LS(pc); |
| |
RC; |
| } |
} |
| if(c=='{') { |
break; |
| PC->ls=LS_VAR_CURLY; |
|
| |
case LS_DEF_SPECIAL_BODY: |
| |
if(c=='\n') |
| |
RC; |
| |
break; |
| |
|
| |
// (EXPRESSION) |
| |
case LS_VAR_ROUND: |
| |
case LS_METHOD_ROUND: |
| |
switch(c) { |
| |
case ')': |
| |
if(--lexical_brackets_nestage==0) { |
| |
if(pc.ls==LS_METHOD_ROUND) // method round param ended |
| |
pc.ls=LS_METHOD_AFTER; // look for method end |
| |
else // pc.ls==LS_VAR_ROUND // variable constructor ended |
| |
pop_LS(pc); // return to normal life |
| |
} |
| |
RC; |
| |
case '#': // comment start skipping |
| |
if(end!=begin) { |
| |
if(!pc.string_start) |
| |
pc.string_start=begin_pos; |
| |
// append piece till # |
| |
pc.string.append_strdup_know_length(begin, end-begin); |
| |
} |
| |
// fall into COMMENT lexical state [wait for \n] |
| |
push_LS(pc, LS_EXPRESSION_COMMENT); |
| lexical_brackets_nestage=1; |
lexical_brackets_nestage=1; |
| result=c; |
continue; |
| |
case '$': |
| |
push_LS(pc, LS_EXPRESSION_VAR_NAME_WITH_COLON); |
| |
RC; |
| |
case '^': |
| |
push_LS(pc, LS_METHOD_NAME); |
| |
RC; |
| |
case '(': |
| |
lexical_brackets_nestage++; |
| |
RC; |
| |
case '-': |
| |
switch(*pc.source) { |
| |
case 'f': // -f |
| |
skip_analized=1; |
| |
result=FEXISTS; |
| |
goto break2; |
| |
case 'd': // -d |
| |
skip_analized=1; |
| |
result=DEXISTS; |
| |
goto break2; |
| |
default: // minus |
| |
result=c; |
| |
goto break2; |
| |
} |
| goto break2; |
goto break2; |
| } |
case '+': case '*': case '/': case '%': case '\\': |
| if(c=='.'/* name part delim */ || c=='$'/* name part subvar */) { |
case '~': |
| result=c; |
case ';': |
| |
RC; |
| |
case '&': case '|': |
| |
if(*pc.source==c) { // && || |
| |
result=c=='&'?LAND:LOR; |
| |
skip_analized=1; |
| |
} else |
| |
result=c; |
| goto break2; |
goto break2; |
| } |
case '!': |
| break; |
switch(pc.source[0]) { |
| case LS_VAR_NAME_CURLY: |
case '|': // !| !|| |
| if(c=='}') { /* ${name} finished, restoring LS */ |
skip_analized=1; |
| pop_LS(PC); |
if(pc.source[1]=='|') { |
| result=c; |
skip_analized++; |
| |
result=LXOR; |
| |
} else |
| |
result=NXOR; |
| |
goto break2; |
| |
case '=': // != |
| |
skip_analized=1; |
| |
result=NNE; |
| |
goto break2; |
| |
} |
| |
RC; |
| |
|
| |
case '<': // <<, <=, < |
| |
switch(*pc.source) { |
| |
case '<': // <[<] |
| |
skip_analized=1; result=NSL; break; |
| |
case '=': // <[=] |
| |
skip_analized=1; result=NLE; break; |
| |
default: // <[] |
| |
result=c; break; |
| |
} |
| goto break2; |
goto break2; |
| } |
case '>': // >>, >=, > |
| if(c=='.'/* name part delim */ || c=='$'/*name part subvar*/) { |
switch(*pc.source) { |
| result=c; |
case '>': // >[>] |
| |
skip_analized=1; result=NSR; break; |
| |
case '=': // >[=] |
| |
skip_analized=1; result=NGE; break; |
| |
default: // >[] |
| |
result=c; break; |
| |
} |
| |
goto break2; |
| |
case '=': // == |
| |
switch(*pc.source) { |
| |
case '=': // =[=] |
| |
skip_analized=1; result=NEQ; break; |
| |
default: // =[] |
| |
result=c; break; // not used now |
| |
} |
| goto break2; |
goto break2; |
| |
|
| |
case '"': |
| |
push_LS(pc, LS_EXPRESSION_STRING_QUOTED); |
| |
RC; |
| |
case '\'': |
| |
push_LS(pc, LS_EXPRESSION_STRING_APOSTROFED); |
| |
RC; |
| |
case 'l': case 'g': case 'e': case 'n': |
| |
if(end==begin) // right after whitespace |
| |
if(isspace(pc.source[1])) { |
| |
switch(*pc.source) { |
| |
// case '?': // ok [and bad cases, yacc would bark at them] |
| |
case 't': // lt gt [et nt] |
| |
result=c=='l'?SLT:c=='g'?SGT:BAD_STRING_COMPARISON_OPERATOR; |
| |
skip_analized=1; |
| |
goto break2; |
| |
case 'e': // le ge ne [ee] |
| |
result=c=='l'?SLE:c=='g'?SGE:c=='n'?SNE:BAD_STRING_COMPARISON_OPERATOR; |
| |
skip_analized=1; |
| |
goto break2; |
| |
case 'q': // eq [lq gq nq] |
| |
result=c=='e'?SEQ:BAD_STRING_COMPARISON_OPERATOR; |
| |
skip_analized=1; |
| |
goto break2; |
| |
} |
| |
} |
| |
break; |
| |
case 'i': |
| |
if(end==begin) // right after whitespace |
| |
if(isspace(pc.source[1])) { |
| |
switch(pc.source[0]) { |
| |
case 'n': // in |
| |
skip_analized=1; |
| |
result=IN; |
| |
goto break2; |
| |
case 's': // is |
| |
skip_analized=1; |
| |
result=IS; |
| |
goto break2; |
| |
} |
| |
} |
| |
break; |
| |
case 'd': |
| |
if(end==begin) // right after whitespace |
| |
if(pc.source[0]=='e' && pc.source[1]=='f') { // def |
| |
switch(pc.source[2]){ |
| |
case ' ': case '\t': case '\n': case '"': case '\'': case '^': case '$': // non-quoted string without whitespace after 'def' is not allowed |
| |
skip_analized=2; |
| |
result=DEF; |
| |
goto break2; |
| |
} |
| |
// error: incorrect char after 'def' |
| |
} |
| |
break; |
| |
case 't': |
| |
if(end==begin) // right after whitespace |
| |
if(pc.source[0]=='r' && pc.source[1]=='u' && pc.source[2]=='e') { // true |
| |
skip_analized=3; |
| |
result=LITERAL_TRUE; |
| |
goto break2; |
| |
} |
| |
break; |
| |
case 'f': |
| |
if(end==begin) // right after whitespace |
| |
if(pc.source[0]=='a' && pc.source[1]=='l' && pc.source[2]=='s' && pc.source[3]=='e') { // false |
| |
skip_analized=4; |
| |
result=LITERAL_FALSE; |
| |
goto break2; |
| |
} |
| |
break; |
| |
case ' ': case '\t': case '\n': |
| |
if(end!=begin) { // there were a string after previous operator? |
| |
result=0; // return that string |
| |
goto break2; |
| |
} |
| |
// that's a leading|traling space or after-operator-space |
| |
// ignoring it |
| |
// reset piece 'begin' position & line |
| |
begin=pc.source; // after whitespace char |
| |
begin_pos=pc.pos; |
| |
continue; |
| } |
} |
| break; |
break; |
| case LS_VAR_ROUND: |
case LS_EXPRESSION_COMMENT: |
| if(c=='$') { |
if(c=='(') |
| push_LS(PC); PC->ls=LS_VAR_NAME_SIMPLE; |
lexical_brackets_nestage++; |
| result=c; |
|
| goto break2; |
switch(*pc.source) { |
| |
case '\n': case ')': |
| |
if(*pc.source==')') |
| |
if(--lexical_brackets_nestage!=0) |
| |
continue; |
| |
|
| |
// skip comment |
| |
begin=pc.source; |
| |
begin_pos=pc.pos; |
| |
|
| |
pop_LS(pc); |
| |
continue; |
| } |
} |
| if(c=='^') { |
break; |
| push_LS(PC); PC->ls=LS_METHOD_NAME; |
|
| result=c; |
// VARIABLE GET/PUT/WITH |
| goto break2; |
case LS_VAR_NAME_SIMPLE_WITH_COLON: |
| |
case LS_VAR_NAME_SIMPLE_WITHOUT_COLON: |
| |
case LS_EXPRESSION_VAR_NAME_WITH_COLON: |
| |
case LS_EXPRESSION_VAR_NAME_WITHOUT_COLON: |
| |
if( |
| |
pc.ls==LS_EXPRESSION_VAR_NAME_WITH_COLON || |
| |
pc.ls==LS_EXPRESSION_VAR_NAME_WITHOUT_COLON) { |
| |
// name in expr ends also before |
| |
switch(c) { |
| |
// expression minus |
| |
case '-': |
| |
// expression integer division |
| |
case '\\': |
| |
pop_LS(pc); |
| |
pc.ungetc(); |
| |
result=EON; |
| |
goto break2; |
| |
} |
| } |
} |
| if(c==')') { |
if( |
| if(--lexical_brackets_nestage==0) { |
pc.ls==LS_VAR_NAME_SIMPLE_WITHOUT_COLON || |
| pop_LS(PC); |
pc.ls==LS_EXPRESSION_VAR_NAME_WITHOUT_COLON) { |
| result=c; |
// name already has ':', stop before next |
| |
switch(c) { |
| |
case ':': |
| |
pop_LS(pc); |
| |
pc.ungetc(); |
| |
result=EON; |
| goto break2; |
goto break2; |
| } |
} |
| } |
} |
| if(c==';'/* operator_or_fmt;value delim */) { |
switch(c) { |
| result=c; |
case 0: |
| goto break2; |
case ' ': case '\t': case '\n': |
| |
case ';': |
| |
case ']': case '}': case ')': |
| |
case '"': case '\'': |
| |
case '<': case '>': // these stand for HTML brackets AND expression binary ops |
| |
case '+': case '*': case '/': case '\\': case '%': |
| |
case '&': case '|': |
| |
case '=': case '!': |
| |
// common delimiters |
| |
case ',': case '?': case '#': |
| |
// mysql column separators |
| |
case '`': |
| |
// before call |
| |
case '^': |
| |
pop_LS(pc); |
| |
pc.ungetc(); |
| |
result=EON; |
| |
goto break2; |
| |
case '[': |
| |
// $name.<[>code] |
| |
if(pc.pos.col>1/*not first column*/ && ( |
| |
end[-1]=='$'/*was start of get*/ || |
| |
end[-1]==':'/*was class name delim */ || |
| |
end[-1]=='.'/*was name delim */ |
| |
)) { |
| |
push_LS(pc, LS_NAME_SQUARE_PART); |
| |
lexical_brackets_nestage=1; |
| |
RC; |
| |
} |
| |
pc.ls=LS_VAR_SQUARE; |
| |
lexical_brackets_nestage=1; |
| |
RC; |
| |
case '{': |
| |
if(begin==end) { // ${name}, no need of EON, switching LS |
| |
pc.ls=LS_VAR_NAME_CURLY; |
| |
} else { |
| |
pc.ls=LS_VAR_CURLY; |
| |
lexical_brackets_nestage=1; |
| |
} |
| |
|
| |
RC; |
| |
case '(': |
| |
pc.ls=LS_VAR_ROUND; |
| |
lexical_brackets_nestage=1; |
| |
RC; |
| |
case '.': // name part delim |
| |
case '$': // name part subvar |
| |
case ':': // class<:>name |
| |
// go to _WITHOUT_COLON state variant... |
| |
if(pc.ls==LS_VAR_NAME_SIMPLE_WITH_COLON) |
| |
pc.ls=LS_VAR_NAME_SIMPLE_WITHOUT_COLON; |
| |
else if(pc.ls==LS_EXPRESSION_VAR_NAME_WITH_COLON) |
| |
pc.ls=LS_EXPRESSION_VAR_NAME_WITHOUT_COLON; |
| |
// ...stop before next ':' |
| |
RC; |
| } |
} |
| if(c=='(') |
|
| lexical_brackets_nestage++; |
|
| break; |
break; |
| case LS_VAR_CURLY: |
|
| if(c=='$') { |
case LS_VAR_NAME_CURLY: |
| push_LS(PC); PC->ls=LS_VAR_NAME_SIMPLE; |
switch(c) { |
| result=c; |
case '[': |
| goto break2; |
// ${name.<[>code]} |
| |
push_LS(pc, LS_NAME_SQUARE_PART); |
| |
lexical_brackets_nestage=1; |
| |
RC; |
| |
case '}': // ${name} finished, restoring LS |
| |
pop_LS(pc); |
| |
RC; |
| |
case '.': // name part delim |
| |
case '$': // name part subvar |
| |
case ':': // ':name' or 'class:name' |
| |
RC; |
| } |
} |
| if(c=='^') { |
break; |
| push_LS(PC); PC->ls=LS_METHOD_NAME; |
|
| result=c; |
case LS_VAR_SQUARE: |
| goto break2; |
switch(c) { |
| |
case '$': |
| |
push_LS(pc, LS_VAR_NAME_SIMPLE_WITH_COLON); |
| |
RC; |
| |
case '^': |
| |
push_LS(pc, LS_METHOD_NAME); |
| |
RC; |
| |
case ']': |
| |
if(--lexical_brackets_nestage==0) { |
| |
pop_LS(pc); |
| |
RC; |
| |
} |
| |
break; |
| |
case ';': // operator_or_fmt;value delim |
| |
RC; |
| |
case '[': |
| |
lexical_brackets_nestage++; |
| |
break; |
| } |
} |
| if(c=='}') |
break; |
| |
|
| |
case LS_VAR_CURLY: |
| |
switch(c) { |
| |
case '$': |
| |
push_LS(pc, LS_VAR_NAME_SIMPLE_WITH_COLON); |
| |
RC; |
| |
case '^': |
| |
push_LS(pc, LS_METHOD_NAME); |
| |
RC; |
| |
case '}': |
| if(--lexical_brackets_nestage==0) { |
if(--lexical_brackets_nestage==0) { |
| pop_LS(PC); |
pop_LS(pc); |
| result=c; |
RC; |
| goto break2; |
|
| } |
} |
| if(c=='{') |
break; |
| |
case '{': |
| lexical_brackets_nestage++; |
lexical_brackets_nestage++; |
| |
break; |
| |
} |
| break; |
break; |
| |
|
| /* METHOD */ |
// METHOD CALL |
| case LS_METHOD_NAME: |
case LS_METHOD_NAME: |
| if(c=='(') { |
switch(c) { |
| PC->ls=LS_METHOD_ROUND; |
case '[': |
| |
// ^name.<[>code].xxx |
| |
if(pc.pos.col>1/*not first column*/ && ( |
| |
end[-1]=='^'/*was start of call*/ || // never, ^[ is literal... |
| |
end[-1]==':'/*was class name delim */ || |
| |
end[-1]=='.'/*was name delim */ |
| |
)) { |
| |
push_LS(pc, LS_NAME_SQUARE_PART); |
| |
lexical_brackets_nestage=1; |
| |
RC; |
| |
} |
| |
pc.ls=LS_METHOD_SQUARE; |
| lexical_brackets_nestage=1; |
lexical_brackets_nestage=1; |
| result=c; |
RC; |
| goto break2; |
case '{': |
| } |
pc.ls=LS_METHOD_CURLY; |
| if(c=='{') { |
|
| PC->ls=LS_METHOD_CURLY; |
|
| lexical_brackets_nestage=1; |
lexical_brackets_nestage=1; |
| result=c; |
RC; |
| goto break2; |
case '(': |
| } |
pc.ls=LS_METHOD_ROUND; |
| if(c=='.'/* name part delim */ || c=='$'/* name part subvar */) { |
lexical_brackets_nestage=1; |
| result=c; |
RC; |
| goto break2; |
case '.': // name part delim |
| |
case '$': // name part subvar |
| |
case ':': // ':name' or 'class:name' |
| |
case '^': // ^abc^xxx wrong. bailing out |
| |
case ']': case '}': case ')': // ^abc]}) wrong. bailing out |
| |
case ' ': // ^if ( wrong. bailing out |
| |
RC; |
| } |
} |
| break; |
break; |
| case LS_METHOD_ROUND: |
|
| if(c=='$') { |
case LS_METHOD_SQUARE: |
| push_LS(PC); PC->ls=LS_VAR_NAME_SIMPLE; |
switch(c) { |
| result=c; |
case '$': |
| goto break2; |
push_LS(pc, LS_VAR_NAME_SIMPLE_WITH_COLON); |
| } |
RC; |
| if(c=='^') { |
case '^': |
| push_LS(PC); PC->ls=LS_METHOD_NAME; |
push_LS(pc, LS_METHOD_NAME); |
| result=c; |
RC; |
| goto break2; |
case ';': // param delim |
| } |
RC; |
| if(c==';'/* param delim */) { |
case ']': |
| result=c; |
|
| goto break2; |
|
| } |
|
| if(c==')') |
|
| if(--lexical_brackets_nestage==0) { |
if(--lexical_brackets_nestage==0) { |
| PC->ls=LS_METHOD_AFTER; |
pc.ls=LS_METHOD_AFTER; |
| result=c; |
RC; |
| goto break2; |
|
| } |
} |
| if(c=='(') |
break; |
| |
case '[': |
| lexical_brackets_nestage++; |
lexical_brackets_nestage++; |
| |
break; |
| |
} |
| break; |
break; |
| |
|
| case LS_METHOD_CURLY: |
case LS_METHOD_CURLY: |
| if(c=='$') { |
switch(c) { |
| push_LS(PC); PC->ls=LS_VAR_NAME_SIMPLE; |
case '$': |
| result=c; |
push_LS(pc, LS_VAR_NAME_SIMPLE_WITH_COLON); |
| goto break2; |
RC; |
| } |
case '^': |
| if(c=='^') { |
push_LS(pc, LS_METHOD_NAME); |
| push_LS(PC); PC->ls=LS_METHOD_NAME; |
RC; |
| result=c; |
case ';': // param delim |
| goto break2; |
RC; |
| } |
case '}': |
| if(c=='}') |
|
| if(--lexical_brackets_nestage==0) { |
if(--lexical_brackets_nestage==0) { |
| PC->ls=LS_METHOD_AFTER; |
pc.ls=LS_METHOD_AFTER; |
| result=c; |
RC; |
| goto break2; |
|
| } |
} |
| if(c=='{') |
break; |
| |
case '{': |
| lexical_brackets_nestage++; |
lexical_brackets_nestage++; |
| |
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_ROUND; |
pc.ls=LS_METHOD_SQUARE; |
| lexical_brackets_nestage=1; |
lexical_brackets_nestage=1; |
| result=c; |
RC; |
| goto break2; |
|
| } |
} |
| if(c=='{') {/* ){ }{ */ |
if(c=='{') {/* ]{ }{ ){ */ |
| PC->ls=LS_METHOD_CURLY; |
pc.ls=LS_METHOD_CURLY; |
| lexical_brackets_nestage=1; |
lexical_brackets_nestage=1; |
| result=c; |
RC; |
| goto break2; |
} |
| |
if(c=='(') {/* ]( }( )( */ |
| |
pc.ls=LS_METHOD_ROUND; |
| |
lexical_brackets_nestage=1; |
| |
RC; |
| } |
} |
| pop_LS(PC); |
pop_LS(pc); |
| PC->source--; PC->col--; |
pc.ungetc(); |
| result=END_OF_NAME; |
result=EON; |
| goto break2; |
goto break2; |
| } |
} |
| if(c==0) { |
if(c==0) { |
| result=-1; |
result=-1; |
| PC->source--; PC->col--; |
|
| break; |
break; |
| } |
} |
| } |
} |
| |
|
| break2: |
break2: |
| if(begin==end) |
if(end!=begin) { // there is last piece? |
| return result; |
if(c=='@' || c==0) // we are before LS_DEF_NAME or EOF? |
| else { |
while(end!=begin && end[-1]=='\n') // trim all empty lines before LS_DEF_NAME and EOF |
| PC->pending_state=result; |
end--; |
| /* append last piece */ |
if(end!=begin && pc.ls!=LS_USER_COMMENT) { // last piece still alive and not comment? |
| PC->string->APPEND(begin, end-begin, PC->file, begin_line/*, start_col*/); |
if(!pc.string_start) |
| /* create STRING value: array of OP_STRING+string */ |
pc.string_start=begin_pos; |
| *lvalp=L(PC->string); |
// append it |
| /* new pieces storage */ |
pc.string.append_strdup_know_length(begin, end-begin); |
| PC->string=new(pool) String(pool); |
} |
| /* go */ |
} |
| return STRING; |
if(!pc.string.is_empty()) { // something accumulated? |
| |
// create STRING value: array of OP_VALUE+origin+vstring |
| |
*lvalp=VL( |
| |
new VString(*new String(pc.string, String::L_CLEAN)), |
| |
pc.file_no, pc.string_start.line, pc.string_start.col); |
| |
// new pieces storage |
| |
pc.string.clear(); |
| |
pc.string_start.clear(); |
| |
// make current result be pending for next call, return STRING for now |
| |
pc.pending_state=result; result=STRING; |
| } |
} |
| |
if(skip_analized) { |
| |
pc.source+=skip_analized; pc.pos.col+=skip_analized; |
| |
} |
| |
return result; |
| } |
} |
| |
|
| int real_yyerror(parse_control *pc, char *s) /* Called by yyparse on error */ |
static int real_yyerror(Parse_control *pc, const char *s) { // Called by yyparse on error |
| { |
strncpy(PC.error, s, MAX_STRING); |
| fprintf(stderr, "[%s]\n", s); |
|
| |
|
| s[MAX_STRING-1]=0; strcpy(pc->error, s); |
|
| return 1; |
return 1; |
| } |
} |
| |
|
| static void |
|
| yyprint( |
|
| FILE *file, |
|
| int type, |
|
| YYSTYPE value) |
|
| { |
|
| if(type==STRING) |
|
| fprintf(file, " \"%s\"", LA2S(value)->cstr()); |
|
| } |
|
| |
|
| |
static void yyprint(FILE *file, int type, YYSTYPE value) { |
| |
if(type==STRING) |
| |
fprintf(file, " \"%s\"", LA2S(*value)->cstr()); |
| |
} |
![[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