clangc 1.0.0.pre

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (38) hide show
  1. checksums.yaml +7 -0
  2. data/ext/clangc/_clangc_functions.c +303 -0
  3. data/ext/clangc/_clangc_functions.h +51 -0
  4. data/ext/clangc/clangc.c +376 -0
  5. data/ext/clangc/class_CodeCompleteResults.c +186 -0
  6. data/ext/clangc/class_CodeCompleteResults.h +51 -0
  7. data/ext/clangc/class_CompletionResult.c +98 -0
  8. data/ext/clangc/class_CompletionResult.h +36 -0
  9. data/ext/clangc/class_CompletionString.c +231 -0
  10. data/ext/clangc/class_CompletionString.h +57 -0
  11. data/ext/clangc/class_Cursor.c +1677 -0
  12. data/ext/clangc/class_Cursor.h +259 -0
  13. data/ext/clangc/class_CursorSet.c +109 -0
  14. data/ext/clangc/class_CursorSet.h +39 -0
  15. data/ext/clangc/class_Diagnostic.c +322 -0
  16. data/ext/clangc/class_Diagnostic.h +66 -0
  17. data/ext/clangc/class_File.c +145 -0
  18. data/ext/clangc/class_File.h +45 -0
  19. data/ext/clangc/class_Index.c +461 -0
  20. data/ext/clangc/class_Index.h +58 -0
  21. data/ext/clangc/class_Module.c +181 -0
  22. data/ext/clangc/class_Module.h +51 -0
  23. data/ext/clangc/class_OverriddenCursor.c +51 -0
  24. data/ext/clangc/class_OverriddenCursor.h +31 -0
  25. data/ext/clangc/class_SourceLocation.c +197 -0
  26. data/ext/clangc/class_SourceLocation.h +45 -0
  27. data/ext/clangc/class_SourceRange.c +123 -0
  28. data/ext/clangc/class_SourceRange.h +42 -0
  29. data/ext/clangc/class_TranslationUnit.c +457 -0
  30. data/ext/clangc/class_TranslationUnit.h +63 -0
  31. data/ext/clangc/class_Type.c +564 -0
  32. data/ext/clangc/class_Type.h +108 -0
  33. data/ext/clangc/constants.c +660 -0
  34. data/ext/clangc/constants.h +21 -0
  35. data/ext/clangc/extconf.rb +34 -0
  36. data/ext/clangc/macros.h +230 -0
  37. data/lib/clangc.rb +397 -0
  38. metadata +95 -0
@@ -0,0 +1,7 @@
1
+ ---
2
+ SHA1:
3
+ metadata.gz: 45e07e9b9db18eeca9b0a85378ecea78a7c052d1
4
+ data.tar.gz: fd2d61448951cf4a9cce3854ffdddde76bec3df5
5
+ SHA512:
6
+ metadata.gz: b3bf07d69593b7a8a1da428a0a0f5615d4411d918d2ef64f6784a4beef6a9819d8587ad58f57ae2f4c9ad62e71fe684c5f2884e0a531d8129c67069dc0b997b2
7
+ data.tar.gz: b1e9423bf2c78e60ec92de23cac45150fb07dcc31aadeff1f15d45f0d0a54988af7cac0ff9cc0a30eb36fdda7f642b3d7c197874f42e134fad3ab0556540f391
@@ -0,0 +1,303 @@
1
+ /*
2
+ * ruby-clangc ruby bindings for the C interface of Clang
3
+ * Copyright (C) 2015-2016 Cedric Le Moigne cedlemo <cedlemo@gmx.com>
4
+ *
5
+ * This program is free software: you can redistribute it and/or modify
6
+ * it under the terms of the GNU General Public License as published by
7
+ * the Free Software Foundation, either version 3 of the License, or
8
+ * (at your option) any later version.
9
+ *
10
+ * This program is distributed in the hope that it will be useful,
11
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
12
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13
+ * GNU General Public License for more details.
14
+ *
15
+ * You should have received a copy of the GNU General Public License
16
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
17
+ */
18
+
19
+ #include "_clangc_functions.h"
20
+ #include "clang-c/Index.h"
21
+ #include "class_SourceRange.h"
22
+ #include "class_SourceLocation.h"
23
+ #include "class_Cursor.h"
24
+
25
+ /**
26
+ * call-seq:
27
+ * Clangc.version => String
28
+ *
29
+ * Return a version string, suitable for showing to a user, but not
30
+ * intended to be parsed (the format is not guaranteed to be stable).
31
+ */
32
+
33
+ VALUE
34
+ m_clangc_get_version(VALUE self)
35
+ {
36
+ return CXSTR_2_RVAL(clang_getClangVersion());
37
+ }
38
+
39
+ /**
40
+ * call-seq:
41
+ * Clangc.default_diagnostic_display_options => Fixnum
42
+ *
43
+ * Retrieve the set of display options most similar to the
44
+ * default behavior of the clang compiler.
45
+ *
46
+ * A set of display options suitable for use with Clangc::Diagnostic#format
47
+ */
48
+
49
+ VALUE
50
+ m_clangc_get_default_diagnostic_display_options(VALUE self)
51
+ {
52
+ return CUINT_2_NUM(clang_defaultDiagnosticDisplayOptions());
53
+ }
54
+
55
+ /**
56
+ * call-seq:
57
+ * Clangc.default_editing_translation_unit_options => Fixnum
58
+ *
59
+ * Returns the set of flags that is suitable for parsing a translation
60
+ * unit that is being edited. (Clangc::TranslationUnit_Flags constants)
61
+ *
62
+ * The set of flags returned provide options for
63
+ * Clangc::Index#parseTranslationUnit
64
+ * to indicate that the translation unit is likely to be reparsed many times,
65
+ * either explicitly (via Clangc::TranslationUnit#reparse) or implicitly
66
+ * (e.g., by code completion ( Clangc::TranslationUnit#CodeCompleteAt). The
67
+ * returned flag
68
+ * set contains an unspecified set of optimizations (e.g., the precompiled
69
+ * preamble) geared toward improving the performance of these routines. The
70
+ * set of optimizations enabled may change from one version to the next.
71
+ */
72
+
73
+ VALUE
74
+ m_clangc_get_default_editing_translation_unit_options(VALUE self)
75
+ {
76
+ return CUINT_2_NUM(clang_defaultEditingTranslationUnitOptions());
77
+ }
78
+
79
+ /**
80
+ * call-seq:
81
+ * Clangc.default_code_complete_options => Fixnum
82
+ *
83
+ * Returns a default set of code-completion options that can be
84
+ * passed to Clangc::TranslationUnit#codeCompleteAt.
85
+ * This set is be bitwise-OR'd constants of the Clangc::CodeComplete_Flags
86
+ */
87
+
88
+ VALUE
89
+ m_clangc_get_default_code_complete_options(VALUE self)
90
+ {
91
+ return CUINT_2_NUM(clang_defaultCodeCompleteOptions());
92
+ }
93
+
94
+ /**
95
+ * call-seq:
96
+ * Clangc.null_source_range
97
+ *
98
+ * Retrieve a NULL (invalid) source range
99
+ */
100
+
101
+ VALUE
102
+ m_clangc_get_null_source_range(VALUE self)
103
+ {
104
+ SourceRange_t *s;
105
+ VALUE source_range;
106
+ R_GET_CLASS_DATA("Clangc", SourceRange, source_range, s);
107
+ s->data = clang_getNullRange();
108
+ return source_range;
109
+ }
110
+
111
+ /**
112
+ * call-seq:
113
+ * Clangc.null_source_location
114
+ *
115
+ * Retrieve a NULL (invalid) source location.
116
+ */
117
+
118
+ VALUE
119
+ m_clangc_get_null_source_location(VALUE self)
120
+ {
121
+ SourceLocation_t *s;
122
+ VALUE source_location;
123
+ R_GET_CLASS_DATA("Clangc", SourceLocation, source_location, s);
124
+ s->data = clang_getNullLocation();
125
+ return source_location;
126
+ }
127
+
128
+ /**
129
+ * call-seq:
130
+ * Clangc.null_cursor
131
+ *
132
+ * Retrieve a NULL cursor which represents no entity
133
+ */
134
+
135
+ VALUE
136
+ m_clangc_get_null_cursor(VALUE self)
137
+ {
138
+ Cursor_t *c;
139
+ VALUE cursor;
140
+ R_GET_CLASS_DATA("Clangc", Cursor, cursor, c);
141
+ c->data = clang_getNullCursor();
142
+ return cursor;
143
+ }
144
+
145
+ static enum CXChildVisitResult
146
+ visitor(CXCursor cursor, CXCursor parent, CXClientData client_data)
147
+ {
148
+ VALUE callback, mClangc, cCursor;
149
+ VALUE r_cursor, r_parent;
150
+ VALUE r_ret;
151
+ Cursor_t *c;
152
+ Cursor_t *p;
153
+ unsigned ret;
154
+
155
+ callback = (VALUE) client_data;
156
+
157
+ mClangc = rb_const_get(rb_cObject, rb_intern("Clangc"));
158
+ cCursor = rb_const_get(mClangc, rb_intern("Cursor"));
159
+
160
+ r_cursor = rb_class_new_instance(0, NULL, cCursor);
161
+ Data_Get_Struct(r_cursor, Cursor_t, c);
162
+ c->data = cursor;
163
+
164
+ r_parent = rb_class_new_instance(0, NULL, cCursor);
165
+ Data_Get_Struct(r_parent, Cursor_t, p);
166
+ p->data = parent;
167
+
168
+ r_ret = rb_funcall(callback, rb_intern("call"), 2, r_cursor, r_parent);
169
+
170
+ if (TYPE(r_ret) == T_FIXNUM)
171
+ {
172
+ ret = NUM2UINT(r_ret);
173
+ if (ret == CXChildVisit_Break || ret == CXChildVisit_Continue ||
174
+ ret == CXChildVisit_Recurse)
175
+ return ret;
176
+ else
177
+ return CXChildVisit_Break;
178
+ }
179
+ else
180
+ return CXChildVisit_Break;
181
+ }
182
+
183
+ /**
184
+ * call-seq:
185
+ * Clangc.visit_children_with_proc(cursor, visitor) => Qtrue/ Qfalse
186
+ *
187
+ * Visit the children of a particular cursor.
188
+ *
189
+ * This function visits all the direct children of the given cursor,
190
+ * invoking the given visitor Proc with the cursors of each
191
+ * visited child. The traversal may be recursive, if the visitor returns
192
+ * Clangc::ChildVisitResult::Recurse. The traversal may also be ended
193
+ * prematurely, if
194
+ * the visitor returns Clangc::ChildVisit::Break.
195
+ *
196
+ * cursor the cursor whose child may be visited. All kinds of
197
+ * cursors can be visited, including invalid cursors (which, by
198
+ * definition, have no children).
199
+ *
200
+ * visitor the visitor function that will be invoked for each
201
+ * child of cursor.
202
+ *
203
+ * returns a true if the traversal was terminated
204
+ * prematurely by the visitor returning Clangc::ChildVisitiResult::Break.
205
+ *
206
+ * You should prefer to use :
207
+ *
208
+ * Clangc.visit_children(cursor: cursor, visitor: callback)
209
+ */
210
+
211
+ VALUE
212
+ m_clangc_visit_children_with_proc(VALUE self, VALUE cursor, VALUE aproc)
213
+ {
214
+ if (rb_class_of(aproc) != rb_cProc) rb_raise(rb_eTypeError, "Need a block");
215
+
216
+ VALUE callback = aproc;
217
+ Cursor_t *c;
218
+ unsigned ret_with_break;
219
+
220
+ Data_Get_Struct(cursor, Cursor_t, c);
221
+ ret_with_break = clang_visitChildren(c->data,
222
+ visitor,
223
+ (CXClientData) callback);
224
+ return NOT_0_2_RVAL(ret_with_break);
225
+ }
226
+
227
+ /**
228
+ * call-seq:
229
+ * Clangc.visit_children_with_block(cursor) => Qtrue/ Qfalse
230
+ *
231
+ * Visit the children of a particular cursor.
232
+ *
233
+ * This function visits all the direct children of the given cursor,
234
+ * invoking the block with the cursors of each
235
+ * visited child. The traversal may be recursive, if the visitor returns
236
+ * Clangc::ChildVisitResult::Recurse. The traversal may also be ended
237
+ * prematurely, if
238
+ * the visitor returns Clangc::ChildVisit::Break.
239
+ *
240
+ * cursor the cursor whose child may be visited. All kinds of
241
+ * cursors can be visited, including invalid cursors (which, by
242
+ * definition, have no children).
243
+ *
244
+ * visitor the visitor function that will be invoked for each
245
+ * child of cursor.
246
+ *
247
+ * returns a true if the traversal was terminated
248
+ * prematurely by the visitor returning Clangc::ChildVisitiResult::Break.
249
+ *
250
+ * You should prefer to use :
251
+ *
252
+ * Clangc.visit_children(cursor: cursor, visitor: callback)
253
+ */
254
+ VALUE
255
+ m_clangc_visit_children_with_block(VALUE self, VALUE cursor)
256
+ {
257
+ if (rb_block_given_p() == 0) rb_raise(rb_eTypeError, "Need a block");
258
+
259
+ VALUE callback = rb_block_proc();
260
+ Cursor_t *c;
261
+ unsigned ret_with_break;
262
+
263
+ Data_Get_Struct(cursor, Cursor_t, c);
264
+ ret_with_break = clang_visitChildren(c->data,
265
+ visitor,
266
+ (CXClientData) callback);
267
+ return NOT_0_2_RVAL(ret_with_break);
268
+ }
269
+
270
+ /**
271
+ * call-seq:
272
+ * Clangc.range(Clangc::SourceLocation, Clangc::SourceLocation) =>
273
+ * Clangc::SourceRange
274
+ *
275
+ * Retrieve a source range given the beginning and ending source
276
+ * locations.
277
+ */
278
+ VALUE
279
+ m_clangc_get_range(VALUE self, VALUE begin, VALUE end)
280
+ {
281
+ CHECK_ARG_TYPE(begin, SourceLocation);
282
+ CHECK_ARG_TYPE(end, SourceLocation);
283
+
284
+ SourceLocation_t *b;
285
+ SourceLocation_t *e;
286
+ VALUE range;
287
+ SourceRange_t *s;
288
+ SourceRange_t *p;
289
+
290
+ Data_Get_Struct(begin, SourceLocation_t, b);
291
+ Data_Get_Struct(end, SourceLocation_t, e);
292
+ // TODO Should I add a check to see if they come from the same
293
+ // file / TU
294
+ R_GET_CLASS_DATA("Clangc", SourceRange, range, s);
295
+
296
+ s->data = clang_getRange(b->data, e->data);
297
+
298
+ // We use the parent of the first parameter (no real reason)
299
+ Data_Get_Struct(b->parent, SourceRange_t, p);
300
+ s->parent = p->parent;
301
+
302
+ return range;
303
+ }
@@ -0,0 +1,51 @@
1
+ /*
2
+ * ruby-clangc ruby bindings for the C interface of Clang
3
+ * Copyright (C) 2015-2016 Cedric Le Moigne cedlemo <cedlemo@gmx.com>
4
+ *
5
+ * This program is free software: you can redistribute it and/or modify
6
+ * it under the terms of the GNU General Public License as published by
7
+ * the Free Software Foundation, either version 3 of the License, or
8
+ * (at your option) any later version.
9
+ *
10
+ * This program is distributed in the hope that it will be useful,
11
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
12
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13
+ * GNU General Public License for more details.
14
+ *
15
+ * You should have received a copy of the GNU General Public License
16
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
17
+ */
18
+ #ifndef _CLANGC_FUNCTIONS_H
19
+ #define _CLANGC_FUNCTIONS_H
20
+ #include <ruby/ruby.h>
21
+ #include "macros.h"
22
+ VALUE
23
+ m_clangc_get_version(VALUE);
24
+
25
+ VALUE
26
+ m_clangc_get_default_diagnostic_display_options(VALUE);
27
+
28
+ VALUE
29
+ m_clangc_get_default_editing_translation_unit_options(VALUE);
30
+
31
+ VALUE
32
+ m_clangc_get_default_code_complete_options(VALUE);
33
+
34
+ VALUE
35
+ m_clangc_get_null_source_range(VALUE);
36
+
37
+ VALUE
38
+ m_clangc_get_null_source_location(VALUE);
39
+
40
+ VALUE
41
+ m_clangc_get_null_cursor(VALUE);
42
+
43
+ VALUE
44
+ m_clangc_visit_children_with_proc(VALUE, VALUE, VALUE);
45
+
46
+ VALUE
47
+ m_clangc_visit_children_with_block(VALUE, VALUE);
48
+
49
+ VALUE
50
+ m_clangc_get_range(VALUE, VALUE, VALUE);
51
+ #endif
@@ -0,0 +1,376 @@
1
+ /*
2
+ * ruby-clangc ruby bindings for the C interface of Clang
3
+ * Copyright (C) 2015-2016 Cedric Le Moigne <cedlemo@gmx.com>
4
+ *
5
+ * This program is free software: you can redistribute it and/or modify
6
+ * it under the terms of the GNU General Public License as published by
7
+ * the Free Software Foundation, either version 3 of the License, or
8
+ * (at your option) any later version.
9
+ *
10
+ * This program is distributed in the hope that it will be useful,
11
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
12
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13
+ * GNU General Public License for more details.
14
+ *
15
+ * You should have received a copy of the GNU General Public License
16
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
17
+ */
18
+ #include <ruby/ruby.h>
19
+ #include "clang-c/Index.h"
20
+
21
+ #include "constants.h"
22
+ #include "_clangc_functions.h"
23
+ #include "class_Index.h"
24
+ #include "class_TranslationUnit.h"
25
+ #include "class_Diagnostic.h"
26
+ #include "class_File.h"
27
+ #include "class_SourceRange.h"
28
+ #include "class_SourceLocation.h"
29
+ #include "class_Cursor.h"
30
+ #include "class_Type.h"
31
+ #include "class_CursorSet.h"
32
+ #include "class_CompletionString.h"
33
+ #include "class_OverriddenCursor.h"
34
+ #include "class_Module.h"
35
+ #include "class_CodeCompleteResults.h"
36
+ #include "class_CompletionResult.h"
37
+
38
+ void Init_clangc(void) {
39
+ VALUE m_Clangc;
40
+ VALUE c_Index;
41
+ VALUE c_TranslationUnit;
42
+ VALUE c_Diagnostic;
43
+ VALUE c_File;
44
+ VALUE c_SourceRange;
45
+ VALUE c_SourceLocation;
46
+ VALUE c_Cursor;
47
+ VALUE c_OverriddenCursor;
48
+ VALUE c_Type;
49
+ VALUE c_CursorSet;
50
+ VALUE c_CompletionString;
51
+ VALUE c_Module;
52
+ VALUE c_CodeCompleteResults;
53
+ VALUE c_CompletionResult;
54
+
55
+ m_Clangc = rb_define_module("Clangc");
56
+
57
+ rb_define_module_function(m_Clangc, "version", RUBY_METHOD_FUNC(m_clangc_get_version), 0);// in _clangc_functions.c
58
+ rb_define_module_function(m_Clangc, "default_diagnostic_display_options", RUBY_METHOD_FUNC(m_clangc_get_default_diagnostic_display_options), 0);// in _clangc_functions.c
59
+ rb_define_module_function(m_Clangc, "default_editing_translation_unit_options", RUBY_METHOD_FUNC(m_clangc_get_default_editing_translation_unit_options), 0);// in _clangc_functions.c
60
+ rb_define_module_function(m_Clangc, "default_code_complete_options", RUBY_METHOD_FUNC(m_clangc_get_default_code_complete_options), 0);// in _clangc_functions.c
61
+ rb_define_module_function(m_Clangc, "null_source_range", RUBY_METHOD_FUNC(m_clangc_get_null_source_range), 0);// in _clangc_functions.c
62
+ rb_define_module_function(m_Clangc, "null_source_location", RUBY_METHOD_FUNC(m_clangc_get_null_source_location), 0);// in _clangc_functions.c
63
+ rb_define_module_function(m_Clangc, "null_cursor", RUBY_METHOD_FUNC(m_clangc_get_null_cursor), 0);// in _clangc_functions.c
64
+ rb_define_module_function(m_Clangc, "visit_children_with_proc", RUBY_METHOD_FUNC(m_clangc_visit_children_with_proc), 2);// in _clangc_functions.c
65
+ rb_define_module_function(m_Clangc, "visit_children_with_block", RUBY_METHOD_FUNC(m_clangc_visit_children_with_block), 1);// in _clangc_functions.c
66
+ rb_define_module_function(m_Clangc, "range", RUBY_METHOD_FUNC(m_clangc_get_range), 2);// in _clangc_functions.c
67
+
68
+ init_clang_enums_to_constants(m_Clangc);
69
+ init_clang_errors_enums_to_constants(m_Clangc);
70
+
71
+ /*
72
+ * An "index" consists of a set of translation units that would
73
+ * typically be linked together into an executable or library.
74
+ */
75
+ c_Index = rb_define_class_under(m_Clangc, "Index", rb_cObject);
76
+ rb_define_alloc_func(c_Index, c_Index_struct_alloc);
77
+ rb_define_private_method(c_Index, "initialize", RUBY_METHOD_FUNC(c_Index_initialize), 2);// in class_Index.c
78
+ rb_define_method(c_Index, "global_options=", RUBY_METHOD_FUNC(c_Index_set_global_options), 1);// in class_Index.c
79
+ rb_define_method(c_Index, "global_options", RUBY_METHOD_FUNC(c_Index_get_global_options), 0);// in class_Index.c
80
+ rb_define_method(c_Index, "create_translation_unit_from_source_file", RUBY_METHOD_FUNC(c_Index_create_TU_from_source_file), 2);// in class_Index.c
81
+ rb_define_method(c_Index, "create_translation_unit", RUBY_METHOD_FUNC(c_Index_create_TU), 1);// in class_Index.c
82
+ rb_define_method(c_Index, "create_translation_unit2", RUBY_METHOD_FUNC(c_Index_create_TU2), 1);// in class_Index.c
83
+ rb_define_method(c_Index, "parse_translation_unit", RUBY_METHOD_FUNC(c_Index_parse_TU), 3);// in class_Index.c
84
+ rb_define_method(c_Index, "parse_translation_unit2", RUBY_METHOD_FUNC(c_Index_parse_TU2), 3);// in class_Index.c
85
+ #if (CINDEX_VERSION_MINOR >= 32)
86
+ rb_define_method(c_Index, "parse_translation_unit2_full_argv", RUBY_METHOD_FUNC(c_Index_parse_TU2_full_argv), 3);// in class_Index.c
87
+ #endif
88
+
89
+ /*
90
+ * A single TranslationUnit which resides in an Index
91
+ */
92
+ c_TranslationUnit = rb_define_class_under(m_Clangc, "TranslationUnit", rb_cObject);
93
+ rb_define_alloc_func(c_TranslationUnit, c_TranslationUnit_struct_alloc);
94
+ rb_define_method(c_TranslationUnit, "diagnostics_num", RUBY_METHOD_FUNC(c_TranslationUnit_get_diagnostics_num), 0);// in class_TranslationUnit.c
95
+ rb_define_method(c_TranslationUnit, "default_save_options", RUBY_METHOD_FUNC(c_TranslationUnit_get_default_save_options), 0);// in class_TranslationUnit.c
96
+ rb_define_method(c_TranslationUnit, "spelling", RUBY_METHOD_FUNC(c_TranslationUnit_get_spelling), 0);// in class_TranslationUnit.c
97
+ rb_define_method(c_TranslationUnit, "default_reparse_options", RUBY_METHOD_FUNC(c_TranslationUnit_get_default_reparse_options), 0);// in class_TranslationUnit.c
98
+ rb_define_method(c_TranslationUnit, "diagnostic", RUBY_METHOD_FUNC(c_TranslationUnit_get_diagnostic), 1);// in class_TranslationUnit.c
99
+ rb_define_method(c_TranslationUnit, "file", RUBY_METHOD_FUNC(c_TranslationUnit_get_file), 1);// in class_TranslationUnit.c
100
+ rb_define_method(c_TranslationUnit, "cursor", RUBY_METHOD_FUNC(c_TranslationUnit_get_cursor), 0);// in class_TranslationUnit.c
101
+ rb_define_method(c_TranslationUnit, "module", RUBY_METHOD_FUNC(c_TranslationUnit_get_module), 1);// in class_TranslationUnit.c
102
+ rb_define_method(c_TranslationUnit, "code_complete_at", RUBY_METHOD_FUNC(c_TranslationUnit_code_complete_at), 4);// in class_TranslationUnit.c
103
+ rb_define_method(c_TranslationUnit, "reparse", RUBY_METHOD_FUNC(c_TranslationUnit_reparse), 1);// in class_TranslationUnit.c
104
+ rb_define_method(c_TranslationUnit, "skipped_ranges", RUBY_METHOD_FUNC(c_TranslationUnit_get_skipped_ranges), 1);// in class_TranslationUnit.c
105
+
106
+ /*
107
+ * A diagnostic object, containing the diagnostic's severity,
108
+ * location, text, source ranges, and fix-it hints.
109
+ */
110
+ c_Diagnostic = rb_define_class_under(m_Clangc, "Diagnostic", rb_cObject);
111
+ rb_define_alloc_func(c_Diagnostic, c_Diagnostic_struct_alloc);
112
+ rb_define_method(c_Diagnostic, "severity", RUBY_METHOD_FUNC(c_Diagnostic_get_severity), 0);// in class_Diagnostic.c
113
+ rb_define_method(c_Diagnostic, "spelling", RUBY_METHOD_FUNC(c_Diagnostic_get_spelling), 0);// in class_Diagnostic.c
114
+ rb_define_method(c_Diagnostic, "category", RUBY_METHOD_FUNC(c_Diagnostic_get_category), 0);// in class_Diagnostic.c
115
+ rb_define_method(c_Diagnostic, "category_name", RUBY_METHOD_FUNC(c_Diagnostic_get_category_name), 0);// in class_Diagnostic.c
116
+ rb_define_method(c_Diagnostic, "category_text", RUBY_METHOD_FUNC(c_Diagnostic_get_category_text), 0);// in class_Diagnostic.c
117
+ rb_define_method(c_Diagnostic, "num_ranges", RUBY_METHOD_FUNC(c_Diagnostic_get_num_ranges), 0);// in class_Diagnostic.c
118
+ rb_define_method(c_Diagnostic, "num_fixits", RUBY_METHOD_FUNC(c_Diagnostic_get_num_fixits), 0);// in class_Diagnostic.c
119
+ rb_define_method(c_Diagnostic, "format", RUBY_METHOD_FUNC(c_Diagnostic_format), 1);// in class_Diagnostic.c
120
+ rb_define_method(c_Diagnostic, "option", RUBY_METHOD_FUNC(c_Diagnostic_get_option), 0);// in class_Diagnostic.c
121
+ rb_define_method(c_Diagnostic, "source_range", RUBY_METHOD_FUNC(c_Diagnostic_get_source_range), 1);// in class_Diagnostic.c
122
+ rb_define_method(c_Diagnostic, "source_location", RUBY_METHOD_FUNC(c_Diagnostic_get_source_location), 0);// in class_Diagnostic.c
123
+ rb_define_method(c_Diagnostic, "fixit", RUBY_METHOD_FUNC(c_Diagnostic_get_fixit), 1); // in class_Diagnostic.c
124
+
125
+ /*
126
+ * A particular source file that is part of a translation unit
127
+ */
128
+ c_File = rb_define_class_under(m_Clangc, "File", rb_cObject);
129
+ rb_define_alloc_func(c_File, c_File_struct_alloc);
130
+ rb_define_method(c_File, "name", RUBY_METHOD_FUNC(c_File_get_name),0);// in class_File.c
131
+ rb_define_method(c_File, "mtime", RUBY_METHOD_FUNC(c_File_get_mtime),0);// in class_File.c
132
+ rb_define_method(c_File, "is_multiple_include_guarded", RUBY_METHOD_FUNC(c_File_is_multiple_include_guarded),0);// in class_File.c
133
+ #if (CINDEX_VERSION_MINOR >= 29)
134
+ rb_define_method(c_File, "is_equal", RUBY_METHOD_FUNC(c_File_is_equal), 1);// in class_File.c
135
+ #endif
136
+
137
+ /*
138
+ * Identifies a half-open character range in the source code.
139
+ *
140
+ * Use Clangc::SourceRange#start and Clangc::SourceRange#end to retrieve the
141
+ * starting and end locations from a source range, respectively.
142
+ */
143
+ c_SourceRange = rb_define_class_under(m_Clangc, "SourceRange", rb_cObject);
144
+ rb_define_alloc_func(c_SourceRange, c_SourceRange_struct_alloc);
145
+ rb_define_method(c_SourceRange, "is_null", RUBY_METHOD_FUNC(c_SourceRange_is_null), 0);// in class_SourceRange.c
146
+ rb_define_method(c_SourceRange, "is_equal", RUBY_METHOD_FUNC(c_SourceRange_is_equal), 1);// in class_SourceRange.c
147
+ rb_define_method(c_SourceRange, "start", RUBY_METHOD_FUNC(c_SourceRange_get_start), 0);// in class_SourceRange.c
148
+ rb_define_method(c_SourceRange, "end", RUBY_METHOD_FUNC(c_SourceRange_get_end), 0);// in class_SourceRange.c
149
+
150
+ /**
151
+ * Identifies a specific source location within a translation
152
+ * unit.
153
+ *
154
+ * Use Clangc::SourceLocation#expansion or Clangc::SourceLocation#spelling
155
+ * to map a source location to a particular file, line, and column.
156
+ */
157
+ c_SourceLocation = rb_define_class_under(m_Clangc, "SourceLocation", rb_cObject);
158
+ rb_define_alloc_func(c_SourceLocation, c_SourceLocation_struct_alloc);
159
+ rb_define_method(c_SourceLocation, "is_in_system_header", RUBY_METHOD_FUNC(c_SourceLocation_is_in_system_header), 0);// in class_SourceLocation.c
160
+ rb_define_method(c_SourceLocation, "is_from_main_file", RUBY_METHOD_FUNC(c_SourceLocation_is_from_main_file), 0);// in class_SourceLocation.c
161
+ rb_define_method(c_SourceLocation, "is_equal", RUBY_METHOD_FUNC(c_SourceLocation_is_equal), 1);// in class_SourceLocation.c
162
+ rb_define_method(c_SourceLocation, "spelling", RUBY_METHOD_FUNC(c_SourceLocation_get_spelling), 0);// in class_SourceLocation.c
163
+ rb_define_method(c_SourceLocation, "file_location", RUBY_METHOD_FUNC(c_SourceLocation_get_file_location), 0);// in class_SourceLocation.c
164
+
165
+ /**
166
+ * A cursor representing some element in the abstract syntax tree for
167
+ * a translation unit.
168
+ *
169
+ * The cursor abstraction unifies the different kinds of entities in a
170
+ * program--declaration, statements, expressions, references to declarations,
171
+ * etc.--under a single "cursor" abstraction with a common set of operations.
172
+ * Common operation for a cursor include: getting the physical location in
173
+ * a source file where the cursor points, getting the name associated with a
174
+ * cursor, and retrieving cursors for any child nodes of a particular cursor.
175
+ *
176
+ * Cursors can be produced in two specific ways.
177
+ * clangc::TranslationUnit.cursor produces a cursor for a translation unit,
178
+ * from which one can use clang.visitChildren to explore the rest of the
179
+ * translation unit. clang.getCursor maps from a physical source location
180
+ * to the entity that resides at that location, allowing one to map from the
181
+ * source code into the AST.
182
+ */
183
+ c_Cursor = rb_define_class_under(m_Clangc, "Cursor", rb_cObject);
184
+ rb_define_alloc_func(c_Cursor, c_Cursor_struct_alloc);
185
+ rb_define_method(c_Cursor, "is_null", RUBY_METHOD_FUNC(c_Cursor_is_null), 0);// in class_Cursor.c
186
+ rb_define_method(c_Cursor, "is_equal", RUBY_METHOD_FUNC(c_Cursor_is_equal), 1);// in class_Cursor.c
187
+ rb_define_method(c_Cursor, "hash", RUBY_METHOD_FUNC(c_Cursor_get_hash), 0);// in class_Cursor.c
188
+ rb_define_method(c_Cursor, "kind", RUBY_METHOD_FUNC(c_Cursor_get_kind), 0);// in class_Cursor.c
189
+ rb_define_method(c_Cursor, "linkage", RUBY_METHOD_FUNC(c_Cursor_get_linkage), 0);// in class_Cursor.c
190
+ rb_define_method(c_Cursor, "availability", RUBY_METHOD_FUNC(c_Cursor_get_availability), 0);// in class_Cursor.c
191
+ rb_define_method(c_Cursor, "language", RUBY_METHOD_FUNC(c_Cursor_get_language), 0);// in class_Cursor.c
192
+ rb_define_method(c_Cursor, "type", RUBY_METHOD_FUNC(c_Cursor_get_type), 0);// in class_Cursor.c
193
+ rb_define_method(c_Cursor, "semantic_parent", RUBY_METHOD_FUNC(c_Cursor_get_semantic_parent), 0);// in class_Cursor.c
194
+ rb_define_method(c_Cursor, "lexical_parent", RUBY_METHOD_FUNC(c_Cursor_get_lexical_parent), 0);// in class_Cursor.c
195
+ rb_define_method(c_Cursor, "location", RUBY_METHOD_FUNC(c_Cursor_get_source_location), 0);// in class_Cursor.c
196
+ rb_define_method(c_Cursor, "extent", RUBY_METHOD_FUNC(c_Cursor_get_extent), 0);// in class_Cursor.c
197
+ rb_define_method(c_Cursor, "spelling", RUBY_METHOD_FUNC(c_Cursor_get_spelling), 0);// in class_Cursor.c
198
+ rb_define_method(c_Cursor, "typedef_decl_underlying_type", RUBY_METHOD_FUNC(c_Cursor_get_typedef_decl_underlying_type), 0);// in class_Cursor.c
199
+ rb_define_method(c_Cursor, "included_file", RUBY_METHOD_FUNC(c_Cursor_get_included_file), 0);// in class_Cursor.c
200
+ rb_define_method(c_Cursor, "is_declaration", RUBY_METHOD_FUNC(c_Cursor_is_declaration), 0);// in class_Cursor.c
201
+ rb_define_method(c_Cursor, "is_reference", RUBY_METHOD_FUNC(c_Cursor_is_reference), 0);// in class_Cursor.c
202
+ rb_define_method(c_Cursor, "is_expression", RUBY_METHOD_FUNC(c_Cursor_is_expression), 0);// in class_Cursor.c
203
+ rb_define_method(c_Cursor, "is_statement", RUBY_METHOD_FUNC(c_Cursor_is_statement), 0);// in class_Cursor.c
204
+ rb_define_method(c_Cursor, "is_attribute", RUBY_METHOD_FUNC(c_Cursor_is_attribute), 0);// in class_Cursor.c
205
+ rb_define_method(c_Cursor, "is_invalid", RUBY_METHOD_FUNC(c_Cursor_is_invalid), 0);// in class_Cursor.c
206
+ rb_define_method(c_Cursor, "is_translation_unit", RUBY_METHOD_FUNC(c_Cursor_is_translation_unit), 0);// in class_Cursor.c
207
+ rb_define_method(c_Cursor, "is_preprocessing", RUBY_METHOD_FUNC(c_Cursor_is_preprocessing), 0);// in class_Cursor.c
208
+ rb_define_method(c_Cursor, "enum_decl_integer_type", RUBY_METHOD_FUNC(c_Cursor_get_enum_decl_integer_type), 0);// in class_Cursor.c
209
+ rb_define_method(c_Cursor, "enum_const_decl_value", RUBY_METHOD_FUNC(c_Cursor_get_enum_const_decl_value), 0);// in class_Cursor.c
210
+ rb_define_method(c_Cursor, "enum_const_decl_unsigned_value", RUBY_METHOD_FUNC(c_Cursor_get_enum_const_decl_unsigned_value), 0);// in class_Cursor.c
211
+ rb_define_method(c_Cursor, "field_decl_bit_width", RUBY_METHOD_FUNC(c_Cursor_get_field_decl_bit_width), 0);// in class_Cursor.c
212
+ rb_define_method(c_Cursor, "num_arguments", RUBY_METHOD_FUNC(c_Cursor_get_num_arguments), 0);// in class_Cursor.c
213
+ rb_define_method(c_Cursor, "argument", RUBY_METHOD_FUNC(c_Cursor_get_argument), 1);// in class_Cursor.c
214
+ #if (CINDEX_VERSION_MINOR >= 29)
215
+ rb_define_method(c_Cursor, "num_template_arguments", RUBY_METHOD_FUNC(c_Cursor_get_num_template_arguments), 0);// in class_Cursor.c
216
+ #endif
217
+ rb_define_method(c_Cursor, "decl_obj_c_type_encoding", RUBY_METHOD_FUNC(c_Cursor_get_decl_obj_c_type_encoding), 0);// in class_Cursor.c
218
+ rb_define_method(c_Cursor, "result_type", RUBY_METHOD_FUNC(c_Cursor_get_result_type), 0);// in class_Cursor.c
219
+ #if (CINDEX_VERSION_MINOR >= 30)
220
+ rb_define_method(c_Cursor, "offset_of_field", RUBY_METHOD_FUNC(c_Cursor_get_offset_of_field), 0);// in class_Cursor.c
221
+ rb_define_method(c_Cursor, "is_anonymous", RUBY_METHOD_FUNC(c_Cursor_is_anonymous), 0);// in class_Cursor.c
222
+ #endif
223
+ rb_define_method(c_Cursor, "is_bit_field", RUBY_METHOD_FUNC(c_Cursor_is_bit_field), 0);// in class_Cursor.c
224
+ rb_define_method(c_Cursor, "is_virtual_base", RUBY_METHOD_FUNC(c_Cursor_is_virtual_base), 0);// in class_Cursor.c
225
+ rb_define_method(c_Cursor, "cxx_access_specifier", RUBY_METHOD_FUNC(c_Cursor_get_cxx_access_specifier), 0);// in class_Cursor.c
226
+ #if (CINDEX_VERSION_MINOR >= 29)
227
+ rb_define_method(c_Cursor, "storage_class", RUBY_METHOD_FUNC(c_Cursor_get_storage_class), 0);// in class_Cursor.c
228
+ #endif
229
+ rb_define_method(c_Cursor, "num_overloaded_decls", RUBY_METHOD_FUNC(c_Cursor_get_num_overloaded_decls), 0);// in class_Cursor.c
230
+ rb_define_method(c_Cursor, "overloaded_decl", RUBY_METHOD_FUNC(c_Cursor_get_overloaded_decl), 1);// in class_Cursor.c
231
+ rb_define_method(c_Cursor, "ib_outlet_collection_type", RUBY_METHOD_FUNC(c_Cursor_get_ib_outlet_collection_type), 0);// in class_Cursor.c
232
+ rb_define_method(c_Cursor, "usr", RUBY_METHOD_FUNC(c_Cursor_get_usr), 0);// in class_Cursor.c
233
+ rb_define_method(c_Cursor, "display_name", RUBY_METHOD_FUNC(c_Cursor_get_display_name), 0);// in class_Cursor.c
234
+ rb_define_method(c_Cursor, "referenced", RUBY_METHOD_FUNC(c_Cursor_get_referenced), 0);// in class_Cursor.c
235
+ rb_define_method(c_Cursor, "definition", RUBY_METHOD_FUNC(c_Cursor_get_definition), 0);// in class_Cursor.c
236
+ rb_define_method(c_Cursor, "is_definition", RUBY_METHOD_FUNC(c_Cursor_is_definition), 0);// in class_Cursor.c
237
+ rb_define_method(c_Cursor, "canonical_cursor", RUBY_METHOD_FUNC(c_Cursor_get_canonical_cursor), 0);// in class_Cursor.c
238
+ rb_define_method(c_Cursor, "obj_c_selector_index", RUBY_METHOD_FUNC(c_Cursor_get_obj_c_selector_index), 0);// in class_Cursor.c
239
+ rb_define_method(c_Cursor, "is_dynamic_call", RUBY_METHOD_FUNC(c_Cursor_is_dynamic_call), 0);// in class_Cursor.c
240
+ rb_define_method(c_Cursor, "receiver_type", RUBY_METHOD_FUNC(c_Cursor_get_receiver_type), 0);// in class_Cursor.c
241
+ rb_define_method(c_Cursor, "obj_c_decl_qualifiers", RUBY_METHOD_FUNC(c_Cursor_get_obj_c_decl_qualifiers), 0);// in class_Cursor.c
242
+ rb_define_method(c_Cursor, "is_obj_c_optional", RUBY_METHOD_FUNC(c_Cursor_is_obj_c_optional), 0);// in class_Cursor.c
243
+ rb_define_method(c_Cursor, "is_variadic", RUBY_METHOD_FUNC(c_Cursor_is_variadic), 0);// in class_Cursor.c
244
+ rb_define_method(c_Cursor, "comment_range", RUBY_METHOD_FUNC(c_Cursor_get_comment_range), 0);// in class_Cursor.c
245
+ rb_define_method(c_Cursor, "raw_comment_text", RUBY_METHOD_FUNC(c_Cursor_get_raw_comment_text), 0);// in class_Cursor.c
246
+ rb_define_method(c_Cursor, "brief_comment_text", RUBY_METHOD_FUNC(c_Cursor_get_brief_comment_text), 0);// in class_Cursor.c
247
+ #if (CINDEX_VERSION_MINOR >= 29)
248
+ rb_define_method(c_Cursor, "mangling", RUBY_METHOD_FUNC(c_Cursor_get_mangling), 0);// in class_Cursor.c
249
+ #endif
250
+ rb_define_method(c_Cursor, "cxx_method_is_pure_virtual", RUBY_METHOD_FUNC(c_Cursor_cxx_method_is_pure_virtual), 0);// in class_Cursor.c
251
+ rb_define_method(c_Cursor, "cxx_method_is_static", RUBY_METHOD_FUNC(c_Cursor_cxx_method_is_static), 0);// in class_Cursor.c
252
+ rb_define_method(c_Cursor, "cxx_method_is_virtual", RUBY_METHOD_FUNC(c_Cursor_cxx_method_is_virtual), 0);// in class_Cursor.c
253
+ rb_define_method(c_Cursor, "cxx_method_is_const", RUBY_METHOD_FUNC(c_Cursor_cxx_method_is_const), 0);// in class_Cursor.c
254
+ rb_define_method(c_Cursor, "template_cursor_kind", RUBY_METHOD_FUNC(c_Cursor_get_template_cursor_kind), 0);// in class_Cursor.c
255
+ rb_define_method(c_Cursor, "specialized_cursor_template", RUBY_METHOD_FUNC(c_Cursor_get_specialized_cursor_template), 0);// in class_Cursor.c
256
+ rb_define_method(c_Cursor, "completion_string", RUBY_METHOD_FUNC(c_Cursor_get_completion_string), 0);// in class_Cursor.c
257
+ #if (CINDEX_VERSION_MINOR >= 29)
258
+ rb_define_method(c_Cursor, "template_argument_kind", RUBY_METHOD_FUNC(c_Cursor_get_template_argument_kind), 1);// in class_Cursor.c
259
+ rb_define_method(c_Cursor, "template_argument_type", RUBY_METHOD_FUNC(c_Cursor_get_template_argument_type), 1);// in class_Cursor.c
260
+ rb_define_method(c_Cursor, "template_argument_value", RUBY_METHOD_FUNC(c_Cursor_get_template_argument_value), 1);// in class_Cursor.c
261
+ rb_define_method(c_Cursor, "template_argument_unsigned_value", RUBY_METHOD_FUNC(c_Cursor_get_template_argument_unsigned_value), 1);// in class_Cursor.c
262
+ #endif
263
+ rb_define_method(c_Cursor, "obj_c_property_attributes", RUBY_METHOD_FUNC(c_Cursor_get_obj_c_property_attributes), 1);// in class_Cursor.c
264
+ rb_define_method(c_Cursor, "overridden_cursors", RUBY_METHOD_FUNC(c_Cursor_get_overridden_cursors), 0);// in class_Cursor.c
265
+ rb_define_method(c_Cursor, "module", RUBY_METHOD_FUNC(c_Cursor_get_module), 0);// in class_Cursor.c
266
+ rb_define_method(c_Cursor, "spelling_name_range", RUBY_METHOD_FUNC(c_Cursor_get_spelling_name_range), 2);// in class_Cursor.c
267
+ rb_define_method(c_Cursor, "reference_name_range", RUBY_METHOD_FUNC(c_Cursor_get_reference_name_range), 2);// in class_Cursor.c
268
+
269
+ /*
270
+ * Overriden Cursor is a subclass of cursor created because they need to be freed
271
+ * unlike the basics Clangc::Cursor
272
+ * */
273
+ c_OverriddenCursor = rb_define_class_under(m_Clangc, "OverriddenCursor", c_Cursor);
274
+ rb_define_alloc_func(c_OverriddenCursor, c_OverriddenCursor_struct_alloc);
275
+
276
+
277
+ /*
278
+ * Type informations for Clangc::Cursor
279
+ */
280
+ c_Type = rb_define_class_under(m_Clangc, "Type", rb_cObject);
281
+ rb_define_alloc_func(c_Type, c_Type_struct_alloc);
282
+ rb_define_method(c_Type, "kind", RUBY_METHOD_FUNC(c_Type_get_kind), 0);// in class_Type.c
283
+ rb_define_method(c_Type, "spelling", RUBY_METHOD_FUNC(c_Type_get_spelling), 0);// in class_Type.c
284
+ rb_define_method(c_Type, "is_equal", RUBY_METHOD_FUNC(c_Type_is_equal), 1);// in class_Type.c
285
+ rb_define_method(c_Type, "canonical_type", RUBY_METHOD_FUNC(c_Type_get_canonical_type), 0);// in class_Type.c
286
+ rb_define_method(c_Type, "pointee_type", RUBY_METHOD_FUNC(c_Type_get_pointee_type), 0);// in class_Type.c
287
+ rb_define_method(c_Type, "is_const_qualified", RUBY_METHOD_FUNC(c_Type_is_const_qualified), 0);// in class_Type.c
288
+ rb_define_method(c_Type, "is_volatile_qualified", RUBY_METHOD_FUNC(c_Type_is_volatile_qualified), 0);// in class_Type.c
289
+ rb_define_method(c_Type, "is_restrict_qualified", RUBY_METHOD_FUNC(c_Type_is_restrict_qualified), 0);// in class_Type.c
290
+ rb_define_method(c_Type, "result_type", RUBY_METHOD_FUNC(c_Type_get_result_type), 0);// in class_Type.c
291
+ rb_define_method(c_Type, "calling_conv", RUBY_METHOD_FUNC(c_Type_get_calling_conv), 0);// in class_Type.c
292
+ rb_define_method(c_Type, "num_arg_types", RUBY_METHOD_FUNC(c_Type_get_num_arg_types), 0);// in class_Type.c
293
+ rb_define_method(c_Type, "arg_type", RUBY_METHOD_FUNC(c_Type_get_arg_type), 1);// in class_Type.c
294
+ rb_define_method(c_Type, "element_type", RUBY_METHOD_FUNC(c_Type_get_element_type), 0);// in class_Type.c
295
+ rb_define_method(c_Type, "num_elements", RUBY_METHOD_FUNC(c_Type_get_num_elements), 0);// in class_Type.c
296
+ rb_define_method(c_Type, "array_element_type", RUBY_METHOD_FUNC(c_Type_get_array_element_type), 0);// in class_Type.c
297
+ rb_define_method(c_Type, "array_size", RUBY_METHOD_FUNC(c_Type_get_array_size), 0);// in class_Type.c
298
+ rb_define_method(c_Type, "is_pod", RUBY_METHOD_FUNC(c_Type_is_pod), 0);// in class_Type.c
299
+ rb_define_method(c_Type, "type_declaration", RUBY_METHOD_FUNC(c_Type_get_type_declaration), 0);// in class_Type.c
300
+ rb_define_method(c_Type, "is_function_type_variadic", RUBY_METHOD_FUNC(c_Type_is_function_type_variadic), 0);// in class_Type.c
301
+ rb_define_method(c_Type, "align_of", RUBY_METHOD_FUNC(c_Type_get_align_of), 0);// in class_Type.c
302
+ rb_define_method(c_Type, "size_of", RUBY_METHOD_FUNC(c_Type_get_size_of), 0);// in class_Type.c
303
+ rb_define_method(c_Type, "class_type", RUBY_METHOD_FUNC(c_Type_get_class_type), 0);// in class_Type.c
304
+ rb_define_method(c_Type, "offset_of", RUBY_METHOD_FUNC(c_Type_get_offset_of), 1);// in class_Type.c
305
+ rb_define_method(c_Type, "num_template_arguments", RUBY_METHOD_FUNC(c_Type_get_num_template_arguments), 0);// in class_Type.c
306
+ rb_define_method(c_Type, "template_argument_as_type", RUBY_METHOD_FUNC(c_Type_get_template_argument_as_type), 1);// in class_Type.c
307
+ rb_define_method(c_Type, "cxx_ref_qualifier", RUBY_METHOD_FUNC(c_Type_get_cxx_ref_qualifier), 0);// in class_Type.c
308
+
309
+ /**
310
+ * \brief A fast container representing a set of CXCursors.
311
+ */
312
+ c_CursorSet = rb_define_class_under(m_Clangc, "CursorSet", rb_cObject);
313
+ rb_define_alloc_func(c_CursorSet, c_CursorSet_struct_alloc);
314
+ rb_define_private_method(c_CursorSet, "initialize", RUBY_METHOD_FUNC(c_CursorSet_initialize), 0);// in class_CursorSet.c
315
+ rb_define_method(c_CursorSet, "contains", RUBY_METHOD_FUNC(c_CursorSet_contains), 1);// in class_CursorSet.c
316
+ rb_define_method(c_CursorSet, "insert", RUBY_METHOD_FUNC(c_CursorSet_insert), 1);// in class_CursorSet.c
317
+
318
+ /**
319
+ * \brief A semantic string that describes a code-completion result.
320
+ *
321
+ * A semantic string that describes the formatting of a code-completion
322
+ * result as a single "template" of text that should be inserted into the
323
+ * source buffer when a particular code-completion result is selected.
324
+ * Each semantic string is made up of some number of "chunks", each of which
325
+ * contains some text along with a description of what that text means, e.g.,
326
+ * the name of the entity being referenced, whether the text chunk is part of
327
+ * the template, or whether it is a "placeholder" that the user should replace
328
+ * with actual code,of a specific kind. See \c CXCompletionChunkKind for a
329
+ * description of the different kinds of chunks.
330
+ */
331
+ c_CompletionString = rb_define_class_under(m_Clangc, "CompletionString", rb_cObject);
332
+ rb_define_alloc_func(c_CompletionString, c_CompletionString_struct_alloc);
333
+ rb_define_method(c_CompletionString, "availability", RUBY_METHOD_FUNC(c_CompletionString_get_availability), 0);// in class_CompletionString.c
334
+ rb_define_method(c_CompletionString, "priority", RUBY_METHOD_FUNC(c_CompletionString_get_priority), 0);// in class_CompletionString.c
335
+ rb_define_method(c_CompletionString, "num_chunks", RUBY_METHOD_FUNC(c_CompletionString_get_num_chunks), 0);// in class_CompletionString.c
336
+ rb_define_method(c_CompletionString, "chunk_kind", RUBY_METHOD_FUNC(c_CompletionString_get_chunk_kind), 1);// in class_CompletionString.c
337
+ rb_define_method(c_CompletionString, "chunk_text", RUBY_METHOD_FUNC(c_CompletionString_get_chunk_text), 1);// in class_CompletionString.c
338
+ rb_define_method(c_CompletionString, "num_annotations", RUBY_METHOD_FUNC(c_CompletionString_get_num_annotations), 0);// in class_CompletionString.c
339
+ rb_define_method(c_CompletionString, "annotation", RUBY_METHOD_FUNC(c_CompletionString_get_annotation), 1);// in class_CompletionString.c
340
+ rb_define_method(c_CompletionString, "brief_comment", RUBY_METHOD_FUNC(c_CompletionString_get_brief_comment), 0);// in class_CompletionString.c
341
+ rb_define_method(c_CompletionString, "chunk_completion_string", RUBY_METHOD_FUNC(c_CompletionString_get_chunk_completion_string), 1);// in class_CompletionString.c
342
+
343
+ /**
344
+ * CXModule class and method
345
+ */
346
+ c_Module = rb_define_class_under(m_Clangc, "Module", rb_cObject);
347
+ rb_define_alloc_func(c_Module, c_Module_struct_alloc);
348
+ rb_define_method(c_Module, "ast_file", RUBY_METHOD_FUNC(c_Module_get_ast_file), 0);// in class_Module.c
349
+ rb_define_method(c_Module, "parent", RUBY_METHOD_FUNC(c_Module_get_parent), 0);// in class_Module.c
350
+ rb_define_method(c_Module, "name", RUBY_METHOD_FUNC(c_Module_get_name), 0);// in class_Module.c
351
+ rb_define_method(c_Module, "full_name", RUBY_METHOD_FUNC(c_Module_get_full_name), 0);// in class_Module.c
352
+ rb_define_method(c_Module, "is_system", RUBY_METHOD_FUNC(c_Module_is_system), 0);// in class_Module.c
353
+ rb_define_method(c_Module, "num_top_level_headers", RUBY_METHOD_FUNC(c_Module_get_num_top_level_headers), 1);// in class_Module.c
354
+ rb_define_method(c_Module, "top_level_header", RUBY_METHOD_FUNC(c_Module_get_top_level_header), 2);// in class_Module.c
355
+
356
+ /**
357
+ * CXCodeCompleteResults class and method
358
+ */
359
+ c_CodeCompleteResults = rb_define_class_under(m_Clangc, "CodeCompleteResults", rb_cObject);
360
+ rb_define_alloc_func(c_CodeCompleteResults, c_CodeCompleteResults_struct_alloc);
361
+ rb_define_method(c_CodeCompleteResults, "num_results", RUBY_METHOD_FUNC(c_CodeCompleteResults_get_num_results), 0);// in class_CodeCompleteResults.c
362
+ rb_define_method(c_CodeCompleteResults, "result", RUBY_METHOD_FUNC(c_CodeCompleteResults_get_result), 1);// in class_CodeCompleteResults.c
363
+ rb_define_method(c_CodeCompleteResults, "container_usr", RUBY_METHOD_FUNC(c_CodeCompleteResults_get_container_usr), 0);// in class_CodeCompleteResults.c
364
+ rb_define_method(c_CodeCompleteResults, "num_diagnostics", RUBY_METHOD_FUNC(c_CodeCompleteResults_get_num_diagnostics), 0);// in class_CodeCompleteResults.c
365
+ rb_define_method(c_CodeCompleteResults, "diagnostic", RUBY_METHOD_FUNC(c_CodeCompleteResults_get_diagnostic), 1);// in class_CodeCompleteResults.c
366
+ rb_define_method(c_CodeCompleteResults, "sort_results", RUBY_METHOD_FUNC(c_CodeCompleteResults_sort_results), 0);// in class_CodeCompleteResults.c
367
+ rb_define_method(c_CodeCompleteResults, "contexts", RUBY_METHOD_FUNC(c_CodeCompleteResults_get_contexts), 0);// in class_CodeCompleteResults.c
368
+
369
+ /**
370
+ * CXCompletionResult class and method
371
+ */
372
+ c_CompletionResult = rb_define_class_under(m_Clangc, "CompletionResult", rb_cObject);
373
+ rb_define_alloc_func(c_CompletionResult, c_CompletionResult_struct_alloc);
374
+ rb_define_method(c_CompletionResult, "cursor_kind", RUBY_METHOD_FUNC(c_CompletionResult_get_cursor_kind), 0);// in class_CompletionResult.c
375
+ rb_define_method(c_CompletionResult, "completion_string", RUBY_METHOD_FUNC(c_CompletionResult_get_completion_string), 0);// in class_CompletionResult.c
376
+ }