package pfff

You can search for identifiers within the package.

in-package search v0.2.0

package pfff

pfff-matcher

Legend:
Library
Module
Module type
Parameter
Class
Class type

type tok = Parse_info.t

and 'a wrap = 'a * tok list

and 'a wrap2 = 'a * tok

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 wrap list

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

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

and ident =

| IdIdent of simple_ident
| IdTemplateId of simple_ident * template_arguments
| IdDestructor of tok * simple_ident
| IdOperator of tok * operator * tok list
| IdConverter of tok * fullType

and simple_ident = string wrap2

and template_arguments = template_argument comma_list angle

and template_argument = (fullType, expression) Common.either

and qualifier =

| QClassname of simple_ident
| QTemplateId of simple_ident * template_arguments

and class_name = name

and namespace_name = name

and typedef_name = name

and enum_name = name

and ident_name = name

and fullType = typeQualifier * typeC

and typeC = typeCbis wrap

and typeCbis =

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

and baseType =

| Void
| IntType of intType
| FloatType of floatType

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 expression = expressionbis wrap

and expressionbis =

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

and ident_info = {

mutable i_scope : Scope_code.t;

}

and argument = (expression, weird_argument) Common.either

and weird_argument =

| ArgType of fullType
| ArgAction of action_macro

and action_macro =

| ActMisc of tok list

and constant =

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

and isWchar =

| IsWchar
| IsChar

and unaryOp =

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

and assignOp =

| SimpleAssign
| OpAssign of arithOp

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 = expression

and statement = statementbis wrap

and statementbis =

| Compound of compound
| ExprStatement of exprStatement
| Labeled of labeled
| Selection of selection
| Iteration of iteration
| Jump of jump
| DeclStmt of block_declaration
| Try of tok * compound * handler list
| NestedFunc of func_definition
| MacroStmt
| StmtTodo

and compound = statement_sequencable list brace

and exprStatement = expression option

and labeled =

| Label of string * statement
| Case of expression * statement
| CaseRange of expression * expression * statement
| Default of statement

and selection =

| If of tok * expression paren * statement * tok option * statement
| Switch of tok * expression paren * statement

and iteration =

| While of tok * expression paren * statement
| DoWhile of tok * statement * tok * expression paren * tok
| For of tok * (exprStatement wrap * exprStatement wrap * exprStatement wrap) paren * statement
| MacroIteration of simple_ident * argument comma_list paren * statement

and jump =

| Goto of string
| Continue
| Break
| Return
| ReturnExpr of expression
| GotoComputed of expression

and handler = tok * exception_declaration paren * compound

and exception_declaration =

| ExnDeclEllipsis of tok
| ExnDecl of parameter

and statement_sequencable =

| StmtElem of statement
| CppDirectiveStmt of cpp_directive
| IfdefStmt of ifdef_directive

and block_declaration =

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

and asmbody = tok list * colon wrap list

and colon =

| Colon of colon_option comma_list

and colon_option = colon_optionbis wrap

and colon_optionbis =

| ColonMisc
| ColonExpr of expression paren

and onedecl = {

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

}

and storage =

| NoSto
| StoTypedef of tok
| Sto of storageClass wrap2

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 expression
| InitList of initialiser comma_list brace
| InitDesignators of designator list * tok * initialiser
| InitFieldOld of simple_ident * tok * initialiser
| InitIndexOld of expression bracket * initialiser

and designator =

| DesignatorField of tok * simple_ident
| DesignatorIndex of expression bracket
| DesignatorRange of (expression * tok * expression) bracket

and func_definition = {

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

}

and functionType = {

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

}

and parameter = {

p_name : simple_ident option;
p_type : fullType;
p_register : tok option;
p_val : (tok * expression) 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 * tok
| ConstructorDecl of simple_ident * parameter comma_list paren * tok
| DestructorDecl of tok * simple_ident * tok option paren * exn_spec option * tok

and enum_definition = tok * simple_ident option * enum_elem comma_list brace

and enum_elem = {

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

}

and class_definition = {

c_kind : structUnion wrap2;
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 wrap2 option;

}

and access_spec =

| Public
| Private
| Protected

and class_member =

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

and fieldkind =

| FieldDecl of onedecl
| BitField of simple_ident option * tok * fullType * constExpression

and class_member_sequencable =

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

and cpp_directive =

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

and define_kind =

| DefineVar
| DefineFunc of string wrap comma_list paren

and define_val =

| DefineExpr of expression
| DefineStmt of statement
| DefineType of fullType
| DefineFunction of func_definition
| DefineInit of initialiser
| DefineText of string wrap
| DefineEmpty
| DefineDoWhileZero of statement wrap
| DefinePrintWrapper of tok * expression paren * name
| DefineTodo

and inc_kind =

| Local
| Standard
| Weird

and ifdef_directive = ifdefkind wrap2

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 * simple_ident * declaration_sequencable list brace
| NameSpaceExtend of string * declaration_sequencable list
| NameSpaceAnon of tok * declaration_sequencable list brace
| EmptyDef of tok
| 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 simple_ident * argument comma_list paren * tok option
| MacroVarTop of simple_ident * tok
| 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 statement
| Expr of expression
| Type of fullType
| 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
| 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 noii : 'a list

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 * 'c)) -> '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