static void HandleExtern() {
if (shared_ptr<ExprAST> E = ParseExtern()) {
//cout<<"Parsed an extern\n";
} else {
getNextToken();
}
}
static void HandleExtern() {
if (ParseExtern()) {
fprintf(stderr, "Parsed an extern\n");
} else {
// Skip token for error recovery.
getNextToken();
}
}
void
HandleExtern()
{
if ( ParseExtern() )
std::cout << "...parsed an extern statement.\n";
else
getNextToken();
}
static void HandleExtern()
{
if (ParseExtern()) {
fprintf(stderr, "Parsed an extern.\n");
}
else {
getNextToken();
}
}
// primary
// ::= identifierexpr
// ::= floatexpr
// ::= intexpr
// ::= boolexpr
// ::= parenexpr
// ::= externexpr
ExprAST *Parser::ParsePrimary() {
if (Lex.tok == tok_extern) return ParseExtern();
if (Lex.tok == tok_identifier) return ParseIdentifierExpr();
if (Lex.tok == tok_true || Lex.tok == tok_false) return ParseBoolExpr();
if (Lex.tok == tok_int) return ParseIntExpr();
if (Lex.tok == tok_float) return ParseFloatExpr();
if (Lex.tok == tok_if) return ParseIfThenElse();
if (Lex.tok == tok_while || Lex.tok == tok_until) return ParseWhile();
if (Lex.tok == tok_break || Lex.tok == tok_continue) {
BreakContE t = (Lex.tok == tok_break ? bc_break : bc_continue);
Lex.gettok();
return new BreakContAST(Lex.tag(), t);
}
if (Lex.tokStr == "(") return ParseParenExpr();
Lex.tag().Throw("Unknown token '" + Lex.tokStr + "' when expecting an expression.");
return 0;
}
DefAST *Parser::ParseFuncDefinition() {
FTag tag = Lex.tag(); // definitions usually span several lines, so save tag for now.
Lex.gettok(); // eat 'func'
if (Lex.tok != tok_identifier) Lex.tag().Throw("Expected identifier after 'func'.");
std::string name = Lex.tokStr;
Lex.gettok(); // eat function name
if (Lex.tokStr != ":") Lex.tag().Throw("Expected ':' in function definition.");
Lex.gettok();
FuncTypeAST *type = ParsePrototype();
if (type == 0) return 0;
if (Lex.tok == tok_extern) {
ExternAST *v = dynamic_cast<ExternAST*>(ParseExtern());
return new ExternFuncDefAST(tag, name, v, type);
} else {
BlockAST *b = dynamic_cast<BlockAST*>(ParseBlock());
if (b == 0) return 0;
return new FuncDefAST(tag, name, new FuncExprAST(tag, type, b));
}
}
/*******************************************************************
* ParseOrdinal
*
* Parse an ordinal definition.
*/
static void ParseOrdinal(int ordinal)
{
const char *token;
ORDDEF *odp = xmalloc( sizeof(*odp) );
memset( odp, 0, sizeof(*odp) );
EntryPoints[nb_entry_points++] = odp;
token = GetToken(0);
for (odp->type = 0; odp->type < TYPE_NBTYPES; odp->type++)
if (TypeNames[odp->type] && !strcmp( token, TypeNames[odp->type] ))
break;
if (odp->type >= TYPE_NBTYPES)
fatal_error( "Expected type after ordinal, found '%s' instead\n", token );
token = GetToken(0);
if (*token == '-') token = ParseFlags( odp );
odp->name = xstrdup( token );
odp->export_name = xstrdup( token );
fix_export_name( odp->name );
odp->lineno = current_line;
odp->ordinal = ordinal;
switch(odp->type)
{
case TYPE_VARIABLE:
ParseVariable( odp );
break;
case TYPE_PASCAL_16:
case TYPE_PASCAL:
case TYPE_STDCALL:
case TYPE_VARARGS:
case TYPE_CDECL:
ParseExportFunction( odp );
break;
case TYPE_ABS:
ParseEquate( odp );
break;
case TYPE_STUB:
ParseStub( odp );
break;
case TYPE_EXTERN:
ParseExtern( odp );
break;
case TYPE_FORWARD:
ParseForward( odp );
break;
default:
assert( 0 );
}
#ifndef __i386__
if (odp->flags & FLAG_I386)
{
/* ignore this entry point on non-Intel archs */
EntryPoints[--nb_entry_points] = NULL;
free( odp );
return;
}
#endif
if (ordinal != -1)
{
if (ordinal >= MAX_ORDINALS) fatal_error( "Ordinal number %d too large\n", ordinal );
if (ordinal > Limit) Limit = ordinal;
if (ordinal < Base) Base = ordinal;
odp->ordinal = ordinal;
Ordinals[ordinal] = odp;
}
if (!strcmp( odp->name, "@" ))
{
if (ordinal == -1)
fatal_error( "Nameless function needs an explicit ordinal number\n" );
if (SpecType != SPEC_WIN32)
fatal_error( "Nameless functions not supported for Win16\n" );
odp->name[0] = 0;
}
else Names[nb_names++] = odp;
}
