zdoom/gzdoom-gles
0
0
Fork 0
mirror of https://github.com/ZDoom/gzdoom-gles.git synced 2024-11-11 23:32:02 +00:00
Code Issues Projects Releases Packages Wiki Activity

- Added functions for converting the AST to text. This is not hooked in anywhere yet, since

Browse source 
the parser currently just throws the AST away.

SVN r2969 (scripting)
This commit is contained in:
Randy Heit 2010-10-31 04:36:00 +00:00
parent 7e60ac1fb8
commit bee4c3e760
3 changed files with 623 additions and 1 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

610
src/zscript/ast.cpp Normal file
View file

@ -0,0 +1,610 @@
#include "dobject.h"
#include "sc_man.h"
#include "memarena.h"
#include "zcc_parser.h"
#include "zcc-parse.h"
extern void (* const TreeNodePrinter[NUM_AST_NODE_TYPES])(FString &, ZCC_TreeNode *);
static const char *BuiltInTypeNames[] =
{
"sint8", "uint8",
"sint16", "uint16",
"sint32", "uint32",
"intauto",
"bool",
"float32", "float64", "floatauto",
"string",
"vector2",
"vector3",
"vector4",
"name",
"usertype"
};
static void PrintNode(FString &out, ZCC_TreeNode *node)
{
assert(TreeNodePrinter[NUM_AST_NODE_TYPES-1] != NULL);
if (node->NodeType >= 0 && node->NodeType < NUM_AST_NODE_TYPES)
{
TreeNodePrinter[node->NodeType](out, node);
}
else
{
out.AppendFormat("(unknown-node-type-%d)", node->NodeType);
}
}
static void PrintNodes(FString &out, ZCC_TreeNode *node, char addchar=' ')
{
ZCC_TreeNode *p;
if (node == NULL)
{
out << "nil";
}
else
{
out << '(';
p = node;
do
{
PrintNode(out, p);
p = p->SiblingNext;
if (p != node)
{
out << ' ';
}
} while (p != node);
out << ')';
}
if (addchar != '\0')
{
out << addchar;
}
}
static void PrintBuiltInType(FString &out, EZCCBuiltinType type, bool addspace)
{
assert(ZCC_NUM_BUILT_IN_TYPES == countof(BuiltInTypeNames));
if (unsigned(type) >= unsigned(ZCC_NUM_BUILT_IN_TYPES))
{
out.AppendFormat("bad-type-%u", type);
}
else
{
out << BuiltInTypeNames[type];
}
if (addspace)
{
out << ' ';
}
}
static void PrintIdentifier(FString &out, ZCC_TreeNode *node)
{
ZCC_Identifier *inode = (ZCC_Identifier *)node;
out.AppendFormat("(identifier '%s')", FName(inode->Id).GetChars());
}
static void PrintStringConst(FString &out, FString str)
{
out << '"';
for (size_t i = 0; i < str.Len(); ++i)
{
if (str[i] == '"')
{
out << "\"";
}
else if (str[i] == '\\')
{
out << "\\\\";
}
else if (str[i] >= 32)
{
out << str[i];
}
else
{
out.AppendFormat("\\x%02X", str[i]);
}
}
}
static void PrintClass(FString &out, ZCC_TreeNode *node)
{
ZCC_Class *cnode = (ZCC_Class *)node;
out << "(class ";
PrintNodes(out, cnode->ClassName);
PrintNodes(out, cnode->ParentName);
PrintNodes(out, cnode->Replaces);
out.AppendFormat("%08x ", cnode->Flags);
PrintNodes(out, cnode->Body, ')');
}
static void PrintStruct(FString &out, ZCC_TreeNode *node)
{
ZCC_Struct *snode = (ZCC_Struct *)node;
out.AppendFormat("(struct '%s' ", FName(snode->StructName).GetChars());
PrintNodes(out, snode->Body, ')');
}
static void PrintEnum(FString &out, ZCC_TreeNode *node)
{
ZCC_Enum *enode = (ZCC_Enum *)node;
out.AppendFormat("(enum '%s' ", FName(enode->EnumName).GetChars());
PrintBuiltInType(out, enode->EnumType, true);
PrintNodes(out, enode->Elements, ')');
}
static void PrintEnumNode(FString &out, ZCC_TreeNode *node)
{
ZCC_EnumNode *enode = (ZCC_EnumNode *)node;
out.AppendFormat("(enum-node '%s' ", FName(enode->ElemName));
PrintNodes(out, enode->ElemValue, ')');
}
static void PrintStates(FString &out, ZCC_TreeNode *node)
{
ZCC_States *snode = (ZCC_States *)node;
out << "(states ";
PrintNodes(out, snode->Body, ')');
}
static void PrintStatePart(FString &out, ZCC_TreeNode *node)
{
out << "(state-part)";
}
static void PrintStateLabel(FString &out, ZCC_TreeNode *node)
{
ZCC_StateLabel *snode = (ZCC_StateLabel *)node;
out.AppendFormat("(state-label '%s')", FName(snode->Label).GetChars());
}
static void PrintStateStop(FString &out, ZCC_TreeNode *node)
{
out << "(state-stop)";
}
static void PrintStateWait(FString &out, ZCC_TreeNode *node)
{
out << "(state-wait)";
}
static void PrintStateFail(FString &out, ZCC_TreeNode *node)
{
out << "(state-fail)";
}
static void PrintStateLoop(FString &out, ZCC_TreeNode *node)
{
out << "(state-loop)";
}
static void PrintStateGoto(FString &out, ZCC_TreeNode *node)
{
ZCC_StateGoto *snode = (ZCC_StateGoto *)node;
out << "(state-goto ";
PrintNodes(out, snode->Label);
PrintNodes(out, snode->Offset, ')');
}
static void PrintStateLine(FString &out, ZCC_TreeNode *node)
{
ZCC_StateLine *snode = (ZCC_StateLine *)node;
out.AppendFormat("(state-line %c%c%c%c %s %s ",
snode->Sprite[0], snode->Sprite[1], snode->Sprite[2], snode->Sprite[3],
snode->bBright ? "bright " : "",
snode->Frames->GetChars());
PrintNodes(out, snode->Offset);
PrintNodes(out, snode->Action, ')');
}
static void PrintVarName(FString &out, ZCC_TreeNode *node)
{
ZCC_VarName *vnode = (ZCC_VarName *)node;
out.AppendFormat("(var-name '%s')", FName(vnode->Name).GetChars());
}
static void PrintType(FString &out, ZCC_TreeNode *node)
{
ZCC_Type *tnode = (ZCC_Type *)node;
out << "(bad-type ";
PrintNodes(out, tnode->ArraySize, ')');
}
static void PrintBasicType(FString &out, ZCC_TreeNode *node)
{
ZCC_BasicType *tnode = (ZCC_BasicType *)node;
out << "(basic-type ";
PrintNodes(out, tnode->ArraySize);
PrintBuiltInType(out, tnode->Type, true);
PrintNodes(out, tnode->UserType, ')');
}
static void PrintMapType(FString &out, ZCC_TreeNode *node)
{
ZCC_MapType *tnode = (ZCC_MapType *)node;
out << "(map-type ";
PrintNodes(out, tnode->ArraySize);
PrintNodes(out, tnode->KeyType);
PrintNodes(out, tnode->ValueType, ')');
}
static void PrintDynArrayType(FString &out, ZCC_TreeNode *node)
{
ZCC_DynArrayType *tnode = (ZCC_DynArrayType *)node;
out << "(dyn-array-type ";
PrintNodes(out, tnode->ArraySize);
PrintNodes(out, tnode->ElementType, ')');
}
static void PrintClassType(FString &out, ZCC_TreeNode *node)
{
ZCC_ClassType *tnode = (ZCC_ClassType *)node;
out << "(class-type ";
PrintNodes(out, tnode->ArraySize);
PrintNodes(out, tnode->Restriction, ')');
}
static void PrintExprType(FString &out, EZCCExprType type)
{
static const char *const types[] =
{
"nil ",
"id ",
"super ",
"self ",
"string-const ",
"int-const ",
"uint-const ",
"float-const ",
"func-call ",
"array-access ",
"member-access ",
"post-inc ",
"post-dec ",
"pre-inc ",
"pre-dec ",
"negate ",
"anti-negate ",
"bit-not ",
"bool-not ",
"size-of ",
"align-of ",
"add ",
"sub ",
"mul ",
"div ",
"mod ",
"pow ",
"cross-product ",
"dot-product ",
"left-shift ",
"right-shift ",
"concat ",
"lt ",
"gt ",
"lteq ",
"gteq ",
"ltgteq ",
"is ",
"eqeq ",
"neq ",
"apreq ",
"bit-and ",
"bit-or ",
"bit-xor ",
"bool-and ",
"bool-or ",
"scope ",
"trinary ",
};
assert(countof(types) == PEX_COUNT_OF);
if (unsigned(type) < countof(types))
{
out << types[type];
}
else
{
out.AppendFormat("bad-pex-%u ", type);
}
}
static void PrintExpression(FString &out, ZCC_TreeNode *node)
{
ZCC_Expression *enode = (ZCC_Expression *)node;
out << "(expr-";
PrintExprType(out, enode->Operation);
out << ')';
}
static void PrintExprID(FString &out, ZCC_TreeNode *node)
{
ZCC_ExprID *enode = (ZCC_ExprID *)node;
assert(enode->Operation == PEX_ID);
out.AppendFormat("(expr-id '%s')", FName(enode->Identifier).GetChars());
}
static void PrintExprString(FString &out, ZCC_TreeNode *node)
{
ZCC_ExprString *enode = (ZCC_ExprString *)node;
assert(enode->Operation == PEX_StringConst);
out.AppendFormat("(expr-string-const ");
PrintStringConst(out, *enode->Value);
out << ')';
}
static void PrintExprInt(FString &out, ZCC_TreeNode *node)
{
ZCC_ExprInt *enode = (ZCC_ExprInt *)node;
assert(enode->Operation == PEX_IntConst || enode->Operation == PEX_UIntConst);
out << "(expr-";
PrintExprType(out, enode->Operation);
out.AppendFormat("%d)", enode->Value);
}
static void PrintExprFloat(FString &out, ZCC_TreeNode *node)
{
ZCC_ExprFloat *enode = (ZCC_ExprFloat *)node;
assert(enode->Operation == PEX_FloatConst);
out.AppendFormat("(expr-float-const %g)", enode->Value);
}
static void PrintExprFuncCall(FString &out, ZCC_TreeNode *node)
{
ZCC_ExprFuncCall *enode = (ZCC_ExprFuncCall *)node;
assert(enode->Operation == PEX_FuncCall);
out << "(expr-func-call ";
PrintNodes(out, enode->Function);
PrintNodes(out, enode->Parameters, ')');
}
static void PrintExprMemberAccess(FString &out, ZCC_TreeNode *node)
{
ZCC_ExprMemberAccess *enode = (ZCC_ExprMemberAccess *)node;
assert(enode->Operation == PEX_MemberAccess);
out << "(expr-member-access ";
PrintNodes(out, enode->Left);
out.AppendFormat("'%s')", FName(enode->Right).GetChars());
}
static void PrintExprUnary(FString &out, ZCC_TreeNode *node)
{
ZCC_ExprUnary *enode = (ZCC_ExprUnary *)node;
out << "(expr-";
PrintExprType(out, enode->Operation);
PrintNodes(out, enode->Operand, ')');
}
static void PrintExprBinary(FString &out, ZCC_TreeNode *node)
{
ZCC_ExprBinary *enode = (ZCC_ExprBinary *)node;
out << "(expr-";
PrintExprType(out, enode->Operation);
PrintNodes(out, enode->Left);
PrintNodes(out, enode->Right, ')');
}
static void PrintExprTrinary(FString &out, ZCC_TreeNode *node)
{
ZCC_ExprTrinary *enode = (ZCC_ExprTrinary *)node;
out << "(expr-";
PrintExprType(out, enode->Operation);
PrintNodes(out, enode->Test);
PrintNodes(out, enode->Left);
PrintNodes(out, enode->Right, ')');
}
static void PrintFuncParam(FString &out, ZCC_TreeNode *node)
{
ZCC_FuncParm *pnode = (ZCC_FuncParm *)node;
out.AppendFormat("(func-parm %s ", FName(pnode->Label).GetChars());;
PrintNodes(out, pnode->Value, ')');
}
static void PrintStatement(FString &out, ZCC_TreeNode *node)
{
out << "(statement)";
}
static void PrintCompoundStmt(FString &out, ZCC_TreeNode *node)
{
ZCC_CompoundStmt *snode = (ZCC_CompoundStmt *)node;
out << "(compound-stmt ";
PrintNodes(out, snode->Content, ')');
}
static void PrintContinueStmt(FString &out, ZCC_TreeNode *node)
{
out << "(continue-stmt)";
}
static void PrintBreakStmt(FString &out, ZCC_TreeNode *node)
{
out << "(break-stmt)";
}
static void PrintReturnStmt(FString &out, ZCC_TreeNode *node)
{
ZCC_ReturnStmt *snode = (ZCC_ReturnStmt *)node;
out << "(return-stmt ";
PrintNodes(out, snode->Values, ')');
}
static void PrintExpressionStmt(FString &out, ZCC_TreeNode *node)
{
ZCC_ExpressionStmt *snode = (ZCC_ExpressionStmt *)node;
out << "(expression-stmt ";
PrintNodes(out, snode->Expression, ')');
}
static void PrintIterationStmt(FString &out, ZCC_TreeNode *node)
{
ZCC_IterationStmt *snode = (ZCC_IterationStmt *)node;
out << "(iteration-stmt ";
out << (snode->CheckAt == ZCC_IterationStmt::Start) ? "start " : "end ";
PrintNodes(out, snode->LoopCondition);
PrintNodes(out, snode->LoopBumper);
PrintNodes(out, snode->LoopStatement, true);
}
static void PrintIfStmt(FString &out, ZCC_TreeNode *node)
{
ZCC_IfStmt *snode = (ZCC_IfStmt *)node;
out << "(if-stmt ";
PrintNodes(out, snode->Condition);
PrintNodes(out, snode->TruePath);
PrintNodes(out, snode->FalsePath, ')');
}
static void PrintSwitchStmt(FString &out, ZCC_TreeNode *node)
{
ZCC_SwitchStmt *snode = (ZCC_SwitchStmt *)node;
out << "(switch-stmt ";
PrintNodes(out, snode->Condition);
PrintNodes(out, snode->Content, ')');
}
static void PrintCaseStmt(FString &out, ZCC_TreeNode *node)
{
ZCC_CaseStmt *snode = (ZCC_CaseStmt *)node;
out << "(case-stmt ";
PrintNodes(out, snode->Condition, ')');
}
static void PrintAssignStmt(FString &out, ZCC_TreeNode *node)
{
ZCC_AssignStmt *snode = (ZCC_AssignStmt *)node;
out << "(assign-stmt ";
switch (snode->AssignOp)
{
case ZCC_EQ: out << "= "; break;
case ZCC_MULEQ: out << "*= "; break;
case ZCC_DIVEQ: out << "/= "; break;
case ZCC_MODEQ: out << "%= "; break;
case ZCC_ADDEQ: out << "+= "; break;
case ZCC_SUBEQ: out << "-= "; break;
case ZCC_LSHEQ: out << "<<= "; break;
case ZCC_RSHEQ: out << ">>= "; break;
case ZCC_ANDEQ: out << "&= "; break;
case ZCC_OREQ: out << "|= "; break;
case ZCC_XOREQ: out << "^= "; break;
default:
out.AppendFormat("assign-op-%d ", snode->AssignOp);
}
PrintNodes(out, snode->Dests);
PrintNodes(out, snode->Sources, ')');
}
static void PrintLocalVarStmt(FString &out, ZCC_TreeNode *node)
{
ZCC_LocalVarStmt *snode = (ZCC_LocalVarStmt *)node;
out << "(local-var-stmt ";
PrintNodes(out, snode->Type);
PrintNodes(out, snode->Vars);
PrintNodes(out, snode->Inits, ')');
}
static void PrintFuncParamDecl(FString &out, ZCC_TreeNode *node)
{
ZCC_FuncParamDecl *dnode = (ZCC_FuncParamDecl *)node;
out << "(func-param-decl ";
PrintNodes(out, dnode->Type);
out.AppendFormat("%s %x)", FName(dnode->Name).GetChars(), dnode->Flags);
}
static void PrintConstantDef(FString &out, ZCC_TreeNode *node)
{
ZCC_ConstantDef *dnode = (ZCC_ConstantDef *)node;
out.AppendFormat("(constant-def %s ", FName(dnode->Name).GetChars());
PrintNodes(out, dnode->Value, ')');
}
static void PrintDeclarator(FString &out, ZCC_TreeNode *node)
{
ZCC_Declarator *dnode = (ZCC_Declarator *)node;
out << "(declarator ";
PrintNodes(out, dnode->Type);
out.AppendFormat("%x)", dnode->Flags);
}
static void PrintVarDeclarator(FString &out, ZCC_TreeNode *node)
{
ZCC_VarDeclarator *dnode = (ZCC_VarDeclarator *)node;
out << "(var-declarator ";
PrintNodes(out, dnode->Type);
out.AppendFormat("%x ", dnode->Flags);
PrintNodes(out, dnode->Names, ')');
}
static void PrintFuncDeclarator(FString &out, ZCC_TreeNode *node)
{
ZCC_FuncDeclarator *dnode = (ZCC_FuncDeclarator *)node;
out << "(func-declarator ";
PrintNodes(out, dnode->Type);
out.AppendFormat("%x %s ", dnode->Flags, FName(dnode->Name).GetChars());
PrintNodes(out, dnode->Params, ')');
}
void (* const TreeNodePrinter[NUM_AST_NODE_TYPES])(FString &, ZCC_TreeNode *) =
{
PrintIdentifier,
PrintClass,
PrintStruct,
PrintEnum,
PrintEnumNode,
PrintStates,
PrintStatePart,
PrintStateLabel,
PrintStateStop,
PrintStateWait,
PrintStateFail,
PrintStateLoop,
PrintStateGoto,
PrintStateLine,
PrintVarName,
PrintType,
PrintBasicType,
PrintMapType,
PrintDynArrayType,
PrintClassType,
PrintExpression,
PrintExprID,
PrintExprString,
PrintExprInt,
PrintExprFloat,
PrintExprFuncCall,
PrintExprMemberAccess,
PrintExprUnary,
PrintExprBinary,
PrintExprTrinary,
PrintFuncParam,
PrintStatement,
PrintCompoundStmt,
PrintContinueStmt,
PrintBreakStmt,
PrintReturnStmt,
PrintExpressionStmt,
PrintIterationStmt,
PrintIfStmt,
PrintSwitchStmt,
PrintCaseStmt,
PrintAssignStmt,
PrintLocalVarStmt,
PrintFuncParamDecl,
PrintConstantDef,
PrintDeclarator,
PrintVarDeclarator,
PrintFuncDeclarator
};
FString ZCC_PrintAST(ZCC_TreeNode *root)
{
FString out;
PrintNodes(out, root, '\0');
return out;
}

10
src/zscript/zcc_parser.h
View file

@ -95,6 +95,8 @@ enum EZCCTreeNodeType
AST_Declarator, AST_Declarator,
AST_VarDeclarator, AST_VarDeclarator,
AST_FuncDeclarator, AST_FuncDeclarator,
NUM_AST_NODE_TYPES
}; };
enum EZCCBuiltinType enum EZCCBuiltinType
@ -117,6 +119,8 @@ enum EZCCBuiltinType
ZCC_Vector4, ZCC_Vector4,
ZCC_Name, ZCC_Name,
ZCC_UserType, ZCC_UserType,
ZCC_NUM_BUILT_IN_TYPES
}; };
enum EZCCExprType enum EZCCExprType
@ -176,7 +180,9 @@ enum EZCCExprType
PEX_Scope, PEX_Scope,
PEX_Trinary PEX_Trinary,
PEX_COUNT_OF
}; };
struct ZCC_TreeNode struct ZCC_TreeNode
@ -487,3 +493,5 @@ struct ZCC_FuncDeclarator : ZCC_Declarator
ZCC_FuncParamDecl *Params; ZCC_FuncParamDecl *Params;
ENamedName Name; ENamedName Name;
}; };
FString ZCC_PrintAST(ZCC_TreeNode *root);

4
zdoom.vcproj
View file

@ -6469,6 +6469,10 @@
<Filter <Filter
Name="ZScript" Name="ZScript"
> >
<File
RelativePath=".\src\zscript\ast.cpp"
>
</File>
<File <File
RelativePath=".\src\zscript\vm.h" RelativePath=".\src\zscript\vm.h"
> >