(file) Return to mof.l CVS log (file) (dir) Up to [OMI] / omi / mof

Diff for /omi/mof/mof.l between version 1.2 and 1.3

version 1.2, 2015/04/20 18:10:13 version 1.3, 2015/04/20 18:19:53
Line 102 
Line 102 
 DISABLEOVERRIDE [Dd][Ii][Ss][Aa][Bb][Ll][Ee][Oo][Vv][Ee][Rr][Rr][Ii][Dd][Ee] DISABLEOVERRIDE [Dd][Ii][Ss][Aa][Bb][Ll][Ee][Oo][Vv][Ee][Rr][Rr][Ii][Dd][Ee]
 RESTRICTED [Rr][Ee][Ss][Tt][Rr][Ii][Cc][Tt][Ee][Dd] RESTRICTED [Rr][Ee][Ss][Tt][Rr][Ii][Cc][Tt][Ee][Dd]
 TOSUBCLASS [Tt][Oo][Ss][Uu][Bb][Cc][Ll][Aa][Ss][Ss] TOSUBCLASS [Tt][Oo][Ss][Uu][Bb][Cc][Ll][Aa][Ss][Ss]
   TOINSTANCE [Tt][Oo][Ii][Nn][Ss][Tt][Aa][Nn][Cc][Ee]
 TRANSLATABLE [Tt][Rr][Aa][Nn][Ss][Ll][Aa][Tt][Aa][Bb][Ll][Ee] TRANSLATABLE [Tt][Rr][Aa][Nn][Ss][Ll][Aa][Tt][Aa][Bb][Ll][Ee]
  
 /* Instance of */ /* Instance of */
 INSTANCE [Ii][Nn][Ss][Tt][Aa][Nn][Cc][Ee] INSTANCE [Ii][Nn][Ss][Tt][Aa][Nn][Cc][Ee]
 OF [Oo][Ff] OF [Oo][Ff]
  
   /* Object */
   OBJECT [Oo][Bb][Jj][Ee][Cc][Tt]
   
 /* Alias */ /* Alias */
 AS [Aa][Ss] AS [Aa][Ss]
  
Line 170 
Line 174 
 } }
  
 {DT_BOOLEAN} { {DT_BOOLEAN} {
       yylval.identifier = MOF_Strdup(&state.heap, yytext);
     return TOK_BOOLEAN;     return TOK_BOOLEAN;
 } }
  
Line 214 
Line 219 
 } }
  
 {DT_DATETIME} { {DT_DATETIME} {
       yylval.identifier = MOF_Strdup(&state.heap, yytext);
     return TOK_DATETIME;     return TOK_DATETIME;
 } }
  
Line 222 
Line 228 
 } }
  
 {DT_STRING} { {DT_STRING} {
       yylval.identifier = MOF_Strdup(&state.heap, yytext);
     return TOK_STRING;     return TOK_STRING;
 } }
  
Line 234 
Line 241 
 } }
  
 {CLASS} { {CLASS} {
       yylval.identifier = MOF_Strdup(&state.heap, yytext);
     return TOK_CLASS;     return TOK_CLASS;
 } }
  
 {ASSOCIATION} { {ASSOCIATION} {
       yylval.identifier = MOF_Strdup(&state.heap, yytext);
     return TOK_ASSOCIATION;     return TOK_ASSOCIATION;
 } }
  
 {INDICATION} { {INDICATION} {
       yylval.identifier = MOF_Strdup(&state.heap, yytext);
     return TOK_INDICATION;     return TOK_INDICATION;
 } }
  
 {QUALIFIER} { {QUALIFIER} {
       yylval.identifier = MOF_Strdup(&state.heap, yytext);
     return TOK_QUALIFIER;     return TOK_QUALIFIER;
 } }
  
 {PROPERTY} { {PROPERTY} {
       yylval.identifier = MOF_Strdup(&state.heap, yytext);
     return TOK_PROPERTY;     return TOK_PROPERTY;
 } }
  
 {REFERENCE} { {REFERENCE} {
       yylval.identifier = MOF_Strdup(&state.heap, yytext);
     return TOK_REFERENCE;     return TOK_REFERENCE;
 } }
  
 {METHOD} { {METHOD} {
       yylval.identifier = MOF_Strdup(&state.heap, yytext);
     return TOK_METHOD;     return TOK_METHOD;
 } }
  
 {PARAMETER} { {PARAMETER} {
       yylval.identifier = MOF_Strdup(&state.heap, yytext);
     return TOK_PARAMETER;     return TOK_PARAMETER;
 } }
  
 {ANY} { {ANY} {
       yylval.identifier = MOF_Strdup(&state.heap, yytext);
     return TOK_ANY;     return TOK_ANY;
 } }
  
 {FLAVOR} { {FLAVOR} {
       yylval.identifier = MOF_Strdup(&state.heap, yytext);
     return TOK_FLAVOR;     return TOK_FLAVOR;
 } }
  
 {ENABLEOVERRIDE} { {ENABLEOVERRIDE} {
       yylval.identifier = MOF_Strdup(&state.heap, yytext);
     return TOK_ENABLEOVERRIDE;     return TOK_ENABLEOVERRIDE;
 } }
  
 {DISABLEOVERRIDE} { {DISABLEOVERRIDE} {
       yylval.identifier = MOF_Strdup(&state.heap, yytext);
     return TOK_DISABLEOVERRIDE;     return TOK_DISABLEOVERRIDE;
 } }
  
 {RESTRICTED} { {RESTRICTED} {
       yylval.identifier = MOF_Strdup(&state.heap, yytext);
     return TOK_RESTRICTED;     return TOK_RESTRICTED;
 } }
  
 {TOSUBCLASS} { {TOSUBCLASS} {
       yylval.identifier = MOF_Strdup(&state.heap, yytext);
     return TOK_TOSUBCLASS;     return TOK_TOSUBCLASS;
 } }
  
   {TOINSTANCE} {
       yylval.identifier = MOF_Strdup(&state.heap, yytext);
       return TOK_TOINSTANCE;
   }
   
 {TRANSLATABLE} { {TRANSLATABLE} {
       yylval.identifier = MOF_Strdup(&state.heap, yytext);
     return TOK_TRANSLATABLE;     return TOK_TRANSLATABLE;
 } }
  
Line 298 
Line 325 
 } }
  
 {OF} { {OF} {
       yylval.identifier = MOF_Strdup(&state.heap, yytext);
     return TOK_OF;     return TOK_OF;
 } }
  
Line 305 
Line 333 
     return TOK_AS;     return TOK_AS;
 } }
  
   {OBJECT} {
       return TOK_OBJECT;
   }
   
 {PRAGMA} { {PRAGMA} {
       yylval.identifier = MOF_Strdup(&state.heap, yytext);
     return TOK_PRAGMA;     return TOK_PRAGMA;
 } }
  
Line 704 
Line 737 
     }     }
  
     /* Open the file */     /* Open the file */
     if ((is = Fopen(path, "rb")) == NULL)      if ((is = File_Open(path, "rb")) == NULL)
     {     {
         yyerrorf(ID_FAILED_TO_OPEN_FILE, "failed to open file: \"%s\"", path);         yyerrorf(ID_FAILED_TO_OPEN_FILE, "failed to open file: \"%s\"", path);
         return -1;         return -1;
Line 759 
Line 792 
     const char* const* paths,     const char* const* paths,
     size_t numPaths)     size_t numPaths)
 { {
     MOF_Parser* self = (MOF_Parser*)calloc(1, sizeof(MOF_Parser));      MOF_Parser* self = (MOF_Parser*)PAL_Calloc(1, sizeof(MOF_Parser));
     size_t i;     size_t i;
     char* str;     char* str;
  
Line 773 
Line 806 
         if (!str)         if (!str)
         {         {
             MOF_Release(&self->state.heap);             MOF_Release(&self->state.heap);
             free(self);              PAL_Free(self);
             return NULL;             return NULL;
         }         }
  
Line 869 
Line 902 
     if (self)     if (self)
     {     {
         MOF_Release(&self->state.heap);         MOF_Release(&self->state.heap);
         free(self);          PAL_Free(self);
     }     }
 } }
  
Line 887 
Line 920 
     state = self->state;     state = self->state;
  
     /* Open input */     /* Open input */
     yyin = Fopen(path, "rb");      yyin = File_Open(path, "rb");
  
     if (!yyin)     if (!yyin)
     {     {
Line 939 
Line 972 
     return 0;     return 0;
 } }
  
   /* Parse a MOF string */
   int MOF_Parser_ParseString(MOF_Parser* self, const char* mof_string)
   {
       YY_BUFFER_STATE bp;
   
       /* Reject null parameters */
       if (!self || !mof_string)
           return -1;
   
       /* Clear stack */
       s_top = 0;
   
       /* Set global state */
       state = self->state;
   
       /* Save path */
       state.path = MOF_Strdup(&state.heap, "MOF string");
   
       /* Set initialize line number */
       state.line = 1;
   
       /* Clear the parser state */
       yy_c_buf_p = 0;
       yy_last_accepting_cpos = 0;
       yy_init = 1;
   
       /* Run the parser */
       bp = yy_scan_string(mof_string);
       yy_switch_to_buffer(bp);
       if (yyparse() != 0)
       {
           yy_delete_buffer(bp);
           self->state = state;
           memset(&state.heap, 0, sizeof(state));
           return -1;
       }
   
       /* Perform post processing (which requires first pass completion) */
       if (PerformPostProcessing() != 0)
       {
           yy_delete_buffer(bp);
           self->state = state;
           memset(&state.heap, 0, sizeof(state));
           return -1;
       }
   
       /* Close stream and release parse buffer */
       yy_delete_buffer(bp);
   
       /* Restore state */
       self->state = state;
       memset(&state.heap, 0, sizeof(state));
   
       return 0;
   }
   
 void MOF_Parser_Dump(MOF_Parser* self, FILE* file) void MOF_Parser_Dump(MOF_Parser* self, FILE* file)
 { {
     size_t i;     size_t i;
Line 952 
Line 1041 
     for (i = 0; i < self->state.instanceDecls.size; i++)     for (i = 0; i < self->state.instanceDecls.size; i++)
         MOF_PrintInstanceDecl(self->state.instanceDecls.data[i], file);         MOF_PrintInstanceDecl(self->state.instanceDecls.data[i], file);
 } }
   
   void MOF_Parser_EnableExtensions(MOF_Parser* self, MI_Boolean enabled)
   {
       self->state.extensionsEnabled = enabled;
       return;
   }

Legend:
Removed from v.1.2  
changed lines
  Added in v.1.3
ViewCVS 0.9.2