void printSeqStatement(FILE* file, IR_myStatement statement, int spaceNum)
{
fprintf(file, "Seq(");
printStatement(file, statement->u.seq.left, spaceNum + 2),
indentAndPrintToFile(file, spaceNum, ", ");
printStatement(file, statement->u.seq.right, spaceNum + 2);
indentAndPrintToFile(file, spaceNum, ")\n");
}
void CodeGenerator::printStatement(const Node *statementNode)
{
Node *son = statementNode->son;
Node *grandSon = son->son;
while(son)
{
switch(son->kind)
{
case VAR_DEC_LIST:
while(grandSon)
{
printVarDec(grandSon);
grandSon = grandSon->bro;
}
break;
case OUTPUT:
printOutput(son);
break;
///아직 여러가지 남음
case STMT:
symbolTable.openNewScope();
printStatement(son);
symbolTable.closeLastScope();
break;
}
son = son->bro;
if(son)
grandSon = son->son;
}
}
void printESeq(FILE* file, IR_myExp exp, int spaceNum)
{
fprintf(file, "Eseq(");
printStatement(file, exp->u.eseq.statement, spaceNum + 2);
indentAndPrintToFile(file, spaceNum, ", ");
printExpression(file, exp->u.eseq.exp, spaceNum + 2);
indentAndPrintToFile(file, spaceNum, ")\n");
}
void printFragments(FILE* file, Frame_myFragList fragments)
{
while (fragments)
{
if (fragments->head->kind == Frame_StringFrag)
{
fprintf(file, "%s:\n", fragments->head->u.strFrag.str);
indentSpace(file, 2);
fprintf(file, "Label: %s\n\n",
MySymbol_GetName(fragments->head->u.strFrag.label));
}
else
{
fprintf(file, "%s:\n", MySymbol_GetName(fragments->head->u.procFrag.funcName));
printStatement(file, fragments->head->u.procFrag.body, 2);
fprintf(file, "\n\n");
}
fragments = fragments->tail;
}
}
NodePointer Parser::statement()
{
NodePointer result;
switch (currentSymbol_.symbolType_)
{
case IF:
return ifStatement();
case WHILE:
return whileStatement();
case IDENTIFIER:
case GLOBAL:
case ARGUMENT:
case CALL:
case CONSTANT:
result = expression();
accept(SEMICOLON);
return result;
case MY:
return localVariable();
case PRINT:
return printStatement();
case SUBROUTINE:
return procedureDefinition();
case RETURN:
return returnStatement();
case LEFT_BRACE:
return blockStatement();
default:
throw ErrorMessage("Unexpected symbol " + symbolToString(currentSymbol_), getLineNumber());
}
}
void CodeGenerator::printSingleFuncDec(const Node *funcDecNode)
{
Node *typeNode = funcDecNode->son;
SYM_TYPE type = getType(typeNode);
printType(typeNode);
ofs << ' ';
Node *funcNameNode = typeNode->bro;
Node *paramNode = funcNameNode->bro;
FuncEntry *funcEntry;
unsigned long long key = SymbolTable::hash(funcNameNode->val.sVal);
if(symbolTable.isInThisScope(key))
{
std::cerr << "function is duplicated : " << funcNameNode->val.sVal << std::endl;
exit(-1);
}
else
{
funcEntry = new FuncEntry(key);
funcEntry->addRetVal(type);
symbolTable.addEntry(funcEntry);
symbolTable.openNewScope();
ofs << funcNameNode->val.sVal << '(';
printParamList(paramNode, funcEntry);
while(paramNode->kind == PARAM)
paramNode = paramNode->bro;
ofs << ')' << std::endl;
ofs << '{' << std::endl;
printStatement(paramNode);
ofs << '}' << std::endl;
symbolTable.closeLastScope();
}
}
static void print(llvm::raw_ostream &out, const Object *x) {
if (x == NULL) {
out << "NULL";
return;
}
switch (x->objKind) {
case SOURCE : {
const Source *y = (const Source *)x;
out << "Source(" << y->fileName << ")";
break;
}
case IDENTIFIER : {
const Identifier *y = (const Identifier *)x;
out << "Identifier(" << y->str << ")";
break;
}
case DOTTED_NAME : {
const DottedName *y = (const DottedName *)x;
out << "DottedName(" << llvm::makeArrayRef(y->parts) << ")";
break;
}
case EXPRESSION : {
const Expr *y = (const Expr *)x;
printExpr(out, y);
break;
}
case EXPR_LIST : {
const ExprList *y = (const ExprList *)x;
out << "ExprList(" << y->exprs << ")";
break;
}
case STATEMENT : {
const Statement *y = (const Statement *)x;
printStatement(out, y);
break;
}
case CASE_BLOCK : {
const CaseBlock *y = (const CaseBlock *)x;
out << "CaseBlock(" << y->caseLabels << ", " << y->body << ")";
break;
}
case CATCH : {
const Catch *y = (const Catch *)x;
out << "Catch(" << y->exceptionVar << ", "
<< y->exceptionType << ", " << y->body << ")";
break;
}
case CODE : {
const Code *y = (const Code *)x;
out << "Code(" << y->patternVars << ", " << y->predicate;
out << ", " << y->formalArgs << ", " << y->hasVarArg;
out << ", " << y->returnSpecs << ", " << y->varReturnSpec;
out << ", " << y->body << ")";
break;
}
case FORMAL_ARG : {
const FormalArg *y = (const FormalArg *)x;
out << "FormalArg(" << y->name << ", " << y->type << ", "
<< y->tempness << ")";
break;
}
case RETURN_SPEC : {
const ReturnSpec *y = (const ReturnSpec *)x;
out << "ReturnSpec(" << y->type << ", " << y->name << ")";
break;
}
case RECORD_DECL : {
const RecordDecl *y = (const RecordDecl *)x;
out << "RecordDecl(" << y->name << ", " << y->params;
out << ", " << y->varParam << ", " << y->body << ")";
break;
}
case RECORD_BODY : {
const RecordBody *y = (const RecordBody *)x;
out << "RecordBody(" << y->isComputed << ", " << y->computed;
out << ", " << y->fields << ")";
break;
}
case RECORD_FIELD : {
const RecordField *y = (const RecordField *)x;
out << "RecordField(" << y->name << ", " << y->type << ")";
break;
}
case VARIANT_DECL : {
const VariantDecl *y = (const VariantDecl *)x;
out << "VariantDecl(" << y->name << ", " << y->params;
out << ", " << y->varParam << ")";
break;
}
case INSTANCE_DECL : {
const InstanceDecl *y = (const InstanceDecl *)x;
out << "InstanceDecl(" << y->patternVars << ", " << y->predicate;
out << ", " << y->target << ", " << y->members << ")";
break;
}
case OVERLOAD : {
const Overload *y = (const Overload *)x;
out << "Overload(" << y->target << ", " << y->code << ", "
<< y->callByName << ", " << y->isInline << ")";
break;
}
case PROCEDURE : {
const Procedure *y = (const Procedure *)x;
out << "Procedure(" << y->name << ")";
break;
}
case INTRINSIC : {
const IntrinsicSymbol *intrin = (const IntrinsicSymbol *)x;
out << "IntrinsicSymbol(" << intrin->name << ", " << intrin->id << ")";
break;
}
case ENUM_DECL : {
const EnumDecl *y = (const EnumDecl *)x;
out << "EnumDecl(" << y->name << ", " << y->members << ")";
break;
}
case ENUM_MEMBER : {
const EnumMember *y = (const EnumMember *)x;
out << "EnumMember(" << y->name << ")";
break;
}
case NEW_TYPE_DECL : {
const NewTypeDecl *y = (const NewTypeDecl *)x;
out << "NewTypeDecl(" << y->name << ")";
break;
}
case GLOBAL_VARIABLE : {
const GlobalVariable *y = (const GlobalVariable *)x;
out << "GlobalVariable(" << y->name << ", " << y->params
<< ", " << y->varParam << ", " << y->expr << ")";
break;
}
case EXTERNAL_PROCEDURE : {
const ExternalProcedure *y = (const ExternalProcedure *)x;
out << "ExternalProcedure(" << y->name << ", " << y->args;
out << ", " << y->hasVarArgs << ", " << y->returnType;
out << ", " << y->body << ")";
break;
}
case EXTERNAL_ARG: {
const ExternalArg *y = (const ExternalArg *)x;
out << "ExternalArg(" << y->name << ", " << y->type << ")";
break;
}
case EXTERNAL_VARIABLE : {
const ExternalVariable *y = (const ExternalVariable *)x;
out << "ExternalVariable(" << y->name << ", " << y->type << ")";
break;
}
case GLOBAL_ALIAS : {
const GlobalAlias *y = (const GlobalAlias *)x;
out << "GlobalAlias(" << y->name << ", " << y->params
<< ", " << y->varParam << ", " << y->expr << ")";
break;
}
case IMPORT : {
const Import *y = (const Import *)x;
switch (y->importKind) {
case IMPORT_MODULE : {
const ImportModule *z = (const ImportModule *)y;
out << "Import(" << z->dottedName << ", " << z->alias << ")";
break;
}
case IMPORT_STAR : {
const ImportStar *z = (const ImportStar *)y;
out << "ImportStar(" << z->dottedName << ")";
break;
}
case IMPORT_MEMBERS : {
const ImportMembers *z = (const ImportMembers *)y;
out << "ImportMembers(" << z->visibility << ", " << z->dottedName << ", [";
for (size_t i = 0; i < z->members.size(); ++i) {
if (i != 0)
out << ", ";
const ImportedMember &a = z->members[i];
out << "(" << a.name << ", " << a.alias << ")";
}
out << "])";
break;
}
default :
assert(false);
}
break;
}
case EVAL_TOPLEVEL : {
const EvalTopLevel *eval = (const EvalTopLevel *)x;
out << "EvalTopLevel(" << eval->args << ")";
break;
}
case STATIC_ASSERT_TOP_LEVEL : {
const StaticAssertTopLevel *staticAssert = (const StaticAssertTopLevel*)x;
out << "StaticAssertTopLevel(" << staticAssert->cond;
for (size_t i = 0; i < staticAssert->message->size(); ++i) {
out << ", " << staticAssert->message->exprs[i];
}
out << ")";
break;
}
case MODULE_DECLARATION : {
const ModuleDeclaration *y = (const ModuleDeclaration *)x;
out << "ModuleDeclaration(" << y->name << ", " << y->attributes << ")";
break;
}
case MODULE : {
const Module *y = (const Module *)x;
out << "Module(" << bigVec(y->imports) << ", "
<< bigVec(y->topLevelItems) << ")";
break;
}
case PRIM_OP : {
const PrimOp *y = (const PrimOp *)x;
out << "PrimOp(" << primOpName(const_cast<PrimOp *>(y)) << ")";
break;
}
case TYPE : {
const Type *y = (const Type *)x;
typePrint(out, const_cast<Type *>(y));
break;
}
case PATTERN : {
const Pattern *y = (const Pattern *)x;
patternPrint(out, const_cast<Pattern *>(y));
break;
}
case MULTI_PATTERN : {
const MultiPattern *y = (const MultiPattern *)x;
patternPrint(out, const_cast<MultiPattern *>(y));
break;
}
case VALUE_HOLDER : {
const ValueHolder *y = (const ValueHolder *)x;
EValuePtr ev = new EValue(y->type, y->buf);
out << "ValueHolder(";
printTypeAndValue(out, ev);
out << ")";
break;
}
case MULTI_STATIC : {
const MultiStatic *y = (const MultiStatic *)x;
out << "MultiStatic(" << y->values << ")";
break;
}
case PVALUE : {
const PValue *y = (const PValue *)x;
out << "PValue(" << y->data << ")";
break;
}
case MULTI_PVALUE : {
const MultiPValue *y = (const MultiPValue *)x;
out << "MultiPValue(" << llvm::makeArrayRef(y->values) << ")";
break;
}
case EVALUE : {
const EValue *y = (const EValue *)x;
out << "EValue(" << y->type << ")";
break;
}
case MULTI_EVALUE : {
const MultiEValue *y = (const MultiEValue *)x;
out << "MultiEValue(" << y->values << ")";
break;
}
case CVALUE : {
const CValue *y = (const CValue *)x;
out << "CValue(" << y->type << ")";
break;
}
case MULTI_CVALUE : {
const MultiCValue *y = (const MultiCValue *)x;
out << "MultiCValue(" << y->values << ")";
break;
}
case DOCUMENTATION : {
const Documentation *d = (const Documentation *)x;
out << "Documentation(" << d->text << ")";
break;
}
default :
out << "UnknownObj(" << x->objKind << ")";
break;
}
}
void ASTPrint( int lev, ASTNode node )
{
if (! node)
{
indent( lev ); ec_stderr_printf( "NULL" );
return;
}
/* Simplify our lives ... */
if (currentScope)
{
if (currentScope->type == PackageScope)
{
currentPackage = currentScope->target;
currentBytecode = EC_PACKAGECODE(currentScope->target);
} else
{
currentBytecode = currentScope->target;
}
currentLiteral = EC_COMPILEDLFRAME(currentBytecode);
}
switch ( node->type )
{
case nullType:
indent( lev ); ec_stderr_printf( "<nullType>" );
break;
case symbolType:
printSymbol( lev, node );
break;
case qualifiedSymbolType:
printQualifiedSymbol( lev, node );
break;
case constExprType:
printConstant( lev, node );
break;
case variableExprType:
printVariable( lev, node );
break;
case arrayConstructionExprType:
printArrayCons( lev, node );
break;
case hashConstructionExprType:
printHashCons( lev, node );
break;
case unaryExprType:
printUnary( lev, node );
break;
case binaryExprType:
printBinary( lev, node );
break;
case conditionalExprType:
printConditional( lev, node );
break;
case orExprType:
printOr( lev, node );
break;
case andExprType:
printAnd( lev, node );
break;
case assignExprType:
printAssign( lev, node );
break;
case simAssignExprType:
printSimAssign( lev, node );
break;
case arrayRefExprType:
printArrayRef( lev, node );
break;
case declNodeType:
printDecl( lev, node );
break;
case declAtomNodeType:
printDeclAtom( lev, node );
break;
case statementType:
printStatement( lev, node );
break;
case labeledStmtType:
printLabeledStmt( lev, node );
break;
case exprStmtType:
printExprStmt( lev, node );
break;
case ifStmtType:
printIf( lev, node );
break;
case whileStmtType:
printWhile( lev, node );
break;
case doStmtType:
printDo( lev, node );
break;
case forStmtType:
printFor( lev, node );
break;
case forInStmtType:
printForIn( lev, node );
break;
case breakStmtType:
printBreak( lev, node );
break;
case continueStmtType:
printContinue( lev, node );
break;
case gotoStmtType:
printGoto( lev, node );
break;
case tryStmtType:
printTry( lev, node );
break;
case catchStmtType:
printCatch( lev, node );
break;
case throwStmtType:
printThrow( lev, node );
break;
case importStmtType:
printImport( lev, node );
break;
case paramNodeType:
printParam( lev, node );
break;
case paramListType:
printParamList( lev, node );
break;
case callNodeType:
printCall( lev, node );
break;
case methodCallNodeType:
printMethodCall( lev, node );
break;
case stmtListType:
printStmtList( lev, node );
break;
case funcNodeType:
printFunction( lev, node );
break;
case returnNodeType:
printReturn( lev, node );
break;
case classNodeType:
printClass( lev, node );
break;
case methodNodeType:
printMethod( lev, node );
break;
case packageNodeType:
printPackage( lev, node );
break;
}
}
