Token Lexer::parseNext() {
//skip whitespace of the current character
skipWhitespace();
//return eof if we are at the end
if (curChar() == '\0') {
return Token::Eof;
}
Token ret;
//first check if it is a keyword and return it
ret = parseKeyword();
if (ret != Token::None)
return ret;
ret = parseSymbol();
if (ret != Token::None)
return ret;
ret = parseIdentifier();
if (ret != Token::None)
return ret;
ret = parseNumeric();
if (ret != Token::None)
return ret;
//if nothing was able to parse it, it must be a character and we return it
value.character = eatChar();
return Token::Character;
}
QVariant parse()
{
LOG_AS("JSONParser");
if(atEnd()) return QVariant();
QChar c = peek();
if(c == '{')
{
return parseObject();
}
else if(c == '[')
{
return parseArray();
}
else if(c == '\"')
{
return parseString();
}
else if(c == '-' || c.isDigit())
{
return parseNumber();
}
else
{
return parseKeyword();
}
}
/**
* Parses the source code
*/
int CodeParser::parse( Scope* scope, TokenStack* stack ) {
int errorCode = 0;
Token *t;
// get the command arguments
while( !errorCode && stack->hasNext() && ( t = stack->peek() ) ) {
//printf( "t = %s[%s]\n", t->getTypeName(), t->getText() );
// check situationally
switch( t->getType() ) {
case tok::CODE_BLOCK:
errorCode = parseAnonymuousCodeBlock( scope, ( t = stack->next() ) );
break;
case tok::ASSEMBLY_BLOCK:
errorCode = assemblyParser->parse( scope, stack );
break;
case tok::END_OF_STATEMENT:
t = stack->next();
this->modifiers = 0;
break;
case tok::ALPHA_NUMERIC:
// is the token a keyword?
if( state->isKeyword( t->getText() ) ) {
const char *keyword = stack->next()->getText();
errorCode = parseKeyword( scope, stack, keyword );
}
// is it a field/method declaration?
else if( state->isClass( t->getText() ) ) {
errorCode = parseClassMember( scope, stack );
}
// must be an assignment or method invocation ...
else {
errorCode = parseExpression( scope, stack );
}
break;
// anything else ...
default:
SYNTAX_ERROR( "unrecognized command", t );
errorCode = -1;
break;
}
}
return errorCode;
}
bool ScriptParser::parseSpecial (int code, const TokenLoc& loc, Scanner& scanner)
{
if (code==Scanner::S_newline) // empty line
return true;
if (code==Scanner::S_open) /// \todo Option to switch this off
{
scanner.putbackSpecial (code, loc);
return parseKeyword (Scanner::K_if, loc, scanner);
}
mLineParser.reset();
if (mLineParser.parseSpecial (code, loc, scanner))
scanner.scan (mLineParser);
return true;
}
void
HangStruct::ScanState(const char *code, const char *state)
{
if (code != 0)
{
for (int n = 0; code[n] != NULLC; n++)
{
if (state[n] == Normal)
{
int c = code[n];
if (isName(c)
&& (n == 0 || !isName(code[n-1])))
{
char *name = parseKeyword(code, n);
int findWord = LookupKeyword(name);
TRACE(("lookup '%s' ->%d\n", name, findWord));
do_aggreg = False;
if (findWord >= 0)
{
indent = 0;
until_parn = 1;
if (pIndentWords[findWord].code == oneLine)
stmt_level++;
else
stmt_level = 0;
}
else
{
if (!strcmp(name, "enum"))
until_curl = 1;
if (parn_level == 0)
until_parn = 0;
indent = 1;
}
delete[] name;
}
else if (!isspace(code[n]))
{
if (do_aggreg && code[n] != L_CURL)
do_aggreg = False;
switch (code[n])
{
case '=':
if (parn_level == 0)
do_aggreg = True;
break;
case L_CURL:
curl_level++;
indent = 0;
stmt_level = 0;
until_parn = 0;
if (do_aggreg)
in_aggreg = curl_level;
break;
case R_CURL:
curl_level--;
indent = 0;
stmt_level = 0;
until_curl = 0;
break;
case ':':
// "::" means something different entirely
if (code[n+1] == ':')
{
n++;
}
else
{
indent = 0;
stmt_level = 0;
until_parn = 0;
}
break;
case SEMICOLON:
if (parn_level == 0)
{
indent = 0;
stmt_level = 0;
until_parn = 0;
until_curl = 0;
if (in_aggreg > curl_level)
in_aggreg = 0;
}
break;
case L_PAREN:
parn_level++;
indent = 1;
break;
case R_PAREN:
parn_level--;
if (until_parn && !parn_level)
indent = 0;
else
indent = 1;
break;
case ESCAPE:
break;
default:
indent = 1;
break;
}
}
}
}
}
}
