[BACK]Return to compile.y CVS log [TXT] [DIR] Up to [parser3project] / parser3 / src / main

Diff for /parser3/src/main/compile.y between versions 1.204.2.1 and 1.204.2.6

version 1.204.2.1, 2003/01/30 09:34:30 version 1.204.2.6, 2003/02/04 09:44:27
Line 19 Line 19
                 -#:     in iis make up specialized Pool object for that                  -#:     in iis make up specialized Pool object for that
 */  */
   
 #define YYSTYPE  ArrayOperation*  #define YYSTYPE  ArrayOperationPtr
 #define YYPARSE_PARAM  pc  #define YYPARSE_PARAM  pc
 #define YYLEX_PARAM  pc  #define YYLEX_PARAM  pc
 #define YYDEBUG  1  #define YYDEBUG  1
Line 114  static int yylex(YYSTYPE *lvalp, void *p Line 114  static int yylex(YYSTYPE *lvalp, void *p
 %%  %%
 all:  all:
         one_big_piece {          one_big_piece {
         Method& method=*NEW Method(POOL,           MethodPtr method(new Method(main_method_name, Method::CT_ANY,
                 PC.request->main_method_name,   
                 Method::CT_ANY,  
                 0, 0, /*min, max numbered_params_count*/                  0, 0, /*min, max numbered_params_count*/
                 0/*param_names*/, 0/*local_names*/,                   ArrayStringPtr(0)/*param_names*/, ArrayStringPtr(0)/*local_names*/, 
                 $1/*parser_code*/, 0/*native_code*/);                  $1/*parser_code*/, 0/*native_code*/));
         PC.cclass->add_method(PC.request->main_method_name, method);          PC.cclass->add_method(main_method_name, method);
 }  }
 |       methods;  |       methods;
   
Line 131  method: control_method | code_method; Line 129  method: control_method | code_method;
   
 control_method: '@' STRING '\n'   control_method: '@' STRING '\n' 
                                 maybe_control_strings {                                  maybe_control_strings {
         const String& command=*LA2S($2);          StringPtr command=LA2S(*$2);
         YYSTYPE strings_code=$4;          YYSTYPE strings_code=$4;
         if(strings_code->size()<1*2) {          if(strings_code->count()<1*2) {
                 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");
                 YYERROR;                  YYERROR;
         }          }
         if(command==CLASS_NAME) {          if(*command==CLASS_NAME) {
                 if(PC.cclass->base_class()) { // already changed from default?                  if(PC.cclass->base_class()) { // already changed from default?
                         strcpy(PC.error, "class already have a name '");                          strcpy(PC.error, "class already have a name '");
                         strncat(PC.error, PC.cclass->name().cstr(), 100);                          strncat(PC.error, PC.cclass->name()->cstr(), 100);
                         strcat(PC.error, "'");                          strcat(PC.error, "'");
                         YYERROR;                          YYERROR;
                 }                  }
                 if(strings_code->size()==1*2) {                  if(strings_code->count()==1*2) {
                         // new class' name                          // new class' name
                         const String *name=LA2S(strings_code);                          StringPtr name=LA2S(*strings_code);
                         // creating the class                          // creating the class
                         PC.cclass=NEW VClass(POOL);                          VStateless_classPtr cclass(new VClass);
                         PC.cclass->set_name(*name);                          PC.cclass=cclass.get();
                           PC.cclass->set_name(name);
                         // append to request's classes                          // append to request's classes
                         PC.request->classes().put(*name, PC.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 sole name");
                         YYERROR;                          YYERROR;
                 }                  }
         } else if(command==USE_CONTROL_METHOD_NAME) {          } else if(*command==USE_CONTROL_METHOD_NAME) {
                 for(int i=0; i<strings_code->size(); i+=2)                   for(int i=0; i<strings_code->count(); i+=2) 
                         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?
                         strcpy(PC.error, "class already have a base '");                          strcpy(PC.error, "class already have a base '");
                         strncat(PC.error, PC.cclass->base_class()->name().cstr(), 100);                          strncat(PC.error, PC.cclass->base_class()->name()->cstr(), 100);
                         strcat(PC.error, "'");                          strcat(PC.error, "'");
                         YYERROR;                          YYERROR;
                 }                  }
                 if(strings_code->size()==1*2) {                  if(strings_code->count()==1*2) {
                         const String& base_name=*LA2S(strings_code);                          StringPtr base_name=LA2S(*strings_code);
                         Value *vbase_class=static_cast<VClass *>(                          if(ValuePtr base_class_value=PC.request->classes().get(base_name)) {
                                 PC.request->classes().get(base_name));                                  // @CLASS == @BASE sanity check
                         VStateless_class *base_class=vbase_class?vbase_class->get_class():0;                                  if(VStateless_class *base_class=base_class_value->get_class()) {
                         if(!base_class) {                                          if(PC.cclass==base_class) {
                                 strcpy(PC.error, base_name.cstr());                                                  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);                                  strcat(PC.error, ": undefined class in @"BASE_NAME);
                                 YYERROR;                                  YYERROR;
                         }                          }
                         // @CLASS == @BASE sanity check  
                         if(PC.cclass==base_class) {  
                                 strcpy(PC.error, "@"CLASS_NAME" equals @"BASE_NAME);  
                                 YYERROR;  
                         }  
                         PC.cclass->set_base(base_class);  
                 } else {                  } else {
                         strcpy(PC.error, "@"BASE_NAME" must contain sole name");                          strcpy(PC.error, "@"BASE_NAME" must contain sole name");
                         YYERROR;                          YYERROR;
                 }                  }
         } else {          } else {
                 strcpy(PC.error, "'");                  strcpy(PC.error, "'");
                 strncat(PC.error, command.cstr(), MAX_STRING/2);                  strncat(PC.error, command->cstr(), MAX_STRING/2);
                 strcat(PC.error, "' invalid special name. valid names are "                  strcat(PC.error, "' invalid special name. valid names are "
                         "'"CLASS_NAME"', '"USE_CONTROL_METHOD_NAME"' and '"BASE_NAME"'");                          "'"CLASS_NAME"', '"USE_CONTROL_METHOD_NAME"' and '"BASE_NAME"'");
                 YYERROR;                  YYERROR;
         }          }
 };  };
 maybe_control_strings: empty | control_strings;  maybe_control_strings: empty | control_strings;
 control_strings: control_string | control_strings control_string { $$=$1; P($$, $2) };  control_strings: control_string | control_strings control_string { $$=$1; P(*$$, *$2) };
 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 {                          maybe_codes {
         const String *name=LA2S($2);          StringPtr name=LA2S(*$2);
   
         YYSTYPE params_names_code=$3;          YYSTYPE params_names_code=$3;
         Array *params_names=0;          ArrayStringPtr params_names;
         if(int size=params_names_code->size()) {          if(int size=params_names_code->count()) {
                 params_names=NEW Array(POOL);                  params_names=ArrayStringPtr(new ArrayString);
                 for(int i=0; i<size; i+=2)                  for(int i=0; i<size; i+=2)
                         *params_names+=LA2S(params_names_code, i);                          *params_names+=LA2S(*params_names_code, i);
         }          }
   
         YYSTYPE locals_names_code=$4;          YYSTYPE locals_names_code=$4;
         Array *locals_names=0;          ArrayStringPtr locals_names;
         if(int size=locals_names_code->size()) {          if(int size=locals_names_code->count()) {
                 locals_names=NEW Array(POOL);                  locals_names=ArrayStringPtr(new ArrayString);
                 for(int i=0; i<size; i+=2)                  for(int i=0; i<size; i+=2)
                         *locals_names+=LA2S(locals_names_code, i);                          *locals_names+=LA2S(*locals_names_code, i);
         }          }
   
         Method& method=*NEW Method(POOL,           MethodPtr 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);                  $7, 0));
         PC.cclass->add_method(*name, method);          PC.cclass->add_method(name, method);
 };  };
   
 maybe_bracketed_strings: empty | bracketed_maybe_strings;  maybe_bracketed_strings: empty | bracketed_maybe_strings;
 bracketed_maybe_strings: '[' maybe_strings ']' {$$=$2};  bracketed_maybe_strings: '[' maybe_strings ']' {$$=$2};
 maybe_strings: empty | strings;  maybe_strings: empty | strings;
 strings: STRING | strings ';' STRING { $$=$1; P($$, $3) };  strings: STRING | strings ';' STRING { $$=$1; P(*$$, *$3) };
   
 maybe_comment: empty | STRING;  maybe_comment: empty | STRING;
   
Line 241  maybe_comment: empty | STRING; Line 244  maybe_comment: empty | STRING;
   
 maybe_codes: empty | codes;  maybe_codes: empty | codes;
   
 codes: code | codes code { $$=$1; P($$, $2) };  codes: code | codes code { $$=$1; P(*$$, *$2) };
 code: write_string | action;  code: write_string | action;
 action: get | put | call;  action: get | put | call;
   
Line 249  action: get | put | call; Line 252  action: get | put | call;
   
 get: get_value {  get: get_value {
         $$=$1; /* stack: resulting value */           $$=$1; /* stack: resulting value */ 
         changetail_or_append($$,           changetail_or_append(*$$, 
                 OP_GET_ELEMENT, false,  /*->*/OP_GET_ELEMENT__WRITE,                  OP_GET_ELEMENT, false,  /*->*/OP_GET_ELEMENT__WRITE,
                 /*or */OP_WRITE_VALUE                  /*or */OP_WRITE_VALUE
                 ); /* value=pop; wcontext.write(value) */                  ); /* value=pop; wcontext.write(value) */
Line 261  name_without_curly_rdive: Line 264  name_without_curly_rdive:
         name_without_curly_rdive_read           name_without_curly_rdive_read 
 |       name_without_curly_rdive_class;  |       name_without_curly_rdive_class;
 name_without_curly_rdive_read: name_without_curly_rdive_code {  name_without_curly_rdive_read: name_without_curly_rdive_code {
         $$=N(POOL);           $$=N(); 
         Array *diving_code=$1;          ArrayOperationPtr diving_code=$1;
         const String *first_name=LA2S(diving_code);          StringPtr first_name=LA2S(*diving_code);
         // self.xxx... -> xxx...          // self.xxx... -> xxx...
         // OP_VALUE+string+OP_GET_ELEMENT+... -> OP_WITH_SELF+...          // OP_VALUE+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->size()>=3?3/*OP_VALUE+string+OP_GET_ELEMENTx*/:2/*OP_+string*/);                          diving_code->count()>=3?3/*OP_VALUE+string+OP_GET_ELEMENTx*/:2/*OP_+string*/);
         } else {          } else {
                 O($$, OP_WITH_READ); /* stack: starting context */                  O(*$$, 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+string+OP_GET_ELEMENT. -> OP_VALUE+string+OP_GET_ELEMENT_OR_OPERATOR.
                 if(PC.in_call_value && diving_code->size()==3)                  if(PC.in_call_value && diving_code->count()==3)
                         diving_code->put_int(2, OP_GET_ELEMENT_OR_OPERATOR);                          (*diving_code)[2].code=OP_GET_ELEMENT_OR_OPERATOR;
                 P($$, diving_code);                  P(*$$, *diving_code);
         }          }
         /* diving code; stack: current context */          /* diving code; stack: current context */
 };  };
 name_without_curly_rdive_class: class_prefix name_without_curly_rdive_code { $$=$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) };  name_without_curly_rdive_code: name_advance2 | name_path name_advance2 { $$=$1; P(*$$, *$2) };
   
 /* put */  /* put */
   
 put: '$' name_expr_wdive construct {  put: '$' name_expr_wdive construct {
         $$=$2; /* stack: context,name */          $$=$2; /* stack: context,name */
         P($$, $3); /* stack: context,name,constructor_value */          P(*$$, *$3); /* stack: context,name,constructor_value */
 };  };
 name_expr_wdive:   name_expr_wdive: 
         name_expr_wdive_root          name_expr_wdive_root
 |       name_expr_wdive_write  |       name_expr_wdive_write
 |       name_expr_wdive_class;  |       name_expr_wdive_class;
 name_expr_wdive_root: name_expr_dive_code {  name_expr_wdive_root: name_expr_dive_code {
         $$=N(POOL);          $$=N();
         Array *diving_code=$1;          ArrayOperationPtr diving_code=$1;
         const String *first_name=LA2S(diving_code);          StringPtr first_name=LA2S(*diving_code);
         // $self.xxx... -> $xxx...          // $self.xxx... -> $xxx...
         // OP_VALUE+string+OP_GET_ELEMENT+... -> OP_WITH_SELF+...          // OP_VALUE+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->size()>=3?3/*OP_VALUE+string+OP_GET_ELEMENTx*/:2/*OP_+string*/);                          diving_code->count()>=3?3/*OP_VALUE+string+OP_GET_ELEMENTx*/:2/*OP_+string*/);
         } else {          } else {
                 O($$, OP_WITH_ROOT); /* stack: starting context */                  O(*$$, OP_WITH_ROOT); /* stack: starting context */
                 P($$, diving_code);                  P(*$$, *diving_code);
         }          }
         /* diving code; stack: current context */          /* diving code; stack: current context */
 };  };
 name_expr_wdive_write: '.' name_expr_dive_code {  name_expr_wdive_write: '.' name_expr_dive_code {
         $$=N(POOL);           $$=N(); 
         O($$, OP_WITH_WRITE); /* stack: starting context */          O(*$$, OP_WITH_WRITE); /* stack: starting context */
         P($$, $2); /* diving code; stack: context,name */          P(*$$, *$2); /* diving code; stack: context,name */
 };  };
 name_expr_wdive_class: class_prefix name_expr_dive_code { $$=$1; P($$, $2) };  name_expr_wdive_class: class_prefix name_expr_dive_code { $$=$1; P(*$$, *$2) };
   
 construct:   construct: 
         construct_square          construct_square
Line 327  construct: Line 330  construct:
 construct_square: '[' any_constructor_code_value ']' {  construct_square: '[' any_constructor_code_value ']' {
         // stack: context, name          // stack: context, name
         $$=$2; // stack: context, name, value          $$=$2; // 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) */
 }  }
 ;  ;
 construct_round: '(' expr_value ')' {   construct_round: '(' expr_value ')' { 
         $$=N(POOL);           $$=N(); 
         O($$, OP_PREPARE_TO_EXPRESSION);          O(*$$, OP_PREPARE_TO_EXPRESSION);
         // stack: context, name          // stack: context, name
         P($$, $2); // stack: context, name, value          P(*$$, *$2); // stack: context, name, value
         O($$, OP_CONSTRUCT_EXPR); /* value=pop->as_expr_result; name=pop; context=pop; construct(context,name,value) */          O(*$$, OP_CONSTRUCT_EXPR); /* value=pop->as_expr_result; name=pop; context=pop; construct(context,name,value) */
 }  }
 ;  ;
 construct_curly: '{' maybe_codes '}' {  construct_curly: '{' maybe_codes '}' {
         // stack: context, name          // stack: context, name
         $$=N(POOL);           $$=N(); 
         OA($$, OP_CURLY_CODE__CONSTRUCT, $2); /* code=pop; name=pop; context=pop; construct(context,name,junction(code)) */          OA(*$$, OP_CURLY_CODE__CONSTRUCT, $2); /* code=pop; name=pop; context=pop; construct(context,name,junction(code)) */
 };  };
   
 any_constructor_code_value:   any_constructor_code_value: 
Line 350  any_constructor_code_value: Line 353  any_constructor_code_value:
 |       constructor_code_value /* $var[something complex] */  |       constructor_code_value /* $var[something complex] */
 ;  ;
 constructor_code_value: constructor_code {  constructor_code_value: constructor_code {
         $$=N(POOL);           $$=N(); 
         OA($$, OP_OBJECT_POOL, $1); /* stack: empty write context */          OA(*$$, OP_OBJECT_POOL, $1); /* 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() */
 };  };
 constructor_code: codes__excluding_sole_str_literal;  constructor_code: codes__excluding_sole_str_literal;
 codes__excluding_sole_str_literal: action | code codes { $$=$1; P($$, $2) };  codes__excluding_sole_str_literal: action | code codes { $$=$1; P(*$$, *$2) };
   
 /* call */  /* call */
   
 call: call_value {  call: call_value {
         $$=$1; /* stack: value */          $$=$1; /* stack: value */
         changetail_or_append($$,           changetail_or_append(*$$, 
                 OP_CALL, true,  /*->*/ OP_CALL__WRITE,                  OP_CALL, true,  /*->*/ OP_CALL__WRITE,
                 /*or */OP_WRITE_VALUE); /* value=pop; wcontext.write(value) */                  /*or */OP_WRITE_VALUE); /* value=pop; wcontext.write(value) */
 };  };
Line 376  call_value: '^' { Line 379  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->size()==3) { // probably [] case. [OP_VALUE + Void + STORE_PARAM]          if(params_code->count()==3) { // probably [] case. [OP_VALUE + Void + STORE_PARAM]
                 if(Value *value=LA2V(params_code)) // it is OP_VALUE + value?                  if(ValuePtr value=LA2V(*params_code)) // it is OP_VALUE + 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=YYSTYPE(0); // ^zzz[] case. don't append lone empty param.
         }          }
         /* stack: context, method_junction */          /* stack: context, method_junction */
         OA($$, OP_CALL, params_code); // method_frame=make frame(pop junction); ncontext=pop; call(ncontext,method_frame) stack: value          OA(*$$, OP_CALL, params_code); // method_frame=make frame(pop junction); ncontext=pop; call(ncontext,method_frame) stack: value
 };  };
   
 call_name: name_without_curly_rdive;  call_name: name_without_curly_rdive;
   
 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_param: 
         store_square_param          store_square_param
 |       store_round_param  |       store_round_param
Line 398  store_round_param: '(' store_expr_param_ Line 401  store_round_param: '(' store_expr_param_
 store_curly_param: '{' store_curly_param_parts '}' {$$=$2};  store_curly_param: '{' store_curly_param_parts '}' {$$=$2};
 store_code_param_parts:  store_code_param_parts:
         store_code_param_part          store_code_param_part
 |       store_code_param_parts ';' store_code_param_part { $$=$1; P($$, $3) }  |       store_code_param_parts ';' store_code_param_part { $$=$1; P(*$$, *$3) }
 ;  ;
 store_expr_param_parts:  store_expr_param_parts:
         store_expr_param_part          store_expr_param_part
 |       store_expr_param_parts ';' store_expr_param_part { $$=$1; P($$, $3) }  |       store_expr_param_parts ';' store_expr_param_part { $$=$1; P(*$$, *$3) }
 ;  ;
 store_curly_param_parts:  store_curly_param_parts:
         store_curly_param_part          store_curly_param_part
 |       store_curly_param_parts ';' store_curly_param_part { $$=$1; P($$, $3) }  |       store_curly_param_parts ';' store_curly_param_part { $$=$1; P(*$$, *$3) }
 ;  ;
 store_code_param_part: code_param_value {  store_code_param_part: code_param_value {
         $$=$1;          $$=$1;
         O($$, OP_STORE_PARAM);          O(*$$, OP_STORE_PARAM);
 };  };
 store_expr_param_part: write_expr_value {  store_expr_param_part: write_expr_value {
         $$=N(POOL);           $$=N(); 
         OA($$, OP_EXPR_CODE__STORE_PARAM, $1);          OA(*$$, OP_EXPR_CODE__STORE_PARAM, $1);
 };  };
 store_curly_param_part: maybe_codes {  store_curly_param_part: maybe_codes {
         $$=N(POOL);           $$=N(); 
         OA($$, OP_CURLY_CODE__STORE_PARAM, $1);          OA(*$$, OP_CURLY_CODE__STORE_PARAM, $1);
 };  };
 code_param_value:  code_param_value:
         void_value /* optimized [;...] case */          void_value /* optimized [;...] case */
Line 426  code_param_value: Line 429  code_param_value:
 |       constructor_code_value /* [something complex] */  |       constructor_code_value /* [something complex] */
 ;  ;
 write_expr_value: expr_value {  write_expr_value: expr_value {
         $$=N(POOL);           $$=N(); 
         O($$, OP_PREPARE_TO_EXPRESSION);          O(*$$, OP_PREPARE_TO_EXPRESSION);
         P($$, $1);          P(*$$, *$1);
         O($$, OP_WRITE_EXPR_RESULT);          O(*$$, OP_WRITE_EXPR_RESULT);
 };  };
   
 /* name */  /* name */
   
 name_expr_dive_code: 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          // we know that name_advance1 not called from ^xxx context
Line 444  name_advance1: name_expr_value { Line 447  name_advance1: name_expr_value {
   
         /* stack: context */          /* stack: context */
         $$=$1; /* stack: context,name */          $$=$1; /* stack: context,name */
         O($$, OP_GET_ELEMENT); /* name=pop; context=pop; stack: context.get_element(name) */          O(*$$, OP_GET_ELEMENT); /* name=pop; context=pop; stack: context.get_element(name) */
 };  };
 name_advance2: name_expr_value {  name_advance2: name_expr_value {
         /* stack: context */          /* stack: context */
         $$=$1; /* stack: context,name */          $$=$1; /* stack: context,name */
         O($$, OP_GET_ELEMENT); /* name=pop; context=pop; stack: context.get_element(name) */          O(*$$, OP_GET_ELEMENT); /* name=pop; context=pop; stack: context.get_element(name) */
 }  }
 |       STRING BOGUS  |       STRING BOGUS
 ;  ;
Line 461  name_expr_value: Line 464  name_expr_value:
 ;  ;
 name_expr_subvar_value: '$' subvar_ref_name_rdive {  name_expr_subvar_value: '$' subvar_ref_name_rdive {
         $$=$2;          $$=$2;
         O($$, OP_GET_ELEMENT);          O(*$$, OP_GET_ELEMENT);
 };  };
 name_expr_with_subvar_value: STRING subvar_get_writes {  name_expr_with_subvar_value: STRING subvar_get_writes {
         Array *code;          ArrayOperationPtr code;
         {          {
                 change_string_literal_to_write_string_literal(code=$1);                  change_string_literal_to_write_string_literal(*(code=$1));
                 P(code, $2);                  P(*code, *$2);
         }          }
         $$=N(POOL);           $$=N(); 
         OA($$, OP_STRING_POOL, code);          OA(*$$, OP_STRING_POOL, code);
 };  };
 name_square_code_value: '[' codes ']' {  name_square_code_value: '[' codes ']' {
         $$=N(POOL);           $$=N(); 
         OA($$, OP_OBJECT_POOL, $2); /* stack: empty write context */          OA(*$$, OP_OBJECT_POOL, $2); /* 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() */
 };  };
 subvar_ref_name_rdive: STRING {  subvar_ref_name_rdive: STRING {
         $$=N(POOL);           $$=N(); 
         O($$, OP_WITH_READ);          O(*$$, OP_WITH_READ);
         P($$, $1);          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;
         O($$, OP_GET_ELEMENT__WRITE);          O(*$$, OP_GET_ELEMENT__WRITE);
 };  };
   
 class_prefix:  class_prefix:
Line 495  class_prefix: Line 498  class_prefix:
 ;  ;
 class_static_prefix: STRING ':' {  class_static_prefix: STRING ':' {
         $$=$1; // stack: class name string          $$=$1; // stack: class name string
         if(*LA2S($$) == BASE_NAME) { // pseude BASE class          if(*LA2S(*$$) == BASE_NAME) { // pseude BASE class
                 if(VStateless_class *base=PC.cclass->base_class()) {                  if(VStateless_class* base=PC.cclass->base_class()) {
                         change_string_literal_value($$, base->name());                          change_string_literal_value(*$$, base->name());
                 } else {                  } else {
                         strcpy(PC.error, "no base class declared");                          strcpy(PC.error, "no base class declared");
                         YYERROR;                          YYERROR;
                 }                  }
         }          }
         O($$, OP_GET_CLASS);          O(*$$, OP_GET_CLASS);
 };  };
 class_constructor_prefix: class_static_prefix ':' {  class_constructor_prefix: class_static_prefix ':' {
         $$=$1;          $$=$1;
Line 511  class_constructor_prefix: class_static_p Line 514  class_constructor_prefix: class_static_p
                 strcpy(PC.error, ":: not allowed here");                  strcpy(PC.error, ":: not allowed here");
                 YYERROR;                  YYERROR;
         }          }
         O($$, OP_PREPARE_TO_CONSTRUCT_OBJECT);          O(*$$, OP_PREPARE_TO_CONSTRUCT_OBJECT);
 };  };
   
   
Line 519  class_constructor_prefix: class_static_p Line 522  class_constructor_prefix: class_static_p
   
 expr_value: expr {  expr_value: expr {
         // see OP_PREPARE_TO_EXPRESSION!!          // see OP_PREPARE_TO_EXPRESSION!!
         if(($$=$1)->size()==2) // only one string literal in there?          if(($$=$1)->count()==2) // only one string literal in there?
                 change_string_literal_to_double_literal($$); // make that string literal Double                  change_string_literal_to_double_literal(*$$); // make that string literal Double
 };  };
 expr:   expr: 
         STRING          STRING
Line 530  expr: Line 533  expr:
 |       '\'' string_inside_quotes_value '\'' { $$ = $2; }  |       '\'' string_inside_quotes_value '\'' { $$ = $2; }
 |       '(' expr ')' { $$ = $2; }  |       '(' expr ')' { $$ = $2; }
 /* stack: operand // stack: @operand */  /* stack: operand // stack: @operand */
 |       '-' expr %prec NUNARY { $$=$2;  O($$, OP_NEG) }  |       '-' expr %prec NUNARY { $$=$2;  O(*$$, OP_NEG) }
 |       '+' expr %prec NUNARY { $$=$2 }  |       '+' expr %prec NUNARY { $$=$2 }
 |       '~' expr { $$=$2;        O($$, OP_INV) }  |       '~' expr { $$=$2;        O(*$$, OP_INV) }
 |       '!' expr { $$=$2;  O($$, OP_NOT) }  |       '!' expr { $$=$2;  O(*$$, OP_NOT) }
 |       "def" expr { $$=$2;  O($$, OP_DEF) }  |       "def" expr { $$=$2;  O(*$$, OP_DEF) }
 |       "in" expr { $$=$2;  O($$, OP_IN) }  |       "in" expr { $$=$2;  O(*$$, OP_IN) }
 |       "-f" expr { $$=$2;  O($$, OP_FEXISTS) }  |       "-f" expr { $$=$2;  O(*$$, OP_FEXISTS) }
 |       "-d" expr { $$=$2;  O($$, OP_DEXISTS) }  |       "-d" expr { $$=$2;  O(*$$, OP_DEXISTS) }
 /* stack: a,b // stack: a@b */  /* stack: a,b // stack: a@b */
 |       expr '-' expr { $$=$1;  P($$, $3);  O($$, OP_SUB) }  |       expr '-' expr { $$=$1;  P(*$$, *$3);  O(*$$, OP_SUB) }
 |       expr '+' expr { $$=$1;  P($$, $3);  O($$, OP_ADD) }  |       expr '+' expr { $$=$1;  P(*$$, *$3);  O(*$$, OP_ADD) }
 |       expr '*' expr { $$=$1;  P($$, $3);  O($$, OP_MUL) }  |       expr '*' expr { $$=$1;  P(*$$, *$3);  O(*$$, OP_MUL) }
 |       expr '/' expr { $$=$1;  P($$, $3);  O($$, OP_DIV) }  |       expr '/' expr { $$=$1;  P(*$$, *$3);  O(*$$, OP_DIV) }
 |       expr '%' expr { $$=$1;  P($$, $3);  O($$, OP_MOD) }  |       expr '%' expr { $$=$1;  P(*$$, *$3);  O(*$$, OP_MOD) }
 |       expr '\\' expr { $$=$1;  P($$, $3);  O($$, OP_INTDIV) }  |       expr '\\' expr { $$=$1;  P(*$$, *$3);  O(*$$, OP_INTDIV) }
 |       expr "<<" expr { $$=$1;  P($$, $3);  O($$, OP_BIN_SL) }  |       expr "<<" expr { $$=$1;  P(*$$, *$3);  O(*$$, OP_BIN_SL) }
 |       expr ">>" expr { $$=$1;  P($$, $3);  O($$, OP_BIN_SR) }  |       expr ">>" expr { $$=$1;  P(*$$, *$3);  O(*$$, OP_BIN_SR) }
 |       expr '&' expr { $$=$1;  P($$, $3);  O($$, OP_BIN_AND) }  |       expr '&' expr { $$=$1;  P(*$$, *$3);  O(*$$, OP_BIN_AND) }
 |       expr '|' expr { $$=$1;  P($$, $3);  O($$, OP_BIN_OR) }  |       expr '|' expr { $$=$1;  P(*$$, *$3);  O(*$$, OP_BIN_OR) }
 |       expr "!|" expr { $$=$1;  P($$, $3);  O($$, OP_BIN_XOR) }  |       expr "!|" expr { $$=$1;  P(*$$, *$3);  O(*$$, OP_BIN_XOR) }
 |       expr "&&" expr { $$=$1;  OA($$, OP_NESTED_CODE, $3);  O($$, OP_LOG_AND) }  |       expr "&&" expr { $$=$1;  OA(*$$, OP_NESTED_CODE, $3);  O(*$$, OP_LOG_AND) }
 |       expr "||" expr { $$=$1;  OA($$, OP_NESTED_CODE, $3);  O($$, OP_LOG_OR) }  |       expr "||" expr { $$=$1;  OA(*$$, OP_NESTED_CODE, $3);  O(*$$, OP_LOG_OR) }
 |       expr "!||" expr { $$=$1;  P($$, $3);  O($$, OP_LOG_XOR) }  |       expr "!||" expr { $$=$1;  P(*$$, *$3);  O(*$$, OP_LOG_XOR) }
 |       expr '<' expr { $$=$1;  P($$, $3);  O($$, OP_NUM_LT) }  |       expr '<' expr { $$=$1;  P(*$$, *$3);  O(*$$, OP_NUM_LT) }
 |       expr '>' expr { $$=$1;  P($$, $3);  O($$, OP_NUM_GT) }  |       expr '>' expr { $$=$1;  P(*$$, *$3);  O(*$$, OP_NUM_GT) }
 |       expr "<=" expr { $$=$1;  P($$, $3);  O($$, OP_NUM_LE) }  |       expr "<=" expr { $$=$1;  P(*$$, *$3);  O(*$$, OP_NUM_LE) }
 |       expr ">=" expr { $$=$1;  P($$, $3);  O($$, OP_NUM_GE) }  |       expr ">=" expr { $$=$1;  P(*$$, *$3);  O(*$$, OP_NUM_GE) }
 |       expr "==" expr { $$=$1;  P($$, $3);  O($$, OP_NUM_EQ) }  |       expr "==" expr { $$=$1;  P(*$$, *$3);  O(*$$, OP_NUM_EQ) }
 |       expr "!=" expr { $$=$1;  P($$, $3);  O($$, OP_NUM_NE) }  |       expr "!=" expr { $$=$1;  P(*$$, *$3);  O(*$$, OP_NUM_NE) }
 |       expr "lt" expr { $$=$1;  P($$, $3);  O($$, OP_STR_LT) }  |       expr "lt" expr { $$=$1;  P(*$$, *$3);  O(*$$, OP_STR_LT) }
 |       expr "gt" expr { $$=$1;  P($$, $3);  O($$, OP_STR_GT) }  |       expr "gt" expr { $$=$1;  P(*$$, *$3);  O(*$$, OP_STR_GT) }
 |       expr "le" expr { $$=$1;  P($$, $3);  O($$, OP_STR_LE) }  |       expr "le" expr { $$=$1;  P(*$$, *$3);  O(*$$, OP_STR_LE) }
 |       expr "ge" expr { $$=$1;  P($$, $3);  O($$, OP_STR_GE) }  |       expr "ge" expr { $$=$1;  P(*$$, *$3);  O(*$$, OP_STR_GE) }
 |       expr "eq" expr { $$=$1;  P($$, $3);  O($$, OP_STR_EQ) }  |       expr "eq" expr { $$=$1;  P(*$$, *$3);  O(*$$, OP_STR_EQ) }
 |       expr "ne" expr { $$=$1;  P($$, $3);  O($$, OP_STR_NE) }  |       expr "ne" expr { $$=$1;  P(*$$, *$3);  O(*$$, OP_STR_NE) }
 |       expr "is" expr { $$=$1;  P($$, $3);  O($$, OP_IS) }  |       expr "is" expr { $$=$1;  P(*$$, *$3);  O(*$$, OP_IS) }
 ;  ;
   
 string_inside_quotes_value: maybe_codes {  string_inside_quotes_value: maybe_codes {
         $$=N(POOL);          $$=N();
         OA($$, OP_STRING_POOL, $1); /* stack: empty write context */          OA(*$$, OP_STRING_POOL, $1); /* stack: empty write context */
         /* some code that writes to that context */          /* some code that writes to that context */
         /* context=pop; stack: context.get_string() */          /* context=pop; stack: context.get_string() */
 };  };
Line 579  string_inside_quotes_value: maybe_codes Line 582  string_inside_quotes_value: maybe_codes
   
 write_string: STRING {  write_string: STRING {
         // optimized from OP_STRING+OP_WRITE_VALUE to OP_STRING__WRITE          // optimized from OP_STRING+OP_WRITE_VALUE to OP_STRING__WRITE
         change_string_literal_to_write_string_literal($$=$1)          change_string_literal_to_write_string_literal(*($$=$1))
 };  };
   
 void_value: /* empty */ { $$=VL(NEW VVoid(POOL)) };  void_value: /* empty */ { $$=VL(ValuePtr(new VVoid())) };
 empty: /* empty */ { $$=N(POOL) };  empty: /* empty */ { $$=N() };
   
 %%  %%
 #endif  #endif
Line 1299  break2: Line 1302  break2:
         }          }
         if(PC.string->size()) { // something accumulated?          if(PC.string->size()) { // something accumulated?
                 // create STRING value: array of OP_VALUE+vstring                  // create STRING value: array of OP_VALUE+vstring
                 *lvalp=VL(NEW VString(*PC.string));                  *lvalp=VL(ValuePtr(new VString(PC.string)));
                 // new pieces storage                  // new pieces storage
                 PC.string=NEW String(POOL);                  PC.string=StringPtr(new String);
                 // 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;
         }          }
Line 1318  static int real_yyerror(parse_control *p Line 1321  static int real_yyerror(parse_control *p
   
 static void yyprint(FILE *file, int type, YYSTYPE value) {  static void yyprint(FILE *file, int type, YYSTYPE value) {
         if(type==STRING)          if(type==STRING)
                 fprintf(file, " \"%s\"", LA2S(value)->cstr());                  fprintf(file, " \"%s\"", LA2S(*value)->cstr().get());
 }  }
Removed from v.1.204.2.1  
changed lines
  Added in v.1.204.2.6

E-mail: