/****************************************************************************** ** This file is part of GAP, a system for computational discrete algebra. ** ** Copyright of GAP belongs to its developers, whose names are too numerous ** to list here. Please refer to the COPYRIGHT file for details. ** ** SPDX-License-Identifier: GPL-2.0-or-later #include "syntaxtree.h" #include "bool.h" #include "calls.h" #include "code.h" #include "common.h" #include "error.h" #include "exprs.h" #include "gvars.h" #include "integer.h" #include "lists.h" #include "modules.h" #include "opers.h" #include "plist.h" #include "precord.h" #include "profile.h" #include "records.h" #include "stats.h" #include "stringobj.h" #include "vars.h" #include <ctype.h>#include <stdarg.h>enum { MAX_ARITY = 4 };typedef Obj (*CompileFuncT)(Obj node, Expr expr);typedef Obj (*CompileArgT)(Expr expr);typedef Expr (*CodeFuncT)(CodeState * cs, Obj node);typedef Expr (*CodeArgT)(CodeState * cs, Obj node);typedef struct {const Char * argname;Int isStat;typedef struct {const Char * name;// We put compilers for statements and expressions into the same static array, // assuming that the set of their respective ids are disjoint. static const CompilerT Compilers[];#define COMPILER_ARITY(...) (sizeof ((ArgT[]){ __VA_ARGS__ }) / sizeof (ArgT))#define COMPILER_GENERIC(tnum, compiler, coder, ...) \#tnum , COMPILER_ARITY(__VA_ARGS__), \#define COMPILER(tnum, compiler, coder) \#define COMPILER_(tnum, ...) \#define ARG(name, func, coder, isStat) \// ARG_EXPR indicates an "expression argument", i.e., that the corresponding // slot of the statement or expression type it belongs to is meant to // reference an expression. This information is used for validation when // coding an AST back into a T_BODY object. The expression is stored in resp. // read from the record entry <name>. #define ARG_EXPR(name, func, coder) ARG(name, func, coder, 0)// ARG_STAT is like ARG_EXPR, except that it indicates that the corresponding // slot should contain a statement instead of an expression. There is no // ARG_STAT, because it is never used. // ARG_EXPR_ can be used instead of ARG_EXPR if the default compiler // and coder should be used to compile the corresponding expression or code // the corresponding subnode. #define ARG_EXPR_(name) \#define ARG_STAT_(name) \// ARGS_EXPR can be used instead of ARG_EXPR as the last argument to the // COMPILER_ macro, and indicates that a variable number of arguments follow; // all are supposed to be expressions; and all of them are to be stored into a // plist which is stored in resp. read from the record entry <name>. #define ARGS_EXPR(name) ARG(name, 0, 0, 0)#define ARGS_STAT(name) ARG(name, 0, 0, 1)// plain list mapping statement tnums to strings // like "EXPR_INT" static Obj typeStrings;// plain record mapping strings like "EXPR_INT" to the // corresponding statement tnum static Obj typeRec;static Obj ElmRecST(UInt1 tnum, Obj node, const char * name)"ElmRecST" , node);if (!IsbPRec(node, rnam)) {const char * typename = Compilers[tnum].name;"while coding %s: node field <%s> must be present" ,Int ) typename , (Int )name);return ElmPRec(node, rnam);static Obj SyntaxTreeFunc(Obj result, Obj func);static UInt1 FIND_TNUM_FROM_STRING(Obj typestr)if (IsbPRec(typeRec, rnam)) {return (UInt1)UInt_ObjInt(ElmPRec(typeRec, rnam));"Unrecognized syntax tree node type %g" , (Int )typestr, 0);static UInt1 GetTypeTNum(Obj node)"GetTypeTNum" , node);"type" );if (!IsbPRec(node, type)) {"while coding: field is not present" , 0, 0);return FIND_TNUM_FROM_STRING(ElmPRec(node, type));static inline Obj NewSyntaxTreeNode(UInt1 tnum)"type" ), typestr);return result;static Obj SyntaxTreeCompiler(Expr expr)// TODO: GAP_ASSERT return comp.compile(result, expr);static Obj SyntaxTreeRNam(Expr expr)return NAME_RNAM(expr);static Expr SyntaxTreeCodeRNamObj(CodeState * cs, Obj node)return RNamObj(node);static Obj SyntaxTreeDefaultCompiler(Obj result, Expr expr)int i;BOOL didvariadic = 0;Int offset = 0;// TODO: GAP_ASSERT tnum range for (i = 0; i < comp.arity; i++) {if (comp.args[i].argcomp) {else {// special case: one argument may have zero as decompiler, // which expresses that this slot is "variadic", and // is decompiled into a single list // Avoid warning about used variable when not in debug mode void )didvariadic;// compile the variadic part into a single list const UInt nr = SIZE_EXPR(expr) / sizeof (expr);const UInt varlength = nr - (comp.arity - 1);for (; offset < varlength; offset++) {// handle 0 to properly deal with EXPR_LIST // offset gets set one bigger final time around loop sizeof (expr));return result;static Stat SyntaxTreeDefaultStatCoder(CodeState *, Obj);static Stat SyntaxTreeDefaultExprCoder(CodeState *, Obj);static Expr SyntaxTreeDefaultCoder(CodeState * cs, Obj node)"SyntaxTreeDefaultCoder" , node);if (comp.code != SyntaxTreeDefaultCoder) {return comp.code(cs, node);// compute how big the statement/expression we are generating needs to // be, i.e., how many Obj-sized "slots" we need; this is usually // comp.arity, but we need to take into account variadic argument lists Int varargloc = -1;for (UInt i = 0; i < comp.arity; ++i) {if (comp.args[i].argcomp == 0) {if (varargloc != -1) {// reserve space for the statement or expressions sizeof (Expr), 0);Int i;for (i = 0; i < arity; i++) {if (i == varargloc) {for (; offset < LEN_LIST(vararglist); offset++) {// Deal with empty entries in list expressions if (elem == 0) {else if (comp.args[i].isStat) {else {// offset gets set one bigger final time around loop else {return expr;// Checks if node codes a statement static Stat SyntaxTreeDefaultStatCoder(CodeState * cs, Obj node)"SyntaxTreeDefaultStatCoder" , node);Int tnum = GetTypeTNum(node);if (!(FIRST_STAT_TNUM <= tnum && tnum <= LAST_STAT_TNUM))"tried to code expression %s as statement" ,Int )Compilers[tnum].name, 0);return (Stat)SyntaxTreeDefaultCoder(cs, node);// Checks if node codes an expression static Expr SyntaxTreeDefaultExprCoder(CodeState * cs, Obj node)"SyntaxTreeDefaultExprCoder" , node);if (!(FIRST_EXPR_TNUM <= tnum && tnum <= LAST_EXPR_TNUM))"tried to code statement %s as expression" ,Int )Compilers[tnum].name, 0);return (Expr)SyntaxTreeDefaultCoder(cs, node);static Expr SyntaxTreeCodeGVar(CodeState * cs, Obj name)"SyntaxTreeCodeGVar" , name);return GVarName(CONST_CSTR_STRING(name));static Obj SyntaxTreeRefLVar(Obj result, Expr expr)"lvar" ), INTOBJ_INT(LVAR_REF_LVAR(expr)));return result;static Expr SyntaxTreeCodeRefLVar(CodeState * cs, Obj node)"SyntaxTreeCodeRefLVar" , node);"lvar" );"SyntaxTreeCodeRefLVar" , lvar);return REF_LVAR_LVAR(INT_INTOBJ(lvar));static Expr SyntaxTreeCodeObjInt(CodeState * cs, Obj node)return UInt_ObjInt(node);static Obj SyntaxTreeEvalCompiler(Obj result, Expr expr)"value" ), o);return result;static Obj SyntaxTreeFuncExpr(Obj result, Expr expr)return result;static Obj SyntaxTreeRangeExpr(Obj result, Expr expr)if (SIZE_EXPR(expr) == 2 * sizeof (Expr)) {"first" ), first);"last" ), last);else {"first" ), first);"second" ), second);"last" ), last);return result;static Expr SyntaxTreeCodeRangeExpr(CodeState * cs, Obj node)"SyntaxTreeCodeRangeExpr" , node);"second" ));sizeof (Expr), 0);"first" )));"last" )));if (hassecond) {"second" )));return result;static Obj SyntaxTreeRecExpr(Obj result, Expr expr)Int i, len;sizeof (Expr));for (i = 1; i <= len; i++) {if (IS_INTEXPR(tmp)) {else {"key" ), key);"value" ), val);"keyvalue" ), list);return result;static Expr SyntaxTreeCodeRecExpr(CodeState * cs, Obj node)"SyntaxTreeCodeRecExpr" , node);"keyvalue" );sizeof (Expr), 0);for (int i = 0; i < len; i++) {"key" );"value" );if (IS_STRING(keynode)) {else {return record;static Obj SyntaxTreeFloatLazy(Obj result, Expr expr)"value" ), string);return result;static Obj SyntaxTreeFloatEager(Obj result, Expr expr)"value" ), value);"string" ), string);"mark" ), ObjsChar[chr]);return result;static Expr SyntaxTreeCodeFloatLazy(CodeState * cs, Obj node)"SyntaxTreeCodeFloatLazy" , node);"value" );return CodeLazyFloatExpr(cs, value, 0);static Expr SyntaxTreeCodeFloatEager(CodeState * cs, Obj node)"SyntaxTreeCodeFloatEager" , node);"value" );"string" );"mark" );sizeof (UInt), 0);return fl;static Obj SyntaxTreeIf(Obj result, Stat stat)Int i, nr;sizeof (Stat));"branches" ), branches);for (i = 0; i < nr; i++) {"condition" ), cond);"body" ), then);return result;static Obj SyntaxTreeCompilePragma(Obj result, Stat stat)"value" ), message);return result;static Expr SyntaxTreeCodeIf(CodeState * cs, Obj node)"SyntaxTreeCodeIf" , node);"branches" );sizeof (Expr), 0);for (int i = 0; i < len; i++) {"condition" );"body" );return ifexpr;static Expr SyntaxTreeCodeImmediateInteger(CodeState * cs, Obj node)"SyntaxTreeCodeImmediateInteger" , node);"value" );"SyntaxTreeCodeImmediateInteger" , value,".value" );return INTEXPR_INT(INT_INTOBJ(value));static Expr SyntaxTreeCodeValue(CodeState * cs, Obj node)"SyntaxTreeCodeValue" , node);"value" );sizeof (UInt), 0);Int ix = AddValueToBody(cs, value);return expr;static Expr SyntaxTreeCodeChar(CodeState * cs, Obj node)"SyntaxTreeCodeChar" , node);"value" );Char currchar = CHAR_VALUE(chr);sizeof (UInt), 0);return lit;static Obj SyntaxTreeFunc(Obj result, Obj func)Int narg;Int nloc;if (NAME_FUNC(func)) {"name" ), NAME_FUNC(func));if (narg < 0) {"variadic" ), True );else {"variadic" ), False );"narg" ), INTOBJ_INT(narg));"nloc" ), INTOBJ_INT(nloc));// names of arguments and locals "nams" ), NAMS_FUNC(func));// switch to this function (so that 'READ_STAT' and 'READ_EXPR' work) "stats" ), stats);return result;static Expr SyntaxTreeCodeFunc(CodeState * cs, Obj node)"SyntaxTreeCodeFunc" , node);Int narg = INT_INTOBJ(ElmRecST(EXPR_FUNC, node, "narg" ));Int nloc = INT_INTOBJ(ElmRecST(EXPR_FUNC, node, "nloc" ));"nams" );"variadic" );if (variadic == True ) {"stats" );"statements" );for (int i = 1; i <= nr_stats; i++) {return CodeFuncExprEnd(cs, nr_stats, FALSE , 0);static Obj FuncSYNTAX_TREE_CODE(Obj self, Obj tree)if (IsbPRec(tree, RNamName("name" ))) {"name" ));return func;static const CompilerT Compilers[] = {"funcref" ), ARGS_EXPR("args" )),"funcref" ), ARGS_EXPR("args" )),"funcref" ), ARGS_EXPR("args" )),"funcref" ), ARGS_EXPR("args" )),"funcref" ), ARGS_EXPR("args" )),"funcref" ), ARGS_EXPR("args" )),"funcref" ), ARGS_EXPR("args" )),"funcref" ), ARGS_EXPR("args" )),"opts" ), ARG_STAT_("call" )),"statements" )),"statements" )),"statements" )),"statements" )),"statements" )),"statements" )),"statements" )),"variable" ),"collection" ),"body" )),"variable" ),"collection" ),"body" )),"variable" ),"collection" ),"body" )),"variable" ),"collection" ),"body" )),"variable" ),"collection" ),"body" )),"variable" ),"collection" ),"body" )),"condition" ), ARGS_STAT("body" )),"condition" ), ARGS_STAT("body" )),"condition" ), ARGS_STAT("body" )),"condition" ), ARGS_STAT("body" )),"condition" ), ARGS_STAT("body" )),"condition" ), ARGS_STAT("body" )),#ifdef HPCGAP"body" ),"locks" )), // TODO: better output #endif "obj" )),"lvar" , ObjInt_UInt, SyntaxTreeCodeObjInt),"rhs" )),"lvar" , ObjInt_UInt, SyntaxTreeCodeObjInt)),"hvar" , ObjInt_UInt, SyntaxTreeCodeObjInt),"rhs" )),"hvar" , ObjInt_UInt, SyntaxTreeCodeObjInt)),"gvar" , NameGVar, SyntaxTreeCodeGVar),"rhs" )),"gvar" , NameGVar, SyntaxTreeCodeGVar)),"list" ), ARG_EXPR_("pos" ), ARG_EXPR_("rhs" )),"list" ),"row" ),"col" ),"rhs" )),"list" ),"poss" ),"rhss" )),"lists" ),"pos" ),"rhss" ),"level" , ObjInt_UInt, SyntaxTreeCodeObjInt)),"lists" ),"poss" ),"rhss" ),"level" , ObjInt_UInt, SyntaxTreeCodeObjInt)),"list" ), ARG_EXPR_("pos" )),"record" ),"rnam" , SyntaxTreeRNam, SyntaxTreeCodeRNamObj),"rhs" )),"record" ),"expression" ),"rhs" )),"record" ),"rnam" , SyntaxTreeRNam, SyntaxTreeCodeRNamObj)),"record" ), ARG_EXPR_("expression" )),"posobj" ),"pos" ),"rhs" )),"posobj" ), ARG_EXPR_("pos" )),"comobj" ),"rnam" , SyntaxTreeRNam, SyntaxTreeCodeRNamObj),"rhs" )),"comobj" ),"expression" ),"rhs" )),"comobj" ),"rnam" , SyntaxTreeRNam, SyntaxTreeCodeRNamObj)),"comobj" ), ARG_EXPR_("expression" )),"sel" ), ARG_EXPR_("lev" ), ARGS_EXPR("args" )),"level" ), ARG_EXPR_("condition" )),"level" ),"condition" ),"message" )),// Statements "funcref" ), ARGS_EXPR("args" )),"funcref" ), ARGS_EXPR("args" )),"funcref" ), ARGS_EXPR("args" )),"funcref" ), ARGS_EXPR("args" )),"funcref" ), ARGS_EXPR("args" )),"funcref" ), ARGS_EXPR("args" )),"funcref" ), ARGS_EXPR("args" )),"funcref" ), ARGS_EXPR("args" )),"opts" ), ARG_EXPR_("call" )),"left" ), ARG_EXPR_("right" )),"left" ), ARG_EXPR_("right" )),"op" )),"left" ), ARG_EXPR_("right" )),"left" ), ARG_EXPR_("right" )),"left" ), ARG_EXPR_("right" )),"left" ), ARG_EXPR_("right" )),"left" ), ARG_EXPR_("right" )),"left" ), ARG_EXPR_("right" )),"left" ), ARG_EXPR_("right" )),"left" ), ARG_EXPR_("right" )),"op" )),"left" ), ARG_EXPR_("right" )),"left" ), ARG_EXPR_("right" )),"left" ), ARG_EXPR_("right" )),"left" ), ARG_EXPR_("right" )),"left" ), ARG_EXPR_("right" )),"cycles" )),"points" )),"list" )),"list" )),// EXPR_REF_LVAR is encoded differently from all other // references to LVARs, so we have to treat // them specially here "lvar" , ObjInt_UInt, SyntaxTreeCodeObjInt)),"hvar" , ObjInt_UInt, SyntaxTreeCodeObjInt)),"hvar" , ObjInt_UInt, SyntaxTreeCodeObjInt)),"gvar" , NameGVar, SyntaxTreeCodeGVar)),"gvar" , NameGVar, SyntaxTreeCodeGVar)),// TODO: can this be unified? "list" ), ARG_EXPR_("pos" )),"list" ), ARG_EXPR_("row" ), ARG_EXPR_("col" )),"list" ), ARG_EXPR_("poss" )),"lists" ),"pos" ),"level" , ObjInt_UInt, SyntaxTreeCodeObjInt)),"lists" ),"poss" ),"level" , ObjInt_UInt, SyntaxTreeCodeObjInt)),"list" ), ARGS_EXPR("pos" )),"record" ),"name" , SyntaxTreeRNam, SyntaxTreeCodeRNamObj)),"record" ), ARG_EXPR_("expression" )),"record" ),"name" , SyntaxTreeRNam, SyntaxTreeCodeRNamObj)),"record" ), ARG_EXPR_("expression" )),"posobj" ), ARG_EXPR_("pos" )),"posobj" ), ARG_EXPR_("pos" )),"comobj" ),"name" , SyntaxTreeRNam, SyntaxTreeCodeRNamObj)),"comobj" ), ARG_EXPR_("expression" )),"comobj" ),"name" , SyntaxTreeRNam, SyntaxTreeCodeRNamObj)),"comobj" ), ARG_EXPR_("expression" )),static Obj FuncSYNTAX_TREE(Obj self, Obj func)if (!IS_FUNC(func) || IsKernelFunction(func) || IS_OPERATION(func)) {"must be a plain GAP function" );return SyntaxTreeFunc(result, func);static StructGVarFunc GVarFuncs[] = { GVAR_FUNC_1ARGS(SYNTAX_TREE, func),static Int InitKernel(StructInitInfo * module)// init filters and functions "typeStrings" );"typeRec" );return 0;static Int InitLibrary(StructInitInfo * module)// init filters and functions for (UInt tnum = 0; tnum < ARRAY_SIZE(Compilers); tnum++) {const char * str = Compilers[tnum].name;if (str) {return 0;static StructInitInfo module = {// init struct using C99 designated initializers; for a full list of // fields, please refer to the definition of StructInitInfo "syntaxtree" ,void )return &module;quality 93%
¤ Dauer der Verarbeitung: 0.24 Sekunden
(vorverarbeitet)
¤ *© Formatika GbR, Deutschland
