clangc 1.0.0.pre

data/ext/clangc/constants.h

@@ -0,0 +1,21 @@
+
+/*
+ * ruby-clangc ruby bindings for the C interface of Clang
+ * Copyright (C) 2015  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/>.
+*/
+#include <ruby/ruby.h>
+void init_clang_enums_to_constants(VALUE);
+void init_clang_errors_enums_to_constants(VALUE);

data/ext/clangc/extconf.rb

@@ -0,0 +1,34 @@
+require "mkmf"
+
+$CFLAGS += " -I#{`llvm-config --prefix`.chomp}/include"
+#$CFLAGS += " -std=c89 -pedantic -Wall"
+#$CFLAGS += " -Wno-missing-braces -Wextra -Wno-missing-field-initializers -Wformat=2"
+#$CFLAGS += " -Wswitch-default -Wswitch-enum -Wcast-align -Wpointer-arith"
+#$CFLAGS += " -Wbad-function-cast -Wstrict-overflow=5 -Wstrict-prototypes -Winline"
+#$CFLAGS += " -Wundef -Wnested-externs -Wcast-qual -Wshadow -Wunreachable-code"
+#$CFLAGS += " -Wlogical-op -Wfloat-equal -Wstrict-aliasing=2 -Wredundant-decls"
+#$CFLAGS += " -Wold-style-definition -Werror"
+#$CFLAGS += " -ggdb3"
+#$CFLAGS += " -O0"
+#$CFLAGS += " -fno-omit-frame-pointer -ffloat-store -fno-common -fstrict-aliasing"
+#$CFLAGS += " -lm"
+#$LIBS += " #{`llvm-config --libs`.chomp}"
+# When the libclang.so is in a custom directory:
+# llvm-config --libdir => /usr/lib64/llvm in Fedora
+# llvm-config --libdir => /usr/lib in Archlinux so not needed 
+$LDFLAGS << " -L#{`llvm-config --libdir`.chomp}"
+# override normal build configuration to build debug friendly library
+# if installed via 'gem install clangc -- --enable-debug'
+if enable_config('debug')
+  puts '[INFO] enabling debug library build configuration.'
+  if RUBY_VERSION < '1.9'
+    $CFLAGS = CONFIG['CFLAGS'].gsub(/\s\-O\d?\s/, ' -O0 ')
+    $CFLAGS.gsub!(/\s?\-g\w*\s/, ' -ggdb3 ')
+    CONFIG['LDSHARED'] = CONFIG['LDSHARED'].gsub(/\s\-s(\s|\z)/, ' ')
+  else
+    CONFIG['debugflags'] << ' -ggdb3 -O0 -std=c89 -pedantic -Wall'
+  end
+end
+have_library("clang", "clang_createIndex")
+
+create_makefile("clangc/clangc")

data/ext/clangc/macros.h

@@ -0,0 +1,230 @@
+/*
+ * 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 MACROS_H
+#define MACROS_H
+/*****************/
+/*Debugging tools*/
+/*****************/
+#include <stdio.h>
+#include <errno.h>
+#include <string.h>
+#include <ruby/ruby.h>
+#include "clang-c/Index.h"
+
+#define clean_errno() (errno == 0 ? "None" : strerror(errno))
+#define SENTINEL(M, ...)                                                       \
+    printf("[SENTINEL] (%s:%s:%d: errno: %s) " M "\n",                         \
+           __FILE__,                                                           \
+           __FUNCTION__,                                                       \
+           __LINE__,                                                           \
+           clean_errno(),                                                      \
+           ##__VA_ARGS__)
+#define LOG_ERR(M, ...)                                                        \
+    fprintf(stderr,                                                            \
+            "[ERROR] (%s:%s:%d: errno: %s) " M "\n",                           \
+            __FILE__,                                                          \
+            __FUNCTION__,                                                      \
+            __LINE__,                                                          \
+            clean_errno(),                                                     \
+            ##__VA_ARGS__)
+#define LOG_WARN(M, ...)                                                       \
+    fprintf(stderr,                                                            \
+            "[WARN]  (%s:%s:%d: errno: %s) " M "\n",                           \
+            __FILE__,                                                          \
+            __FUNCTION__,                                                      \
+            __LINE__,                                                          \
+            clean_errno(),                                                     \
+            ##__VA_ARGS__)
+#define LOG_INFO(M, ...)                                                       \
+    fprintf(stderr,                                                            \
+            "[INFO]  (%s:%s:%d) " M "\n",                                      \
+            __FILE__,                                                          \
+            __FUNCTION__,                                                      \
+            __LINE__,                                                          \
+            ##__VA_ARGS__)
+#define check(A, M, ...)                                                       \
+    if (!(A))                                                                  \
+    {                                                                          \
+        log_err(M, ##__VA_ARGS__);                                             \
+        errno = 0;                                                             \
+    }
+#define check_mem(A) check((A), "Out of memory.")
+#define check_debug(A, M, ...)                                                 \
+    if (!(A))                                                                  \
+    {                                                                          \
+        debug(M, ##__VA_ARGS__);                                               \
+        errno = 0;                                                             \
+        goto error;                                                            \
+    }
+/*****************/
+/*Common C macros*/
+/*****************/
+#define CARRAY_LEN(A) (sizeof(A) / sizeof((A)[0]));
+#define CHECK_IN_RANGE(A, MIN, MAX)                                            \
+    if (A < MIN) A = MIN;                                                      \
+    if (A > MAX) A = MAX;
+
+/***************************/
+/*Ruby arguments to C value*/
+/***************************/
+// ruby array of string to C array
+#define RARRAY_OF_STRINGS_2_C(args)                                            \
+    Check_Type(args, T_ARRAY);                                                 \
+    int len = RARRAY_LEN(args);                                                \
+    const char *c_args[len];                                                   \
+    if (len > 0)                                                               \
+    {                                                                          \
+        int j = 0;                                                             \
+        for (j = 0; j < len; j++)                                              \
+        {                                                                      \
+            VALUE arg = rb_ary_entry(args, j);                                 \
+            c_args[j] = StringValueCStr(arg);                                  \
+        }                                                                      \
+    }
+// ruby boolean value to C int
+static inline int rbool_2_int(VALUE rval)
+{
+    return (int) ((rval == Qtrue) ? 1 : 0);
+}
+#define RBOOL_2_INT(a) rbool_2_int(a)
+
+// Ruby string to C char
+static inline char *rstring_2_char(VALUE rval)
+{
+    return StringValueCStr(rval);
+}
+#define RSTRING_2_CHAR(rval) rstring_2_char(rval)
+
+static int symbol_2_const(char *module_name, char *enum_name, VALUE sym)
+{
+  VALUE main_module, enum_module, constant_name;
+  main_module = rb_const_get(rb_cObject, rb_intern(module_name));
+  enum_module = rb_const_get(main_module, rb_intern(enum_name));
+  constant_name = rb_funcall(sym, rb_intern("to_s"), 0, NULL);
+  constant_name = rb_funcall(constant_name, rb_intern("upcase"), 0, NULL);
+  VALUE num =  rb_const_get(enum_module, rb_intern_str(constant_name));
+  
+  return NUM2UINT(num);
+}
+
+static int bitmask_or_array(char *module_name, char *enum_name, VALUE array)
+{
+  int or_sum = 0;
+  int i = 0;
+  int len = RARRAY_LEN(array);
+  
+  for(i = 0; i < len; i++)
+  {
+    VALUE sym = rb_ary_entry(array, i);
+    or_sum = or_sum | symbol_2_const(module_name, enum_name, sym);
+  }
+  return or_sum;
+}
+
+static unsigned int rb_constant_argument_to_uint(char *module_name, char *enum_name, VALUE argument)
+{
+  if(TYPE(argument) == T_SYMBOL)
+    return symbol_2_const(module_name, enum_name, argument);
+  else if(TYPE(argument) == T_ARRAY)
+    return bitmask_or_array(module_name, enum_name, argument);
+  else
+    return NUM2UINT(argument);
+}
+#define CLANGC_CONSTANT_TO_UINT(enum_name, argument) \
+  rb_constant_argument_to_uint("Clangc", enum_name, argument)
+
+/****************/
+/*Classes Macros*/
+/****************/
+// Check argument
+static inline void check_arg_type(VALUE arg, char *class_name)
+{
+    VALUE mModule;
+    VALUE cKlass;
+    char *message;
+    int len;
+
+    Check_Type(arg, T_DATA);
+    mModule = rb_const_get(rb_cObject, rb_intern("Clangc"));
+    cKlass = rb_const_get(mModule, rb_intern(class_name));
+    
+    len = asprintf(&message, "Clangc::%s Object was expected", class_name);
+    
+    if (cKlass != rb_funcall(arg, rb_intern("class"), 0))
+    {
+        if (len != -1)
+        {
+            rb_raise(rb_eTypeError, "%s", message);
+            free(message);
+        }
+        else
+            rb_raise(rb_eTypeError, "Not the object type expected");
+    }
+}
+
+#define CHECK_ARG_TYPE(arg, classname) check_arg_type(arg, #classname)
+
+// Create a new instance without args and get its data
+#define R_GET_CLASS_DATA(module_name, class_name, instance, data_ptr)          \
+    VALUE mModule = rb_const_get(rb_cObject, rb_intern(module_name));          \
+    VALUE cKlass = rb_const_get(mModule, rb_intern(#class_name));              \
+    instance = rb_class_new_instance(0, NULL, cKlass);                         \
+    Data_Get_Struct(instance, class_name##_t, data_ptr);
+
+// Create a new instance with args and get its data
+#define R_GET_CLASS_WITH_ARGS_DATA(                                            \
+    module_name, class_name, instance, args, data_type, data_ptr)              \
+    VALUE mModule = rb_const_get(rb_cObject, rb_intern(module_name));          \
+    VALUE cKlass = rb_const_get(mModule, rb_intern(class_name));               \
+    int args_n = CARRAY_LEN(args) instance =                                   \
+        rb_class_new_instance(args_len, args, cKlass);                         \
+    Data_Get_Struct(instance, data_type, data_ptr);
+
+/* For later.
+#define NEW_CLASS_INSTANCE(class_name)\
+static inline VALUE new_##class_name##_inst(class_name##_t *data)\
+{\
+  VALUE instance;\
+  R_GET_CLASS_DATA("clangc", class_name, instance, data);\
+  return instance;\
+}
+NEW_CLASS_INSTANCE(TranslationUnit)
+#undef NEW_CLASS_INSTANCE*/
+
+/************************/
+/*C values to Ruby value*/
+/************************/
+static inline VALUE cxstring_2_rval(CXString str)
+{
+    VALUE r_string;
+    const char *c_string =
+        (clang_getCString(str) != NULL) ? clang_getCString(str) : "";
+    r_string = rb_str_new2(c_string);
+    clang_disposeString(str);
+    return r_string;
+}
+#define CUINT_2_NUM(c_val) UINT2NUM(c_val)
+#define CINT_2_NUM(c_val) INT2NUM(c_val)
+#define CLLONG_2_NUM(c_val) LL2NUM(c_val)
+#define CULLONG_2_NUM(c_val) ULL2NUM(c_val)
+#define NOT_0_2_RVAL(c_val) ((c_val == 0) ? Qfalse : Qtrue)
+#define EQ_1_2_RVAL(c_val) ((c_val == 1) ? Qtrue : Qfalse)
+#define CXSTR_2_RVAL(str) (cxstring_2_rval(str))
+
+#endif // MACROS_H

data/lib/clangc.rb

@@ -0,0 +1,397 @@
+require "clangc/clangc"
+
+module Clangc
+  ##
+  # :call-seq:
+  # Clangc.visit_children(Hash)
+  #
+  # This is a convenient method that call Clangc.visit_children_with_proc or
+  # Clangc.visit_children_with_block.
+  # the Hash arguments can accept two keys:
+  # * cursor
+  # * visitor
+  #
+  #    Clangc.visit_children(cursor: acursor, visitor: aproc)
+  #
+  #    Clangc.visit_children(cursor: acursor) do |cursor, parent|
+  #      #do your stuf
+  #      return Clangc::ChildVisitResult::Recurse
+  #      #return Clangc::ChildVisitResult::Break
+  #    end
+  def self.visit_children(args)
+    cursor = args[:cursor]
+    callback = args[:visitor] || nil
+    if(callback)
+      visit_children_with_proc(cursor, callback)
+    else
+      visit_children_with_block(cursor) do |cursor, parent|
+        yield(cursor, parent)
+      end
+    end
+  end
+  class TranslationUnit
+    ##
+    # :call-seq:
+    #   Clangc::TranslationUnit#diagnostics => Array
+    #
+    # Returns an array of Clangc::Diagnostic for the current Clangc::TranslationUnit.
+    # The array is empty if no Clangc::Diagnostic can be found.
+    def diagnostics
+      ds = []
+      for i in 0..(diagnostics_num - 1) do
+        ds << diagnostic(i)
+      end
+      ds
+    end
+  end
+  class Diagnostic
+    ##
+    # :call-seq:
+    #   Clangc::Diagnostic#source_ranges => Array
+    #
+    # Returns an array of Clangc::SourceRange for the current Clangc::Diagnostic.
+    # The array is empty if there is no Clangc::SourceRange
+    def source_ranges
+      num = num_ranges
+      sr = []
+      return sr if num == 0
+
+      for i in 0..(num - 1) do
+        sr << source_range(i)
+      end
+      sr
+    end
+  end
+  class Type
+    ##
+    # :call-seq:
+    # Clangc::Type#arg_types -> Array
+    #
+    # Return an array that contains all the
+    # types for the argument of the function that
+    # is related to the current type.
+    # If the current type is not a function, it returns
+    # an empty array.
+    def arg_types
+      num = num_arg_types
+      return [] if num == -1
+
+      types = []
+      for i in 0..(num - 1) do
+        types << arg_type(i)
+      end
+      types
+    end
+      ##
+    # :call-seq:
+    # Clangc::Type#template_arguments_as_type -> Array
+    #
+    # Return an array that contains all the
+    # types for the arguments of the current Class Type template that
+    # is related to the current cursor.
+    # If the Cursor is not a Class Declaration, it returns
+    # an empty array.
+    def template_arguments_as_type
+      num = num_template_arguments
+      types = []
+      return types if num == -1
+
+      for i in 0..(num - 1) do
+        types << template_argument_as_type(i)
+      end
+      types
+    end
+  end
+  class Cursor
+    ##
+    # :call-seq:
+    # Clangc::Cursor#arguments -> Array
+    #
+    # Return an array that contains all the
+    # cursors for the arguments of the function that
+    # is related to the current cursor.
+    # If the current cursor is not a function, it returns
+    # an empty array.
+    def arguments
+      num = num_arguments
+      cursors = []
+      return cursors if num == -1
+
+      for i in 0..(num - 1) do
+        cursors << argument(i)
+      end
+      cursors
+    end
+    ##
+    # :call-seq:
+    # Clangc::Cursor#overloaded_decls -> Array
+    #
+    # Return an array that contains all the
+    # cursors for the overloaded declarations that
+    # are related to the current cursor.
+    # If the current cursor is not an overloaded declaration, it returns
+    # an empty array.
+    def overloaded_decls
+      num = num_overloaded_decls
+      cursors = []
+      return cursors if num == 0
+
+      for i in 0..(num - 1) do
+        cursors << overloaded_decl(i)
+      end
+      cursors
+    end
+    ##
+    # :call-seq:
+    # Clangc::Cursor#template_arguments_kinds -> Array
+    #
+    # Return an array that contains all the
+    # kinds for the arguments of the function template that
+    # is related to the current cursor.
+    # If the current cursor is not a function declaration, it returns
+    # an empty array.
+    def template_arguments_kinds
+      num = num_template_arguments
+      kinds = []
+      return kinds if num == -1
+
+      for i in 0..(num - 1) do
+        kinds << template_argument_kind(i)
+      end
+      kinds
+    end
+    ##
+    # :call-seq:
+    # Clangc::Cursor#template_arguments_types -> Array
+    #
+    # Return an array that contains all the
+    # types for the arguments of the function template that
+    # is related to the current cursor.
+    # If the current cursor is not a function declaration, it returns
+    # an empty array.
+    def template_arguments_types
+      num = num_template_arguments
+      types = []
+      return types if num == -1
+
+      for i in 0..(num - 1) do
+        types << template_argument_type(i)
+      end
+      types
+    end
+    ##
+    # :call-seq:
+    # Clangc::Cursor#template_arguments_values -> Array
+    #
+    # Return an array that contains all the
+    # values for the arguments of the function template that
+    # is related to the current cursor.
+    # If the current cursor is not a function declaration, it returns
+    # an empty array.
+    def template_arguments_values
+      num = num_template_arguments
+      values = []
+      return values if num == -1
+
+      for i in 0..(num - 1) do
+        values << template_argument_value(i)
+      end
+      values
+    end
+    ##
+    # :call-seq:
+    # Clangc::Cursor#template_arguments_unsigned_values -> Array
+    #
+    # Return an array that contains all the
+    # values for the arguments of the function template that
+    # is related to the current cursor.
+    # If the current cursor is not a function declaration, it returns
+    # an empty array.
+    def template_arguments_unsigned_values
+      num = num_template_arguments
+      values = []
+      return values if num == -1
+
+      for i in 0..(num - 1) do
+        values << template_argument_unsigned_value(i)
+      end
+      values
+    end
+  end
+  class Module
+    ##
+    # :call-seq:
+    # Clangc::Module#top_level_headers(Clangc::TranslationUnit) -> Array
+    #
+    # Return an array that contains all the
+    # Clangc::File corresponding to the related
+    # toplevel headers.
+    # If the current cursor is not a module, it returns
+    # an empty array.
+    def top_level_headers(tu)
+      num = num_top_level_headers(tu)
+      headers = []
+      return headers if num < 1
+
+      for i in 0..(num - 1) do
+        headers << top_level_header(tu, i)
+      end
+      headers
+    end
+  end
+  class CompletionString
+    ##
+    # :call-seq:
+    # Clangc::CompletionString#chunk_kinds -> Array
+    #
+    # Return an array that contains all the
+    # kinds of the chunk completions for a
+    # completion string.
+    def chunk_kinds
+      num = num_chunks
+      return [] if num == -1
+
+      kinds = []
+      for i in 0..(num - 1) do
+        kinds << chunk_kind(i)
+      end
+      kinds
+    end
+    ##
+    # :call-seq:
+    # Clangc::CompletionString#chunk_texts -> Array
+    #
+    # Return an array that contains all the
+    # texts of the chunk completions for a
+    # completion string.
+    def chunk_texts
+      num = num_chunks
+      return [] if num == -1
+
+      texts = []
+      for i in 0..(num - 1) do
+        texts << chunk_text(i)
+      end
+      texts
+    end
+    ##
+    # :call-seq:
+    #   Clangc::CompletionString#num_annotations -> Array
+    #
+    # Return an array that contains all the
+    # annotations for a completion string.
+    def annotations
+      num = num_annotations
+      return [] if num == -1
+
+      annotations = []
+      for i in 0..(num - 1) do
+        annotations << annotation(i)
+      end
+      annotations
+    end
+    ##
+    # :call-seq:
+    # Clangc::CompletionString#chunk_text_completion_strings -> Array
+    #
+    # Return an array that contains all the
+    # completion strings for a
+    # completion string.
+    def chunk_completion_strings
+      num = num_chunks
+      return [] if num == -1
+
+      completion_strings = []
+      for i in 0..(num - 1) do
+        completion_strings << chunk_completion_string(i)
+      end
+      completion_strings
+    end
+  end
+  class CodeCompleteResults
+    ##
+    # :call-seq:
+    #   Clangc::CodeCompleteResults#results => Array
+    #
+    # Returns an Array of Clangc::CompletionResult
+    def results
+      num = num_results
+      return [] if num < 0
+
+      res = []
+      for i in 0..(num - 1) do
+        res << result(i)
+      end
+      res
+    end
+    ##
+    # :call-seq:
+    #   Clangc::CodeCompleteResults#diagnostics => Array
+    #
+    # Returns an Array of Clangc::Diagnostics
+    def diagnostics
+      num = num_diagnostics
+      return [] if num < 0
+
+      diags = []
+      for i in 0..(num - 1) do
+        diags << diagnostic(i)
+      end
+      diags
+    end
+  end
+
+  class Index
+    ##
+    # :call-seq:
+    #   Clangc::Index#translation_unit(options) => Clangc::TranslationUnit
+    #
+    # Convenient method that easily allow to create a translation unit
+    # through different ways based on the options you use:
+    # :source => source file
+    # :args   => command line arguments
+    # :error  => true or false or nil
+    # :ast => String an ast file
+    alias_method :create_translation_unit_raw, :create_translation_unit
+
+    def create_translation_unit(options)
+      source =  options[:source] || ""
+      args =    options[:args] || []
+      error =   options[:error] || nil
+      ast =     options[:ast] || nil
+      if ast
+        error ? create_translation_unit2(ast) : create_translation_unit_raw(ast)
+      else
+        create_translation_unit_from_source_file(source, args)
+      end
+    end
+
+    ##
+    # :call-seq:
+    #   Clangc::Index#parse_translation_unit(options) => Clangc::TranslationUnit
+    #
+    # Convenient method that easily allow to parse a file to a translation
+    # unit through different ways based on the options you use:
+    # :source => source file
+    # :args   => command line arguments
+    # :error  => true or false or nil
+    # :flags  => bitwise OR of the TranslationUnit_Flags constants
+    # :argv  => true or false in order to use argv form
+    alias_method :parse_translation_unit_raw, :parse_translation_unit
+
+    def parse_translation_unit(options)
+      source =  options[:source] || ""
+      args =    options[:args] || []
+      error =   options[:error] || nil
+      flags =   options[:flags] || Clangc::TranslationUnit_Flags::NONE
+      argv =    options[:argv] || false
+      if error && argv
+        parse_translation_unit2_full_argv(source, args, flags)
+      elsif error
+        parse_translation_unit2(source, args, flags)
+      else
+        parse_translation_unit_raw(source, args, flags)
+      end
+    end
+  end
+end