clangc 1.0.0.pre

data/ext/clangc/class_Diagnostic.h

@@ -0,0 +1,66 @@
+/*
+ * 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 DIAGNOSTIC_H
+#define DIAGNOSTIC_H
+#include <ruby/ruby.h>
+#include "clang-c/Index.h"
+typedef struct Diagnostic_t
+{
+    CXDiagnostic data;
+    VALUE parent;
+} Diagnostic_t;
+
+VALUE
+c_Diagnostic_struct_alloc(VALUE);
+
+VALUE
+c_Diagnostic_get_severity(VALUE);
+
+VALUE
+c_Diagnostic_get_spelling(VALUE);
+
+VALUE
+c_Diagnostic_get_category(VALUE);
+
+VALUE
+c_Diagnostic_get_category_name(VALUE);
+
+VALUE
+c_Diagnostic_get_category_text(VALUE);
+
+VALUE
+c_Diagnostic_get_num_ranges(VALUE);
+
+VALUE
+c_Diagnostic_get_num_fixits(VALUE);
+
+VALUE
+c_Diagnostic_format(VALUE, VALUE);
+
+VALUE
+c_Diagnostic_get_option(VALUE);
+
+VALUE
+c_Diagnostic_get_source_range(VALUE, VALUE);
+
+VALUE
+c_Diagnostic_get_source_location(VALUE);
+
+VALUE
+c_Diagnostic_get_fixit(VALUE, VALUE);
+#endif // DIAGNOSTIC_H

data/ext/clangc/class_File.c

@@ -0,0 +1,145 @@
+/*
+ * 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/>.
+*/
+/*File ruby class*/
+#include "class_File.h"
+#include "macros.h"
+#include "class_TranslationUnit.h"
+
+static void c_File_struct_free(File_t *s)
+{
+    if (s)
+    {
+
+        ruby_xfree(s);
+    }
+}
+
+static void c_File_mark(void *s)
+{
+    if (s)
+    {
+        File_t *t = (File_t *) s;
+        rb_gc_mark(t->parent);
+    }
+}
+
+VALUE
+c_File_struct_alloc(VALUE klass)
+{
+
+    File_t *ptr;
+    ptr = (File_t *) ruby_xmalloc(sizeof(File_t));
+    ptr->data = NULL;
+    ptr->parent = Qnil;
+    return Data_Wrap_Struct(
+        klass, c_File_mark, c_File_struct_free, (void *) ptr);
+}
+
+VALUE
+generate_File_under(VALUE module, VALUE superclass)
+{
+    VALUE klass = rb_define_class_under(module, "File", superclass);
+    rb_define_alloc_func(klass, c_File_struct_alloc);
+    return klass;
+}
+
+/**
+ * call-seq:
+ *  Clangc::File#name => String
+ *
+ * Retrieve the complete file and path name of the given file.
+ * Returns Qnil if the CXFile pointer is NULL (this can happen)
+ */
+VALUE
+c_File_get_name(VALUE self)
+{
+    File_t *f;
+    VALUE name = Qnil;
+    Data_Get_Struct(self, File_t, f);
+    if (f->data != NULL)
+    {
+        name = CXSTR_2_RVAL(clang_getFileName(f->data));
+    }
+    else
+        name = Qnil;
+    return name;
+}
+
+/**
+ * call-seq:
+ *  Clangc::File#mtime => Time
+ *
+ * Retrieve the last modification time of the given file.
+ */
+
+VALUE
+c_File_get_mtime(VALUE self)
+{
+    File_t *f;
+    VALUE mtime = Qnil;
+    Data_Get_Struct(self, File_t, f);
+    mtime = rb_time_new(clang_getFileTime(f->data), 0);
+    return mtime;
+}
+
+/**
+* call-seq:
+*   Clangc::File#is_multiple_include_guarded => true or false
+*
+* Determine whether the given header is guarded against
+* multiple inclusions, either with the conventional
+* \#ifndef/\#define/\#endif macro guards or with \#pragma once.
+*/
+
+VALUE
+c_File_is_multiple_include_guarded(VALUE self)
+{
+    File_t *f;
+    Data_Get_Struct(self, File_t, f);
+    TranslationUnit_t *t;
+    Data_Get_Struct(f->parent, TranslationUnit_t, t);
+    unsigned int ret = clang_isFileMultipleIncludeGuarded(t->data, f->data);
+    return NOT_0_2_RVAL(ret);
+}
+
+#if (CINDEX_VERSION_MINOR >= 29)
+/**
+* call-seq:
+*   clangc::File#is_equal(file) => true or false
+*
+* Returns true if the file1 and file2 point to the same file,
+* or both null.
+* Two ruby objects Clangc::File can be different but can hold the
+* same File_t data.
+*/
+
+VALUE
+c_File_is_equal(VALUE self, VALUE file)
+{
+    File_t *f1;
+    File_t *f2;
+    Data_Get_Struct(self, File_t, f1);
+    CHECK_ARG_TYPE(file, File);
+    Data_Get_Struct(file, File_t, f2);
+    return NOT_0_2_RVAL(clang_File_isEqual(f1->data, f2->data));
+}
+#endif
+
+/*
+ * skipped :
+ * clang_getFileUniqueID*/

data/ext/clangc/class_File.h

@@ -0,0 +1,45 @@
+/*
+ * 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 FILE_H
+#define FILE_H
+#include <ruby/ruby.h>
+#include "clang-c/Index.h"
+typedef struct File_t
+{
+    CXFile data;
+    VALUE parent; // A translation unit ( a CXFile is a file related to a
+                  // translation unit)
+} File_t;
+
+VALUE
+c_File_struct_alloc(VALUE);
+
+VALUE
+c_File_get_name(VALUE);
+
+VALUE
+c_File_get_mtime(VALUE);
+
+VALUE
+c_File_is_multiple_include_guarded(VALUE);
+
+#if (CINDEX_VERSION_MINOR >= 29)
+VALUE
+c_File_is_equal(VALUE, VALUE);
+#endif
+#endif // FILE_H

data/ext/clangc/class_Index.c

@@ -0,0 +1,461 @@
+/*
+ * 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/>.
+*/
+/*Index ruby class*/
+#include "class_Index.h"
+#include "class_TranslationUnit.h"
+#include "stdio.h"
+#include "macros.h"
+
+static void c_Index_struct_free(Index_t *s)
+{
+    if (s)
+    {
+        if (s->data) clang_disposeIndex(s->data);
+
+        ruby_xfree(s);
+    }
+}
+
+VALUE
+c_Index_struct_alloc(VALUE klass)
+{
+    Index_t *i;
+    i = (Index_t *) ruby_xmalloc(sizeof(Index_t));
+    i->data = NULL;
+    return Data_Wrap_Struct(klass, NULL, c_Index_struct_free, (void *) i);
+}
+
+/*
+* call-seq:
+*   Clangc::Index.new(exclude_decl_from_pch, display_diagnostics) =>
+* Clangc::Index
+*
+* Provides a shared context for creating translation units.
+*
+* It provides two options:
+*
+* - excludeDeclarationsFromPCH:
+* When true, 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 false, all declarations
+* will be enumerated.
+* The 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).
+*
+* - displayDiagnostics:
+* When true, default diagnostics are displayed, when false, it is up to the user
+* to display them.
+*/
+VALUE
+c_Index_initialize(VALUE self,
+                   VALUE excl_decls_from_PCH,
+                   VALUE display_diagnostics)
+{
+    Index_t *i;
+    int c_excl_decls_from_PCH;
+    int c_display_diagnostics;
+
+    c_excl_decls_from_PCH = RBOOL_2_INT(excl_decls_from_PCH);
+    c_display_diagnostics = RBOOL_2_INT(display_diagnostics);
+    Data_Get_Struct(self, Index_t, i);
+
+    i->data = clang_createIndex(c_excl_decls_from_PCH, c_display_diagnostics);
+    return self;
+}
+
+/*
+* call-seq:
+*   Clangc::Index#global_options=(options) => nil
+*
+* Sets general options associated with an Index instance.
+* - options:
+* A bitmask of options, a bitwise OR of the Clangc::GlobalOptFlags constants.
+*/
+VALUE
+c_Index_set_global_options(VALUE self, VALUE options)
+{
+    Index_t *i;
+    unsigned int c_options;
+
+    Data_Get_Struct(self, Index_t, i);
+    c_options = CLANGC_CONSTANT_TO_UINT("GlobalOptFlags", options);
+    clang_CXIndex_setGlobalOptions(i->data, c_options);
+    return Qnil;
+}
+
+/*
+* call-seq:
+*   Clangc::Index#global_options() => num
+*
+* Gets the general options associated with an Index.
+* A bitmask of options, a bitwise OR of the Clangc::GlobalOptFlags constants.
+*/
+VALUE
+c_Index_get_global_options(VALUE self)
+{
+    Index_t *i;
+    Data_Get_Struct(self, Index_t, i);
+    return CUINT_2_NUM(clang_CXIndex_getGlobalOptions(i->data));
+}
+/*
+* call-seq:
+*   Clangc::Index#create_translation_unit_from_source_file(source, args) =>
+* Clangc::TranslationUnit
+*
+* Return a TranslationUnit instance for a given source file and the provided
+* command line arguments one would pass to the compiler.
+*
+* - source:
+* The source filename argument must be a string but is optional.  If the caller
+* provides a nil value, the name of the source file is expected to reside in the
+* specified command line arguments.
+* - args:
+* Must be an array of strings or empty.
+* The command-line arguments that would be passed to the 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>'.
+*
+* TODO : (not implemented yet)
+* - num_unsaved_files
+* the number of unsaved file entries in unsaved_files.
+*
+* - unsaved_files
+* 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.
+*/
+
+VALUE
+c_Index_create_TU_from_source_file(VALUE self, VALUE source_file, VALUE args)
+{
+    char *c_source_file = NULL;
+    Index_t *i;
+    VALUE tu;
+    TranslationUnit_t *c_tu;
+
+    c_source_file = RSTRING_2_CHAR(source_file);
+    RARRAY_OF_STRINGS_2_C(args);
+    Data_Get_Struct(self, Index_t, i);
+    R_GET_CLASS_DATA("Clangc", TranslationUnit, tu, c_tu);
+
+    c_tu->data = clang_createTranslationUnitFromSourceFile(
+        i->data, c_source_file, len, c_args, 0, 0); // TODO manage unsaved files
+    c_tu->parent = self;
+
+    if (c_tu->data != NULL)
+        return tu;
+    else
+        return Qnil;
+}
+/*
+* call-seq:
+*   Clangc::Index#create_translation_unit(ast_file) => Clangc::TranslationUnit
+*
+* Create a translation unit from an AST file name. If the creation fail, it
+* returns
+* nil.
+* The AST file is created by clang with the option -emit-ast
+*/
+VALUE
+c_Index_create_TU(VALUE self, VALUE ast_file)
+{
+    Index_t *i;
+    Data_Get_Struct(self, Index_t, i);
+    VALUE tu;
+    TranslationUnit_t *c_tu;
+    R_GET_CLASS_DATA("Clangc", TranslationUnit, tu, c_tu);
+    char *c_ast_file = NULL;
+    c_ast_file = RSTRING_2_CHAR(ast_file);
+    c_tu->data = clang_createTranslationUnit(i->data, c_ast_file);
+
+    c_tu->parent = self;
+
+    if (c_tu->data)
+        return tu;
+    else
+        return Qnil;
+}
+/*
+* call-seq:
+*   Clangc::Index#create_translation_unit2(ast_file) => Clangc::TranslationUnit
+* or an error code
+*
+* Create a translation unit from an AST file name. If the creation fail, it
+* returns
+* an error code Clangc::ErrorCode. With this implementation,
+* Clangc::ErrorCode::Success is not
+* used.
+* The AST file is created by clang with the option -emit-ast
+*/
+VALUE
+c_Index_create_TU2(VALUE self, VALUE ast_file)
+{
+    Index_t *i;
+    Data_Get_Struct(self, Index_t, i);
+    VALUE tu;
+    TranslationUnit_t *c_tu;
+    R_GET_CLASS_DATA("Clangc", TranslationUnit, tu, c_tu);
+    char *c_ast_file = NULL;
+    c_ast_file = RSTRING_2_CHAR(ast_file);
+    unsigned int er =
+        clang_createTranslationUnit2(i->data, c_ast_file, &(c_tu->data));
+
+    c_tu->parent = self;
+
+    if (er != 0)
+        return CUINT_2_NUM(er);
+    else
+        return tu;
+}
+/*
+* call-seq:
+*   Clangc::Index#parse_translation_unit(source_file, args, options) =>
+* Clangc::TranslationUnit
+*
+* Parse the given source file and generate 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.
+*
+* - source_file:
+* The name of the source file to load, or nil if the source file is included in
+* the command line arguments.
+*
+* - args:
+* The command-line arguments that would be passed to the 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>'.
+*
+* - options:
+* A bitmask of options that affects how the translation unit is managed but not
+* its compilation. This should be a bitwise OR of the TranslationUnit_Flags
+* constants.
+*
+* TODO:
+* - unsaved_files:
+* 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:
+* The number of unsaved file entries in unsaved_files.
+*/
+VALUE
+c_Index_parse_TU(VALUE self, VALUE source_file, VALUE args, VALUE options)
+{
+    char *c_source_file = NULL;
+    c_source_file = RSTRING_2_CHAR(source_file);
+
+    unsigned int c_options = CLANGC_CONSTANT_TO_UINT("TranslationUnit_Flags",
+                                                     options);
+
+    RARRAY_OF_STRINGS_2_C(args);
+    Index_t *i;
+    Data_Get_Struct(self, Index_t, i);
+    VALUE tu;
+    TranslationUnit_t *c_tu;
+    R_GET_CLASS_DATA("Clangc", TranslationUnit, tu, c_tu);
+
+    c_tu->data =
+        clang_parseTranslationUnit(i->data,
+                                   c_source_file,
+                                   c_args,
+                                   len,
+                                   0,
+                                   0,
+                                   c_options); // TODO manage unsaved files
+
+    c_tu->parent = self;
+
+    if (c_tu->data)
+        return tu;
+    else
+        return Qnil;
+}
+/*
+* call-seq:
+*   Clangc::Index#parse_translation_unit2(source_file, args, options) =>
+* Clangc::TranslationUnit
+*
+* Parse the given source file and generate the translation unit corresponding
+* to that file. If its fails, it returns an Integer corresponding to the
+* error code a Clangc::ErrorCode constant.
+*
+* 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.
+*
+* - source_file:
+* The name of the source file to load, or nil if the source file is included in
+* the command line arguments.
+*
+* - args:
+* The command-line arguments that would be passed to the 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>'.
+*
+* - options:
+* A bitmask of options that affects how the translation unit is managed but not
+* its compilation. This should be a bitwise OR of the TranslationUnit_Flags
+* constants.
+*
+* TODO:
+* - unsaved_files:
+* 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:
+* The number of unsaved file entries in unsaved_files.
+*/
+VALUE
+c_Index_parse_TU2(VALUE self, VALUE source_file, VALUE args, VALUE options)
+{
+    char *c_source_file = NULL;
+    c_source_file = RSTRING_2_CHAR(source_file);
+
+    unsigned int c_options = CLANGC_CONSTANT_TO_UINT("TranslationUnit_Flags",
+                                                     options);
+
+    RARRAY_OF_STRINGS_2_C(args);
+    Index_t *i;
+    Data_Get_Struct(self, Index_t, i);
+    VALUE tu;
+    TranslationUnit_t *c_tu;
+    R_GET_CLASS_DATA("Clangc", TranslationUnit, tu, c_tu);
+
+    unsigned int er =
+        clang_parseTranslationUnit2(i->data,
+                                    c_source_file,
+                                    c_args,
+                                    len,
+                                    0,
+                                    0,
+                                    c_options, // TODO manage unsaved files
+                                    &(c_tu->data));
+
+    c_tu->parent = self;
+
+    if (er != 0)
+        return CUINT_2_NUM(er);
+    else
+        return tu;
+}
+
+#if (CINDEX_VERSION_MINOR >= 32)
+/*
+* call-seq:
+*   Clangc::Index#parse_translation_unit2_full_argv(source_file, args, options) =>
+* Clangc::TranslationUnit
+*
+* Parse the given source file and generate the translation unit corresponding
+* to that file. If its fails, it returns an Integer corresponding to the
+* error code a Clangc::ErrorCode constant.
+*
+* 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.
+*
+* - source_file:
+* The name of the source file to load, or nil if the source file is included in
+* the command line arguments.
+*
+* - args:
+* The command-line arguments that would be passed to the 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>'.
+*
+* - options:
+* A bitmask of options that affects how the translation unit is managed but not
+* its compilation. This should be a bitwise OR of the TranslationUnit_Flags
+* constants.
+*
+* TODO:
+* - unsaved_files:
+* 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:
+* The number of unsaved file entries in unsaved_files.
+* Same as clang_parseTranslationUnit2 but requires a full command line
+* for \c command_line_args including argv[0]. This is useful if the standard
+* library paths are relative to the binary.
+*/
+VALUE
+c_Index_parse_TU2_full_argv(VALUE self, VALUE source_file, VALUE args, VALUE options)
+{
+    char *c_source_file = NULL;
+    c_source_file = RSTRING_2_CHAR(source_file);
+
+    unsigned int c_options = CLANGC_CONSTANT_TO_UINT("TranslationUnit_Flags",
+                                                     options);
+
+    RARRAY_OF_STRINGS_2_C(args);
+    Index_t *i;
+    Data_Get_Struct(self, Index_t, i);
+    VALUE tu;
+    TranslationUnit_t *c_tu;
+    R_GET_CLASS_DATA("Clangc", TranslationUnit, tu, c_tu);
+
+    unsigned int er =
+        clang_parseTranslationUnit2FullArgv(i->data,
+                                            c_source_file,
+                                            c_args,
+                                            len,
+                                            0,
+                                            0,
+                                            c_options, // TODO manage unsaved files
+                                            &(c_tu->data));
+
+    c_tu->parent = self;
+
+    if (er != 0)
+        return CUINT_2_NUM(er);
+    else
+        return tu;
+}
+#endif