clangc 1.0.0.pre

data/ext/clangc/class_CodeCompleteResults.c

@@ -0,0 +1,186 @@
+/*
+ * ruby-clangc ruby bindings for the C interface of Clang
+ * Copyright (C) 2016 Cedric Le Moigne <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/>.
+*/
+/*CodeCompleteResults ruby class*/
+#include "class_CodeCompleteResults.h"
+#include "class_CompletionResult.h"
+#include "class_Diagnostic.h"
+#include "macros.h"
+
+static void c_CodeCompleteResults_struct_free(CodeCompleteResults_t *s)
+{
+    if (s)
+    {
+        if (s->data) clang_disposeCodeCompleteResults(s->data);
+        ruby_xfree(s);
+    }
+}
+
+static void c_CodeCompleteResults_mark(void *s)
+{
+    if (s)
+    {
+        CodeCompleteResults_t *t = (CodeCompleteResults_t *) s;
+        rb_gc_mark(t->parent);
+    }
+}
+
+VALUE
+c_CodeCompleteResults_struct_alloc(VALUE klass)
+{
+
+    CodeCompleteResults_t *ptr;
+    ptr = (CodeCompleteResults_t *) ruby_xmalloc(sizeof(CodeCompleteResults_t));
+    ptr->data = NULL;
+    ptr->parent = Qnil;
+
+    return Data_Wrap_Struct(
+        klass, NULL, c_CodeCompleteResults_struct_free, (void *) ptr);
+}
+
+/**
+ * call-seq:
+ *  Clangc::CodeCompleteResults#num_results => Number
+ *
+ * Retrieve the number of Clangc::CompletionResult
+ *
+ * Not based on libclang function
+ */
+VALUE
+c_CodeCompleteResults_get_num_results(VALUE self)
+{
+    CodeCompleteResults_t *c;
+    Data_Get_Struct(self, CodeCompleteResults_t, c);
+
+    return CUINT_2_NUM(c->data->NumResults);
+}
+
+/**
+ * call-seq:
+ *  Clangc::CodeCompleteResults#results(index) => Clangc::CompletionResult
+ *
+ * Retrieve Clangc::CompletionResult instance a index
+ *
+ * Return nil if  index < 0 or index >= num results
+ * Not based on libclang function
+ */
+VALUE
+c_CodeCompleteResults_get_result(VALUE self, VALUE index)
+{
+    CodeCompleteResults_t *c;
+    Data_Get_Struct(self, CodeCompleteResults_t, c);
+    unsigned i = NUM2UINT(index);
+
+    if (i < 0 || i > c->data->NumResults) return Qnil;
+
+    VALUE result;
+    CompletionResult_t *cr;
+    R_GET_CLASS_DATA("Clangc", CompletionResult, result, cr);
+    cr->data = &(c->data->Results[i]);
+    cr->parent = self;
+
+    return result;
+}
+
+/**
+ * call-seq:
+ *  Clangc::CodeCompleteResults#container_usr => String
+ *
+ * Returns the USR for the container for the current code completion
+ * context. If there is not a container for the current context, this
+ * function will return the empty string.
+ */
+VALUE
+c_CodeCompleteResults_get_container_usr(VALUE self)
+{
+    CodeCompleteResults_t *c;
+    Data_Get_Struct(self, CodeCompleteResults_t, c);
+
+    return CXSTR_2_RVAL(clang_codeCompleteGetContainerUSR(c->data));
+}
+/**
+ * call-seq:
+ *  Clangc::CodeCompleteResults#num_diagnostics => Number
+ *
+ * Determine the number of diagnostics produced prior to the
+ * location where code completion was performed.
+ */
+VALUE
+c_CodeCompleteResults_get_num_diagnostics(VALUE self)
+{
+    CodeCompleteResults_t *c;
+    Data_Get_Struct(self, CodeCompleteResults_t, c);
+
+    return CUINT_2_NUM(clang_codeCompleteGetNumDiagnostics(c->data));
+}
+
+/**
+ * call-seq:
+ *  Clangc::CodeCompleteResults#diagnostic(index) => Clangc::Diagnostic
+ *
+ * Retrieve a diagnostic associated with the given code completion.
+ */
+VALUE
+c_CodeCompleteResults_get_diagnostic(VALUE self, VALUE index)
+{
+    CodeCompleteResults_t *c;
+    Data_Get_Struct(self, CodeCompleteResults_t, c);
+
+    VALUE diagnostic;
+    Diagnostic_t *d;
+    R_GET_CLASS_DATA("Clangc", Diagnostic, diagnostic, d);
+
+    d->data = clang_codeCompleteGetDiagnostic(c->data, NUM2UINT(index));
+    d->parent = c->parent;
+
+    return diagnostic;
+}
+
+/**
+ * call-seq:
+ *  Clangc::CodeCompleteResults#sort_results => nil
+ *
+ * Sort the code-completion results in case-insensitive alphabetical
+ * order.
+ */
+VALUE
+c_CodeCompleteResults_sort_results(VALUE self)
+{
+    CodeCompleteResults_t *c;
+    Data_Get_Struct(self, CodeCompleteResults_t, c);
+
+    clang_sortCodeCompletionResults(c->data->Results, c->data->NumResults);
+    return Qnil;
+}
+
+/**
+ * call-seq:
+ *  Clangc::CodeCompleteResults#contexts => Number
+ *
+ * Determines what completions are appropriate for the context
+ * the given code completion.
+ * 
+ * the kinds of completions that are appropriate for use
+ * along with the given code completion results.
+ */
+VALUE
+c_CodeCompleteResults_get_contexts(VALUE self)
+{
+    CodeCompleteResults_t *c;
+    Data_Get_Struct(self, CodeCompleteResults_t, c);
+    CULLONG_2_NUM(clang_codeCompleteGetContexts(c->data));
+}

data/ext/clangc/class_CodeCompleteResults.h

@@ -0,0 +1,51 @@
+/*
+ * ruby-clangc ruby bindings for the C interface of Clang
+ * Copyright (C) 2016  Cedric Le Moigne <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 CODECOMPLETERESULTS_H
+#define CODECOMPLETERESULTS_H
+#include <ruby/ruby.h>
+#include "clang-c/Index.h"
+typedef struct CodeCompleteResults_t
+{
+    CXCodeCompleteResults *data;
+    VALUE parent;
+} CodeCompleteResults_t;
+
+VALUE
+c_CodeCompleteResults_struct_alloc(VALUE);
+
+VALUE
+c_CodeCompleteResults_get_num_results(VALUE);
+
+VALUE
+c_CodeCompleteResults_get_result(VALUE, VALUE);
+
+VALUE
+c_CodeCompleteResults_get_container_usr(VALUE);
+
+VALUE
+c_CodeCompleteResults_get_num_diagnostics(VALUE);
+
+VALUE
+c_CodeCompleteResults_get_diagnostic(VALUE, VALUE);
+
+VALUE
+c_CodeCompleteResults_sort_results(VALUE);
+
+VALUE
+c_CodeCompleteResults_get_contexts(VALUE);
+#endif // CODECOMPLETERESULTS_H

data/ext/clangc/class_CompletionResult.c

@@ -0,0 +1,98 @@
+/*
+ * ruby-clangc ruby bindings for the C interface of Clang
+ * Copyright (C) 2016 Cedric Le Moigne <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/>.
+*/
+/*CompletionResult ruby class*/
+#include "class_CompletionResult.h"
+#include "class_CompletionString.h"
+#include "macros.h"
+
+static void c_CompletionResult_struct_free(CompletionResult_t *s)
+{
+    if (s)
+    {
+
+        ruby_xfree(s);
+    }
+}
+
+static void c_CompletionResult_mark(void *s)
+{
+    if (s)
+    {
+        CompletionResult_t *t = (CompletionResult_t *) s;
+        rb_gc_mark(t->parent);
+    }
+}
+
+VALUE
+c_CompletionResult_struct_alloc(VALUE klass)
+{
+
+    CompletionResult_t *ptr;
+    ptr = (CompletionResult_t *) ruby_xmalloc(sizeof(CompletionResult_t));
+    ptr->data = NULL;
+    ptr->parent = Qnil;
+
+    return Data_Wrap_Struct(
+        klass, NULL, c_CompletionResult_struct_free, (void *) ptr);
+}
+
+/*
+ * call-seq:
+ *  Clangc::CompletionResult#cursor_kind => Clangc::CursorKind
+ *
+ * \brief The kind of entity that this completion refers to.
+ *
+ * The cursor kind will be a macro, keyword, or a declaration (one of the
+ * *Decl cursor kinds), describing the entity that the completion is
+ * referring to.
+ *
+ * In the future, we would like to provide a full cursor, to allow
+ * the client to extract additional information from declaration.
+ *  Get
+ * */
+VALUE
+c_CompletionResult_get_cursor_kind(VALUE self)
+{
+    CompletionResult_t *c;
+    Data_Get_Struct(self, CompletionResult_t, c);
+
+    return CUINT_2_NUM(c->data->CursorKind);
+}
+
+/*
+ * call-seq:
+ *  Clangc::CompletionResult#completion_string => Clangc::CompetionString
+ *
+ * The code-completion string that describes how to insert this
+ * code-completion result into the editing buffer.
+ * */
+VALUE
+c_CompletionResult_get_completion_string(VALUE self)
+{
+    CompletionResult_t *c;
+    Data_Get_Struct(self, CompletionResult_t, c);
+
+    CompletionString_t *cs;
+    VALUE completion_string;
+    R_GET_CLASS_DATA("Clangc", CompletionString, completion_string, cs);
+
+    cs->data = c->data->CompletionString;
+    cs->parent = self;
+
+    return completion_string;
+}

data/ext/clangc/class_CompletionResult.h

@@ -0,0 +1,36 @@
+/*
+ * ruby-clangc ruby bindings for the C interface of Clang
+ * Copyright (C) 2016 Cedric Le Moigne <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 COMPLETIONRESULT_H
+#define COMPLETIONRESULT_H
+#include <ruby/ruby.h>
+#include "clang-c/Index.h"
+typedef struct CompletionResult_t
+{
+    CXCompletionResult *data;
+    VALUE parent;
+} CompletionResult_t;
+
+VALUE
+c_CompletionResult_struct_alloc(VALUE);
+
+VALUE
+c_CompletionResult_get_cursor_kind(VALUE);
+
+VALUE
+c_CompletionResult_get_completion_string(VALUE);
+#endif // COMPLETIONRESULT_H

data/ext/clangc/class_CompletionString.c

@@ -0,0 +1,231 @@
+/*
+ * 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/>.
+*/
+/*CompletionString ruby class*/
+#include "class_CompletionString.h"
+#include "macros.h"
+
+static void c_CompletionString_struct_free(CompletionString_t *s)
+{
+    if (s)
+    {
+        ruby_xfree(s);
+    }
+}
+
+static void c_CompletionString_mark(void *s)
+{
+    if (s)
+    {
+        CompletionString_t *t = (CompletionString_t *) s;
+        rb_gc_mark(t->parent);
+    }
+}
+
+VALUE
+c_CompletionString_struct_alloc(VALUE klass)
+{
+
+    CompletionString_t *ptr;
+    ptr = (CompletionString_t *) ruby_xmalloc(sizeof(CompletionString_t));
+    ptr->data = NULL;
+    ptr->parent = Qnil;
+
+    return Data_Wrap_Struct(
+        klass, NULL, c_CompletionString_struct_free, (void *) ptr);
+}
+
+/**
+ * Clangc::CompletionString#availability => Clangc::AvailabilityKind
+ *
+ * Determine the availability of the entity that this code-completion
+ * string refers to.
+ *
+ * The availability of the completion string which is one of the
+ * Clangc::AvailabilityKind constants.
+ */
+VALUE
+c_CompletionString_get_availability(VALUE self)
+{
+    CompletionString_t *c;
+    Data_Get_Struct(self, CompletionString_t, c);
+
+    return CUINT_2_NUM(clang_getCompletionAvailability(c->data));
+}
+
+/**
+ * call-seq:
+ *  Clangc::CompletionString#priority => Number
+ *
+ * Determine the priority of this code completion.
+ *
+ * The priority of a code completion indicates how likely it is that this
+ * particular completion is the completion that the user will select. The
+ * priority is selected by various internal heuristics.
+ *
+ * Rreturns The priority of this completion string. Smaller values indicate
+ * higher-priority (more likely) completions.
+ */
+VALUE
+c_CompletionString_get_priority(VALUE self)
+{
+    CompletionString_t *c;
+    Data_Get_Struct(self, CompletionString_t, c);
+
+    return CUINT_2_NUM(clang_getCompletionPriority(c->data));
+}
+
+/**
+ * call-seq:
+ *  Clangc::CompletionString#num_chunks => Number
+ *
+ * Retrieve the number of chunks in the given code-completion string.
+ */
+VALUE
+c_CompletionString_get_num_chunks(VALUE self)
+{
+    CompletionString_t *c;
+    Data_Get_Struct(self, CompletionString_t, c);
+
+    return CUINT_2_NUM(clang_getNumCompletionChunks(c->data));
+}
+
+/**
+ * call-seq:
+ *  Clangc::CompletionString#chunk_kind(Number) => Clangc::CompletionChunkKind
+ *
+ * Determine the kind of a particular chunk within a completion string.
+ *
+ * chunk_number the 0-based index of the chunk in the completion string.
+ *
+ * It returns the kind of the chunk at the index chunk_number (a
+ * Clangc::CompletionChunkKind constant).
+ */
+VALUE
+c_CompletionString_get_chunk_kind(VALUE self, VALUE index)
+{
+    CompletionString_t *c;
+    Data_Get_Struct(self, CompletionString_t, c);
+
+    return CUINT_2_NUM(clang_getCompletionChunkKind(c->data, NUM2UINT(index)));
+}
+
+/**
+ * call-seq
+ *  Clangc::CompletionString#chunk_text(Number) => String
+ *
+ * Retrieve the text associated with a particular chunk within a
+ * completion string.
+ *
+ * chunk_number the 0-based index of the chunk in the completion string.
+ *
+ * Returns the text associated with the chunk at index chunk_number.
+ */
+VALUE
+c_CompletionString_get_chunk_text(VALUE self, VALUE index)
+{
+    CompletionString_t *c;
+    Data_Get_Struct(self, CompletionString_t, c);
+
+    return CXSTR_2_RVAL(clang_getCompletionChunkText(c->data, NUM2UINT(index)));
+}
+
+/**
+ * call-seq:
+ *  Clangc::CompletionString#num_annotations => Number
+ *
+ * Retrieve the number of annotations associated with the given
+ * completion string.
+ *
+ * Returns the number of annotations associated with the given completion
+ * string.
+ */
+VALUE
+c_CompletionString_get_num_annotations(VALUE self)
+{
+    CompletionString_t *c;
+    Data_Get_Struct(self, CompletionString_t, c);
+
+    return CUINT_2_NUM(clang_getCompletionNumAnnotations(c->data));
+}
+
+/**
+ * call-seq:
+ *  Clangc::CompletionString#annotation(Number)  => String
+ *
+ * Retrieve the annotation associated with the given completion string.
+ *
+ * annotation_number the 0-based index of the annotation of the
+ * completion string.
+ *
+ * Returns annotation string associated with the completion at index
+ * annotation_number, or a NULL string if that annotation is not available.
+ */
+VALUE
+c_CompletionString_get_annotation(VALUE self, VALUE index)
+{
+    CompletionString_t *c;
+    Data_Get_Struct(self, CompletionString_t, c);
+
+    return CXSTR_2_RVAL(
+        clang_getCompletionAnnotation(c->data, NUM2UINT(index)));
+}
+
+/**
+ * Call-seq:
+ *  Clangc::CompletionString#brief_comment => String
+ *
+ * Retrieve the brief documentation comment attached to the declaration
+ * that corresponds to the given completion string.
+ */
+VALUE
+c_CompletionString_get_brief_comment(VALUE self)
+{
+    CompletionString_t *c;
+    Data_Get_Struct(self, CompletionString_t, c);
+
+    return CXSTR_2_RVAL(clang_getCompletionBriefComment(c->data));
+}
+
+/**
+ * call-seq:
+ *  Clangc::CompletionString#chunk_completion_string(index) =>
+ * Clangc::CompletionString
+ *
+ * Retrieve the completion string associated with a particular chunk
+ * within a completion string.
+ *
+ * 0-based index of the chunk in the completion string.
+ *
+ * Returns the completion string associated with the chunk at index
+ * \c chunk_number.
+ */
+VALUE
+c_CompletionString_get_chunk_completion_string(VALUE self, VALUE index)
+{
+    CompletionString_t *c;
+    Data_Get_Struct(self, CompletionString_t, c);
+
+    VALUE completion_string;
+    CompletionString_t *cs;
+    R_GET_CLASS_DATA("Clangc", CompletionString, completion_string, cs);
+    cs->data =
+        clang_getCompletionChunkCompletionString(c->data, NUM2UINT(index));
+    cs->parent = c->parent;
+
+    return completion_string;
+}