[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.186.2.1 and 1.197

version 1.186.2.1, 2002/05/07 07:23:10 version 1.197, 2002/09/20 14:12:00
Line 60  static int yylex(YYSTYPE *lvalp, void *p Line 60  static int yylex(YYSTYPE *lvalp, void *p
 %token BAD_STRING_COMPARISON_OPERATOR  %token BAD_STRING_COMPARISON_OPERATOR
 %token BAD_HEX_LITERAL  %token BAD_HEX_LITERAL
 %token BAD_METHOD_DECL_START  %token BAD_METHOD_DECL_START
   %token BAD_METHOD_PARAMETER_NAME_CHARACTER
   %token BAD_MATH_OPERATOR_CHARACTER
   
 %token LAND "&&"  %token LAND "&&"
 %token LOR "||"  %token LOR "||"
 %token LXOR "##"  %token LXOR "!||"
   %token NXOR "!|"
   
 %token NLE "<="  %token NLE "<="
 %token NGE ">="  %token NGE ">="
 %token NEQ "=="  %token NEQ "=="
 %token NNE "!="  %token NNE "!="
   %token NSL "<<"
   %token NSR ">>"
   
 %token SLT "lt"  %token SLT "lt"
 %token SGT "gt"  %token SGT "gt"
Line 84  static int yylex(YYSTYPE *lvalp, void *p Line 89  static int yylex(YYSTYPE *lvalp, void *p
 %token IS "is"  %token IS "is"
   
 /* logical */  /* logical */
 %left "##"  %left "!||"
 %left "||"  %left "||"
 %left "&&"  %left "&&"
 %left '<' '>' "<=" ">="   "lt" "gt" "le" "ge"  %left '<' '>' "<=" ">="   "lt" "gt" "le" "ge"
Line 93  static int yylex(YYSTYPE *lvalp, void *p Line 98  static int yylex(YYSTYPE *lvalp, void *p
 %left '!'  %left '!'
   
 /* bitwise */  /* bitwise */
 %left '#'  %left "!|"
 %left '|'  %left '|'
 %left '&'   %left '&' 
 %left '~'  %left '~'
   %left ">>"
   %left "<<" 
   
 /* numerical */  /* numerical */
 %left '-' '+'  %left '-' '+'
Line 104  static int yylex(YYSTYPE *lvalp, void *p Line 111  static int yylex(YYSTYPE *lvalp, void *p
 %left NEG     /* negation: unary - */  %left NEG     /* negation: unary - */
   
 %%  %%
 all:   all:
         one_big_piece {          one_big_piece {
         Method& method=*NEW Method(POOL,           Method& method=*NEW Method(POOL, 
                 PC.request->main_method_name,                   PC.request->main_method_name, 
Line 132  control_method: '@' STRING '\n' Line 139  control_method: '@' STRING '\n'
                 YYERROR;                  YYERROR;
         }          }
         if(command==CLASS_NAME) {          if(command==CLASS_NAME) {
                 if(PC.cclass->base()) { // 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, "'");
Line 154  control_method: '@' STRING '\n' Line 161  control_method: '@' STRING '\n'
                 for(int i=0; i<strings_code->size(); i+=2)                   for(int i=0; i<strings_code->size(); i+=2) 
                         PC.request->use_file(*LA2S(strings_code, i));                          PC.request->use_file(*LA2S(strings_code, i));
         } else if(command==BASE_NAME) {          } else if(command==BASE_NAME) {
                 if(PC.cclass->base()) { // 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()->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->size()==1*2) {
                         const String& base_name=*LA2S(strings_code);                          const String& base_name=*LA2S(strings_code);
                         VClass *base=static_cast<VClass *>(                          Value *vbase_class=static_cast<VClass *>(
                                 PC.request->classes().get(base_name));                                  PC.request->classes().get(base_name));
                         if(!base) {                          VStateless_class *base_class=vbase_class?vbase_class->get_class():0;
                           if(!base_class) {
                                 strcpy(PC.error, base_name.cstr());                                  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                          // @CLASS == @BASE sanity check
                         if(PC.cclass==base) {                          if(PC.cclass==base_class) {
                                 strcpy(PC.error, "@"CLASS_NAME" equals @"BASE_NAME);                                  strcpy(PC.error, "@"CLASS_NAME" equals @"BASE_NAME);
                                 YYERROR;                                  YYERROR;
                         }                          }
                         PC.cclass->set_base(*base);                          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;
Line 265  name_without_curly_rdive_read: name_with Line 273  name_without_curly_rdive_read: name_with
         } else {          } else {
                 O($$, OP_WITH_READ); /* stack: starting context */                  O($$, OP_WITH_READ); /* stack: starting context */
   
                 // ^if ELEMENT -> ^if ELEMENT_OR_OPERATOR                  bool noDot=diving_code->size()==3;
                 // OP_VALUE+string+OP_GET_ELEMENT. -> OP_VALUE+string+OP_GET_ELEMENT_OR_OPERATOR.                  // OP_VALUE+string+OP_GET_ELEMENT. -> OP_VALUE+string+...OR_OPERATOR/OR_JUNCTION_EXP.
                 if(PC.in_call_value && diving_code->size()==3)                  if(PC.in_call_value) {
                         diving_code->put_int(2, OP_GET_ELEMENT_OR_OPERATOR);                          //  ^if << possibly operator
                           //  but ^code.xxxx  << expand junction !!!
   
                           diving_code->put_int(2, 
                                   noDot? // ELEMENT without .SUBELEMENT
                                           OP_GET_ELEMENT_OR_OPERATOR // possibly ^if  [search for operator]
                                           : OP_GET_ELEMENT_OR_JUNCTION_EXPAND); // possibly ^junction.xxx [if junction, expand it]
                   } else {
                           //  $code  << expand junction
                           //  $code.value << do not expand junction
                           //  $code.value[xxx]  << do not expand junction
   
                           if(noDot)
                                   diving_code->put_int(2, OP_GET_ELEMENT_OR_JUNCTION_EXPAND); // possibly $junction [if junction, expand it]
                   }
                   
                 P($$, diving_code);                  P($$, diving_code);
         }          }
         /* diving code; stack: current context */          /* diving code; stack: current context */
Line 486  class_prefix: Line 509  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(VStateless_class *base=PC.cclass->base_class()) {
                           change_string_literal_value($$, base->name());
                   } else {
                           strcpy(PC.error, "no base class declared");
                           YYERROR;
                   }
           }
         O($$, OP_GET_CLASS);          O($$, OP_GET_CLASS);
 };  };
 class_constructor_prefix: class_static_prefix ':' {  class_constructor_prefix: class_static_prefix ':' {
Line 528  expr: Line 559  expr:
 |       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_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) }
Line 633  case LS_VAR_NAME_SIMPLE_WITH_COLON: Line 666  case LS_VAR_NAME_SIMPLE_WITH_COLON:
 case LS_VAR_NAME_SIMPLE_WITHOUT_COLON:  case LS_VAR_NAME_SIMPLE_WITHOUT_COLON:
 case LS_VAR_NAME_CURLY:  case LS_VAR_NAME_CURLY:
 case LS_METHOD_NAME:  case LS_METHOD_NAME:
 case LS_COMMENT:  case LS_USER_COMMENT:
 case LS_DEF_COMMENT:  case LS_DEF_COMMENT:
         // no literals in names, please          // no literals in names, please
         break;          break;
Line 701  default: Line 734  default:
                                 PC.string->APPEND_CLEAN(begin, end-begin, PC.file, begin_line);                                  PC.string->APPEND_CLEAN(begin, end-begin, PC.file, begin_line);
                         }                          }
                         // fall into COMMENT lexical state [wait for \n]                          // fall into COMMENT lexical state [wait for \n]
                         push_LS(PC, LS_COMMENT);                          push_LS(PC, LS_USER_COMMENT);
                         continue;                          continue;
                 }                  }
                 switch(PC.ls) {                  switch(PC.ls) {
Line 740  default: Line 773  default:
                         break;                          break;
                                                   
                 // #COMMENT                  // #COMMENT
                 case LS_COMMENT:                  case LS_USER_COMMENT:
                         if(c=='\n') {                          if(c=='\n') {
                                 // skip comment                                  // skip comment
                                 begin=PC.source;                                  begin=PC.source;
Line 787  default: Line 820  default:
   
                 case LS_DEF_PARAMS:                  case LS_DEF_PARAMS:
                         switch(c) {                          switch(c) {
                           case '$': // common error
                                   result=BAD_METHOD_PARAMETER_NAME_CHARACTER;
                                   goto break2;
                         case ';':                          case ';':
                                 RC;                                  RC;
                         case ']':                          case ']':
Line 835  default: Line 871  default:
                                         else // PC.ls==LS_VAR_ROUND // variable constructor ended                                          else // PC.ls==LS_VAR_ROUND // variable constructor ended
                                                 pop_LS(PC); // return to normal life                                                  pop_LS(PC); // return to normal life
                                 RC;                                  RC;
                           case '#': // comment start skipping
                                   if(end!=begin) {
                                           // append piece till #
                                           PC.string->APPEND_CLEAN(begin, end-begin, PC.file, begin_line);
                                   }
                                   // fall into COMMENT lexical state [wait for \n]
                                   push_LS(PC, LS_EXPRESSION_COMMENT);
                                   lexical_brackets_nestage=1;
                                   continue;
                         case '$':                          case '$':
                                 push_LS(PC, LS_EXPRESSION_VAR_NAME_WITH_COLON);                                                           push_LS(PC, LS_EXPRESSION_VAR_NAME_WITH_COLON);                         
                                 RC;                                  RC;
Line 854  default: Line 899  default:
                                         skip_analized=1;                                          skip_analized=1;
                                         result=DEXISTS;                                          result=DEXISTS;
                                         goto break2;                                          goto break2;
                                 default:                                  default: // minus
                                         result=c;                                          result=c;
                                         goto break2;                                          goto break2;
                                 }                                  }
Line 863  default: Line 908  default:
                         case '~':                          case '~':
                         case ';':                          case ';':
                                 RC;                                  RC;
                         case '&': case '|':  case '#':                          case '&': case '|':
                                 if(*PC.source==c) { // && ||                                  if(*PC.source==c) { // && ||
                                         result=c=='#'?LXOR:c=='&'?LAND:LOR;                                          result=c=='&'?LAND:LOR;
                                         skip_analized=1;                                          skip_analized=1;
                                 } else                                  } else
                                         result=c;                                          result=c;
                                 goto break2;                                  goto break2;
                         case '<': case '>': case '=': case '!':                           case '!':
                                 if(*PC.source=='=') { // <= >= == !=                                  switch(PC.source[0]) { 
                                   case '|': // !| !||
                                         skip_analized=1;                                          skip_analized=1;
                                         switch(c) {                                          if(PC.source[1]=='|') {
                                         case '<': result=NLE; break;                                                  skip_analized++;
                                         case '>': result=NGE; break;                                                  result=LXOR;
                                         case '=': result=NEQ; break;                                          } else
                                         case '!': result=NNE; break;                                                  result=NXOR;
                                         }                                          goto break2;
                                 } else                                  case '=': // !=
                                         result=c;                                          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;
                           case '>': // >>, >=, >
                                   switch(*PC.source) {
                                   case '>': // >[>]
                                           skip_analized=1; result=NSR; break;
                                   case '=': // >[=]
                                           skip_analized=1; result=NGE; break;
                                   default: // >[]
                                           result=c; break;
                                   }
                                 goto break2;                                  goto break2;
                           case '=': // ==
                                   switch(*PC.source) {
                                   case '=': // =[=]
                                           skip_analized=1; result=NEQ; break;
                                   default: // =[]
                                           result=c; break; // not used now
                                   }
                                   goto break2;
   
                         case '"':                          case '"':
                                 push_LS(PC, LS_EXPRESSION_STRING_QUOTED);                                  push_LS(PC, LS_EXPRESSION_STRING_QUOTED);
                                 RC;                                  RC;
Line 944  default: Line 1023  default:
                                 continue;                                  continue;
                         }                          }
                         break;                          break;
                   case LS_EXPRESSION_COMMENT:
                           if(c=='(')
                                   lexical_brackets_nestage++;
                           
                           switch(*PC.source) {
                           case '\n': case ')':
                                   if(*PC.source==')')
                                           if(--lexical_brackets_nestage!=0)
                                                   continue;
   
                                   // skip comment
                                   begin=PC.source;
                                   begin_line=PC.line;
   
                                   pop_LS(PC);
                                   continue;
                           }
                           break;
   
                 // VARIABLE GET/PUT/WITH                  // VARIABLE GET/PUT/WITH
                 case LS_VAR_NAME_SIMPLE_WITH_COLON:                   case LS_VAR_NAME_SIMPLE_WITH_COLON: 
Line 988  default: Line 1085  default:
                         case '&': case '|':                           case '&': case '|': 
                         case '=': case '!':                          case '=': case '!':
                         // common delimiters                          // common delimiters
                         case ',': case '?':                          case ',': case '?': case '#':
                         // before call                          // before call
                         case '^':                           case '^': 
                                 pop_LS(PC);                                  pop_LS(PC);
Line 1207  break2: Line 1304  break2:
                         if(end!=begin && end[-1]=='\n') // allow one empty line before LS_DEF_NAME                          if(end!=begin && end[-1]=='\n') // allow one empty line before LS_DEF_NAME
                                 end--;                                  end--;
                 }                  }
                 if(end!=begin && PC.ls!=LS_COMMENT) { // last piece still alive and not comment?                  if(end!=begin && PC.ls!=LS_USER_COMMENT) { // last piece still alive and not comment?
                         // append it                          // append it
                         PC.string->APPEND_CLEAN(begin, end-begin, PC.file, begin_line/*, start_col*/);                          PC.string->APPEND_CLEAN(begin, end-begin, PC.file, begin_line/*, start_col*/);
                 }                  }
Removed from v.1.186.2.1  
changed lines
  Added in v.1.197

E-mail: