static void parseFunction (tokenInfo *const token)
{
tokenInfo *const name = newToken ();
vString *const signature = vStringNew ();
boolean is_class = FALSE;
/*
* This deals with these formats
* function validFunctionTwo(a,b) {}
*/
readToken (name);
if (!isType (name, TOKEN_IDENTIFIER))
goto cleanUp;
/* Add scope in case this is an INNER function */
addToScope(name, token->scope);
readToken (token);
while (isType (token, TOKEN_PERIOD))
{
readToken (token);
if ( isKeyword(token, KEYWORD_NONE) )
{
addContext (name, token);
readToken (token);
}
}
if ( isType (token, TOKEN_OPEN_PAREN) )
skipArgumentList(token, FALSE, signature);
if ( isType (token, TOKEN_OPEN_CURLY) )
{
is_class = parseBlock (token, name);
if ( is_class )
makeClassTag (name, signature);
else
makeFunctionTag (name, signature);
}
findCmdTerm (token, FALSE, FALSE);
cleanUp:
vStringDelete (signature);
deleteToken (name);
}
static boolean parseIf (tokenInfo *const token)
{
boolean read_next_token = TRUE;
/*
* If statements have two forms
* if ( ... )
* one line;
*
* if ( ... )
* statement;
* else
* statement
*
* if ( ... ) {
* multiple;
* statements;
* }
*
*
* if ( ... ) {
* return elem
* }
*
* This example if correctly written, but the
* else contains only 1 statement without a terminator
* since the function finishes with the closing brace.
*
* function a(flag){
* if(flag)
* test(1);
* else
* test(2)
* }
*
* TODO: Deal with statements that can optional end
* without a semi-colon. Currently this messes up
* the parsing of blocks.
* Need to somehow detect this has happened, and either
* backup a token, or skip reading the next token if
* that is possible from all code locations.
*
*/
readToken (token);
if (isKeyword (token, KEYWORD_if))
{
/*
* Check for an "else if" and consume the "if"
*/
readToken (token);
}
if (isType (token, TOKEN_OPEN_PAREN))
{
/*
* Handle nameless functions, these will only
* be considered methods.
*/
skipArgumentList(token);
}
if (isType (token, TOKEN_OPEN_CURLY))
{
/*
* This will be either a function or a class.
* We can only determine this by checking the body
* of the function. If we find a "this." we know
* it is a class, otherwise it is a function.
*/
parseBlock (token, token);
}
else
{
findCmdTerm (token);
/* The next token should only be read if this statement had its own
* terminator */
read_next_token = isType (token, TOKEN_SEMICOLON);
}
return read_next_token;
}
static boolean parseIf (tokenInfo *const token, tokenInfo *const parent)
{
boolean read_next_token = TRUE;
/*
* If statements have two forms
* if ( ... )
* one line;
*
* if ( ... )
* statement;
* else
* statement
*
* if ( ... ) {
* multiple;
* statements;
* }
*
*
* if ( ... ) {
* return elem
* }
*
* This example if correctly written, but the
* else contains only 1 statement without a terminator
* since the function finishes with the closing brace.
*
* function a(flag){
* if(flag)
* test(1);
* else
* test(2)
* }
*
* TODO: Deal with statements that can optional end
* without a semi-colon. Currently this messes up
* the parsing of blocks.
* Need to somehow detect this has happened, and either
* backup a token, or skip reading the next token if
* that is possible from all code locations.
*
*/
readToken (token);
if (isKeyword (token, KEYWORD_if))
{
/*
* Check for an "else if" and consume the "if"
*/
readToken (token);
}
if (isType (token, TOKEN_OPEN_PAREN))
{
skipArgumentList(token, FALSE, NULL);
}
if (isType (token, TOKEN_OPEN_CURLY))
{
parseBlock (token, parent);
}
else
{
/* The next token should only be read if this statement had its own
* terminator */
read_next_token = findCmdTerm (token, TRUE, FALSE);
}
return read_next_token;
}
