version 1.2, 2015/04/20 18:10:13
|
version 1.3, 2015/04/20 18:19:53
|
|
|
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] |
| |
|
|
} | } |
| |
{DT_BOOLEAN} { | {DT_BOOLEAN} { |
|
yylval.identifier = MOF_Strdup(&state.heap, yytext); |
return TOK_BOOLEAN; | return TOK_BOOLEAN; |
} | } |
| |
|
|
} | } |
| |
{DT_DATETIME} { | {DT_DATETIME} { |
|
yylval.identifier = MOF_Strdup(&state.heap, yytext); |
return TOK_DATETIME; | return TOK_DATETIME; |
} | } |
| |
|
|
} | } |
| |
{DT_STRING} { | {DT_STRING} { |
|
yylval.identifier = MOF_Strdup(&state.heap, yytext); |
return TOK_STRING; | return TOK_STRING; |
} | } |
| |
|
|
} | } |
| |
{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; |
} | } |
| |
|
|
} | } |
| |
{OF} { | {OF} { |
|
yylval.identifier = MOF_Strdup(&state.heap, yytext); |
return TOK_OF; | return TOK_OF; |
} | } |
| |
|
|
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; |
} | } |
| |
|
|
} | } |
| |
/* 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; |
|
|
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; |
| |
|
|
if (!str) | if (!str) |
{ | { |
MOF_Release(&self->state.heap); | MOF_Release(&self->state.heap); |
free(self); |
PAL_Free(self); |
return NULL; | return NULL; |
} | } |
| |
|
|
if (self) | if (self) |
{ | { |
MOF_Release(&self->state.heap); | MOF_Release(&self->state.heap); |
free(self); |
PAL_Free(self); |
} | } |
} | } |
| |
|
|
state = self->state; | state = self->state; |
| |
/* Open input */ | /* Open input */ |
yyin = Fopen(path, "rb"); |
yyin = File_Open(path, "rb"); |
| |
if (!yyin) | if (!yyin) |
{ | { |
|
|
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; |
|
|
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; |
|
} |