Module: FFIGen::Clang

Extended by:
FFI::Library
Defined in:
lib/ffi_gen/clang.rb

Defined Under Namespace

Classes: CodeCompleteResults, CompletionResult, CursorAndRangeVisitor, CursorSetImpl, FileUniqueID, IdxAttrInfo, IdxBaseClassInfo, IdxCXXClassDeclInfo, IdxContainerInfo, IdxDeclInfo, IdxEntityInfo, IdxEntityRefInfo, IdxIBOutletCollectionAttrInfo, IdxImportedASTFileInfo, IdxIncludedFileInfo, IdxLoc, IdxObjCCategoryDeclInfo, IdxObjCContainerDeclInfo, IdxObjCInterfaceDeclInfo, IdxObjCPropertyDeclInfo, IdxObjCProtocolRefInfo, IdxObjCProtocolRefListInfo, IndexerCallbacks, PlatformAvailability, SourceLocation, SourceRange, SourceRangeList, TUResourceUsage, TUResourceUsageEntry, Token, TranslationUnitImpl, UnsavedFile, Version

Constant Summary collapse

CINDEX_VERSION_MAJOR = 
0
CINDEX_VERSION_MINOR = 
27

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

._callback_cursor_visitor_(enumcx_child_visit_result, cursor, parent, client_data) ⇒ Symbol from _enum_child_visit_result_

Visitor invoked for each cursor found by a traversal.

This visitor function will be invoked for each cursor found by clang_visitCursorChildren(). Its first argument is the cursor being visited, its second argument is the parent visitor for that cursor, and its third argument is the client data provided to clang_visitCursorChildren().

The visitor should return one of the c CXChildVisitResult values to direct clang_visitCursorChildren().

This entry is only for documentation and no real method.

Parameters:

Returns:



3542
 
# File 'lib/ffi_gen/clang.rb', line 3542

callback :cursor_visitor, [:child_visit_result, Cursor.by_value, Cursor.by_value, :pointer], :child_visit_result

._callback_inclusion_visitor_(included_file, inclusion_stack, include_len, client_data) ⇒ FFI::Pointer(File)

Visitor invoked for each file in a translation unit

(used with clang_getInclusions()).

This visitor function will be invoked by clang_getInclusions() for each file included (either at the top-level or by #include directives) within a translation unit. The first argument is the file being included, and the second and third arguments provide the inclusion stack. The array is sorted in order of immediate inclusion. For example, the first element refers to the location that included ‘included_file’.

This entry is only for documentation and no real method.

Parameters:

  • included_file (FFI::Pointer(File))
  • inclusion_stack (SourceLocation)
  • include_len (Integer)
  • client_data (FFI::Pointer(ClientData))

Returns:

  • (FFI::Pointer(File)) 


4964
 
# File 'lib/ffi_gen/clang.rb', line 4964

callback :inclusion_visitor, [:pointer, SourceLocation, :uint, :pointer], :pointer

._enum_availability_kind_ ⇒ Symbol

Describes the availability of a particular entity, which indicates whether the use of this entity will result in a warning or error due to it being deprecated or unavailable.

This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:availability_kind).

Options:

:available

The entity is available.

:deprecated

The entity is available, but has been deprecated (and its use is not recommended).

:not_available

The entity is not available; any use of it will be an error.

:not_accessible

The entity is available, but not accessible; any use of it will be an error.

Returns:

  • (Symbol) 


129
130
131
132
133
134
 
# File 'lib/ffi_gen/clang.rb', line 129

enum :availability_kind, [
  :available, 0,
  :deprecated, 1,
  :not_available, 2,
  :not_accessible, 3
]

._enum_calling_conv_ ⇒ Symbol

Describes the calling convention of a function type

This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:calling_conv).

Options:

:default
:c
:x86_std_call
:x86_fast_call
:x86_this_call
:x86_pascal
:aapcs
:aapcs_vfp
:pnacl_call
:intel_ocl_bicc
:x86_64_win64
:x86_64_sys_v
:invalid
:unexposed

Returns:

  • (Symbol) 


2930
2931
2932
2933
2934
2935
2936
2937
2938
2939
2940
2941
2942
2943
2944
2945
 
# File 'lib/ffi_gen/clang.rb', line 2930

enum :calling_conv, [
  :default, 0,
  :c, 1,
  :x86_std_call, 2,
  :x86_fast_call, 3,
  :x86_this_call, 4,
  :x86_pascal, 5,
  :aapcs, 6,
  :aapcs_vfp, 7,
  :pnacl_call, 8,
  :intel_ocl_bicc, 9,
  :x86_64_win64, 10,
  :x86_64_sys_v, 11,
  :invalid, 100,
  :unexposed, 200
]

._enum_child_visit_result_ ⇒ Symbol

Describes how the traversal of the children of a particular cursor should proceed after visiting a particular child cursor.

A value of this enumeration type should be returned by each c CXCursorVisitor to indicate how clang_visitChildren() proceed.

This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:child_visit_result).

Options:

:break_

Terminates the cursor traversal.

:continue

Continues the cursor traversal with the next sibling of the cursor just visited, without visiting its children.

:recurse

Recursively traverse the children of this cursor, using the same visitor and client data.

Returns:

  • (Symbol) 


3516
3517
3518
3519
3520
 
# File 'lib/ffi_gen/clang.rb', line 3516

enum :child_visit_result, [
  :break_, 0,
  :continue, 1,
  :recurse, 2
]

._enum_code_complete_flags_ ⇒ Symbol

Flags that can be passed to c clang_codeCompleteAt() to modify its behavior.

The enumerators in this enumeration can be bitwise-OR’d together to provide multiple options to c clang_codeCompleteAt().

This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:code_complete_flags).

Options:

:include_macros

Whether to include macros within the set of code completions returned.

:include_code_patterns

Whether to include code patterns for language constructs within the set of code completions, e.g., for loops.

:include_brief_comments

Whether to include brief documentation within the set of code completions returned.

Returns:

  • (Symbol) 


4662
4663
4664
4665
4666
 
# File 'lib/ffi_gen/clang.rb', line 4662

enum :code_complete_flags, [
  :include_macros, 1,
  :include_code_patterns, 2,
  :include_brief_comments, 4
]

._enum_completion_chunk_kind_ ⇒ Symbol

Describes a single piece of text within a code-completion string.

Each “chunk” within a code-completion string (c CXCompletionString) is either a piece of text with a specific “kind” that describes how that text should be interpreted by the client or is another completion string.

This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:completion_chunk_kind).

Options:

:optional

A code-completion string that describes “optional” text that could be a part of the template (but is not required).

The Optional chunk is the only kind of chunk that has a code-completion string for its representation, which is accessible via c clang_getCompletionChunkCompletionString(). The code-completion string describes an additional part of the template that is completely optional. For example, optional chunks can be used to describe the placeholders for arguments that match up with defaulted function parameters, e.g. given:

code void f(int x, float y = 3.14, double z = 2.71828); endcode

The code-completion string for this function would contain:

- a TypedText chunk for "f".
- a LeftParen chunk for "(".
- a Placeholder chunk for "int x"
- an Optional chunk containing the remaining defaulted arguments, e.g.,
    - a Comma chunk for ","
    - a Placeholder chunk for "float y"
    - an Optional chunk containing the last defaulted argument:
        - a Comma chunk for ","
        - a Placeholder chunk for "double z"
- a RightParen chunk for ")"

There are many ways to handle Optional chunks. Two simple approaches are:

- Completely ignore optional chunks, in which case the template for the
  function "f" would only include the first parameter ("int x").
- Fully expand all optional chunks, in which case the template for the
  function "f" would have all of the parameters.
:typed_text

Text that a user would be expected to type to get this code-completion result.

There will be exactly one “typed text” chunk in a semantic string, which will typically provide the spelling of a keyword or the name of a declaration that could be used at the current code point. Clients are expected to filter the code-completion results based on the text in this chunk.

:text

Text that should be inserted as part of a code-completion result.

A “text” chunk represents text that is part of the template to be inserted into user code should this particular code-completion result be selected.

:placeholder

Placeholder text that should be replaced by the user.

A “placeholder” chunk marks a place where the user should insert text into the code-completion template. For example, placeholders might mark the function parameters for a function declaration, to indicate that the user should provide arguments for each of those parameters. The actual text in a placeholder is a suggestion for the text to display before the user replaces the placeholder with real code.

:informative

Informative text that should be displayed but never inserted as part of the template.

An “informative” chunk contains annotations that can be displayed to help the user decide whether a particular code-completion result is the right option, but which is not part of the actual template to be inserted by code completion.

:current_parameter

Text that describes the current parameter when code-completion is referring to function call, message send, or template specialization.

A “current parameter” chunk occurs when code-completion is providing information about a parameter corresponding to the argument at the code-completion point. For example, given a function

code int add(int x, int y); endcode

and the source code c add(, where the code-completion point is after the “(”, the code-completion string will contain a “current parameter” chunk for “int x”, indicating that the current argument will initialize that parameter. After typing further, to c add(17, (where the code-completion point is after the “,”), the code-completion string will contain a “current paremeter” chunk to “int y”.

:left_paren

A left parenthesis (‘(’), used to initiate a function call or signal the beginning of a function parameter list.

:right_paren

A right parenthesis (‘)’), used to finish a function call or signal the end of a function parameter list.

:left_bracket

A left bracket (‘(’).

:right_bracket

A right bracket (‘)’).

:left_brace

A left brace (‘

:right_brace

A right brace (‘’).

:left_angle

A left angle bracket (‘<’).

:right_angle

A right angle bracket (‘>’).

:comma

A comma separator (‘,’).

:result_type

Text that specifies the result type of a given result.

This special kind of informative chunk is not meant to be inserted into the text buffer. Rather, it is meant to illustrate the type that an expression using the given completion string would have.

:colon

A colon (‘:’).

:semi_colon

A semicolon (‘;’).

:equal

An ‘=’ sign.

:horizontal_space

Horizontal space (‘ ’).

:vertical_space

Vertical space (‘n’), after which it is generally a good idea to perform indentation.

Returns:

  • (Symbol) 


4483
4484
4485
4486
4487
4488
4489
4490
4491
4492
4493
4494
4495
4496
4497
4498
4499
4500
4501
4502
4503
4504
4505
 
# File 'lib/ffi_gen/clang.rb', line 4483

enum :completion_chunk_kind, [
  :optional, 0,
  :typed_text, 1,
  :text, 2,
  :placeholder, 3,
  :informative, 4,
  :current_parameter, 5,
  :left_paren, 6,
  :right_paren, 7,
  :left_bracket, 8,
  :right_bracket, 9,
  :left_brace, 10,
  :right_brace, 11,
  :left_angle, 12,
  :right_angle, 13,
  :comma, 14,
  :result_type, 15,
  :colon, 16,
  :semi_colon, 17,
  :equal, 18,
  :horizontal_space, 19,
  :vertical_space, 20
]

._enum_completion_context_ ⇒ Symbol

Bits that represent the context under which completion is occurring.

The enumerators in this enumeration may be bitwise-OR’d together if multiple contexts are occurring simultaneously.

This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:completion_context).

Options:

:unexposed

The context for completions is unexposed, as only Clang results should be included. (This is equivalent to having no context bits set.)

:any_type

Completions for any possible type should be included in the results.

:any_value

Completions for any possible value (variables, function calls, etc.) should be included in the results.

:obj_c_object_value

Completions for values that resolve to an Objective-C object should be included in the results.

:obj_c_selector_value

Completions for values that resolve to an Objective-C selector should be included in the results.

:cxx_class_type_value

Completions for values that resolve to a C++ class type should be included in the results.

:dot_member_access

Completions for fields of the member being accessed using the dot operator should be included in the results.

:arrow_member_access

Completions for fields of the member being accessed using the arrow operator should be included in the results.

:obj_c_property_access

Completions for properties of the Objective-C object being accessed using the dot operator should be included in the results.

:enum_tag

Completions for enum tags should be included in the results.

:union_tag

Completions for union tags should be included in the results.

:struct_tag

Completions for struct tags should be included in the results.

:class_tag

Completions for C++ class names should be included in the results.

:namespace

Completions for C++ namespaces and namespace aliases should be included in the results.

:nested_name_specifier

Completions for C++ nested name specifiers should be included in the results.

:obj_c_interface

Completions for Objective-C interfaces (classes) should be included in the results.

:obj_c_protocol

Completions for Objective-C protocols should be included in the results.

:obj_c_category

Completions for Objective-C categories should be included in the results.

:obj_c_instance_message

Completions for Objective-C instance messages should be included in the results.

:obj_c_class_message

Completions for Objective-C class messages should be included in the results.

:obj_c_selector_name

Completions for Objective-C selector names should be included in the results.

:macro_name

Completions for preprocessor macro names should be included in the results.

:natural_language

Natural language completions should be included in the results.

:unknown

The current context is unknown, so set all contexts.

Returns:

  • (Symbol) 


4745
4746
4747
4748
4749
4750
4751
4752
4753
4754
4755
4756
4757
4758
4759
4760
4761
4762
4763
4764
4765
4766
4767
4768
4769
4770
 
# File 'lib/ffi_gen/clang.rb', line 4745

enum :completion_context, [
  :unexposed, 0,
  :any_type, 1,
  :any_value, 2,
  :obj_c_object_value, 4,
  :obj_c_selector_value, 8,
  :cxx_class_type_value, 16,
  :dot_member_access, 32,
  :arrow_member_access, 64,
  :obj_c_property_access, 128,
  :enum_tag, 256,
  :union_tag, 512,
  :struct_tag, 1024,
  :class_tag, 2048,
  :namespace, 4096,
  :nested_name_specifier, 8192,
  :obj_c_interface, 16384,
  :obj_c_protocol, 32768,
  :obj_c_category, 65536,
  :obj_c_instance_message, 131072,
  :obj_c_class_message, 262144,
  :obj_c_selector_name, 524288,
  :macro_name, 1048576,
  :natural_language, 2097152,
  :unknown, 4194303
]

._enum_cursor_kind_ ⇒ Symbol

Describes the kind of entity that a cursor refers to.

This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:cursor_kind).

Options:

:unexposed_decl

A declaration whose specific kind is not exposed via this interface.

Unexposed declarations have the same operations as any other kind of declaration; one can extract their location information, spelling, find their definitions, etc. However, the specific kind of the declaration is not reported.

:struct_decl

A C or C++ struct.

:union_decl

A C or C++ union.

:class_decl

A C++ class.

:enum_decl

An enumeration.

:field_decl

A field (in C) or non-static data member (in C++) in a struct, union, or C++ class.

:enum_constant_decl

An enumerator constant.

:function_decl

A function.

:var_decl

A variable.

:parm_decl

A function or method parameter.

:obj_c_interface_decl

An Objective-C @interface.

:obj_c_category_decl

An Objective-C @interface for a category.

:obj_c_protocol_decl

An Objective-C @protocol declaration.

:obj_c_property_decl

An Objective-C @property declaration.

:obj_c_ivar_decl

An Objective-C instance variable.

:obj_c_instance_method_decl

An Objective-C instance method.

:obj_c_class_method_decl

An Objective-C class method.

:obj_c_implementation_decl

An Objective-C @implementation.

:obj_c_category_impl_decl

An Objective-C @implementation for a category.

:typedef_decl

A typedef

:cxx_method

A C++ class method.

:namespace

A C++ namespace.

:linkage_spec

A linkage specification, e.g. ‘extern “C”’.

:constructor

A C++ constructor.

:destructor

A C++ destructor.

:conversion_function

A C++ conversion function.

:template_type_parameter

A C++ template type parameter.

:non_type_template_parameter

A C++ non-type template parameter.

:template_template_parameter

A C++ template template parameter.

:function_template

A C++ function template.

:class_template

A C++ class template.

:class_template_partial_specialization

A C++ class template partial specialization.

:namespace_alias

A C++ namespace alias declaration.

:using_directive

A C++ using directive.

:using_declaration

A C++ using declaration.

:type_alias_decl

A C++ alias declaration

:obj_c_synthesize_decl

An Objective-C @synthesize definition.

:obj_c_dynamic_decl

An Objective-C @dynamic definition.

:cxx_access_specifier

An access specifier.

:first_ref

References

:obj_c_super_class_ref

Decl references

:obj_c_protocol_ref
:obj_c_class_ref
:type_ref

A reference to a type declaration.

A type reference occurs anywhere where a type is named but not declared. For example, given:

code typedef unsigned size_type; size_type size; endcode

The typedef is a declaration of size_type (CXCursor_TypedefDecl), while the type of the variable “size” is referenced. The cursor referenced by the type of size is the typedef for size_type.

:cxx_base_specifier
:template_ref

A reference to a class template, function template, template template parameter, or class template partial specialization.

:namespace_ref

A reference to a namespace or namespace alias.

:member_ref

A reference to a member of a struct, union, or class that occurs in some non-expression context, e.g., a designated initializer.

:label_ref

A reference to a labeled statement.

This cursor kind is used to describe the jump to “start_over” in the goto statement in the following example:

code

start_over:
  ++counter;

  goto start_over;

endcode

A label reference cursor refers to a label statement.

:overloaded_decl_ref

A reference to a set of overloaded functions or function templates that has not yet been resolved to a specific function or function template.

An overloaded declaration reference cursor occurs in C++ templates where a dependent name refers to a function. For example:

code template<typename T> void swap(T&, T&);

struct X { … }; void swap(X&, X&);

template<typename T> void reverse(T* first, T* last) {

while (first < last - 1) {
  swap(*first, *--last);
  ++first;
}

}

struct Y { }; void swap(Y&, Y&); endcode

Here, the identifier “swap” is associated with an overloaded declaration reference. In the template definition, “swap” refers to either of the two “swap” functions declared above, so both results will be available. At instantiation time, “swap” may also refer to other functions found via argument-dependent lookup (e.g., the “swap” function at the end of the example).

The functions c clang_getNumOverloadedDecls() and c clang_getOverloadedDecl() can be used to retrieve the definitions referenced by this cursor.

:variable_ref

A reference to a variable that occurs in some non-expression context, e.g., a C++ lambda capture list.

:first_invalid

Error conditions

:invalid_file
:no_decl_found
:not_implemented
:invalid_code
:first_expr

Expressions

:unexposed_expr

An expression whose specific kind is not exposed via this interface.

Unexposed expressions have the same operations as any other kind of expression; one can extract their location information, spelling, children, etc. However, the specific kind of the expression is not reported.

:decl_ref_expr

An expression that refers to some value declaration, such as a function, variable, or enumerator.

:member_ref_expr

An expression that refers to a member of a struct, union, class, Objective-C class, etc.

:call_expr

An expression that calls a function.

:obj_c_message_expr

An expression that sends a message to an Objective-C

object or class.
:block_expr

An expression that represents a block literal.

:integer_literal

An integer literal.

:floating_literal

A floating point number literal.

:imaginary_literal

An imaginary number literal.

:string_literal

A string literal.

:character_literal

A character literal.

:paren_expr

A parenthesized expression, e.g. “(1)”.

This AST node is only formed if full location information is requested.

:unary_operator

This represents the unary-expression’s (except sizeof and alignof).

:array_subscript_expr

(C99 6.5.2.1) Array Subscripting.

:binary_operator

A builtin binary operation expression such as “x + y” or “x <= y”.

:compound_assign_operator

Compound assignment such as “+=”.

:conditional_operator

The ?: ternary operator.

:c_style_cast_expr

An explicit cast in C (C99 6.5.4) or a C-style cast in C++ (C++ (expr.cast)), which uses the syntax (Type)expr.

For example: (int)f.

:compound_literal_expr

(C99 6.5.2.5)

:init_list_expr

Describes an C or C++ initializer list.

:addr_label_expr

The GNU address of label extension, representing &&label.

:stmt_expr

This is the GNU Statement Expression extension: (X=4; X;)

:generic_selection_expr

Represents a C11 generic selection.

:gnu_null_expr

Implements the GNU __null extension, which is a name for a null pointer constant that has integral type (e.g., int or long) and is the same size and alignment as a pointer.

The __null extension is typically only used by system headers, which define NULL as __null in C++ rather than using 0 (which is an integer that may not match the size of a pointer).

:cxx_static_cast_expr

C++‘s static_cast<> expression.

:cxx_dynamic_cast_expr

C++‘s dynamic_cast<> expression.

:cxx_reinterpret_cast_expr

C++‘s reinterpret_cast<> expression.

:cxx_const_cast_expr

C++‘s const_cast<> expression.

:cxx_functional_cast_expr

Represents an explicit C++ type conversion that uses “functional” notion (C++ (expr.type.conv)).

Example: code

x = int(0.5);

endcode

:cxx_typeid_expr

A C++ typeid expression (C++ (expr.typeid)).

:cxx_bool_literal_expr

(C++ 2.13.5) C++ Boolean Literal.

:cxx_null_ptr_literal_expr

(C++0x 2.14.7) C++ Pointer Literal.

:cxx_this_expr

Represents the “this” expression in C++

:cxx_throw_expr

(C++ 15) C++ Throw Expression.

This handles ‘throw’ and ‘throw’ assignment-expression. When assignment-expression isn’t present, Op will be null.

:cxx_new_expr

A new expression for memory allocation and constructor calls, e.g: “new CXXNewExpr(foo)”.

:cxx_delete_expr

A delete expression for memory deallocation and destructor calls, e.g. “delete() pArray”.

:unary_expr

A unary expression.

:obj_c_string_literal

An Objective-C string literal i.e. @“foo”.

:obj_c_encode_expr

An Objective-C @encode expression.

:obj_c_selector_expr

An Objective-C @selector expression.

:obj_c_protocol_expr

An Objective-C @protocol expression.

:obj_c_bridged_cast_expr

An Objective-C “bridged” cast expression, which casts between Objective-C pointers and C pointers, transferring ownership in the process.

code

NSString *str = (__bridge_transfer NSString *)CFCreateString();

endcode

:pack_expansion_expr

Represents a C++0x pack expansion that produces a sequence of expressions.

A pack expansion expression contains a pattern (which itself is an expression) followed by an ellipsis. For example:

code template<typename F, typename …Types> void forward(F f, Types &&…args) 

f(static_cast<Types&&>(args)...);

endcode

:size_of_pack_expr

Represents an expression that computes the length of a parameter pack.

code template<typename …Types> struct count 

static const unsigned value = sizeof...(Types);

; endcode

:lambda_expr

Represents a C++ lambda expression that produces a local function object.

code void abssort(float *x, unsigned N) {

std::sort(x, x + N,
          ()(float a, float b) {
            return std::abs(a) < std::abs(b);
          });

} endcode

:obj_c_bool_literal_expr

Objective-c Boolean Literal.

:obj_c_self_expr

Represents the “self” expression in an Objective-C method.

:first_stmt

Statements

:unexposed_stmt

A statement whose specific kind is not exposed via this interface.

Unexposed statements have the same operations as any other kind of statement; one can extract their location information, spelling, children, etc. However, the specific kind of the statement is not reported.

:label_stmt

A labelled statement in a function.

This cursor kind is used to describe the “start_over:” label statement in the following example:

code

start_over:
  ++counter;

endcode

:compound_stmt

A group of statements like { stmt stmt }.

This cursor kind is used to describe compound statements, e.g. function bodies.

:case_stmt

A case statement.

:default_stmt

A default statement.

:if_stmt

An if statement

:switch_stmt

A switch statement.

:while_stmt

A while statement.

:do_stmt

A do statement.

:for_stmt

A for statement.

:goto_stmt

A goto statement.

:indirect_goto_stmt

An indirect goto statement.

:continue_stmt

A continue statement.

:break_stmt

A break statement.

:return_stmt

A return statement.

:gcc_asm_stmt

A GCC inline assembly statement extension.

:obj_c_at_try_stmt

Objective-C’s overall @try-@catch-@finally statement.

:obj_c_at_catch_stmt

Objective-C’s @catch statement.

:obj_c_at_finally_stmt

Objective-C’s @finally statement.

:obj_c_at_throw_stmt

Objective-C’s @throw statement.

:obj_c_at_synchronized_stmt

Objective-C’s @synchronized statement.

:obj_c_autorelease_pool_stmt

Objective-C’s autorelease pool statement.

:obj_c_for_collection_stmt

Objective-C’s collection statement.

:cxx_catch_stmt

C++‘s catch statement.

:cxx_try_stmt

C++‘s try statement.

:cxx_for_range_stmt

C++‘s for (* : *) statement.

:seh_try_stmt

Windows Structured Exception Handling’s try statement.

:seh_except_stmt

Windows Structured Exception Handling’s except statement.

:seh_finally_stmt

Windows Structured Exception Handling’s finally statement.

:ms_asm_stmt

A MS inline assembly statement extension.

:null_stmt

The null satement “;”: C99 6.8.3p3.

This cursor kind is used to describe the null statement.

:decl_stmt

Adaptor class for mixing declarations with statements and expressions.

:omp_parallel_directive

OpenMP parallel directive.

:omp_simd_directive

OpenMP simd directive.

:omp_for_directive

OpenMP for directive.

:omp_sections_directive

OpenMP sections directive.

:omp_section_directive

OpenMP section directive.

:omp_single_directive

OpenMP single directive.

:omp_parallel_for_directive

OpenMP parallel for directive.

:omp_parallel_sections_directive

OpenMP parallel sections directive.

:omp_task_directive

OpenMP task directive.

:omp_master_directive

OpenMP master directive.

:omp_critical_directive

OpenMP critical directive.

:omp_taskyield_directive

OpenMP taskyield directive.

:omp_barrier_directive

OpenMP barrier directive.

:omp_taskwait_directive

OpenMP taskwait directive.

:omp_flush_directive

OpenMP flush directive.

:seh_leave_stmt

Windows Structured Exception Handling’s leave statement.

:translation_unit

Cursor that represents the translation unit itself.

The translation unit cursor exists primarily to act as the root cursor for traversing the contents of a translation unit.

:first_attr

Attributes

:unexposed_attr

An attribute whose specific kind is not exposed via this interface.

:ib_action_attr
:ib_outlet_attr
:ib_outlet_collection_attr
:cxx_final_attr
:cxx_override_attr
:annotate_attr
:asm_label_attr
:packed_attr
:pure_attr
:const_attr
:no_duplicate_attr
:cuda_constant_attr
:cuda_device_attr
:cuda_global_attr
:cuda_host_attr
:preprocessing_directive

Preprocessing

:macro_definition
:macro_expansion
:inclusion_directive
:module_import_decl

A module import declaration.

Returns:

  • (Symbol) 


2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
2025
2026
2027
2028
2029
2030
2031
2032
2033
2034
2035
2036
2037
2038
2039
2040
2041
2042
2043
2044
2045
2046
2047
2048
2049
2050
2051
2052
2053
2054
2055
2056
2057
2058
2059
2060
2061
2062
2063
2064
2065
2066
2067
2068
2069
2070
2071
2072
2073
2074
2075
2076
2077
2078
2079
2080
2081
2082
2083
2084
2085
2086
2087
2088
2089
2090
2091
2092
2093
2094
2095
2096
2097
2098
2099
2100
2101
2102
2103
2104
2105
2106
2107
2108
2109
2110
2111
2112
2113
2114
2115
2116
2117
2118
2119
2120
2121
2122
2123
2124
2125
2126
2127
2128
2129
2130
2131
2132
2133
2134
2135
2136
2137
2138
2139
2140
2141
2142
2143
2144
2145
2146
2147
2148
2149
2150
2151
2152
2153
2154
2155
2156
2157
2158
2159
2160
2161
2162
2163
2164
2165
2166
2167
2168
2169
2170
2171
2172
2173
2174
2175
2176
2177
2178
2179
2180
2181
2182
2183
2184
2185
2186
2187
2188
 
# File 'lib/ffi_gen/clang.rb', line 2011

enum :cursor_kind, [
  :unexposed_decl, 1,
  :struct_decl, 2,
  :union_decl, 3,
  :class_decl, 4,
  :enum_decl, 5,
  :field_decl, 6,
  :enum_constant_decl, 7,
  :function_decl, 8,
  :var_decl, 9,
  :parm_decl, 10,
  :obj_c_interface_decl, 11,
  :obj_c_category_decl, 12,
  :obj_c_protocol_decl, 13,
  :obj_c_property_decl, 14,
  :obj_c_ivar_decl, 15,
  :obj_c_instance_method_decl, 16,
  :obj_c_class_method_decl, 17,
  :obj_c_implementation_decl, 18,
  :obj_c_category_impl_decl, 19,
  :typedef_decl, 20,
  :cxx_method, 21,
  :namespace, 22,
  :linkage_spec, 23,
  :constructor, 24,
  :destructor, 25,
  :conversion_function, 26,
  :template_type_parameter, 27,
  :non_type_template_parameter, 28,
  :template_template_parameter, 29,
  :function_template, 30,
  :class_template, 31,
  :class_template_partial_specialization, 32,
  :namespace_alias, 33,
  :using_directive, 34,
  :using_declaration, 35,
  :type_alias_decl, 36,
  :obj_c_synthesize_decl, 37,
  :obj_c_dynamic_decl, 38,
  :cxx_access_specifier, 39,
  :first_ref, 40,
  :obj_c_super_class_ref, 40,
  :obj_c_protocol_ref, 41,
  :obj_c_class_ref, 42,
  :type_ref, 43,
  :cxx_base_specifier, 44,
  :template_ref, 45,
  :namespace_ref, 46,
  :member_ref, 47,
  :label_ref, 48,
  :overloaded_decl_ref, 49,
  :variable_ref, 50,
  :first_invalid, 70,
  :invalid_file, 70,
  :no_decl_found, 71,
  :not_implemented, 72,
  :invalid_code, 73,
  :first_expr, 100,
  :unexposed_expr, 100,
  :decl_ref_expr, 101,
  :member_ref_expr, 102,
  :call_expr, 103,
  :obj_c_message_expr, 104,
  :block_expr, 105,
  :integer_literal, 106,
  :floating_literal, 107,
  :imaginary_literal, 108,
  :string_literal, 109,
  :character_literal, 110,
  :paren_expr, 111,
  :unary_operator, 112,
  :array_subscript_expr, 113,
  :binary_operator, 114,
  :compound_assign_operator, 115,
  :conditional_operator, 116,
  :c_style_cast_expr, 117,
  :compound_literal_expr, 118,
  :init_list_expr, 119,
  :addr_label_expr, 120,
  :stmt_expr, 121,
  :generic_selection_expr, 122,
  :gnu_null_expr, 123,
  :cxx_static_cast_expr, 124,
  :cxx_dynamic_cast_expr, 125,
  :cxx_reinterpret_cast_expr, 126,
  :cxx_const_cast_expr, 127,
  :cxx_functional_cast_expr, 128,
  :cxx_typeid_expr, 129,
  :cxx_bool_literal_expr, 130,
  :cxx_null_ptr_literal_expr, 131,
  :cxx_this_expr, 132,
  :cxx_throw_expr, 133,
  :cxx_new_expr, 134,
  :cxx_delete_expr, 135,
  :unary_expr, 136,
  :obj_c_string_literal, 137,
  :obj_c_encode_expr, 138,
  :obj_c_selector_expr, 139,
  :obj_c_protocol_expr, 140,
  :obj_c_bridged_cast_expr, 141,
  :pack_expansion_expr, 142,
  :size_of_pack_expr, 143,
  :lambda_expr, 144,
  :obj_c_bool_literal_expr, 145,
  :obj_c_self_expr, 146,
  :first_stmt, 200,
  :unexposed_stmt, 200,
  :label_stmt, 201,
  :compound_stmt, 202,
  :case_stmt, 203,
  :default_stmt, 204,
  :if_stmt, 205,
  :switch_stmt, 206,
  :while_stmt, 207,
  :do_stmt, 208,
  :for_stmt, 209,
  :goto_stmt, 210,
  :indirect_goto_stmt, 211,
  :continue_stmt, 212,
  :break_stmt, 213,
  :return_stmt, 214,
  :gcc_asm_stmt, 215,
  :obj_c_at_try_stmt, 216,
  :obj_c_at_catch_stmt, 217,
  :obj_c_at_finally_stmt, 218,
  :obj_c_at_throw_stmt, 219,
  :obj_c_at_synchronized_stmt, 220,
  :obj_c_autorelease_pool_stmt, 221,
  :obj_c_for_collection_stmt, 222,
  :cxx_catch_stmt, 223,
  :cxx_try_stmt, 224,
  :cxx_for_range_stmt, 225,
  :seh_try_stmt, 226,
  :seh_except_stmt, 227,
  :seh_finally_stmt, 228,
  :ms_asm_stmt, 229,
  :null_stmt, 230,
  :decl_stmt, 231,
  :omp_parallel_directive, 232,
  :omp_simd_directive, 233,
  :omp_for_directive, 234,
  :omp_sections_directive, 235,
  :omp_section_directive, 236,
  :omp_single_directive, 237,
  :omp_parallel_for_directive, 238,
  :omp_parallel_sections_directive, 239,
  :omp_task_directive, 240,
  :omp_master_directive, 241,
  :omp_critical_directive, 242,
  :omp_taskyield_directive, 243,
  :omp_barrier_directive, 244,
  :omp_taskwait_directive, 245,
  :omp_flush_directive, 246,
  :seh_leave_stmt, 247,
  :translation_unit, 300,
  :first_attr, 400,
  :unexposed_attr, 400,
  :ib_action_attr, 401,
  :ib_outlet_attr, 402,
  :ib_outlet_collection_attr, 403,
  :cxx_final_attr, 404,
  :cxx_override_attr, 405,
  :annotate_attr, 406,
  :asm_label_attr, 407,
  :packed_attr, 408,
  :pure_attr, 409,
  :const_attr, 410,
  :no_duplicate_attr, 411,
  :cuda_constant_attr, 412,
  :cuda_device_attr, 413,
  :cuda_global_attr, 414,
  :cuda_host_attr, 415,
  :preprocessing_directive, 500,
  :macro_definition, 501,
  :macro_expansion, 502,
  :inclusion_directive, 503,
  :module_import_decl, 600
]

._enum_cxx_access_specifier_ ⇒ Symbol

Represents the C++ access control level to a base class for a cursor with kind CX_CXXBaseSpecifier.

This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:cxx_access_specifier).

Options:

:invalid_access_specifier
:public
:protected
:private

Returns:

  • (Symbol) 


3443
3444
3445
3446
3447
3448
 
# File 'lib/ffi_gen/clang.rb', line 3443

enum :cxx_access_specifier, [
  :invalid_access_specifier, 0,
  :public, 1,
  :protected, 2,
  :private, 3
]

._enum_diagnostic_display_options_ ⇒ Symbol

Options to control the display of diagnostics.

The values in this enum are meant to be combined to customize the behavior of c clang_formatDiagnostic().

This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:diagnostic_display_options).

Options:

:source_location

Display the source-location information where the diagnostic was located.

When set, diagnostics will be prefixed by the file, line, and (optionally) column to which the diagnostic refers. For example,

code test.c:28: warning: extra tokens at end of #endif directive endcode

This option corresponds to the clang flag c -fshow-source-location.

:column

If displaying the source-location information of the diagnostic, also include the column number.

This option corresponds to the clang flag c -fshow-column.

:source_ranges

If displaying the source-location information of the diagnostic, also include information about source ranges in a machine-parsable format.

This option corresponds to the clang flag c -fdiagnostics-print-source-range-info.

:option

Display the option name associated with this diagnostic, if any.

The option name displayed (e.g., -Wconversion) will be placed in brackets after the diagnostic text. This option corresponds to the clang flag c -fdiagnostics-show-option.

:category_id

Display the category number associated with this diagnostic, if any.

The category number is displayed within brackets after the diagnostic text. This option corresponds to the clang flag c -fdiagnostics-show-category=id.

:category_name

Display the category name associated with this diagnostic, if any.

The category name is displayed within brackets after the diagnostic text. This option corresponds to the clang flag c -fdiagnostics-show-category=name.

Returns:

  • (Symbol) 


824
825
826
827
828
829
830
831
 
# File 'lib/ffi_gen/clang.rb', line 824

enum :diagnostic_display_options, [
  :source_location, 1,
  :column, 2,
  :source_ranges, 4,
  :option, 8,
  :category_id, 16,
  :category_name, 32
]

._enum_diagnostic_severity_ ⇒ Symbol

Describes the severity of a particular diagnostic.

This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:diagnostic_severity).

Options:

:ignored

A diagnostic that has been suppressed, e.g., by a command-line option.

:note

This diagnostic is a note that should be attached to the previous (non-note) diagnostic.

:warning

This diagnostic indicates suspicious code that may not be wrong.

:error

This diagnostic indicates that the code is ill-formed.

:fatal

This diagnostic indicates that the code is ill-formed such that future parser recovery is unlikely to produce useful results.

Returns:

  • (Symbol) 


647
648
649
650
651
652
653
 
# File 'lib/ffi_gen/clang.rb', line 647

enum :diagnostic_severity, [
  :ignored, 0,
  :note, 1,
  :warning, 2,
  :error, 3,
  :fatal, 4
]

._enum_error_code_ ⇒ Symbol

(Not documented)

This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:error_code).

Options:

:success

No error.

:failure

A generic error code, no further details are available.

Errors of this kind can get their own specific error codes in future libclang versions.

:crashed

libclang crashed while performing the requested operation.

:invalid_arguments

The function detected that the arguments violate the function contract.

:ast_read_error

An AST deserialization error has occurred.

Returns:

  • (Symbol) 


46
47
48
49
50
51
52
 
# File 'lib/ffi_gen/clang.rb', line 46

enum :error_code, [
  :success, 0,
  :failure, 1,
  :crashed, 2,
  :invalid_arguments, 3,
  :ast_read_error, 4
]

._enum_global_opt_flags_ ⇒ Symbol

(Not documented)

This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:global_opt_flags).

Options:

:none

Used to indicate that no special CXIndex options are needed.

:thread_background_priority_for_indexing

Used to indicate that threads that libclang creates for indexing purposes should use background priority.

Affects #clang_indexSourceFile, #clang_indexTranslationUnit, #clang_parseTranslationUnit, #clang_saveTranslationUnit.

:thread_background_priority_for_editing

Used to indicate that threads that libclang creates for editing purposes should use background priority.

Affects #clang_reparseTranslationUnit, #clang_codeCompleteAt, #clang_annotateTokens

Returns:

  • (Symbol) 


236
237
238
239
240
 
# File 'lib/ffi_gen/clang.rb', line 236

enum :global_opt_flags, [
  :none, 0,
  :thread_background_priority_for_indexing, 1,
  :thread_background_priority_for_editing, 2
]

._enum_idx_attr_kind_ ⇒ Symbol

(Not documented)

This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:idx_attr_kind).

Options:

:unexposed
:ib_action
:ib_outlet
:ib_outlet_collection

Returns:

  • (Symbol) 


5325
5326
5327
5328
5329
5330
 
# File 'lib/ffi_gen/clang.rb', line 5325

enum :idx_attr_kind, [
  :unexposed, 0,
  :ib_action, 1,
  :ib_outlet, 2,
  :ib_outlet_collection, 3
]

._enum_idx_decl_info_flags_ ⇒ Symbol

(Not documented)

This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:idx_decl_info_flags).

Options:

:idx_decl_flag_skipped

Returns:

  • (Symbol) 


5415
5416
5417
 
# File 'lib/ffi_gen/clang.rb', line 5415

enum :idx_decl_info_flags, [
  :idx_decl_flag_skipped, 1
]

._enum_idx_entity_cxx_template_kind_ ⇒ Symbol

Extra C++ template information for an entity. This can apply to: CXIdxEntity_Function CXIdxEntity_CXXClass CXIdxEntity_CXXStaticMethod CXIdxEntity_CXXInstanceMethod CXIdxEntity_CXXConstructor CXIdxEntity_CXXConversionFunction CXIdxEntity_CXXTypeAlias

This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:idx_entity_cxx_template_kind).

Options:

:non_template
:template
:template_partial_specialization
:template_specialization

Returns:

  • (Symbol) 


5301
5302
5303
5304
5305
5306
 
# File 'lib/ffi_gen/clang.rb', line 5301

enum :idx_entity_cxx_template_kind, [
  :non_template, 0,
  :template, 1,
  :template_partial_specialization, 2,
  :template_specialization, 3
]

._enum_idx_entity_kind_ ⇒ Symbol

(Not documented)

This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:idx_entity_kind).

Options:

:unexposed
:typedef
:function
:variable
:field
:enum_constant
:obj_c_class
:obj_c_protocol
:obj_c_category
:obj_c_instance_method
:obj_c_class_method
:obj_c_property
:obj_c_ivar
:enum
:struct
:union
:cxx_class
:cxx_namespace
:cxx_namespace_alias
:cxx_static_variable
:cxx_static_method
:cxx_instance_method
:cxx_constructor
:cxx_destructor
:cxx_conversion_function
:cxx_type_alias
:cxx_interface

Returns:

  • (Symbol) 


5223
5224
5225
5226
5227
5228
5229
5230
5231
5232
5233
5234
5235
5236
5237
5238
5239
5240
5241
5242
5243
5244
5245
5246
5247
5248
5249
5250
5251
 
# File 'lib/ffi_gen/clang.rb', line 5223

enum :idx_entity_kind, [
  :unexposed, 0,
  :typedef, 1,
  :function, 2,
  :variable, 3,
  :field, 4,
  :enum_constant, 5,
  :obj_c_class, 6,
  :obj_c_protocol, 7,
  :obj_c_category, 8,
  :obj_c_instance_method, 9,
  :obj_c_class_method, 10,
  :obj_c_property, 11,
  :obj_c_ivar, 12,
  :enum, 13,
  :struct, 14,
  :union, 15,
  :cxx_class, 16,
  :cxx_namespace, 17,
  :cxx_namespace_alias, 18,
  :cxx_static_variable, 19,
  :cxx_static_method, 20,
  :cxx_instance_method, 21,
  :cxx_constructor, 22,
  :cxx_destructor, 23,
  :cxx_conversion_function, 24,
  :cxx_type_alias, 25,
  :cxx_interface, 26
]

._enum_idx_entity_language_ ⇒ Symbol

(Not documented)

This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:idx_entity_language).

Options:

:lang_none
:lang_c
:lang_obj_c
:lang_cxx

Returns:

  • (Symbol) 


5270
5271
5272
5273
5274
5275
 
# File 'lib/ffi_gen/clang.rb', line 5270

enum :idx_entity_language, [
  :lang_none, 0,
  :lang_c, 1,
  :lang_obj_c, 2,
  :lang_cxx, 3
]

._enum_idx_entity_ref_kind_ ⇒ Symbol

Data for IndexerCallbacks#indexEntityReference.

This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:idx_entity_ref_kind).

Options:

:direct

The entity is referenced directly in user’s code.

:implicit

An implicit reference, e.g. a reference of an Objective-C method via the dot syntax.

Returns:

  • (Symbol) 


5621
5622
5623
5624
 
# File 'lib/ffi_gen/clang.rb', line 5621

enum :idx_entity_ref_kind, [
  :direct, 1,
  :implicit, 2
]

._enum_idx_obj_c_container_kind_ ⇒ Symbol

(Not documented)

This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:idx_obj_c_container_kind).

Options:

:forward_ref
:interface
:implementation

Returns:

  • (Symbol) 


5481
5482
5483
5484
5485
 
# File 'lib/ffi_gen/clang.rb', line 5481

enum :idx_obj_c_container_kind, [
  :forward_ref, 0,
  :interface, 1,
  :implementation, 2
]

._enum_index_opt_flags_ ⇒ Symbol

(Not documented)

This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:index_opt_flags).

Options:

:none

Used to indicate that no special indexing options are needed.

:suppress_redundant_refs

Used to indicate that IndexerCallbacks#indexEntityReference should be invoked for only one reference of an entity per source file that does not also include a declaration/definition of the entity.

:index_function_local_symbols

Function-local symbols should be indexed. If this is not set function-local symbols will be ignored.

:index_implicit_template_instantiations

Implicit function/class template instantiations should be indexed. If this is not set, implicit instantiations will be ignored.

:suppress_warnings

Suppress all compiler warnings when parsing for indexing.

:skip_parsed_bodies_in_session

Skip a function/method body that was already parsed during an indexing session associated with a c CXIndexAction object. Bodies in system headers are always skipped.

Returns:

  • (Symbol) 


5842
5843
5844
5845
5846
5847
5848
5849
 
# File 'lib/ffi_gen/clang.rb', line 5842

enum :index_opt_flags, [
  :none, 0,
  :suppress_redundant_refs, 1,
  :index_function_local_symbols, 2,
  :index_implicit_template_instantiations, 4,
  :suppress_warnings, 8,
  :skip_parsed_bodies_in_session, 16
]

._enum_language_kind_ ⇒ Symbol

Describe the “language” of the entity referred to by a cursor.

This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:language_kind).

Options:

:invalid
:c
:obj_c
:c_plus_plus

Returns:

  • (Symbol) 


2486
2487
2488
2489
2490
2491
 
# File 'lib/ffi_gen/clang.rb', line 2486

enum :language_kind, [
  :invalid, 0,
  :c, 1,
  :obj_c, 2,
  :c_plus_plus, 3
]

._enum_linkage_kind_ ⇒ Symbol

Describe the linkage of the entity referred to by a cursor.

This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:linkage_kind).

Options:

:invalid

This value indicates that no linkage information is available for a provided CXCursor.

:no_linkage

This is the linkage for variables, parameters, and so on that

have automatic storage.  This covers normal (non-extern) local variables.
:internal

This is the linkage for static variables and static functions.

:unique_external

This is the linkage for entities with external linkage that live in C++ anonymous namespaces.

:external

This is the linkage for entities with true, external linkage.

Returns:

  • (Symbol) 


2374
2375
2376
2377
2378
2379
2380
 
# File 'lib/ffi_gen/clang.rb', line 2374

enum :linkage_kind, [
  :invalid, 0,
  :no_linkage, 1,
  :internal, 2,
  :unique_external, 3,
  :external, 4
]

._enum_load_diag_error_ ⇒ Symbol

Describes the kind of error that occurred (if any) in a call to c clang_loadDiagnostics.

This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:load_diag_error).

Options:

:none

Indicates that no error occurred.

:unknown

Indicates that an unknown error occurred while attempting to deserialize diagnostics.

:cannot_load

Indicates that the file containing the serialized diagnostics could not be opened.

:invalid_file

Indicates that the serialized diagnostics file is invalid or corrupt.

Returns:

  • (Symbol) 


694
695
696
697
698
699
 
# File 'lib/ffi_gen/clang.rb', line 694

enum :load_diag_error, [
  :none, 0,
  :unknown, 1,
  :cannot_load, 2,
  :invalid_file, 3
]

._enum_name_ref_flags_ ⇒ Symbol

(Not documented)

This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:name_ref_flags).

Options:

:range_want_qualifier
Include the nested-name-specifier, e.g. Foo

in x.Foo::y, in the

range.

:range_want_template_args

Include the explicit template arguments, e.g. <int> in x.f<int>, in the range.

:range_want_single_piece

If the name is non-contiguous, return the full spanning range.

Non-contiguous names occur in Objective-C when a selector with two or more parameters is used, or in C++ when using an operator: code (object doSomething:here withValue:there); // Objective-C return some_vector(1); // C++ endcode

Returns:

  • (Symbol) 


4153
4154
4155
4156
4157
 
# File 'lib/ffi_gen/clang.rb', line 4153

enum :name_ref_flags, [
  :range_want_qualifier, 1,
  :range_want_template_args, 2,
  :range_want_single_piece, 4
]

._enum_obj_c_decl_qualifier_kind_ ⇒ Symbol

‘Qualifiers’ written next to the return and parameter types in Objective-C method declarations.

This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:obj_c_decl_qualifier_kind).

Options:

:none
:in_
:inout
:out
:bycopy
:byref
:oneway

Returns:

  • (Symbol) 


3879
3880
3881
3882
3883
3884
3885
3886
3887
 
# File 'lib/ffi_gen/clang.rb', line 3879

enum :obj_c_decl_qualifier_kind, [
  :none, 0,
  :in_, 1,
  :inout, 2,
  :out, 4,
  :bycopy, 8,
  :byref, 16,
  :oneway, 32
]

._enum_obj_c_property_attr_kind_ ⇒ Symbol

Property attributes for a c CXCursor_ObjCPropertyDecl.

This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:obj_c_property_attr_kind).

Options:

:noattr
:readonly
:getter
:assign
:readwrite
:retain
:copy
:nonatomic
:setter
:atomic
:weak
:strong
:unsafe_unretained

Returns:

  • (Symbol) 


3828
3829
3830
3831
3832
3833
3834
3835
3836
3837
3838
3839
3840
3841
3842
 
# File 'lib/ffi_gen/clang.rb', line 3828

enum :obj_c_property_attr_kind, [
  :noattr, 0,
  :readonly, 1,
  :getter, 2,
  :assign, 4,
  :readwrite, 8,
  :retain, 16,
  :copy, 32,
  :nonatomic, 64,
  :setter, 128,
  :atomic, 256,
  :weak, 512,
  :strong, 1024,
  :unsafe_unretained, 2048
]

._enum_ref_qualifier_kind_ ⇒ Symbol

(Not documented)

This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:ref_qualifier_kind).

Options:

:none

No ref-qualifier was provided.

:l_value

An lvalue ref-qualifier was provided (c &).

:r_value

An rvalue ref-qualifier was provided (c &&).

Returns:

  • (Symbol) 


3365
3366
3367
3368
3369
 
# File 'lib/ffi_gen/clang.rb', line 3365

enum :ref_qualifier_kind, [
  :none, 0,
  :l_value, 1,
  :r_value, 2
]

._enum_reparse_flags_ ⇒ Symbol

Flags that control the reparsing of translation units.

The enumerators in this enumeration type are meant to be bitwise ORed together to specify which options should be used when reparsing the translation unit.

This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:reparse_flags).

Options:

:reparse_none

Used to indicate that no special reparsing options are needed.

Returns:

  • (Symbol) 


1327
1328
1329
 
# File 'lib/ffi_gen/clang.rb', line 1327

enum :reparse_flags, [
  :reparse_none, 0
]

._enum_result_ ⇒ Symbol

(Not documented)

This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:result).

Options:

:success

Function returned successfully.

:invalid

One of the parameters was invalid for the function.

:visit_break

The function was terminated by a callback (e.g. it returned CXVisit_Break)

Returns:

  • (Symbol) 


5074
5075
5076
5077
5078
 
# File 'lib/ffi_gen/clang.rb', line 5074

enum :result, [
  :success, 0,
  :invalid, 1,
  :visit_break, 2
]

._enum_save_error_ ⇒ Symbol

Describes the kind of error that occurred (if any) in a call to c clang_saveTranslationUnit().

This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:save_error).

Options:

:none

Indicates that no error occurred while saving a translation unit.

:unknown

Indicates that an unknown error occurred while attempting to save the file.

This error typically indicates that file I/O failed when attempting to write the file.

:translation_errors

Indicates that errors during translation prevented this attempt to save the translation unit.

Errors that prevent the translation unit from being saved can be extracted using c clang_getNumDiagnostics() and c clang_getDiagnostic().

:invalid_tu

Indicates that the translation unit to be saved was somehow invalid (e.g., NULL).

Returns:

  • (Symbol) 


1275
1276
1277
1278
1279
1280
 
# File 'lib/ffi_gen/clang.rb', line 1275

enum :save_error, [
  :none, 0,
  :unknown, 1,
  :translation_errors, 2,
  :invalid_tu, 3
]

._enum_save_translation_unit_flags_ ⇒ Symbol

Flags that control how translation units are saved.

The enumerators in this enumeration type are meant to be bitwise ORed together to specify which options should be used when saving the translation unit.

This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:save_translation_unit_flags).

Options:

:save_translation_unit_none

Used to indicate that no special saving options are needed.

Returns:

  • (Symbol) 


1230
1231
1232
 
# File 'lib/ffi_gen/clang.rb', line 1230

enum :save_translation_unit_flags, [
  :save_translation_unit_none, 0
]

._enum_token_kind_ ⇒ Symbol

Describes a kind of token.

This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:token_kind).

Options:

:punctuation

A token that contains some kind of punctuation.

:keyword

A language keyword.

:identifier

An identifier (that is not a keyword).

:literal

A numeric, string, or character literal.

:comment

A comment.

Returns:

  • (Symbol) 


4178
4179
4180
4181
4182
4183
4184
 
# File 'lib/ffi_gen/clang.rb', line 4178

enum :token_kind, [
  :punctuation, 0,
  :keyword, 1,
  :identifier, 2,
  :literal, 3,
  :comment, 4
]

._enum_translation_unit_flags_ ⇒ Symbol

Flags that control the creation of translation units.

The enumerators in this enumeration type are meant to be bitwise ORed together to specify which options should be used when constructing the translation unit.

This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:translation_unit_flags).

Options:

:none

Used to indicate that no special translation-unit options are needed.

:detailed_preprocessing_record

Used to indicate that the parser should construct a “detailed” preprocessing record, including all macro definitions and instantiations.

Constructing a detailed preprocessing record requires more memory and time to parse, since the information contained in the record is usually not retained. However, it can be useful for applications that require more detailed information about the behavior of the preprocessor.

:incomplete

Used to indicate that the translation unit is incomplete.

When a translation unit is considered “incomplete”, semantic analysis that is typically performed at the end of the translation unit will be suppressed. For example, this suppresses the completion of tentative declarations in C and of instantiation of implicitly-instantiation function templates in C++. This option is typically used when parsing a header with the intent of producing a precompiled header.

:precompiled_preamble

Used to indicate that the translation unit should be built with an implicit precompiled header for the preamble.

An implicit precompiled header is used as an optimization when a particular translation unit is likely to be reparsed many times when the sources aren’t changing that often. In this case, an implicit precompiled header will be built containing all of the initial includes at the top of the main file (what we refer to as the “preamble” of the file). In subsequent parses, if the preamble or the files in it have not changed, c clang_reparseTranslationUnit() will re-use the implicit precompiled header to improve parsing performance.

:cache_completion_results

Used to indicate that the translation unit should cache some code-completion results with each reparse of the source file.

Caching of code-completion results is a performance optimization that introduces some overhead to reparsing but improves the performance of code-completion operations.

:for_serialization

Used to indicate that the translation unit will be serialized with c clang_saveTranslationUnit.

This option is typically used when parsing a header with the intent of producing a precompiled header.

:cxx_chained_pch

DEPRECATED: Enabled chained precompiled preambles in C++.

Note: this is a temporary option that is available only while we are testing C++ precompiled preamble support. It is deprecated.

:skip_function_bodies

Used to indicate that function/method bodies should be skipped while parsing.

This option can be used to search for declarations/definitions while ignoring the usages.

:include_brief_comments_in_code_completion

Used to indicate that brief documentation comments should be included into the set of code completions returned from this translation unit.

Returns:

  • (Symbol) 


1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
 
# File 'lib/ffi_gen/clang.rb', line 1130

enum :translation_unit_flags, [
  :none, 0,
  :detailed_preprocessing_record, 1,
  :incomplete, 2,
  :precompiled_preamble, 4,
  :cache_completion_results, 8,
  :for_serialization, 16,
  :cxx_chained_pch, 32,
  :skip_function_bodies, 64,
  :include_brief_comments_in_code_completion, 128
]

._enum_tu_resource_usage_kind_ ⇒ Symbol

Categorizes how memory is being used by a translation unit.

This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:tu_resource_usage_kind).

Options:

:ast
:identifiers
:selectors
:global_completion_results
:source_manager_content_cache
:ast_side_tables
:source_manager_membuffer_malloc
:source_manager_membuffer_m_map
:external_ast_source_membuffer_malloc
:external_ast_source_membuffer_m_map
:preprocessor
:preprocessing_record
:source_manager_data_structures
:preprocessor_header_search

Returns:

  • (Symbol) 


1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
 
# File 'lib/ffi_gen/clang.rb', line 1420

enum :tu_resource_usage_kind, [
  :ast, 1,
  :identifiers, 2,
  :selectors, 3,
  :global_completion_results, 4,
  :source_manager_content_cache, 5,
  :ast_side_tables, 6,
  :source_manager_membuffer_malloc, 7,
  :source_manager_membuffer_m_map, 8,
  :external_ast_source_membuffer_malloc, 9,
  :external_ast_source_membuffer_m_map, 10,
  :preprocessor, 11,
  :preprocessing_record, 12,
  :source_manager_data_structures, 13,
  :preprocessor_header_search, 14
]

._enum_type_kind_ ⇒ Symbol

Describes the kind of type

This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:type_kind).

Options:

:invalid

Represents an invalid type (e.g., where no type is available).

:unexposed

A type whose specific kind is not exposed via this interface.

:void

Builtin types

:bool
:char_u
:u_char
:char16
:char32
:u_short
:u_int
:u_long
:u_long_long
:u_int128
:char_s
:s_char
:w_char
:short
:int
:long
:long_long
:int128
:float
:double
:long_double
:null_ptr
:overload
:dependent
:obj_c_id
:obj_c_class
:obj_c_sel
:complex
:pointer
:block_pointer
:l_value_reference
:r_value_reference
:record
:enum
:typedef
:obj_c_interface
:obj_c_object_pointer
:function_no_proto
:function_proto
:constant_array
:vector
:incomplete_array
:variable_array
:dependent_sized_array
:member_pointer

Returns:

  • (Symbol) 


2842
2843
2844
2845
2846
2847
2848
2849
2850
2851
2852
2853
2854
2855
2856
2857
2858
2859
2860
2861
2862
2863
2864
2865
2866
2867
2868
2869
2870
2871
2872
2873
2874
2875
2876
2877
2878
2879
2880
2881
2882
2883
2884
2885
2886
2887
2888
2889
2890
2891
 
# File 'lib/ffi_gen/clang.rb', line 2842

enum :type_kind, [
  :invalid, 0,
  :unexposed, 1,
  :void, 2,
  :bool, 3,
  :char_u, 4,
  :u_char, 5,
  :char16, 6,
  :char32, 7,
  :u_short, 8,
  :u_int, 9,
  :u_long, 10,
  :u_long_long, 11,
  :u_int128, 12,
  :char_s, 13,
  :s_char, 14,
  :w_char, 15,
  :short, 16,
  :int, 17,
  :long, 18,
  :long_long, 19,
  :int128, 20,
  :float, 21,
  :double, 22,
  :long_double, 23,
  :null_ptr, 24,
  :overload, 25,
  :dependent, 26,
  :obj_c_id, 27,
  :obj_c_class, 28,
  :obj_c_sel, 29,
  :complex, 100,
  :pointer, 101,
  :block_pointer, 102,
  :l_value_reference, 103,
  :r_value_reference, 104,
  :record, 105,
  :enum, 106,
  :typedef, 107,
  :obj_c_interface, 108,
  :obj_c_object_pointer, 109,
  :function_no_proto, 110,
  :function_proto, 111,
  :constant_array, 112,
  :vector, 113,
  :incomplete_array, 114,
  :variable_array, 115,
  :dependent_sized_array, 116,
  :member_pointer, 117
]

._enum_type_layout_error_ ⇒ Symbol

List the possible error codes for c clang_Type_getSizeOf,

\c clang_Type_getAlignOf, \c clang_Type_getOffsetOf and
\c clang_Cursor_getOffsetOf.

A value of this enumeration type can be returned if the target type is not a valid argument to sizeof, alignof or offsetof.

This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:type_layout_error).

Options:

:invalid

Type is of kind CXType_Invalid.

:incomplete

The type is an incomplete Type.

:dependent

The type is a dependent Type.

:not_constant_size

The type is not a constant size type.

:invalid_field_name

The Field name is not valid for this record.

Returns:

  • (Symbol) 


3282
3283
3284
3285
3286
3287
3288
 
# File 'lib/ffi_gen/clang.rb', line 3282

enum :type_layout_error, [
  :invalid, -1,
  :incomplete, -2,
  :dependent, -3,
  :not_constant_size, -4,
  :invalid_field_name, -5
]

._enum_visitor_result_ ⇒ Symbol

defgroup CINDEX_HIGH Higher level API functions

@{

This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:visitor_result).

Options:

:visit_break
:visit_continue

Returns:

  • (Symbol) 


5041
5042
5043
5044
 
# File 'lib/ffi_gen/clang.rb', line 5041

enum :visitor_result, [
  :visit_break, 0,
  :visit_continue, 1
]

.annotate_tokens(tu, tokens, num_tokens, cursors) ⇒ nil

Annotate the given set of tokens by providing cursors for each token that can be mapped to a specific entity within the abstract syntax tree.

This token-annotation routine is equivalent to invoking clang_getCursor() for the source locations of each of the tokens. The cursors provided are filtered, so that only those cursors that have a direct correspondence to the token are accepted. For example, given a function call c f(x), clang_getCursor() would provide the following cursors:

* when the cursor is over the 'f', a DeclRefExpr cursor referring to 'f'.
* when the cursor is over the '(' or the ')', a CallExpr referring to 'f'.
* when the cursor is over the 'x', a DeclRefExpr cursor referring to 'x'.

Only the first and last of these cursors will occur within the annotate, since the tokens “f” and “x’ directly refer to a function and a variable, respectively, but the parentheses are just a small part of the full syntax of the function call expression, which is not provided as an annotation.

Parameters:

  • tu (TranslationUnitImpl) —

    the translation unit that owns the given tokens.

  • tokens (Token) —

    the set of tokens to annotate.

  • num_tokens (Integer) —

    the number of tokens in p Tokens.

  • cursors (Cursor) —

    an array of p NumTokens cursors, whose contents will be replaced with the cursors corresponding to each token.

Returns:

  • (nil) 


4280
 
# File 'lib/ffi_gen/clang.rb', line 4280

attach_function :annotate_tokens, :clang_annotateTokens, [TranslationUnitImpl, Token, :uint, Cursor], :void

.attach_function(name, *_) ⇒ Object 



9
10
11
12
13
 
# File 'lib/ffi_gen/clang.rb', line 9

def self.attach_function(name, *_)
  begin; super; rescue FFI::NotFoundError => e
    (class << self; self; end).class_eval { define_method(name) { |*_| raise e } }
  end
end

.code_complete_at(tu, complete_filename, complete_line, complete_column, unsaved_files, num_unsaved_files, options) ⇒ CodeCompleteResults

Perform code completion at a given location in a translation unit.

This function performs code completion at a particular file, line, and column within source code, providing results that suggest potential code snippets based on the context of the completion. The basic model for code completion is that Clang will parse a complete source file, performing syntax checking up to the location where code-completion has been requested. At that point, a special code-completion token is passed to the parser, which recognizes this token and determines, based on the current location in the C/Objective-C/C++ grammar and the state of semantic analysis, what completions to provide. These completions are returned via a new c CXCodeCompleteResults structure.

Code completion itself is meant to be triggered by the client when the user types punctuation characters or whitespace, at which point the code-completion location will coincide with the cursor. For example, if c p is a pointer, code-completion might be triggered after the “-” and then after the “>” in c p->. When the code-completion location is afer the “>”, the completion results will provide, e.g., the members of the struct that “p” points to. The client is responsible for placing the cursor at the beginning of the token currently being typed, then filtering the results based on the contents of the token. For example, when code-completing for the expression c p->get, the client should provide the location just after the “>” (e.g., pointing at the “g”) to this code-completion hook. Then, the client can filter the results based on the current token text (“get”), only showing those results that start with “get”. The intent of this interface is to separate the relatively high-latency acquisition of code-completion results from the filtering of results on a per-character basis, which must have a lower latency.

Parameters:

  • tu (TranslationUnitImpl) —

    The translation unit in which code-completion should occur. The source files for this translation unit need not be completely up-to-date (and the contents of those source files may be overridden via p unsaved_files). Cursors referring into the translation unit may be invalidated by this invocation.

  • complete_filename (String) —

    The name of the source file where code completion should be performed. This filename may be any file included in the translation unit.

  • complete_line (Integer) —

    The line at which code-completion should occur.

  • complete_column (Integer) —

    The column at which code-completion should occur. Note that the column should point just after the syntactic construct that initiated code completion, and not in the middle of a lexical token.

  • unsaved_files (UnsavedFile) —

    the Tiles that have not yet been saved to disk but may be required for parsing or code completion, including the contents of those files. The contents and name of these files (as specified by CXUnsavedFile) are copied when necessary, so the client only needs to guarantee their validity until the call to this function returns.

  • num_unsaved_files (Integer) —

    The number of unsaved file entries in p unsaved_files.

  • options (Integer) —

    Extra options that control the behavior of code completion, expressed as a bitwise OR of the enumerators of the CXCodeComplete_Flags enumeration. The c clang_defaultCodeCompleteOptions() function returns a default set of code-completion options.

Returns:

  • (CodeCompleteResults) —

    If successful, a new c CXCodeCompleteResults structure containing code-completion results, which should eventually be freed with c clang_disposeCodeCompleteResults(). If code completion fails, returns NULL.



4841
 
# File 'lib/ffi_gen/clang.rb', line 4841

attach_function :code_complete_at, :clang_codeCompleteAt, [TranslationUnitImpl, :string, :uint, :uint, UnsavedFile, :uint, :uint], CodeCompleteResults

.code_complete_get_container_kind(results, is_incomplete) ⇒ Symbol from _enum_cursor_kind_

Returns the cursor kind for the container for the current code completion context. The container is only guaranteed to be set for contexts where a container exists (i.e. member accesses or Objective-C message sends); if there is not a container, this function will return CXCursor_InvalidCode.

Parameters:

  • results (CodeCompleteResults) —

    the code completion results to query

  • is_incomplete (FFI::Pointer(*UInt)) —

    on return, this value will be false if Clang has complete information about the container. If Clang does not have complete information, this value will be true.

Returns:

  • (Symbol from _enum_cursor_kind_) —

    the container kind, or CXCursor_InvalidCode if there is not a container



4904
 
# File 'lib/ffi_gen/clang.rb', line 4904

attach_function :code_complete_get_container_kind, :clang_codeCompleteGetContainerKind, [CodeCompleteResults, :pointer], :cursor_kind

.code_complete_get_container_usr(results) ⇒ String

Returns the USR for the container for the current code completion context. If there is not a container for the current context, this function will return the empty string.

Parameters:

Returns:

  • (String) —

    the USR for the container



4914
 
# File 'lib/ffi_gen/clang.rb', line 4914

attach_function :code_complete_get_container_usr, :clang_codeCompleteGetContainerUSR, [CodeCompleteResults], String.by_value

.code_complete_get_contexts(results) ⇒ Integer

Determines what completions are appropriate for the context the given code completion.

Parameters:

Returns:

  • (Integer) —

    the kinds of completions that are appropriate for use along with the given code completion results.



4888
 
# File 'lib/ffi_gen/clang.rb', line 4888

attach_function :code_complete_get_contexts, :clang_codeCompleteGetContexts, [CodeCompleteResults], :ulong_long

.code_complete_get_diagnostic(results, index) ⇒ FFI::Pointer(Diagnostic)

Retrieve a diagnostic associated with the given code completion.

Parameters:

  • results (CodeCompleteResults) —

    the code completion results to query.

  • index (Integer) —

    the zero-based diagnostic number to retrieve.

Returns:

  • (FFI::Pointer(Diagnostic)) —

    the requested diagnostic. This diagnostic must be freed via a call to c clang_disposeDiagnostic().



4878
 
# File 'lib/ffi_gen/clang.rb', line 4878

attach_function :code_complete_get_diagnostic, :clang_codeCompleteGetDiagnostic, [CodeCompleteResults, :uint], :pointer

.code_complete_get_num_diagnostics(results) ⇒ Integer

Determine the number of diagnostics produced prior to the location where code completion was performed.

Parameters:

Returns:

  • (Integer) 


4868
 
# File 'lib/ffi_gen/clang.rb', line 4868

attach_function :code_complete_get_num_diagnostics, :clang_codeCompleteGetNumDiagnostics, [CodeCompleteResults], :uint

.code_complete_get_obj_c_selector(results) ⇒ String

Returns the currently-entered selector for an Objective-C message send, formatted like “initWithFoo:bar:”. Only guaranteed to return a non-empty string for CXCompletionContext_ObjCInstanceMessage and CXCompletionContext_ObjCClassMessage.

Parameters:

Returns:

  • (String) —

    the selector (or partial selector) that has been entered thus far for an Objective-C message send.



4926
 
# File 'lib/ffi_gen/clang.rb', line 4926

attach_function :code_complete_get_obj_c_selector, :clang_codeCompleteGetObjCSelector, [CodeCompleteResults], String.by_value

.construct_usr_obj_c_category(class_name, category_name) ⇒ String

Construct a USR for a specified Objective-C category.

Parameters:

Returns:



3594
 
# File 'lib/ffi_gen/clang.rb', line 3594

attach_function :construct_usr_obj_c_category, :clang_constructUSR_ObjCCategory, [:string, :string], String.by_value

.construct_usr_obj_c_class(class_name) ⇒ String

Construct a USR for a specified Objective-C class.

Parameters:

Returns:



3585
 
# File 'lib/ffi_gen/clang.rb', line 3585

attach_function :construct_usr_obj_c_class, :clang_constructUSR_ObjCClass, [:string], String.by_value

.construct_usr_obj_c_ivar(name, class_usr) ⇒ String

Construct a USR for a specified Objective-C instance variable and

the USR for its containing class.

Parameters:

Returns:



3612
 
# File 'lib/ffi_gen/clang.rb', line 3612

attach_function :construct_usr_obj_c_ivar, :clang_constructUSR_ObjCIvar, [:string, String.by_value], String.by_value

.construct_usr_obj_c_method(name, is_instance_method, class_usr) ⇒ String

Construct a USR for a specified Objective-C method and

the USR for its containing class.

Parameters:

  • name (String)
  • is_instance_method (Integer)
  • class_usr (String)

Returns:



3623
 
# File 'lib/ffi_gen/clang.rb', line 3623

attach_function :construct_usr_obj_c_method, :clang_constructUSR_ObjCMethod, [:string, :uint, String.by_value], String.by_value

.construct_usr_obj_c_property(property, class_usr) ⇒ String

Construct a USR for a specified Objective-C property and the USR

for its containing class.

Parameters:

Returns:



3633
 
# File 'lib/ffi_gen/clang.rb', line 3633

attach_function :construct_usr_obj_c_property, :clang_constructUSR_ObjCProperty, [:string, String.by_value], String.by_value

.construct_usr_obj_c_protocol(protocol_name) ⇒ String

Construct a USR for a specified Objective-C protocol.

Parameters:

Returns:



3602
 
# File 'lib/ffi_gen/clang.rb', line 3602

attach_function :construct_usr_obj_c_protocol, :clang_constructUSR_ObjCProtocol, [:string], String.by_value

.create_cx_cursor_set ⇒ CursorSetImpl

Creates an empty CXCursorSet.

Returns:



2519
 
# File 'lib/ffi_gen/clang.rb', line 2519

attach_function :create_cx_cursor_set, :clang_createCXCursorSet, [], CursorSetImpl

.create_index(exclude_declarations_from_pch, display_diagnostics) ⇒ FFI::Pointer(Index)

Provides a shared context for creating translation units.

It provides two options:

  • excludeDeclarationsFromPCH: When non-zero, allows enumeration of “local”

declarations (when loading any new translation units). A “local” declaration is one that belongs in the translation unit itself and not in a precompiled header that was used by the translation unit. If zero, all declarations will be enumerated.

Here is an example:

code

// excludeDeclsFromPCH = 1, displayDiagnostics=1
Idx = clang_createIndex(1, 1);

// IndexTest.pch was produced with the following command:
// "clang -x c IndexTest.h -emit-ast -o IndexTest.pch"
TU = clang_createTranslationUnit(Idx, "IndexTest.pch");

// This will load all the symbols from 'IndexTest.pch'
clang_visitChildren(clang_getTranslationUnitCursor(TU),
                    TranslationUnitVisitor, 0);
clang_disposeTranslationUnit(TU);

// This will load all the symbols from 'IndexTest.c', excluding symbols
// from 'IndexTest.pch'.
char *args() = { "-Xclang", "-include-pch=IndexTest.pch" };
TU = clang_createTranslationUnitFromSourceFile(Idx, "IndexTest.c", 2, args,
                                               0, 0);
clang_visitChildren(clang_getTranslationUnitCursor(TU),
                    TranslationUnitVisitor, 0);
clang_disposeTranslationUnit(TU);

endcode

This process of creating the ‘pch’, loading it separately, and using it (via -include-pch) allows ‘excludeDeclsFromPCH’ to remove redundant callbacks (which gives the indexer the same performance benefit as the compiler).

Parameters:

  • exclude_declarations_from_pch (Integer)
  • display_diagnostics (Integer)

Returns:

  • (FFI::Pointer(Index)) 


200
 
# File 'lib/ffi_gen/clang.rb', line 200

attach_function :create_index, :clang_createIndex, [:int, :int], :pointer

.create_translation_unit(c_idx, ast_filename) ⇒ TranslationUnitImpl

Same as c clang_createTranslationUnit2, but returns the c CXTranslationUnit instead of an error code. In case of an error this routine returns a c NULL c CXTranslationUnit, without further detailed error codes.

Parameters:

  • c_idx (FFI::Pointer(Index))
  • ast_filename (String)

Returns:



1039
 
# File 'lib/ffi_gen/clang.rb', line 1039

attach_function :create_translation_unit, :clang_createTranslationUnit, [:pointer, :string], TranslationUnitImpl

.create_translation_unit2(c_idx, ast_filename, out_tu) ⇒ Symbol from _enum_error_code_

Create a translation unit from an AST file (c -emit-ast).

param(out) out_TU A non-NULL pointer to store the created c CXTranslationUnit.

Parameters:

  • c_idx (FFI::Pointer(Index))
  • ast_filename (String)
  • out_tu (FFI::Pointer(*TranslationUnit))

Returns:

  • (Symbol from _enum_error_code_) —

    Zero on success, otherwise returns an error code.



1052
 
# File 'lib/ffi_gen/clang.rb', line 1052

attach_function :create_translation_unit2, :clang_createTranslationUnit2, [:pointer, :string, :pointer], :error_code

.create_translation_unit_from_source_file(c_idx, source_filename, num_clang_command_line_args, command_line_args, num_unsaved_files, unsaved_files) ⇒ TranslationUnitImpl

Return the CXTranslationUnit for a given source file and the provided command line arguments one would pass to the compiler.

Note: The ‘source_filename’ argument is optional. If the caller provides a NULL pointer, the name of the source file is expected to reside in the specified command line arguments.

Note: When encountered in ‘clang_command_line_args’, the following options are ignored:

'-c'
'-emit-ast'
'-fsyntax-only'
'-o \<output file>'  (both '-o' and '\<output file>' are ignored)

Parameters:

  • c_idx (FFI::Pointer(Index)) —

    The index object with which the translation unit will be associated.

  • source_filename (String) —

    The name of the source file to load, or NULL if the source file is included in p clang_command_line_args.

  • num_clang_command_line_args (Integer) —

    The number of command-line arguments in p clang_command_line_args.

  • command_line_args (FFI::Pointer(**CharS)) —

    The command-line arguments that would be passed to the c clang executable if it were being invoked out-of-process. These command-line options will be parsed and will affect how the translation unit is parsed. Note that the following options are ignored: ‘-c’, ‘-emit-ast’, ‘-fsyntax-only’ (which is the default), and ‘-o <output file>’.

  • num_unsaved_files (Integer) —

    the number of unsaved file entries in p unsaved_files.

  • unsaved_files (UnsavedFile) —

    the files that have not yet been saved to disk but may be required for code completion, including the contents of those files. The contents and name of these files (as specified by CXUnsavedFile) are copied when necessary, so the client only needs to guarantee their validity until the call to this function returns.

Returns:



1027
 
# File 'lib/ffi_gen/clang.rb', line 1027

attach_function :create_translation_unit_from_source_file, :clang_createTranslationUnitFromSourceFile, [:pointer, :string, :int, :pointer, :uint, UnsavedFile], TranslationUnitImpl

.cursor_get_argument(c, i) ⇒ Cursor

Retrieve the argument cursor of a function or method.

The argument cursor can be determined for calls as well as for declarations of functions or methods. For other cursors and for invalid indices, an invalid cursor is returned.

Parameters:

Returns:



3059
 
# File 'lib/ffi_gen/clang.rb', line 3059

attach_function :cursor_get_argument, :clang_Cursor_getArgument, [Cursor.by_value, :uint], Cursor.by_value

.cursor_get_brief_comment_text(c) ⇒ String

Given a cursor that represents a documentable entity (e.g., declaration), return the associated paragraph; otherwise return the first paragraph.

Parameters:

Returns:



3945
 
# File 'lib/ffi_gen/clang.rb', line 3945

attach_function :cursor_get_brief_comment_text, :clang_Cursor_getBriefCommentText, [Cursor.by_value], String.by_value

.cursor_get_comment_range(c) ⇒ SourceRange

Given a cursor that represents a declaration, return the associated comment’s source range. The range may include multiple consecutive comments with whitespace in between.

Parameters:

Returns:



3926
 
# File 'lib/ffi_gen/clang.rb', line 3926

attach_function :cursor_get_comment_range, :clang_Cursor_getCommentRange, [Cursor.by_value], SourceRange.by_value

.cursor_get_module(c) ⇒ FFI::Pointer(Module)

Given a CXCursor_ModuleImportDecl cursor, return the associated module.

Parameters:

Returns:

  • (FFI::Pointer(Module)) 


3953
 
# File 'lib/ffi_gen/clang.rb', line 3953

attach_function :cursor_get_module, :clang_Cursor_getModule, [Cursor.by_value], :pointer

.cursor_get_num_arguments(c) ⇒ Integer

Retrieve the number of non-variadic arguments associated with a given cursor.

The number of arguments can be determined for calls as well as for declarations of functions or methods. For other cursors -1 is returned.

Parameters:

Returns:

  • (Integer) 


3046
 
# File 'lib/ffi_gen/clang.rb', line 3046

attach_function :cursor_get_num_arguments, :clang_Cursor_getNumArguments, [Cursor.by_value], :int

.cursor_get_obj_c_decl_qualifiers(c) ⇒ Integer

Given a cursor that represents an Objective-C method or parameter declaration, return the associated Objective-C qualifiers for the return type or the parameter respectively. The bits are formed from CXObjCDeclQualifierKind.

Parameters:

Returns:

  • (Integer) 


3898
 
# File 'lib/ffi_gen/clang.rb', line 3898

attach_function :cursor_get_obj_c_decl_qualifiers, :clang_Cursor_getObjCDeclQualifiers, [Cursor.by_value], :uint

.cursor_get_obj_c_property_attributes(c, reserved) ⇒ Integer

Given a cursor that represents a property declaration, return the associated property attributes. The bits are formed from c CXObjCPropertyAttrKind.

Parameters:

  • c (Cursor)
  • reserved (Integer) —

    Reserved for future use, pass 0.

Returns:

  • (Integer) 


3853
 
# File 'lib/ffi_gen/clang.rb', line 3853

attach_function :cursor_get_obj_c_property_attributes, :clang_Cursor_getObjCPropertyAttributes, [Cursor.by_value, :uint], :uint

.cursor_get_obj_c_selector_index(cursor) ⇒ Integer

If the cursor points to a selector identifier in an Objective-C method or message expression, this returns the selector index.

After getting a cursor with #clang_getCursor, this can be called to determine if the location points to a selector identifier.

Parameters:

Returns:

  • (Integer) —

    The selector index if the cursor is an Objective-C method or message expression and the cursor is pointing to a selector identifier, or -1 otherwise.



3766
 
# File 'lib/ffi_gen/clang.rb', line 3766

attach_function :cursor_get_obj_c_selector_index, :clang_Cursor_getObjCSelectorIndex, [Cursor.by_value], :int

.cursor_get_raw_comment_text(c) ⇒ String

Given a cursor that represents a declaration, return the associated comment text, including comment markers.

Parameters:

Returns:



3935
 
# File 'lib/ffi_gen/clang.rb', line 3935

attach_function :cursor_get_raw_comment_text, :clang_Cursor_getRawCommentText, [Cursor.by_value], String.by_value

.cursor_get_receiver_type(c) ⇒ Type

Given a cursor pointing to an Objective-C message, returns the CXType of the receiver.

Parameters:

Returns:



3791
 
# File 'lib/ffi_gen/clang.rb', line 3791

attach_function :cursor_get_receiver_type, :clang_Cursor_getReceiverType, [Cursor.by_value], Type.by_value

.cursor_get_spelling_name_range(cursor, piece_index, options) ⇒ SourceRange

Retrieve a range for a piece that forms the cursors spelling name. Most of the times there is only one range for the complete spelling but for Objective-C methods and Objective-C message expressions, there are multiple pieces for each selector identifier.

Parameters:

  • cursor (Cursor)
  • piece_index (Integer) —

    the index of the spelling name piece. If this is greater than the actual number of pieces, it will return a NULL (invalid) range.

  • options (Integer) —

    Reserved.

Returns:



3655
 
# File 'lib/ffi_gen/clang.rb', line 3655

attach_function :cursor_get_spelling_name_range, :clang_Cursor_getSpellingNameRange, [Cursor.by_value, :uint, :uint], SourceRange.by_value

.cursor_get_translation_unit(cursor) ⇒ TranslationUnitImpl

Returns the translation unit that a cursor originated from.

Parameters:

Returns:



2507
 
# File 'lib/ffi_gen/clang.rb', line 2507

attach_function :cursor_get_translation_unit, :clang_Cursor_getTranslationUnit, [Cursor.by_value], TranslationUnitImpl

.cursor_is_bit_field(c) ⇒ Integer

Returns non-zero if the cursor specifies a Record member that is a

bitfield.

Parameters:

Returns:

  • (Integer) 


3414
 
# File 'lib/ffi_gen/clang.rb', line 3414

attach_function :cursor_is_bit_field, :clang_Cursor_isBitField, [Cursor.by_value], :uint

.cursor_is_dynamic_call(c) ⇒ Integer

Given a cursor pointing to a C++ method call or an Objective-C message, returns non-zero if the method/message is “dynamic”, meaning:

For a C++ method: the call is virtual. For an Objective-C message: the receiver is an object instance, not ‘super’ or a specific class.

If the method/message is “static” or the cursor does not point to a method/message, it will return zero.

Parameters:

Returns:

  • (Integer) 


3782
 
# File 'lib/ffi_gen/clang.rb', line 3782

attach_function :cursor_is_dynamic_call, :clang_Cursor_isDynamicCall, [Cursor.by_value], :int

.cursor_is_null(cursor) ⇒ Integer

Returns non-zero if p cursor is null.

Parameters:

Returns:

  • (Integer) 


2253
 
# File 'lib/ffi_gen/clang.rb', line 2253

attach_function :cursor_is_null, :clang_Cursor_isNull, [Cursor.by_value], :int

.cursor_is_obj_c_optional(c) ⇒ Integer

Given a cursor that represents an Objective-C method or property declaration, return non-zero if the declaration was affected by “@optional”. Returns zero if the cursor is not such a declaration or it is “@required”.

Parameters:

Returns:

  • (Integer) 


3908
 
# File 'lib/ffi_gen/clang.rb', line 3908

attach_function :cursor_is_obj_c_optional, :clang_Cursor_isObjCOptional, [Cursor.by_value], :uint

.cursor_is_variadic(c) ⇒ Integer

Returns non-zero if the given cursor is a variadic function or method.

Parameters:

Returns:

  • (Integer) 


3916
 
# File 'lib/ffi_gen/clang.rb', line 3916

attach_function :cursor_is_variadic, :clang_Cursor_isVariadic, [Cursor.by_value], :uint

.cx_cursor_set_contains(cset, cursor) ⇒ Integer

Queries a CXCursorSet to see if it contains a specific CXCursor.

Parameters:

Returns:

  • (Integer) —

    non-zero if the set contains the specified cursor.



2536
 
# File 'lib/ffi_gen/clang.rb', line 2536

attach_function :cx_cursor_set_contains, :clang_CXCursorSet_contains, [CursorSetImpl, Cursor.by_value], :uint

.cx_cursor_set_insert(cset, cursor) ⇒ Integer

Inserts a CXCursor into a CXCursorSet.

Parameters:

Returns:

  • (Integer) —

    zero if the CXCursor was already in the set, and non-zero otherwise.



2545
 
# File 'lib/ffi_gen/clang.rb', line 2545

attach_function :cx_cursor_set_insert, :clang_CXCursorSet_insert, [CursorSetImpl, Cursor.by_value], :uint

.cx_index_get_global_options(index) ⇒ Integer

Gets the general options associated with a CXIndex.

Parameters:

  • index (FFI::Pointer(Index))

Returns:

  • (Integer) —

    A bitmask of options, a bitwise OR of CXGlobalOpt_XXX flags that are associated with the given CXIndex object.



266
 
# File 'lib/ffi_gen/clang.rb', line 266

attach_function :cx_index_get_global_options, :clang_CXIndex_getGlobalOptions, [:pointer], :uint

.cx_index_set_global_options(index, options) ⇒ nil

Sets general options associated with a CXIndex.

For example: code CXIndex idx = …; clang_CXIndex_setGlobalOptions(idx,

clang_CXIndex_getGlobalOptions(idx) |
CXGlobalOpt_ThreadBackgroundPriorityForIndexing);

endcode

Parameters:

  • index (FFI::Pointer(Index))
  • options (Integer) —

    A bitmask of options, a bitwise OR of CXGlobalOpt_XXX flags.

Returns:

  • (nil) 


257
 
# File 'lib/ffi_gen/clang.rb', line 257

attach_function :cx_index_set_global_options, :clang_CXIndex_setGlobalOptions, [:pointer, :uint], :void

.cxx_method_is_const(c) ⇒ Integer

Determine if a C++ member function or member function template is declared ‘const’.

Parameters:

Returns:

  • (Integer) 


4061
 
# File 'lib/ffi_gen/clang.rb', line 4061

attach_function :cxx_method_is_const, :clang_CXXMethod_isConst, [Cursor.by_value], :uint

.cxx_method_is_pure_virtual(c) ⇒ Integer

Determine if a C++ member function or member function template is pure virtual.

Parameters:

Returns:

  • (Integer) 


4033
 
# File 'lib/ffi_gen/clang.rb', line 4033

attach_function :cxx_method_is_pure_virtual, :clang_CXXMethod_isPureVirtual, [Cursor.by_value], :uint

.cxx_method_is_static(c) ⇒ Integer

Determine if a C++ member function or member function template is declared ‘static’.

Parameters:

Returns:

  • (Integer) 


4042
 
# File 'lib/ffi_gen/clang.rb', line 4042

attach_function :cxx_method_is_static, :clang_CXXMethod_isStatic, [Cursor.by_value], :uint

.cxx_method_is_virtual(c) ⇒ Integer

Determine if a C++ member function or member function template is explicitly declared ‘virtual’ or if it overrides a virtual method from one of the base classes.

Parameters:

Returns:

  • (Integer) 


4052
 
# File 'lib/ffi_gen/clang.rb', line 4052

attach_function :cxx_method_is_virtual, :clang_CXXMethod_isVirtual, [Cursor.by_value], :uint

.default_code_complete_options ⇒ Integer

Returns a default set of code-completion options that can be passed toc clang_codeCompleteAt().

Returns:

  • (Integer) 


4778
 
# File 'lib/ffi_gen/clang.rb', line 4778

attach_function :default_code_complete_options, :clang_defaultCodeCompleteOptions, [], :uint

.default_diagnostic_display_options ⇒ Integer

Retrieve the set of display options most similar to the default behavior of the clang compiler.

Returns:

  • (Integer) —

    A set of display options suitable for use with c clang_formatDiagnostic().



855
 
# File 'lib/ffi_gen/clang.rb', line 855

attach_function :default_diagnostic_display_options, :clang_defaultDiagnosticDisplayOptions, [], :uint

.default_editing_translation_unit_options ⇒ Integer

Returns the set of flags that is suitable for parsing a translation unit that is being edited.

The set of flags returned provide options for c clang_parseTranslationUnit() to indicate that the translation unit is likely to be reparsed many times, either explicitly (via c clang_reparseTranslationUnit()) or implicitly (e.g., by code completion (c clang_codeCompletionAt())). The returned flag set contains an unspecified set of optimizations (e.g., the precompiled preamble) geared toward improving the performance of these routines. The set of optimizations enabled may change from one version to the next.

Returns:

  • (Integer) 


1156
 
# File 'lib/ffi_gen/clang.rb', line 1156

attach_function :default_editing_translation_unit_options, :clang_defaultEditingTranslationUnitOptions, [], :uint

.default_reparse_options(tu) ⇒ Integer

Returns the set of flags that is suitable for reparsing a translation unit.

The set of flags returned provide options for c clang_reparseTranslationUnit() by default. The returned flag set contains an unspecified set of optimizations geared toward common uses of reparsing. The set of optimizations enabled may change from one version to the next.

Parameters:

Returns:

  • (Integer) 


1344
 
# File 'lib/ffi_gen/clang.rb', line 1344

attach_function :default_reparse_options, :clang_defaultReparseOptions, [TranslationUnitImpl], :uint

.default_save_options(tu) ⇒ Integer

Returns the set of flags that is suitable for saving a translation unit.

The set of flags returned provide options for c clang_saveTranslationUnit() by default. The returned flag set contains an unspecified set of options that save translation units with the most commonly-requested data.

Parameters:

Returns:

  • (Integer) 


1246
 
# File 'lib/ffi_gen/clang.rb', line 1246

attach_function :default_save_options, :clang_defaultSaveOptions, [TranslationUnitImpl], :uint

.dispose_code_complete_results(results) ⇒ nil

Free the given set of code-completion results.

Parameters:

Returns:

  • (nil) 


4859
 
# File 'lib/ffi_gen/clang.rb', line 4859

attach_function :dispose_code_complete_results, :clang_disposeCodeCompleteResults, [CodeCompleteResults], :void

.dispose_cx_cursor_set(cset) ⇒ nil

Disposes a CXCursorSet and releases its associated memory.

Parameters:

Returns:

  • (nil) 


2527
 
# File 'lib/ffi_gen/clang.rb', line 2527

attach_function :dispose_cx_cursor_set, :clang_disposeCXCursorSet, [CursorSetImpl], :void

.dispose_cx_platform_availability(availability) ⇒ nil

Free the memory associated with a c CXPlatformAvailability structure.

Parameters:

Returns:

  • (nil) 


2467
 
# File 'lib/ffi_gen/clang.rb', line 2467

attach_function :dispose_cx_platform_availability, :clang_disposeCXPlatformAvailability, [PlatformAvailability], :void

.dispose_cxtu_resource_usage(usage) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


1490
 
# File 'lib/ffi_gen/clang.rb', line 1490

attach_function :dispose_cxtu_resource_usage, :clang_disposeCXTUResourceUsage, [TUResourceUsage.by_value], :void

.dispose_diagnostic(diagnostic) ⇒ nil

Destroy a diagnostic.

Parameters:

  • diagnostic (FFI::Pointer(Diagnostic))

Returns:

  • (nil) 


768
 
# File 'lib/ffi_gen/clang.rb', line 768

attach_function :dispose_diagnostic, :clang_disposeDiagnostic, [:pointer], :void

.dispose_diagnostic_set(diags) ⇒ nil

Release a CXDiagnosticSet and all of its contained diagnostics.

Parameters:

  • diags (FFI::Pointer(DiagnosticSet))

Returns:

  • (nil) 


721
 
# File 'lib/ffi_gen/clang.rb', line 721

attach_function :dispose_diagnostic_set, :clang_disposeDiagnosticSet, [:pointer], :void

.dispose_index(index) ⇒ nil

Destroy the given index.

The index must not be destroyed until all of the translation units created within that index have been destroyed.

Parameters:

  • index (FFI::Pointer(Index))

Returns:

  • (nil) 


211
 
# File 'lib/ffi_gen/clang.rb', line 211

attach_function :dispose_index, :clang_disposeIndex, [:pointer], :void

.dispose_overridden_cursors(overridden) ⇒ nil

Free the set of overridden cursors returned by c clang_getOverriddenCursors().

Parameters:

Returns:

  • (nil) 


2675
 
# File 'lib/ffi_gen/clang.rb', line 2675

attach_function :dispose_overridden_cursors, :clang_disposeOverriddenCursors, [Cursor], :void

.dispose_source_range_list(ranges) ⇒ nil

Destroy the given c CXSourceRangeList.

Parameters:

Returns:

  • (nil) 


621
 
# File 'lib/ffi_gen/clang.rb', line 621

attach_function :dispose_source_range_list, :clang_disposeSourceRangeList, [SourceRangeList], :void

.dispose_string(string) ⇒ nil

Free the given string.

Parameters:

Returns:

  • (nil) 


80
 
# File 'lib/ffi_gen/clang.rb', line 80

attach_function :dispose_string, :clang_disposeString, [String.by_value], :void

.dispose_tokens(tu, tokens, num_tokens) ⇒ nil

Free the given set of tokens.

Parameters:

Returns:

  • (nil) 


4290
 
# File 'lib/ffi_gen/clang.rb', line 4290

attach_function :dispose_tokens, :clang_disposeTokens, [TranslationUnitImpl, Token, :uint], :void

.dispose_translation_unit(translation_unit_impl) ⇒ nil

Destroy the specified CXTranslationUnit object.

Parameters:

Returns:

  • (nil) 


1310
 
# File 'lib/ffi_gen/clang.rb', line 1310

attach_function :dispose_translation_unit, :clang_disposeTranslationUnit, [TranslationUnitImpl], :void

.enable_stack_traces ⇒ nil

(Not documented)

Returns:

  • (nil) 


4319
 
# File 'lib/ffi_gen/clang.rb', line 4319

attach_function :enable_stack_traces, :clang_enableStackTraces, [], :void

.equal_cursors(cursor, cursor) ⇒ Integer

Determine whether two cursors are equivalent.

Parameters:

Returns:

  • (Integer) 


2245
 
# File 'lib/ffi_gen/clang.rb', line 2245

attach_function :equal_cursors, :clang_equalCursors, [Cursor.by_value, Cursor.by_value], :uint

.equal_locations(loc1, loc2) ⇒ Integer

Determine whether two source locations, which must refer into the same translation unit, refer to exactly the same point in the source code.

Parameters:

Returns:

  • (Integer) —

    non-zero if the source locations refer to the same location, zero if they refer to different locations.



376
 
# File 'lib/ffi_gen/clang.rb', line 376

attach_function :equal_locations, :clang_equalLocations, [SourceLocation.by_value, SourceLocation.by_value], :uint

.equal_ranges(range1, range2) ⇒ Integer

Determine whether two ranges are equivalent.

Parameters:

Returns:

  • (Integer) —

    non-zero if the ranges are the same, zero if they differ.



442
 
# File 'lib/ffi_gen/clang.rb', line 442

attach_function :equal_ranges, :clang_equalRanges, [SourceRange.by_value, SourceRange.by_value], :uint

.equal_types(a, b) ⇒ Integer

Determine whether two CXTypes represent the same type.

Parameters:

Returns:

  • (Integer) —

    non-zero if the CXTypes represent the same type and zero otherwise.



3069
 
# File 'lib/ffi_gen/clang.rb', line 3069

attach_function :equal_types, :clang_equalTypes, [Type.by_value, Type.by_value], :uint

.execute_on_thread(fn, user_data, stack_size) ⇒ nil

(Not documented)

Parameters:

  • fn (FFI::Pointer(*))
  • user_data (FFI::Pointer(*Void))
  • stack_size (Integer)

Returns:

  • (nil) 


4329
 
# File 'lib/ffi_gen/clang.rb', line 4329

attach_function :execute_on_thread, :clang_executeOnThread, [:pointer, :pointer, :uint], :void

.find_includes_in_file(tu, file, visitor) ⇒ Symbol from _enum_result_

Find #import/#include directives in a specific file.

Parameters:

  • tu (TranslationUnitImpl) —

    translation unit containing the file to query.

  • file (FFI::Pointer(File)) —

    to search for #import/#include directives.

  • visitor (CursorAndRangeVisitor) —

    callback that will receive pairs of CXCursor/CXSourceRange for each directive found.

Returns:

  • (Symbol from _enum_result_) —

    one of the CXResult enumerators.



5102
 
# File 'lib/ffi_gen/clang.rb', line 5102

attach_function :find_includes_in_file, :clang_findIncludesInFile, [TranslationUnitImpl, :pointer, CursorAndRangeVisitor.by_value], :result

.find_references_in_file(cursor, file, visitor) ⇒ Symbol from _enum_result_

Find references of a declaration in a specific file.

Parameters:

  • cursor (Cursor) —

    pointing to a declaration or a reference of one.

  • file (FFI::Pointer(File)) —

    to search for references.

  • visitor (CursorAndRangeVisitor) —

    callback that will receive pairs of CXCursor/CXSourceRange for each reference found. The CXSourceRange will point inside the file; if the reference is inside a macro (and not a macro argument) the CXSourceRange will be invalid.

Returns:

  • (Symbol from _enum_result_) —

    one of the CXResult enumerators.



5091
 
# File 'lib/ffi_gen/clang.rb', line 5091

attach_function :find_references_in_file, :clang_findReferencesInFile, [Cursor.by_value, :pointer, CursorAndRangeVisitor.by_value], :result

.format_diagnostic(diagnostic, options) ⇒ String

Format the given diagnostic in a manner that is suitable for display.

This routine will format the given diagnostic to a string, rendering the diagnostic according to the various options given. The c clang_defaultDiagnosticDisplayOptions() function returns the set of options that most closely mimics the behavior of the clang compiler.

Parameters:

  • diagnostic (FFI::Pointer(Diagnostic)) —

    The diagnostic to print.

  • options (Integer) —

    A set of options that control the diagnostic display, created by combining c CXDiagnosticDisplayOptions values.

Returns:

  • (String) —

    A new string containing for formatted diagnostic.



846
 
# File 'lib/ffi_gen/clang.rb', line 846

attach_function :format_diagnostic, :clang_formatDiagnostic, [:pointer, :uint], String.by_value

.get_arg_type(t, i) ⇒ Type

Retrieve the type of a parameter of a function type.

If a non-function type is passed in or the function does not have enough parameters, an invalid type is returned.

Parameters:

  • t (Type)
  • i (Integer)

Returns:



3187
 
# File 'lib/ffi_gen/clang.rb', line 3187

attach_function :get_arg_type, :clang_getArgType, [Type.by_value, :uint], Type.by_value

.get_array_element_type(t) ⇒ Type

Return the element type of an array type.

If a non-array type is passed in, an invalid type is returned.

Parameters:

Returns:



3246
 
# File 'lib/ffi_gen/clang.rb', line 3246

attach_function :get_array_element_type, :clang_getArrayElementType, [Type.by_value], Type.by_value

.get_array_size(t) ⇒ Integer

Return the array size of a constant array.

If a non-array type is passed in, -1 is returned.

Parameters:

Returns:

  • (Integer) 


3256
 
# File 'lib/ffi_gen/clang.rb', line 3256

attach_function :get_array_size, :clang_getArraySize, [Type.by_value], :long_long

.get_c_string(string) ⇒ String

Retrieve the character data associated with the given string.

Parameters:

Returns:



72
 
# File 'lib/ffi_gen/clang.rb', line 72

attach_function :get_c_string, :clang_getCString, [String.by_value], :string

.get_canonical_cursor(cursor) ⇒ Cursor

Retrieve the canonical cursor corresponding to the given cursor.

In the C family of languages, many kinds of entities can be declared several times within a single translation unit. For example, a structure type can be forward-declared (possibly multiple times) and later defined:

code struct X; struct X; struct X 

int member;

; endcode

The declarations and the definition of c X are represented by three different cursors, all of which are declarations of the same underlying entity. One of these cursor is considered the “canonical” cursor, which is effectively the representative for the underlying entity. One can determine if two cursors are declarations of the same underlying entity by comparing their canonical cursors.

Parameters:

Returns:

  • (Cursor) —

    The canonical cursor for the entity referred to by the given cursor.



3752
 
# File 'lib/ffi_gen/clang.rb', line 3752

attach_function :get_canonical_cursor, :clang_getCanonicalCursor, [Cursor.by_value], Cursor.by_value

.get_canonical_type(t) ⇒ Type

Return the canonical type for a CXType.

Clang’s type system explicitly models typedefs and all the ways a specific type can be represented. The canonical type is the underlying type with all the “sugar” removed. For example, if ‘T’ is a typedef for ‘int’, the canonical type for ‘T’ would be ‘int’.

Parameters:

Returns:



3082
 
# File 'lib/ffi_gen/clang.rb', line 3082

attach_function :get_canonical_type, :clang_getCanonicalType, [Type.by_value], Type.by_value

.get_child_diagnostics(d) ⇒ FFI::Pointer(DiagnosticSet)

Retrieve the child diagnostics of a CXDiagnostic.

This CXDiagnosticSet does not need to be released by clang_disposeDiagnosticSet.

Parameters:

  • d (FFI::Pointer(Diagnostic))

Returns:

  • (FFI::Pointer(DiagnosticSet)) 


732
 
# File 'lib/ffi_gen/clang.rb', line 732

attach_function :get_child_diagnostics, :clang_getChildDiagnostics, [:pointer], :pointer

.get_clang_version ⇒ String

Return a version string, suitable for showing to a user, but not

intended to be parsed (the format is not guaranteed to be stable).

Returns:



4934
 
# File 'lib/ffi_gen/clang.rb', line 4934

attach_function :get_clang_version, :clang_getClangVersion, [], String.by_value

.get_completion_annotation(completion_string, annotation_number) ⇒ String

Retrieve the annotation associated with the given completion string.

Parameters:

  • completion_string (FFI::Pointer(CompletionString)) —

    the completion string to query.

  • annotation_number (Integer) —

    the 0-based index of the annotation of the completion string.

Returns:

  • (String) —

    annotation string associated with the completion at index c annotation_number, or a NULL string if that annotation is not available.



4586
 
# File 'lib/ffi_gen/clang.rb', line 4586

attach_function :get_completion_annotation, :clang_getCompletionAnnotation, [:pointer, :uint], String.by_value

.get_completion_availability(completion_string) ⇒ Symbol from _enum_availability_kind_

Determine the availability of the entity that this code-completion string refers to.

Parameters:

  • completion_string (FFI::Pointer(CompletionString)) —

    The completion string to query.

Returns:



4565
 
# File 'lib/ffi_gen/clang.rb', line 4565

attach_function :get_completion_availability, :clang_getCompletionAvailability, [:pointer], :availability_kind

.get_completion_brief_comment(completion_string) ⇒ String

Retrieve the brief documentation comment attached to the declaration that corresponds to the given completion string.

Parameters:

  • completion_string (FFI::Pointer(CompletionString))

Returns:



4611
 
# File 'lib/ffi_gen/clang.rb', line 4611

attach_function :get_completion_brief_comment, :clang_getCompletionBriefComment, [:pointer], String.by_value

.get_completion_chunk_completion_string(completion_string, chunk_number) ⇒ FFI::Pointer(CompletionString)

Retrieve the completion string associated with a particular chunk within a completion string.

Parameters:

  • completion_string (FFI::Pointer(CompletionString)) —

    the completion string to query.

  • chunk_number (Integer) —

    the 0-based index of the chunk in the completion string.

Returns:

  • (FFI::Pointer(CompletionString)) —

    the completion string associated with the chunk at index c chunk_number.



4535
 
# File 'lib/ffi_gen/clang.rb', line 4535

attach_function :get_completion_chunk_completion_string, :clang_getCompletionChunkCompletionString, [:pointer, :uint], :pointer

.get_completion_chunk_kind(completion_string, chunk_number) ⇒ Symbol from _enum_completion_chunk_kind_

Determine the kind of a particular chunk within a completion string.

Parameters:

  • completion_string (FFI::Pointer(CompletionString)) —

    the completion string to query.

  • chunk_number (Integer) —

    the 0-based index of the chunk in the completion string.

Returns:



4514
 
# File 'lib/ffi_gen/clang.rb', line 4514

attach_function :get_completion_chunk_kind, :clang_getCompletionChunkKind, [:pointer, :uint], :completion_chunk_kind

.get_completion_chunk_text(completion_string, chunk_number) ⇒ String

Retrieve the text associated with a particular chunk within a completion string.

Parameters:

  • completion_string (FFI::Pointer(CompletionString)) —

    the completion string to query.

  • chunk_number (Integer) —

    the 0-based index of the chunk in the completion string.

Returns:

  • (String) —

    the text associated with the chunk at index c chunk_number.



4524
 
# File 'lib/ffi_gen/clang.rb', line 4524

attach_function :get_completion_chunk_text, :clang_getCompletionChunkText, [:pointer, :uint], String.by_value

.get_completion_num_annotations(completion_string) ⇒ Integer

Retrieve the number of annotations associated with the given completion string.

Parameters:

  • completion_string (FFI::Pointer(CompletionString)) —

    the completion string to query.

Returns:

  • (Integer) —

    the number of annotations associated with the given completion string.



4575
 
# File 'lib/ffi_gen/clang.rb', line 4575

attach_function :get_completion_num_annotations, :clang_getCompletionNumAnnotations, [:pointer], :uint

.get_completion_parent(completion_string, kind) ⇒ String

Retrieve the parent context of the given completion string.

The parent context of a completion string is the semantic parent of the declaration (if any) that the code completion represents. For example, a code completion for an Objective-C method would have the method’s class or protocol as its context.

Parameters:

  • completion_string (FFI::Pointer(CompletionString)) —

    The code completion string whose parent is being queried.

  • kind (FFI::Pointer(*CursorKind)) —

    DEPRECATED: always set to CXCursor_NotImplemented if non-NULL.

Returns:

  • (String) —

    The name of the completion parent, e.g., “NSObject” if the completion string represents a method in the NSObject class.



4602
 
# File 'lib/ffi_gen/clang.rb', line 4602

attach_function :get_completion_parent, :clang_getCompletionParent, [:pointer, :pointer], String.by_value

.get_completion_priority(completion_string) ⇒ Integer

Determine the priority of this code completion.

The priority of a code completion indicates how likely it is that this particular completion is the completion that the user will select. The priority is selected by various internal heuristics.

Parameters:

  • completion_string (FFI::Pointer(CompletionString)) —

    The completion string to query.

Returns:

  • (Integer) —

    The priority of this completion string. Smaller values indicate higher-priority (more likely) completions.



4556
 
# File 'lib/ffi_gen/clang.rb', line 4556

attach_function :get_completion_priority, :clang_getCompletionPriority, [:pointer], :uint

.get_cursor(translation_unit_impl, source_location) ⇒ Cursor

Map a source location to the cursor that describes the entity at that location in the source code.

clang_getCursor() maps an arbitrary source location within a translation unit down to the most specific cursor that describes the entity at that location. For example, given an expression c x + y, invoking clang_getCursor() with a source location pointing to “x” will return the cursor for “x”; similarly for “y”. If the cursor points anywhere between “x” or “y” (e.g., on the + or the whitespace around it), clang_getCursor() will return a cursor referring to the “+” expression.

Parameters:

Returns:

  • (Cursor) —

    a cursor representing the entity at the given source location, or a NULL cursor if no such entity can be found.



2703
 
# File 'lib/ffi_gen/clang.rb', line 2703

attach_function :get_cursor, :clang_getCursor, [TranslationUnitImpl, SourceLocation.by_value], Cursor.by_value

.get_cursor_availability(cursor) ⇒ Symbol from _enum_availability_kind_

Determine the availability of the entity that this cursor refers to, taking the current target platform into account.

Parameters:

  • cursor (Cursor) —

    The cursor to query.

Returns:



2397
 
# File 'lib/ffi_gen/clang.rb', line 2397

attach_function :get_cursor_availability, :clang_getCursorAvailability, [Cursor.by_value], :availability_kind

.get_cursor_completion_string(cursor) ⇒ FFI::Pointer(CompletionString)

Retrieve a completion string for an arbitrary declaration or macro definition cursor.

Parameters:

  • cursor (Cursor) —

    The cursor to query.

Returns:

  • (FFI::Pointer(CompletionString)) —

    A non-context-sensitive completion string for declaration and macro definition cursors, or NULL for other kinds of cursors.



4621
 
# File 'lib/ffi_gen/clang.rb', line 4621

attach_function :get_cursor_completion_string, :clang_getCursorCompletionString, [Cursor.by_value], :pointer

.get_cursor_definition(cursor) ⇒ Cursor

For a cursor that is either a reference to or a declaration of some entity, retrieve a cursor that describes the definition of that entity.

Some entities can be declared multiple times within a translation unit, but only one of those declarations can also be a definition. For example, given:

code int f(int, int); int g(int x, int y) { return f(x, y); } int f(int a, int b) { return a + b; } int f(int, int); endcode

there are three declarations of the function “f”, but only the second one is a definition. The clang_getCursorDefinition() function will take any cursor pointing to a declaration of “f” (the first or fourth lines of the example) or a cursor referenced that uses “f” (the call to “f’ inside ”g“) and will return a declaration cursor pointing to the definition (the second ”f“ declaration).

If given a cursor for which there is no corresponding definition, e.g., because there is no definition of that entity within this translation unit, returns a NULL cursor.

Parameters:

Returns:



3716
 
# File 'lib/ffi_gen/clang.rb', line 3716

attach_function :get_cursor_definition, :clang_getCursorDefinition, [Cursor.by_value], Cursor.by_value

.get_cursor_display_name(cursor) ⇒ String

Retrieve the display name for the entity referenced by this cursor.

The display name contains extra information that helps identify the cursor, such as the parameters of a function or template or the arguments of a class template specialization.

Parameters:

Returns:



3667
 
# File 'lib/ffi_gen/clang.rb', line 3667

attach_function :get_cursor_display_name, :clang_getCursorDisplayName, [Cursor.by_value], String.by_value

.get_cursor_extent(cursor) ⇒ SourceRange

Retrieve the physical extent of the source construct referenced by the given cursor.

The extent of a cursor starts with the file/line/column pointing at the first character within the source construct that the cursor refers to and ends with the last character within that source construct. For a declaration, the extent covers the declaration itself. For a reference, the extent covers the location of the reference (e.g., where the referenced entity was actually used).

Parameters:

Returns:



2734
 
# File 'lib/ffi_gen/clang.rb', line 2734

attach_function :get_cursor_extent, :clang_getCursorExtent, [Cursor.by_value], SourceRange.by_value

.get_cursor_kind(cursor) ⇒ Symbol from _enum_cursor_kind_

Retrieve the kind of the given cursor.

Parameters:

Returns:



2269
 
# File 'lib/ffi_gen/clang.rb', line 2269

attach_function :get_cursor_kind, :clang_getCursorKind, [Cursor.by_value], :cursor_kind

.get_cursor_kind_spelling(kind) ⇒ String

for debug/testing

Parameters:

Returns:



4298
 
# File 'lib/ffi_gen/clang.rb', line 4298

attach_function :get_cursor_kind_spelling, :clang_getCursorKindSpelling, [:cursor_kind], String.by_value

.get_cursor_language(cursor) ⇒ Symbol from _enum_language_kind_

Determine the “language” of the entity referred to by a given cursor.

Parameters:

Returns:



2499
 
# File 'lib/ffi_gen/clang.rb', line 2499

attach_function :get_cursor_language, :clang_getCursorLanguage, [Cursor.by_value], :language_kind

.get_cursor_lexical_parent(cursor) ⇒ Cursor

Determine the lexical parent of the given cursor.

The lexical parent of a cursor is the cursor in which the given p cursor was actually written. For many declarations, the lexical and semantic parents are equivalent (the semantic parent is returned by c clang_getCursorSemanticParent()). They diverge when declarations or definitions are provided out-of-line. For example:

code class C 

void f();

;

void C::f() { } endcode

In the out-of-line definition of c C::f, the semantic parent is the class c C, of which this function is a member. The lexical parent is the place where the declaration actually occurs in the source code; in this case, the definition occurs in the translation unit. In general, the lexical parent for a given entity can change without affecting the semantics of the program, and the lexical parent of different declarations of the same entity may be different. Changing the semantic parent of a declaration, on the other hand, can have a major impact on semantics, and redeclarations of a particular entity should all have the same semantic context.

In the example above, both declarations of c C::f have c C as their semantic context, while the lexical context of the first c C::f is c C and the lexical context of the second c C::f is the translation unit.

For declarations written in the global scope, the lexical parent is the translation unit.

Parameters:

Returns:



2622
 
# File 'lib/ffi_gen/clang.rb', line 2622

attach_function :get_cursor_lexical_parent, :clang_getCursorLexicalParent, [Cursor.by_value], Cursor.by_value

.get_cursor_linkage(cursor) ⇒ Symbol from _enum_linkage_kind_

Determine the linkage of the entity referred to by a given cursor.

Parameters:

Returns:



2388
 
# File 'lib/ffi_gen/clang.rb', line 2388

attach_function :get_cursor_linkage, :clang_getCursorLinkage, [Cursor.by_value], :linkage_kind

.get_cursor_location(cursor) ⇒ SourceLocation

Retrieve the physical location of the source constructor referenced by the given cursor.

The location of a declaration is typically the location of the name of that declaration, where the name of that declaration would occur if it is unnamed, or some keyword that introduces that particular declaration. The location of a reference is where that reference occurs within the source code.

Parameters:

Returns:



2718
 
# File 'lib/ffi_gen/clang.rb', line 2718

attach_function :get_cursor_location, :clang_getCursorLocation, [Cursor.by_value], SourceLocation.by_value

.get_cursor_platform_availability(cursor, always_deprecated, deprecated_message, always_unavailable, unavailable_message, availability, availability_size) ⇒ Integer

Determine the availability of the entity that this cursor refers to on any platforms for which availability information is known.

Parameters:

  • cursor (Cursor) —

    The cursor to query.

  • always_deprecated (FFI::Pointer(*Int)) —

    If non-NULL, will be set to indicate whether the entity is deprecated on all platforms.

  • deprecated_message (String) —

    If non-NULL, will be set to the message text provided along with the unconditional deprecation of this entity. The client is responsible for deallocating this string.

  • always_unavailable (FFI::Pointer(*Int)) —

    If non-NULL, will be set to indicate whether the entity is unavailable on all platforms.

  • unavailable_message (String) —

    If non-NULL, will be set to the message text provided along with the unconditional unavailability of this entity. The client is responsible for deallocating this string.

  • availability (PlatformAvailability) —

    If non-NULL, an array of CXPlatformAvailability instances that will be populated with platform availability information, up to either the number of platforms for which availability information is available (as returned by this function) or c availability_size, whichever is smaller.

  • availability_size (Integer) —

    The number of elements available in the c availability array.

Returns:

  • (Integer) —

    The number of platforms (N) for which availability information is available (which is unrelated to c availability_size).

    Note that the client is responsible for calling c clang_disposeCXPlatformAvailability to free each of the platform-availability structures returned. There are c min(N, availability_size) such structures.



2459
 
# File 'lib/ffi_gen/clang.rb', line 2459

attach_function :get_cursor_platform_availability, :clang_getCursorPlatformAvailability, [Cursor.by_value, :pointer, String, :pointer, String, PlatformAvailability, :int], :int

.get_cursor_reference_name_range(c, name_flags, piece_index) ⇒ SourceRange

Given a cursor that references something else, return the source range covering that reference.

Parameters:

  • c (Cursor) —

    A cursor pointing to a member reference, a declaration reference, or an operator call.

  • name_flags (Integer) —

    A bitset with three independent flags: CXNameRange_WantQualifier, CXNameRange_WantTemplateArgs, and CXNameRange_WantSinglePiece.

  • piece_index (Integer) —

    For contiguous names or when passing the flag CXNameRange_WantSinglePiece, only one piece with index 0 is available. When the CXNameRange_WantSinglePiece flag is not passed for a non-contiguous names, this index can be used to retrieve the individual pieces of the name. See also CXNameRange_WantSinglePiece.

Returns:

  • (SourceRange) —

    The piece of the name pointed to by the given cursor. If there is no name, or if the PieceIndex is out-of-range, a null-cursor will be returned.



4127
 
# File 'lib/ffi_gen/clang.rb', line 4127

attach_function :get_cursor_reference_name_range, :clang_getCursorReferenceNameRange, [Cursor.by_value, :uint, :uint], SourceRange.by_value

.get_cursor_referenced(cursor) ⇒ Cursor

For a cursor that is a reference, retrieve a cursor representing the entity that it references.

Reference cursors refer to other entities in the AST. For example, an Objective-C superclass reference cursor refers to an Objective-C class. This function produces the cursor for the Objective-C class from the cursor for the superclass reference. If the input cursor is a declaration or definition, it returns that declaration or definition unchanged. Otherwise, returns the NULL cursor.

Parameters:

Returns:



3683
 
# File 'lib/ffi_gen/clang.rb', line 3683

attach_function :get_cursor_referenced, :clang_getCursorReferenced, [Cursor.by_value], Cursor.by_value

.get_cursor_result_type(c) ⇒ Type

Retrieve the return type associated with a given cursor.

This only returns a valid type if the cursor refers to a function or method.

Parameters:

Returns:



3205
 
# File 'lib/ffi_gen/clang.rb', line 3205

attach_function :get_cursor_result_type, :clang_getCursorResultType, [Cursor.by_value], Type.by_value

.get_cursor_semantic_parent(cursor) ⇒ Cursor

Determine the semantic parent of the given cursor.

The semantic parent of a cursor is the cursor that semantically contains the given p cursor. For many declarations, the lexical and semantic parents are equivalent (the lexical parent is returned by c clang_getCursorLexicalParent()). They diverge when declarations or definitions are provided out-of-line. For example:

code class C 

void f();

;

void C::f() { } endcode

In the out-of-line definition of c C::f, the semantic parent is the class c C, of which this function is a member. The lexical parent is the place where the declaration actually occurs in the source code; in this case, the definition occurs in the translation unit. In general, the lexical parent for a given entity can change without affecting the semantics of the program, and the lexical parent of different declarations of the same entity may be different. Changing the semantic parent of a declaration, on the other hand, can have a major impact on semantics, and redeclarations of a particular entity should all have the same semantic context.

In the example above, both declarations of c C::f have c C as their semantic context, while the lexical context of the first c C::f is c C and the lexical context of the second c C::f is the translation unit.

For global declarations, the semantic parent is the translation unit.

Parameters:

Returns:



2583
 
# File 'lib/ffi_gen/clang.rb', line 2583

attach_function :get_cursor_semantic_parent, :clang_getCursorSemanticParent, [Cursor.by_value], Cursor.by_value

.get_cursor_spelling(cursor) ⇒ String

Retrieve a name for the entity referenced by this cursor.

Parameters:

Returns:



3641
 
# File 'lib/ffi_gen/clang.rb', line 3641

attach_function :get_cursor_spelling, :clang_getCursorSpelling, [Cursor.by_value], String.by_value

.get_cursor_type(c) ⇒ Type

Retrieve the type of a CXCursor (if any).

Parameters:

Returns:



2965
 
# File 'lib/ffi_gen/clang.rb', line 2965

attach_function :get_cursor_type, :clang_getCursorType, [Cursor.by_value], Type.by_value

.get_cursor_usr(cursor) ⇒ String

Retrieve a Unified Symbol Resolution (USR) for the entity referenced by the given cursor.

A Unified Symbol Resolution (USR) is a string that identifies a particular entity (function, class, variable, etc.) within a program. USRs can be compared across translation units to determine, e.g., when references in one translation refer to an entity defined in another translation unit.

Parameters:

Returns:



3577
 
# File 'lib/ffi_gen/clang.rb', line 3577

attach_function :get_cursor_usr, :clang_getCursorUSR, [Cursor.by_value], String.by_value

.get_cxtu_resource_usage(tu) ⇒ TUResourceUsage

Return the memory usage of a translation unit. This object

should be released with clang_disposeCXTUResourceUsage().

Parameters:

Returns:



1482
 
# File 'lib/ffi_gen/clang.rb', line 1482

attach_function :get_cxtu_resource_usage, :clang_getCXTUResourceUsage, [TranslationUnitImpl], TUResourceUsage.by_value

.get_cxx_access_specifier(cursor) ⇒ Symbol from _enum_cxx_access_specifier_

Returns the access control level for the referenced object.

If the cursor refers to a C++ declaration, its access control level within its parent scope is returned. Otherwise, if the cursor refers to a base specifier or access specifier, the specifier itself is returned.

Parameters:

Returns:



3460
 
# File 'lib/ffi_gen/clang.rb', line 3460

attach_function :get_cxx_access_specifier, :clang_getCXXAccessSpecifier, [Cursor.by_value], :cxx_access_specifier

.get_decl_obj_c_type_encoding(c) ⇒ String

Returns the Objective-C type encoding for the specified declaration.

Parameters:

Returns:



3136
 
# File 'lib/ffi_gen/clang.rb', line 3136

attach_function :get_decl_obj_c_type_encoding, :clang_getDeclObjCTypeEncoding, [Cursor.by_value], String.by_value

.get_definition_spelling_and_extent(cursor, start_buf, end_buf, start_line, start_column, end_line, end_column) ⇒ nil

(Not documented)

Parameters:

  • cursor (Cursor)
  • start_buf (FFI::Pointer(**CharS))
  • end_buf (FFI::Pointer(**CharS))
  • start_line (FFI::Pointer(*UInt))
  • start_column (FFI::Pointer(*UInt))
  • end_line (FFI::Pointer(*UInt))
  • end_column (FFI::Pointer(*UInt))

Returns:

  • (nil) 


4312
 
# File 'lib/ffi_gen/clang.rb', line 4312

attach_function :get_definition_spelling_and_extent, :clang_getDefinitionSpellingAndExtent, [Cursor.by_value, :pointer, :pointer, :pointer, :pointer, :pointer, :pointer], :void

.get_diagnostic(unit, index) ⇒ FFI::Pointer(Diagnostic)

Retrieve a diagnostic associated with the given translation unit.

Parameters:

  • unit (TranslationUnitImpl) —

    the translation unit to query.

  • index (Integer) —

    the zero-based diagnostic number to retrieve.

Returns:

  • (FFI::Pointer(Diagnostic)) —

    the requested diagnostic. This diagnostic must be freed via a call to c clang_disposeDiagnostic().



751
 
# File 'lib/ffi_gen/clang.rb', line 751

attach_function :get_diagnostic, :clang_getDiagnostic, [TranslationUnitImpl, :uint], :pointer

.get_diagnostic_category(diagnostic) ⇒ Integer

Retrieve the category number for this diagnostic.

Diagnostics can be categorized into groups along with other, related diagnostics (e.g., diagnostics under the same warning flag). This routine retrieves the category number for the given diagnostic.

Parameters:

  • diagnostic (FFI::Pointer(Diagnostic))

Returns:

  • (Integer) —

    The number of the category that contains this diagnostic, or zero if this diagnostic is uncategorized.



907
 
# File 'lib/ffi_gen/clang.rb', line 907

attach_function :get_diagnostic_category, :clang_getDiagnosticCategory, [:pointer], :uint

.get_diagnostic_category_name(category) ⇒ String

Retrieve the name of a particular diagnostic category. This

is now deprecated.  Use clang_getDiagnosticCategoryText()
instead.

Parameters:

  • category (Integer) —

    A diagnostic category number, as returned by c clang_getDiagnosticCategory().

Returns:

  • (String) —

    The name of the given diagnostic category.



918
 
# File 'lib/ffi_gen/clang.rb', line 918

attach_function :get_diagnostic_category_name, :clang_getDiagnosticCategoryName, [:uint], String.by_value

.get_diagnostic_category_text(diagnostic) ⇒ String

Retrieve the diagnostic category text for a given diagnostic.

Parameters:

  • diagnostic (FFI::Pointer(Diagnostic))

Returns:

  • (String) —

    The text of the given diagnostic category.



926
 
# File 'lib/ffi_gen/clang.rb', line 926

attach_function :get_diagnostic_category_text, :clang_getDiagnosticCategoryText, [:pointer], String.by_value

.get_diagnostic_fix_it(diagnostic, fix_it, replacement_range) ⇒ String

Retrieve the replacement information for a given fix-it.

Fix-its are described in terms of a source range whose contents should be replaced by a string. This approach generalizes over three kinds of operations: removal of source code (the range covers the code to be removed and the replacement string is empty), replacement of source code (the range covers the code to be replaced and the replacement string provides the new code), and insertion (both the start and end of the range point at the insertion location, and the replacement string provides the text to insert).

Parameters:

  • diagnostic (FFI::Pointer(Diagnostic)) —

    The diagnostic whose fix-its are being queried.

  • fix_it (Integer) —

    The zero-based index of the fix-it.

  • replacement_range (SourceRange) —

    The source range whose contents will be replaced with the returned replacement string. Note that source ranges are half-open ranges (a, b), so the source code should be replaced from a and up to (but not including) b.

Returns:

  • (String) —

    A string containing text that should be replace the source code indicated by the c ReplacementRange.



981
 
# File 'lib/ffi_gen/clang.rb', line 981

attach_function :get_diagnostic_fix_it, :clang_getDiagnosticFixIt, [:pointer, :uint, SourceRange], String.by_value

.get_diagnostic_in_set(diags, index) ⇒ FFI::Pointer(Diagnostic)

Retrieve a diagnostic associated with the given CXDiagnosticSet.

Parameters:

  • diags (FFI::Pointer(DiagnosticSet)) —

    the CXDiagnosticSet to query.

  • index (Integer) —

    the zero-based diagnostic number to retrieve.

Returns:

  • (FFI::Pointer(Diagnostic)) —

    the requested diagnostic. This diagnostic must be freed via a call to c clang_disposeDiagnostic().



671
 
# File 'lib/ffi_gen/clang.rb', line 671

attach_function :get_diagnostic_in_set, :clang_getDiagnosticInSet, [:pointer, :uint], :pointer

.get_diagnostic_location(diagnostic) ⇒ SourceLocation

Retrieve the source location of the given diagnostic.

This location is where Clang would print the caret (‘^’) when displaying the diagnostic on the command line.

Parameters:

  • diagnostic (FFI::Pointer(Diagnostic))

Returns:



874
 
# File 'lib/ffi_gen/clang.rb', line 874

attach_function :get_diagnostic_location, :clang_getDiagnosticLocation, [:pointer], SourceLocation.by_value

.get_diagnostic_num_fix_its(diagnostic) ⇒ Integer

Determine the number of fix-it hints associated with the given diagnostic.

Parameters:

  • diagnostic (FFI::Pointer(Diagnostic))

Returns:

  • (Integer) 


957
 
# File 'lib/ffi_gen/clang.rb', line 957

attach_function :get_diagnostic_num_fix_its, :clang_getDiagnosticNumFixIts, [:pointer], :uint

.get_diagnostic_num_ranges(diagnostic) ⇒ Integer

Determine the number of source ranges associated with the given diagnostic.

Parameters:

  • diagnostic (FFI::Pointer(Diagnostic))

Returns:

  • (Integer) 


935
 
# File 'lib/ffi_gen/clang.rb', line 935

attach_function :get_diagnostic_num_ranges, :clang_getDiagnosticNumRanges, [:pointer], :uint

.get_diagnostic_option(diag, disable) ⇒ String

Retrieve the name of the command-line option that enabled this diagnostic.

Parameters:

  • diag (FFI::Pointer(Diagnostic)) —

    The diagnostic to be queried.

  • disable (String) —

    If non-NULL, will be set to the option that disables this diagnostic (if any).

Returns:

  • (String) —

    A string that contains the command-line option used to enable this warning, such as “-Wconversion” or “-pedantic”.



894
 
# File 'lib/ffi_gen/clang.rb', line 894

attach_function :get_diagnostic_option, :clang_getDiagnosticOption, [:pointer, String], String.by_value

.get_diagnostic_range(diagnostic, range) ⇒ SourceRange

Retrieve a source range associated with the diagnostic.

A diagnostic’s source ranges highlight important elements in the source code. On the command line, Clang displays source ranges by underlining them with ‘~’ characters.

Parameters:

  • diagnostic (FFI::Pointer(Diagnostic)) —

    the diagnostic whose range is being extracted.

  • range (Integer) —

    the zero-based index specifying which range to

Returns:



948
 
# File 'lib/ffi_gen/clang.rb', line 948

attach_function :get_diagnostic_range, :clang_getDiagnosticRange, [:pointer, :uint], SourceRange.by_value

.get_diagnostic_set_from_tu(unit) ⇒ FFI::Pointer(DiagnosticSet)

Retrieve the complete set of diagnostics associated with a

translation unit.

Parameters:

Returns:

  • (FFI::Pointer(DiagnosticSet)) 


760
 
# File 'lib/ffi_gen/clang.rb', line 760

attach_function :get_diagnostic_set_from_tu, :clang_getDiagnosticSetFromTU, [TranslationUnitImpl], :pointer

.get_diagnostic_severity(diagnostic) ⇒ Symbol from _enum_diagnostic_severity_

Determine the severity of the given diagnostic.

Parameters:

  • diagnostic (FFI::Pointer(Diagnostic))

Returns:



863
 
# File 'lib/ffi_gen/clang.rb', line 863

attach_function :get_diagnostic_severity, :clang_getDiagnosticSeverity, [:pointer], :diagnostic_severity

.get_diagnostic_spelling(diagnostic) ⇒ String

Retrieve the text of the given diagnostic.

Parameters:

  • diagnostic (FFI::Pointer(Diagnostic))

Returns:



882
 
# File 'lib/ffi_gen/clang.rb', line 882

attach_function :get_diagnostic_spelling, :clang_getDiagnosticSpelling, [:pointer], String.by_value

.get_element_type(t) ⇒ Type

Return the element type of an array, complex, or vector type.

If a type is passed in that is not an array, complex, or vector type, an invalid type is returned.

Parameters:

Returns:



3225
 
# File 'lib/ffi_gen/clang.rb', line 3225

attach_function :get_element_type, :clang_getElementType, [Type.by_value], Type.by_value

.get_enum_constant_decl_unsigned_value(c) ⇒ Integer

Retrieve the integer value of an enum constant declaration as an unsigned

long long.

If the cursor does not reference an enum constant declaration, ULLONG_MAX is returned. Since this is also potentially a valid constant value, the kind of the cursor must be verified before calling this function.

Parameters:

Returns:

  • (Integer) 


3024
 
# File 'lib/ffi_gen/clang.rb', line 3024

attach_function :get_enum_constant_decl_unsigned_value, :clang_getEnumConstantDeclUnsignedValue, [Cursor.by_value], :ulong_long

.get_enum_constant_decl_value(c) ⇒ Integer

Retrieve the integer value of an enum constant declaration as a signed

long long.

If the cursor does not reference an enum constant declaration, LLONG_MIN is returned. Since this is also potentially a valid constant value, the kind of the cursor must be verified before calling this function.

Parameters:

Returns:

  • (Integer) 


3011
 
# File 'lib/ffi_gen/clang.rb', line 3011

attach_function :get_enum_constant_decl_value, :clang_getEnumConstantDeclValue, [Cursor.by_value], :long_long

.get_enum_decl_integer_type(c) ⇒ Type

Retrieve the integer type of an enum declaration.

If the cursor does not reference an enum declaration, an invalid type is returned.

Parameters:

Returns:



2998
 
# File 'lib/ffi_gen/clang.rb', line 2998

attach_function :get_enum_decl_integer_type, :clang_getEnumDeclIntegerType, [Cursor.by_value], Type.by_value

.get_expansion_location(location, file, line, column, offset) ⇒ nil

Retrieve the file, line, column, and offset represented by the given source location.

If the location refers into a macro expansion, retrieves the location of the macro expansion.

Parameters:

  • location (SourceLocation) —

    the location within a source file that will be decomposed into its parts.

  • file (FFI::Pointer(*File)) —

    (out) if non-NULL, will be set to the file to which the given source location points.

  • line (FFI::Pointer(*UInt)) —

    (out) if non-NULL, will be set to the line to which the given source location points.

  • column (FFI::Pointer(*UInt)) —

    (out) if non-NULL, will be set to the column to which the given source location points.

  • offset (FFI::Pointer(*UInt)) —

    (out) if non-NULL, will be set to the offset into the buffer to which the given source location points.

Returns:

  • (nil) 


471
 
# File 'lib/ffi_gen/clang.rb', line 471

attach_function :get_expansion_location, :clang_getExpansionLocation, [SourceLocation.by_value, :pointer, :pointer, :pointer, :pointer], :void

.get_field_decl_bit_width(c) ⇒ Integer

Retrieve the bit width of a bit field declaration as an integer.

If a cursor that is not a bit field declaration is passed in, -1 is returned.

Parameters:

Returns:

  • (Integer) 


3034
 
# File 'lib/ffi_gen/clang.rb', line 3034

attach_function :get_field_decl_bit_width, :clang_getFieldDeclBitWidth, [Cursor.by_value], :int

.get_file(tu, file_name) ⇒ FFI::Pointer(File)

Retrieve a file handle within the given translation unit.

Parameters:

Returns:

  • (FFI::Pointer(File)) —

    the file handle for the named file in the translation unit p tu, or a NULL file handle if the file was not a part of this translation unit.



323
 
# File 'lib/ffi_gen/clang.rb', line 323

attach_function :get_file, :clang_getFile, [TranslationUnitImpl, :string], :pointer

.get_file_location(location, file, line, column, offset) ⇒ nil

Retrieve the file, line, column, and offset represented by the given source location.

If the location refers into a macro expansion, return where the macro was expanded or where the macro argument was written, if the location points at a macro argument.

Parameters:

  • location (SourceLocation) —

    the location within a source file that will be decomposed into its parts.

  • file (FFI::Pointer(*File)) —

    (out) if non-NULL, will be set to the file to which the given source location points.

  • line (FFI::Pointer(*UInt)) —

    (out) if non-NULL, will be set to the line to which the given source location points.

  • column (FFI::Pointer(*UInt)) —

    (out) if non-NULL, will be set to the column to which the given source location points.

  • offset (FFI::Pointer(*UInt)) —

    (out) if non-NULL, will be set to the offset into the buffer to which the given source location points.

Returns:

  • (nil) 


571
 
# File 'lib/ffi_gen/clang.rb', line 571

attach_function :get_file_location, :clang_getFileLocation, [SourceLocation.by_value, :pointer, :pointer, :pointer, :pointer], :void

.get_file_name(s_file) ⇒ String

Retrieve the complete file and path name of the given file.

Parameters:

  • s_file (FFI::Pointer(File))

Returns:



274
 
# File 'lib/ffi_gen/clang.rb', line 274

attach_function :get_file_name, :clang_getFileName, [:pointer], String.by_value

.get_file_time(s_file) ⇒ Integer

Retrieve the last modification time of the given file.

Parameters:

  • s_file (FFI::Pointer(File))

Returns:

  • (Integer) 


282
 
# File 'lib/ffi_gen/clang.rb', line 282

attach_function :get_file_time, :clang_getFileTime, [:pointer], :long

.get_file_unique_id(file, out_id) ⇒ Integer

Retrieve the unique ID for the given c file.

Parameters:

  • file (FFI::Pointer(File)) —

    the file to get the ID for.

  • out_id (FileUniqueID) —

    stores the returned CXFileUniqueID.

Returns:

  • (Integer) —

    If there was a failure getting the unique ID, returns non-zero, otherwise returns 0.



302
 
# File 'lib/ffi_gen/clang.rb', line 302

attach_function :get_file_unique_id, :clang_getFileUniqueID, [:pointer, FileUniqueID], :int

.get_function_type_calling_conv(t) ⇒ Symbol from _enum_calling_conv_

Retrieve the calling convention associated with a function type.

If a non-function type is passed in, CXCallingConv_Invalid is returned.

Parameters:

Returns:



3154
 
# File 'lib/ffi_gen/clang.rb', line 3154

attach_function :get_function_type_calling_conv, :clang_getFunctionTypeCallingConv, [Type.by_value], :calling_conv

.get_ib_outlet_collection_type(cursor) ⇒ Type

For cursors representing an iboutletcollection attribute,

this function returns the collection element type.

Parameters:

Returns:



3493
 
# File 'lib/ffi_gen/clang.rb', line 3493

attach_function :get_ib_outlet_collection_type, :clang_getIBOutletCollectionType, [Cursor.by_value], Type.by_value

.get_included_file(cursor) ⇒ FFI::Pointer(File)

Retrieve the file that is included by the given inclusion directive cursor.

Parameters:

Returns:

  • (FFI::Pointer(File)) 


2684
 
# File 'lib/ffi_gen/clang.rb', line 2684

attach_function :get_included_file, :clang_getIncludedFile, [Cursor.by_value], :pointer

.get_inclusions(tu, visitor, client_data) ⇒ nil

Visit the set of preprocessor inclusions in a translation unit.

The visitor function is called with the provided data for every included
file.  This does not include headers included by the PCH file (unless one
is inspecting the inclusions in the PCH file itself).

Parameters:

Returns:

  • (nil) 


4977
 
# File 'lib/ffi_gen/clang.rb', line 4977

attach_function :get_inclusions, :clang_getInclusions, [TranslationUnitImpl, :inclusion_visitor, :pointer], :void

.get_instantiation_location(location, file, line, column, offset) ⇒ nil

Legacy API to retrieve the file, line, column, and offset represented by the given source location.

This interface has been replaced by the newer interface #clang_getExpansionLocation(). See that interface’s documentation for details.

Parameters:

  • location (SourceLocation)
  • file (FFI::Pointer(*File))
  • line (FFI::Pointer(*UInt))
  • column (FFI::Pointer(*UInt))
  • offset (FFI::Pointer(*UInt))

Returns:

  • (nil) 


528
 
# File 'lib/ffi_gen/clang.rb', line 528

attach_function :get_instantiation_location, :clang_getInstantiationLocation, [SourceLocation.by_value, :pointer, :pointer, :pointer, :pointer], :void

.get_location(tu, file, line, column) ⇒ SourceLocation

Retrieves the source location associated with a given file/line/column in a particular translation unit.

Parameters:

Returns:



388
 
# File 'lib/ffi_gen/clang.rb', line 388

attach_function :get_location, :clang_getLocation, [TranslationUnitImpl, :pointer, :uint, :uint], SourceLocation.by_value

.get_location_for_offset(tu, file, offset) ⇒ SourceLocation

Retrieves the source location associated with a given character offset in a particular translation unit.

Parameters:

Returns:



399
 
# File 'lib/ffi_gen/clang.rb', line 399

attach_function :get_location_for_offset, :clang_getLocationForOffset, [TranslationUnitImpl, :pointer, :uint], SourceLocation.by_value

.get_module_for_file(translation_unit_impl, file) ⇒ FFI::Pointer(Module)

Given a CXFile header file, return the module that contains it, if one exists.

Parameters:

Returns:

  • (FFI::Pointer(Module)) 


3963
 
# File 'lib/ffi_gen/clang.rb', line 3963

attach_function :get_module_for_file, :clang_getModuleForFile, [TranslationUnitImpl, :pointer], :pointer

.get_null_cursor ⇒ Cursor

Retrieve the NULL cursor, which represents no entity.

Returns:



2225
 
# File 'lib/ffi_gen/clang.rb', line 2225

attach_function :get_null_cursor, :clang_getNullCursor, [], Cursor.by_value

.get_null_location ⇒ SourceLocation

Retrieve a NULL (invalid) source location.

Returns:



364
 
# File 'lib/ffi_gen/clang.rb', line 364

attach_function :get_null_location, :clang_getNullLocation, [], SourceLocation.by_value

.get_null_range ⇒ SourceRange

Retrieve a NULL (invalid) source range.

Returns:



423
 
# File 'lib/ffi_gen/clang.rb', line 423

attach_function :get_null_range, :clang_getNullRange, [], SourceRange.by_value

.get_num_arg_types(t) ⇒ Integer

Retrieve the number of non-variadic parameters associated with a function type.

If a non-function type is passed in, -1 is returned.

Parameters:

Returns:

  • (Integer) 


3175
 
# File 'lib/ffi_gen/clang.rb', line 3175

attach_function :get_num_arg_types, :clang_getNumArgTypes, [Type.by_value], :int

.get_num_completion_chunks(completion_string) ⇒ Integer

Retrieve the number of chunks in the given code-completion string.

Parameters:

  • completion_string (FFI::Pointer(CompletionString))

Returns:

  • (Integer) 


4543
 
# File 'lib/ffi_gen/clang.rb', line 4543

attach_function :get_num_completion_chunks, :clang_getNumCompletionChunks, [:pointer], :uint

.get_num_diagnostics(unit) ⇒ Integer

Determine the number of diagnostics produced for the given translation unit.

Parameters:

Returns:

  • (Integer) 


741
 
# File 'lib/ffi_gen/clang.rb', line 741

attach_function :get_num_diagnostics, :clang_getNumDiagnostics, [TranslationUnitImpl], :uint

.get_num_diagnostics_in_set(diags) ⇒ Integer

Determine the number of diagnostics in a CXDiagnosticSet.

Parameters:

  • diags (FFI::Pointer(DiagnosticSet))

Returns:

  • (Integer) 


661
 
# File 'lib/ffi_gen/clang.rb', line 661

attach_function :get_num_diagnostics_in_set, :clang_getNumDiagnosticsInSet, [:pointer], :uint

.get_num_elements(t) ⇒ Integer

Return the number of elements of an array or vector type.

If a type is passed in that is not an array or vector type, -1 is returned.

Parameters:

Returns:

  • (Integer) 


3236
 
# File 'lib/ffi_gen/clang.rb', line 3236

attach_function :get_num_elements, :clang_getNumElements, [Type.by_value], :long_long

.get_num_overloaded_decls(cursor) ⇒ Integer

Determine the number of overloaded declarations referenced by a c CXCursor_OverloadedDeclRef cursor.

Parameters:

  • cursor (Cursor) —

    The cursor whose overloaded declarations are being queried.

Returns:

  • (Integer) —

    The number of overloaded declarations referenced by c cursor. If it is not a c CXCursor_OverloadedDeclRef cursor, returns 0.



3470
 
# File 'lib/ffi_gen/clang.rb', line 3470

attach_function :get_num_overloaded_decls, :clang_getNumOverloadedDecls, [Cursor.by_value], :uint

.get_overloaded_decl(cursor, index) ⇒ Cursor

Retrieve a cursor for one of the overloaded declarations referenced by a c CXCursor_OverloadedDeclRef cursor.

Parameters:

  • cursor (Cursor) —

    The cursor whose overloaded declarations are being queried.

  • index (Integer) —

    The zero-based index into the set of overloaded declarations in the cursor.

Returns:

  • (Cursor) —

    A cursor representing the declaration referenced by the given c cursor at the specified c index. If the cursor does not have an associated set of overloaded declarations, or if the index is out of bounds, returns c clang_getNullCursor();



3484
 
# File 'lib/ffi_gen/clang.rb', line 3484

attach_function :get_overloaded_decl, :clang_getOverloadedDecl, [Cursor.by_value, :uint], Cursor.by_value

.get_overridden_cursors(cursor, overridden, num_overridden) ⇒ nil

Determine the set of methods that are overridden by the given method.

In both Objective-C and C++, a method (aka virtual member function, in C++) can override a virtual method in a base class. For Objective-C, a method is said to override any method in the class’s base class, its protocols, or its categories’ protocols, that has the same selector and is of the same kind (class or instance). If no such method exists, the search continues to the class’s superclass, its protocols, and its categories, and so on. A method from an Objective-C implementation is considered to override the same methods as its corresponding method in the interface.

For C++, a virtual member function overrides any virtual member function with the same signature that occurs in its base classes. With multiple inheritance, a virtual member function can override several virtual member functions coming from different base classes.

In all cases, this function determines the immediate overridden method, rather than all of the overridden methods. For example, if a method is originally declared in a class A, then overridden in B (which in inherits from A) and also in C (which inherited from B), then the only overridden method returned from this function when invoked on C’s method will be B’s method. The client may then invoke this function again, given the previously-found overridden methods, to map out the complete method-override set.

Parameters:

  • cursor (Cursor) —

    A cursor representing an Objective-C or C++ method. This routine will compute the set of methods that this method overrides.

  • overridden (FFI::Pointer(**Cursor)) —

    A pointer whose pointee will be replaced with a pointer to an array of cursors, representing the set of overridden methods. If there are no overridden methods, the pointee will be set to NULL. The pointee must be freed via a call to c clang_disposeOverriddenCursors().

  • num_overridden (FFI::Pointer(*UInt)) —

    A pointer to the number of overridden functions, will be set to the number of overridden functions in the array pointed to by p overridden.

Returns:

  • (nil) 


2666
 
# File 'lib/ffi_gen/clang.rb', line 2666

attach_function :get_overridden_cursors, :clang_getOverriddenCursors, [Cursor.by_value, :pointer, :pointer], :void

.get_pointee_type(t) ⇒ Type

For pointer types, returns the type of the pointee.

Parameters:

Returns:



3120
 
# File 'lib/ffi_gen/clang.rb', line 3120

attach_function :get_pointee_type, :clang_getPointeeType, [Type.by_value], Type.by_value

.get_presumed_location(location, filename, line, column) ⇒ nil

Retrieve the file, line, column, and offset represented by the given source location, as specified in a # line directive.

Example: given the following source code in a file somefile.c

code #123 “dummy.c” 1

static int func(void) 

return 0;

endcode

the location information returned by this function would be

File: dummy.c Line: 124 Column: 12

whereas clang_getExpansionLocation would have returned

File: somefile.c Line: 3 Column: 12

Parameters:

  • location (SourceLocation) —

    the location within a source file that will be decomposed into its parts.

  • filename (String) —

    (out) if non-NULL, will be set to the filename of the source location. Note that filenames returned will be for “virtual” files, which don’t necessarily exist on the machine running clang - e.g. when parsing preprocessed output obtained from a different environment. If a non-NULL value is passed in, remember to dispose of the returned value using c clang_disposeString() once you’ve finished with it. For an invalid source location, an empty string is returned.

  • line (FFI::Pointer(*UInt)) —

    (out) if non-NULL, will be set to the line number of the source location. For an invalid source location, zero is returned.

  • column (FFI::Pointer(*UInt)) —

    (out) if non-NULL, will be set to the column number of the source location. For an invalid source location, zero is returned.

Returns:

  • (nil) 


511
 
# File 'lib/ffi_gen/clang.rb', line 511

attach_function :get_presumed_location, :clang_getPresumedLocation, [SourceLocation.by_value, String, :pointer, :pointer], :void

.get_range(begin_, end_) ⇒ SourceRange

Retrieve a source range given the beginning and ending source locations.

Parameters:

Returns:



433
 
# File 'lib/ffi_gen/clang.rb', line 433

attach_function :get_range, :clang_getRange, [SourceLocation.by_value, SourceLocation.by_value], SourceRange.by_value

.get_range_end(range) ⇒ SourceLocation

Retrieve a source location representing the last character within a source range.

Parameters:

Returns:



589
 
# File 'lib/ffi_gen/clang.rb', line 589

attach_function :get_range_end, :clang_getRangeEnd, [SourceRange.by_value], SourceLocation.by_value

.get_range_start(range) ⇒ SourceLocation

Retrieve a source location representing the first character within a source range.

Parameters:

Returns:



580
 
# File 'lib/ffi_gen/clang.rb', line 580

attach_function :get_range_start, :clang_getRangeStart, [SourceRange.by_value], SourceLocation.by_value

.get_remappings(path) ⇒ FFI::Pointer(Remapping)

Retrieve a remapping.

Parameters:

  • path (String) —

    the path that contains metadata about remappings.

Returns:

  • (FFI::Pointer(Remapping)) —

    the requested remapping. This remapping must be freed via a call to c clang_remap_dispose(). Can return NULL if an error occurred.



4986
 
# File 'lib/ffi_gen/clang.rb', line 4986

attach_function :get_remappings, :clang_getRemappings, [:string], :pointer

.get_remappings_from_file_list(file_paths, num_files) ⇒ FFI::Pointer(Remapping)

Retrieve a remapping.

Parameters:

  • file_paths (FFI::Pointer(**CharS)) —

    pointer to an array of file paths containing remapping info.

  • num_files (Integer) —

    number of file paths.

Returns:

  • (FFI::Pointer(Remapping)) —

    the requested remapping. This remapping must be freed via a call to c clang_remap_dispose(). Can return NULL if an error occurred.



4996
 
# File 'lib/ffi_gen/clang.rb', line 4996

attach_function :get_remappings_from_file_list, :clang_getRemappingsFromFileList, [:pointer, :uint], :pointer

.get_result_type(t) ⇒ Type

Retrieve the return type associated with a function type.

If a non-function type is passed in, an invalid type is returned.

Parameters:

Returns:



3164
 
# File 'lib/ffi_gen/clang.rb', line 3164

attach_function :get_result_type, :clang_getResultType, [Type.by_value], Type.by_value

.get_skipped_ranges(tu, file) ⇒ SourceRangeList

Retrieve all ranges that were skipped by the preprocessor.

The preprocessor will skip lines when they are surrounded by an if/ifdef/ifndef directive whose condition does not evaluate to true.

Parameters:

Returns:



613
 
# File 'lib/ffi_gen/clang.rb', line 613

attach_function :get_skipped_ranges, :clang_getSkippedRanges, [TranslationUnitImpl, :pointer], SourceRangeList

.get_specialized_cursor_template(c) ⇒ Cursor

Given a cursor that may represent a specialization or instantiation of a template, retrieve the cursor that represents the template that it specializes or from which it was instantiated.

This routine determines the template involved both for explicit specializations of templates and for implicit instantiations of the template, both of which are referred to as “specializations”. For a class template specialization (e.g., c std::vector<bool>), this routine will return either the primary template (c std::vector) or, if the specialization was instantiated from a class template partial specialization, the class template partial specialization. For a class template partial specialization and a function template specialization (including instantiations), this this routine will return the specialized template.

For members of a class template (e.g., member functions, member classes, or static data members), returns the specialized or instantiated member. Although not strictly “templates” in the C++ language, members of class templates have the same notions of specializations and instantiations that templates do, so this routine treats them similarly.

Parameters:

  • c (Cursor) —

    A cursor that may be a specialization of a template or a member of a template.

Returns:

  • (Cursor) —

    If the given cursor is a specialization or instantiation of a template or a member thereof, the template or member that it specializes or from which it was instantiated. Otherwise, returns a NULL cursor.



4108
 
# File 'lib/ffi_gen/clang.rb', line 4108

attach_function :get_specialized_cursor_template, :clang_getSpecializedCursorTemplate, [Cursor.by_value], Cursor.by_value

.get_spelling_location(location, file, line, column, offset) ⇒ nil

Retrieve the file, line, column, and offset represented by the given source location.

If the location refers into a macro instantiation, return where the location was originally spelled in the source file.

Parameters:

  • location (SourceLocation) —

    the location within a source file that will be decomposed into its parts.

  • file (FFI::Pointer(*File)) —

    (out) if non-NULL, will be set to the file to which the given source location points.

  • line (FFI::Pointer(*UInt)) —

    (out) if non-NULL, will be set to the line to which the given source location points.

  • column (FFI::Pointer(*UInt)) —

    (out) if non-NULL, will be set to the column to which the given source location points.

  • offset (FFI::Pointer(*UInt)) —

    (out) if non-NULL, will be set to the offset into the buffer to which the given source location points.

Returns:

  • (nil) 


549
 
# File 'lib/ffi_gen/clang.rb', line 549

attach_function :get_spelling_location, :clang_getSpellingLocation, [SourceLocation.by_value, :pointer, :pointer, :pointer, :pointer], :void

.get_template_cursor_kind(c) ⇒ Symbol from _enum_cursor_kind_

Given a cursor that represents a template, determine the cursor kind of the specializations would be generated by instantiating the template.

This routine can be used to determine what flavor of function template, class template, or class template partial specialization is stored in the cursor. For example, it can describe whether a class template cursor is declared with “struct”, “class” or “union”.

Parameters:

  • c (Cursor) —

    The cursor to query. This cursor should represent a template declaration.

Returns:

  • (Symbol from _enum_cursor_kind_) —

    The cursor kind of the specializations that would be generated by instantiating the template p C. If p C is not a template, returns c CXCursor_NoDeclFound.



4079
 
# File 'lib/ffi_gen/clang.rb', line 4079

attach_function :get_template_cursor_kind, :clang_getTemplateCursorKind, [Cursor.by_value], :cursor_kind

.get_token_extent(translation_unit_impl, token) ⇒ SourceRange

Retrieve a source range that covers the given token.

Parameters:

Returns:



4234
 
# File 'lib/ffi_gen/clang.rb', line 4234

attach_function :get_token_extent, :clang_getTokenExtent, [TranslationUnitImpl, Token.by_value], SourceRange.by_value

.get_token_kind(token) ⇒ Symbol from _enum_token_kind_

Determine the kind of the given token.

Parameters:

Returns:



4204
 
# File 'lib/ffi_gen/clang.rb', line 4204

attach_function :get_token_kind, :clang_getTokenKind, [Token.by_value], :token_kind

.get_token_location(translation_unit_impl, token) ⇒ SourceLocation

Retrieve the source location of the given token.

Parameters:

Returns:



4225
 
# File 'lib/ffi_gen/clang.rb', line 4225

attach_function :get_token_location, :clang_getTokenLocation, [TranslationUnitImpl, Token.by_value], SourceLocation.by_value

.get_token_spelling(translation_unit_impl, token) ⇒ String

Determine the spelling of the given token.

The spelling of a token is the textual representation of that token, e.g., the text of an identifier or keyword.

Parameters:

Returns:



4216
 
# File 'lib/ffi_gen/clang.rb', line 4216

attach_function :get_token_spelling, :clang_getTokenSpelling, [TranslationUnitImpl, Token.by_value], String.by_value

.get_translation_unit_cursor(translation_unit_impl) ⇒ Cursor

Retrieve the cursor that represents the given translation unit.

The translation unit cursor can be used to start traversing the various declarations within the given translation unit.

Parameters:

Returns:



2236
 
# File 'lib/ffi_gen/clang.rb', line 2236

attach_function :get_translation_unit_cursor, :clang_getTranslationUnitCursor, [TranslationUnitImpl], Cursor.by_value

.get_translation_unit_spelling(ct_unit) ⇒ String

Get the original translation unit source file name.

Parameters:

Returns:



989
 
# File 'lib/ffi_gen/clang.rb', line 989

attach_function :get_translation_unit_spelling, :clang_getTranslationUnitSpelling, [TranslationUnitImpl], String.by_value

.get_tu_resource_usage_name(kind) ⇒ String

Returns the human-readable null-terminated C string that represents

the name of the memory category.  This string should never be freed.

Parameters:

Returns:



1444
 
# File 'lib/ffi_gen/clang.rb', line 1444

attach_function :get_tu_resource_usage_name, :clang_getTUResourceUsageName, [:tu_resource_usage_kind], :string

.get_type_declaration(t) ⇒ Cursor

Return the cursor for the declaration of the given type.

Parameters:

Returns:



3128
 
# File 'lib/ffi_gen/clang.rb', line 3128

attach_function :get_type_declaration, :clang_getTypeDeclaration, [Type.by_value], Cursor.by_value

.get_type_kind_spelling(k) ⇒ String

Retrieve the spelling of a given CXTypeKind.

Parameters:

Returns:



3144
 
# File 'lib/ffi_gen/clang.rb', line 3144

attach_function :get_type_kind_spelling, :clang_getTypeKindSpelling, [:type_kind], String.by_value

.get_type_spelling(ct) ⇒ String

Pretty-print the underlying type using the rules of the language of the translation unit from which it came.

If the type is invalid, an empty string is returned.

Parameters:

Returns:



2976
 
# File 'lib/ffi_gen/clang.rb', line 2976

attach_function :get_type_spelling, :clang_getTypeSpelling, [Type.by_value], String.by_value

.get_typedef_decl_underlying_type(c) ⇒ Type

Retrieve the underlying type of a typedef declaration.

If the cursor does not reference a typedef declaration, an invalid type is returned.

Parameters:

Returns:



2987
 
# File 'lib/ffi_gen/clang.rb', line 2987

attach_function :get_typedef_decl_underlying_type, :clang_getTypedefDeclUnderlyingType, [Cursor.by_value], Type.by_value

.hash_cursor(cursor) ⇒ Integer

Compute a hash value for the given cursor.

Parameters:

Returns:

  • (Integer) 


2261
 
# File 'lib/ffi_gen/clang.rb', line 2261

attach_function :hash_cursor, :clang_hashCursor, [Cursor.by_value], :uint

.index_action_create(c_idx) ⇒ FFI::Pointer(IndexAction)

An indexing action/session, to be applied to one or multiple translation units.

Parameters:

  • c_idx (FFI::Pointer(Index)) —

    The index object with which the index action will be associated.

Returns:

  • (FFI::Pointer(IndexAction)) 


5802
 
# File 'lib/ffi_gen/clang.rb', line 5802

attach_function :index_action_create, :clang_IndexAction_create, [:pointer], :pointer

.index_action_dispose(index_action) ⇒ nil

Destroy the given index action.

The index action must not be destroyed until all of the translation units created within that index action have been destroyed.

Parameters:

  • index_action (FFI::Pointer(IndexAction))

Returns:

  • (nil) 


5813
 
# File 'lib/ffi_gen/clang.rb', line 5813

attach_function :index_action_dispose, :clang_IndexAction_dispose, [:pointer], :void

.index_get_client_container(idx_container_info) ⇒ FFI::Pointer(IdxClientContainer)

For retrieving a custom CXIdxClientContainer attached to a container.

Parameters:

Returns:

  • (FFI::Pointer(IdxClientContainer)) 


5766
 
# File 'lib/ffi_gen/clang.rb', line 5766

attach_function :index_get_client_container, :clang_index_getClientContainer, [IdxContainerInfo], :pointer

.index_get_client_entity(idx_entity_info) ⇒ FFI::Pointer(IdxClientEntity)

For retrieving a custom CXIdxClientEntity attached to an entity.

Parameters:

Returns:

  • (FFI::Pointer(IdxClientEntity)) 


5784
 
# File 'lib/ffi_gen/clang.rb', line 5784

attach_function :index_get_client_entity, :clang_index_getClientEntity, [IdxEntityInfo], :pointer

.index_get_cxx_class_decl_info(idx_decl_info) ⇒ IdxCXXClassDeclInfo

(Not documented)

Parameters:

Returns:



5757
 
# File 'lib/ffi_gen/clang.rb', line 5757

attach_function :index_get_cxx_class_decl_info, :clang_index_getCXXClassDeclInfo, [IdxDeclInfo], IdxCXXClassDeclInfo

.index_get_ib_outlet_collection_attr_info(idx_attr_info) ⇒ IdxIBOutletCollectionAttrInfo

(Not documented)

Parameters:

Returns:



5749
 
# File 'lib/ffi_gen/clang.rb', line 5749

attach_function :index_get_ib_outlet_collection_attr_info, :clang_index_getIBOutletCollectionAttrInfo, [IdxAttrInfo], IdxIBOutletCollectionAttrInfo

.index_get_obj_c_category_decl_info(idx_decl_info) ⇒ IdxObjCCategoryDeclInfo

(Not documented)

Parameters:

Returns:



5725
 
# File 'lib/ffi_gen/clang.rb', line 5725

attach_function :index_get_obj_c_category_decl_info, :clang_index_getObjCCategoryDeclInfo, [IdxDeclInfo], IdxObjCCategoryDeclInfo

.index_get_obj_c_container_decl_info(idx_decl_info) ⇒ IdxObjCContainerDeclInfo

(Not documented)

Parameters:

Returns:



5709
 
# File 'lib/ffi_gen/clang.rb', line 5709

attach_function :index_get_obj_c_container_decl_info, :clang_index_getObjCContainerDeclInfo, [IdxDeclInfo], IdxObjCContainerDeclInfo

.index_get_obj_c_interface_decl_info(idx_decl_info) ⇒ IdxObjCInterfaceDeclInfo

(Not documented)

Parameters:

Returns:



5717
 
# File 'lib/ffi_gen/clang.rb', line 5717

attach_function :index_get_obj_c_interface_decl_info, :clang_index_getObjCInterfaceDeclInfo, [IdxDeclInfo], IdxObjCInterfaceDeclInfo

.index_get_obj_c_property_decl_info(idx_decl_info) ⇒ IdxObjCPropertyDeclInfo

(Not documented)

Parameters:

Returns:



5741
 
# File 'lib/ffi_gen/clang.rb', line 5741

attach_function :index_get_obj_c_property_decl_info, :clang_index_getObjCPropertyDeclInfo, [IdxDeclInfo], IdxObjCPropertyDeclInfo

.index_get_obj_c_protocol_ref_list_info(idx_decl_info) ⇒ IdxObjCProtocolRefListInfo

(Not documented)

Parameters:

Returns:



5733
 
# File 'lib/ffi_gen/clang.rb', line 5733

attach_function :index_get_obj_c_protocol_ref_list_info, :clang_index_getObjCProtocolRefListInfo, [IdxDeclInfo], IdxObjCProtocolRefListInfo

.index_is_entity_obj_c_container_kind(idx_entity_kind) ⇒ Integer

(Not documented)

Parameters:

Returns:

  • (Integer) 


5701
 
# File 'lib/ffi_gen/clang.rb', line 5701

attach_function :index_is_entity_obj_c_container_kind, :clang_index_isEntityObjCContainerKind, [:idx_entity_kind], :int

.index_loc_get_cx_source_location(loc) ⇒ SourceLocation

Retrieve the CXSourceLocation represented by the given CXIdxLoc.

Parameters:

Returns:



5930
 
# File 'lib/ffi_gen/clang.rb', line 5930

attach_function :index_loc_get_cx_source_location, :clang_indexLoc_getCXSourceLocation, [IdxLoc.by_value], SourceLocation.by_value

.index_loc_get_file_location(loc, index_file, file, line, column, offset) ⇒ nil

Retrieve the CXIdxFile, file, line, column, and offset represented by the given CXIdxLoc.

If the location refers into a macro expansion, retrieves the location of the macro expansion and if it refers into a macro argument retrieves the location of the argument.

Parameters:

  • loc (IdxLoc)
  • index_file (FFI::Pointer(*IdxClientFile))
  • file (FFI::Pointer(*File))
  • line (FFI::Pointer(*UInt))
  • column (FFI::Pointer(*UInt))
  • offset (FFI::Pointer(*UInt))

Returns:

  • (nil) 


5922
 
# File 'lib/ffi_gen/clang.rb', line 5922

attach_function :index_loc_get_file_location, :clang_indexLoc_getFileLocation, [IdxLoc.by_value, :pointer, :pointer, :pointer, :pointer, :pointer], :void

.index_set_client_container(idx_container_info, idx_client_container) ⇒ nil

For setting a custom CXIdxClientContainer attached to a container.

Parameters:

  • idx_container_info (IdxContainerInfo)
  • idx_client_container (FFI::Pointer(IdxClientContainer))

Returns:

  • (nil) 


5776
 
# File 'lib/ffi_gen/clang.rb', line 5776

attach_function :index_set_client_container, :clang_index_setClientContainer, [IdxContainerInfo, :pointer], :void

.index_set_client_entity(idx_entity_info, idx_client_entity) ⇒ nil

For setting a custom CXIdxClientEntity attached to an entity.

Parameters:

  • idx_entity_info (IdxEntityInfo)
  • idx_client_entity (FFI::Pointer(IdxClientEntity))

Returns:

  • (nil) 


5793
 
# File 'lib/ffi_gen/clang.rb', line 5793

attach_function :index_set_client_entity, :clang_index_setClientEntity, [IdxEntityInfo, :pointer], :void

.index_source_file(index_action, client_data, index_callbacks, index_callbacks_size, index_options, source_filename, command_line_args, num_command_line_args, unsaved_files, num_unsaved_files, out_tu, tu_options) ⇒ Integer

Index the given source file and the translation unit corresponding to that file via callbacks implemented through #IndexerCallbacks.

Parameters:

  • index_action (FFI::Pointer(IndexAction))
  • client_data (FFI::Pointer(ClientData)) —

    pointer data supplied by the client, which will be passed to the invoked callbacks.

  • index_callbacks (IndexerCallbacks) —

    Pointer to indexing callbacks that the client implements.

  • index_callbacks_size (Integer) —

    Size of #IndexerCallbacks structure that gets passed in index_callbacks.

  • index_options (Integer) —

    A bitmask of options that affects how indexing is performed. This should be a bitwise OR of the CXIndexOpt_XXX flags.

    param(out) out_TU pointer to store a c CXTranslationUnit that can be reused after indexing is finished. Set to c NULL if you do not require it.

  • source_filename (String)
  • command_line_args (FFI::Pointer(**CharS))
  • num_command_line_args (Integer)
  • unsaved_files (UnsavedFile)
  • num_unsaved_files (Integer)
  • out_tu (FFI::Pointer(*TranslationUnit))
  • tu_options (Integer)

Returns:

  • (Integer) —

    0 on success or if there were errors from which the compiler could recover. If there is a failure from which the there is no recovery, returns a non-zero c CXErrorCode.

    The rest of the parameters are the same as #clang_parseTranslationUnit.



5880
 
# File 'lib/ffi_gen/clang.rb', line 5880

attach_function :index_source_file, :clang_indexSourceFile, [:pointer, :pointer, IndexerCallbacks, :uint, :uint, :string, :pointer, :int, UnsavedFile, :uint, :pointer, :uint], :int

.index_translation_unit(index_action, client_data, index_callbacks, index_callbacks_size, index_options, translation_unit_impl) ⇒ Integer

Index the given translation unit via callbacks implemented through #IndexerCallbacks.

The order of callback invocations is not guaranteed to be the same as when indexing a source file. The high level order will be:

-Preprocessor callbacks invocations
-Declaration/reference callbacks invocations
-Diagnostic callback invocations

The parameters are the same as #clang_indexSourceFile.

Parameters:

  • index_action (FFI::Pointer(IndexAction))
  • client_data (FFI::Pointer(ClientData))
  • index_callbacks (IndexerCallbacks)
  • index_callbacks_size (Integer)
  • index_options (Integer)
  • translation_unit_impl (TranslationUnitImpl)

Returns:

  • (Integer) —

    If there is a failure from which the there is no recovery, returns non-zero, otherwise returns 0.



5904
 
# File 'lib/ffi_gen/clang.rb', line 5904

attach_function :index_translation_unit, :clang_indexTranslationUnit, [:pointer, :pointer, IndexerCallbacks, :uint, :uint, TranslationUnitImpl], :int

.is_attribute(cursor_kind) ⇒ Integer

Determine whether the given cursor kind represents an attribute.

Parameters:

Returns:

  • (Integer) 


2314
 
# File 'lib/ffi_gen/clang.rb', line 2314

attach_function :is_attribute, :clang_isAttribute, [:cursor_kind], :uint

.is_const_qualified_type(t) ⇒ Integer

Determine whether a CXType has the “const” qualifier set, without looking through typedefs that may have added “const” at a different level.

Parameters:

Returns:

  • (Integer) 


3092
 
# File 'lib/ffi_gen/clang.rb', line 3092

attach_function :is_const_qualified_type, :clang_isConstQualifiedType, [Type.by_value], :uint

.is_cursor_definition(cursor) ⇒ Integer

Determine whether the declaration pointed to by this cursor is also a definition of that entity.

Parameters:

Returns:

  • (Integer) 


3725
 
# File 'lib/ffi_gen/clang.rb', line 3725

attach_function :is_cursor_definition, :clang_isCursorDefinition, [Cursor.by_value], :uint

.is_declaration(cursor_kind) ⇒ Integer

Determine whether the given cursor kind represents a declaration.

Parameters:

Returns:

  • (Integer) 


2277
 
# File 'lib/ffi_gen/clang.rb', line 2277

attach_function :is_declaration, :clang_isDeclaration, [:cursor_kind], :uint

.is_expression(cursor_kind) ⇒ Integer

Determine whether the given cursor kind represents an expression.

Parameters:

Returns:

  • (Integer) 


2298
 
# File 'lib/ffi_gen/clang.rb', line 2298

attach_function :is_expression, :clang_isExpression, [:cursor_kind], :uint

.is_file_multiple_include_guarded(tu, file) ⇒ Integer

Determine whether the given header is guarded against multiple inclusions, either with the conventional #ifndef/#define/#endif macro guards or with #pragma once.

Parameters:

Returns:

  • (Integer) 


313
 
# File 'lib/ffi_gen/clang.rb', line 313

attach_function :is_file_multiple_include_guarded, :clang_isFileMultipleIncludeGuarded, [TranslationUnitImpl, :pointer], :uint

.is_function_type_variadic(t) ⇒ Integer

Return 1 if the CXType is a variadic function type, and 0 otherwise.

Parameters:

Returns:

  • (Integer) 


3195
 
# File 'lib/ffi_gen/clang.rb', line 3195

attach_function :is_function_type_variadic, :clang_isFunctionTypeVariadic, [Type.by_value], :uint

.is_invalid(cursor_kind) ⇒ Integer

Determine whether the given cursor kind represents an invalid cursor.

Parameters:

Returns:

  • (Integer) 


2323
 
# File 'lib/ffi_gen/clang.rb', line 2323

attach_function :is_invalid, :clang_isInvalid, [:cursor_kind], :uint

.is_pod_type(t) ⇒ Integer

Return 1 if the CXType is a POD (plain old data) type, and 0

otherwise.

Parameters:

Returns:

  • (Integer) 


3214
 
# File 'lib/ffi_gen/clang.rb', line 3214

attach_function :is_pod_type, :clang_isPODType, [Type.by_value], :uint

.is_preprocessing(cursor_kind) ⇒ Integer

Determine whether the given cursor represents a preprocessing element, such as a preprocessor directive or macro instantiation.

Parameters:

Returns:

  • (Integer) 


2341
 
# File 'lib/ffi_gen/clang.rb', line 2341

attach_function :is_preprocessing, :clang_isPreprocessing, [:cursor_kind], :uint

.is_reference(cursor_kind) ⇒ Integer

Determine whether the given cursor kind represents a simple reference.

Note that other kinds of cursors (such as expressions) can also refer to other cursors. Use clang_getCursorReferenced() to determine whether a particular cursor refers to another entity.

Parameters:

Returns:

  • (Integer) 


2290
 
# File 'lib/ffi_gen/clang.rb', line 2290

attach_function :is_reference, :clang_isReference, [:cursor_kind], :uint

.is_restrict_qualified_type(t) ⇒ Integer

Determine whether a CXType has the “restrict” qualifier set, without looking through typedefs that may have added “restrict” at a different level.

Parameters:

Returns:

  • (Integer) 


3112
 
# File 'lib/ffi_gen/clang.rb', line 3112

attach_function :is_restrict_qualified_type, :clang_isRestrictQualifiedType, [Type.by_value], :uint

.is_statement(cursor_kind) ⇒ Integer

Determine whether the given cursor kind represents a statement.

Parameters:

Returns:

  • (Integer) 


2306
 
# File 'lib/ffi_gen/clang.rb', line 2306

attach_function :is_statement, :clang_isStatement, [:cursor_kind], :uint

.is_translation_unit(cursor_kind) ⇒ Integer

Determine whether the given cursor kind represents a translation unit.

Parameters:

Returns:

  • (Integer) 


2332
 
# File 'lib/ffi_gen/clang.rb', line 2332

attach_function :is_translation_unit, :clang_isTranslationUnit, [:cursor_kind], :uint

.is_unexposed(cursor_kind) ⇒ Integer

Determine whether the given cursor represents a currently

unexposed piece of the AST (e.g., CXCursor_UnexposedStmt).

Parameters:

Returns:

  • (Integer) 


2350
 
# File 'lib/ffi_gen/clang.rb', line 2350

attach_function :is_unexposed, :clang_isUnexposed, [:cursor_kind], :uint

.is_virtual_base(cursor) ⇒ Integer

Returns 1 if the base class specified by the cursor with kind

CX_CXXBaseSpecifier is virtual.

Parameters:

Returns:

  • (Integer) 


3423
 
# File 'lib/ffi_gen/clang.rb', line 3423

attach_function :is_virtual_base, :clang_isVirtualBase, [Cursor.by_value], :uint

.is_volatile_qualified_type(t) ⇒ Integer

Determine whether a CXType has the “volatile” qualifier set, without looking through typedefs that may have added “volatile” at a different level.

Parameters:

Returns:

  • (Integer) 


3102
 
# File 'lib/ffi_gen/clang.rb', line 3102

attach_function :is_volatile_qualified_type, :clang_isVolatileQualifiedType, [Type.by_value], :uint

.load_diagnostics(file, error, error_string) ⇒ FFI::Pointer(DiagnosticSet)

Deserialize a set of diagnostics from a Clang diagnostics bitcode file.

Parameters:

  • file (String) —

    The name of the file to deserialize.

  • error (FFI::Pointer(*LoadDiagError)) —

    A pointer to a enum value recording if there was a problem deserializing the diagnostics.

  • error_string (String) —

    A pointer to a CXString for recording the error string if the file was not successfully loaded.

Returns:

  • (FFI::Pointer(DiagnosticSet)) —

    A loaded CXDiagnosticSet if successful, and NULL otherwise. These diagnostics should be released using clang_disposeDiagnosticSet().



713
 
# File 'lib/ffi_gen/clang.rb', line 713

attach_function :load_diagnostics, :clang_loadDiagnostics, [:string, :pointer, String], :pointer

.location_is_from_main_file(location) ⇒ Integer

Returns non-zero if the given source location is in the main file of the corresponding translation unit.

Parameters:

Returns:

  • (Integer) 


416
 
# File 'lib/ffi_gen/clang.rb', line 416

attach_function :location_is_from_main_file, :clang_Location_isFromMainFile, [SourceLocation.by_value], :int

.location_is_in_system_header(location) ⇒ Integer

Returns non-zero if the given source location is in a system header.

Parameters:

Returns:

  • (Integer) 


407
 
# File 'lib/ffi_gen/clang.rb', line 407

attach_function :location_is_in_system_header, :clang_Location_isInSystemHeader, [SourceLocation.by_value], :int

.module_get_ast_file(module_) ⇒ FFI::Pointer(File)

(Not documented)

Parameters:

  • module_ (FFI::Pointer(Module)) —

    a module object.

Returns:

  • (FFI::Pointer(File)) —

    the module file where the provided module object came from.



3971
 
# File 'lib/ffi_gen/clang.rb', line 3971

attach_function :module_get_ast_file, :clang_Module_getASTFile, [:pointer], :pointer

.module_get_full_name(module_) ⇒ String

(Not documented)

Parameters:

  • module_ (FFI::Pointer(Module)) —

    a module object.

Returns:

  • (String) —

    the full name of the module, e.g. “std.vector”.



3997
 
# File 'lib/ffi_gen/clang.rb', line 3997

attach_function :module_get_full_name, :clang_Module_getFullName, [:pointer], String.by_value

.module_get_name(module_) ⇒ String

(Not documented)

Parameters:

  • module_ (FFI::Pointer(Module)) —

    a module object.

Returns:

  • (String) —

    the name of the module, e.g. for the ‘std.vector’ sub-module it will return “vector”.



3989
 
# File 'lib/ffi_gen/clang.rb', line 3989

attach_function :module_get_name, :clang_Module_getName, [:pointer], String.by_value

.module_get_num_top_level_headers(translation_unit_impl, module_) ⇒ Integer

(Not documented)

Parameters:

  • translation_unit_impl (TranslationUnitImpl)
  • module_ (FFI::Pointer(Module)) —

    a module object.

Returns:

  • (Integer) —

    the number of top level headers associated with this module.



4014
 
# File 'lib/ffi_gen/clang.rb', line 4014

attach_function :module_get_num_top_level_headers, :clang_Module_getNumTopLevelHeaders, [TranslationUnitImpl, :pointer], :uint

.module_get_parent(module_) ⇒ FFI::Pointer(Module)

(Not documented)

Parameters:

  • module_ (FFI::Pointer(Module)) —

    a module object.

Returns:

  • (FFI::Pointer(Module)) —

    the parent of a sub-module or NULL if the given module is top-level, e.g. for ‘std.vector’ it will return the ‘std’ module.



3980
 
# File 'lib/ffi_gen/clang.rb', line 3980

attach_function :module_get_parent, :clang_Module_getParent, [:pointer], :pointer

.module_get_top_level_header(translation_unit_impl, module_, index) ⇒ FFI::Pointer(File)

(Not documented)

Parameters:

  • translation_unit_impl (TranslationUnitImpl)
  • module_ (FFI::Pointer(Module)) —

    a module object.

  • index (Integer) —

    top level header index (zero-based).

Returns:

  • (FFI::Pointer(File)) —

    the specified top level header associated with the module.



4024
 
# File 'lib/ffi_gen/clang.rb', line 4024

attach_function :module_get_top_level_header, :clang_Module_getTopLevelHeader, [TranslationUnitImpl, :pointer, :uint], :pointer

.module_is_system(module_) ⇒ Integer

(Not documented)

Parameters:

  • module_ (FFI::Pointer(Module)) —

    a module object.

Returns:

  • (Integer) —

    non-zero if the module is a system one.



4005
 
# File 'lib/ffi_gen/clang.rb', line 4005

attach_function :module_is_system, :clang_Module_isSystem, [:pointer], :int

.parse_translation_unit(c_idx, source_filename, command_line_args, num_command_line_args, unsaved_files, num_unsaved_files, options) ⇒ TranslationUnitImpl

Same as c clang_parseTranslationUnit2, but returns the c CXTranslationUnit instead of an error code. In case of an error this routine returns a c NULL c CXTranslationUnit, without further detailed error codes.

Parameters:

  • c_idx (FFI::Pointer(Index))
  • source_filename (String)
  • command_line_args (FFI::Pointer(**CharS))
  • num_command_line_args (Integer)
  • unsaved_files (UnsavedFile)
  • num_unsaved_files (Integer)
  • options (Integer)

Returns:



1173
 
# File 'lib/ffi_gen/clang.rb', line 1173

attach_function :parse_translation_unit, :clang_parseTranslationUnit, [:pointer, :string, :pointer, :int, UnsavedFile, :uint, :uint], TranslationUnitImpl

.parse_translation_unit2(c_idx, source_filename, command_line_args, num_command_line_args, unsaved_files, num_unsaved_files, options, out_tu) ⇒ Symbol from _enum_error_code_

Parse the given source file and the translation unit corresponding to that file.

This routine is the main entry point for the Clang C API, providing the ability to parse a source file into a translation unit that can then be queried by other functions in the API. This routine accepts a set of command-line arguments so that the compilation can be configured in the same way that the compiler is configured on the command line.

Parameters:

  • c_idx (FFI::Pointer(Index)) —

    The index object with which the translation unit will be associated.

  • source_filename (String) —

    The name of the source file to load, or NULL if the source file is included in c command_line_args.

  • command_line_args (FFI::Pointer(**CharS)) —

    The command-line arguments that would be passed to the c clang executable if it were being invoked out-of-process. These command-line options will be parsed and will affect how the translation unit is parsed. Note that the following options are ignored: ‘-c’, ‘-emit-ast’, ‘-fsyntax-only’ (which is the default), and ‘-o <output file>’.

  • num_command_line_args (Integer) —

    The number of command-line arguments in c command_line_args.

  • unsaved_files (UnsavedFile) —

    the files that have not yet been saved to disk but may be required for parsing, including the contents of those files. The contents and name of these files (as specified by CXUnsavedFile) are copied when necessary, so the client only needs to guarantee their validity until the call to this function returns.

  • num_unsaved_files (Integer) —

    the number of unsaved file entries in p unsaved_files.

  • options (Integer) —

    A bitmask of options that affects how the translation unit is managed but not its compilation. This should be a bitwise OR of the CXTranslationUnit_XXX flags.

    param(out) out_TU A non-NULL pointer to store the created c CXTranslationUnit, describing the parsed code and containing any diagnostics produced by the compiler.

  • out_tu (FFI::Pointer(*TranslationUnit))

Returns:

  • (Symbol from _enum_error_code_) —

    Zero on success, otherwise returns an error code.



1213
 
# File 'lib/ffi_gen/clang.rb', line 1213

attach_function :parse_translation_unit2, :clang_parseTranslationUnit2, [:pointer, :string, :pointer, :int, UnsavedFile, :uint, :uint, :pointer], :error_code

.range_is_null(range) ⇒ Integer

Returns non-zero if p range is null.

Parameters:

Returns:

  • (Integer) 


450
 
# File 'lib/ffi_gen/clang.rb', line 450

attach_function :range_is_null, :clang_Range_isNull, [SourceRange.by_value], :int

.remap_dispose(remapping) ⇒ nil

Dispose the remapping.

Parameters:

  • remapping (FFI::Pointer(Remapping))

Returns:

  • (nil) 


5024
 
# File 'lib/ffi_gen/clang.rb', line 5024

attach_function :remap_dispose, :clang_remap_dispose, [:pointer], :void

.remap_get_filenames(remapping, index, original, transformed) ⇒ nil

Get the original and the associated filename from the remapping.

Parameters:

  • remapping (FFI::Pointer(Remapping))
  • index (Integer)
  • original (String) —

    If non-NULL, will be set to the original filename.

  • transformed (String) —

    If non-NULL, will be set to the filename that the original is associated with.

Returns:

  • (nil) 


5016
 
# File 'lib/ffi_gen/clang.rb', line 5016

attach_function :remap_get_filenames, :clang_remap_getFilenames, [:pointer, :uint, String, String], :void

.remap_get_num_files(remapping) ⇒ Integer

Determine the number of remappings.

Parameters:

  • remapping (FFI::Pointer(Remapping))

Returns:

  • (Integer) 


5004
 
# File 'lib/ffi_gen/clang.rb', line 5004

attach_function :remap_get_num_files, :clang_remap_getNumFiles, [:pointer], :uint

.reparse_translation_unit(tu, num_unsaved_files, unsaved_files, options) ⇒ Integer

Reparse the source files that produced this translation unit.

This routine can be used to re-parse the source files that originally created the given translation unit, for example because those source files have changed (either on disk or as passed via p unsaved_files). The source code will be reparsed with the same command-line options as it was originally parsed.

Reparsing a translation unit invalidates all cursors and source locations that refer into that translation unit. This makes reparsing a translation unit semantically equivalent to destroying the translation unit and then creating a new translation unit with the same command-line arguments. However, it may be more efficient to reparse a translation unit using this routine.

Parameters:

  • tu (TranslationUnitImpl) —

    The translation unit whose contents will be re-parsed. The translation unit must originally have been built with c clang_createTranslationUnitFromSourceFile().

  • num_unsaved_files (Integer) —

    The number of unsaved file entries in p unsaved_files.

  • unsaved_files (UnsavedFile) —

    The files that have not yet been saved to disk but may be required for parsing, including the contents of those files. The contents and name of these files (as specified by CXUnsavedFile) are copied when necessary, so the client only needs to guarantee their validity until the call to this function returns.

  • options (Integer) —

    A bitset of options composed of the flags in CXReparse_Flags. The function c clang_defaultReparseOptions() produces a default set of options recommended for most uses, based on the translation unit.

Returns:

  • (Integer) —

    0 if the sources could be reparsed. A non-zero error code will be returned if reparsing was impossible, such that the translation unit is invalid. In such cases, the only valid call for c TU is c clang_disposeTranslationUnit(TU). The error codes returned by this routine are described by the c CXErrorCode enum.



1381
 
# File 'lib/ffi_gen/clang.rb', line 1381

attach_function :reparse_translation_unit, :clang_reparseTranslationUnit, [TranslationUnitImpl, :uint, UnsavedFile, :uint], :int

.save_translation_unit(tu, file_name, options) ⇒ Integer

Saves a translation unit into a serialized representation of that translation unit on disk.

Any translation unit that was parsed without error can be saved into a file. The translation unit can then be deserialized into a new c CXTranslationUnit with c clang_createTranslationUnit() or, if it is an incomplete translation unit that corresponds to a header, used as a precompiled header when parsing other translation units.

Parameters:

  • tu (TranslationUnitImpl) —

    The translation unit to save.

  • file_name (String) —

    The file to which the translation unit will be saved.

  • options (Integer) —

    A bitmask of options that affects how the translation unit is saved. This should be a bitwise OR of the CXSaveTranslationUnit_XXX flags.

Returns:

  • (Integer) —

    A value that will match one of the enumerators of the CXSaveError enumeration. Zero (CXSaveError_None) indicates that the translation unit was saved successfully, while a non-zero value indicates that a problem occurred.



1302
 
# File 'lib/ffi_gen/clang.rb', line 1302

attach_function :save_translation_unit, :clang_saveTranslationUnit, [TranslationUnitImpl, :string, :uint], :int

.sort_code_completion_results(results, num_results) ⇒ nil

Sort the code-completion results in case-insensitive alphabetical order.

Parameters:

  • results (CompletionResult) —

    The set of results to sort.

  • num_results (Integer) —

    The number of results in p Results.

Returns:

  • (nil) 


4851
 
# File 'lib/ffi_gen/clang.rb', line 4851

attach_function :sort_code_completion_results, :clang_sortCodeCompletionResults, [CompletionResult, :uint], :void

.toggle_crash_recovery(is_enabled) ⇒ nil

Enable/disable crash recovery.

Parameters:

  • is_enabled (Integer) —

    Flag to indicate if crash recovery is enabled. A non-zero value enables crash recovery, while 0 disables it.

Returns:

  • (nil) 


4943
 
# File 'lib/ffi_gen/clang.rb', line 4943

attach_function :toggle_crash_recovery, :clang_toggleCrashRecovery, [:uint], :void

.tokenize(tu, range, tokens, num_tokens) ⇒ nil

Tokenize the source code described by the given range into raw lexical tokens.

Parameters:

  • tu (TranslationUnitImpl) —

    the translation unit whose text is being tokenized.

  • range (SourceRange) —

    the source range in which text should be tokenized. All of the tokens produced by tokenization will fall within this source range,

  • tokens (FFI::Pointer(**Token)) —

    this pointer will be set to point to the array of tokens that occur within the given source range. The returned pointer must be freed with clang_disposeTokens() before the translation unit is destroyed.

  • num_tokens (FFI::Pointer(*UInt)) —

    will be set to the number of tokens in the c *Tokens array.

Returns:

  • (nil) 


4250
 
# File 'lib/ffi_gen/clang.rb', line 4250

attach_function :tokenize, :clang_tokenize, [TranslationUnitImpl, SourceRange.by_value, :pointer, :pointer], :void

.type_get_align_of(t) ⇒ Integer

Return the alignment of a type in bytes as per C++(expr.alignof)

standard.

If the type declaration is invalid, CXTypeLayoutError_Invalid is returned. If the type declaration is an incomplete type, CXTypeLayoutError_Incomplete

is returned.

If the type declaration is a dependent type, CXTypeLayoutError_Dependent is

returned.

If the type declaration is not a constant size type,

CXTypeLayoutError_NotConstantSize is returned.

Parameters:

Returns:

  • (Integer) 


3305
 
# File 'lib/ffi_gen/clang.rb', line 3305

attach_function :type_get_align_of, :clang_Type_getAlignOf, [Type.by_value], :long_long

.type_get_class_type(t) ⇒ Type

Return the class type of an member pointer type.

If a non-member-pointer type is passed in, an invalid type is returned.

Parameters:

Returns:



3315
 
# File 'lib/ffi_gen/clang.rb', line 3315

attach_function :type_get_class_type, :clang_Type_getClassType, [Type.by_value], Type.by_value

.type_get_cxx_ref_qualifier(t) ⇒ Symbol from _enum_ref_qualifier_kind_

Retrieve the ref-qualifier kind of a function or method.

The ref-qualifier is returned for C++ functions or methods. For other types or non-C++ declarations, CXRefQualifier_None is returned.

Parameters:

Returns:



3405
 
# File 'lib/ffi_gen/clang.rb', line 3405

attach_function :type_get_cxx_ref_qualifier, :clang_Type_getCXXRefQualifier, [Type.by_value], :ref_qualifier_kind

.type_get_num_template_arguments(t) ⇒ Integer

Returns the number of template arguments for given class template specialization, or -1 if type c T is not a class template specialization.

Variadic argument packs count as only one argument, and can not be inspected further.

Parameters:

Returns:

  • (Integer) 


3381
 
# File 'lib/ffi_gen/clang.rb', line 3381

attach_function :type_get_num_template_arguments, :clang_Type_getNumTemplateArguments, [Type.by_value], :int

.type_get_offset_of(t, s) ⇒ Integer

Return the offset of a field named S in a record of type T in bits

as it would be returned by __offsetof__ as per C++11(18.2p4)

If the cursor is not a record field declaration, CXTypeLayoutError_Invalid

is returned.

If the field’s type declaration is an incomplete type,

CXTypeLayoutError_Incomplete is returned.

If the field’s type declaration is a dependent type,

CXTypeLayoutError_Dependent is returned.

If the field’s name S is not found,

CXTypeLayoutError_InvalidFieldName is returned.

Parameters:

Returns:

  • (Integer) 


3348
 
# File 'lib/ffi_gen/clang.rb', line 3348

attach_function :type_get_offset_of, :clang_Type_getOffsetOf, [Type.by_value, :string], :long_long

.type_get_size_of(t) ⇒ Integer

Return the size of a type in bytes as per C++(expr.sizeof) standard.

If the type declaration is invalid, CXTypeLayoutError_Invalid is returned. If the type declaration is an incomplete type, CXTypeLayoutError_Incomplete

is returned.

If the type declaration is a dependent type, CXTypeLayoutError_Dependent is

returned.

Parameters:

Returns:

  • (Integer) 


3329
 
# File 'lib/ffi_gen/clang.rb', line 3329

attach_function :type_get_size_of, :clang_Type_getSizeOf, [Type.by_value], :long_long

.type_get_template_argument_as_type(t, i) ⇒ Type

Returns the type template argument of a template class specialization at given index.

This function only returns template type arguments and does not handle template template arguments or variadic packs.

Parameters:

  • t (Type)
  • i (Integer)

Returns:



3394
 
# File 'lib/ffi_gen/clang.rb', line 3394

attach_function :type_get_template_argument_as_type, :clang_Type_getTemplateArgumentAsType, [Type.by_value, :uint], Type.by_value

.visit_children(parent, visitor, client_data) ⇒ Integer

Visit the children of a particular cursor.

This function visits all the direct children of the given cursor, invoking the given p visitor function with the cursors of each visited child. The traversal may be recursive, if the visitor returns c CXChildVisit_Recurse. The traversal may also be ended prematurely, if the visitor returns c CXChildVisit_Break.

Parameters:

  • parent (Cursor) —

    the cursor whose child may be visited. All kinds of cursors can be visited, including invalid cursors (which, by definition, have no children).

  • visitor (Proc(_callback_cursor_visitor_)) —

    the visitor function that will be invoked for each child of p parent.

  • client_data (FFI::Pointer(ClientData)) —

    pointer data supplied by the client, which will be passed to the visitor each time it is invoked.

Returns:

  • (Integer) —

    a non-zero value if the traversal was terminated prematurely by the visitor returning c CXChildVisit_Break.



3563
 
# File 'lib/ffi_gen/clang.rb', line 3563

attach_function :visit_children, :clang_visitChildren, [Cursor.by_value, :cursor_visitor, :pointer], :uint

Instance Method Details

#cindex_version_stringize(major, minor) ⇒ Object 



19
20
21
 
# File 'lib/ffi_gen/clang.rb', line 19

def cindex_version_stringize(major, minor)
  cindex_version_stringize(major, minor)
end