zdoom/gzdoom
0
0
Fork 0
mirror of https://github.com/ZDoom/gzdoom.git synced 2024-12-11 13:11:48 +00:00
Code Issues Projects Releases Packages Wiki Activity
gzdoom/src/zscript/zcc_compile.h

57 lines
1.9 KiB
C
Raw Normal View History

Add evaluation of constant unary and binary expressions - Added ZCCCompiler class as a place to generate IR and symbols from an AST. Right now, all it does is simplify constant expressions into constant values. - Do type promotion on the AST where appropriate. - Added true and false tokens to the parser driver.
2013-10-24 04:06:32 +00:00
#ifndef ZCC_COMPILE_H
#define ZCC_COMPILE_H
class ZCCCompiler
{
public:
ZCCCompiler(ZCC_AST &tree, DObject *outer, PSymbolTable &symbols);
int Compile();
private:
Store known but uncompiled nodes in the symbol table - Don't bother keeping track of uncompiled nodes in a special table. Use the regular symbol table instead. This should in the future make compiling nodes referenced deeper than (and before) their definitions fairly straightforward. - Also, break up the compiler's Message() function into Warn() and Error() and get rid of zcc_errors.h. I can't really see having a set of error numbers being useful.
2016-03-13 03:22:29 +00:00
void CompileConstants(const TArray<ZCC_ConstantDef *> &defs);
Add evaluation of constant unary and binary expressions - Added ZCCCompiler class as a place to generate IR and symbols from an AST. Right now, all it does is simplify constant expressions into constant values. - Do type promotion on the AST where appropriate. - Added true and false tokens to the parser driver.
2013-10-24 04:06:32 +00:00
PSymbolConst *CompileConstant(ZCC_ConstantDef *def);
TArray<ZCC_ConstantDef *> Constants;
TArray<ZCC_Struct *> Structs;
TArray<ZCC_Class *> Classes;
Allow using constants in other constants before their definitions. - Something like this is now valid: const foo = bar + 10; const bar = 1000;
2013-10-26 03:01:18 +00:00
Store known but uncompiled nodes in the symbol table - Don't bother keeping track of uncompiled nodes in a special table. Use the regular symbol table instead. This should in the future make compiling nodes referenced deeper than (and before) their definitions fairly straightforward. - Also, break up the compiler's Message() function into Warn() and Error() and get rid of zcc_errors.h. I can't really see having a set of error numbers being useful.
2016-03-13 03:22:29 +00:00
bool AddNamedNode(ZCC_NamedNode *node);
Add evaluation of constant unary and binary expressions - Added ZCCCompiler class as a place to generate IR and symbols from an AST. Right now, all it does is simplify constant expressions into constant values. - Do type promotion on the AST where appropriate. - Added true and false tokens to the parser driver.
2013-10-24 04:06:32 +00:00
ZCC_Expression *Simplify(ZCC_Expression *root);
ZCC_Expression *SimplifyUnary(ZCC_ExprUnary *unary);
ZCC_Expression *SimplifyBinary(ZCC_ExprBinary *binary);
Allow access to the numeric properties. - Identifiers can now evaluate to type references. - The dot operator can now find symbols in type references.
2013-10-30 02:55:32 +00:00
ZCC_Expression *SimplifyMemberAccess(ZCC_ExprMemberAccess *dotop);
Interpret function calls to type refs as type casts
2013-10-31 01:53:02 +00:00
ZCC_Expression *SimplifyFunctionCall(ZCC_ExprFuncCall *callop);
Add evaluation of constant unary and binary expressions - Added ZCCCompiler class as a place to generate IR and symbols from an AST. Right now, all it does is simplify constant expressions into constant values. - Do type promotion on the AST where appropriate. - Added true and false tokens to the parser driver.
2013-10-24 04:06:32 +00:00
ZCC_OpProto *PromoteUnary(EZCCExprType op, ZCC_Expression *&expr);
ZCC_OpProto *PromoteBinary(EZCCExprType op, ZCC_Expression *&left, ZCC_Expression *&right);
void PromoteToInt(ZCC_Expression *&expr);
void PromoteToUInt(ZCC_Expression *&expr);
void PromoteToDouble(ZCC_Expression *&expr);
void PromoteToString(ZCC_Expression *&expr);
ZCC_Expression *ApplyConversion(ZCC_Expression *expr, const PType::Conversion **route, int routelen);
ZCC_Expression *AddCastNode(PType *type, ZCC_Expression *expr);
ZCC_Expression *IdentifyIdentifier(ZCC_ExprID *idnode);
Store known but uncompiled nodes in the symbol table - Don't bother keeping track of uncompiled nodes in a special table. Use the regular symbol table instead. This should in the future make compiling nodes referenced deeper than (and before) their definitions fairly straightforward. - Also, break up the compiler's Message() function into Warn() and Error() and get rid of zcc_errors.h. I can't really see having a set of error numbers being useful.
2016-03-13 03:22:29 +00:00
ZCC_Expression *NodeFromSymbol(PSymbol *sym, ZCC_Expression *source, PSymbolTable *table);
Allow access to the numeric properties. - Identifiers can now evaluate to type references. - The dot operator can now find symbols in type references.
2013-10-30 02:55:32 +00:00
ZCC_ExprConstant *NodeFromSymbolConst(PSymbolConst *sym, ZCC_Expression *idnode);
ZCC_ExprTypeRef *NodeFromSymbolType(PSymbolType *sym, ZCC_Expression *idnode);
Store known but uncompiled nodes in the symbol table - Don't bother keeping track of uncompiled nodes in a special table. Use the regular symbol table instead. This should in the future make compiling nodes referenced deeper than (and before) their definitions fairly straightforward. - Also, break up the compiler's Message() function into Warn() and Error() and get rid of zcc_errors.h. I can't really see having a set of error numbers being useful.
2016-03-13 03:22:29 +00:00
PSymbol *ZCCCompiler::CompileNode(ZCC_NamedNode *node);
Add evaluation of constant unary and binary expressions - Added ZCCCompiler class as a place to generate IR and symbols from an AST. Right now, all it does is simplify constant expressions into constant values. - Do type promotion on the AST where appropriate. - Added true and false tokens to the parser driver.
2013-10-24 04:06:32 +00:00
Store known but uncompiled nodes in the symbol table - Don't bother keeping track of uncompiled nodes in a special table. Use the regular symbol table instead. This should in the future make compiling nodes referenced deeper than (and before) their definitions fairly straightforward. - Also, break up the compiler's Message() function into Warn() and Error() and get rid of zcc_errors.h. I can't really see having a set of error numbers being useful.
2016-03-13 03:22:29 +00:00
void Warn(ZCC_TreeNode *node, const char *msg, ...);
void Error(ZCC_TreeNode *node, const char *msg, ...);
void MessageV(ZCC_TreeNode *node, const char *txtcolor, const char *msg, va_list argptr);
Add evaluation of constant unary and binary expressions - Added ZCCCompiler class as a place to generate IR and symbols from an AST. Right now, all it does is simplify constant expressions into constant values. - Do type promotion on the AST where appropriate. - Added true and false tokens to the parser driver.
2013-10-24 04:06:32 +00:00
DObject *Outer;
Store known but uncompiled nodes in the symbol table - Don't bother keeping track of uncompiled nodes in a special table. Use the regular symbol table instead. This should in the future make compiling nodes referenced deeper than (and before) their definitions fairly straightforward. - Also, break up the compiler's Message() function into Warn() and Error() and get rid of zcc_errors.h. I can't really see having a set of error numbers being useful.
2016-03-13 03:22:29 +00:00
PSymbolTable *Symbols;
Add evaluation of constant unary and binary expressions - Added ZCCCompiler class as a place to generate IR and symbols from an AST. Right now, all it does is simplify constant expressions into constant values. - Do type promotion on the AST where appropriate. - Added true and false tokens to the parser driver.
2013-10-24 04:06:32 +00:00
ZCC_AST &AST;
int ErrorCount;
int WarnCount;
};
void ZCC_InitConversions();
#endif
Reference in a new issue Copy permalink