parsing_cocci/parser_cocci_menhir.mly

   1 /*
   2 * Copyright 2005-2009, Ecole des Mines de Nantes, University of Copenhagen
   3 * Yoann Padioleau, Julia Lawall, Rene Rydhof Hansen, Henrik Stuart, Gilles Muller
   4 * This file is part of Coccinelle.
   5 *
   6 * Coccinelle is free software: you can redistribute it and/or modify
   7 * it under the terms of the GNU General Public License as published by
   8 * the Free Software Foundation, according to version 2 of the License.
   9 *
  10 * Coccinelle is distributed in the hope that it will be useful,
  11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 * GNU General Public License for more details.
  14 *
  15 * You should have received a copy of the GNU General Public License
  16 * along with Coccinelle.  If not, see <http://www.gnu.org/licenses/>.
  17 *
  18 * The authors reserve the right to distribute this or future versions of
  19 * Coccinelle under other licenses.
  20 */
  21
  22
  23 %{
  24
  25 (* Not clear how to allow function declarations to specify a return type
  26 and how to allow both to be specified as static, because they are in
  27 different rules.  The rules seem to have to be combined, which would allow
  28 functions to be declared as local variables *)
  29
  30 (* Not clear how to let a function have a parameter of type void.  At the
  31 moment, void is allowed to be the type of a variable, which is wrong, and a
  32 parameter needs both a type and an identifier *)
  33 module Ast0 = Ast0_cocci
  34 module Ast = Ast_cocci
  35 module P = Parse_aux
  36 %}
  37
  38 %token EOF
  39
  40 %token TIdentifier TExpression TStatement TFunction TLocal TType TParameter
  41 %token TIdExpression TInitialiser
  42 %token Tlist TFresh TConstant TError TWords TWhy0 TPlus0 TBang0
  43 %token TPure TContext TGenerated
  44 %token TTypedef TDeclarer TIterator TName TPosition TPosAny
  45 %token TUsing TDisable TExtends TDepends TOn TEver TNever TExists TForall
  46 %token TScript TReverse TNothing
  47 %token<string> TRuleName
  48
  49 %token<Data.clt> Tchar Tshort Tint Tdouble Tfloat Tlong
  50 %token<Data.clt> Tvoid Tstruct Tunion Tenum
  51 %token<Data.clt> Tunsigned Tsigned
  52
  53 %token<Data.clt> Tstatic Tauto Tregister Textern Tinline Ttypedef
  54 %token<Data.clt> Tconst Tvolatile
  55 %token<string * Data.clt> Tattr
  56
  57 %token <Data.clt> TIf TElse TWhile TFor TDo TSwitch TCase TDefault TReturn
  58 %token <Data.clt> TBreak TContinue TGoto TSizeof TFunDecl
  59 %token <string * Data.clt> TIdent TTypeId TDeclarerId TIteratorId TPragma
  60
  61 %token <Parse_aux.idinfo>     TMetaId TMetaFunc TMetaLocalFunc
  62 %token <Parse_aux.idinfo>     TMetaIterator TMetaDeclarer
  63 %token <Parse_aux.expinfo>    TMetaErr
  64 %token <Parse_aux.info>       TMetaParam TMetaStm TMetaStmList TMetaType
  65 %token <Parse_aux.info>       TMetaInit
  66 %token <Parse_aux.list_info>  TMetaParamList TMetaExpList
  67 %token <Parse_aux.typed_info> TMetaExp TMetaIdExp TMetaLocalIdExp TMetaConst
  68 %token <Parse_aux.pos_info>   TMetaPos
  69
  70 %token TArob TArobArob TPArob
  71 %token <string> TScriptData
  72
  73 %token <Data.clt> TEllipsis TOEllipsis TCEllipsis TPOEllipsis TPCEllipsis
  74 %token <Data.clt> TWhen TWhenTrue TWhenFalse TAny TStrict TLineEnd
  75
  76 %token <Data.clt> TWhy TDotDot TBang TOPar TOPar0
  77 %token <Data.clt> TMid0 TCPar TCPar0
  78
  79 %token <string>  TPathIsoFile
  80 %token <string * Data.clt> TIncludeL TIncludeNL
  81 %token <Data.clt * token> TDefine
  82 %token <Data.clt * token * int> TDefineParam
  83 %token <string * Data.clt> TMinusFile TPlusFile
  84
  85 %token <Data.clt> TInc TDec
  86
  87 %token <string * Data.clt> TString TChar TFloat TInt
  88
  89 %token <Data.clt> TOrLog
  90 %token <Data.clt> TAndLog
  91 %token <Data.clt> TOr
  92 %token <Data.clt> TXor
  93 %token <Data.clt> TAnd
  94 %token <Data.clt> TEqEq TNotEq
  95 %token <Ast_cocci.logicalOp * Data.clt> TLogOp /* TInf TSup TInfEq TSupEq */
  96 %token <Ast_cocci.arithOp * Data.clt>   TShOp  /* TShl TShr */
  97 %token <Ast_cocci.arithOp * Data.clt>   TDmOp  /* TDiv TMod */
  98 %token <Data.clt> TPlus TMinus
  99 %token <Data.clt> TMul TTilde
 100
 101 %token <Data.clt> TOBrace TCBrace TOInit
 102 %token <Data.clt> TOCro TCCro
 103
 104 %token <Data.clt> TPtrOp
 105
 106 %token TMPtVirg
 107 %token <Data.clt> TEq TDot TComma TPtVirg
 108 %token <Ast_cocci.assignOp * Data.clt> TAssign
 109
 110 %token TIso TRightIso TIsoExpression TIsoStatement TIsoDeclaration TIsoType
 111 %token TIsoTopLevel TIsoArgExpression TIsoTestExpression
 112
 113 %token TInvalid
 114
 115 /* operator precedence */
 116 %nonassoc TIf
 117 %nonassoc TElse
 118
 119 %left TOrLog
 120 %left TAndLog
 121 %left TOr
 122 %left TXor
 123 %left TAnd
 124 %left TEqEq TNotEq
 125 %left TLogOp /* TInf TSup TInfEq TSupEq */
 126 %left TShOp /* TShl TShr */
 127 %left TPlus TMinus
 128 %left TMul TDmOp /* TDiv TMod */
 129
 130 %start reinit
 131 %type <unit> reinit
 132
 133 %start minus_main
 134 %type <Ast0_cocci.rule> minus_main
 135
 136 %start minus_exp_main
 137 %type <Ast0_cocci.rule> minus_exp_main
 138
 139 %start plus_main
 140 %type <Ast0_cocci.rule> plus_main
 141
 142 %start plus_exp_main
 143 %type <Ast0_cocci.rule> plus_exp_main
 144
 145 %start include_main
 146 %type <(string,string) Common.either list> include_main
 147
 148 %start iso_rule_name
 149 %type <Ast_cocci.rulename>
 150 iso_rule_name
 151
 152 %start rule_name
 153 %type <Ast_cocci.rulename>
 154 rule_name
 155
 156 %start meta_main
 157 %type <(Ast_cocci.metavar,Ast_cocci.metavar) Common.either list> meta_main
 158
 159 %start <string * (string * string)> script_meta_main
 160
 161 %start iso_main
 162 %type <Ast0_cocci.anything list list> iso_main
 163
 164 %start iso_meta_main
 165 %type <(Ast_cocci.metavar,Ast_cocci.metavar) Common.either list> iso_meta_main
 166
 167 %start never_used
 168 %type <unit> never_used
 169
 170 %%
 171
 172 reinit: { }
 173 minus_main: minus_body EOF { $1 } | m=minus_body TArobArob { m }
 174 | m=minus_body TArob { m }
 175 plus_main: plus_body EOF { $1 } | p=plus_body TArobArob { p }
 176 | p=plus_body TArob { p }
 177 minus_exp_main: minus_exp_body EOF { $1 } | m=minus_exp_body TArobArob { m }
 178 | m=minus_exp_body TArob { m }
 179 plus_exp_main: plus_exp_body EOF { $1 } | p=plus_exp_body TArobArob { p }
 180 | p=plus_exp_body TArob { p }
 181 meta_main: m=metadec   { m (!Ast0.rule_name) }
 182 iso_meta_main: m=metadec { m "" }
 183
 184 /*****************************************************************************
 185 *
 186 *
 187 *****************************************************************************/
 188
 189 pure:
 190   TPure          { Ast0.Pure }
 191 | TContext       { Ast0.Context }
 192 | TPure TContext { Ast0.PureContext }
 193 | TContext TPure { Ast0.PureContext }
 194 | /* empty */    { Ast0.Impure }
 195
 196 iso_rule_name:
 197   nm=pure_ident TArob { P.make_iso_rule_name_result (P.id2name nm) }
 198
 199 rule_name:
 200   nm=ioption(pure_ident) extends d=depends i=loption(choose_iso)
 201     a=loption(disable) e=exists ee=is_expression TArob
 202       { P.make_cocci_rule_name_result nm d i a e ee }
 203   | TGenerated extends d=depends i=loption(choose_iso)
 204     a=loption(disable) e=exists ee=is_expression TArob
 205       /* these rules have no name as a cheap way to ensure that no normal
 206       rule inherits their metavariables or depends on them */
 207       { P.make_generated_rule_name_result None d i a e ee }
 208   | TScript TDotDot lang=pure_ident d=depends TArob
 209       { P.make_script_rule_name_result lang d }
 210
 211 extends:
 212   /* empty */                                     { () }
 213 | TExtends parent=TRuleName
 214     { !Data.install_bindings (parent) }
 215
 216 depends:
 217   /* empty */              { Ast.NoDep }
 218 | TDepends TOn parents=dep { parents }
 219
 220 dep:
 221   pnrule           { $1 }
 222 | dep TAndLog dep  { Ast.AndDep($1, $3) }
 223 | dep TOrLog  dep  { Ast.OrDep ($1, $3) }
 224
 225 pnrule:
 226   TRuleName        { Ast.Dep      $1 }
 227 | TBang TRuleName  { Ast.AntiDep  $2 }
 228 | TEver TRuleName  { Ast.EverDep  $2 }
 229 | TNever TRuleName { Ast.NeverDep $2 }
 230 | TOPar dep TCPar  { $2 }
 231
 232 choose_iso:
 233   TUsing separated_nonempty_list(TComma,TString) { List.map P.id2name $2 }
 234
 235 disable:
 236   TDisable separated_nonempty_list(TComma,pure_ident) { List.map P.id2name $2 }
 237
 238 exists:
 239   TExists { Ast.Exists }
 240 | TForall { Ast.Forall }
 241 | TReverse TForall { Ast.ReverseForall }
 242 |         { Ast.Undetermined }
 243
 244 is_expression: // for more flexible parsing of top level expressions
 245               { false }
 246 | TExpression { true }
 247
 248 include_main:
 249   list(incl) TArob     { $1 }
 250 | list(incl) TArobArob { $1 }
 251
 252 incl:
 253   TUsing TString      { Common.Left(P.id2name $2) }
 254 | TUsing TPathIsoFile { Common.Right $2 }
 255
 256 metadec:
 257   ar=arity ispure=pure
 258   kindfn=metakind ids=comma_list(pure_ident_or_meta_ident) TMPtVirg
 259     { P.create_metadec ar ispure kindfn ids }
 260 | ar=arity ispure=pure
 261   kindfn=metakind_atomic
 262   ids=comma_list(pure_ident_or_meta_ident_with_not_eq(not_eq)) TMPtVirg
 263     { P.create_metadec_ne ar ispure kindfn ids }
 264 | ar=arity ispure=pure
 265   kindfn=metakind_atomic_expi
 266   ids=comma_list(pure_ident_or_meta_ident_with_not_eq(not_eqe)) TMPtVirg
 267     { P.create_metadec_ne ar ispure kindfn ids }
 268 | ar=arity ispure=pure
 269   kindfn=metakind_atomic_expe
 270   ids=comma_list(pure_ident_or_meta_ident_with_not_eq(not_ceq)) TMPtVirg
 271     { P.create_metadec_ne ar ispure kindfn ids }
 272 | ar=arity TPosition a=option(TPosAny)
 273     ids=comma_list(pure_ident_or_meta_ident_with_not_eq(not_pos)) TMPtVirg
 274     (* pb: position variables can't be inherited from normal rules, and then
 275        there is no way to inherit from a generated rule, so there is no point
 276        to have a position variable *)
 277     { (if !Data.in_generating
 278       then failwith "position variables not allowed in a generated rule file");
 279       let kindfn arity name pure check_meta constraints =
 280       let tok = check_meta(Ast.MetaPosDecl(arity,name)) in
 281       let any = match a with None -> Ast.PER | Some _ -> Ast.ALL in
 282       !Data.add_pos_meta name constraints any; tok in
 283     P.create_metadec_ne ar false kindfn ids }
 284 | ar=arity ispure=pure
 285     TParameter Tlist TOCro id=pure_ident_or_meta_ident TCCro
 286     ids=comma_list(pure_ident_or_meta_ident) TMPtVirg
 287     { P.create_len_metadec ar ispure
 288         (fun lenname arity name pure check_meta ->
 289           let tok =
 290             check_meta(Ast.MetaParamListDecl(arity,name,Some lenname)) in
 291           !Data.add_paramlist_meta name (Some lenname) pure; tok)
 292         id ids }
 293 | ar=arity ispure=pure
 294     TExpression Tlist TOCro id=pure_ident_or_meta_ident TCCro
 295     ids=comma_list(pure_ident_or_meta_ident) TMPtVirg
 296     { P.create_len_metadec ar ispure
 297         (fun lenname arity name pure check_meta ->
 298           let tok =
 299             check_meta(Ast.MetaExpListDecl(arity,name,Some lenname)) in
 300           !Data.add_explist_meta name (Some lenname) pure; tok)
 301         id ids }
 302
 303 %inline metakind:
 304   TFresh TIdentifier
 305     { (fun arity name pure check_meta ->
 306       let tok = check_meta(Ast.MetaFreshIdDecl(arity,name)) in
 307       !Data.add_id_meta name [] pure; tok) }
 308 | TParameter
 309     { (fun arity name pure check_meta ->
 310       let tok = check_meta(Ast.MetaParamDecl(arity,name)) in
 311       !Data.add_param_meta name pure; tok) }
 312 | TParameter Tlist
 313     { (fun arity name pure check_meta ->
 314       let tok = check_meta(Ast.MetaParamListDecl(arity,name,None)) in
 315       !Data.add_paramlist_meta name None pure; tok) }
 316 | TExpression Tlist
 317     { (fun arity name pure check_meta ->
 318       let tok = check_meta(Ast.MetaExpListDecl(arity,name,None)) in
 319       !Data.add_explist_meta name None pure; tok) }
 320 | TType
 321     { (fun arity name pure check_meta ->
 322       let tok = check_meta(Ast.MetaTypeDecl(arity,name)) in
 323       !Data.add_type_meta name pure; tok) }
 324 | TInitialiser
 325     { (fun arity name pure check_meta ->
 326       let tok = check_meta(Ast.MetaInitDecl(arity,name)) in
 327       !Data.add_init_meta name pure; tok) }
 328 | TStatement
 329     { (fun arity name pure check_meta ->
 330       let tok = check_meta(Ast.MetaStmDecl(arity,name)) in
 331       !Data.add_stm_meta name pure; tok) }
 332 | TStatement Tlist
 333     { (fun arity name pure check_meta ->
 334       let tok = check_meta(Ast.MetaStmListDecl(arity,name)) in
 335       !Data.add_stmlist_meta name pure; tok) }
 336 | TTypedef
 337     { (fun arity (_,name) pure check_meta ->
 338       if arity = Ast.NONE && pure = Ast0.Impure
 339       then (!Data.add_type_name name; [])
 340       else raise (Semantic_cocci.Semantic "bad typedef")) }
 341 | TDeclarer TName
 342     { (fun arity (_,name) pure check_meta ->
 343       if arity = Ast.NONE && pure = Ast0.Impure
 344       then (!Data.add_declarer_name name; [])
 345       else raise (Semantic_cocci.Semantic "bad declarer")) }
 346 | TIterator TName
 347     { (fun arity (_,name) pure check_meta ->
 348       if arity = Ast.NONE && pure = Ast0.Impure
 349       then (!Data.add_iterator_name name; [])
 350       else raise (Semantic_cocci.Semantic "bad iterator")) }
 351
 352
 353 %inline metakind_atomic:
 354   TIdentifier
 355     { (fun arity name pure check_meta constraints ->
 356       let tok = check_meta(Ast.MetaIdDecl(arity,name)) in
 357       !Data.add_id_meta name constraints pure; tok) }
 358 | TFunction
 359     { (fun arity name pure check_meta constraints ->
 360       let tok = check_meta(Ast.MetaFuncDecl(arity,name)) in
 361       !Data.add_func_meta name constraints pure; tok) }
 362 | TLocal TFunction
 363     { (fun arity name pure check_meta constraints ->
 364       let tok = check_meta(Ast.MetaLocalFuncDecl(arity,name)) in
 365       !Data.add_local_func_meta name constraints pure;
 366       tok) }
 367 | TDeclarer
 368     { (fun arity name pure check_meta constraints ->
 369       let tok = check_meta(Ast.MetaDeclarerDecl(arity,name)) in
 370       !Data.add_declarer_meta name constraints pure; tok) }
 371 | TIterator
 372     { (fun arity name pure check_meta constraints ->
 373       let tok = check_meta(Ast.MetaIteratorDecl(arity,name)) in
 374       !Data.add_iterator_meta name constraints pure; tok) }
 375
 376 %inline metakind_atomic_expi:
 377   TError
 378     { (fun arity name pure check_meta constraints ->
 379       let tok = check_meta(Ast.MetaErrDecl(arity,name)) in
 380       !Data.add_err_meta name constraints pure; tok) }
 381 | l=option(TLocal) TIdExpression ty=ioption(meta_exp_type)
 382     { (fun arity name pure check_meta constraints ->
 383       match l with
 384         None ->
 385           !Data.add_idexp_meta ty name constraints pure;
 386           check_meta(Ast.MetaIdExpDecl(arity,name,ty))
 387       | Some _ ->
 388           !Data.add_local_idexp_meta ty name constraints pure;
 389           check_meta(Ast.MetaLocalIdExpDecl(arity,name,ty))) }
 390 | l=option(TLocal) TIdExpression m=nonempty_list(TMul)
 391     { (fun arity name pure check_meta constraints ->
 392       let ty = Some [P.ty_pointerify Type_cocci.Unknown m] in
 393       match l with
 394         None ->
 395           !Data.add_idexp_meta ty name constraints pure;
 396           check_meta(Ast.MetaIdExpDecl(arity,name,ty))
 397       | Some _ ->
 398           !Data.add_local_idexp_meta ty name constraints pure;
 399           check_meta(Ast.MetaLocalIdExpDecl(arity,name,ty))) }
 400 | TExpression m=nonempty_list(TMul)
 401     { (fun arity name pure check_meta constraints ->
 402       let ty = Some [P.ty_pointerify Type_cocci.Unknown m] in
 403       let tok = check_meta(Ast.MetaExpDecl(arity,name,ty)) in
 404       !Data.add_exp_meta ty name constraints pure; tok) }
 405 | vl=meta_exp_type TOCro TCCro
 406     { (fun arity name pure check_meta constraints ->
 407       let ty = Some (List.map (function x -> Type_cocci.Array x) vl) in
 408       let tok = check_meta(Ast.MetaExpDecl(arity,name,ty)) in
 409       !Data.add_exp_meta ty name constraints pure; tok) }
 410 | TConstant ty=ioption(meta_exp_type)
 411     { (fun arity name pure check_meta constraints ->
 412       let tok = check_meta(Ast.MetaConstDecl(arity,name,ty)) in
 413       !Data.add_const_meta ty name constraints pure; tok) }
 414
 415 %inline metakind_atomic_expe:
 416   TExpression
 417     { (fun arity name pure check_meta constraints ->
 418       let tok = check_meta(Ast.MetaExpDecl(arity,name,None)) in
 419       !Data.add_exp_meta None name constraints pure; tok) }
 420 | vl=meta_exp_type // no error if use $1 but doesn't type check
 421     { (fun arity name pure check_meta constraints ->
 422       let ty = Some vl in
 423       List.iter
 424         (function c ->
 425           match Ast0.unwrap c with
 426             Ast0.Constant(_) ->
 427               if not
 428                   (List.exists
 429                      (function
 430                          Type_cocci.BaseType(Type_cocci.IntType) -> true
 431                        | Type_cocci.BaseType(Type_cocci.ShortType) -> true
 432                        | Type_cocci.BaseType(Type_cocci.LongType) -> true
 433                        | _ -> false)
 434                      vl)
 435               then failwith "metavariable with int constraint must be an int"
 436           | _ -> ())
 437         constraints;
 438       let tok = check_meta(Ast.MetaExpDecl(arity,name,ty)) in
 439       !Data.add_exp_meta ty name constraints pure; tok) }
 440
 441
 442 meta_exp_type:
 443   t=ctype
 444     { [Ast0_cocci.ast0_type_to_type t] }
 445 | TOBrace t=comma_list(ctype) TCBrace m=list(TMul)
 446     { List.map
 447         (function x -> P.ty_pointerify (Ast0_cocci.ast0_type_to_type x) m)
 448         t }
 449
 450 arity: TBang0 { Ast.UNIQUE }
 451      | TWhy0  { Ast.OPT }
 452      | TPlus0 { Ast.MULTI }
 453      | /* empty */ { Ast.NONE }
 454
 455 generic_ctype_full:
 456        q=ctype_qualif_opt ty=Tchar
 457         { q (Ast0.wrap(Ast0.BaseType(Ast.CharType,[P.clt2mcode "char" ty]))) }
 458      | q=ctype_qualif_opt ty=Tshort
 459         { q (Ast0.wrap(Ast0.BaseType(Ast.ShortType,[P.clt2mcode "short" ty])))}
 460      | q=ctype_qualif_opt ty=Tint
 461          { q (Ast0.wrap(Ast0.BaseType(Ast.IntType,[P.clt2mcode "int" ty]))) }
 462      | t=Tdouble
 463          { Ast0.wrap(Ast0.BaseType(Ast.DoubleType,[P.clt2mcode "double" t])) }
 464      | t=Tfloat
 465          { Ast0.wrap(Ast0.BaseType(Ast.FloatType,[P.clt2mcode "float" t])) }
 466      | q=ctype_qualif_opt ty=Tlong
 467          { q (Ast0.wrap(Ast0.BaseType(Ast.LongType,[P.clt2mcode "long" ty]))) }
 468      | q=ctype_qualif_opt ty=Tlong ty1=Tlong
 469          { q (Ast0.wrap
 470                 (Ast0.BaseType
 471                    (Ast.LongLongType,
 472                       [P.clt2mcode "long" ty;P.clt2mcode "long" ty1]))) }
 473      | s=Tenum i=ident
 474          { Ast0.wrap(Ast0.EnumName(P.clt2mcode "enum" s, i)) }
 475      | s=struct_or_union i=ident
 476          { Ast0.wrap(Ast0.StructUnionName(s, Some i)) }
 477      | s=struct_or_union i=ioption(ident)
 478        l=TOBrace d=struct_decl_list r=TCBrace
 479          { (if i = None && !Data.in_iso
 480            then failwith "structures must be named in the iso file");
 481            Ast0.wrap(Ast0.StructUnionDef(Ast0.wrap(Ast0.StructUnionName(s, i)),
 482                                          P.clt2mcode "{" l,
 483                                          d, P.clt2mcode "}" r)) }
 484      | s=TMetaType l=TOBrace d=struct_decl_list r=TCBrace
 485          { let (nm,pure,clt) = s in
 486          let ty =
 487            Ast0.wrap(Ast0.MetaType(P.clt2mcode nm clt,pure)) in
 488          Ast0.wrap
 489            (Ast0.StructUnionDef(ty,P.clt2mcode "{" l,d,P.clt2mcode "}" r)) }
 490      | r=TRuleName TDot p=TIdent
 491          { let nm = (r,P.id2name p) in
 492          (* this is only possible when we are in a metavar decl.  Otherwise,
 493             it will be represented already as a MetaType *)
 494          let _ = P.check_meta(Ast.MetaTypeDecl(Ast.NONE,nm)) in
 495          Ast0.wrap(Ast0.MetaType(P.clt2mcode nm (P.id2clt p),
 496                                  Ast0.Impure (*will be ignored*))) }
 497      | p=TTypeId
 498          { Ast0.wrap(Ast0.TypeName(P.id2mcode p)) }
 499      | q=ctype_qualif_opt p=TMetaType
 500          { let (nm,pure,clt) = p in
 501          q (Ast0.wrap(Ast0.MetaType(P.clt2mcode nm clt,pure))) }
 502
 503 generic_ctype:
 504        q=ctype_qualif     { q None }
 505      | generic_ctype_full { $1 }
 506
 507 struct_or_union:
 508        s=Tstruct { P.clt2mcode Ast.Struct s }
 509      | u=Tunion  { P.clt2mcode Ast.Union u }
 510
 511 struct_decl:
 512       TNothing { [] }
 513     | t=ctype d=d_ident pv=TPtVirg
 514          { let (id,fn) = d in
 515          [Ast0.wrap(Ast0.UnInit(None,fn t,id,P.clt2mcode ";" pv))] }
 516     | t=fn_ctype lp1=TOPar st=TMul d=d_ident rp1=TCPar
 517         lp2=TOPar p=decl_list(name_opt_decl) rp2=TCPar pv=TPtVirg
 518         { let (id,fn) = d in
 519         let t =
 520           Ast0.wrap
 521             (Ast0.FunctionPointer
 522                (t,P.clt2mcode "(" lp1,P.clt2mcode "*" st,P.clt2mcode ")" rp1,
 523                 P.clt2mcode "(" lp2,p,P.clt2mcode ")" rp2)) in
 524         [Ast0.wrap(Ast0.UnInit(None,fn t,id,P.clt2mcode ";" pv))] }
 525      | cv=ioption(const_vol) i=pure_ident d=d_ident pv=TPtVirg
 526          { let (id,fn) = d in
 527          let idtype = P.make_cv cv (Ast0.wrap (Ast0.TypeName(P.id2mcode i))) in
 528          [Ast0.wrap(Ast0.UnInit(None,fn idtype,id,P.clt2mcode ";" pv))] }
 529
 530 struct_decl_list:
 531    struct_decl_list_start { Ast0.wrap(Ast0.DOTS($1)) }
 532
 533 struct_decl_list_start:
 534   struct_decl                        { $1 }
 535 | struct_decl struct_decl_list_start { $1@$2 }
 536 | d=edots_when(TEllipsis,struct_decl) r=continue_struct_decl_list
 537     { (P.mkddots "..." d)::r }
 538
 539 continue_struct_decl_list:
 540   /* empty */                        { [] }
 541 | struct_decl struct_decl_list_start { $1@$2 }
 542 | struct_decl                        { $1 }
 543
 544 ctype:
 545        cv=ioption(const_vol) ty=generic_ctype m=list(TMul)
 546          { P.pointerify (P.make_cv cv ty) m }
 547      | cv=ioption(const_vol) t=Tvoid m=nonempty_list(TMul)
 548          { let ty =
 549              Ast0.wrap(Ast0.BaseType(Ast.VoidType,[P.clt2mcode "void" t])) in
 550            P.pointerify (P.make_cv cv ty) m }
 551    | lp=TOPar0 t=midzero_list(ctype,ctype) rp=TCPar0
 552       /* more hacks */
 553     { let (mids,code) = t in
 554       Ast0.wrap
 555         (Ast0.DisjType(P.clt2mcode "(" lp,code,mids, P.clt2mcode ")" rp)) }
 556
 557 ctype_full:
 558        cv=ioption(const_vol) ty=generic_ctype_full m=list(TMul)
 559          { P.pointerify (P.make_cv cv ty) m }
 560      | cv=ioption(const_vol) t=Tvoid m=nonempty_list(TMul)
 561          { let ty =
 562              Ast0.wrap(Ast0.BaseType(Ast.VoidType,[P.clt2mcode "void" t])) in
 563            P.pointerify (P.make_cv cv ty) m }
 564    | lp=TOPar0 t=midzero_list(ctype,ctype) rp=TCPar0
 565       /* more hacks */
 566     { let (mids,code) = t in
 567       Ast0.wrap
 568         (Ast0.DisjType(P.clt2mcode "(" lp,code,mids, P.clt2mcode ")" rp)) }
 569
 570
 571 fn_ctype: // allows metavariables
 572        ty=generic_ctype m=list(TMul) { P.pointerify ty m }
 573      | t=Tvoid m=list(TMul)
 574          { P.pointerify
 575              (Ast0.wrap(Ast0.BaseType(Ast.VoidType,[P.clt2mcode "void" t])))
 576              m }
 577
 578 %inline ctype_qualif:
 579   r=Tunsigned
 580    { function x -> Ast0.wrap(Ast0.Signed(P.clt2mcode Ast.Unsigned r,x)) }
 581 | r=Tsigned
 582    { function x -> Ast0.wrap(Ast0.Signed(P.clt2mcode Ast.Signed r,x)) }
 583
 584 %inline ctype_qualif_opt:
 585   s=ctype_qualif  { function x -> s (Some x) }
 586 | /* empty */   { function x -> x }
 587
 588 /*****************************************************************************/
 589
 590 /* have to inline everything to avoid conflicts? switch to proper
 591 declarations, statements, and expressions for the subterms */
 592
 593 minus_body:
 594     f=loption(filespec)
 595     b=loption(minus_start)
 596     ew=loption(error_words)
 597     { match f@b@ew with
 598       [] -> raise (Semantic_cocci.Semantic "minus slice can't be empty")
 599     | code -> Top_level.top_level code }
 600
 601 plus_body:
 602     f=loption(filespec)
 603     b=loption(plus_start)
 604     ew=loption(error_words)
 605     { Top_level.top_level (f@b@ew) }
 606
 607 minus_exp_body:
 608     f=loption(filespec)
 609     b=top_eexpr
 610     ew=loption(error_words)
 611     { match f@[b]@ew with
 612       [] -> raise (Semantic_cocci.Semantic "minus slice can't be empty")
 613     | code -> Top_level.top_level code }
 614
 615 plus_exp_body:
 616     f=loption(filespec)
 617     b=top_eexpr
 618     ew=loption(error_words)
 619     { Top_level.top_level (f@[b]@ew) }
 620
 621 filespec:
 622   TMinusFile TPlusFile
 623     { [Ast0.wrap
 624           (Ast0.FILEINFO(P.id2mcode $1,
 625                          P.id2mcode $2))] }
 626
 627 includes:
 628   TIncludeL
 629     { Ast0.wrap
 630               (Ast0.Include(P.clt2mcode "#include" (P.drop_aft (P.id2clt $1)),
 631                             let (arity,ln,lln,offset,col,strbef,straft,pos) =
 632                               P.id2clt $1 in
 633                             let clt =
 634                               (arity,ln,lln,offset,0,strbef,straft,pos) in
 635                             P.clt2mcode
 636                               (Ast.Local (Parse_aux.str2inc (P.id2name $1)))
 637                               (P.drop_bef clt))) }
 638 | TIncludeNL
 639     { Ast0.wrap
 640               (Ast0.Include(P.clt2mcode "#include" (P.drop_aft (P.id2clt $1)),
 641                             let (arity,ln,lln,offset,col,strbef,straft,pos) =
 642                               P.id2clt $1 in
 643                             let clt =
 644                               (arity,ln,lln,offset,0,strbef,straft,pos) in
 645                             P.clt2mcode
 646                               (Ast.NonLocal (Parse_aux.str2inc (P.id2name $1)))
 647                               (P.drop_bef clt))) }
 648 | d=defineop t=ctype TLineEnd
 649     { let ty = Ast0.wrap(Ast0.TopExp(Ast0.wrap(Ast0.TypeExp(t)))) in
 650       d (Ast0.wrap(Ast0.DOTS([ty]))) }
 651 | defineop b=toplevel_seq_start(toplevel_after_dots) TLineEnd
 652     { let body =
 653         match b with
 654           [e] ->
 655             (match Ast0.unwrap e with
 656               Ast0.Exp(e1) ->
 657                 [Ast0.rewrap e (Ast0.TopExp(Ast0.set_arg_exp (e1)))]
 658             | _ -> b)
 659         | _ -> b in
 660       $1 (Ast0.wrap(Ast0.DOTS(body))) }
 661
 662 defineop:
 663   TDefine
 664     { let (clt,ident) = $1 in
 665       function body ->
 666         Ast0.wrap
 667           (Ast0.Define
 668              (P.clt2mcode "#define" clt,
 669               (match ident with
 670                 TMetaId((nm,constraints,pure,clt)) ->
 671                   Ast0.wrap(Ast0.MetaId(P.clt2mcode nm clt,constraints,pure))
 672               | TIdent(nm_pure) ->
 673                   Ast0.wrap(Ast0.Id(P.id2mcode nm_pure))
 674               | _ ->
 675                   raise
 676                     (Semantic_cocci.Semantic
 677                        "unexpected name for a #define")),
 678               Ast0.wrap Ast0.NoParams,
 679               body)) }
 680 | TDefineParam define_param_list_option TCPar
 681     { let (clt,ident,parenoff) = $1 in
 682       let (arity,line,lline,offset,col,strbef,straft,pos) = clt in
 683       let lp =
 684         P.clt2mcode "("
 685           (arity,line,lline,parenoff,0,[],[],Ast0.NoMetaPos) in
 686       function body ->
 687         Ast0.wrap
 688           (Ast0.Define
 689              (P.clt2mcode "#define" clt,
 690               (match ident with
 691                 TMetaId((nm,constraints,pure,clt)) ->
 692                   Ast0.wrap(Ast0.MetaId(P.clt2mcode nm clt,constraints,pure))
 693               | TIdent(nm_pure) ->
 694                   Ast0.wrap(Ast0.Id(P.id2mcode nm_pure))
 695               | _ ->
 696                   raise
 697                     (Semantic_cocci.Semantic
 698                        "unexpected name for a #define")),
 699               Ast0.wrap (Ast0.DParams (lp,$2,P.clt2mcode ")" $3)),body)) }
 700
 701 /* ---------------------------------------------------------------------- */
 702
 703 define_param_list: define_param_list_start
 704      {let circle x =
 705        match Ast0.unwrap x with Ast0.DPcircles(_) -> true | _ -> false in
 706      if List.exists circle $1
 707      then Ast0.wrap(Ast0.CIRCLES($1))
 708      else Ast0.wrap(Ast0.DOTS($1)) }
 709
 710 define_param_list_start:
 711     ident { [Ast0.wrap(Ast0.DParam $1)] }
 712   | ident TComma define_param_list_start
 713       { Ast0.wrap(Ast0.DParam $1)::
 714         Ast0.wrap(Ast0.DPComma(P.clt2mcode "," $2))::$3 }
 715   | d=TEllipsis r=list(dp_comma_args(TEllipsis))
 716       { (P.mkdpdots "..." d)::
 717         (List.concat (List.map (function x -> x (P.mkdpdots "...")) r)) }
 718
 719 dp_comma_args(dotter):
 720   c=TComma d=dotter
 721     { function dot_builder ->
 722       [Ast0.wrap(Ast0.DPComma(P.clt2mcode "," c)); dot_builder d] }
 723 | TComma ident
 724     { function dot_builder ->
 725       [Ast0.wrap(Ast0.DPComma(P.clt2mcode "," $1));
 726         Ast0.wrap(Ast0.DParam $2)] }
 727
 728 define_param_list_option: define_param_list { $1 }
 729          | /* empty */     { Ast0.wrap(Ast0.DOTS([])) }
 730
 731 /*****************************************************************************/
 732
 733 funproto:
 734   s=ioption(storage) t=ctype
 735   id=func_ident lp=TOPar d=decl_list(name_opt_decl) rp=TCPar pt=TPtVirg
 736       { Ast0.wrap
 737           (Ast0.UnInit
 738              (s,
 739               Ast0.wrap
 740                 (Ast0.FunctionType(Some t,
 741                                    P.clt2mcode "(" lp, d, P.clt2mcode ")" rp)),
 742               id, P.clt2mcode ";" pt)) }
 743 | s=ioption(storage) t=Tvoid
 744   id=func_ident lp=TOPar d=decl_list(name_opt_decl) rp=TCPar pt=TPtVirg
 745     { let t = Ast0.wrap(Ast0.BaseType(Ast.VoidType,[P.clt2mcode "void" t])) in
 746       Ast0.wrap
 747         (Ast0.UnInit
 748            (s,
 749             Ast0.wrap
 750               (Ast0.FunctionType(Some t,
 751                                  P.clt2mcode "(" lp, d, P.clt2mcode ")" rp)),
 752             id, P.clt2mcode ";" pt)) }
 753
 754
 755 fundecl:
 756   f=fninfo
 757   TFunDecl i=func_ident lp=TOPar d=decl_list(decl) rp=TCPar
 758   lb=TOBrace b=fun_start rb=TCBrace
 759       { Ast0.wrap(Ast0.FunDecl((Ast0.default_info(),Ast0.context_befaft()),
 760                                f, i,
 761                                P.clt2mcode "(" lp, d,
 762                                P.clt2mcode ")" rp,
 763                                P.clt2mcode "{" lb, b,
 764                                P.clt2mcode "}" rb)) }
 765
 766 fninfo:
 767     /* empty */ { [] }
 768   | storage  fninfo
 769       { try
 770         let _ =
 771           List.find (function Ast0.FStorage(_) -> true | _ -> false) $2 in
 772         raise (Semantic_cocci.Semantic "duplicate storage")
 773       with Not_found -> (Ast0.FStorage($1))::$2 }
 774   | t=fn_ctype r=fninfo_nt { (Ast0.FType(t))::r }
 775   | Tinline  fninfo
 776       { try
 777         let _ = List.find (function Ast0.FInline(_) -> true | _ -> false) $2 in
 778         raise (Semantic_cocci.Semantic "duplicate inline")
 779       with Not_found -> (Ast0.FInline(P.clt2mcode "inline" $1))::$2 }
 780   | Tattr    fninfo
 781       { try
 782         let _ = List.find (function Ast0.FAttr(_) -> true | _ -> false) $2 in
 783         raise (Semantic_cocci.Semantic "multiple attributes")
 784       with Not_found -> (Ast0.FAttr(P.id2mcode $1))::$2 }
 785
 786 fninfo_nt:
 787     /* empty */ { [] }
 788   | storage  fninfo_nt
 789       { try
 790         let _ =
 791           List.find (function Ast0.FStorage(_) -> true | _ -> false) $2 in
 792         raise (Semantic_cocci.Semantic "duplicate storage")
 793       with Not_found -> (Ast0.FStorage($1))::$2 }
 794   | Tinline  fninfo_nt
 795       { try
 796         let _ = List.find (function Ast0.FInline(_) -> true | _ -> false) $2 in
 797         raise (Semantic_cocci.Semantic "duplicate inline")
 798       with Not_found -> (Ast0.FInline(P.clt2mcode "inline" $1))::$2 }
 799   | Tattr    fninfo_nt
 800       { try
 801         let _ = List.find (function Ast0.FAttr(_) -> true | _ -> false) $2 in
 802         raise (Semantic_cocci.Semantic "duplicate init")
 803       with Not_found -> (Ast0.FAttr(P.id2mcode $1))::$2 }
 804
 805 storage:
 806          s=Tstatic      { P.clt2mcode Ast.Static s }
 807        | s=Tauto        { P.clt2mcode Ast.Auto s }
 808        | s=Tregister    { P.clt2mcode Ast.Register s }
 809        | s=Textern      { P.clt2mcode Ast.Extern s }
 810
 811 decl: t=ctype i=ident
 812         { Ast0.wrap(Ast0.Param(t, Some i)) }
 813     | t=fn_ctype lp=TOPar s=TMul i=ident rp=TCPar
 814         lp1=TOPar d=decl_list(name_opt_decl) rp1=TCPar
 815         { let fnptr =
 816           Ast0.wrap
 817             (Ast0.FunctionPointer
 818                (t,P.clt2mcode "(" lp,P.clt2mcode "*" s,P.clt2mcode ")" rp,
 819                 P.clt2mcode "(" lp1,d,P.clt2mcode ")" rp1)) in
 820         Ast0.wrap(Ast0.Param(fnptr, Some i)) }
 821     | t=Tvoid
 822         { let ty =
 823           Ast0.wrap(Ast0.BaseType(Ast.VoidType,[P.clt2mcode "void" t])) in
 824           Ast0.wrap(Ast0.VoidParam(ty)) }
 825     | TMetaParam
 826         { let (nm,pure,clt) = $1 in
 827         Ast0.wrap(Ast0.MetaParam(P.clt2mcode nm clt,pure)) }
 828
 829 name_opt_decl:
 830       decl  { $1 }
 831     | t=ctype { Ast0.wrap(Ast0.Param(t, None)) }
 832     | t=fn_ctype lp=TOPar s=TMul rp=TCPar
 833         lp1=TOPar d=decl_list(name_opt_decl) rp1=TCPar
 834         { let fnptr =
 835           Ast0.wrap
 836             (Ast0.FunctionPointer
 837                (t,P.clt2mcode "(" lp,P.clt2mcode "*" s,P.clt2mcode ")" rp,
 838                 P.clt2mcode "(" lp1,d,P.clt2mcode ")" rp1)) in
 839         Ast0.wrap(Ast0.Param(fnptr, None)) }
 840
 841 const_vol:
 842       Tconst       { P.clt2mcode Ast.Const $1 }
 843     | Tvolatile    { P.clt2mcode Ast.Volatile $1 }
 844
 845 /*****************************************************************************/
 846
 847 statement:
 848   includes { $1 } /* shouldn't be allowed to be a single_statement... */
 849 | TMetaStm
 850     { P.meta_stm $1 }
 851 | expr TPtVirg
 852     { P.exp_stm $1 $2 }
 853 | TIf TOPar eexpr TCPar single_statement %prec TIf
 854     { P.ifthen $1 $2 $3 $4 $5 }
 855 | TIf TOPar eexpr TCPar single_statement TElse single_statement
 856     { P.ifthenelse $1 $2 $3 $4 $5 $6 $7 }
 857 | TFor TOPar option(eexpr) TPtVirg option(eexpr) TPtVirg
 858     option(eexpr) TCPar single_statement
 859     { P.forloop $1 $2 $3 $4 $5 $6 $7 $8 $9 }
 860 | TWhile TOPar eexpr TCPar single_statement
 861     { P.whileloop $1 $2 $3 $4 $5 }
 862 | TDo single_statement TWhile TOPar eexpr TCPar TPtVirg
 863     { P.doloop $1 $2 $3 $4 $5 $6 $7 }
 864 | iter_ident TOPar eexpr_list_option TCPar single_statement
 865     { P.iterator $1 $2 $3 $4 $5 }
 866 | TSwitch TOPar eexpr TCPar TOBrace list(case_line) TCBrace
 867     { P.switch $1 $2 $3 $4 $5 $6 $7 }
 868 | TReturn eexpr TPtVirg { P.ret_exp $1 $2 $3 }
 869 | TReturn TPtVirg { P.ret $1 $2 }
 870 | TBreak TPtVirg { P.break $1 $2 }
 871 | TContinue TPtVirg { P.cont $1 $2 }
 872 | ident TDotDot { P.label $1 $2 }
 873 | TGoto ident TPtVirg { P.goto $1 $2 $3 }
 874 | TOBrace fun_start TCBrace
 875     { P.seq $1 $2 $3 }
 876
 877 stm_dots:
 878   TEllipsis w=list(whenppdecs)
 879     { Ast0.wrap(Ast0.Dots(P.clt2mcode "..." $1, List.concat w)) }
 880 | TOEllipsis w=list(whenppdecs) b=nest_start c=TCEllipsis
 881     { Ast0.wrap(Ast0.Nest(P.clt2mcode "<..." $1, b,
 882                           P.clt2mcode "...>" c, List.concat w, false)) }
 883 | TPOEllipsis w=list(whenppdecs) b=nest_start c=TPCEllipsis
 884     { Ast0.wrap(Ast0.Nest(P.clt2mcode "<+..." $1, b,
 885                           P.clt2mcode "...+>" c, List.concat w, true)) }
 886
 887 %inline stm_dots_ell:
 888   a=TEllipsis w=list(whenppdecs)
 889     { Ast0.wrap(Ast0.Dots(P.clt2mcode "..." a, List.concat w)) }
 890
 891 %inline stm_dots_nest:
 892   a=TOEllipsis w=list(whenppdecs) b=nest_start c=TCEllipsis
 893     { Ast0.wrap(Ast0.Nest(P.clt2mcode "<..." a, b,
 894                           P.clt2mcode "...>" c, List.concat w, false)) }
 895 | a=TPOEllipsis w=list(whenppdecs) b=nest_start c=TPCEllipsis
 896     { Ast0.wrap(Ast0.Nest(P.clt2mcode "<+..." a, b,
 897                           P.clt2mcode "...+>" c, List.concat w, true)) }
 898
 899 whenppdecs: w=whens(when_start,rule_elem_statement)
 900     { w }
 901
 902 /* a statement that fits into a single rule_elem.  should nests be included?
 903 what about statement metavariables? */
 904 rule_elem_statement:
 905   one_decl_var
 906     { Ast0.wrap(Ast0.Decl((Ast0.default_info(),Ast0.context_befaft()),$1)) }
 907 | expr TPtVirg { P.exp_stm $1 $2 }
 908 | TReturn eexpr TPtVirg { P.ret_exp $1 $2 $3 }
 909 | TReturn TPtVirg { P.ret $1 $2 }
 910 | TBreak TPtVirg { P.break $1 $2 }
 911 | TContinue TPtVirg { P.cont $1 $2 }
 912 | TOPar0 midzero_list(rule_elem_statement,rule_elem_statement) TCPar0
 913     { let (mids,code) = $2 in
 914     Ast0.wrap
 915       (Ast0.Disj(P.clt2mcode "(" $1,
 916                  List.map (function x -> Ast0.wrap(Ast0.DOTS([x]))) code,
 917                  mids, P.clt2mcode ")" $3)) }
 918
 919 /* a statement on its own */
 920 single_statement:
 921     statement                         { $1 }
 922   | TOPar0 midzero_list(statement,statement) TCPar0
 923       /* degenerate case, elements are single statements and thus don't
 924         contain dots */
 925       { let (mids,code) = $2 in
 926         Ast0.wrap
 927           (Ast0.Disj(P.clt2mcode "(" $1,
 928                      List.map (function x -> Ast0.wrap(Ast0.DOTS([x]))) code,
 929                      mids, P.clt2mcode ")" $3)) }
 930
 931 case_line:
 932     TDefault TDotDot fun_start
 933       { Ast0.wrap(Ast0.Default(P.clt2mcode "default" $1,P.clt2mcode ":" $2,$3)) }
 934   | TCase eexpr TDotDot fun_start
 935       { Ast0.wrap(Ast0.Case(P.clt2mcode "case" $1,$2,P.clt2mcode ":" $3,$4)) }
 936
 937 /* In the following, an identifier as a type is not fully supported.  Indeed,
 938 the language is ambiguous: what is foo * bar; */
 939 /* The AST DisjDecl cannot be generated because it would be ambiguous with
 940 a disjunction on a statement with a declaration in each branch */
 941 decl_var:
 942     t=ctype pv=TPtVirg
 943       { [Ast0.wrap(Ast0.TyDecl(t,P.clt2mcode ";" pv))] }
 944   | s=ioption(storage) t=ctype d=comma_list(d_ident) pv=TPtVirg
 945       { List.map
 946           (function (id,fn) ->
 947             Ast0.wrap(Ast0.UnInit(s,fn t,id,P.clt2mcode ";" pv)))
 948           d }
 949   | f=funproto { [f] }
 950   | s=ioption(storage) t=ctype d=d_ident q=TEq e=initialize pv=TPtVirg
 951       {let (id,fn) = d in
 952       [Ast0.wrap(Ast0.Init(s,fn t,id,P.clt2mcode "=" q,e,P.clt2mcode ";" pv))]}
 953   /* type is a typedef name */
 954   | s=ioption(storage) cv=ioption(const_vol) i=pure_ident
 955       d=comma_list(d_ident) pv=TPtVirg
 956       { List.map
 957           (function (id,fn) ->
 958             let idtype =
 959               P.make_cv cv (Ast0.wrap (Ast0.TypeName(P.id2mcode i))) in
 960             Ast0.wrap(Ast0.UnInit(s,fn idtype,id,P.clt2mcode ";" pv)))
 961           d }
 962   | s=ioption(storage) cv=ioption(const_vol) i=pure_ident d=d_ident q=TEq
 963       e=initialize pv=TPtVirg
 964       { let (id,fn) = d in
 965       !Data.add_type_name (P.id2name i);
 966       let idtype = P.make_cv cv (Ast0.wrap (Ast0.TypeName(P.id2mcode i))) in
 967       [Ast0.wrap(Ast0.Init(s,fn idtype,id,P.clt2mcode "=" q,e,
 968                            P.clt2mcode ";" pv))] }
 969   /* function pointer type */
 970   | s=ioption(storage)
 971     t=fn_ctype lp1=TOPar st=TMul d=d_ident rp1=TCPar
 972     lp2=TOPar p=decl_list(name_opt_decl) rp2=TCPar
 973     pv=TPtVirg
 974       { let (id,fn) = d in
 975         let t =
 976           Ast0.wrap
 977             (Ast0.FunctionPointer
 978                (t,P.clt2mcode "(" lp1,P.clt2mcode "*" st,P.clt2mcode ")" rp1,
 979                 P.clt2mcode "(" lp2,p,P.clt2mcode ")" rp2)) in
 980         [Ast0.wrap(Ast0.UnInit(s,fn t,id,P.clt2mcode ";" pv))] }
 981   | decl_ident TOPar eexpr_list_option TCPar TPtVirg
 982       { [Ast0.wrap(Ast0.MacroDecl($1,P.clt2mcode "(" $2,$3,
 983                                   P.clt2mcode ")" $4,P.clt2mcode ";" $5))] }
 984   | s=ioption(storage)
 985     t=fn_ctype lp1=TOPar st=TMul d=d_ident rp1=TCPar
 986     lp2=TOPar p=decl_list(name_opt_decl) rp2=TCPar
 987     q=TEq e=initialize pv=TPtVirg
 988       { let (id,fn) = d in
 989         let t =
 990           Ast0.wrap
 991             (Ast0.FunctionPointer
 992                (t,P.clt2mcode "(" lp1,P.clt2mcode "*" st,P.clt2mcode ")" rp1,
 993                 P.clt2mcode "(" lp2,p,P.clt2mcode ")" rp2)) in
 994       [Ast0.wrap(Ast0.Init(s,fn t,id,P.clt2mcode "=" q,e,P.clt2mcode ";" pv))]}
 995   | s=Ttypedef t=ctype_full id=typedef_ident pv=TPtVirg
 996       { let s = P.clt2mcode "typedef" s in
 997         [Ast0.wrap(Ast0.Typedef(s,t,id,P.clt2mcode ";" pv))] }
 998
 999 one_decl_var:
1000     t=ctype pv=TPtVirg
1001       { Ast0.wrap(Ast0.TyDecl(t,P.clt2mcode ";" pv)) }
1002   | s=ioption(storage) t=ctype d=d_ident pv=TPtVirg
1003       { let (id,fn) = d in
1004         Ast0.wrap(Ast0.UnInit(s,fn t,id,P.clt2mcode ";" pv)) }
1005   | f=funproto { f }
1006   | s=ioption(storage) t=ctype d=d_ident q=TEq e=initialize pv=TPtVirg
1007       { let (id,fn) = d in
1008       Ast0.wrap(Ast0.Init(s,fn t,id,P.clt2mcode "=" q,e,P.clt2mcode ";" pv)) }
1009   /* type is a typedef name */
1010   | s=ioption(storage) cv=ioption(const_vol) i=pure_ident
1011       d=d_ident pv=TPtVirg
1012       { let (id,fn) = d in
1013         let idtype = P.make_cv cv (Ast0.wrap (Ast0.TypeName(P.id2mcode i))) in
1014         Ast0.wrap(Ast0.UnInit(s,fn idtype,id,P.clt2mcode ";" pv)) }
1015   | s=ioption(storage) cv=ioption(const_vol) i=pure_ident d=d_ident q=TEq
1016       e=initialize pv=TPtVirg
1017       { let (id,fn) = d in
1018       !Data.add_type_name (P.id2name i);
1019       let idtype = P.make_cv cv (Ast0.wrap (Ast0.TypeName(P.id2mcode i))) in
1020       Ast0.wrap(Ast0.Init(s,fn idtype,id,P.clt2mcode "=" q,e,
1021                            P.clt2mcode ";" pv)) }
1022   /* function pointer type */
1023   | s=ioption(storage)
1024     t=fn_ctype lp1=TOPar st=TMul d=d_ident rp1=TCPar
1025     lp2=TOPar p=decl_list(name_opt_decl) rp2=TCPar
1026     pv=TPtVirg
1027       { let (id,fn) = d in
1028         let t =
1029           Ast0.wrap
1030             (Ast0.FunctionPointer
1031                (t,P.clt2mcode "(" lp1,P.clt2mcode "*" st,P.clt2mcode ")" rp1,
1032                 P.clt2mcode "(" lp2,p,P.clt2mcode ")" rp2)) in
1033         Ast0.wrap(Ast0.UnInit(s,fn t,id,P.clt2mcode ";" pv)) }
1034   | decl_ident TOPar eexpr_list_option TCPar TPtVirg
1035       { Ast0.wrap(Ast0.MacroDecl($1,P.clt2mcode "(" $2,$3,
1036                                   P.clt2mcode ")" $4,P.clt2mcode ";" $5)) }
1037   | s=ioption(storage)
1038     t=fn_ctype lp1=TOPar st=TMul d=d_ident rp1=TCPar
1039     lp2=TOPar p=decl_list(name_opt_decl) rp2=TCPar
1040     q=TEq e=initialize pv=TPtVirg
1041       { let (id,fn) = d in
1042         let t =
1043           Ast0.wrap
1044             (Ast0.FunctionPointer
1045                (t,P.clt2mcode "(" lp1,P.clt2mcode "*" st,P.clt2mcode ")" rp1,
1046                 P.clt2mcode "(" lp2,p,P.clt2mcode ")" rp2)) in
1047       Ast0.wrap(Ast0.Init(s,fn t,id,P.clt2mcode "=" q,e,P.clt2mcode ";" pv))}
1048
1049
1050 d_ident:
1051     ident list(array_dec)
1052       { ($1,
1053          function t ->
1054            List.fold_right
1055              (function (l,i,r) ->
1056                function rest ->
1057                  Ast0.wrap
1058                    (Ast0.Array(rest,P.clt2mcode "[" l,i,P.clt2mcode "]" r)))
1059              $2 t) }
1060
1061 array_dec: l=TOCro i=option(eexpr) r=TCCro { (l,i,r) }
1062
1063 initialize:
1064     eexpr
1065       { Ast0.wrap(Ast0.InitExpr($1)) }
1066   | TOBrace initialize_list TCBrace
1067       { Ast0.wrap(Ast0.InitList(P.clt2mcode "{" $1,$2,P.clt2mcode "}" $3)) }
1068   | TOBrace TCBrace
1069       { Ast0.wrap
1070           (Ast0.InitList(P.clt2mcode "{" $1,Ast0.wrap(Ast0.DOTS []),
1071                          P.clt2mcode "}" $2)) }
1072   | TMetaInit
1073       {let (nm,pure,clt) = $1 in
1074       Ast0.wrap(Ast0.MetaInit(P.clt2mcode nm clt,pure)) }
1075
1076 initialize2:
1077   /*arithexpr and not eexpr because can have ambiguity with comma*/
1078   /*dots and nests probably not allowed at top level, haven't looked into why*/
1079   arith_expr(eexpr,invalid) { Ast0.wrap(Ast0.InitExpr($1)) }
1080 | TOBrace initialize_list TCBrace
1081     { Ast0.wrap(Ast0.InitList(P.clt2mcode "{" $1,$2,P.clt2mcode "}" $3)) }
1082 | TOBrace TCBrace
1083     { Ast0.wrap
1084         (Ast0.InitList(P.clt2mcode "{" $1,Ast0.wrap(Ast0.DOTS []),
1085                        P.clt2mcode "}" $2)) }
1086            /* gccext:, labeled elements */
1087 | list(designator) TEq initialize2
1088     { Ast0.wrap(Ast0.InitGccExt($1,P.clt2mcode "=" $2,$3)) }
1089 | ident TDotDot initialize2
1090     { Ast0.wrap(Ast0.InitGccName($1,P.clt2mcode ":" $2,$3)) } /* in old kernel */
1091
1092 designator:
1093  | TDot ident
1094      { Ast0.DesignatorField (P.clt2mcode "." $1,$2) }
1095  | TOCro eexpr TCCro
1096      { Ast0.DesignatorIndex (P.clt2mcode "[" $1,$2,P.clt2mcode "]" $3) }
1097  | TOCro eexpr TEllipsis eexpr TCCro
1098      { Ast0.DesignatorRange (P.clt2mcode "[" $1,$2,P.clt2mcode "..." $3,
1099                              $4,P.clt2mcode "]" $5) }
1100
1101 initialize_list:
1102    initialize_list_start { Ast0.wrap(Ast0.DOTS($1)) }
1103
1104 initialize_list_start:
1105   initialize2 TComma { [$1;Ast0.wrap(Ast0.IComma(P.clt2mcode "," $2))] }
1106 | initialize2 TComma initialize_list_start
1107     { $1::Ast0.wrap(Ast0.IComma(P.clt2mcode "," $2))::$3 }
1108 | d=edots_when(TEllipsis,initialize)
1109       r=comma_initializers(edots_when(TEllipsis,initialize))
1110     { (P.mkidots "..." d)::
1111       (List.concat(List.map (function x -> x (P.mkidots "...")) r)) }
1112
1113 comma_initializers(dotter):
1114   /* empty */ { [] }
1115 | d=dotter r=comma_initializers2(dotter)
1116       { (function dot_builder -> [dot_builder d])::r }
1117 | i=initialize2 c=TComma r=comma_initializers(dotter)
1118     { (function dot_builder -> [i; Ast0.wrap(Ast0.IComma(P.clt2mcode "," c))])::
1119       r }
1120
1121 comma_initializers2(dotter):
1122   /* empty */ { [] }
1123 | i=initialize2 c=TComma r=comma_initializers(dotter)
1124     { (function dot_builder -> [i; Ast0.wrap(Ast0.IComma(P.clt2mcode "," c))])::
1125       r }
1126
1127 /* a statement that is part of a list */
1128 decl_statement:
1129     TMetaStmList
1130       { let (nm,pure,clt) = $1 in
1131       [Ast0.wrap(Ast0.MetaStmt(P.clt2mcode nm clt,pure))] }
1132   | decl_var
1133       { List.map
1134           (function x ->
1135             Ast0.wrap
1136               (Ast0.Decl((Ast0.default_info(),Ast0.context_befaft()),x)))
1137           $1 }
1138   | statement { [$1] }
1139   /* this doesn't allow expressions at top level, because the parser doesn't
1140         know whether there is one.  If there is one, this is not sequencible.
1141         If there is not one, then it is.  It seems complicated to get around
1142     this at the parser level.  We would have to have a check afterwards to
1143     allow this.  One case where this would be useful is for a when.  Now
1144         we allow a sequence of whens, so one can be on only statements and
1145     one can be on only expressions. */
1146   | TOPar0 t=midzero_list(fun_start,fun_start) TCPar0
1147       { let (mids,code) = t in
1148         if List.for_all
1149             (function x ->
1150               match Ast0.unwrap x with Ast0.DOTS([]) -> true | _ -> false)
1151             code
1152       then []
1153       else
1154           [Ast0.wrap(Ast0.Disj(P.clt2mcode "(" $1, code, mids,
1155                                P.clt2mcode ")" $3))] }
1156
1157 /* a statement that is part of a list */
1158 decl_statement_expr:
1159     TMetaStmList
1160       { let (nm,pure,clt) = $1 in
1161       [Ast0.wrap(Ast0.MetaStmt(P.clt2mcode nm clt,pure))] }
1162   | decl_var
1163       { List.map
1164           (function x ->
1165             Ast0.wrap
1166               (Ast0.Decl((Ast0.default_info(),Ast0.context_befaft()),x)))
1167           $1 }
1168   | statement { [$1] }
1169   /* this doesn't allow expressions at top level, because the parser doesn't
1170         know whether there is one.  If there is one, this is not sequencible.
1171         If there is not one, then it is.  It seems complicated to get around
1172     this at the parser level.  We would have to have a check afterwards to
1173     allow this.  One case where this would be useful is for a when.  Now
1174         we allow a sequence of whens, so one can be on only statements and
1175     one can be on only expressions. */
1176   | TOPar0 t=midzero_list(fun_after_stm,fun_after_dots_or) TCPar0
1177       { let (mids,code) = t in
1178         if List.for_all (function [] -> true | _ -> false) code
1179       then []
1180       else
1181           let dot_code =
1182             List.map (function x -> Ast0.wrap(Ast0.DOTS x)) code in
1183           [Ast0.wrap(Ast0.Disj(P.clt2mcode "(" $1, dot_code, mids,
1184                                P.clt2mcode ")" $3))] }
1185
1186 /*****************************************************************************/
1187
1188 /* The following cannot contain <... ...> at the top level.  This can only
1189 be allowed as an expression when the expression is delimited on both sides
1190 by expression-specific markers.  In that case, the rule eexpr is used, which
1191 allows <... ...> anywhere.  Hopefully, this will not be too much of a problem
1192 in practice. */
1193 expr:  basic_expr(expr,invalid) { $1 }
1194 /* allows ... and nests */
1195 eexpr: basic_expr(eexpr,dot_expressions) { $1 }
1196 /* allows nests but not .... */
1197 dexpr: basic_expr(eexpr,nest_expressions) { $1 }
1198
1199 top_eexpr:
1200   eexpr { Ast0.wrap(Ast0.OTHER(Ast0.wrap(Ast0.Exp($1)))) }
1201
1202 invalid:
1203   TInvalid { raise (Semantic_cocci.Semantic "not matchable") }
1204
1205 dot_expressions:
1206   TEllipsis { Ast0.wrap(Ast0.Edots(P.clt2mcode "..." $1,None)) }
1207 | nest_expressions { $1 }
1208
1209 /* not clear what whencode would mean, so just drop it */
1210 nest_expressions:
1211   TOEllipsis e=expr_dots(TEllipsis) c=TCEllipsis
1212     { Ast0.wrap(Ast0.NestExpr(P.clt2mcode "<..." $1,
1213                               Ast0.wrap(Ast0.DOTS(e (P.mkedots "..."))),
1214                               P.clt2mcode "...>" c, None, false)) }
1215 | TPOEllipsis e=expr_dots(TEllipsis) c=TPCEllipsis
1216     { Ast0.wrap(Ast0.NestExpr(P.clt2mcode "<+..." $1,
1217                               Ast0.wrap(Ast0.DOTS(e (P.mkedots "..."))),
1218                               P.clt2mcode "...+>" c, None, true)) }
1219
1220 //whenexp: TWhen TNotEq w=eexpr TLineEnd { w }
1221
1222 basic_expr(recurser,primary_extra):
1223   assign_expr(recurser,primary_extra)                        { $1 }
1224
1225 assign_expr(r,pe):
1226     cond_expr(r,pe)                        { $1 }
1227   | unary_expr(r,pe) TAssign assign_expr_bis
1228       { let (op,clt) = $2 in
1229       Ast0.wrap(Ast0.Assignment($1,P.clt2mcode op clt,
1230                                 Ast0.set_arg_exp $3,false)) }
1231   | unary_expr(r,pe) TEq assign_expr_bis
1232       { Ast0.wrap
1233           (Ast0.Assignment
1234              ($1,P.clt2mcode Ast.SimpleAssign $2,Ast0.set_arg_exp $3,false)) }
1235
1236 assign_expr_bis:
1237     cond_expr(eexpr,dot_expressions)                        { $1 }
1238   | unary_expr(eexpr,dot_expressions) TAssign assign_expr_bis
1239       { let (op,clt) = $2 in
1240       Ast0.wrap(Ast0.Assignment($1,P.clt2mcode op clt,
1241                                 Ast0.set_arg_exp $3,false)) }
1242   | unary_expr(eexpr,dot_expressions) TEq assign_expr_bis
1243       { Ast0.wrap
1244           (Ast0.Assignment
1245              ($1,P.clt2mcode Ast.SimpleAssign $2,Ast0.set_arg_exp $3,false)) }
1246
1247 cond_expr(r,pe):
1248     arith_expr(r,pe)                         { $1 }
1249   | l=arith_expr(r,pe) w=TWhy t=option(eexpr) dd=TDotDot r=cond_expr(r,pe)
1250       { Ast0.wrap(Ast0.CondExpr (l, P.clt2mcode "?" w, t,
1251                                  P.clt2mcode ":" dd, r)) }
1252
1253 arith_expr(r,pe):
1254     cast_expr(r,pe)                         { $1 }
1255   | arith_expr(r,pe) TMul    arith_expr(r,pe)
1256       { P.arith_op Ast.Mul $1 $2 $3 }
1257   | arith_expr(r,pe) TDmOp    arith_expr(r,pe)
1258       { let (op,clt) = $2 in P.arith_op op $1 clt $3 }
1259   | arith_expr(r,pe) TPlus   arith_expr(r,pe)
1260       { P.arith_op Ast.Plus $1 $2 $3 }
1261   | arith_expr(r,pe) TMinus  arith_expr(r,pe)
1262       { P.arith_op Ast.Minus $1 $2 $3 }
1263   | arith_expr(r,pe) TShOp    arith_expr(r,pe)
1264       { let (op,clt) = $2 in P.arith_op op $1 clt $3 }
1265   | arith_expr(r,pe) TLogOp    arith_expr(r,pe)
1266       { let (op,clt) = $2 in P.logic_op op $1 clt $3 }
1267   | arith_expr(r,pe) TEqEq   arith_expr(r,pe)
1268       { P.logic_op Ast.Eq $1 $2 $3 }
1269   | arith_expr(r,pe) TNotEq  arith_expr(r,pe)
1270       { P.logic_op Ast.NotEq $1 $2 $3 }
1271   | arith_expr(r,pe) TAnd    arith_expr(r,pe)
1272       { P.arith_op Ast.And $1 $2 $3 }
1273   | arith_expr(r,pe) TOr     arith_expr(r,pe)
1274       { P.arith_op Ast.Or $1 $2 $3 }
1275   | arith_expr(r,pe) TXor    arith_expr(r,pe)
1276       { P.arith_op Ast.Xor $1 $2 $3 }
1277   | arith_expr(r,pe) TAndLog arith_expr(r,pe)
1278       { P.logic_op Ast.AndLog $1 $2 $3 }
1279   | arith_expr(r,pe) TOrLog  arith_expr(r,pe)
1280       { P.logic_op Ast.OrLog $1 $2 $3 }
1281
1282 cast_expr(r,pe):
1283     unary_expr(r,pe)                      { $1 }
1284   | lp=TOPar t=ctype rp=TCPar e=cast_expr(r,pe)
1285       { Ast0.wrap(Ast0.Cast (P.clt2mcode "(" lp, t,
1286                              P.clt2mcode ")" rp, e)) }
1287
1288 unary_expr(r,pe):
1289     postfix_expr(r,pe)                   { $1 }
1290   | TInc unary_expr(r,pe)
1291       { Ast0.wrap(Ast0.Infix ($2, P.clt2mcode Ast.Inc $1)) }
1292   | TDec unary_expr(r,pe)
1293       { Ast0.wrap(Ast0.Infix ($2, P.clt2mcode Ast.Dec $1)) }
1294   | unary_op cast_expr(r,pe)
1295       { let mcode = $1 in Ast0.wrap(Ast0.Unary($2, mcode)) }
1296   | TBang unary_expr(r,pe)
1297       { let mcode = P.clt2mcode Ast.Not $1 in
1298       Ast0.wrap(Ast0.Unary($2, mcode)) }
1299   | TSizeof unary_expr(r,pe)
1300       { Ast0.wrap(Ast0.SizeOfExpr (P.clt2mcode "sizeof" $1, $2)) }
1301   | s=TSizeof lp=TOPar t=ctype rp=TCPar
1302       { Ast0.wrap(Ast0.SizeOfType (P.clt2mcode "sizeof" s,
1303                                    P.clt2mcode "(" lp,t,
1304                                    P.clt2mcode ")" rp)) }
1305
1306 unary_op: TAnd    { P.clt2mcode Ast.GetRef $1 }
1307         | TMul    { P.clt2mcode Ast.DeRef $1 }
1308         | TPlus   { P.clt2mcode Ast.UnPlus $1 }
1309         | TMinus  { P.clt2mcode Ast.UnMinus $1 }
1310         | TTilde  { P.clt2mcode Ast.Tilde $1 }
1311
1312 postfix_expr(r,pe):
1313    primary_expr(r,pe)                            { $1 }
1314  | postfix_expr(r,pe) TOCro eexpr TCCro
1315      { Ast0.wrap(Ast0.ArrayAccess ($1,P.clt2mcode "[" $2,$3,
1316                                        P.clt2mcode "]" $4)) }
1317  | postfix_expr(r,pe) TDot   ident
1318      { Ast0.wrap(Ast0.RecordAccess($1, P.clt2mcode "." $2, $3)) }
1319  | postfix_expr(r,pe) TPtrOp ident
1320      { Ast0.wrap(Ast0.RecordPtAccess($1, P.clt2mcode "->" $2,
1321                                      $3)) }
1322  | postfix_expr(r,pe) TInc
1323      { Ast0.wrap(Ast0.Postfix ($1, P.clt2mcode Ast.Inc $2)) }
1324  | postfix_expr(r,pe) TDec
1325      { Ast0.wrap(Ast0.Postfix ($1, P.clt2mcode Ast.Dec $2)) }
1326  | postfix_expr(r,pe) TOPar eexpr_list_option TCPar
1327      { Ast0.wrap(Ast0.FunCall($1,P.clt2mcode "(" $2,
1328                               $3,
1329                               P.clt2mcode ")" $4)) }
1330
1331 primary_expr(recurser,primary_extra):
1332    func_ident   { Ast0.wrap(Ast0.Ident($1)) }
1333  | TInt
1334      { let (x,clt) = $1 in
1335      Ast0.wrap(Ast0.Constant (P.clt2mcode (Ast.Int x) clt)) }
1336  | TFloat
1337      { let (x,clt) = $1 in
1338      Ast0.wrap(Ast0.Constant (P.clt2mcode (Ast.Float x) clt)) }
1339  | TString
1340      { let (x,clt) = $1 in
1341      Ast0.wrap(Ast0.Constant (P.clt2mcode (Ast.String x) clt)) }
1342  | TChar
1343      { let (x,clt) = $1 in
1344      Ast0.wrap(Ast0.Constant (P.clt2mcode (Ast.Char x) clt)) }
1345  | TMetaConst
1346      { let (nm,constraints,pure,ty,clt) = $1 in
1347      Ast0.wrap
1348        (Ast0.MetaExpr(P.clt2mcode nm clt,constraints,ty,Ast.CONST,pure)) }
1349  | TMetaErr
1350      { let (nm,constraints,pure,clt) = $1 in
1351      Ast0.wrap(Ast0.MetaErr(P.clt2mcode nm clt,constraints,pure)) }
1352  | TMetaExp
1353      { let (nm,constraints,pure,ty,clt) = $1 in
1354      Ast0.wrap
1355        (Ast0.MetaExpr(P.clt2mcode nm clt,constraints,ty,Ast.ANY,pure)) }
1356  | TMetaIdExp
1357      { let (nm,constraints,pure,ty,clt) = $1 in
1358      Ast0.wrap
1359        (Ast0.MetaExpr(P.clt2mcode nm clt,constraints,ty,Ast.ID,pure)) }
1360  | TMetaLocalIdExp
1361      { let (nm,constraints,pure,ty,clt) = $1 in
1362      Ast0.wrap
1363        (Ast0.MetaExpr(P.clt2mcode nm clt,constraints,ty,Ast.LocalID,pure)) }
1364  | TOPar eexpr TCPar
1365      { Ast0.wrap(Ast0.Paren(P.clt2mcode "(" $1,$2,
1366                             P.clt2mcode ")" $3)) }
1367  | TOPar0 midzero_list(recurser,eexpr) TCPar0
1368      { let (mids,code) = $2 in
1369        Ast0.wrap(Ast0.DisjExpr(P.clt2mcode "(" $1,
1370                                code, mids,
1371                                P.clt2mcode ")" $3)) }
1372  | primary_extra { $1 }
1373
1374 expr_dots(dotter):
1375     r=no_dot_start_end(dexpr,edots_when(dotter,eexpr)) { r }
1376
1377 // used in NEST
1378 no_dot_start_end(grammar,dotter):
1379   g=grammar dg=list(pair(dotter,grammar))
1380   { function dot_builder ->
1381       g :: (List.concat(List.map (function (d,g) -> [dot_builder d;g]) dg)) }
1382
1383 /*****************************************************************************/
1384
1385 pure_ident:
1386      TIdent { $1 }
1387
1388 meta_ident:
1389        TRuleName TDot pure_ident { (Some $1,P.id2name $3) }
1390
1391 pure_ident_or_meta_ident:
1392        pure_ident                { (None,P.id2name $1) }
1393      | meta_ident                { $1 }
1394      | Tlist                     { (None,"list") }
1395      | TError                    { (None,"error") }
1396      | TType                     { (None,"type") }
1397      | TName                     { (None,"name") }
1398
1399 pure_ident_or_meta_ident_with_not_eq(not_eq):
1400        i=pure_ident_or_meta_ident l=loption(not_eq) { (i,l) }
1401
1402 not_eq:
1403        TNotEq i=pure_ident
1404          { (if !Data.in_iso
1405            then failwith "constraints not allowed in iso file");
1406            (if !Data.in_generating
1407            (* pb: constraints not stored with metavars; too lazy to search for
1408               them in the pattern *)
1409            then failwith "constraints not allowed in a generated rule file");
1410            [Ast0.wrap(Ast0.Id(P.id2mcode i))] }
1411      | TNotEq TOBrace l=comma_list(pure_ident) TCBrace
1412          { (if !Data.in_iso
1413            then failwith "constraints not allowed in iso file");
1414            (if !Data.in_generating
1415            then failwith "constraints not allowed in a generated rule file");
1416            List.map (function i -> Ast0.wrap(Ast0.Id(P.id2mcode i))) l }
1417
1418 not_eqe:
1419        TNotEq i=pure_ident
1420          { (if !Data.in_iso
1421            then failwith "constraints not allowed in iso file");
1422            (if !Data.in_generating
1423            then failwith "constraints not allowed in a generated rule file");
1424            [Ast0.wrap(Ast0.Ident(Ast0.wrap(Ast0.Id(P.id2mcode i))))] }
1425      | TNotEq TOBrace l=comma_list(pure_ident) TCBrace
1426          { (if !Data.in_iso
1427            then failwith "constraints not allowed in iso file");
1428            (if !Data.in_generating
1429            then failwith "constraints not allowed in a generated rule file");
1430            List.map
1431              (function i ->
1432                Ast0.wrap(Ast0.Ident(Ast0.wrap(Ast0.Id(P.id2mcode i)))))
1433              l }
1434
1435 not_ceq:
1436        TNotEq i=ident_or_const
1437          { (if !Data.in_iso
1438            then failwith "constraints not allowed in iso file");
1439            (if !Data.in_generating
1440            then failwith "constraints not allowed in a generated rule file");
1441            [i] }
1442      | TNotEq TOBrace l=comma_list(ident_or_const) TCBrace
1443          { (if !Data.in_iso
1444            then failwith "constraints not allowed in iso file");
1445            (if !Data.in_generating
1446            then failwith "constraints not allowed in a generated rule file");
1447            l }
1448
1449 ident_or_const:
1450        i=pure_ident { Ast0.wrap(Ast0.Ident(Ast0.wrap(Ast0.Id(P.id2mcode i)))) }
1451      | TInt
1452          { let (x,clt) = $1 in
1453          Ast0.wrap(Ast0.Constant (P.clt2mcode (Ast.Int x) clt)) }
1454
1455 not_pos:
1456        TNotEq i=meta_ident
1457          { (if !Data.in_iso
1458            then failwith "constraints not allowed in iso file");
1459            (if !Data.in_generating
1460            then failwith "constraints not allowed in a generated rule file");
1461            match i with
1462              (None,_) -> failwith "constraint must be an inherited variable"
1463            | (Some rule,name) ->
1464                let i = (rule,name) in
1465                P.check_meta(Ast.MetaPosDecl(Ast.NONE,i));
1466                [i] }
1467      | TNotEq TOBrace l=comma_list(meta_ident) TCBrace
1468          { (if !Data.in_iso
1469            then failwith "constraints not allowed in iso file");
1470            (if !Data.in_generating
1471            then failwith "constraints not allowed in a generated rule file");
1472            List.map
1473              (function
1474                  (None,_) ->
1475                    failwith "constraint must be an inherited variable"
1476                | (Some rule,name) ->
1477                    let i = (rule,name) in
1478                    P.check_meta(Ast.MetaPosDecl(Ast.NONE,i));
1479                    i)
1480              l }
1481
1482 func_ident: pure_ident
1483          { Ast0.wrap(Ast0.Id(P.id2mcode $1)) }
1484      | TMetaId
1485          { let (nm,constraints,pure,clt) = $1 in
1486          Ast0.wrap(Ast0.MetaId(P.clt2mcode nm clt,constraints,pure)) }
1487      | TMetaFunc
1488          { let (nm,constraints,pure,clt) = $1 in
1489          Ast0.wrap(Ast0.MetaFunc(P.clt2mcode nm clt,constraints,pure)) }
1490      | TMetaLocalFunc
1491          { let (nm,constraints,pure,clt) = $1 in
1492          Ast0.wrap
1493            (Ast0.MetaLocalFunc(P.clt2mcode nm clt,constraints,pure)) }
1494
1495 ident: pure_ident
1496          { Ast0.wrap(Ast0.Id(P.id2mcode $1)) }
1497      | TMetaId
1498          { let (nm,constraints,pure,clt) = $1 in
1499          Ast0.wrap(Ast0.MetaId(P.clt2mcode nm clt,constraints,pure)) }
1500
1501 decl_ident:
1502        TDeclarerId
1503          { Ast0.wrap(Ast0.Id(P.id2mcode $1)) }
1504      | TMetaDeclarer
1505          { let (nm,constraints,pure,clt) = $1 in
1506          Ast0.wrap(Ast0.MetaId(P.clt2mcode nm clt,constraints,pure)) }
1507
1508 iter_ident:
1509        TIteratorId
1510          { Ast0.wrap(Ast0.Id(P.id2mcode $1)) }
1511      | TMetaIterator
1512          { let (nm,constraints,pure,clt) = $1 in
1513          Ast0.wrap(Ast0.MetaId(P.clt2mcode nm clt,constraints,pure)) }
1514
1515 typedef_ident:
1516        pure_ident
1517          { Ast0.wrap(Ast0.TypeName(P.id2mcode $1)) }
1518      | TMetaType
1519          { let (nm,pure,clt) = $1 in
1520          Ast0.wrap(Ast0.MetaType(P.clt2mcode nm clt,pure)) }
1521
1522 /*****************************************************************************/
1523
1524 decl_list(decl):
1525   /* empty */ { Ast0.wrap(Ast0.DOTS([])) }
1526 | decl_list_start(decl)
1527      {let circle x =
1528        match Ast0.unwrap x with Ast0.Pcircles(_) -> true | _ -> false in
1529      if List.exists circle $1
1530      then Ast0.wrap(Ast0.CIRCLES($1))
1531      else Ast0.wrap(Ast0.DOTS($1)) }
1532
1533 decl_list_start(decl):
1534   one_dec(decl)  { [$1] }
1535 | one_dec(decl) TComma decl_list_start(decl)
1536     { $1::Ast0.wrap(Ast0.PComma(P.clt2mcode "," $2))::$3 }
1537 | TEllipsis list(comma_decls(TEllipsis,decl))
1538     { Ast0.wrap(Ast0.Pdots(P.clt2mcode "..." $1))::
1539       (List.concat(List.map (function x -> x (P.mkpdots "...")) $2)) }
1540
1541 one_dec(decl):
1542   decl  { $1 }
1543 | TMetaParamList
1544     { let (nm,lenname,pure,clt) = $1 in
1545     let nm = P.clt2mcode nm clt in
1546     let lenname =
1547       match lenname with
1548         Some nm -> Some(P.clt2mcode nm clt)
1549       | None -> None in
1550     Ast0.wrap(Ast0.MetaParamList(nm,lenname,pure)) }
1551
1552 comma_decls(dotter,decl):
1553   TComma dotter
1554     { function dot_builder ->
1555       [Ast0.wrap(Ast0.PComma(P.clt2mcode "," $1));
1556         dot_builder $2] }
1557 | TComma one_dec(decl)
1558     { function dot_builder ->
1559       [Ast0.wrap(Ast0.PComma(P.clt2mcode "," $1)); $2] }
1560
1561 /* ---------------------------------------------------------------------- */
1562
1563 error_words:
1564     TError TWords TEq TOCro cl=comma_list(dexpr) TCCro
1565       { [Ast0.wrap(Ast0.ERRORWORDS(cl))] }
1566
1567 /* ---------------------------------------------------------------------- */
1568 /* sequences of statements and expressions */
1569
1570 /* There are number of cases that must be considered:
1571
1572 1. Top level:
1573    Dots and nests allowed at the beginning or end
1574    Expressions allowed at the beginning or end
1575    One function allowed, by itself
1576 2. A function body:
1577    Dots and nests allowed at the beginning or end
1578    Expressions not allowed at the beginning or end
1579    Functions not allowed
1580 3. The body of a nest:
1581    Dots and nests not allowed at the beginning or end
1582    Expressions allowed at the beginning or end
1583    Functions not allowed
1584 4. Whencode:
1585    Dots and nests not allowed at the beginning but allowed at the end
1586    Expressions allowed at the beginning or end
1587    Functions not allowed
1588
1589 These are implemented by the rules minus_toplevel_sequence,
1590 plus_toplevel_sequence, function_body_sequence, nest_body_sequence, and
1591 when_body_sequence.
1592 */
1593 /* ------------------------------------------------------------------------ */
1594 /* Minus top level */
1595
1596 /* doesn't allow only ... */
1597 minus_start:
1598   fundecl                { [Ast0.wrap(Ast0.DECL($1))] }
1599 | ctype                  { [Ast0.wrap(Ast0.OTHER(Ast0.wrap(Ast0.Ty($1))))] }
1600 | top_init          { [Ast0.wrap(Ast0.OTHER(Ast0.wrap(Ast0.TopInit($1))))] }
1601 | toplevel_seq_startne(toplevel_after_dots_init)
1602     { List.map (function x -> Ast0.wrap(Ast0.OTHER(x))) $1 }
1603
1604 toplevel_seq_startne(after_dots_init):
1605   a=stm_dots_ell b=after_dots_init           { a::b }
1606 | a=stm_dots_nest b=after_dots_init           { a::b }
1607 | a=stm_dots_nest                      { [a] }
1608 | expr toplevel_after_exp            { (Ast0.wrap(Ast0.Exp($1)))::$2 }
1609 | decl_statement_expr toplevel_after_stm  { $1@$2 }
1610
1611 toplevel_seq_start(after_dots_init):
1612   stm_dots after_dots_init           { $1::$2 }
1613 | expr toplevel_after_exp            { (Ast0.wrap(Ast0.Exp($1)))::$2 }
1614 | decl_statement_expr toplevel_after_stm  { $1@$2 }
1615
1616 toplevel_after_dots_init:
1617   TNothing toplevel_after_exp        {$2}
1618 | expr toplevel_after_exp            {(Ast0.wrap(Ast0.Exp($1)))::$2}
1619 | decl_statement_expr toplevel_after_stm  {$1@$2}
1620
1621 toplevel_after_exp:
1622   /* empty */                        {[]}
1623 | stm_dots toplevel_after_dots       {$1::$2}
1624
1625 toplevel_after_dots:
1626   /* empty */                        {[]}
1627 | TNothing toplevel_after_exp        {$2}
1628 | expr toplevel_after_exp            {(Ast0.wrap(Ast0.Exp($1)))::$2}
1629 | decl_statement_expr toplevel_after_stm  {$1@$2}
1630
1631 toplevel_after_stm:
1632   /* empty */                        {[]}
1633 | stm_dots toplevel_after_dots       {$1::$2}
1634 | decl_statement toplevel_after_stm  {$1@$2}
1635
1636 top_init:
1637   TOInit initialize_list TCBrace
1638     { Ast0.wrap(Ast0.InitList(P.clt2mcode "{" $1,$2,P.clt2mcode "}" $3)) }
1639
1640 /* ------------------------------------------------------------------------ */
1641 /* Plus top level */
1642
1643 /* does allow only ... also allows multiple top-level functions */
1644 plus_start:
1645   ctype                   { [Ast0.wrap(Ast0.OTHER(Ast0.wrap(Ast0.Ty($1))))] }
1646 | top_init           { [Ast0.wrap(Ast0.OTHER(Ast0.wrap(Ast0.TopInit($1))))] }
1647 | stm_dots plus_after_dots
1648                                           { (Ast0.wrap(Ast0.OTHER($1)))::$2 }
1649 | expr plus_after_exp
1650                      { (Ast0.wrap(Ast0.OTHER(Ast0.wrap(Ast0.Exp($1)))))::$2 }
1651 | fundecl plus_after_stm                     { Ast0.wrap(Ast0.DECL($1))::$2 }
1652 | decl_statement_expr plus_after_stm
1653                 { (List.map (function x -> Ast0.wrap(Ast0.OTHER(x))) $1)@$2 }
1654
1655 plus_after_exp:
1656   /* empty */                                                            {[]}
1657 | stm_dots plus_after_dots                { (Ast0.wrap(Ast0.OTHER($1)))::$2 }
1658
1659 plus_after_dots:
1660   /* empty */                                                            {[]}
1661 | TNothing plus_after_exp                                                {$2}
1662 | expr plus_after_exp
1663                      { (Ast0.wrap(Ast0.OTHER(Ast0.wrap(Ast0.Exp($1)))))::$2 }
1664 | fundecl plus_after_stm                     { Ast0.wrap(Ast0.DECL($1))::$2 }
1665 | decl_statement_expr plus_after_stm
1666                 { (List.map (function x -> Ast0.wrap(Ast0.OTHER(x))) $1)@$2 }
1667
1668 plus_after_stm:
1669   /* empty */                                                            {[]}
1670 | stm_dots plus_after_dots                { (Ast0.wrap(Ast0.OTHER($1)))::$2 }
1671 | fundecl plus_after_stm                     { Ast0.wrap(Ast0.DECL($1))::$2 }
1672 | decl_statement plus_after_stm
1673                 { (List.map (function x -> Ast0.wrap(Ast0.OTHER(x))) $1)@$2 }
1674
1675 /* ------------------------------------------------------------------------ */
1676 /* Function body */
1677
1678 fun_start:
1679   fun_after_stm  { Ast0.wrap(Ast0.DOTS($1)) }
1680
1681 fun_after_stm:
1682   /* empty */                  {[]}
1683 | stm_dots fun_after_dots      {$1::$2}
1684 | decl_statement fun_after_stm {$1@$2}
1685
1686 fun_after_dots:
1687   /* empty */                  {[]}
1688 | TNothing fun_after_exp       {$2}
1689 | expr fun_after_exp           {Ast0.wrap(Ast0.Exp($1))::$2}
1690 | decl_statement_expr fun_after_stm {$1@$2}
1691
1692 fun_after_exp:
1693   stm_dots fun_after_dots      {$1::$2}
1694
1695 /* hack to allow mixing statements and expressions in an or */
1696 fun_after_dots_or:
1697   /* empty */                  {[]}
1698 | TNothing fun_after_exp_or    {$2}
1699 | expr fun_after_exp_or        {Ast0.wrap(Ast0.Exp($1))::$2}
1700 | decl_statement_expr fun_after_stm {$1@$2}
1701
1702 fun_after_exp_or:
1703   /* empty */                  {[]}
1704 | stm_dots fun_after_dots      {$1::$2}
1705
1706 /* ------------------------------------------------------------------------ */
1707 /* Nest body */
1708
1709 nest_start:
1710   nest_after_dots  { Ast0.wrap(Ast0.DOTS($1)) }
1711
1712 nest_after_dots:
1713   decl_statement_expr nest_after_stm {$1@$2}
1714 | TNothing nest_after_exp       {$2}
1715 | expr nest_after_exp           {(Ast0.wrap(Ast0.Exp($1)))::$2}
1716
1717 nest_after_stm:
1718   /* empty */                   {[]}
1719 | stm_dots nest_after_dots      {$1::$2}
1720 | decl_statement nest_after_stm {$1@$2}
1721
1722 nest_after_exp:
1723   /* empty */                   {[]}
1724 | stm_dots nest_after_dots      {$1::$2}
1725
1726 /* ------------------------------------------------------------------------ */
1727 /*Whencode*/
1728
1729 when_start:
1730   expr toplevel_after_exp
1731     { Ast0.wrap(Ast0.DOTS((Ast0.wrap(Ast0.Exp($1)))::$2)) }
1732 | decl_statement toplevel_after_stm
1733     { Ast0.wrap(Ast0.DOTS($1@$2)) }
1734
1735 /* ---------------------------------------------------------------------- */
1736
1737 eexpr_list:
1738   eexpr_list_start
1739      {let circle x =
1740        match Ast0.unwrap x with Ast0.Ecircles(_) -> true | _ -> false in
1741      let star x =
1742        match Ast0.unwrap x with Ast0.Estars(_) -> true | _ -> false in
1743      if List.exists circle $1
1744      then Ast0.wrap(Ast0.CIRCLES($1))
1745      else
1746        if List.exists star $1
1747        then Ast0.wrap(Ast0.STARS($1))
1748        else Ast0.wrap(Ast0.DOTS($1)) }
1749
1750 /* arg expr.  may contain a type or a explist metavariable */
1751 aexpr:
1752     eexpr
1753       { Ast0.set_arg_exp $1 }
1754   | TMetaExpList
1755       { let (nm,lenname,pure,clt) = $1 in
1756       let nm = P.clt2mcode nm clt in
1757       let lenname =
1758         match lenname with
1759           Some nm -> Some(P.clt2mcode nm clt)
1760         | None -> None in
1761       Ast0.wrap(Ast0.MetaExprList(nm,lenname,pure)) }
1762   | ctype
1763       { Ast0.set_arg_exp(Ast0.wrap(Ast0.TypeExp($1))) }
1764
1765 eexpr_list_start:
1766     aexpr { [$1] }
1767   | aexpr TComma eexpr_list_start
1768       { $1::Ast0.wrap(Ast0.EComma(P.clt2mcode "," $2))::$3 }
1769
1770 comma_args(dotter):
1771   c=TComma d=dotter
1772     { function dot_builder ->
1773       [Ast0.wrap(Ast0.EComma(P.clt2mcode "," c)); dot_builder d] }
1774 | TComma aexpr
1775     { function dot_builder ->
1776       [Ast0.wrap(Ast0.EComma(P.clt2mcode "," $1)); $2] }
1777
1778 eexpr_list_option: eexpr_list { $1 }
1779          | /* empty */     { Ast0.wrap(Ast0.DOTS([])) }
1780
1781 /****************************************************************************/
1782
1783 // non-empty lists - drop separator
1784 comma_list(elem):
1785   separated_nonempty_list(TComma,elem) { $1 }
1786
1787 midzero_list(elem,aft):
1788   a=elem b=list(mzl(aft))
1789      { let (mids,code) = List.split b in (mids,(a::code)) }
1790
1791 mzl(elem):
1792   a=TMid0 b=elem { (P.clt2mcode "|" a, b) }
1793
1794 edots_when(dotter,when_grammar):
1795     d=dotter                                      { (d,None) }
1796   | d=dotter TWhen TNotEq w=when_grammar TLineEnd { (d,Some w) }
1797
1798 whens(when_grammar,simple_when_grammar):
1799     TWhen TNotEq w=when_grammar TLineEnd { [Ast0.WhenNot w] }
1800   | TWhen TEq w=simple_when_grammar TLineEnd { [Ast0.WhenAlways w] }
1801   | TWhen comma_list(any_strict) TLineEnd
1802       { List.map (function x -> Ast0.WhenModifier(x)) $2 }
1803   | TWhenTrue TNotEq e = eexpr TLineEnd { [Ast0.WhenNotTrue e] }
1804   | TWhenFalse TNotEq e = eexpr TLineEnd { [Ast0.WhenNotFalse e] }
1805
1806 any_strict:
1807     TAny    { Ast.WhenAny }
1808   | TStrict { Ast.WhenStrict }
1809   | TForall { Ast.WhenForall }
1810   | TExists { Ast.WhenExists }
1811
1812 /*****************************************************************************
1813 *
1814 *
1815 *****************************************************************************/
1816
1817 iso_main:
1818   TIsoExpression e1=dexpr el=list(iso(dexpr)) EOF
1819     { P.iso_adjust (function x -> Ast0.ExprTag x) e1 el }
1820 | TIsoArgExpression e1=dexpr el=list(iso(dexpr)) EOF
1821     { P.iso_adjust (function x -> Ast0.ArgExprTag x) e1 el }
1822 | TIsoTestExpression e1=dexpr el=list(iso(dexpr)) EOF
1823     { P.iso_adjust (function x -> Ast0.TestExprTag x) e1 el }
1824 | TIsoStatement s1=single_statement sl=list(iso(single_statement)) EOF
1825     { P.iso_adjust (function x -> Ast0.StmtTag x) s1 sl }
1826 | TIsoType t1=ctype tl=list(iso(ctype)) EOF
1827     { P.iso_adjust (function x -> Ast0.TypeCTag x) t1 tl }
1828 | TIsoTopLevel e1=nest_start el=list(iso(nest_start)) EOF
1829     { P.iso_adjust (function x -> Ast0.DotsStmtTag x) e1 el }
1830 | TIsoDeclaration d1=decl_var dl=list(iso(decl_var)) EOF
1831     { let check_one = function
1832         [x] -> x
1833       | _ ->
1834           raise
1835             (Semantic_cocci.Semantic
1836                "only one variable per declaration in an isomorphism rule") in
1837     let d1 = check_one d1 in
1838     let dl =
1839       List.map
1840         (function
1841             Common.Left x -> Common.Left(check_one x)
1842           | Common.Right x -> Common.Right(check_one x))
1843         dl in
1844     P.iso_adjust (function x -> Ast0.DeclTag x) d1 dl }
1845
1846 iso(term):
1847     TIso t=term { Common.Left t }
1848   | TRightIso t=term { Common.Right t }
1849
1850 /*****************************************************************************
1851 *
1852 *
1853 *****************************************************************************/
1854
1855 never_used: TPragma { () }
1856   | TPArob TMetaPos { () }
1857   | TScriptData     { () }
1858
1859 script_meta_main: py=pure_ident TShOp TRuleName TDot cocci=pure_ident TMPtVirg
1860   { (P.id2name py, ($3, P.id2name cocci)) }