AST* ParseOperator(ParserState* parser) {
AST* ast;
switch(parser->currentToken.type) {
case TOKEN_BEGIN:
return ParseBlock(parser);
case TOKEN_ID:
ast = parser->nextToken.type == TOKEN_LEFTBRACKET ? ParseFunctionCall(parser) : ParseAssignment(parser);
Match(parser, TOKEN_SEMICOLON);
return ast;
case TOKEN_LOCAL:
ast = ParseAssignment(parser);
Match(parser, TOKEN_SEMICOLON);
return ast;
case TOKEN_WHILE:
return ParseWhileCycle(parser);
case TOKEN_IF:
return ParseIfStatement(parser);
case TOKEN_FUNCTION:
return ParseFunctionDefinition(parser);
case TOKEN_RETURN:
ast = ParseReturn(parser);
Match(parser, TOKEN_SEMICOLON);
return ast;
case TOKEN_PRINT:
ast = ParsePrint(parser);
Match(parser, TOKEN_SEMICOLON);
return ast;
case TOKEN_INCLUDE:
return ParseInclude(parser);
case TOKEN_LOAD:
ast = ParseLoad(parser);
Match(parser, TOKEN_SEMICOLON);
return ast; /** TODO: Factor common parts out of switch */
}
FailWithUnexpectedToken(parser, parser->currentToken.type, TOKEN_ID);
return NULL;
}
void XSDParser::BuildDocumentTree(CDataTypeModule& module)
{
size_t lexerStackSize = m_StackLexer.size();
bool skipEof = false;
ParseHeader();
CopyComments(module.Comments());
TToken tok;
int emb=0;
for (;;) {
tok = GetNextToken();
switch ( tok ) {
case K_INCLUDE:
ParseInclude();
break;
case K_ELEMENT:
ParseElementContent(0, emb);
break;
case K_ATTRIBUTE:
ParseAttributeContent();
break;
case K_COMPLEXTYPE:
case K_SIMPLETYPE:
CreateTypeDefinition(DTDEntity::eType);
break;
case K_GROUP:
CreateTypeDefinition(DTDEntity::eGroup);
break;
case K_ATTPAIR:
break;
case T_EOF:
if (skipEof) {
skipEof = false;
break;
}
ParseError("Unexpected end-of-file", "keyword");
return;
case K_ENDOFTAG:
if (m_StackLexer.size() > lexerStackSize) {
skipEof = true;
break;
}
if (m_SrcType == eSchema) {
ProcessNamedTypes();
}
return;
case K_IMPORT:
ParseImport();
break;
case K_ATTRIBUTEGROUP:
CreateTypeDefinition(DTDEntity::eAttGroup);
break;
case K_ANNOTATION:
m_Comments = &(module.Comments());
ParseAnnotation();
break;
default:
ParseError("Invalid keyword", "keyword");
return;
}
}
}
/** Parse a token list. */
void Parse(const TokenNode *start, int depth)
{
TokenNode *tp;
if(!start) {
return;
}
if(JLIKELY(start->type == TOK_JWM)) {
for(tp = start->subnodeHead; tp; tp = tp->next) {
if(shouldReload) {
switch(tp->type) {
case TOK_ROOTMENU:
ParseRootMenu(tp);
break;
case TOK_INCLUDE:
ParseInclude(tp, depth);
break;
default:
break;
}
} else {
switch(tp->type) {
case TOK_DESKTOPS:
ParseDesktops(tp);
break;
case TOK_DOUBLECLICKSPEED:
settings.doubleClickSpeed = ParseUnsigned(tp, tp->value);
break;
case TOK_DOUBLECLICKDELTA:
settings.doubleClickDelta = ParseUnsigned(tp, tp->value);
break;
case TOK_FOCUSMODEL:
ParseFocusModel(tp);
break;
case TOK_GROUP:
ParseGroup(tp);
break;
case TOK_ICONPATH:
AddIconPath(tp->value);
break;
case TOK_INCLUDE:
ParseInclude(tp, depth);
break;
case TOK_KEY:
ParseKey(tp);
break;
case TOK_MENUSTYLE:
ParseMenuStyle(tp);
break;
case TOK_MOVEMODE:
ParseMoveMode(tp);
break;
case TOK_PAGERSTYLE:
ParsePagerStyle(tp);
break;
case TOK_POPUPSTYLE:
ParsePopupStyle(tp);
break;
case TOK_RESIZEMODE:
ParseResizeMode(tp);
break;
case TOK_RESTARTCOMMAND:
AddRestartCommand(tp->value);
break;
case TOK_ROOTMENU:
ParseRootMenu(tp);
break;
case TOK_SHUTDOWNCOMMAND:
AddShutdownCommand(tp->value);
break;
case TOK_SNAPMODE:
ParseSnapMode(tp);
break;
case TOK_STARTUPCOMMAND:
AddStartupCommand(tp->value);
break;
case TOK_TASKLISTSTYLE:
ParseTaskListStyle(tp);
break;
case TOK_TRAY:
ParseTray(tp);
break;
case TOK_TRAYSTYLE:
ParseTrayStyle(tp);
break;
case TOK_TRAYBUTTONSTYLE:
ParseTrayButtonStyle(tp);
break;
case TOK_CLOCKSTYLE:
ParseClockStyle(tp);
break;
case TOK_WINDOWSTYLE:
ParseWindowStyle(tp);
break;
case TOK_BUTTONCLOSE:
SetBorderIcon(BI_CLOSE, tp->value);
break;
case TOK_BUTTONMAX:
SetBorderIcon(BI_MAX, tp->value);
break;
case TOK_BUTTONMAXACTIVE:
SetBorderIcon(BI_MAX_ACTIVE, tp->value);
break;
case TOK_BUTTONMIN:
SetBorderIcon(BI_MIN, tp->value);
break;
default:
InvalidTag(tp, TOK_JWM);
break;
}
}
}
} else {
ParseError(start, "invalid start tag: %s", GetTokenName(start));
}
}
int Parser::Parse()
{
Tag *tagList;
TypeDecl *typeDecl;
Statement *stmt;
// keep going until there are no more tokens!
while(t)
{
TOKEN allowed[] =
{
TOK_LENGTHIS, TOK_SIZEIS, TOK_IGNORE, TOK_STRING,
TOK_OFFSET, TOK_ALIGN, TOK_BITFLAG, TOK_STYLE, TOK_DISPLAY,
TOK_ENDIAN, TOK_SWITCHIS, TOK_CASE, TOK_NAME,
TOK_ENUM, TOK_EXPORT, TOK_ASSOC,
TOK_NULL
};
// save any whitespace before the tags
FILEREF fileRef;
lex_fileref(&fileRef);
if(!ParseTags(&tagList, allowed))
return 0;
//
// Decide what kind of statement/construct we need to parse
//
switch(t)
{
case TOK_INCLUDE:
// include-statement (not the same as #include which
// is a C-preprocessor thing)
if((stmt = ParseInclude()) == 0)
{
return 0;
}
curFile->stmtList.push_back(stmt);
break;
default:
size_t s1 = globalFileHistory.size();
// anything else must be a type-declaration
if((typeDecl = ParseTypeDecl(tagList, globalIdentifierList, false, true)) == 0)
return 0;
size_t s2 = globalFileHistory.size();
// store in the global list
typeDecl->fileRef = fileRef;
globalTypeDeclList.push_back(typeDecl);
//curFile->typeDeclList.push_back(typeDecl);
curFile->stmtList.push_back(new Statement(typeDecl));
// every type-declaration must end with a ';'
if(!Expected(';'))
return 0;
// record any whitespace that appears after the type-decl
lex_fileref(&typeDecl->postRef);
break;
}
}
ExportStructs();
return (errcount == 0) ? 1 : 0;
}
