X-Git-Url: https://git.hcoop.net/bpt/coccinelle.git/blobdiff_plain/1be43e1299fc61538d62349ca012514b28f8734f..3a31414346dd7d7e8baa4cb8b804a2d5e1797962:/parsing_cocci/ast0_cocci.ml
diff --git a/parsing_cocci/ast0_cocci.ml b/parsing_cocci/ast0_cocci.ml
index 5d9f214..f38cb00 100644
--- a/parsing_cocci/ast0_cocci.ml
+++ b/parsing_cocci/ast0_cocci.ml
@@ -1,26 +1,29 @@
(*
-* Copyright 2005-2008, Ecole des Mines de Nantes, University of Copenhagen
-* Yoann Padioleau, Julia Lawall, Rene Rydhof Hansen, Henrik Stuart, Gilles Muller
-* This file is part of Coccinelle.
-*
-* Coccinelle is free software: you can redistribute it and/or modify
-* it under the terms of the GNU General Public License as published by
-* the Free Software Foundation, according to version 2 of the License.
-*
-* Coccinelle is distributed in the hope that it will be useful,
-* but WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with Coccinelle. If not, see .
-*
-* The authors reserve the right to distribute this or future versions of
-* Coccinelle under other licenses.
-*)
+ * Copyright 2010, INRIA, University of Copenhagen
+ * Julia Lawall, Rene Rydhof Hansen, Gilles Muller, Nicolas Palix
+ * Copyright 2005-2009, Ecole des Mines de Nantes, University of Copenhagen
+ * Yoann Padioleau, Julia Lawall, Rene Rydhof Hansen, Henrik Stuart, Gilles Muller, Nicolas Palix
+ * This file is part of Coccinelle.
+ *
+ * Coccinelle is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, according to version 2 of the License.
+ *
+ * Coccinelle is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Coccinelle. If not, see .
+ *
+ * The authors reserve the right to distribute this or future versions of
+ * Coccinelle under other licenses.
+ *)
module Ast = Ast_cocci
+module TC = Type_cocci
(* --------------------------------------------------------------------- *)
(* Modified code *)
@@ -35,28 +38,38 @@ let default_token_info =
(* MIXED is like CONTEXT, since sometimes MIXED things have to revert to
CONTEXT - see insert_plus.ml *)
+type count = ONE (* + *) | MANY (* ++ *)
+
type mcodekind =
MINUS of (Ast.anything list list * token_info) ref
- | PLUS
+ | PLUS of Ast.count
| CONTEXT of (Ast.anything Ast.befaft * token_info * token_info) ref
| MIXED of (Ast.anything Ast.befaft * token_info * token_info) ref
-type info = { line_start : int; line_end : int;
- logical_start : int; logical_end : int;
+type position_info = { line_start : int; line_end : int;
+ logical_start : int; logical_end : int;
+ column : int; offset : int; }
+
+type info = { pos_info : position_info;
attachable_start : bool; attachable_end : bool;
mcode_start : mcodekind list; mcode_end : mcodekind list;
- column : int; offset : int;
(* the following are only for + code *)
- strings_before : string list; strings_after : string list }
-
-type 'a mcode = 'a * arity * info * mcodekind * meta_pos ref (* pos, - only *)
+ strings_before : (Ast.added_string * position_info) list;
+ strings_after : (Ast.added_string * position_info) list }
+
+(* adjacency index is incremented when we skip over dots or nest delimiters
+it is used in deciding how much to remove, when two adjacent code tokens are
+removed. *)
+type 'a mcode =
+ 'a * arity * info * mcodekind * meta_pos ref (* pos, - only *) *
+ int (* adjacency_index *)
(* int ref is an index *)
and 'a wrap =
{ node : 'a;
info : info;
index : int ref;
mcodekind : mcodekind ref;
- exp_ty : Type_cocci.typeC option ref; (* only for expressions *)
+ exp_ty : TC.typeC option ref; (* only for expressions *)
bef_aft : dots_bef_aft; (* only for statements *)
true_if_arg : bool; (* true if "arg_exp", only for exprs *)
true_if_test : bool; (* true if "test position", only for exprs *)
@@ -90,10 +103,10 @@ and 'a dots = 'a base_dots wrap
(* Identifier *)
and base_ident =
- Id of string mcode
- | MetaId of Ast.meta_name mcode * ident list * pure
- | MetaFunc of Ast.meta_name mcode * ident list * pure
- | MetaLocalFunc of Ast.meta_name mcode * ident list * pure
+ Id of string mcode
+ | MetaId of Ast.meta_name mcode * Ast.idconstraint * pure
+ | MetaFunc of Ast.meta_name mcode * Ast.idconstraint * pure
+ | MetaLocalFunc of Ast.meta_name mcode * Ast.idconstraint * pure
| OptIdent of ident
| UniqueIdent of ident
@@ -102,7 +115,7 @@ and ident = base_ident wrap
(* --------------------------------------------------------------------- *)
(* Expression *)
-and base_expression =
+and base_expression =
Ident of ident
| Constant of Ast.constant mcode
| FunCall of expression * string mcode (* ( *) *
@@ -128,9 +141,9 @@ and base_expression =
| SizeOfType of string mcode (* sizeof *) * string mcode (* ( *) *
typeC * string mcode (* ) *)
| TypeExp of typeC (* type name used as an expression, only in args *)
- | MetaErr of Ast.meta_name mcode * expression list * pure
- | MetaExpr of Ast.meta_name mcode * expression list *
- Type_cocci.typeC list option * Ast.form * pure
+ | MetaErr of Ast.meta_name mcode * constraints * pure
+ | MetaExpr of Ast.meta_name mcode * constraints *
+ TC.typeC list option * Ast.form * pure
| MetaExprList of Ast.meta_name mcode (* only in arg lists *) *
listlen * pure
| EComma of string mcode (* only in arg lists *)
@@ -146,15 +159,24 @@ and base_expression =
and expression = base_expression wrap
-and listlen = Ast.meta_name mcode option
+and constraints =
+ NoConstraint
+ | NotIdCstrt of Ast.reconstraint
+ | NotExpCstrt of expression list
+ | SubExpCstrt of Ast.meta_name list
+
+and listlen =
+ MetaListLen of Ast.meta_name mcode
+ | CstListLen of int
+ | AnyListLen
(* --------------------------------------------------------------------- *)
(* Types *)
-and base_typeC =
+and base_typeC =
ConstVol of Ast.const_vol mcode * typeC
- | BaseType of Ast.baseType mcode * Ast.sign mcode option
- | ImplicitInt of Ast.sign mcode
+ | BaseType of Ast.baseType * string mcode list
+ | Signed of Ast.sign mcode * typeC option
| Pointer of typeC * string mcode (* * *)
| FunctionPointer of typeC *
string mcode(* ( *)*string mcode(* * *)*string mcode(* ) *)*
@@ -164,6 +186,9 @@ and base_typeC =
string mcode (* ) *)
| Array of typeC * string mcode (* [ *) *
expression option * string mcode (* ] *)
+ | EnumName of string mcode (*enum*) * ident option (* name *)
+ | EnumDef of typeC (* either StructUnionName or metavar *) *
+ string mcode (* { *) * expression dots * string mcode (* } *)
| StructUnionName of Ast.structUnion mcode * ident option (* name *)
| StructUnionDef of typeC (* either StructUnionName or metavar *) *
string mcode (* { *) * declaration dots * string mcode (* } *)
@@ -182,7 +207,12 @@ and typeC = base_typeC wrap
split out into multiple declarations of a single variable each. *)
and base_declaration =
- Init of Ast.storage mcode option * typeC * ident * string mcode (*=*) *
+ MetaDecl of Ast.meta_name mcode * pure (* variables *)
+ (* the following are kept separate from MetaDecls because ultimately
+ they don't match the same thin at all. Consider whether there
+ should be a separate type for fields, as in the C AST *)
+ | MetaField of Ast.meta_name mcode * pure (* structure fields *)
+ | Init of Ast.storage mcode option * typeC * ident * string mcode (*=*) *
initialiser * string mcode (*;*)
| UnInit of Ast.storage mcode option * typeC * ident * string mcode (* ; *)
| TyDecl of typeC * string mcode (* ; *)
@@ -202,24 +232,28 @@ and declaration = base_declaration wrap
(* Initializers *)
and base_initialiser =
- InitExpr of expression
- | InitList of string mcode (*{*) * initialiser_list * string mcode (*}*)
- | InitGccDotName of
- string mcode (*.*) * ident (* name *) * string mcode (*=*) *
+ MetaInit of Ast.meta_name mcode * pure
+ | InitExpr of expression
+ | InitList of string mcode (*{*) * initialiser_list * string mcode (*}*) *
+ (* true if ordered, as for array, false if unordered, as for struct *)
+ bool
+ | InitGccExt of
+ designator list (* name *) * string mcode (*=*) *
initialiser (* gccext: *)
| InitGccName of ident (* name *) * string mcode (*:*) *
initialiser
- | InitGccIndex of
- string mcode (*[*) * expression * string mcode (*]*) *
- string mcode (*=*) * initialiser
- | InitGccRange of
- string mcode (*[*) * expression * string mcode (*...*) *
- expression * string mcode (*]*) * string mcode (*=*) * initialiser
| IComma of string mcode (* , *)
| Idots of string mcode (* ... *) * initialiser option (* whencode *)
| OptIni of initialiser
| UniqueIni of initialiser
+and designator =
+ DesignatorField of string mcode (* . *) * ident
+ | DesignatorIndex of string mcode (* [ *) * expression * string mcode (* ] *)
+ | DesignatorRange of
+ string mcode (* [ *) * expression * string mcode (* ... *) *
+ expression * string mcode (* ] *)
+
and initialiser = base_initialiser wrap
and initialiser_list = initialiser dots
@@ -293,6 +327,7 @@ and base_statement =
statement * (info * mcodekind) (* after info *)
| Switch of string mcode (* switch *) * string mcode (* ( *) *
expression * string mcode (* ) *) * string mcode (* { *) *
+ statement (*decl*) dots *
case_line dots * string mcode (* } *)
| Break of string mcode (* break *) * string mcode (* ; *)
| Continue of string mcode (* continue *) * string mcode (* ; *)
@@ -323,6 +358,7 @@ and base_statement =
string mcode (* { *) * statement dots *
string mcode (* } *)
| Include of string mcode (* #include *) * Ast.inc_file mcode (* file *)
+ | Undef of string mcode (* #define *) * ident (* name *)
| Define of string mcode (* #define *) * ident (* name *) *
define_parameters (*params*) * statement dots
| OptStm of statement
@@ -347,6 +383,8 @@ and base_case_line =
Default of string mcode (* default *) * string mcode (*:*) * statement dots
| Case of string mcode (* case *) * expression * string mcode (*:*) *
statement dots
+ | DisjCase of string mcode * case_line list *
+ string mcode list (* the |s *) * string mcode
| OptCase of case_line
and case_line = base_case_line wrap
@@ -375,9 +413,14 @@ and parsed_rule =
CocciRule of
(rule * Ast.metavar list *
(string list * string list * Ast.dependency * string * Ast.exists)) *
- (rule * Ast.metavar list)
- | ScriptRule of
- string * Ast.dependency * (string * Ast.meta_name) list * string
+ (rule * Ast.metavar list) * Ast.ruletype
+ | ScriptRule of string (* name *) *
+ string * Ast.dependency *
+ (Ast.script_meta_name * Ast.meta_name * Ast.metavar) list *
+ Ast.meta_name list (*script vars*) *
+ string
+ | InitialScriptRule of string (* name *) *string * Ast.dependency * string
+ | FinalScriptRule of string (* name *) *string * Ast.dependency * string
(* --------------------------------------------------------------------- *)
@@ -423,17 +466,22 @@ let top x = TopTag x
(* --------------------------------------------------------------------- *)
(* Avoid cluttering the parser. Calculated in compute_lines.ml. *)
-let default_info _ = (* why is this a function? *)
+let pos_info =
{ line_start = -1; line_end = -1;
logical_start = -1; logical_end = -1;
+ column = -1; offset = -1; }
+
+let default_info _ = (* why is this a function? *)
+ { pos_info = pos_info;
attachable_start = true; attachable_end = true;
mcode_start = []; mcode_end = [];
- column = -1; offset = -1; strings_before = []; strings_after = [] }
+ strings_before = []; strings_after = [] }
let default_befaft _ =
MIXED(ref (Ast.NOTHING,default_token_info,default_token_info))
let context_befaft _ =
CONTEXT(ref (Ast.NOTHING,default_token_info,default_token_info))
+let minus_befaft _ = MINUS(ref ([],default_token_info))
let wrap x =
{ node = x;
@@ -458,23 +506,25 @@ let context_wrap x =
true_if_test_exp = false;
iso_info = [] }
let unwrap x = x.node
-let unwrap_mcode (x,_,_,_,_) = x
+let unwrap_mcode (x,_,_,_,_,_) = x
let rewrap model x = { model with node = x }
-let rewrap_mcode (_,arity,info,mcodekind,pos) x = (x,arity,info,mcodekind,pos)
+let rewrap_mcode (_,arity,info,mcodekind,pos,adj) x =
+ (x,arity,info,mcodekind,pos,adj)
let copywrap model x =
{ model with node = x; index = ref !(model.index);
mcodekind = ref !(model.mcodekind); exp_ty = ref !(model.exp_ty)}
-let get_pos (_,_,_,_,x) = !x
-let get_pos_ref (_,_,_,_,x) = x
-let set_pos pos (m,arity,info,mcodekind,_) = (m,arity,info,mcodekind,ref pos)
+let get_pos (_,_,_,_,x,_) = !x
+let get_pos_ref (_,_,_,_,x,_) = x
+let set_pos pos (m,arity,info,mcodekind,_,adj) =
+ (m,arity,info,mcodekind,ref pos,adj)
let get_info x = x.info
let set_info x info = {x with info = info}
-let get_line x = x.info.line_start
-let get_line_end x = x.info.line_end
+let get_line x = x.info.pos_info.line_start
+let get_line_end x = x.info.pos_info.line_end
let get_index x = !(x.index)
let set_index x i = x.index := i
let get_mcodekind x = !(x.mcodekind)
-let get_mcode_mcodekind (_,_,_,mcodekind,_) = mcodekind
+let get_mcode_mcodekind (_,_,_,mcodekind,_,_) = mcodekind
let get_mcodekind_ref x = x.mcodekind
let set_mcodekind x mk = x.mcodekind := mk
let set_type x t = x.exp_ty := t
@@ -489,7 +539,7 @@ let get_test_exp x = x.true_if_test_exp
let set_test_exp x = {x with true_if_test_exp = true}
let get_iso x = x.iso_info
let set_iso x i = if !Flag.track_iso_usage then {x with iso_info = i} else x
-let set_mcode_data data (_,ar,info,mc,pos) = (data,ar,info,mc,pos)
+let set_mcode_data data (_,ar,info,mc,pos,adj) = (data,ar,info,mc,pos,adj)
(* --------------------------------------------------------------------- *)
@@ -509,127 +559,164 @@ let undots d =
let rec ast0_type_to_type ty =
match unwrap ty with
- ConstVol(cv,ty) -> Type_cocci.ConstVol(const_vol cv,ast0_type_to_type ty)
- | BaseType(bty,None) ->
- Type_cocci.BaseType(baseType bty,None)
- | BaseType(bty,Some sgn) ->
- Type_cocci.BaseType(baseType bty,Some (sign sgn))
- | ImplicitInt(sgn) ->
- let bty = Type_cocci.IntType in
- Type_cocci.BaseType(bty,Some (sign sgn))
- | Pointer(ty,_) -> Type_cocci.Pointer(ast0_type_to_type ty)
+ ConstVol(cv,ty) -> TC.ConstVol(const_vol cv,ast0_type_to_type ty)
+ | BaseType(bty,strings) ->
+ TC.BaseType(baseType bty)
+ | Signed(sgn,None) ->
+ TC.SignedT(sign sgn,None)
+ | Signed(sgn,Some ty) ->
+ let bty = ast0_type_to_type ty in
+ TC.SignedT(sign sgn,Some bty)
+ | Pointer(ty,_) -> TC.Pointer(ast0_type_to_type ty)
| FunctionPointer(ty,_,_,_,_,params,_) ->
- Type_cocci.FunctionPointer(ast0_type_to_type ty)
+ TC.FunctionPointer(ast0_type_to_type ty)
| FunctionType _ -> failwith "not supported"
- | Array(ety,_,_,_) -> Type_cocci.Array(ast0_type_to_type ety)
- | StructUnionName(su,Some tag) ->
+ | Array(ety,_,_,_) -> TC.Array(ast0_type_to_type ety)
+ | EnumName(su,Some tag) ->
(match unwrap tag with
Id(tag) ->
- Type_cocci.StructUnionName(structUnion su,false,unwrap_mcode tag)
+ TC.EnumName(TC.Name(unwrap_mcode tag))
| MetaId(tag,_,_) ->
(Printf.printf
- "warning: struct/union with a metavariable name detected.\n";
+ "warning: enum with a metavariable name detected.\n";
Printf.printf
"For type checking assuming the name of the metavariable is the name of the type\n";
- let (rule,tag) = unwrap_mcode tag in
- Type_cocci.StructUnionName(structUnion su,true,rule^tag))
+ TC.EnumName(TC.MV(unwrap_mcode tag,TC.Unitary,false)))
+ | _ -> failwith "unexpected enum type name")
+ | EnumName(su,None) -> failwith "nameless enum - what to do???"
+ | EnumDef(ty,_,_,_) -> ast0_type_to_type ty
+ | StructUnionName(su,Some tag) ->
+ (match unwrap tag with
+ Id(tag) ->
+ TC.StructUnionName(structUnion su,TC.Name(unwrap_mcode tag))
+ | MetaId(tag,Ast.IdNoConstraint,_) ->
+ (Common.pr2
+ "warning: struct/union with a metavariable name detected.\n";
+ Common.pr2
+ "For type checking assuming the name of the metavariable is the name of the type\n";
+ TC.StructUnionName(structUnion su,
+ TC.MV(unwrap_mcode tag,TC.Unitary,false)))
+ | MetaId(tag,_,_) ->
+ (* would have to duplicate the type in type_cocci.ml?
+ perhaps polymorphism would help? *)
+ failwith "constraints not supported on struct type name"
| _ -> failwith "unexpected struct/union type name")
| StructUnionName(su,None) -> failwith "nameless structure - what to do???"
| StructUnionDef(ty,_,_,_) -> ast0_type_to_type ty
- | TypeName(name) -> Type_cocci.TypeName(unwrap_mcode name)
+ | TypeName(name) -> TC.TypeName(unwrap_mcode name)
| MetaType(name,_) ->
- Type_cocci.MetaType(unwrap_mcode name,Type_cocci.Unitary,false)
- | DisjType(_,types,_,_) -> failwith "unexpected DisjType"
+ TC.MetaType(unwrap_mcode name,TC.Unitary,false)
+ | DisjType(_,types,_,_) ->
+ Common.pr2_once
+ "disjtype not supported in smpl type inference, assuming unknown";
+ TC.Unknown
| OptType(ty) | UniqueType(ty) ->
ast0_type_to_type ty
-and baseType t =
- match unwrap_mcode t with
- Ast.VoidType -> Type_cocci.VoidType
- | Ast.CharType -> Type_cocci.CharType
- | Ast.ShortType -> Type_cocci.ShortType
- | Ast.IntType -> Type_cocci.IntType
- | Ast.DoubleType -> Type_cocci.DoubleType
- | Ast.FloatType -> Type_cocci.FloatType
- | Ast.LongType -> Type_cocci.LongType
+and baseType = function
+ Ast.VoidType -> TC.VoidType
+ | Ast.CharType -> TC.CharType
+ | Ast.ShortType -> TC.ShortType
+ | Ast.IntType -> TC.IntType
+ | Ast.DoubleType -> TC.DoubleType
+ | Ast.FloatType -> TC.FloatType
+ | Ast.LongType -> TC.LongType
+ | Ast.LongLongType -> TC.LongLongType
+ | Ast.SizeType -> TC.SizeType
+ | Ast.SSizeType -> TC.SSizeType
+ | Ast.PtrDiffType -> TC.PtrDiffType
and structUnion t =
match unwrap_mcode t with
- Ast.Struct -> Type_cocci.Struct
- | Ast.Union -> Type_cocci.Union
+ Ast.Struct -> TC.Struct
+ | Ast.Union -> TC.Union
and sign t =
match unwrap_mcode t with
- Ast.Signed -> Type_cocci.Signed
- | Ast.Unsigned -> Type_cocci.Unsigned
+ Ast.Signed -> TC.Signed
+ | Ast.Unsigned -> TC.Unsigned
and const_vol t =
match unwrap_mcode t with
- Ast.Const -> Type_cocci.Const
- | Ast.Volatile -> Type_cocci.Volatile
+ Ast.Const -> TC.Const
+ | Ast.Volatile -> TC.Volatile
(* --------------------------------------------------------------------- *)
(* this function is a rather minimal attempt. the problem is that information
has been lost. but since it is only used for metavariable types in the isos,
perhaps it doesn't matter *)
-let make_mcode x = (x,NONE,default_info(),context_befaft(),ref NoMetaPos)
-let make_mcode_info x info = (x,NONE,info,context_befaft(),ref NoMetaPos)
+and make_mcode x = (x,NONE,default_info(),context_befaft(),ref NoMetaPos,-1)
+let make_mcode_info x info = (x,NONE,info,context_befaft(),ref NoMetaPos,-1)
+and make_minus_mcode x =
+ (x,NONE,default_info(),minus_befaft(),ref NoMetaPos,-1)
exception TyConv
let rec reverse_type ty =
match ty with
- Type_cocci.ConstVol(cv,ty) ->
- ConstVol(reverse_const_vol cv,wrap(reverse_type ty))
- | Type_cocci.BaseType(bty,None) ->
- BaseType(reverse_baseType bty,None)
- | Type_cocci.BaseType(bty,Some sgn) ->
- BaseType(reverse_baseType bty,Some (reverse_sign sgn))
- | Type_cocci.Pointer(ty) ->
- Pointer(wrap(reverse_type ty),make_mcode "*")
- | Type_cocci.StructUnionName(su,mv,tag) ->
- if mv
- then
- (* not right... *)
- StructUnionName(reverse_structUnion su,
- Some(wrap(MetaId(make_mcode ("",tag),[],Impure))))
- else
- StructUnionName(reverse_structUnion su,
- Some (wrap(Id(make_mcode tag))))
- | Type_cocci.TypeName(name) -> TypeName(make_mcode name)
- | Type_cocci.MetaType(name,_,_) ->
+ TC.ConstVol(cv,ty) ->
+ ConstVol(reverse_const_vol cv,context_wrap(reverse_type ty))
+ | TC.BaseType(bty) ->
+ BaseType(reverse_baseType bty,[(* not used *)])
+ | TC.SignedT(sgn,None) -> Signed(reverse_sign sgn,None)
+ | TC.SignedT(sgn,Some bty) ->
+ Signed(reverse_sign sgn,Some (context_wrap(reverse_type ty)))
+ | TC.Pointer(ty) ->
+ Pointer(context_wrap(reverse_type ty),make_mcode "*")
+ | TC.EnumName(TC.MV(name,_,_)) ->
+ EnumName
+ (make_mcode "enum",
+ Some (context_wrap(MetaId(make_mcode name,Ast.IdNoConstraint,
+ Impure))))
+ | TC.EnumName(TC.Name tag) ->
+ EnumName(make_mcode "enum",Some(context_wrap(Id(make_mcode tag))))
+ | TC.StructUnionName(su,TC.MV(name,_,_)) ->
+ (* not right?... *)
+ StructUnionName
+ (reverse_structUnion su,
+ Some(context_wrap(MetaId(make_mcode name,Ast.IdNoConstraint,
+ Impure(*not really right*)))))
+ | TC.StructUnionName(su,TC.Name tag) ->
+ StructUnionName
+ (reverse_structUnion su,
+ Some (context_wrap(Id(make_mcode tag))))
+ | TC.TypeName(name) -> TypeName(make_mcode name)
+ | TC.MetaType(name,_,_) ->
MetaType(make_mcode name,Impure(*not really right*))
| _ -> raise TyConv
-and reverse_baseType t =
- make_mcode
- (match t with
- Type_cocci.VoidType -> Ast.VoidType
- | Type_cocci.CharType -> Ast.CharType
- | Type_cocci.BoolType -> Ast.IntType
- | Type_cocci.ShortType -> Ast.ShortType
- | Type_cocci.IntType -> Ast.IntType
- | Type_cocci.DoubleType -> Ast.DoubleType
- | Type_cocci.FloatType -> Ast.FloatType
- | Type_cocci.LongType -> Ast.LongType)
+and reverse_baseType = function
+ TC.VoidType -> Ast.VoidType
+ | TC.CharType -> Ast.CharType
+ | TC.BoolType -> Ast.IntType
+ | TC.ShortType -> Ast.ShortType
+ | TC.IntType -> Ast.IntType
+ | TC.DoubleType -> Ast.DoubleType
+ | TC.FloatType -> Ast.FloatType
+ | TC.LongType -> Ast.LongType
+ | TC.LongLongType -> Ast.LongLongType
+ | TC.SizeType -> Ast.SizeType
+ | TC.SSizeType -> Ast.SSizeType
+ | TC.PtrDiffType -> Ast.PtrDiffType
+
and reverse_structUnion t =
make_mcode
(match t with
- Type_cocci.Struct -> Ast.Struct
- | Type_cocci.Union -> Ast.Union)
+ TC.Struct -> Ast.Struct
+ | TC.Union -> Ast.Union)
and reverse_sign t =
make_mcode
(match t with
- Type_cocci.Signed -> Ast.Signed
- | Type_cocci.Unsigned -> Ast.Unsigned)
+ TC.Signed -> Ast.Signed
+ | TC.Unsigned -> Ast.Unsigned)
and reverse_const_vol t =
make_mcode
(match t with
- Type_cocci.Const -> Ast.Const
- | Type_cocci.Volatile -> Ast.Volatile)
+ TC.Const -> Ast.Const
+ | TC.Volatile -> Ast.Volatile)
(* --------------------------------------------------------------------- *)