[Linux-kernel-mentees] [PATCH 03/26] parsing_cocci: parser: Add direct_declarator/direct_abstract_d rules

Jaskaran Singh jaskaransingh7654321 at gmail.com
Thu Mar 19 05:11:56 UTC 2020


On Wed, 2020-03-18 at 18:31 +0100, Julia Lawall wrote:
> 
> On Mon, 16 Mar 2020, Jaskaran Singh wrote:
> 
> > The direct_declarator rule and the direct_abstract_d rule are
> > present in the C parser. Add similar rules to the SmPL parser so
> > that
> > declarators are parsed as they are in the C parser.
> > 
> > For the type ParenType, direct_declarator and direct_abstract_d
> > only
> > allow the following productions:
> > 
> > 	( * id  [ .* ] ) ( params )
> > 
> > i.e. a function pointer or an array of function pointers. The
> > compromise
> > is flexibility in the range of productions, mainly because
> > collateral
> > evolutions needed by having a flexible rule are very large and
> > distasteful.
> 
> It is not clear what is meant by flexible.  Can you give an example
> of
> what will not be supported?
> 

Well, it's mainly anything that uses ParenType for anything other than
a function pointer or an array of function pointers. Examples of
productions that aren't supported:

int (**x[])(params); // array of pointer to function pointer

int (*x[][])(params); // array of array of function pointers

int ((*x))(params); // ident wrapped in double parantheses

To be honest, I think the first two and similar ones (i.e. array of
array of ... pointer to pointer to ....) can be supported by
implementing some kind of loop, but don't know about other
productions.

Cheers,
Jaskaran.

> julia
> 
> > Replace usage of the older d_ident rule in the SmPL parser with the
> > above mentioned rules. All usages of d_ident, however, have not
> > been
> > removed due to reduce/reduce conflicts.
> > 
> > Remove rules/productions that parse function pointers with usage of
> > direct_declarator and direct_abstract_d.
> > 
> > Signed-off-by: Jaskaran Singh <jaskaransingh7654321 at gmail.com>
> > ---
> >  parsing_cocci/parser_cocci_menhir.mly | 239 +++++++++++++---------
> > ----
> >  1 file changed, 116 insertions(+), 123 deletions(-)
> > 
> > diff --git a/parsing_cocci/parser_cocci_menhir.mly
> > b/parsing_cocci/parser_cocci_menhir.mly
> > index 26958f63..fade830f 100644
> > --- a/parsing_cocci/parser_cocci_menhir.mly
> > +++ b/parsing_cocci/parser_cocci_menhir.mly
> > @@ -1116,33 +1116,17 @@ struct_decl_one:
> >  	{ let (mids,code) = t in
> >  	Ast0.wrap
> >  	  (Ast0.ConjField(P.id2mcode lp,code,mids, P.id2mcode rp)) }
> > -    | t=ctype d=d_ident_option bf=struct_bitfield? pv=TPtVirg
> > +    | t=ctype d=direct_decl_option(disj_ident) bf=struct_bitfield?
> > pv=TPtVirg
> >  	 { let (id,fn) = d in
> >  	 Ast0.wrap(Ast0.Field(fn t,id,bf,P.clt2mcode ";" pv)) }
> > -    | t=ctype lp1=TOPar st=TMul d=d_ident_option rp1=TCPar
> > -	lp2=TOPar p=decl_list(name_opt_decl) rp2=TCPar
> > -	bf=struct_bitfield? pv=TPtVirg
> > -        { let (id,fn) = d in
> > -        let t =
> > -	  Ast0.wrap
> > -	    (Ast0.FunctionPointer
> > -	       (t,P.clt2mcode "(" lp1,P.clt2mcode "*" st,P.clt2mcode
> > ")" rp1,
> > -		P.clt2mcode "(" lp2,p,P.clt2mcode ")" rp2)) in
> > -        Ast0.wrap(Ast0.Field(fn t,id,bf,P.clt2mcode ";" pv)) }
> > -     | cv=ioption(const_vol) i=pure_ident_or_symbol
> > d=d_ident_option
> > +    | cv=ioption(const_vol) i=pure_ident_or_symbol
> > +      d=direct_decl_option(disj_ident)
> >  	 bf=struct_bitfield?
> >  	 pv=TPtVirg
> >  	 { let (id,fn) = d in
> >  	 let idtype = P.make_cv cv (Ast0.wrap (Ast0.TypeName(P.id2mcode
> > i))) in
> >  	 Ast0.wrap(Ast0.Field(fn idtype,id,bf,P.clt2mcode ";" pv)) }
> > 
> > -d_ident_option:
> > -	 { None, (fun x -> x) }
> > -     | d=d_ident {
> > -       let (id, fn) = d in
> > -       (Some id, fn)
> > -    }
> > -
> >  struct_bitfield:
> >     c=TDotDot e=expr { (P.clt2mcode ":" c, e) }
> > 
> > @@ -1529,17 +1513,9 @@ storage:
> >         | s=Tregister    { P.clt2mcode Ast.Register s }
> >         | s=Textern      { P.clt2mcode Ast.Extern s }
> > 
> > -decl: t=ctype i=disj_ident a=list(array_dec)
> > -	{ let t = P.arrayify t a in Ast0.wrap(Ast0.Param(t, Some i)) }
> > +decl: t=ctype d=direct_declarator(disj_ident)
> > +	{ let (i,fn) = d in Ast0.wrap(Ast0.Param(fn t, Some i)) }
> >      | t=ctype { (*verify in FunDecl*) Ast0.wrap(Ast0.Param(t,
> > None)) }
> > -    | t=ctype lp=TOPar s=TMul i=disj_ident rp=TCPar
> > -	lp1=TOPar d=decl_list(name_opt_decl) rp1=TCPar
> > -        { let fnptr =
> > -	  Ast0.wrap
> > -	    (Ast0.FunctionPointer
> > -	       (t,P.clt2mcode "(" lp,P.clt2mcode "*" s,P.clt2mcode ")"
> > rp,
> > -		P.clt2mcode "(" lp1,d,P.clt2mcode ")" rp1)) in
> > -	Ast0.wrap(Ast0.Param(fnptr, Some i)) }
> >      | TMetaParam
> >  	{ let (nm,cstr,pure,clt) = $1 in
> >  	Ast0.wrap(Ast0.MetaParam(P.clt2mcode nm clt,cstr,pure)) }
> > @@ -1547,14 +1523,6 @@ decl: t=ctype i=disj_ident a=list(array_dec)
> > 
> >  name_opt_decl:
> >        decl  { $1 }
> > -    | t=ctype lp=TOPar s=TMul rp=TCPar
> > -	lp1=TOPar d=decl_list(name_opt_decl) rp1=TCPar
> > -        { let fnptr =
> > -	  Ast0.wrap
> > -	    (Ast0.FunctionPointer
> > -	       (t,P.clt2mcode "(" lp,P.clt2mcode "*" s,P.clt2mcode ")"
> > rp,
> > -		P.clt2mcode "(" lp1,d,P.clt2mcode ")" rp1)) in
> > -	Ast0.wrap(Ast0.Param(fnptr, None)) }
> > 
> >  const_vol:
> >        Tconst       { P.clt2mcode Ast.Const $1 }
> > @@ -1684,13 +1652,15 @@ decl_var:
> >      t=ctype pv=TPtVirg
> >        { [Ast0.wrap(Ast0.TyDecl(t,P.clt2mcode ";" pv))] }
> >    | TMetaDecl { [P.meta_decl $1] }
> > -  | s=ioption(storage) t=ctype d=comma_list(d_ident) pv=TPtVirg
> > +  | s=ioption(storage) t=ctype
> > +      d=comma_list(direct_declarator(disj_ident)) pv=TPtVirg
> >        { List.map
> >  	  (function (id,fn) ->
> >  	    Ast0.wrap(Ast0.UnInit(s,fn t,id,[],P.clt2mcode ";" pv)))
> >  	  d }
> >    | f=funproto { [f] }
> > -  | s=ioption(storage) t=ctype d=d_ident a=attr_list q=TEq
> > e=initialize
> > +  | s=ioption(storage) t=ctype d=direct_declarator(disj_ident)
> > +    a=attr_list q=TEq e=initialize
> >        pv=TPtVirg
> >        {let (id,fn) = d in
> >        [Ast0.wrap
> > @@ -1711,18 +1681,6 @@ decl_var:
> >        let idtype = P.make_cv cv (Ast0.wrap
> > (Ast0.TypeName(P.id2mcode i))) in
> >        [Ast0.wrap(Ast0.Init(s,fn idtype,id,a,P.clt2mcode "=" q,e,
> >  			   P.clt2mcode ";" pv))] }
> > -  /* function pointer type */
> > -  | s=ioption(storage)
> > -    t=ctype lp1=TOPar st=TMul d=d_ident rp1=TCPar
> > -    lp2=TOPar p=decl_list(name_opt_decl) rp2=TCPar
> > -    pv=TPtVirg
> > -      { let (id,fn) = d in
> > -        let t =
> > -	  Ast0.wrap
> > -	    (Ast0.FunctionPointer
> > -	       (t,P.clt2mcode "(" lp1,P.clt2mcode "*" st,P.clt2mcode
> > ")" rp1,
> > -		P.clt2mcode "(" lp2,p,P.clt2mcode ")" rp2)) in
> > -        [Ast0.wrap(Ast0.UnInit(s,fn t,id,[],P.clt2mcode ";" pv))]
> > }
> >    | s=ioption(storage) d=decl_ident o=TOPar e=eexpr_list_option
> > c=TCPar
> >        p=TPtVirg
> >        { [Ast0.wrap(Ast0.MacroDecl(s,d,P.clt2mcode "(" o,e,
> > @@ -1735,56 +1693,25 @@ decl_var:
> >  	       (s,d,P.clt2mcode "(" o,e,
> >  		P.clt2mcode ")" c,P.clt2mcode "=" q,i,
> >  		P.clt2mcode ";" p))] }
> > -  | s=ioption(storage)
> > -    t=ctype lp1=TOPar st=TMul d=d_ident rp1=TCPar
> > -    lp2=TOPar p=decl_list(name_opt_decl) rp2=TCPar
> > -    q=TEq e=initialize pv=TPtVirg
> > -      { let (id,fn) = d in
> > -        let t =
> > -	  Ast0.wrap
> > -	    (Ast0.FunctionPointer
> > -	       (t,P.clt2mcode "(" lp1,P.clt2mcode "*" st,P.clt2mcode
> > ")" rp1,
> > -		P.clt2mcode "(" lp2,p,P.clt2mcode ")" rp2)) in
> > -      [Ast0.wrap
> > -	  (Ast0.Init(s,fn t,id,[],P.clt2mcode "=" q,e,P.clt2mcode ";"
> > pv))]}
> > -  | s=Ttypedef t=typedef_ctype id=comma_list(typedef_ident)
> > pv=TPtVirg
> > +  | s=Ttypedef t=typedef_ctype
> > +      d=comma_list(direct_declarator(typedef_ident)) pv=TPtVirg
> >        { let s = P.clt2mcode "typedef" s in
> >          List.map
> > -	  (function id ->
> > -	    Ast0.wrap(Ast0.Typedef(s,t,id,P.clt2mcode ";" pv)))
> > -	  id }
> > -  | s=Ttypedef t=typedef_ctype id=typedef_ident
> > -      l=TOCro i=eexpr r=TCCro pv=TPtVirg
> > -      { let s = P.clt2mcode "typedef" s in
> > -        let t = P.arrayify t [(l,Some i,r)] in
> > -	[Ast0.wrap(Ast0.Typedef(s,t,id,P.clt2mcode ";" pv))] }
> > -  | s=Ttypedef t=typedef_ctype id=typedef_ident
> > -      l=TOCro i=eexpr r=TCCro
> > -      l2=TOCro i2=eexpr r2=TCCro pv=TPtVirg
> > -      { let s = P.clt2mcode "typedef" s in
> > -        let t = P.arrayify t [(l,Some i,r)] in
> > -        let t = P.arrayify t [(l2,Some i2,r2)] in
> > -	[Ast0.wrap(Ast0.Typedef(s,t,id,P.clt2mcode ";" pv))] }
> > -  | s=Ttypedef
> > -    t=typedef_ctype lp1=TOPar st=TMul id=typedef_ident rp1=TCPar
> > -    lp2=TOPar p=decl_list(name_opt_decl) rp2=TCPar pv=TPtVirg
> > -      { let s = P.clt2mcode "typedef" s in
> > -        let t =
> > -	  Ast0.wrap
> > -	    (Ast0.FunctionPointer
> > -	       (t,P.clt2mcode "(" lp1,P.clt2mcode "*" st,P.clt2mcode
> > ")" rp1,
> > -		P.clt2mcode "(" lp2,p,P.clt2mcode ")" rp2)) in
> > -	[Ast0.wrap(Ast0.Typedef(s,t,id,P.clt2mcode ";" pv))]}
> > +	  (function (id,fn) ->
> > +	    Ast0.wrap(Ast0.Typedef(s,fn t,id,P.clt2mcode ";" pv)))
> > +	  d }
> > 
> >  one_decl_var:
> >      t=ctype pv=TPtVirg
> >        { Ast0.wrap(Ast0.TyDecl(t,P.clt2mcode ";" pv)) }
> >    | TMetaDecl { P.meta_decl $1 }
> > -  | s=ioption(storage) t=ctype d=d_ident a=attr_list pv=TPtVirg
> > +  | s=ioption(storage) t=ctype d=direct_declarator(disj_ident)
> > +      a=attr_list pv=TPtVirg
> >        { let (id,fn) = d in
> >          Ast0.wrap(Ast0.UnInit(s,fn t,id,a,P.clt2mcode ";" pv)) }
> >    | f=funproto { f }
> > -  | s=ioption(storage) t=ctype d=d_ident a=attr_list q=TEq
> > e=initialize
> > +  | s=ioption(storage) t=ctype d=direct_declarator(disj_ident)
> > +      a=attr_list q=TEq e=initialize
> >        pv=TPtVirg
> >        { let (id,fn) = d in
> >        Ast0.wrap
> > @@ -1802,18 +1729,6 @@ one_decl_var:
> >        let idtype = P.make_cv cv (Ast0.wrap
> > (Ast0.TypeName(P.id2mcode i))) in
> >        Ast0.wrap(Ast0.Init(s,fn idtype,id,a,P.clt2mcode "=" q,e,
> >  			   P.clt2mcode ";" pv)) }
> > -  /* function pointer type */
> > -  | s=ioption(storage)
> > -    t=ctype lp1=TOPar st=TMul d=d_ident rp1=TCPar
> > -    lp2=TOPar p=decl_list(name_opt_decl) rp2=TCPar
> > -    pv=TPtVirg
> > -      { let (id,fn) = d in
> > -        let t =
> > -	  Ast0.wrap
> > -	    (Ast0.FunctionPointer
> > -	       (t,P.clt2mcode "(" lp1,P.clt2mcode "*" st,P.clt2mcode
> > ")" rp1,
> > -		P.clt2mcode "(" lp2,p,P.clt2mcode ")" rp2)) in
> > -        Ast0.wrap(Ast0.UnInit(s,fn t,id,[],P.clt2mcode ";" pv)) }
> >    | s=ioption(storage) d=decl_ident o=TOPar e=eexpr_list_option
> > c=TCPar
> >        p=TPtVirg
> >        { Ast0.wrap(Ast0.MacroDecl(s,d,P.clt2mcode "(" o,e,
> > @@ -1826,19 +1741,103 @@ one_decl_var:
> >                 (s,d,P.clt2mcode "(" o,e,
> >                  P.clt2mcode ")" c,P.clt2mcode "=" q,i,
> >                  P.clt2mcode ";" p)) }
> > -  | s=ioption(storage)
> > -    t=ctype lp1=TOPar st=TMul d=d_ident rp1=TCPar
> > -    lp2=TOPar p=decl_list(name_opt_decl) rp2=TCPar a=attr_list
> > -    q=TEq e=initialize pv=TPtVirg
> > -      { let (id,fn) = d in
> > -        let t =
> > -	  Ast0.wrap
> > -	    (Ast0.FunctionPointer
> > -	       (t,P.clt2mcode "(" lp1,P.clt2mcode "*" st,P.clt2mcode
> > ")" rp1,
> > -		P.clt2mcode "(" lp2,p,P.clt2mcode ")" rp2)) in
> > -      Ast0.wrap(Ast0.Init(s,fn t,id,a,P.clt2mcode "="
> > q,e,P.clt2mcode ";" pv))}
> > 
> > 
> > +direct_declarator(ident_type):
> > +    ident_type
> > +      { ($1, function x -> x) }
> > +  | o=TOPar m=list(TMul) d=direct_declarator(ident_type) c=TCPar
> > +      { let (id,fn) = d in
> > +        (id,
> > +         function t ->
> > +          let ty =  fn (P.pointerify t m) in
> > +          let _ =
> > +           match Ast0.unwrap ty with
> > +            Ast0.Pointer(ty1,_) ->
> > +             (match Ast0.unwrap ty1 with
> > +               Ast0.FunctionType(ty2,_,_,_) -> ()
> > +             | _ ->
> > +              raise (Semantic_cocci.Semantic "expected function
> > pointer"))
> > +           | Ast0.Array(ty1,_,_,_) ->
> > +              (match Ast0.unwrap ty1 with
> > +                Ast0.Pointer(ty2,_) ->(
> > +                 match Ast0.unwrap ty2 with
> > +                  Ast0.FunctionType(ty3,_,_,_) -> ()
> > +                 | _ ->
> > +                  raise (Semantic_cocci.Semantic "expected
> > function pointer"))
> > +             | _ ->
> > +              raise (Semantic_cocci.Semantic "expected function
> > pointer"))
> > +           | _ ->
> > +            raise (Semantic_cocci.Semantic "expected function
> > pointer") in
> > +          Ast0.wrap
> > +            (Ast0.ParenType
> > +               (P.clt2mcode "(" o,
> > +                ty,
> > +                P.clt2mcode ")" c))) }
> > +  | d=direct_declarator(ident_type) a=array_dec
> > +      { let (id,fn) = d in
> > +        (id, function t -> let r = P.arrayify t [a] in fn r) }
> > +  | d=direct_declarator(ident_type)
> > +      o=TOPar arglist=decl_list(name_opt_decl) c=TCPar
> > +      { let (id,fn) = d in
> > +        (id, function t ->
> > +              let r =
> > +               Ast0.wrap
> > +                (Ast0.FunctionType
> > +                  (t,P.clt2mcode "(" o,arglist,P.clt2mcode ")" c))
> > in fn r) }
> > +
> > +
> > +direct_abstract_d:
> > +    o=TOPar m=list(TMul) d=direct_abstract_d c=TCPar
> > +      { function t ->
> > +          let ty = d (P.pointerify t m) in
> > +          let _ =
> > +           match Ast0.unwrap ty with
> > +            Ast0.Pointer(ty1,_) ->
> > +             (match Ast0.unwrap ty1 with
> > +               Ast0.FunctionType(ty2,_,_,_) ->()
> > +             | _ ->
> > +              raise (Semantic_cocci.Semantic "expected function
> > pointer"))
> > +           | Ast0.Array(ty1,_,_,_) ->
> > +              (match Ast0.unwrap ty1 with
> > +                Ast0.Pointer(ty2,_) ->(
> > +                 match Ast0.unwrap ty2 with
> > +                  Ast0.FunctionType(ty3,_,_,_) -> ()
> > +                 | _ ->
> > +                  raise (Semantic_cocci.Semantic "expected
> > function pointer"))
> > +             | _ ->
> > +              raise (Semantic_cocci.Semantic "expected function
> > pointer"))
> > +           | _ ->
> > +            raise (Semantic_cocci.Semantic "expected function
> > pointer") in
> > +          Ast0.wrap
> > +            (Ast0.ParenType
> > +               (P.clt2mcode "(" o,
> > +                ty,
> > +                P.clt2mcode ")" c))
> > +      }
> > +  | a=array_dec
> > +      { function t -> P.arrayify t [a] }
> > +  | d=direct_abstract_d a=array_dec
> > +      { function t -> let r = P.arrayify t [a] in d r }
> > +  | o=TOPar arglist=decl_list(name_opt_decl) c=TCPar
> > +      { function t ->
> > +               Ast0.wrap
> > +                (Ast0.FunctionType
> > +                  (t,P.clt2mcode "(" o,arglist,P.clt2mcode ")" c))
> > }
> > +  | d=direct_abstract_d o=TOPar arglist=decl_list(name_opt_decl)
> > c=TCPar
> > +      { function t ->
> > +              let r =
> > +               Ast0.wrap
> > +                (Ast0.FunctionType
> > +                  (t,P.clt2mcode "(" o,arglist,P.clt2mcode ")" c))
> > in d r }
> > +
> > +
> > +direct_decl_option(ident_type):
> > +      { (None, function x -> x) }
> > +  | d=direct_declarator(ident_type)
> > +      { let (id,fn) = d in
> > +        (Some id, fn) }
> > +
> >  d_ident:
> >      disj_ident list(array_dec)
> >        { ($1, function t -> P.arrayify t $2) }
> > @@ -2151,16 +2150,10 @@ cast_expr(r,pe):
> >      unary_expr(r,pe)                      { $1 }
> >    | lp=TOPar t=ctype rp=TCPar e=cast_expr(r,pe)
> >        { Ast0.wrap(Ast0.Cast (P.clt2mcode "(" lp, t,
> > +                             P.clt2mcode ")" rp, e)) }
> > +  | lp=TOPar t=ctype d=direct_abstract_d rp=TCPar
> > e=cast_expr(r,pe)
> > +      { Ast0.wrap(Ast0.Cast (P.clt2mcode "(" lp, d t,
> >  			     P.clt2mcode ")" rp, e)) }
> > -  | lp=TOPar t=ctype lp1=TOPar s=TMul rp1=TCPar
> > -      lp2=TOPar d=decl_list(name_opt_decl) rp2=TCPar rp=TCPar
> > -      e=cast_expr(r,pe)
> > -      { let fnptr =
> > -	  Ast0.wrap
> > -	    (Ast0.FunctionPointer
> > -	       (t,P.clt2mcode "(" lp1,P.clt2mcode "*" s,P.clt2mcode ")"
> > rp1,
> > -		P.clt2mcode "(" lp2,d,P.clt2mcode ")" rp2)) in
> > -      Ast0.wrap(Ast0.Cast (P.clt2mcode "(" lp, fnptr, P.clt2mcode
> > ")" rp, e)) }
> > 
> >  unary_expr(r,pe):
> >      postfix_expr(r,pe)                   { $1 }
> > --
> > 2.21.1
> > 
> > 



More information about the Linux-kernel-mentees mailing list