Class: FFI::Clang::Cursor

Inherits:
Object
  • Object
show all
Defined in:
lib/ffi/clang/cursor.rb

Defined Under Namespace

Classes: PlatformAvailability

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(cxcursor, translation_unit) ⇒ Cursor

Returns a new instance of Cursor.



40
41
42
43
 
# File 'lib/ffi/clang/cursor.rb', line 40

def initialize(cxcursor, translation_unit)
	@cursor = cxcursor
	@translation_unit = translation_unit
end

Instance Attribute Details

#cursor ⇒ Object (readonly)

Returns the value of attribute cursor.



28
29
30
 
# File 'lib/ffi/clang/cursor.rb', line 28

def cursor
  @cursor
end

#translation_unit ⇒ Object (readonly)

Returns the value of attribute translation_unit.



29
30
31
 
# File 'lib/ffi/clang/cursor.rb', line 29

def translation_unit
  @translation_unit
end

Class Method Details

.kind_spelling(kind) ⇒ Object

this function is categorized as “Debugging facilities”



36
37
38
 
# File 'lib/ffi/clang/cursor.rb', line 36

def self.kind_spelling(kind)
	Lib.extract_string Lib.get_cursor_kind_spelling(kind)
end

.null_cursor ⇒ Object 



31
32
33
 
# File 'lib/ffi/clang/cursor.rb', line 31

def self.null_cursor
	Cursor.new Lib.get_null_cursor, nil
end

Instance Method Details

#abstract? ⇒ Boolean

Returns:

  • (Boolean) 


476
477
478
 
# File 'lib/ffi/clang/cursor.rb', line 476

def abstract?
	Lib.is_abstract(@cursor) != 0
end

#access_specifier ⇒ Object 



260
261
262
 
# File 'lib/ffi/clang/cursor.rb', line 260

def access_specifier
	Lib.get_cxx_access_specifier @cursor
end

#argument(i) ⇒ Object 



370
371
372
 
# File 'lib/ffi/clang/cursor.rb', line 370

def argument(i)
	Cursor.new Lib.cursor_get_argument(@cursor, i), @translation_unit
end

#attribute? ⇒ Boolean

Returns:

  • (Boolean) 


81
82
83
 
# File 'lib/ffi/clang/cursor.rb', line 81

def attribute?
	Lib.is_attribute(kind) != 0
end

#availability ⇒ Object 



296
297
298
 
# File 'lib/ffi/clang/cursor.rb', line 296

def availability
	Lib.get_cursor_availability(@cursor)
end

#bitfield? ⇒ Boolean

Returns:

  • (Boolean) 


350
351
352
 
# File 'lib/ffi/clang/cursor.rb', line 350

def bitfield?
	Lib.is_bit_field(@cursor) != 0
end

#bitwidth ⇒ Object 



354
355
356
 
# File 'lib/ffi/clang/cursor.rb', line 354

def bitwidth
	Lib.get_field_decl_bit_width(@cursor)
end

#canonical ⇒ Object 



221
222
223
 
# File 'lib/ffi/clang/cursor.rb', line 221

def canonical
	Cursor.new Lib.get_canonical_cursor(@cursor), @translation_unit
end

#comment ⇒ Object 



53
54
55
 
# File 'lib/ffi/clang/cursor.rb', line 53

def comment
	Comment.build_from Lib.cursor_get_parsed_comment(@cursor)
end

#comment_range ⇒ Object 



57
58
59
 
# File 'lib/ffi/clang/cursor.rb', line 57

def comment_range
	SourceRange.new(Lib.cursor_get_comment_range(@cursor))
end

#completion ⇒ Object 



61
62
63
 
# File 'lib/ffi/clang/cursor.rb', line 61

def completion
	CodeCompletion::String.new Lib.get_cursor_completion_string(@cursor)
end

#const? ⇒ Boolean

Returns:

  • (Boolean) 


484
485
486
 
# File 'lib/ffi/clang/cursor.rb', line 484

def const?
	Lib.is_const(@cursor) != 0
end

#converting_constructor? ⇒ Boolean

Returns:

  • (Boolean) 


436
437
438
 
# File 'lib/ffi/clang/cursor.rb', line 436

def converting_constructor?
	Lib.is_converting_constructor(@cursor) != 0
end

#copy_assignment_operator? ⇒ Boolean

Returns:

  • (Boolean) 


464
465
466
 
# File 'lib/ffi/clang/cursor.rb', line 464

def copy_assignment_operator?
	Lib.is_copy_assignment_operator(@cursor) != 0
end

#copy_constructor? ⇒ Boolean

Returns:

  • (Boolean) 


440
441
442
 
# File 'lib/ffi/clang/cursor.rb', line 440

def copy_constructor?
	Lib.is_copy_constructor(@cursor) != 0
end

#declaration? ⇒ Boolean

Returns:

  • (Boolean) 


65
66
67
 
# File 'lib/ffi/clang/cursor.rb', line 65

def declaration?
	Lib.is_declaration(kind) != 0
end

#default_constructor? ⇒ Boolean

Returns:

  • (Boolean) 


444
445
446
 
# File 'lib/ffi/clang/cursor.rb', line 444

def default_constructor?
	Lib.is_default_constructor(@cursor) != 0
end

#defaulted? ⇒ Boolean

Returns:

  • (Boolean) 


456
457
458
 
# File 'lib/ffi/clang/cursor.rb', line 456

def defaulted?
	Lib.is_defaulted(@cursor) != 0
end

#definition ⇒ Object 



225
226
227
 
# File 'lib/ffi/clang/cursor.rb', line 225

def definition
	Cursor.new Lib.get_cursor_definition(@cursor), @translation_unit
end

#definition? ⇒ Boolean

Returns:

  • (Boolean) 


189
190
191
 
# File 'lib/ffi/clang/cursor.rb', line 189

def definition?
	Lib.is_definition(@cursor) != 0
end

#deleted? ⇒ Boolean

Returns:

  • (Boolean) 


460
461
462
 
# File 'lib/ffi/clang/cursor.rb', line 460

def deleted?
	Lib.is_deleted(@cursor) != 0
end

#display_name ⇒ Object 



134
135
136
 
# File 'lib/ffi/clang/cursor.rb', line 134

def display_name
	Lib.extract_string Lib.get_cursor_display_name(@cursor)
end

#dynamic_call? ⇒ Boolean

Returns:

  • (Boolean) 


181
182
183
 
# File 'lib/ffi/clang/cursor.rb', line 181

def dynamic_call?
	Lib.is_dynamic_call(@cursor) != 0
end

#enum_scoped? ⇒ Boolean

Returns:

  • (Boolean) 


480
481
482
 
# File 'lib/ffi/clang/cursor.rb', line 480

def enum_scoped?
	Lib.is_enum_scoped(@cursor) != 0
end

#enum_type ⇒ Object 



213
214
215
 
# File 'lib/ffi/clang/cursor.rb', line 213

def enum_type
	Type.new Lib.get_enum_decl_integer_type(@cursor), @translation_unit
end

#enum_unsigned_value ⇒ Object 



209
210
211
 
# File 'lib/ffi/clang/cursor.rb', line 209

def enum_unsigned_value
	Lib.get_enum_unsigned_value @cursor
end

#enum_value ⇒ Object 



205
206
207
 
# File 'lib/ffi/clang/cursor.rb', line 205

def enum_value
	Lib.get_enum_value @cursor
end

#eql?(other) ⇒ Boolean Also known as: ==

Returns:

  • (Boolean) 


378
379
380
 
# File 'lib/ffi/clang/cursor.rb', line 378

def eql?(other)
	Lib.are_equal(@cursor, other.cursor) != 0
end

#expansion_location ⇒ Object Also known as: location 



113
114
115
 
# File 'lib/ffi/clang/cursor.rb', line 113

def expansion_location
	ExpansionLocation.new(Lib.get_cursor_location(@cursor))
end

#explicit? ⇒ Boolean

Returns:

  • (Boolean) 


472
473
474
 
# File 'lib/ffi/clang/cursor.rb', line 472

def explicit?
	Lib.is_explicit(@cursor) != 0
end

#expression? ⇒ Boolean

Returns:

  • (Boolean) 


73
74
75
 
# File 'lib/ffi/clang/cursor.rb', line 73

def expression?
	Lib.is_expression(kind) != 0
end

#extent ⇒ Object 



130
131
132
 
# File 'lib/ffi/clang/cursor.rb', line 130

def extent
	SourceRange.new(Lib.get_cursor_extent(@cursor))
end

#file_location ⇒ Object 



126
127
128
 
# File 'lib/ffi/clang/cursor.rb', line 126

def file_location
	FileLocation.new(Lib.get_cursor_location(@cursor))
end

#filter ⇒ Object 



397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
 
# File 'lib/ffi/clang/cursor.rb', line 397

def filter
	return to_enum(:select) unless block_given?
	
	matching = []

	self.visit_children do |child, parent|
		if yield(child, parent)
			matching << child
		end

		:recurse
	end

	return matching
end

#find_all(*kinds) ⇒ Object 



387
388
389
390
391
 
# File 'lib/ffi/clang/cursor.rb', line 387

def find_all(*kinds)
	filter do |child, parent|
		kinds.include?(child.kind)
	end
end

#find_first(*kinds) ⇒ Object 



393
394
395
 
# File 'lib/ffi/clang/cursor.rb', line 393

def find_first(*kinds)
	find_all(*kinds).first
end

#find_references_in_file(file = nil, &block) ⇒ Object 



280
281
282
283
284
285
286
287
288
289
290
 
# File 'lib/ffi/clang/cursor.rb', line 280

def find_references_in_file(file = nil, &block)
	file ||= Lib.extract_string Lib.get_translation_unit_spelling(@translation_unit)

	visit_adapter = Proc.new do |unused, cxcursor, cxsource_range|
		block.call Cursor.new(cxcursor, @translation_unit), SourceRange.new(cxsource_range)
	end
	visitor = FFI::Clang::Lib::CXCursorAndRangeVisitor.new
	visitor[:visit] = visit_adapter

	Lib.find_references_in_file(@cursor, Lib.get_file(@translation_unit, file), visitor)
end

#forward_declaration? ⇒ Boolean

Returns:

  • (Boolean) 


234
235
236
237
238
239
240
241
242
 
# File 'lib/ffi/clang/cursor.rb', line 234

def forward_declaration?
	# Is this a forward declaration for a definition contained in the same translation_unit?
	# https://joshpeterson.github.io/identifying-a-forward-declaration-with-libclang
	#
	# Possible alternate implementations?
	# self.declaration? && !self.definition? && self.definition
	# !self.definition? && self.definition
	self.declaration? && !self.eql?(self.definition) && !self.definition.invalid?
end

#hash ⇒ Object 



383
384
385
 
# File 'lib/ffi/clang/cursor.rb', line 383

def hash
	Lib.get_cursor_hash(@cursor)
end

#included_file ⇒ Object 



300
301
302
 
# File 'lib/ffi/clang/cursor.rb', line 300

def included_file
	File.new Lib.get_included_file(@cursor), @translation_unit
end

#invalid? ⇒ Boolean

Returns:

  • (Boolean) 


97
98
99
 
# File 'lib/ffi/clang/cursor.rb', line 97

def invalid?
	Lib.is_invalid(kind) != 0
end

#kind ⇒ Object 



157
158
159
 
# File 'lib/ffi/clang/cursor.rb', line 157

def kind
	@cursor[:kind]
end

#kind_spelling ⇒ Object 



161
162
163
 
# File 'lib/ffi/clang/cursor.rb', line 161

def kind_spelling
	Cursor.kind_spelling @cursor[:kind]
end

#language ⇒ Object 



264
265
266
 
# File 'lib/ffi/clang/cursor.rb', line 264

def language
	Lib.get_language @cursor
end

#lexical_parent ⇒ Object 



252
253
254
 
# File 'lib/ffi/clang/cursor.rb', line 252

def lexical_parent
	Cursor.new Lib.get_cursor_lexical_parent(@cursor), @translation_unit
end

#linkage ⇒ Object 



292
293
294
 
# File 'lib/ffi/clang/cursor.rb', line 292

def linkage
	Lib.get_cursor_linkage(@cursor)
end

#move_assignment_operator? ⇒ Boolean

Returns:

  • (Boolean) 


468
469
470
 
# File 'lib/ffi/clang/cursor.rb', line 468

def move_assignment_operator?
	Lib.is_move_assignment_operator(@cursor) != 0
end

#move_constructor? ⇒ Boolean

Returns:

  • (Boolean) 


448
449
450
 
# File 'lib/ffi/clang/cursor.rb', line 448

def move_constructor?
	Lib.is_move_constructor(@cursor) != 0
end

#mutable? ⇒ Boolean

Returns:

  • (Boolean) 


452
453
454
 
# File 'lib/ffi/clang/cursor.rb', line 452

def mutable?
	Lib.is_mutable(@cursor) != 0
end

#null? ⇒ Boolean

Returns:

  • (Boolean) 


45
46
47
 
# File 'lib/ffi/clang/cursor.rb', line 45

def null?
	Lib.cursor_is_null(@cursor) != 0
end

#num_args ⇒ Object 



268
269
270
 
# File 'lib/ffi/clang/cursor.rb', line 268

def num_args
	Lib.get_num_args @cursor
end

#num_arguments ⇒ Object 



374
375
376
 
# File 'lib/ffi/clang/cursor.rb', line 374

def num_arguments
	Lib.cursor_get_num_arguments(@cursor)
end

#num_overloaded_decls ⇒ Object 



362
363
364
 
# File 'lib/ffi/clang/cursor.rb', line 362

def num_overloaded_decls
	Lib.get_num_overloaded_decls(@cursor)
end

#objc_type_encoding ⇒ Object 



366
367
368
 
# File 'lib/ffi/clang/cursor.rb', line 366

def objc_type_encoding
	Lib.extract_string Lib.get_decl_objc_type_encoding(@cursor)
end

#opaque_declaration? ⇒ Boolean

Returns:

  • (Boolean) 


229
230
231
232
 
# File 'lib/ffi/clang/cursor.rb', line 229

def opaque_declaration?
	# Is this a declaration that does not have a definition in the translation unit
	self.declaration? && !self.definition? && self.definition.invalid?
end

#overloaded_decl(i) ⇒ Object 



358
359
360
 
# File 'lib/ffi/clang/cursor.rb', line 358

def overloaded_decl(i)
	Cursor.new Lib.get_overloaded_decl(@cursor, i), @translation_unit
end

#overriddens ⇒ Object 



334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
 
# File 'lib/ffi/clang/cursor.rb', line 334

def overriddens
	cursor_ptr = FFI::MemoryPointer.new :pointer
	num_ptr = FFI::MemoryPointer.new :uint
	Lib.get_overridden_cursors(@cursor, cursor_ptr, num_ptr)
	num = num_ptr.get_uint(0)
	cur_ptr = cursor_ptr.get_pointer(0)

	overriddens = []
	num.times {
		overriddens << Cursor.new(cur_ptr, @translation_unit)
		cur_ptr += Lib::CXCursor.size
	}
	Lib.dispose_overridden_cursors(cursor_ptr.get_pointer(0)) if num != 0
	overriddens
end

#platform_availability(max_availability_size = 4) ⇒ Object 



304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
 
# File 'lib/ffi/clang/cursor.rb', line 304

def platform_availability(max_availability_size = 4)
	availability_ptr = FFI::MemoryPointer.new(Lib::CXPlatformAvailability, max_availability_size)
	always_deprecated_ptr = FFI::MemoryPointer.new :int
	always_unavailable_ptr = FFI::MemoryPointer.new :int
	deprecated_message_ptr = FFI::MemoryPointer.new Lib::CXString
	unavailable_message_ptr = FFI::MemoryPointer.new Lib::CXString

	actual_availability_size = Lib.get_cursor_platform_availability(
		@cursor,
		always_deprecated_ptr, deprecated_message_ptr,
		always_unavailable_ptr, unavailable_message_ptr,
		availability_ptr, max_availability_size)

	availability = []
	cur_ptr = availability_ptr
	[actual_availability_size, max_availability_size].min.times {
		availability << PlatformAvailability.new(cur_ptr)
		cur_ptr += Lib::CXPlatformAvailability.size
	}

	# return as Hash
	{
		always_deprecated: always_deprecated_ptr.get_int(0),
		always_unavailable: always_unavailable_ptr.get_int(0),
		deprecated_message: Lib.extract_string(Lib::CXString.new(deprecated_message_ptr)),
		unavailable_message: Lib.extract_string(Lib::CXString.new(unavailable_message_ptr)),
		availability: availability
	}
end

#preprocessing? ⇒ Boolean

Returns:

  • (Boolean) 


105
106
107
 
# File 'lib/ffi/clang/cursor.rb', line 105

def preprocessing?
	Lib.is_preprocessing(kind) != 0
end

#presumed_location ⇒ Object 



118
119
120
 
# File 'lib/ffi/clang/cursor.rb', line 118

def presumed_location
	PresumedLocation.new(Lib.get_cursor_location(@cursor))
end

#printing_policy ⇒ Object 



149
150
151
 
# File 'lib/ffi/clang/cursor.rb', line 149

def printing_policy
	PrintingPolicy.new(cursor)
end

#private? ⇒ Boolean

Returns:

  • (Boolean) 


89
90
91
 
# File 'lib/ffi/clang/cursor.rb', line 89

def private?
	Lib.cxx_get_access_specifier(@cursor) == :private
end

#protected? ⇒ Boolean

Returns:

  • (Boolean) 


93
94
95
 
# File 'lib/ffi/clang/cursor.rb', line 93

def protected?
	Lib.cxx_get_access_specifier(@cursor) == :protected
end

#public? ⇒ Boolean

Returns:

  • (Boolean) 


85
86
87
 
# File 'lib/ffi/clang/cursor.rb', line 85

def public?
	Lib.cxx_get_access_specifier(@cursor) == :public
end

#pure_virtual? ⇒ Boolean

Returns:

  • (Boolean) 


201
202
203
 
# File 'lib/ffi/clang/cursor.rb', line 201

def pure_virtual?
	Lib.cxx_method_is_pure_virtual(@cursor) != 0
end

#qualified_name ⇒ Object 



138
139
140
141
142
143
 
# File 'lib/ffi/clang/cursor.rb', line 138

def qualified_name
	if self.kind != :cursor_translation_unit
		result = self.semantic_parent.qualified_name
		result ? "#{result}::#{self.spelling}" : self.spelling
	end
end

#raw_comment_text ⇒ Object 



49
50
51
 
# File 'lib/ffi/clang/cursor.rb', line 49

def raw_comment_text
	Lib.extract_string Lib.cursor_get_raw_comment_text(@cursor)
end

#reference? ⇒ Boolean

Returns:

  • (Boolean) 


69
70
71
 
# File 'lib/ffi/clang/cursor.rb', line 69

def reference?
	Lib.is_reference(kind) != 0
end

#referenced ⇒ Object 



244
245
246
 
# File 'lib/ffi/clang/cursor.rb', line 244

def referenced
	Cursor.new Lib.get_cursor_referenced(@cursor), @translation_unit
end

#references(file = nil) ⇒ Object 



427
428
429
430
431
432
433
434
 
# File 'lib/ffi/clang/cursor.rb', line 427

def references(file = nil)
	refs = []
	self.find_references_in_file(file) do |cursor, unused|
		refs << cursor
		:continue
	end
	refs
end

#result_type ⇒ Object 



169
170
171
 
# File 'lib/ffi/clang/cursor.rb', line 169

def result_type
	Type.new Lib.get_cursor_result_type(@cursor), @translation_unit
end

#select ⇒ Object 



413
414
415
416
417
 
# File 'lib/ffi/clang/cursor.rb', line 413

def select
	filter do |child, parent|
		yield(child)
	end
end

#semantic_parent ⇒ Object 



248
249
250
 
# File 'lib/ffi/clang/cursor.rb', line 248

def semantic_parent
	Cursor.new Lib.get_cursor_semantic_parent(@cursor), @translation_unit
end

#specialized_template ⇒ Object 



217
218
219
 
# File 'lib/ffi/clang/cursor.rb', line 217

def specialized_template
	Cursor.new Lib.get_specialized_cursor_template(@cursor), @translation_unit
end

#spelling ⇒ Object 



145
146
147
 
# File 'lib/ffi/clang/cursor.rb', line 145

def spelling
	Lib.extract_string Lib.get_cursor_spelling(@cursor)
end

#spelling_location ⇒ Object 



122
123
124
 
# File 'lib/ffi/clang/cursor.rb', line 122

def spelling_location
	SpellingLocation.new(Lib.get_cursor_location(@cursor))
end

#statement? ⇒ Boolean

Returns:

  • (Boolean) 


77
78
79
 
# File 'lib/ffi/clang/cursor.rb', line 77

def statement?
	Lib.is_statement(kind) != 0
end

#static? ⇒ Boolean

Returns:

  • (Boolean) 


193
194
195
 
# File 'lib/ffi/clang/cursor.rb', line 193

def static?
	Lib.cxx_method_is_static(@cursor) != 0
end

#template_kind ⇒ Object 



256
257
258
 
# File 'lib/ffi/clang/cursor.rb', line 256

def template_kind
	Lib.get_template_cursor_kind @cursor
end

#to_a ⇒ Object 



423
424
425
 
# File 'lib/ffi/clang/cursor.rb', line 423

def to_a
	filter.collect{|child, parent| child}
end

#to_s ⇒ Object 



419
420
421
 
# File 'lib/ffi/clang/cursor.rb', line 419

def to_s
	"Cursor <#{self.kind.to_s.gsub(/^cursor_/, '')}: #{self.spelling}>"
end

#translation_unit? ⇒ Boolean

Returns:

  • (Boolean) 


101
102
103
 
# File 'lib/ffi/clang/cursor.rb', line 101

def translation_unit?
	Lib.is_translation_unit(kind) != 0
end

#type ⇒ Object 



165
166
167
 
# File 'lib/ffi/clang/cursor.rb', line 165

def type
	Type.new Lib.get_cursor_type(@cursor), @translation_unit
end

#underlying_type ⇒ Object 



173
174
175
 
# File 'lib/ffi/clang/cursor.rb', line 173

def underlying_type
	Type.new Lib.get_typedef_decl_underlying_type(@cursor), @translation_unit
end

#unexposed? ⇒ Boolean

Returns:

  • (Boolean) 


109
110
111
 
# File 'lib/ffi/clang/cursor.rb', line 109

def unexposed?
	Lib.is_unexposed(kind) != 0
end

#usr ⇒ Object 



153
154
155
 
# File 'lib/ffi/clang/cursor.rb', line 153

def usr
	Lib.extract_string Lib.get_cursor_usr(@cursor)
end

#variadic? ⇒ Boolean

Returns:

  • (Boolean) 


185
186
187
 
# File 'lib/ffi/clang/cursor.rb', line 185

def variadic?
	Lib.is_variadic(@cursor) != 0
end

#virtual? ⇒ Boolean

Returns:

  • (Boolean) 


197
198
199
 
# File 'lib/ffi/clang/cursor.rb', line 197

def virtual?
	Lib.cxx_method_is_virtual(@cursor) != 0
end

#virtual_base? ⇒ Boolean

Returns:

  • (Boolean) 


177
178
179
 
# File 'lib/ffi/clang/cursor.rb', line 177

def virtual_base?
	Lib.is_virtual_base(@cursor) != 0
end

#visit_children(&block) ⇒ Object 



272
273
274
275
276
277
278
 
# File 'lib/ffi/clang/cursor.rb', line 272

def visit_children(&block)
	adapter = Proc.new do |cxcursor, parent_cursor, unused|
		block.call Cursor.new(cxcursor, @translation_unit), Cursor.new(parent_cursor, @translation_unit)
	end
	
	Lib.visit_children(@cursor, adapter, nil)
end