← Back to branch summary

~ubuntu-branches/debian/stretch/gnome-builder/stretch

« back to all changes in this revision

Viewing changes to libide/c/ide-c-language.c

  • Committer: Package Import Robot
  • Author(s): Andreas Henriksson
  • Date: 2015-10-11 12:38:45 UTC
  • Revision ID: package-import@ubuntu.com-20151011123845-a0hvkz01se0p1p5a
Tags: upstream-3.16.3
Import upstream version 3.16.3

Show diffs side-by-side

added added

removed removed

Lines of Context:
libide/c/ide-c-language.c
 
1
/* ide-c-language.c
 
2
 *
 
3
 * Copyright (C) 2015 Christian Hergert <christian@hergert.me>
 
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 <glib/gi18n.h>
 
20
 
 
21
#include "ide-c-format-provider.h"
 
22
#include "ide-c-indenter.h"
 
23
#include "ide-c-language.h"
 
24
#include "ide-clang-completion-provider.h"
 
25
#include "ide-clang-diagnostic-provider.h"
 
26
#include "ide-clang-highlighter.h"
 
27
#include "ide-clang-symbol-resolver.h"
 
28
#include "ide-diagnostician.h"
 
29
#include "ide-internal.h"
 
30
 
 
31
typedef struct
 
32
{
 
33
  IdeDiagnostician  *diagnostician;
 
34
  IdeHighlighter    *highlighter;
 
35
  IdeIndenter       *indenter;
 
36
  IdeRefactory      *refactory;
 
37
  IdeSymbolResolver *symbol_resolver;
 
38
} IdeCLanguagePrivate;
 
39
 
 
40
static void _g_initable_iface_init (GInitableIface *iface);
 
41
 
 
42
G_DEFINE_TYPE_EXTENDED (IdeCLanguage, ide_c_language, IDE_TYPE_LANGUAGE, 0,
 
43
                        G_ADD_PRIVATE (IdeCLanguage)
 
44
                        G_IMPLEMENT_INTERFACE (G_TYPE_INITABLE,
 
45
                                               _g_initable_iface_init))
 
46
 
 
47
static GList *
 
48
ide_c_language_get_completion_providers (IdeLanguage *language)
 
49
{
 
50
  GList *providers = NULL;
 
51
 
 
52
  g_return_val_if_fail (IDE_IS_C_LANGUAGE (language), NULL);
 
53
 
 
54
  providers = IDE_LANGUAGE_CLASS (ide_c_language_parent_class)->get_completion_providers (language);
 
55
  providers = g_list_append (providers, g_object_new (IDE_TYPE_C_FORMAT_PROVIDER, NULL));
 
56
  providers = g_list_append (providers, g_object_new (IDE_TYPE_CLANG_COMPLETION_PROVIDER, NULL));
 
57
 
 
58
  return providers;
 
59
}
 
60
 
 
61
static IdeDiagnostician *
 
62
ide_c_language_get_diagnostician (IdeLanguage *language)
 
63
{
 
64
  IdeCLanguage *self = (IdeCLanguage *)language;
 
65
  IdeCLanguagePrivate *priv = ide_c_language_get_instance_private (self);
 
66
 
 
67
  g_return_val_if_fail (IDE_IS_C_LANGUAGE (self), NULL);
 
68
 
 
69
  return priv->diagnostician;
 
70
}
 
71
 
 
72
static IdeHighlighter *
 
73
ide_c_language_get_highlighter (IdeLanguage *language)
 
74
{
 
75
  IdeCLanguage *self = (IdeCLanguage *)language;
 
76
  IdeCLanguagePrivate *priv = ide_c_language_get_instance_private (self);
 
77
 
 
78
  g_return_val_if_fail (IDE_IS_C_LANGUAGE (self), NULL);
 
79
 
 
80
  return priv->highlighter;
 
81
}
 
82
 
 
83
static IdeIndenter *
 
84
ide_c_language_get_indenter (IdeLanguage *language)
 
85
{
 
86
  IdeCLanguage *self = (IdeCLanguage *)language;
 
87
  IdeCLanguagePrivate *priv = ide_c_language_get_instance_private (self);
 
88
 
 
89
  g_return_val_if_fail (IDE_IS_C_LANGUAGE (self), NULL);
 
90
 
 
91
  return priv->indenter;
 
92
}
 
93
 
 
94
static IdeRefactory *
 
95
ide_c_language_get_refactory (IdeLanguage *language)
 
96
{
 
97
  IdeCLanguage *self = (IdeCLanguage *)language;
 
98
  IdeCLanguagePrivate *priv = ide_c_language_get_instance_private (self);
 
99
 
 
100
  g_return_val_if_fail (IDE_IS_C_LANGUAGE (self), NULL);
 
101
 
 
102
  return priv->refactory;
 
103
}
 
104
 
 
105
static IdeSymbolResolver *
 
106
ide_c_language_get_symbol_resolver (IdeLanguage *language)
 
107
{
 
108
  IdeCLanguage *self = (IdeCLanguage *)language;
 
109
  IdeCLanguagePrivate *priv = ide_c_language_get_instance_private (self);
 
110
 
 
111
  g_return_val_if_fail (IDE_IS_C_LANGUAGE (self), NULL);
 
112
 
 
113
  return priv->symbol_resolver;
 
114
}
 
115
 
 
116
static const gchar *
 
117
ide_c_language_get_name (IdeLanguage *self)
 
118
{
 
119
  return _("C");
 
120
}
 
121
 
 
122
static void
 
123
ide_c_language_dispose (GObject *object)
 
124
{
 
125
  IdeCLanguage *self = (IdeCLanguage *)object;
 
126
  IdeCLanguagePrivate *priv = ide_c_language_get_instance_private (self);
 
127
 
 
128
  g_clear_object (&priv->diagnostician);
 
129
  g_clear_object (&priv->highlighter);
 
130
  g_clear_object (&priv->indenter);
 
131
  g_clear_object (&priv->refactory);
 
132
  g_clear_object (&priv->symbol_resolver);
 
133
 
 
134
  G_OBJECT_CLASS (ide_c_language_parent_class)->dispose (object);
 
135
}
 
136
 
 
137
static void
 
138
ide_c_language_class_init (IdeCLanguageClass *klass)
 
139
{
 
140
  IdeLanguageClass *language_class = IDE_LANGUAGE_CLASS (klass);
 
141
  GObjectClass *object_class = G_OBJECT_CLASS (klass);
 
142
 
 
143
  language_class->get_completion_providers = ide_c_language_get_completion_providers;
 
144
  language_class->get_diagnostician = ide_c_language_get_diagnostician;
 
145
  language_class->get_highlighter = ide_c_language_get_highlighter;
 
146
  language_class->get_indenter = ide_c_language_get_indenter;
 
147
  language_class->get_refactory = ide_c_language_get_refactory;
 
148
  language_class->get_symbol_resolver = ide_c_language_get_symbol_resolver;
 
149
  language_class->get_name = ide_c_language_get_name;
 
150
 
 
151
  object_class->dispose = ide_c_language_dispose;
 
152
}
 
153
 
 
154
static void
 
155
ide_c_language_init (IdeCLanguage *self)
 
156
{
 
157
}
 
158
 
 
159
static gboolean
 
160
ide_c_language_initiable_init (GInitable     *initable,
 
161
                               GCancellable  *cancellable,
 
162
                               GError       **error)
 
163
{
 
164
  IdeCLanguage *self = (IdeCLanguage *)initable;
 
165
  IdeCLanguagePrivate *priv = ide_c_language_get_instance_private (self);
 
166
  const gchar *id;
 
167
 
 
168
  g_return_val_if_fail (IDE_IS_C_LANGUAGE (self), FALSE);
 
169
  g_return_val_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable), FALSE);
 
170
 
 
171
  id = ide_language_get_id (IDE_LANGUAGE (self));
 
172
 
 
173
  if ((g_strcmp0 (id, "c") == 0) ||
 
174
      (g_strcmp0 (id, "chdr") == 0) ||
 
175
      (g_strcmp0 (id, "cpp") == 0))
 
176
    {
 
177
      IdeContext *context;
 
178
      IdeDiagnosticProvider *provider;
 
179
 
 
180
      context = ide_object_get_context (IDE_OBJECT (initable));
 
181
 
 
182
      /*
 
183
       * Create our diagnostician using clang as a backend.
 
184
       */
 
185
      priv->diagnostician = g_object_new (IDE_TYPE_DIAGNOSTICIAN,
 
186
                                          "context", context,
 
187
                                          NULL);
 
188
      provider = g_object_new (IDE_TYPE_CLANG_DIAGNOSTIC_PROVIDER,
 
189
                               "context", context,
 
190
                               NULL);
 
191
      _ide_diagnostician_add_provider (priv->diagnostician, provider);
 
192
      g_clear_object (&provider);
 
193
 
 
194
      /*
 
195
       * Create our highlighter that will use clang for semantic highlighting.
 
196
       */
 
197
      priv->highlighter = g_object_new (IDE_TYPE_CLANG_HIGHLIGHTER,
 
198
                                        "context", context,
 
199
                                        NULL);
 
200
 
 
201
      /*
 
202
       * Create our indenter to provide as-you-type indentation.
 
203
       *
 
204
       * TODO: How can we disambiguate c/c++/obj-c headers?
 
205
       */
 
206
      if (!ide_str_equal0 (id, "cpp"))
 
207
        priv->indenter = g_object_new (IDE_TYPE_C_INDENTER,
 
208
                                       "context", context,
 
209
                                       NULL);
 
210
 
 
211
      /*
 
212
       * TODO: Refactory design (rename local, extract method, etc).
 
213
       */
 
214
 
 
215
      /*
 
216
       * Create our symbol resolver to help discover symbols within a file
 
217
       * as well as what symbol is at "location X".
 
218
       */
 
219
      priv->symbol_resolver = g_object_new (IDE_TYPE_CLANG_SYMBOL_RESOLVER,
 
220
                                            "context", context,
 
221
                                            NULL);
 
222
 
 
223
      return TRUE;
 
224
    }
 
225
 
 
226
  g_set_error (error,
 
227
               G_IO_ERROR,
 
228
               G_IO_ERROR_NOT_SUPPORTED,
 
229
               _("Language id does not match a C language."));
 
230
 
 
231
  return FALSE;
 
232
}
 
233
 
 
234
static void
 
235
_g_initable_iface_init (GInitableIface *iface)
 
236
{
 
237
  iface->init = ide_c_language_initiable_init;
 
238
}