pfff 0.40.4 (latest) · OCaml Package

type tok = Parse_info.t

and 'a wrap = 'a * tok

and 'a wrapx = 'a * tok list

and 'a paren = tok * 'a * tok

and 'a brace = tok * 'a * tok

and 'a bracket = tok * 'a * tok

and 'a angle = tok * 'a * tok

and 'a comma_list = 'a wrapx list

and 'a comma_list2 = ('a, tok) Common.either list

and sc = tok

type name = tok option * (qualifier * tok) list * ident_or_op

and ident_or_op =

| IdIdent of ident
| IdTemplateId of ident * template_arguments
| IdDestructor of tok * ident
| IdOperator of tok * operator * tok list
| IdConverter of tok * type_

and ident = string wrap

and template_arguments = template_argument comma_list angle

and template_argument = (type_, expr) Common.either

and qualifier =

| QClassname of ident
| QTemplateId of ident * template_arguments

and class_name = name

and namespace_name = name

and typedef_name = name

and enum_name = name

and ident_name = name

and type_ = typeQualifier * typeC

and typeC =

| BaseType of baseType
| Pointer of tok * type_
| Reference of tok * type_
| Array of constExpression option bracket * type_
| FunctionType of functionType
| EnumName of tok * ident
| StructUnionName of structUnion wrap * ident
| TypeName of name
| TypenameKwd of tok * name
| TypeOf of tok * (type_, expr) Common.either paren
| EnumDef of enum_definition
| StructDef of class_definition
| ParenType of type_ paren

and baseType =

| Void of tok
| IntType of intType * tok list
| FloatType of floatType * tok list

and intType =

| CChar
| Si of signed
| CBool
| WChar_t

and signed = sign * base

and base =

| CChar2
| CShort
| CInt
| CLong
| CLongLong

and sign =

| Signed
| UnSigned

and floatType =

| CFloat
| CDouble
| CLongDouble

and typeQualifier = {

const : tok option;
volatile : tok option;

}

and expr =

| Id of name * ident_info
| C of constant
| Call of expr * argument comma_list paren
| CondExpr of expr * tok * expr option * tok * expr
| Sequence of expr * tok * expr
| Assign of expr * assignOp * expr
| Postfix of expr * fixOp wrap
| Infix of expr * fixOp wrap
| Unary of expr * unaryOp wrap
| Binary of expr * binaryOp wrap * expr
| ArrayAccess of expr * expr bracket
| RecordAccess of expr * tok * name
| RecordPtAccess of expr * tok * name
| RecordStarAccess of expr * tok * expr
| RecordPtStarAccess of expr * tok * expr
| SizeOfExpr of tok * expr
| SizeOfType of tok * type_ paren
| Cast of type_ paren * expr
| StatementExpr of compound paren
| GccConstructor of type_ paren * initialiser comma_list brace
| This of tok
| ConstructedObject of type_ * argument comma_list paren
| TypeId of tok * (type_, expr) Common.either paren
| CplusplusCast of cast_operator wrap * type_ angle * expr paren
| New of tok option * tok * argument comma_list paren option * type_ * argument comma_list paren option
| Delete of tok option * tok * expr
| DeleteArray of tok option * tok * unit bracket * expr
| Throw of tok * expr option
| ParenExpr of expr paren
| Ellipses of tok
| ExprTodo of tok

and ident_info = {

mutable i_scope : Scope_code.t;

}

and argument =

| Arg of expr
| ArgType of type_
| ArgAction of action_macro

and action_macro =

| ActMisc of tok list

and constant =

| Int of string wrap
| Float of string wrap * floatType
| Char of string wrap * isWchar
| String of string wrap * isWchar
| MultiString of string wrap list
| Bool of bool wrap

and isWchar =

| IsWchar
| IsChar

and unaryOp =

| UnPlus
| UnMinus
| Tilde
| Not
| GetRef
| DeRef
| GetRefLabel

and assignOp =

| SimpleAssign of tok
| OpAssign of arithOp wrap

and fixOp =

| Dec
| Inc

and binaryOp =

| Arith of arithOp
| Logical of logicalOp

and arithOp =

| Plus
| Minus
| Mul
| Div
| Mod
| DecLeft
| DecRight
| And
| Or
| Xor

and logicalOp =

| Inf
| Sup
| InfEq
| SupEq
| Eq
| NotEq
| AndLog
| OrLog

and ptrOp =

| PtrStarOp
| PtrOp

and allocOp =

| NewOp
| DeleteOp
| NewArrayOp
| DeleteArrayOp

and accessop =

| ParenOp
| ArrayOp

and operator =

| BinaryOp of binaryOp
| AssignOp of assignOp
| FixOp of fixOp
| PtrOpOp of ptrOp
| AccessOp of accessop
| AllocOp of allocOp
| UnaryTildeOp
| UnaryNotOp
| CommaOp

and cast_operator =

| Static_cast
| Dynamic_cast
| Const_cast
| Reinterpret_cast

and constExpression = expr

and stmt =

| Compound of compound
| ExprStatement of expr option * sc
| If of tok * expr paren * stmt * (tok * stmt) option
| Switch of tok * expr paren * stmt
| While of tok * expr paren * stmt
| DoWhile of tok * stmt * tok * expr paren * sc
| For of tok * (expr option * sc * expr option * sc * expr option) paren * stmt
| MacroIteration of ident * argument comma_list paren * stmt
| Jump of jump * sc
| Label of string wrap * tok * stmt
| Case of tok * expr * tok * stmt
| CaseRange of tok * expr * tok * expr * tok * stmt
| Default of tok * tok * stmt
| DeclStmt of block_declaration
| Try of tok * compound * handler list
| NestedFunc of func_definition
| MacroStmt of tok
| StmtTodo of tok

and compound = stmt_sequencable list brace

and jump =

| Goto of tok * string wrap
| Continue of tok
| Break of tok
| Return of tok * expr option
| GotoComputed of tok * tok * expr

and handler = tok * exception_declaration paren * compound

and exception_declaration =

| ExnDeclEllipsis of tok
| ExnDecl of parameter

and stmt_sequencable =

| StmtElem of stmt
| CppDirectiveStmt of cpp_directive
| IfdefStmt of ifdef_directive

and block_declaration =

| DeclList of onedecl comma_list * sc
| MacroDecl of tok list * ident * argument comma_list paren * tok
| UsingDecl of tok * name * sc
| UsingDirective of tok * tok * namespace_name * sc
| NameSpaceAlias of tok * ident * tok * namespace_name * sc
| Asm of tok * tok option * asmbody paren * sc

and asmbody = string wrap list * colon list

and colon =

| Colon of tok * colon_option comma_list

and colon_option =

| ColonExpr of tok list * expr paren
| ColonMisc of tok list

and onedecl = {

v_namei : (name * init option) option;
v_type : type_;
v_storage : storage;

}

and storage =

| NoSto
| StoTypedef of tok
| Sto of storageClass wrap

and storageClass =

| Auto
| Static
| Register
| Extern

and _func_specifier =

| Inline
| Virtual

and init =

| EqInit of tok * initialiser
| ObjInit of argument comma_list paren

and initialiser =

| InitExpr of expr
| InitList of initialiser comma_list brace
| InitDesignators of designator list * tok * initialiser
| InitFieldOld of ident * tok * initialiser
| InitIndexOld of expr bracket * initialiser

and designator =

| DesignatorField of tok * ident
| DesignatorIndex of expr bracket
| DesignatorRange of (expr * tok * expr) bracket

and func_definition = {

f_name : name;
f_type : functionType;
f_storage : storage;
f_body : compound;

}

and functionType = {

ft_ret : type_;
ft_params : parameter comma_list paren;
ft_dots : (tok * tok) option;
ft_const : tok option;
ft_throw : exn_spec option;

}

and parameter = {

p_name : ident option;
p_type : type_;
p_register : tok option;
p_val : (tok * expr) option;

}

and exn_spec = tok * name comma_list2 paren

and func_or_else =

| FunctionOrMethod of func_definition
| Constructor of func_definition
| Destructor of func_definition

and method_decl =

| MethodDecl of onedecl * (tok * tok) option * sc
| ConstructorDecl of ident * parameter comma_list paren * sc
| DestructorDecl of tok * ident * tok option paren * exn_spec option * sc

and enum_definition = tok * ident option * enum_elem comma_list brace

and enum_elem = {

e_name : ident;
e_val : (tok * constExpression) option;

}

and class_definition = {

c_kind : structUnion wrap;
c_name : ident_name option;
c_inherit : (tok * base_clause comma_list) option;
c_members : class_member_sequencable list brace;

}

and structUnion =

| Struct
| Union
| Class

and base_clause = {

i_name : class_name;
i_virtual : tok option;
i_access : access_spec wrap option;

}

and access_spec =

| Public
| Private
| Protected

and class_member =

| Access of access_spec wrap * tok
| MemberField of fieldkind comma_list * sc
| MemberFunc of func_or_else
| MemberDecl of method_decl
| QualifiedIdInClass of name * sc
| TemplateDeclInClass of tok * template_parameters * declaration
| UsingDeclInClass of tok * name * sc
| EmptyField of sc

and fieldkind =

| FieldDecl of onedecl
| BitField of ident option * tok * type_ * constExpression

and class_member_sequencable =

| ClassElem of class_member
| CppDirectiveStruct of cpp_directive
| IfdefStruct of ifdef_directive

and cpp_directive =

| Define of tok * ident * define_kind * define_val
| Include of tok * inc_kind * string
| Undef of ident
| PragmaAndCo of tok

and define_kind =

| DefineVar
| DefineFunc of string wrap comma_list paren

and define_val =

| DefineExpr of expr
| DefineStmt of stmt
| DefineType of type_
| DefineFunction of func_definition
| DefineInit of initialiser
| DefineEmpty
| DefineDoWhileZero of tok * stmt * tok * tok paren
| DefinePrintWrapper of tok * expr paren * name
| DefineTodo

and inc_kind =

| Local
| Standard
| Weird

and ifdef_directive = ifdefkind wrap

and ifdefkind =

| Ifdef
| IfdefElse
| IfdefElseif
| IfdefEndif

and declaration =

| BlockDecl of block_declaration
| Func of func_or_else
| TemplateDecl of tok * template_parameters * declaration
| TemplateSpecialization of tok * unit angle * declaration
| ExternC of tok * tok * declaration
| ExternCList of tok * tok * declaration_sequencable list brace
| NameSpace of tok * ident * declaration_sequencable list brace
| NameSpaceExtend of string * declaration_sequencable list
| NameSpaceAnon of tok * declaration_sequencable list brace
| EmptyDef of sc
| DeclTodo

and template_parameter = parameter

and template_parameters = template_parameter comma_list angle

and declaration_sequencable =

| DeclElem of declaration
| CppDirectiveDecl of cpp_directive
| IfdefDecl of ifdef_directive
| MacroTop of ident * argument comma_list paren * tok option
| MacroVarTop of ident * sc
| NotParsedCorrectly of tok list

and toplevel = declaration_sequencable

and program = toplevel list

and any =

| Program of program
| Toplevel of toplevel
| Cpp of cpp_directive
| Stmt of stmt
| Expr of expr
| Type of type_
| Name of name
| BlockDecl2 of block_declaration
| ClassDef of class_definition
| FuncDef of func_definition
| FuncOrElse of func_or_else
| ClassMember of class_member
| OneDecl of onedecl
| Init of initialiser
| Stmts of stmt list
| Constant of constant
| Argument of argument
| Parameter of parameter
| Body of compound
| Info of tok
| InfoList of tok list

val nQ : typeQualifier

val noIdInfo : unit -> ident_info

val noQscope : 'a list

val unwrap : ('a * 'b) -> 'a

val uncomma : ('a * 'b) list -> 'a list

val unparen : ('a * 'b * 'c) -> 'b

val unbrace : ('a * 'b * 'c) -> 'b

val unwrap_typeC : ('a * 'b) -> 'b

val make_expanded : Parse_info.token_mutable -> Parse_info.token_mutable

val rewrap_pinfo : 
  Parse_info.token_origin ->
  Parse_info.token_mutable ->
  Parse_info.token_mutable

val string_of_name_tmp : name -> string

val ii_of_id_name : name -> tok list

package pfff