jamgram.yy

   1 /*\r
   2  * Copyright 1993-2002 Christopher Seiwald and Perforce Software, Inc.\r
   3  *\r
   4  * This file is part of Jam - see jam.c for Copyright information.\r
   5  */\r
   6 \r
   7 /*\r
   8  * jamgram.yy - jam grammar\r
   9  *\r
  10  * 04/13/94 (seiwald) - added shorthand L0 for null list pointer\r
  11  * 06/01/94 (seiwald) - new 'actions existing' does existing sources\r
  12  * 08/23/94 (seiwald) - Support for '+=' (append to variable)\r
  13  * 08/31/94 (seiwald) - Allow ?= as alias for "default =".\r
  14  * 09/15/94 (seiwald) - if conditionals take only single arguments, so\r
  15  *                      that 'if foo == bar' gives syntax error (use =).\r
  16  * 02/11/95 (seiwald) - when scanning arguments to rules, only treat\r
  17  *                      punctuation keywords as keywords.  All arg lists\r
  18  *                      are terminated with punctuation keywords.\r
  19  * 09/11/00 (seiwald) - Support for function calls; rules return LIST *.\r
  20  * 01/22/01 (seiwald) - replace evaluate_if() with compile_eval()\r
  21  * 01/24/01 (seiwald) - 'while' statement\r
  22  * 03/23/01 (seiwald) - "[ on target rule ]" support \r
  23  * 02/27/02 (seiwald) - un-break "expr : arg in list" syntax\r
  24  * 03/02/02 (seiwald) - rules can be invoked via variable names\r
  25  * 03/12/02 (seiwald) - set YYMAXDEPTH for big, right-recursive rules\r
  26  * 02/28/02 (seiwald) - merge EXEC_xxx flags in with RULE_xxx \r
  27  * 06/21/02 (seiwald) - support for named parameters\r
  28  * 10/22/02 (seiwald) - working return/break/continue statements\r
  29  */\r
  30 \r
  31 %token ARG STRING\r
  32 \r
  33 %left `||` `|`\r
  34 %left `&&` `&`\r
  35 %left `=` `!=` `in`\r
  36 %left `<` `<=` `>` `>=`\r
  37 %left `!`\r
  38 \r
  39 %{\r
  40 #include "jam.h"\r
  41 \r
  42 #include "lists.h"\r
  43 #include "variable.h"\r
  44 #include "parse.h"\r
  45 #include "scan.h"\r
  46 #include "compile.h"\r
  47 #include "newstr.h"\r
  48 #include "rules.h"\r
  49 \r
  50 # define YYMAXDEPTH 10000       /* for OSF and other less endowed yaccs */\r
  51 \r
  52 # define F0 (LIST *(*)(PARSE *, LOL *, int *))0\r
  53 # define P0 (PARSE *)0\r
  54 # define S0 (char *)0\r
  55 \r
  56 # define pappend( l,r )         parse_make( compile_append,l,r,P0,S0,S0,0 )\r
  57 # define pbreak( l,f )          parse_make( compile_break,l,P0,P0,S0,S0,f )\r
  58 # define peval( c,l,r )         parse_make( compile_eval,l,r,P0,S0,S0,c )\r
  59 # define pfor( s,l,r )          parse_make( compile_foreach,l,r,P0,s,S0,0 )\r
  60 # define pif( l,r,t )           parse_make( compile_if,l,r,t,S0,S0,0 )\r
  61 # define pincl( l )             parse_make( compile_include,l,P0,P0,S0,S0,0 )\r
  62 # define plist( s )             parse_make( compile_list,P0,P0,P0,s,S0,0 )\r
  63 # define plocal( l,r,t )        parse_make( compile_local,l,r,t,S0,S0,0 )\r
  64 # define pnull()                parse_make( compile_null,P0,P0,P0,S0,S0,0 )\r
  65 # define pon( l,r )             parse_make( compile_on,l,r,P0,S0,S0,0 )\r
  66 # define prule( a,p )           parse_make( compile_rule,a,p,P0,S0,S0,0 )\r
  67 # define prules( l,r )          parse_make( compile_rules,l,r,P0,S0,S0,0 )\r
  68 # define pset( l,r,a )          parse_make( compile_set,l,r,P0,S0,S0,a )\r
  69 # define pset1( l,r,t,a )       parse_make( compile_settings,l,r,t,S0,S0,a )\r
  70 # define psetc( s,l,r )         parse_make( compile_setcomp,l,r,P0,s,S0,0 )\r
  71 # define psete( s,l,s1,f )      parse_make( compile_setexec,l,P0,P0,s,s1,f )\r
  72 # define pswitch( l,r )         parse_make( compile_switch,l,r,P0,S0,S0,0 )\r
  73 # define pwhile( l,r )          parse_make( compile_while,l,r,P0,S0,S0,0 )\r
  74 \r
  75 # define pnode( l,r )           parse_make( F0,l,r,P0,S0,S0,0 )\r
  76 # define psnode( s,l )          parse_make( F0,l,P0,P0,s,S0,0 )\r
  77 \r
  78 %}\r
  79 \r
  80 %%\r
  81 \r
  82 run     : /* empty */\r
  83                 /* do nothing */\r
  84         | rules\r
  85                 { parse_save( $1.parse ); }\r
  86         ;\r
  87 \r
  88 /*\r
  89  * block - zero or more rules\r
  90  * rules - one or more rules\r
  91  * rule - any one of jam's rules\r
  92  * right-recursive so rules execute in order.\r
  93  */\r
  94 \r
  95 block   : /* empty */\r
  96                 { $$.parse = pnull(); }\r
  97         | rules\r
  98                 { $$.parse = $1.parse; }\r
  99         ;\r
 100 \r
 101 rules   : rule\r
 102                 { $$.parse = $1.parse; }\r
 103         | rule rules\r
 104                 { $$.parse = prules( $1.parse, $2.parse ); }\r
 105         | `local` list `;` block\r
 106                 { $$.parse = plocal( $2.parse, pnull(), $4.parse ); }\r
 107         | `local` list `=` list `;` block\r
 108                 { $$.parse = plocal( $2.parse, $4.parse, $6.parse ); }\r
 109         ;\r
 110 \r
 111 rule    : `{` block `}`\r
 112                 { $$.parse = $2.parse; }\r
 113         | `include` list `;`\r
 114                 { $$.parse = pincl( $2.parse ); }\r
 115         | arg lol `;`\r
 116                 { $$.parse = prule( $1.parse, $2.parse ); }\r
 117         | arg assign list `;`\r
 118                 { $$.parse = pset( $1.parse, $3.parse, $2.number ); }\r
 119         | arg `on` list assign list `;`\r
 120                 { $$.parse = pset1( $1.parse, $3.parse, $5.parse, $4.number ); }\r
 121         | `break` list `;`\r
 122                 { $$.parse = pbreak( $2.parse, JMP_BREAK ); }\r
 123         | `continue` list `;`\r
 124                 { $$.parse = pbreak( $2.parse, JMP_CONTINUE ); }\r
 125         | `return` list `;`\r
 126                 { $$.parse = pbreak( $2.parse, JMP_RETURN ); }\r
 127         | `for` ARG `in` list `{` block `}`\r
 128                 { $$.parse = pfor( $2.string, $4.parse, $6.parse ); }\r
 129         | `switch` list `{` cases `}`\r
 130                 { $$.parse = pswitch( $2.parse, $4.parse ); }\r
 131         | `if` expr `{` block `}` \r
 132                 { $$.parse = pif( $2.parse, $4.parse, pnull() ); }\r
 133         | `if` expr `{` block `}` `else` rule\r
 134                 { $$.parse = pif( $2.parse, $4.parse, $7.parse ); }\r
 135         | `while` expr `{` block `}`\r
 136                 { $$.parse = pwhile( $2.parse, $4.parse ); }\r
 137         | `rule` ARG params `{` block `}`\r
 138                 { $$.parse = psetc( $2.string, $3.parse, $5.parse ); }\r
 139         | `on` arg rule\r
 140                 { $$.parse = pon( $2.parse, $3.parse ); }\r
 141         | `actions` eflags ARG bindlist `{`\r
 142                 { yymode( SCAN_STRING ); }\r
 143           STRING \r
 144                 { yymode( SCAN_NORMAL ); }\r
 145           `}`\r
 146                 { $$.parse = psete( $3.string,$4.parse,$7.string,$2.number ); }\r
 147         ;\r
 148 \r
 149 /*\r
 150  * assign - = or +=\r
 151  */\r
 152 \r
 153 assign  : `=`\r
 154                 { $$.number = VAR_SET; }\r
 155         | `+=`\r
 156                 { $$.number = VAR_APPEND; }\r
 157         | `?=`\r
 158                 { $$.number = VAR_DEFAULT; }\r
 159         | `default` `=`\r
 160                 { $$.number = VAR_DEFAULT; }\r
 161         ;\r
 162 \r
 163 /*\r
 164  * expr - an expression for if\r
 165  */\r
 166 \r
 167 expr    : arg \r
 168                 { $$.parse = peval( EXPR_EXISTS, $1.parse, pnull() ); }\r
 169         | expr `=` expr \r
 170                 { $$.parse = peval( EXPR_EQUALS, $1.parse, $3.parse ); }\r
 171         | expr `!=` expr\r
 172                 { $$.parse = peval( EXPR_NOTEQ, $1.parse, $3.parse ); }\r
 173         | expr `<` expr\r
 174                 { $$.parse = peval( EXPR_LESS, $1.parse, $3.parse ); }\r
 175         | expr `<=` expr \r
 176                 { $$.parse = peval( EXPR_LESSEQ, $1.parse, $3.parse ); }\r
 177         | expr `>` expr \r
 178                 { $$.parse = peval( EXPR_MORE, $1.parse, $3.parse ); }\r
 179         | expr `>=` expr \r
 180                 { $$.parse = peval( EXPR_MOREEQ, $1.parse, $3.parse ); }\r
 181         | expr `&` expr \r
 182                 { $$.parse = peval( EXPR_AND, $1.parse, $3.parse ); }\r
 183         | expr `&&` expr \r
 184                 { $$.parse = peval( EXPR_AND, $1.parse, $3.parse ); }\r
 185         | expr `|` expr\r
 186                 { $$.parse = peval( EXPR_OR, $1.parse, $3.parse ); }\r
 187         | expr `||` expr\r
 188                 { $$.parse = peval( EXPR_OR, $1.parse, $3.parse ); }\r
 189         | arg `in` list\r
 190                 { $$.parse = peval( EXPR_IN, $1.parse, $3.parse ); }\r
 191         | `!` expr\r
 192                 { $$.parse = peval( EXPR_NOT, $2.parse, pnull() ); }\r
 193         | `(` expr `)`\r
 194                 { $$.parse = $2.parse; }\r
 195         ;\r
 196 \r
 197 /*\r
 198  * cases - action elements inside a 'switch'\r
 199  * case - a single action element inside a 'switch'\r
 200  * right-recursive rule so cases can be examined in order.\r
 201  */\r
 202 \r
 203 cases   : /* empty */\r
 204                 { $$.parse = P0; }\r
 205         | case cases\r
 206                 { $$.parse = pnode( $1.parse, $2.parse ); }\r
 207         ;\r
 208 \r
 209 case    : `case` ARG `:` block\r
 210                 { $$.parse = psnode( $2.string, $4.parse ); }\r
 211         ;\r
 212 \r
 213 /*\r
 214  * params - optional parameter names to rule definition\r
 215  * right-recursive rule so that params can be added in order.\r
 216  */\r
 217 \r
 218 params  : /* empty */\r
 219                 { $$.parse = P0; }\r
 220         | ARG `:` params\r
 221                 { $$.parse = psnode( $1.string, $3.parse ); }\r
 222         | ARG\r
 223                 { $$.parse = psnode( $1.string, P0 ); }\r
 224         ;\r
 225 \r
 226 /*\r
 227  * lol - list of lists\r
 228  * right-recursive rule so that lists can be added in order.\r
 229  */\r
 230 \r
 231 lol     : list\r
 232                 { $$.parse = pnode( P0, $1.parse ); }\r
 233         | list `:` lol\r
 234                 { $$.parse = pnode( $3.parse, $1.parse ); }\r
 235         ;\r
 236 \r
 237 /*\r
 238  * list - zero or more args in a LIST\r
 239  * listp - list (in puncutation only mode)\r
 240  * arg - one ARG or function call\r
 241  */\r
 242 \r
 243 list    : listp\r
 244                 { $$.parse = $1.parse; yymode( SCAN_NORMAL ); }\r
 245         ;\r
 246 \r
 247 listp   : /* empty */\r
 248                 { $$.parse = pnull(); yymode( SCAN_PUNCT ); }\r
 249         | listp arg\r
 250                 { $$.parse = pappend( $1.parse, $2.parse ); }\r
 251         ;\r
 252 \r
 253 arg     : ARG \r
 254                 { $$.parse = plist( $1.string ); }\r
 255         | `[` { yymode( SCAN_NORMAL ); } func `]`\r
 256                 { $$.parse = $3.parse; }\r
 257         ;\r
 258 \r
 259 /*\r
 260  * func - a function call (inside [])\r
 261  * This needs to be split cleanly out of 'rule'\r
 262  */\r
 263 \r
 264 func    : arg lol\r
 265                 { $$.parse = prule( $1.parse, $2.parse ); }\r
 266         | `on` arg arg lol\r
 267                 { $$.parse = pon( $2.parse, prule( $3.parse, $4.parse ) ); }\r
 268         | `on` arg `return` list \r
 269                 { $$.parse = pon( $2.parse, $4.parse ); }\r
 270         ;\r
 271 \r
 272 /*\r
 273  * eflags - zero or more modifiers to 'executes'\r
 274  * eflag - a single modifier to 'executes'\r
 275  */\r
 276 \r
 277 eflags  : /* empty */\r
 278                 { $$.number = 0; }\r
 279         | eflags eflag\r
 280                 { $$.number = $1.number | $2.number; }\r
 281         ;\r
 282 \r
 283 eflag   : `updated`\r
 284                 { $$.number = RULE_UPDATED; }\r
 285         | `together`\r
 286                 { $$.number = RULE_TOGETHER; }\r
 287         | `ignore`\r
 288                 { $$.number = RULE_IGNORE; }\r
 289         | `quietly`\r
 290                 { $$.number = RULE_QUIETLY; }\r
 291         | `piecemeal`\r
 292                 { $$.number = RULE_PIECEMEAL; }\r
 293         | `existing`\r
 294                 { $$.number = RULE_EXISTING; }\r
 295         | `maxline` ARG\r
 296                 { $$.number = atoi( $2.string ) * RULE_MAXLINE; }\r
 297         ;\r
 298 \r
 299 \r
 300 /*\r
 301  * bindlist - list of variable to bind for an action\r
 302  */\r
 303 \r
 304 bindlist : /* empty */\r
 305                 { $$.parse = pnull(); }\r
 306         | `bind` list\r
 307                 { $$.parse = $2.parse; }\r
 308         ;\r
 309 \r
 310 \r