(file) Return to cimmof_lex.cpp CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / Compiler

Diff for /pegasus/src/Pegasus/Compiler/cimmof_lex.cpp between version 1.35.8.2 and 1.35.8.3

version 1.35.8.2, 2013/06/03 22:35:46 version 1.35.8.3, 2013/09/14 23:08:18
Line 76 
Line 76 
 typedef unsigned char flex_uint8_t; typedef unsigned char flex_uint8_t;
 typedef unsigned short int flex_uint16_t; typedef unsigned short int flex_uint16_t;
 typedef unsigned int flex_uint32_t; typedef unsigned int flex_uint32_t;
   #endif /* ! C99 */
  
 /* Limits of integral types. */ /* Limits of integral types. */
 #ifndef INT8_MIN #ifndef INT8_MIN
Line 106 
Line 107 
 #define UINT32_MAX             (4294967295U) #define UINT32_MAX             (4294967295U)
 #endif #endif
  
 #endif /* ! C99 */  
   
 #endif /* ! FLEXINT_H */ #endif /* ! FLEXINT_H */
  
 #ifdef __cplusplus #ifdef __cplusplus
Line 164 
Line 163 
  
 /* Size of default input buffer. */ /* Size of default input buffer. */
 #ifndef YY_BUF_SIZE #ifndef YY_BUF_SIZE
 #ifdef __ia64__  
 /* On IA-64, the buffer size is 16k, not 8k.  
  * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.  
  * Ditto for the __ia64__ case accordingly.  
  */  
 #define YY_BUF_SIZE 32768  
 #else  
 #define YY_BUF_SIZE 16384 #define YY_BUF_SIZE 16384
 #endif /* __ia64__ */  
 #endif #endif
  
 /* The state buf must be large enough to hold one state per character in the main buffer. /* The state buf must be large enough to hold one state per character in the main buffer.
Line 775 
Line 766 
 // //
 ////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
 */ */
 #line 36 "cimmof.l"  #line 38 "cimmof.l"
  
  
 #include "cimmofParser.h" #include "cimmofParser.h"
Line 823 
Line 814 
  
  
  
 #line 824 "cimmof_lex.cpp"  #line 815 "cimmof_lex.cpp"
  
 #define INITIAL 0 #define INITIAL 0
 #define myStr 1 #define myStr 1
Line 884 
Line 875 
 #endif #endif
 #endif #endif
  
     static void yyunput (int c,char *buf_ptr  );  
   
 #ifndef yytext_ptr #ifndef yytext_ptr
 static void yy_flex_strncpy (char *,yyconst char *,int ); static void yy_flex_strncpy (char *,yyconst char *,int );
 #endif #endif
Line 912 
Line 901 
  
     static void yy_pop_state (void );     static void yy_pop_state (void );
  
     static int yy_top_state (void );  
   
 /* Amount of stuff to slurp up with each read. */ /* Amount of stuff to slurp up with each read. */
 #ifndef YY_READ_BUF_SIZE #ifndef YY_READ_BUF_SIZE
 #ifdef __ia64__  
 /* On IA-64, the buffer size is 16k, not 8k */  
 #define YY_READ_BUF_SIZE 16384  
 #else  
 #define YY_READ_BUF_SIZE 8192 #define YY_READ_BUF_SIZE 8192
 #endif /* __ia64__ */  
 #endif #endif
  
 /* Copy whatever the last rule matched to the standard output. */ /* Copy whatever the last rule matched to the standard output. */
Line 940 
Line 922 
         if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \         if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
                 { \                 { \
                 int c = '*'; \                 int c = '*'; \
                 size_t n; \                  unsigned n; \
                 for ( n = 0; n < max_size && \                 for ( n = 0; n < max_size && \
                              (c = getc( cimmof_in )) != EOF && c != '\n'; ++n ) \                              (c = getc( cimmof_in )) != EOF && c != '\n'; ++n ) \
                         buf[n] = (char) c; \                         buf[n] = (char) c; \
Line 1022 
Line 1004 
         register char *yy_cp, *yy_bp;         register char *yy_cp, *yy_bp;
         register int yy_act;         register int yy_act;
  
 #line 86 "cimmof.l"  #line 88 "cimmof.l"
  
  
  
 #line 1027 "cimmof_lex.cpp"  #line 1009 "cimmof_lex.cpp"
  
         if ( !(yy_init) )         if ( !(yy_init) )
                 {                 {
Line 1118 
Line 1100 
 case 1: case 1:
 /* rule 1 can match eol */ /* rule 1 can match eol */
 YY_RULE_SETUP YY_RULE_SETUP
 #line 89 "cimmof.l"  #line 91 "cimmof.l"
 { cimmofParser::Instance()->increment_lineno(); } { cimmofParser::Instance()->increment_lineno(); }
         YY_BREAK         YY_BREAK
 case 2: case 2:
 /* rule 2 can match eol */ /* rule 2 can match eol */
 YY_RULE_SETUP YY_RULE_SETUP
 #line 90 "cimmof.l"  #line 92 "cimmof.l"
 { cimmofParser::Instance()->increment_lineno(); } { cimmofParser::Instance()->increment_lineno(); }
         YY_BREAK         YY_BREAK
 case 3: case 3:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 91 "cimmof.l"  #line 93 "cimmof.l"
 { /* skip white space */ } { /* skip white space */ }
         YY_BREAK         YY_BREAK
 case 4: case 4:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 92 "cimmof.l"  #line 94 "cimmof.l"
 { return(TOK_CLASS); } { return(TOK_CLASS); }
         YY_BREAK         YY_BREAK
 case 5: case 5:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 93 "cimmof.l"  #line 95 "cimmof.l"
 { return(TOK_LEFTCURLYBRACE); } { return(TOK_LEFTCURLYBRACE); }
         YY_BREAK         YY_BREAK
 case 6: case 6:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 94 "cimmof.l"  #line 96 "cimmof.l"
 { return(TOK_RIGHTCURLYBRACE); } { return(TOK_RIGHTCURLYBRACE); }
         YY_BREAK         YY_BREAK
 case 7: case 7:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 95 "cimmof.l"  #line 97 "cimmof.l"
 { return(TOK_LEFTSQUAREBRACKET); } { return(TOK_LEFTSQUAREBRACKET); }
         YY_BREAK         YY_BREAK
 case 8: case 8:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 96 "cimmof.l"  #line 98 "cimmof.l"
 { return(TOK_RIGHTSQUAREBRACKET); } { return(TOK_RIGHTSQUAREBRACKET); }
         YY_BREAK         YY_BREAK
 case 9: case 9:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 97 "cimmof.l"  #line 99 "cimmof.l"
 { return(TOK_LEFTPAREN); } { return(TOK_LEFTPAREN); }
         YY_BREAK         YY_BREAK
 case 10: case 10:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 98 "cimmof.l"  #line 100 "cimmof.l"
 { return(TOK_RIGHTPAREN); } { return(TOK_RIGHTPAREN); }
         YY_BREAK         YY_BREAK
 case 11: case 11:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 99 "cimmof.l"  #line 101 "cimmof.l"
 { return(TOK_COLON); } { return(TOK_COLON); }
         YY_BREAK         YY_BREAK
 case 12: case 12:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 100 "cimmof.l"  #line 102 "cimmof.l"
 { return(TOK_SEMICOLON); } { return(TOK_SEMICOLON); }
         YY_BREAK         YY_BREAK
 case 13: case 13:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 101 "cimmof.l"  #line 103 "cimmof.l"
 { {
                    cimmof_lval.strval = new String(cimmof_text);                    cimmof_lval.strval = new String(cimmof_text);
                    return(TOK_REAL_VALUE); }                    return(TOK_REAL_VALUE); }
         YY_BREAK         YY_BREAK
 case 14: case 14:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 104 "cimmof.l"  #line 106 "cimmof.l"
 { cimmof_lval.strval = new String(cimmof_text); { cimmof_lval.strval = new String(cimmof_text);
                    return(TOK_OCTAL_VALUE); }                    return(TOK_OCTAL_VALUE); }
         YY_BREAK         YY_BREAK
 case 15: case 15:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 106 "cimmof.l"  #line 108 "cimmof.l"
 { cimmof_lval.strval = new String(cimmof_text); { cimmof_lval.strval = new String(cimmof_text);
                    return(TOK_HEX_VALUE); }                    return(TOK_HEX_VALUE); }
         YY_BREAK         YY_BREAK
 case 16: case 16:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 108 "cimmof.l"  #line 110 "cimmof.l"
 { cimmof_lval.strval = new String(cimmof_text); { cimmof_lval.strval = new String(cimmof_text);
                    return(TOK_BINARY_VALUE); }                    return(TOK_BINARY_VALUE); }
         YY_BREAK         YY_BREAK
 case 17: case 17:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 110 "cimmof.l"  #line 112 "cimmof.l"
 { cimmof_lval.strval = new String(cimmof_text); { cimmof_lval.strval = new String(cimmof_text);
                    return(TOK_POSITIVE_DECIMAL_VALUE); }                    return(TOK_POSITIVE_DECIMAL_VALUE); }
         YY_BREAK         YY_BREAK
 case 18: case 18:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 112 "cimmof.l"  #line 114 "cimmof.l"
 { /* Note: All non-zero unsigned integers are handled above */ { /* Note: All non-zero unsigned integers are handled above */
                  cimmof_lval.strval = new String(cimmof_text);                  cimmof_lval.strval = new String(cimmof_text);
                    return(TOK_SIGNED_DECIMAL_VALUE); }                    return(TOK_SIGNED_DECIMAL_VALUE); }
         YY_BREAK         YY_BREAK
 case 19: case 19:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 115 "cimmof.l"  #line 117 "cimmof.l"
 { return(TOK_EQUAL); } { return(TOK_EQUAL); }
         YY_BREAK         YY_BREAK
 case 20: case 20:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 116 "cimmof.l"  #line 118 "cimmof.l"
 { return(TOK_COMMA); } { return(TOK_COMMA); }
         YY_BREAK         YY_BREAK
 case 21: case 21:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 117 "cimmof.l"  #line 119 "cimmof.l"
 { cimmof_lval.strval = new String(cimmof_text); { cimmof_lval.strval = new String(cimmof_text);
                    return(TOK_CHAR_VALUE); }                    return(TOK_CHAR_VALUE); }
         YY_BREAK         YY_BREAK
Line 1246 
Line 1228 
     */     */
 case 22: case 22:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 134 "cimmof.l"  #line 136 "cimmof.l"
 { BEGIN(myStr); strbuf_p = strbuf; { BEGIN(myStr); strbuf_p = strbuf;
                /**strbuf_p++ = '"';*/ }                /**strbuf_p++ = '"';*/ }
         YY_BREAK         YY_BREAK
 case 23: case 23:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 136 "cimmof.l"  #line 138 "cimmof.l"
 { BEGIN(INITIAL); { BEGIN(INITIAL);
                /**strbuf_p++ = '"';*/  *strbuf_p = '\0';                /**strbuf_p++ = '"';*/  *strbuf_p = '\0';
                   cimmof_leng = strbuf_p - strbuf;                   cimmof_leng = strbuf_p - strbuf;
Line 1260 
Line 1242 
                   return TOK_STRING_VALUE; }                   return TOK_STRING_VALUE; }
         YY_BREAK         YY_BREAK
 case YY_STATE_EOF(myStr): case YY_STATE_EOF(myStr):
 #line 141 "cimmof.l"  #line 143 "cimmof.l"
 case 24: case 24:
 /* rule 24 can match eol */ /* rule 24 can match eol */
 YY_RULE_SETUP YY_RULE_SETUP
 #line 142 "cimmof.l"  #line 144 "cimmof.l"
 { BEGIN(INITIAL); { BEGIN(INITIAL);
                /**strbuf_p++ = '"';*/  *strbuf_p = '\0';                /**strbuf_p++ = '"';*/  *strbuf_p = '\0';
                   cimmof_leng = strbuf_p - strbuf;                   cimmof_leng = strbuf_p - strbuf;
Line 1273 
Line 1255 
         YY_BREAK         YY_BREAK
 case 25: case 25:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 147 "cimmof.l"  #line 149 "cimmof.l"
 { /* backspace */        *strbuf_p++ = '\b'; } { /* backspace */        *strbuf_p++ = '\b'; }
         YY_BREAK         YY_BREAK
 case 26: case 26:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 148 "cimmof.l"  #line 150 "cimmof.l"
 { /* form feed */        *strbuf_p++ = '\f'; } { /* form feed */        *strbuf_p++ = '\f'; }
         YY_BREAK         YY_BREAK
 case 27: case 27:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 149 "cimmof.l"  #line 151 "cimmof.l"
 { /* line feed */        *strbuf_p++ = '\n'; } { /* line feed */        *strbuf_p++ = '\n'; }
         YY_BREAK         YY_BREAK
 case 28: case 28:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 150 "cimmof.l"  #line 152 "cimmof.l"
 { /* carriage return */  *strbuf_p++ = '\r'; } { /* carriage return */  *strbuf_p++ = '\r'; }
         YY_BREAK         YY_BREAK
 case 29: case 29:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 151 "cimmof.l"  #line 153 "cimmof.l"
 { /* horizontal tab */   *strbuf_p++ = '\t'; } { /* horizontal tab */   *strbuf_p++ = '\t'; }
         YY_BREAK         YY_BREAK
 case 30: case 30:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 152 "cimmof.l"  #line 154 "cimmof.l"
 { /* single quote */     *strbuf_p++ = '\''; } { /* single quote */     *strbuf_p++ = '\''; }
         YY_BREAK         YY_BREAK
 case 31: case 31:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 153 "cimmof.l"  #line 155 "cimmof.l"
 { /* double quote */     *strbuf_p++ = '"';  } { /* double quote */     *strbuf_p++ = '"';  }
         YY_BREAK         YY_BREAK
 case 32: case 32:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 154 "cimmof.l"  #line 156 "cimmof.l"
 { /* backslash */        *strbuf_p++ = '\\'; } { /* backslash */        *strbuf_p++ = '\\'; }
         YY_BREAK         YY_BREAK
 case 33: case 33:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 155 "cimmof.l"  #line 157 "cimmof.l"
 { yy_push_state(myHex); { yy_push_state(myHex);
                   memcpy(slashx,cimmof_text,2);                   memcpy(slashx,cimmof_text,2);
                }                }
Line 1321 
Line 1303 
 case 34: case 34:
 /* rule 34 can match eol */ /* rule 34 can match eol */
 YY_RULE_SETUP YY_RULE_SETUP
 #line 158 "cimmof.l"  #line 160 "cimmof.l"
 { *strbuf_p++ = '\\'; { *strbuf_p++ = '\\';
                         *strbuf_p++ = cimmof_text[1]; }                         *strbuf_p++ = cimmof_text[1]; }
         YY_BREAK         YY_BREAK
 case 35: case 35:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 160 "cimmof.l"  #line 162 "cimmof.l"
 { char *t = cimmof_text; { char *t = cimmof_text;
                             while( *t ) *strbuf_p++ = *t++;                             while( *t ) *strbuf_p++ = *t++;
                             *strbuf_p = '\0'; }                             *strbuf_p = '\0'; }
         YY_BREAK         YY_BREAK
 case 36: case 36:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 163 "cimmof.l"  #line 165 "cimmof.l"
 { /* get escaped hex digits */ { /* get escaped hex digits */
                             char  hexfmt[4];   unsigned int n;                             char  hexfmt[4];   unsigned int n;
                             sprintf( hexfmt, "%%%dx", cimmof_leng );                             sprintf( hexfmt, "%%%dx", cimmof_leng );
Line 1351 
Line 1333 
         YY_BREAK         YY_BREAK
 case 37: case 37:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 176 "cimmof.l"  #line 178 "cimmof.l"
 { memcpy(strbuf_p,slashx,2); { memcpy(strbuf_p,slashx,2);
                               strbuf_p += 2;                               strbuf_p += 2;
                               *strbuf_p++ = *cimmof_text;                               *strbuf_p++ = *cimmof_text;
Line 1361 
Line 1343 
 /* --- end of bugzilla 544 fix --- */ /* --- end of bugzilla 544 fix --- */
 case 38: case 38:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 184 "cimmof.l"  #line 186 "cimmof.l"
 {   int c1=0, c2=yyinput(); {   int c1=0, c2=yyinput();
                                 for(;;) {                                 for(;;) {
                                      if (c2==EOF) break;                                      if (c2==EOF) break;
Line 1373 
Line 1355 
         YY_BREAK         YY_BREAK
 case YY_STATE_EOF(INITIAL): case YY_STATE_EOF(INITIAL):
 case YY_STATE_EOF(myHex): case YY_STATE_EOF(myHex):
 #line 192 "cimmof.l"  #line 194 "cimmof.l"
 { yyterminate(); } { yyterminate(); }
         YY_BREAK         YY_BREAK
 case 39: case 39:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 193 "cimmof.l"  #line 195 "cimmof.l"
 { return(TOK_NULL_VALUE); } { return(TOK_NULL_VALUE); }
         YY_BREAK         YY_BREAK
 case 40: case 40:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 194 "cimmof.l"  #line 196 "cimmof.l"
 { return(TOK_TRUE); } { return(TOK_TRUE); }
         YY_BREAK         YY_BREAK
 case 41: case 41:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 195 "cimmof.l"  #line 197 "cimmof.l"
 { return(TOK_FALSE); } { return(TOK_FALSE); }
         YY_BREAK         YY_BREAK
 case 42: case 42:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 196 "cimmof.l"  #line 198 "cimmof.l"
 { return(TOK_PERIOD); } { return(TOK_PERIOD); }
         YY_BREAK         YY_BREAK
 case 43: case 43:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 197 "cimmof.l"  #line 199 "cimmof.l"
 { return(TOK_PRAGMA); } { return(TOK_PRAGMA); }
         YY_BREAK         YY_BREAK
 case 44: case 44:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 198 "cimmof.l"  #line 200 "cimmof.l"
 { return(TOK_INSTANCE); } { return(TOK_INSTANCE); }
         YY_BREAK         YY_BREAK
 case 45: case 45:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 199 "cimmof.l"  #line 201 "cimmof.l"
 { return(TOK_OF); } { return(TOK_OF); }
         YY_BREAK         YY_BREAK
 case 46: case 46:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 200 "cimmof.l"  #line 202 "cimmof.l"
 {return(TOK_QUALIFIER); } {return(TOK_QUALIFIER); }
         YY_BREAK         YY_BREAK
 case 47: case 47:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 201 "cimmof.l"  #line 203 "cimmof.l"
 { return(TOK_SCOPE); } { return(TOK_SCOPE); }
         YY_BREAK         YY_BREAK
 case 48: case 48:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 203 "cimmof.l"  #line 205 "cimmof.l"
 { {
                                        metaQualifierName = strdup(cimmof_text);                                        metaQualifierName = strdup(cimmof_text);
                                        return(TOK_ASSOCIATION); }                                        return(TOK_ASSOCIATION); }
         YY_BREAK         YY_BREAK
 case 49: case 49:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 206 "cimmof.l"  #line 208 "cimmof.l"
 { {
                                        metaQualifierName = strdup(cimmof_text);                                        metaQualifierName = strdup(cimmof_text);
                                        return(TOK_INDICATION); }                                        return(TOK_INDICATION); }
         YY_BREAK         YY_BREAK
 case 50: case 50:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 210 "cimmof.l"  #line 212 "cimmof.l"
 { return(TOK_PROPERTY); } { return(TOK_PROPERTY); }
         YY_BREAK         YY_BREAK
 case 51: case 51:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 211 "cimmof.l"  #line 213 "cimmof.l"
 { return(TOK_REFERENCE); } { return(TOK_REFERENCE); }
         YY_BREAK         YY_BREAK
 case 52: case 52:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 212 "cimmof.l"  #line 214 "cimmof.l"
 { return(TOK_METHOD); } { return(TOK_METHOD); }
         YY_BREAK         YY_BREAK
 case 53: case 53:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 213 "cimmof.l"  #line 215 "cimmof.l"
 {return(TOK_PARAMETER); } {return(TOK_PARAMETER); }
         YY_BREAK         YY_BREAK
 case 54: case 54:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 214 "cimmof.l"  #line 216 "cimmof.l"
 { return(TOK_ANY); } { return(TOK_ANY); }
         YY_BREAK         YY_BREAK
 case 55: case 55:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 216 "cimmof.l"  #line 218 "cimmof.l"
 { return(TOK_REF); } { return(TOK_REF); }
         YY_BREAK         YY_BREAK
 case 56: case 56:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 217 "cimmof.l"  #line 219 "cimmof.l"
 { return(TOK_FLAVOR); } { return(TOK_FLAVOR); }
         YY_BREAK         YY_BREAK
 case 57: case 57:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 218 "cimmof.l"  #line 220 "cimmof.l"
 { {
                                          return(TOK_ENABLEOVERRIDE); }                                          return(TOK_ENABLEOVERRIDE); }
         YY_BREAK         YY_BREAK
 case 58: case 58:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 220 "cimmof.l"  #line 222 "cimmof.l"
 { {
                                          return(TOK_DISABLEOVERRIDE); }                                          return(TOK_DISABLEOVERRIDE); }
         YY_BREAK         YY_BREAK
 case 59: case 59:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 222 "cimmof.l"  #line 224 "cimmof.l"
 { return(TOK_RESTRICTED); } { return(TOK_RESTRICTED); }
         YY_BREAK         YY_BREAK
 case 60: case 60:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 223 "cimmof.l"  #line 225 "cimmof.l"
 { return(TOK_TOSUBCLASS); } { return(TOK_TOSUBCLASS); }
         YY_BREAK         YY_BREAK
 case 61: case 61:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 224 "cimmof.l"  #line 226 "cimmof.l"
 { return(TOK_TRANSLATABLE); } { return(TOK_TRANSLATABLE); }
         YY_BREAK         YY_BREAK
 case 62: case 62:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 225 "cimmof.l"  #line 227 "cimmof.l"
 { return(TOK_INCLUDE); } { return(TOK_INCLUDE); }
         YY_BREAK         YY_BREAK
 case 63: case 63:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 226 "cimmof.l"  #line 228 "cimmof.l"
 { cimmof_lval.strval = new String(cimmof_text); { cimmof_lval.strval = new String(cimmof_text);
                                        return TOK_ALIAS_IDENTIFIER; }                                        return TOK_ALIAS_IDENTIFIER; }
         YY_BREAK         YY_BREAK
 case 64: case 64:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 228 "cimmof.l"  #line 230 "cimmof.l"
 { return TOK_AS; } { return TOK_AS; }
         YY_BREAK         YY_BREAK
 case 65: case 65:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 229 "cimmof.l"  #line 231 "cimmof.l"
 { return(TOK_DT_STR); } { return(TOK_DT_STR); }
         YY_BREAK         YY_BREAK
 case 66: case 66:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 230 "cimmof.l"  #line 232 "cimmof.l"
 { return(TOK_DT_BOOL); } { return(TOK_DT_BOOL); }
         YY_BREAK         YY_BREAK
 case 67: case 67:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 231 "cimmof.l"  #line 233 "cimmof.l"
 { return(TOK_DT_DATETIME); } { return(TOK_DT_DATETIME); }
         YY_BREAK         YY_BREAK
 case 68: case 68:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 232 "cimmof.l"  #line 234 "cimmof.l"
 { return(TOK_DT_UINT8); } { return(TOK_DT_UINT8); }
         YY_BREAK         YY_BREAK
 case 69: case 69:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 233 "cimmof.l"  #line 235 "cimmof.l"
 { return(TOK_DT_UINT16); } { return(TOK_DT_UINT16); }
         YY_BREAK         YY_BREAK
 case 70: case 70:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 234 "cimmof.l"  #line 236 "cimmof.l"
 { return(TOK_DT_UINT32); } { return(TOK_DT_UINT32); }
         YY_BREAK         YY_BREAK
 case 71: case 71:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 235 "cimmof.l"  #line 237 "cimmof.l"
 { return(TOK_DT_UINT64); } { return(TOK_DT_UINT64); }
         YY_BREAK         YY_BREAK
 case 72: case 72:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 236 "cimmof.l"  #line 238 "cimmof.l"
 { return(TOK_DT_SINT8); } { return(TOK_DT_SINT8); }
         YY_BREAK         YY_BREAK
 case 73: case 73:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 237 "cimmof.l"  #line 239 "cimmof.l"
 { return(TOK_DT_SINT16); } { return(TOK_DT_SINT16); }
         YY_BREAK         YY_BREAK
 case 74: case 74:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 238 "cimmof.l"  #line 240 "cimmof.l"
 { return(TOK_DT_SINT32); } { return(TOK_DT_SINT32); }
         YY_BREAK         YY_BREAK
 case 75: case 75:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 239 "cimmof.l"  #line 241 "cimmof.l"
 { return(TOK_DT_SINT64); } { return(TOK_DT_SINT64); }
         YY_BREAK         YY_BREAK
 case 76: case 76:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 240 "cimmof.l"  #line 242 "cimmof.l"
 { return(TOK_DT_REAL32); } { return(TOK_DT_REAL32); }
         YY_BREAK         YY_BREAK
 case 77: case 77:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 241 "cimmof.l"  #line 243 "cimmof.l"
 { return(TOK_DT_REAL64); } { return(TOK_DT_REAL64); }
         YY_BREAK         YY_BREAK
 case 78: case 78:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 242 "cimmof.l"  #line 244 "cimmof.l"
 { return(TOK_DT_CHAR8); } { return(TOK_DT_CHAR8); }
         YY_BREAK         YY_BREAK
 case 79: case 79:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 243 "cimmof.l"  #line 245 "cimmof.l"
 { return(TOK_DT_CHAR16); } { return(TOK_DT_CHAR16); }
         YY_BREAK         YY_BREAK
 case 80: case 80:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 244 "cimmof.l"  #line 246 "cimmof.l"
 { cimmof_lval.strval = new String(cimmof_text); { cimmof_lval.strval = new String(cimmof_text);
                                          return(TOK_SIMPLE_IDENTIFIER); }                                          return(TOK_SIMPLE_IDENTIFIER); }
         YY_BREAK         YY_BREAK
 case 81: case 81:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 246 "cimmof.l"  #line 248 "cimmof.l"
 { cimmof_lval.strval = new String(cimmof_text); { cimmof_lval.strval = new String(cimmof_text);
                                          return(TOK_UNEXPECTED_CHAR); }                                          return(TOK_UNEXPECTED_CHAR); }
         YY_BREAK         YY_BREAK
 case 82: case 82:
 YY_RULE_SETUP YY_RULE_SETUP
 #line 249 "cimmof.l"  #line 251 "cimmof.l"
 ECHO; ECHO;
         YY_BREAK         YY_BREAK
 #line 1606 "cimmof_lex.cpp"  #line 1588 "cimmof_lex.cpp"
  
         case YY_END_OF_BUFFER:         case YY_END_OF_BUFFER:
                 {                 {
Line 1933 
Line 1915 
         return yy_is_jam ? 0 : yy_current_state;         return yy_is_jam ? 0 : yy_current_state;
 } }
  
     static void yyunput (int c, register char * yy_bp )  
 {  
         register char *yy_cp;  
   
     yy_cp = (yy_c_buf_p);  
   
         /* undo effects of setting up cimmof_text */  
         *yy_cp = (yy_hold_char);  
   
         if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )  
                 { /* need to shift things up to make room */  
                 /* +2 for EOB chars. */  
                 register int number_to_move = (yy_n_chars) + 2;  
                 register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[  
                                         YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];  
                 register char *source =  
                                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];  
   
                 while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )  
                         *--dest = *--source;  
   
                 yy_cp += (int) (dest - source);  
                 yy_bp += (int) (dest - source);  
                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars =  
                         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;  
   
                 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )  
                         YY_FATAL_ERROR( "flex scanner push-back overflow" );  
                 }  
   
         *--yy_cp = (char) c;  
   
     if ( c == '\n' ){  
         --cimmof_lineno;  
     }  
   
         (yytext_ptr) = yy_bp;  
         (yy_hold_char) = *yy_cp;  
         (yy_c_buf_p) = yy_cp;  
 }  
   
 #ifndef YY_NO_INPUT #ifndef YY_NO_INPUT
 #ifdef __cplusplus #ifdef __cplusplus
     static int yyinput (void)     static int yyinput (void)
Line 2367 
Line 2308 
  
 /** Setup the input buffer state to scan the given bytes. The next call to cimmof_lex() will /** Setup the input buffer state to scan the given bytes. The next call to cimmof_lex() will
  * scan from a @e copy of @a bytes.  * scan from a @e copy of @a bytes.
  * @param yybytes the byte buffer to scan   * @param bytes the byte buffer to scan
  * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.   * @param len the number of bytes in the buffer pointed to by @a bytes.
  *  *
  * @return the newly allocated buffer state object.  * @return the newly allocated buffer state object.
  */  */
Line 2434 
Line 2375 
         BEGIN((yy_start_stack)[(yy_start_stack_ptr)]);         BEGIN((yy_start_stack)[(yy_start_stack_ptr)]);
 } }
  
     static int yy_top_state  (void)  
 {  
         return (yy_start_stack)[(yy_start_stack_ptr) - 1];  
 }  
   
 #ifndef YY_EXIT_FAILURE #ifndef YY_EXIT_FAILURE
 #define YY_EXIT_FAILURE 2 #define YY_EXIT_FAILURE 2
 #endif #endif
Line 2655 
Line 2591 
  
 #define YYTABLES_NAME "yytables" #define YYTABLES_NAME "yytables"
  
 #line 249 "cimmof.l"  #line 251 "cimmof.l"
  
  
  
 void cimmof_yy_less(int n) { yyless(n); } void cimmof_yy_less(int n) { yyless(n); }
  
 // Implemented to hide bison functions that are defined but not used  
 // so compiler unused warnings can be enabled.  The functions defined in ths  
 // dummy function are those current defined by Flex but never called by  
 // Pegasus lex definitions. Since each compiler has different rules for  
 // hiding unused functions, we implement each that we know.  
 // CLANG can use the pragma below.  
 // GCC hides the unused function through the recursive call  
 // NOT tested with other compilers.  
 #ifdef __clang__  
 #pragma clang diagnostic push  
 #pragma clang diagnostic ignored "-Wunused-function"  
 #endif  
 static void UNUSED_LEX_FUNCTIONS()  
 {  
    UNUSED_LEX_FUNCTIONS();    // call itself to avoid unused function warning  
    yyunput(3, (char *)"");    // call unused lex functions  
    yy_top_state();  
 }  
 #ifdef __clang__  
 #pragma clang diagnostic pop  
 #endif  
   

Legend:
Removed from v.1.35.8.2  
changed lines
  Added in v.1.35.8.3
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2