clangc 1.0.0.pre

data/ext/clangc/class_Cursor.h

@@ -0,0 +1,259 @@
+/*
+ * ruby-clangc ruby bindings for the C interface of Clang
+ * Copyright (C) 2015-2016 Cedric Le Moigne cedlemo <cedlemo@gmx.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+#ifndef CURSOR_H
+#define CURSOR_H
+#include <ruby/ruby.h>
+#include "clang-c/Index.h"
+typedef struct Cursor_t
+{
+    CXCursor data;
+    VALUE parent;
+} Cursor_t;
+
+VALUE
+c_Cursor_struct_alloc(VALUE);
+
+VALUE
+c_Cursor_is_null(VALUE);
+
+VALUE
+c_Cursor_is_equal(VALUE, VALUE);
+
+VALUE
+c_Cursor_get_hash(VALUE);
+
+VALUE
+c_Cursor_get_kind(VALUE);
+
+VALUE
+c_Cursor_get_linkage(VALUE);
+
+VALUE
+c_Cursor_get_availability(VALUE);
+
+VALUE
+c_Cursor_get_language(VALUE);
+
+VALUE
+c_Cursor_get_type(VALUE);
+
+VALUE
+c_Cursor_get_semantic_parent(VALUE);
+
+VALUE
+c_Cursor_get_lexical_parent(VALUE);
+
+VALUE
+c_Cursor_get_source_location(VALUE);
+
+VALUE
+c_Cursor_get_extent(VALUE);
+
+VALUE
+c_Cursor_get_spelling(VALUE);
+
+VALUE
+c_Cursor_get_typedef_decl_underlying_type(VALUE);
+
+VALUE
+c_Cursor_get_included_file(VALUE);
+
+VALUE
+c_Cursor_is_declaration(VALUE);
+
+VALUE
+c_Cursor_is_reference(VALUE);
+
+VALUE
+c_Cursor_is_expression(VALUE);
+
+VALUE
+c_Cursor_is_statement(VALUE);
+
+VALUE
+c_Cursor_is_attribute(VALUE);
+
+VALUE
+c_Cursor_is_invalid(VALUE);
+
+VALUE
+c_Cursor_is_translation_unit(VALUE);
+
+VALUE
+c_Cursor_is_preprocessing(VALUE);
+
+VALUE
+c_Cursor_get_enum_decl_integer_type(VALUE);
+
+VALUE
+c_Cursor_get_enum_const_decl_value(VALUE);
+
+VALUE
+c_Cursor_get_enum_const_decl_unsigned_value(VALUE);
+
+VALUE
+c_Cursor_get_field_decl_bit_width(VALUE);
+
+VALUE
+c_Cursor_get_num_arguments(VALUE);
+
+VALUE
+c_Cursor_get_argument(VALUE, VALUE);
+
+#if (CINDEX_VERSION_MINOR >= 29)
+VALUE
+c_Cursor_get_num_template_arguments(VALUE);
+#endif
+
+VALUE
+c_Cursor_get_decl_obj_c_type_encoding(VALUE);
+
+VALUE
+c_Cursor_get_result_type(VALUE);
+
+#if (CINDEX_VERSION_MINOR >= 30)
+VALUE
+c_Cursor_get_offset_of_field(VALUE);
+
+VALUE
+c_Cursor_is_anonymous(VALUE);
+#endif
+
+VALUE
+c_Cursor_is_bit_field(VALUE);
+
+VALUE
+c_Cursor_is_virtual_base(VALUE);
+
+VALUE
+c_Cursor_get_cxx_access_specifier(VALUE);
+
+#if (CINDEX_VERSION_MINOR >= 29)
+VALUE
+c_Cursor_get_storage_class(VALUE);
+#endif
+
+VALUE
+c_Cursor_get_num_overloaded_decls(VALUE);
+
+VALUE
+c_Cursor_get_overloaded_decl(VALUE, VALUE);
+
+VALUE
+c_Cursor_get_ib_outlet_collection_type(VALUE);
+
+VALUE
+c_Cursor_get_usr(VALUE);
+
+VALUE
+c_Cursor_get_display_name(VALUE);
+
+VALUE
+c_Cursor_get_referenced(VALUE);
+
+VALUE
+c_Cursor_get_definition(VALUE);
+
+VALUE
+c_Cursor_is_definition(VALUE);
+
+VALUE
+c_Cursor_get_canonical_cursor(VALUE);
+
+VALUE
+c_Cursor_get_obj_c_selector_index(VALUE);
+
+VALUE
+c_Cursor_is_dynamic_call(VALUE);
+
+VALUE
+c_Cursor_get_receiver_type(VALUE);
+
+VALUE
+c_Cursor_get_obj_c_decl_qualifiers(VALUE);
+
+VALUE
+c_Cursor_is_obj_c_optional(VALUE);
+
+VALUE
+c_Cursor_is_variadic(VALUE);
+
+VALUE
+c_Cursor_get_comment_range(VALUE);
+
+VALUE
+c_Cursor_get_raw_comment_text(VALUE);
+
+VALUE
+c_Cursor_get_brief_comment_text(VALUE);
+
+#if (CINDEX_VERSION_MINOR >= 29)
+VALUE
+c_Cursor_get_mangling(VALUE);
+#endif
+
+VALUE
+c_Cursor_cxx_method_is_pure_virtual(VALUE);
+
+VALUE
+c_Cursor_cxx_method_is_static(VALUE);
+
+VALUE
+c_Cursor_cxx_method_is_virtual(VALUE);
+
+VALUE
+c_Cursor_cxx_method_is_const(VALUE);
+
+VALUE
+c_Cursor_get_template_cursor_kind(VALUE);
+
+VALUE
+c_Cursor_get_specialized_cursor_template(VALUE);
+
+VALUE
+c_Cursor_get_completion_string(VALUE);
+
+#if (CINDEX_VERSION_MINOR >= 29)
+VALUE
+c_Cursor_get_template_argument_kind(VALUE, VALUE);
+
+VALUE
+c_Cursor_get_template_argument_type(VALUE, VALUE);
+
+VALUE
+c_Cursor_get_template_argument_value(VALUE, VALUE);
+
+VALUE
+c_Cursor_get_template_argument_unsigned_value(VALUE, VALUE);
+#endif
+
+VALUE
+c_Cursor_get_obj_c_property_attributes(VALUE, VALUE);
+
+VALUE
+c_Cursor_get_overridden_cursors(VALUE);
+
+VALUE
+c_Cursor_get_module(VALUE);
+
+VALUE
+c_Cursor_get_spelling_name_range(VALUE, VALUE, VALUE);
+
+VALUE
+c_Cursor_get_reference_name_range(VALUE, VALUE, VALUE);
+#endif // CURSOR_H

data/ext/clangc/class_CursorSet.c

@@ -0,0 +1,109 @@
+/*
+ * ruby-clangc ruby bindings for the C interface of Clang
+ * Copyright (C) 2015-2016 Cedric Le Moigne cedlemo <cedlemo@gmx.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/*CursorSet ruby class*/
+#include "class_CursorSet.h"
+#include "macros.h"
+#include "class_Cursor.h"
+
+static void c_CursorSet_struct_free(CursorSet_t *s)
+{
+    if (s)
+    {
+        if (s->data) clang_disposeCXCursorSet(s->data);
+
+        ruby_xfree(s);
+    }
+}
+
+static void c_CursorSet_mark(void *s)
+{
+    if (s)
+    {
+        CursorSet_t *t = (CursorSet_t *) s;
+        rb_gc_mark(t->parent);
+    }
+}
+VALUE
+c_CursorSet_struct_alloc(VALUE klass)
+{
+
+    CursorSet_t *ptr;
+    ptr = (CursorSet_t *) ruby_xmalloc(sizeof(CursorSet_t));
+    ptr->data = NULL;
+    ptr->parent = Qnil;
+
+    return Data_Wrap_Struct(klass, NULL, c_CursorSet_struct_free, (void *) ptr);
+}
+
+/**
+* call-seq:
+*   Clangc::CursorSet#new => Clangc::CursorSet
+*
+* Creates an empty Clangc::CursorSet instance which is
+* a fast container representing a set of Clangc::Cursor.
+*/
+VALUE
+c_CursorSet_initialize(VALUE self)
+{
+    CursorSet_t *c;
+    Data_Get_Struct(self, CursorSet_t, c);
+    c->data = clang_createCXCursorSet();
+    return self;
+}
+
+/**
+* call-seq:
+*   Clangc::CursorSet#contains(Clangc::Cursor) => true / false
+*
+* Queries a CXCursorSet to see if it contains a specific CXCursor.
+*
+* Returns true if the set contains the specified cursor.
+*/
+VALUE
+c_CursorSet_contains(VALUE self, VALUE cursor)
+{
+    CursorSet_t *cs;
+    Cursor_t *c;
+
+    Data_Get_Struct(self, CursorSet_t, cs);
+    CHECK_ARG_TYPE(cursor, Cursor);
+    Data_Get_Struct(cursor, Cursor_t, c);
+
+    return NOT_0_2_RVAL(clang_CXCursorSet_contains(cs->data, c->data));
+}
+
+/**
+* call-seq:
+*   Clangc::CursorSet(Clangc::Cursor) => true/false
+*
+* Inserts a CXCursor into a CXCursorSet.
+*
+* Returns false if the CXCursor was already in the set, and true otherwise.
+*/
+VALUE
+c_CursorSet_insert(VALUE self, VALUE cursor)
+{
+    CursorSet_t *cs;
+    Cursor_t *c;
+
+    Data_Get_Struct(self, CursorSet_t, cs);
+    CHECK_ARG_TYPE(cursor, Cursor);
+    Data_Get_Struct(cursor, Cursor_t, c);
+
+    return NOT_0_2_RVAL(clang_CXCursorSet_insert(cs->data, c->data));
+}

data/ext/clangc/class_CursorSet.h

@@ -0,0 +1,39 @@
+/*
+ * ruby-clangc ruby bindings for the C interface of Clang
+ * Copyright (C) 2015-2016 Cedric Le Moigne cedlemo <cedlemo@gmx.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+#ifndef CURSORSET_H
+#define CURSORSET_H
+#include <ruby/ruby.h>
+#include "clang-c/Index.h"
+typedef struct CursorSet_t
+{
+    CXCursorSet data;
+    VALUE parent;
+} CursorSet_t;
+
+VALUE
+c_CursorSet_struct_alloc(VALUE);
+
+VALUE
+c_CursorSet_initialize(VALUE);
+
+VALUE
+c_CursorSet_contains(VALUE, VALUE);
+
+VALUE
+c_CursorSet_insert(VALUE, VALUE);
+#endif // CURSORSET_H

data/ext/clangc/class_Diagnostic.c

@@ -0,0 +1,322 @@
+/*
+ * ruby-clangc ruby bindings for the C interface of Clang
+ * Copyright (C) 2015-2016 Cedric Le Moigne cedlemo <cedlemo@gmx.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/*Diagnostic ruby class*/
+#include "class_Diagnostic.h"
+#include "macros.h"
+#include "class_SourceRange.h"
+#include "class_SourceLocation.h"
+
+static void c_Diagnostic_struct_free(Diagnostic_t *s)
+{
+    if (s)
+    {
+
+        if (s->data) clang_disposeDiagnostic(s->data);
+
+        ruby_xfree(s);
+    }
+}
+static void c_Diagnostic_mark(void *s)
+{
+    if (s)
+    {
+        Diagnostic_t *d = (Diagnostic_t *) s;
+        rb_gc_mark(d->parent);
+    }
+}
+VALUE
+c_Diagnostic_struct_alloc(VALUE klass)
+{
+
+    Diagnostic_t *ptr;
+    ptr = (Diagnostic_t *) ruby_xmalloc(sizeof(Diagnostic_t));
+    ptr->data = NULL;
+    ptr->parent = Qnil;
+    return Data_Wrap_Struct(
+        klass, c_Diagnostic_mark, c_Diagnostic_struct_free, (void *) ptr);
+}
+
+/**
+* call-seq:
+*   Clangc::Diagnostic#severity => Fixnum
+*
+* Determine the severity of the given diagnostic. It returns one of the
+* constants defined
+* in Clangc::DiagnosticSeverity.constants
+*/
+VALUE
+c_Diagnostic_get_severity(VALUE self)
+{
+    Diagnostic_t *d;
+    Data_Get_Struct(self, Diagnostic_t, d);
+    unsigned int severity = clang_getDiagnosticSeverity(d->data);
+    return CUINT_2_NUM(severity);
+}
+
+/**
+* call-seq:
+*   Clangc::Diagnostic#spelling => String
+*
+* Retrieve the text of the given diagnostic.
+*/
+VALUE
+c_Diagnostic_get_spelling(VALUE self)
+{
+    Diagnostic_t *d;
+    Data_Get_Struct(self, Diagnostic_t, d);
+    return CXSTR_2_RVAL(clang_getDiagnosticSpelling(d->data));
+}
+
+/**
+* call-seq:
+*   Clangc::Diagnostic#category => Fixnum
+*
+* 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.
+*
+* The number of the category that contains this diagnostic, or zero
+* if this diagnostic is uncategorized.
+*/
+VALUE
+c_Diagnostic_get_category(VALUE self)
+{
+    Diagnostic_t *d;
+    Data_Get_Struct(self, Diagnostic_t, d);
+    unsigned int category = clang_getDiagnosticCategory(d->data);
+    return CUINT_2_NUM(category);
+}
+
+/**
+* call-seq:
+*   Clangc::Diagnostic#category_name => String
+*
+* Retrieve the name of a particular diagnostic category.  This
+* is now deprecated.  Use Clangc::Diagnostic#category_text
+* instead.
+*/
+VALUE
+c_Diagnostic_get_category_name(VALUE self)
+{
+    // TODO deprecated write if macro based on clang vervion
+    Diagnostic_t *d;
+    Data_Get_Struct(self, Diagnostic_t, d);
+    return CXSTR_2_RVAL(
+        clang_getDiagnosticCategoryName(clang_getDiagnosticCategory(d->data)));
+}
+
+/**
+* call-seq:
+*   Clangc::Diagnostic#category_text => String
+*
+* Retrieve the diagnostic category text for a given diagnostic.
+* Returns The text of the given diagnostic category.
+*/
+VALUE
+c_Diagnostic_get_category_text(VALUE self)
+{
+    Diagnostic_t *d;
+    Data_Get_Struct(self, Diagnostic_t, d);
+    return CXSTR_2_RVAL(clang_getDiagnosticCategoryText(d->data));
+}
+
+/**
+* call-seq:
+*   Clangc::Diagnostic#num_ranges => Fixnum
+*
+* Determine the number of source ranges associated with the given
+* diagnostic.
+*/
+VALUE
+c_Diagnostic_get_num_ranges(VALUE self)
+{
+    Diagnostic_t *d;
+    Data_Get_Struct(self, Diagnostic_t, d);
+    unsigned int num = clang_getDiagnosticNumRanges(d->data);
+    return CUINT_2_NUM(num);
+}
+
+/**
+* call-seq:
+*   Clangc::Diagnostic#num_fixits => Fixnum
+*
+* Determine the number of fix-it hints associated with the given
+* diagnostic.
+*/
+VALUE
+c_Diagnostic_get_num_fixits(VALUE self)
+{
+    Diagnostic_t *d;
+    Data_Get_Struct(self, Diagnostic_t, d);
+    unsigned int num = clang_getDiagnosticNumFixIts(d->data);
+    return CUINT_2_NUM(num);
+}
+
+/**
+* call-seq:
+*   Clangc::Diagnostic#format(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
+* Clangc.default_diagnostic_display_options function returns the set of
+* options that most closely mimics the behavior of the clang compiler.
+*
+* options A set of options that control the diagnostic display,
+* created by combining Clangc::DiagnosticDisplayOptions constants.
+*
+* It returns a new string containing for formatted diagnostic.
+*/
+VALUE
+c_Diagnostic_format(VALUE self, VALUE options)
+{
+    Diagnostic_t *d;
+    Data_Get_Struct(self, Diagnostic_t, d);
+    unsigned int c_options = CLANGC_CONSTANT_TO_UINT("DiagnosticDisplayOptions",
+                                                     options);
+    return CXSTR_2_RVAL(clang_formatDiagnostic(d->data, c_options));
+}
+
+/**
+* call-seq:
+*   Clangc::Diagnostic#option => Array
+*
+* Retrieve the name of the command-line option that enabled this
+* diagnostic such as ("-Wconversion" or "-pedantic") and the option
+* that disables it if any.
+* returned_array[0] == String command-line option that enabled the diagnostic
+* returned_array[1] == String or nil command-line option that disable the
+* diagnostic
+*/
+
+VALUE
+c_Diagnostic_get_option(VALUE self)
+{
+    Diagnostic_t *d;
+    Data_Get_Struct(self, Diagnostic_t, d);
+
+    CXString str1;
+    CXString str2;
+    str1 = clang_getDiagnosticOption(d->data, &str2);
+    VALUE ret = rb_ary_new();
+    rb_ary_push(ret, CXSTR_2_RVAL(str1));
+    rb_ary_push(ret, CXSTR_2_RVAL(str2));
+
+    return ret;
+}
+
+/**
+* Retrieve a source range associated with the diagnostic.
+* call-seq:
+*   Clangc::Diagnostic#source_range(index) => Clangc::SourceRange
+*
+* 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.
+*
+* \param Diagnostic the diagnostic whose range is being extracted.
+*
+* \param Range the zero-based index specifying which range to
+*
+* \returns the requested source range.
+*/
+VALUE
+c_Diagnostic_get_source_range(VALUE self, VALUE index)
+{
+    Diagnostic_t *d;
+    Data_Get_Struct(self, Diagnostic_t, d);
+    unsigned int c_index = NUM2UINT(index);
+    VALUE a_source_range;
+    SourceRange_t *s;
+    R_GET_CLASS_DATA("Clangc", SourceRange, a_source_range, s);
+    s->data = clang_getDiagnosticRange(d->data, c_index);
+    s->parent = self;
+    return a_source_range;
+}
+
+/**
+* call-seq:
+*   Clangc::Diagnostic#source_location => Clangc::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.
+*/
+
+VALUE
+c_Diagnostic_get_source_location(VALUE self)
+{
+    Diagnostic_t *d;
+    Data_Get_Struct(self, Diagnostic_t, d);
+    VALUE a_source_location;
+    SourceLocation_t *sl;
+    R_GET_CLASS_DATA("Clangc", SourceLocation, a_source_location, sl);
+    sl->data = clang_getDiagnosticLocation(d->data);
+    sl->parent = self;
+    return a_source_location;
+}
+
+/**
+ * call-seq:
+ *  Clangc::Diagnostic#fix_it(fix_number) => Array [Str, Clangc::SourceRange]
+ *
+ * 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).
+ *
+ * fix_number The zero-based index of the fix-it.
+ *
+ * Returns an Array with in the following order:
+ *
+ * A string containing text that should be replace the source
+ * code indicated by the \c ReplacementRange.
+ *
+ * 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.
+ */
+VALUE
+c_Diagnostic_get_fixit(VALUE self, VALUE index)
+{
+    Diagnostic_t *d;
+    Data_Get_Struct(self, Diagnostic_t, d);
+    unsigned int c_index = NUM2UINT(index);
+    VALUE source_range;
+    SourceRange_t *s;
+    CXString fixit_str;
+    VALUE ret = rb_ary_new();
+    R_GET_CLASS_DATA("Clangc", SourceRange, source_range, s);
+    s->parent = self;
+    fixit_str = clang_getDiagnosticFixIt(d->data, c_index, &(s->data));
+    rb_ary_push(ret, CXSTR_2_RVAL(fixit_str));
+    rb_ary_push(ret, source_range);
+    return ret;
+}