zeta/grammar.h

   1 // Run-time for grammars
   2
   3 typedef struct ParseValue ParseValue;
   4 typedef struct Gram Gram;
   5 typedef struct GramPrec GramPrec;
   6 typedef struct Ast Ast;
   7 typedef struct Line Line;
   8
   9 // CFG values
  10 typedef ParseValue CfgValue;
  11 typedef void SlrLexerArg;
  12
  13 #include "cfg.h"
  14 #include "slr.h"
  15 #ifdef GLR
  16 #include "glr.h"
  17 #define RgTokenL GlrTokenL
  18 #define RgToken GlrToken
  19 #define RgParse GlrParse
  20 #define mkRgTokenL mkGlrTokenL
  21 #define revRgTokenL revGlrTokenL
  22 #define RgTokenLL GlrTokenLL
  23 #define mkRgTokenLL mkGlrTokenLL
  24 #define revRgTokenLL revGlrTokenLL
  25 #define rgnewparse glrnewparse
  26 #define rgfreeparse (void)
  27 #define rgnewtoken glrnewtoken
  28 #define rgparse glrparse
  29 #else
  30 #include "rnglr.h"
  31 #endif
  32
  33 LIST(CfgSym)
  34 LIST(Gram)
  35 LIST(Ast)
  36
  37 // DFA values
  38 typedef CfgSym DKey;
  39 typedef CfgSymL DKeyL;
  40
  41 #include "nfa.h"
  42 #include "dfa.h"
  43
  44 struct Gram
  45 {
  46         Name name;
  47         Type *type;
  48         CfgGram *cfg;
  49         Hash *syms;
  50         DFA *dfa;
  51         int dfaprec;
  52         Hash *precs;
  53         Hash *ignores;
  54         Hash *rules;
  55         CfgSym *ignore;
  56         CfgSym *any;
  57         TypeL *gramx1s;
  58 };
  59
  60 struct GramPrec
  61 {
  62         CfgPrec *cfgprec;
  63 };
  64
  65 Gram*   mkGram(Name name);
  66 void    gramaddrule(Type*, GramPrec*, CfgSym*, CfgSymL*);
  67 CfgSym* gramsym(Type*, Name);
  68 CfgSym* gramliteral(Type*, Name);
  69 CfgSym* gramregexp(Type*, Name, int regexpflags, int canfail);
  70 GramPrec*       gramprec(Gram*, Name, CfgAssoc, CfgPrecKind, int creat);
  71 CfgSym* gramlooksym(Gram*, Name);
  72 CfgRule*        gramlookrule(Gram*, Name);
  73 CfgSym* gramunlistsym(Gram*, CfgSym*);
  74
  75 int     gramignoring(Gram*, CfgSym*);
  76 CfgSym* gramignore(Gram*, Name, int, int);
  77 int             grampriority(Gram*, Name, Name, int);
  78
  79 // Parsing
  80
  81 struct Line
  82 {
  83         Name file;
  84         int line;
  85 };
  86
  87 // TODO: Replace ParseValue with Ast.
  88 struct ParseValue
  89 {
  90         int ref;        // reference count during parsing
  91         int refcheck;
  92         Ast *ast;
  93         Line line;
  94 };
  95 ParseValue *mkParseValue(Ast*);
  96 void pvfree(CfgSym*, CfgValue*);
  97 void pvdup(CfgSym*, CfgValue**, CfgValue*);
  98
  99 Ast *parsetext(Type*, Name);
 100 int astfmt(Fmt*);
 101
 102 // Abstract syntax trees
 103 #define NoParentYet     ((Ast*)-1)
 104
 105 typedef struct Attr Attr;
 106 typedef enum AstOp {
 107         AstString = 1,
 108         AstRule,
 109         AstMerge,
 110         AstSlot,
 111 } AstOp;
 112 struct Ast
 113 {
 114         uchar op;
 115         uchar slotnum;
 116         uchar ref;
 117         uchar nright;
 118 //      int refcheck;
 119         Ast *canonical;
 120         Ast *copiedfrom;
 121         Type *tag;
 122         Line line;
 123         Ast *parent;
 124         Map attrmap;
 125
 126         CfgSym *sym;
 127         CfgRule *rule;
 128         Name text;
 129         Ast **right;
 130 };
 131 Ast *mkastrule(CfgRule*, Ast**);
 132 Ast *mkaststring(CfgSym*, Name);
 133 Ast *mkastmerge(Ast*, Ast*);
 134 Ast *mkastslot(Type*, CfgSym*, int);
 135 Ast *mkAst(AstOp, CfgSym*);
 136
 137 Ast *asttoquestion(Ast*, CfgSym*);      /* sym is ? type */
 138 Ast *astfromquestion(Ast*, CfgSym*);    /* sym is ? type */
 139 Ast *astlisttostar(Zlist*, CfgSym*);    /* sym is * type */
 140 Ast *astlisttoplus(Zlist*, CfgSym*);    /* sym is + type */
 141 int aststartolist(Ast*, CfgSym*, Zlist**);      /* sym is * type */
 142 int astplustolist(Ast*, CfgSym*, Zlist**);      /* sym is + type */
 143 Zlist *asttolist(Ast*);
 144 Zarray *astsplit(Ast*);
 145 void    astremovecopiedfrom(Ast*);
 146 Ast *astjoin(Ast*, Zarray*);
 147 Ast *astcopy(Ast*);
 148 Ast *astlastkid(Ast*);
 149 Name    astlisp(Ast*);
 150 Name    astlong(Ast*);
 151 Name    asttostring(Ast*);
 152 int     astmerged(Ast*);
 153 int     astslotted(Ast*);
 154 Ast*    astdup(Ast*);
 155 void    astfree(Ast*);
 156 void    astrefcheck(Ast*, int);
 157 Ast *astleak(Ast*);
 158 Ast     *astright(Ast*, int);
 159 Zpoly*  astline(Ast*);
 160 Ast     *astcanonicalize(Ast*);
 161
 162 Ast     *astparent(Ast*, Type*);
 163 Ast     *astcvtslot(Ast*, Type*);
 164
 165 void    astswap(Ast*, Ast*);
 166
 167 int     astsame(Ast*, Ast*);
 168
 169 #define astparent_attr(a) astparent(a, 0)
 170 Ast     *astprev_attr(Ast*);
 171 Ast     *astnext_attr(Ast*);
 172 Ast     *astcopiedfrom_attr(Ast*);
 173 int     parseaction(CfgGram*, CfgRule*, ParseValue**, ParseValue**);
 174
 175 // Attributes on ASTs
 176
 177 typedef struct AttrInfo AttrInfo;
 178
 179 struct AttrInfo
 180 {
 181         Name name;
 182         Type *type;
 183         Zfn **fn;
 184         Name pos;
 185         int registered;
 186         int ncompute;
 187 };
 188
 189 typedef enum AttrState
 190 {
 191         AttrUninit = 0,
 192         AttrComputing,
 193         AttrInit
 194 } AttrState;
 195 struct Attr
 196 {
 197         AttrState       state;
 198         Zpoly   data;
 199         MapElem me;
 200 };
 201 void regattr(AttrInfo*);
 202 void attrstats(void);
 203 void attrloop(AttrInfo*);
 204
 205 void    set_attribute(Ast*, AttrInfo*, Zpoly);
 206 Attr *get_attribute(Ast*, AttrInfo*);
 207 //Zpoly attribute(Ast*, AttrInfo*);
 208
 209 typedef struct AttrLink AttrLink;
 210 struct AttrLink
 211 {
 212         AttrInfo *info;
 213         Ast *ast;
 214         AttrLink *next;
 215 };
 216
 217 extern AttrLink *attrlinks;
 218
 219
 220 extern int nmkast;
 221 extern int nfreeast;
 222 extern int nleakast;
 223
 224 extern int nattr;
 225 extern AttrInfo **attrinfo;
 226
 227 #define GS(_name_) \
 228         ({ \
 229                 static CfgSym *sym; \
 230                 if(!sym){ \
 231                         Name x = _name_; \
 232                         sym = gramlooksym(__tgram__->gram, x); \
 233                         if(sym == nil) \
 234                                 panic("no symbol %s in %s", x, __tgram__->name); \
 235                 } \
 236                 sym; \
 237         })
 238
 239 #define GR(_name_) \
 240         ({ \
 241                 static CfgRule *rule; \
 242                 if(!rule){ \
 243                         Name x = _name_; \
 244                         rule = gramlookrule(__tgram__->gram, x); \
 245                         if(rule == nil) \
 246                                 panic("no rule %s in %s", x, __tgram__->name); \
 247                 } \
 248                 rule; \
 249         })
 250
 251
 252 enum
 253 {
 254         LeftRecursive = 1
 255 };