~ubuntu-branches/debian/squeeze/geany-plugins/squeeze

« back to all changes in this revision

Viewing changes to spellcheck/src/speller.c

  • Committer: Bazaar Package Importer
  • Author(s): Chow Loong Jin
  • Date: 2009-07-10 22:56:41 UTC
  • Revision ID: james.westby@ubuntu.com-20090710225641-xc1126t7pq0jmpos
Tags: upstream-0.17.1
ImportĀ upstreamĀ versionĀ 0.17.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
/*
 
2
 *      speller.c - this file is part of Spellcheck, a Geany plugin
 
3
 *
 
4
 *      Copyright 2008-2009 Enrico Trƶger <enrico(dot)troeger(at)uvena(dot)de>
 
5
 *      Copyright 2008-2009 Nick Treleaven <nick(dot)treleaven(at)btinternet(dot)com>
 
6
 *
 
7
 *      This program is free software; you can redistribute it and/or modify
 
8
 *      it under the terms of the GNU General Public License as published by
 
9
 *      the Free Software Foundation; either version 2 of the License, or
 
10
 *      (at your option) any later version.
 
11
 *
 
12
 *      This program is distributed in the hope that it will be useful,
 
13
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 
14
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
15
 *      GNU General Public License for more details.
 
16
 *
 
17
 *      You should have received a copy of the GNU General Public License
 
18
 *      along with this program; if not, write to the Free Software
 
19
 *      Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 
20
 *      MA 02110-1301, USA.
 
21
 *
 
22
 * $Id$
 
23
 */
 
24
 
 
25
 
 
26
#include "geany.h"
 
27
#include "support.h"
 
28
 
 
29
#include <string.h>
 
30
#include <ctype.h>
 
31
#include <enchant.h>
 
32
 
 
33
#include "plugindata.h"
 
34
 
 
35
#include "document.h"
 
36
#include "editor.h"
 
37
#include "msgwindow.h"
 
38
#include "utils.h"
 
39
#include "ui_utils.h"
 
40
#include "scintilla/SciLexer.h"
 
41
 
 
42
#include "geanyfunctions.h"
 
43
 
 
44
#include "speller.h"
 
45
#include "scplugin.h"
 
46
 
 
47
 
 
48
 
 
49
static EnchantBroker *sc_speller_broker = NULL;
 
50
static EnchantDict *sc_speller_dict = NULL;
 
51
 
 
52
 
 
53
 
 
54
static void dict_describe(const gchar* const lang, const gchar* const name,
 
55
                                                  const gchar* const desc, const gchar* const file, void *target)
 
56
{
 
57
        gchar **result = (gchar**) target;
 
58
        *result = g_strdup_printf("\"%s\" (%s)", lang, name);
 
59
}
 
60
 
 
61
 
 
62
static gint sc_speller_check_word(GeanyDocument *doc, gint line_number, const gchar *word,
 
63
                                                   gint start_pos, gint end_pos)
 
64
{
 
65
        gsize n_suggs = 0;
 
66
 
 
67
        g_return_val_if_fail(sc_speller_dict != NULL, 0);
 
68
        g_return_val_if_fail(doc != NULL, 0);
 
69
        g_return_val_if_fail(word != NULL, 0);
 
70
        g_return_val_if_fail(start_pos >= 0 && end_pos >= 0, 0);
 
71
 
 
72
        if (! NZV(word))
 
73
                return 0;
 
74
 
 
75
        /* ignore numbers or words starting with digits */
 
76
        if (isdigit(*word))
 
77
                return 0;
 
78
 
 
79
        /* ignore non-text */
 
80
        if (! sc_speller_is_text(doc, start_pos))
 
81
                return 0;
 
82
 
 
83
        /* early out if the word is spelled correctly */
 
84
        if (enchant_dict_check(sc_speller_dict, word, -1) == 0)
 
85
                return 0;
 
86
 
 
87
        editor_indicator_set_on_range(doc->editor, GEANY_INDICATOR_ERROR, start_pos, end_pos);
 
88
 
 
89
        if (sc_info->use_msgwin && line_number != -1)
 
90
        {
 
91
                gsize j;
 
92
                gchar **suggs;
 
93
                GString *str;
 
94
 
 
95
                str = g_string_sized_new(256);
 
96
                suggs = enchant_dict_suggest(sc_speller_dict, word, -1, &n_suggs);
 
97
                if (suggs != NULL)
 
98
                {
 
99
                        g_string_append_printf(str, "line %d: %s | ",  line_number + 1, word);
 
100
 
 
101
                        g_string_append(str, _("Try: "));
 
102
 
 
103
                        /* Now find the misspellings in the line, limit suggestions to a maximum of 15 (for now) */
 
104
                        for (j = 0; j < MIN(n_suggs, 15); j++)
 
105
                        {
 
106
                                g_string_append(str, suggs[j]);
 
107
                                g_string_append_c(str, ' ');
 
108
                        }
 
109
 
 
110
                        msgwin_msg_add(COLOR_RED, line_number + 1, doc, "%s", str->str);
 
111
 
 
112
                        if (suggs != NULL && n_suggs > 0)
 
113
                                enchant_dict_free_string_list(sc_speller_dict, suggs);
 
114
                }
 
115
                g_string_free(str, TRUE);
 
116
        }
 
117
 
 
118
        return n_suggs;
 
119
}
 
120
 
 
121
 
 
122
gint sc_speller_process_line(GeanyDocument *doc, gint line_number, const gchar *line)
 
123
{
 
124
        gint pos_start, pos_end;
 
125
        gint wstart, wend;
 
126
        GString *str;
 
127
        gint suggestions_found = 0;
 
128
        gchar c;
 
129
 
 
130
        g_return_val_if_fail(sc_speller_dict != NULL, 0);
 
131
        g_return_val_if_fail(doc != NULL, 0);
 
132
        g_return_val_if_fail(line != NULL, 0);
 
133
 
 
134
        str = g_string_sized_new(256);
 
135
 
 
136
        pos_start = sci_get_position_from_line(doc->editor->sci, line_number);
 
137
        pos_end = sci_get_position_from_line(doc->editor->sci, line_number + 1);
 
138
 
 
139
        while (pos_start < pos_end)
 
140
        {
 
141
                wstart = scintilla_send_message(doc->editor->sci, SCI_WORDSTARTPOSITION, pos_start, TRUE);
 
142
                wend = scintilla_send_message(doc->editor->sci, SCI_WORDENDPOSITION, wstart, FALSE);
 
143
                if (wstart == wend)
 
144
                        break;
 
145
                c = sci_get_char_at(doc->editor->sci, wstart);
 
146
                /* hopefully it's enough to check for these both */
 
147
                if (ispunct(c) || isspace(c))
 
148
                {
 
149
                        pos_start++;
 
150
                        continue;
 
151
                }
 
152
 
 
153
                /* ensure the string has enough allocated memory */
 
154
                if (str->len < (guint)(wend - wstart))
 
155
                        g_string_set_size(str, wend - wstart);
 
156
 
 
157
                sci_get_text_range(doc->editor->sci, wstart, wend, str->str);
 
158
 
 
159
                suggestions_found += sc_speller_check_word(doc, line_number, str->str, wstart, wend);
 
160
 
 
161
                pos_start = wend + 1;
 
162
        }
 
163
 
 
164
        g_string_free(str, TRUE);
 
165
        return suggestions_found;
 
166
}
 
167
 
 
168
 
 
169
void sc_speller_check_document(GeanyDocument *doc)
 
170
{
 
171
        gchar *line;
 
172
        gint i;
 
173
        gint first_line, last_line;
 
174
        gchar *dict_string = NULL;
 
175
        gint suggestions_found = 0;
 
176
 
 
177
        g_return_if_fail(sc_speller_dict != NULL);
 
178
        g_return_if_fail(doc != NULL);
 
179
 
 
180
        ui_progress_bar_start(_("Checking"));
 
181
 
 
182
        enchant_dict_describe(sc_speller_dict, dict_describe, &dict_string);
 
183
 
 
184
        if (sci_has_selection(doc->editor->sci))
 
185
        {
 
186
                first_line = sci_get_line_from_position(
 
187
                        doc->editor->sci, sci_get_selection_start(doc->editor->sci));
 
188
                last_line = sci_get_line_from_position(
 
189
                        doc->editor->sci, sci_get_selection_end(doc->editor->sci));
 
190
 
 
191
                if (sc_info->use_msgwin)
 
192
                        msgwin_msg_add(COLOR_BLUE, -1, NULL,
 
193
                                _("Checking file \"%s\" (lines %d to %d using %s):"),
 
194
                                DOC_FILENAME(doc), first_line + 1, last_line + 1, dict_string);
 
195
                g_message("Checking file \"%s\" (lines %d to %d using %s):",
 
196
                        DOC_FILENAME(doc), first_line + 1, last_line + 1, dict_string);
 
197
        }
 
198
        else
 
199
        {
 
200
                first_line = 0;
 
201
                last_line = sci_get_line_count(doc->editor->sci);
 
202
                if (sc_info->use_msgwin)
 
203
                        msgwin_msg_add(COLOR_BLUE, -1, NULL, _("Checking file \"%s\" (using %s):"),
 
204
                                DOC_FILENAME(doc), dict_string);
 
205
                g_message("Checking file \"%s\" (using %s):", DOC_FILENAME(doc), dict_string);
 
206
        }
 
207
        g_free(dict_string);
 
208
 
 
209
        for (i = first_line; i < last_line; i++)
 
210
        {
 
211
                line = sci_get_line(doc->editor->sci, i);
 
212
 
 
213
                suggestions_found += sc_speller_process_line(doc, i, line);
 
214
 
 
215
                /* process other GTK events to keep the GUI being responsive */
 
216
                while (g_main_context_iteration(NULL, FALSE));
 
217
 
 
218
                g_free(line);
 
219
        }
 
220
        if (suggestions_found == 0 && sc_info->use_msgwin)
 
221
                msgwin_msg_add(COLOR_BLUE, -1, NULL, _("The checked text is spelled correctly."));
 
222
 
 
223
        ui_progress_bar_stop();
 
224
}
 
225
 
 
226
 
 
227
static void broker_init_failed(void)
 
228
{
 
229
        const gchar *err = enchant_broker_get_error(sc_speller_broker);
 
230
        dialogs_show_msgbox(GTK_MESSAGE_ERROR,
 
231
                _("The Enchant library couldn't be initialized (%s)."),
 
232
                (err != NULL) ? err : _("unknown error (maybe the chosen language is not available)"));
 
233
}
 
234
 
 
235
 
 
236
static void dict_compare(gpointer data, gpointer user_data)
 
237
{
 
238
        gboolean *supported = user_data;
 
239
 
 
240
        if (utils_str_equal(sc_info->default_language, data))
 
241
                *supported = TRUE;
 
242
}
 
243
 
 
244
 
 
245
static gboolean check_default_lang(void)
 
246
{
 
247
        gboolean supported = FALSE;
 
248
 
 
249
        g_ptr_array_foreach(sc_info->dicts, dict_compare, &supported);
 
250
 
 
251
        return supported;
 
252
}
 
253
 
 
254
 
 
255
void sc_speller_reinit_enchant_dict(void)
 
256
{
 
257
        gchar *lang = sc_info->default_language;
 
258
 
 
259
        /* Release a previous dict object */
 
260
        if (sc_speller_dict != NULL)
 
261
                enchant_broker_free_dict(sc_speller_broker, sc_speller_dict);
 
262
 
 
263
        /* Check if the stored default dictionary is (still) avaiable, fall back to the first
 
264
         * one in the list if not */
 
265
        if (! check_default_lang())
 
266
        {
 
267
                if (sc_info->dicts->len > 0)
 
268
                {
 
269
                        lang = g_ptr_array_index(sc_info->dicts, 0);
 
270
                        g_warning("Stored language ('%s') could not be loaded. Falling back to '%s'",
 
271
                                sc_info->default_language, lang);
 
272
                }
 
273
                else
 
274
                        g_warning("Stored language ('%s') could not be loaded.", sc_info->default_language);
 
275
        }
 
276
 
 
277
        /* Request new dict object */
 
278
        sc_speller_dict = enchant_broker_request_dict(sc_speller_broker, lang);
 
279
        if (sc_speller_dict == NULL)
 
280
        {
 
281
                broker_init_failed();
 
282
                gtk_widget_set_sensitive(sc_info->menu_item, FALSE);
 
283
        }
 
284
        else
 
285
        {
 
286
                gtk_widget_set_sensitive(sc_info->menu_item, TRUE);
 
287
        }
 
288
}
 
289
 
 
290
 
 
291
gchar *sc_speller_get_default_lang(void)
 
292
{
 
293
        const gchar *lang = g_getenv("LANG");
 
294
        gchar *result = NULL;
 
295
 
 
296
        if (NZV(lang))
 
297
        {
 
298
                if (*lang == 'C' || *lang == 'c')
 
299
                        lang = "en";
 
300
                else
 
301
                {       /* if we have something like de_DE.UTF-8, strip everything from the period to the end */
 
302
                        gchar *period = strchr(lang, '.');
 
303
                        if (period != NULL)
 
304
                                result = g_strndup(lang, g_utf8_pointer_to_offset(lang, period));
 
305
                }
 
306
        }
 
307
        else
 
308
                lang = "en";
 
309
 
 
310
        return (result != NULL) ? result : g_strdup(lang);
 
311
}
 
312
 
 
313
 
 
314
static void add_dict_array(const gchar* const lang_tag, const gchar* const provider_name,
 
315
                                                   const gchar* const provider_desc, const gchar* const provider_file,
 
316
                                                   gpointer user_data)
 
317
{
 
318
        guint i;
 
319
        gchar *result = g_strdup(lang_tag);
 
320
 
 
321
        /* sometimes dictionaries are named lang-LOCALE instead of lang_LOCALE, so replace the
 
322
         * hyphen by a dash, enchant seems to not care about it. */
 
323
        for (i = 0; i < strlen(result); i++)
 
324
        {
 
325
                if (result[i] == '-')
 
326
                        result[i] = '_';
 
327
        }
 
328
 
 
329
        /* find duplicates and skip them */
 
330
        for (i = 0; i < sc_info->dicts->len; i++)
 
331
        {
 
332
                if (utils_str_equal(g_ptr_array_index(sc_info->dicts, i), result))
 
333
                        return;
 
334
        }
 
335
 
 
336
        g_ptr_array_add(sc_info->dicts, result);
 
337
}
 
338
 
 
339
 
 
340
static gint sort_dicts(gconstpointer a, gconstpointer b)
 
341
{       /* casting mania ;-) */
 
342
        return strcmp((gchar*)((GPtrArray*)a)->pdata, (gchar*)((GPtrArray*)b)->pdata);
 
343
}
 
344
 
 
345
 
 
346
static void create_dicts_array(void)
 
347
{
 
348
        sc_info->dicts = g_ptr_array_new();
 
349
 
 
350
        enchant_broker_list_dicts(sc_speller_broker, add_dict_array, sc_info->dicts);
 
351
 
 
352
        g_ptr_array_sort(sc_info->dicts, sort_dicts);
 
353
}
 
354
 
 
355
 
 
356
void sc_speller_dict_free_string_list(gchar **tmp_suggs)
 
357
{
 
358
        g_return_if_fail(sc_speller_dict != NULL);
 
359
 
 
360
        enchant_dict_free_string_list(sc_speller_dict, tmp_suggs);
 
361
}
 
362
 
 
363
 
 
364
void sc_speller_add_word(const gchar *word)
 
365
{
 
366
        g_return_if_fail(sc_speller_dict != NULL);
 
367
        g_return_if_fail(word != NULL);
 
368
 
 
369
        enchant_dict_add_to_pwl(sc_speller_dict, word, -1);
 
370
}
 
371
 
 
372
gboolean sc_speller_dict_check(const gchar *word)
 
373
{
 
374
        g_return_val_if_fail(sc_speller_dict != NULL, FALSE);
 
375
        g_return_val_if_fail(word != NULL, FALSE);
 
376
 
 
377
        return enchant_dict_check(sc_speller_dict, word, -1);
 
378
}
 
379
 
 
380
 
 
381
gchar **sc_speller_dict_suggest(const gchar *word, gsize *n_suggs)
 
382
{
 
383
        g_return_val_if_fail(sc_speller_dict != NULL, NULL);
 
384
        g_return_val_if_fail(word != NULL, NULL);
 
385
 
 
386
        return enchant_dict_suggest(sc_speller_dict, word, -1, n_suggs);
 
387
}
 
388
 
 
389
 
 
390
void sc_speller_add_word_to_session(const gchar *word)
 
391
{
 
392
        g_return_if_fail(sc_speller_dict != NULL);
 
393
        g_return_if_fail(word != NULL);
 
394
 
 
395
        enchant_dict_add_to_session(sc_speller_dict, word, -1);
 
396
}
 
397
 
 
398
 
 
399
void sc_speller_store_replacement(const gchar *old_word, const gchar *new_word)
 
400
{
 
401
        g_return_if_fail(sc_speller_dict != NULL);
 
402
        g_return_if_fail(old_word != NULL);
 
403
        g_return_if_fail(new_word != NULL);
 
404
 
 
405
        enchant_dict_store_replacement(sc_speller_dict, old_word, -1, new_word, -1);
 
406
}
 
407
 
 
408
 
 
409
void sc_speller_init(void)
 
410
{
 
411
        sc_speller_broker = enchant_broker_init();
 
412
 
 
413
        create_dicts_array();
 
414
 
 
415
        sc_speller_reinit_enchant_dict();
 
416
}
 
417
 
 
418
 
 
419
void sc_speller_free(void)
 
420
{
 
421
        if (sc_speller_dict != NULL)
 
422
                enchant_broker_free_dict(sc_speller_broker, sc_speller_dict);
 
423
        enchant_broker_free(sc_speller_broker);
 
424
}
 
425
 
 
426
 
 
427
gboolean sc_speller_is_text(GeanyDocument *doc, gint pos)
 
428
{
 
429
        gint lexer, style;
 
430
 
 
431
        g_return_val_if_fail(doc != NULL, FALSE);
 
432
        g_return_val_if_fail(pos >= 0, FALSE);
 
433
 
 
434
        style = sci_get_style_at(doc->editor->sci, pos);
 
435
        /* early out for the default style */
 
436
        if (style == STYLE_DEFAULT)
 
437
                return TRUE;
 
438
 
 
439
        lexer = scintilla_send_message(doc->editor->sci, SCI_GETLEXER, 0, 0);
 
440
        switch (lexer)
 
441
        {
 
442
                case SCLEX_ADA:
 
443
                {
 
444
                        switch (style)
 
445
                        {
 
446
                                case SCE_ADA_DEFAULT:
 
447
                                case SCE_ADA_COMMENTLINE:
 
448
                                case SCE_ADA_STRING:
 
449
                                case SCE_ADA_STRINGEOL:
 
450
                                case SCE_ADA_CHARACTER:
 
451
                                case SCE_ADA_CHARACTEREOL:
 
452
                                        return TRUE;
 
453
                                default:
 
454
                                        return FALSE;
 
455
                        }
 
456
                        break;
 
457
                }
 
458
                case SCLEX_ASM:
 
459
                {
 
460
                        switch (style)
 
461
                        {
 
462
                                case SCE_ASM_DEFAULT:
 
463
                                case SCE_ASM_COMMENT:
 
464
                                case SCE_ASM_COMMENTBLOCK:
 
465
                                case SCE_ASM_STRING:
 
466
                                case SCE_ASM_STRINGEOL:
 
467
                                case SCE_ASM_CHARACTER:
 
468
                                        return TRUE;
 
469
                                default:
 
470
                                        return FALSE;
 
471
                        }
 
472
                        break;
 
473
                }
 
474
                case SCLEX_BASH:
 
475
                {
 
476
                        switch (style)
 
477
                        {
 
478
                                case SCE_SH_DEFAULT:
 
479
                                case SCE_SH_COMMENTLINE:
 
480
                                case SCE_SH_STRING:
 
481
                                case SCE_SH_CHARACTER:
 
482
                                        return TRUE;
 
483
                                default:
 
484
                                        return FALSE;
 
485
                        }
 
486
                        break;
 
487
                }
 
488
                case SCLEX_CAML:
 
489
                {
 
490
                        switch (style)
 
491
                        {
 
492
                                case SCE_CAML_DEFAULT:
 
493
                                case SCE_CAML_COMMENT:
 
494
                                case SCE_CAML_COMMENT1:
 
495
                                case SCE_CAML_COMMENT2:
 
496
                                case SCE_CAML_COMMENT3:
 
497
                                case SCE_CAML_STRING:
 
498
                                case SCE_CAML_CHAR:
 
499
                                        return TRUE;
 
500
                                default:
 
501
                                        return FALSE;
 
502
                        }
 
503
                        break;
 
504
                }
 
505
#ifdef SCE_PAS_DEFAULT
 
506
                case SCLEX_PASCAL:
 
507
                {
 
508
                        switch (style)
 
509
                        {
 
510
                                case SCE_PAS_DEFAULT:
 
511
                                case SCE_PAS_COMMENT:
 
512
                                case SCE_PAS_COMMENT2:
 
513
                                case SCE_PAS_COMMENTLINE:
 
514
                                case SCE_PAS_STRING:
 
515
                                case SCE_PAS_CHARACTER:
 
516
                                        return TRUE;
 
517
                                default:
 
518
                                        return FALSE;
 
519
                        }
 
520
                        break;
 
521
                }
 
522
 
 
523
#endif
 
524
                case SCLEX_CPP:
 
525
#ifndef SCE_PAS_DEFAULT
 
526
                case SCLEX_PASCAL:
 
527
#endif
 
528
                {
 
529
                        switch (style)
 
530
                        {
 
531
                                case SCE_C_DEFAULT:
 
532
                                case SCE_C_COMMENT:
 
533
                                case SCE_C_COMMENTLINE:
 
534
                                case SCE_C_COMMENTDOC:
 
535
                                case SCE_C_STRING:
 
536
                                case SCE_C_CHARACTER:
 
537
                                case SCE_C_STRINGEOL:
 
538
                                case SCE_C_COMMENTLINEDOC:
 
539
                                        return TRUE;
 
540
                                default:
 
541
                                        return FALSE;
 
542
                        }
 
543
                        break;
 
544
                }
 
545
                case SCLEX_CMAKE:
 
546
                {
 
547
                        switch (style)
 
548
                        {
 
549
                                case SCE_CMAKE_DEFAULT:
 
550
                                case SCE_CMAKE_COMMENT:
 
551
                                case SCE_CMAKE_STRINGDQ:
 
552
                                case SCE_CMAKE_STRINGLQ:
 
553
                                case SCE_CMAKE_STRINGRQ:
 
554
                                case SCE_CMAKE_STRINGVAR:
 
555
                                        return TRUE;
 
556
                                default:
 
557
                                        return FALSE;
 
558
                        }
 
559
                        break;
 
560
                }
 
561
                case SCLEX_CSS:
 
562
                {
 
563
                        switch (style)
 
564
                        {
 
565
                                case SCE_CSS_DEFAULT:
 
566
                                case SCE_CSS_COMMENT:
 
567
                                        return TRUE;
 
568
                                default:
 
569
                                        return FALSE;
 
570
                        }
 
571
                        break;
 
572
                }
 
573
                case SCLEX_D:
 
574
                {
 
575
                        switch (style)
 
576
                        {
 
577
                                case SCE_D_DEFAULT:
 
578
                                case SCE_D_COMMENT:
 
579
                                case SCE_D_COMMENTLINE:
 
580
                                case SCE_D_COMMENTDOC:
 
581
                                case SCE_D_COMMENTNESTED:
 
582
                                case SCE_D_STRING:
 
583
                                case SCE_D_STRINGEOL:
 
584
                                case SCE_D_CHARACTER:
 
585
                                case SCE_D_COMMENTLINEDOC:
 
586
                                        return TRUE;
 
587
                                default:
 
588
                                        return FALSE;
 
589
                        }
 
590
                        break;
 
591
                }
 
592
                case SCLEX_DIFF:
 
593
                {
 
594
                        switch (style)
 
595
                        {
 
596
                                case SCE_DIFF_DEFAULT:
 
597
                                case SCE_DIFF_COMMENT:
 
598
                                case SCE_DIFF_HEADER:
 
599
                                        return TRUE;
 
600
                                default:
 
601
                                        return FALSE;
 
602
                        }
 
603
                        break;
 
604
                }
 
605
                case SCLEX_FORTRAN:
 
606
                case SCLEX_F77:
 
607
                {
 
608
                        switch (style)
 
609
                        {
 
610
                                case SCE_F_DEFAULT:
 
611
                                case SCE_F_COMMENT:
 
612
                                case SCE_F_STRING1:
 
613
                                case SCE_F_STRING2:
 
614
                                case SCE_F_STRINGEOL:
 
615
                                        return TRUE;
 
616
                                default:
 
617
                                        return FALSE;
 
618
                        }
 
619
                        break;
 
620
                }
 
621
                case SCLEX_FREEBASIC:
 
622
                {
 
623
                        switch (style)
 
624
                        {
 
625
                                case SCE_B_DEFAULT:
 
626
                                case SCE_B_COMMENT:
 
627
                                case SCE_B_STRING:
 
628
                                case SCE_B_STRINGEOL:
 
629
                                case SCE_B_CONSTANT:
 
630
                                        return TRUE;
 
631
                                default:
 
632
                                        return FALSE;
 
633
                        }
 
634
                        break;
 
635
                }
 
636
                case SCLEX_HASKELL:
 
637
                {
 
638
                        switch (style)
 
639
                        {
 
640
                                case SCE_HA_DEFAULT:
 
641
                                case SCE_HA_COMMENTLINE:
 
642
                                case SCE_HA_COMMENTBLOCK:
 
643
                                case SCE_HA_COMMENTBLOCK2:
 
644
                                case SCE_HA_COMMENTBLOCK3:
 
645
                                case SCE_HA_STRING:
 
646
                                case SCE_HA_CHARACTER:
 
647
                                case SCE_HA_DATA:
 
648
                                        return TRUE;
 
649
                                default:
 
650
                                        return FALSE;
 
651
                        }
 
652
                        break;
 
653
                }
 
654
                case SCLEX_HTML:
 
655
                case SCLEX_XML:
 
656
                {
 
657
                        switch (style)
 
658
                        {
 
659
                                case SCE_H_DEFAULT:
 
660
                                case SCE_H_TAGUNKNOWN:
 
661
                                case SCE_H_ATTRIBUTEUNKNOWN:
 
662
                                case SCE_H_DOUBLESTRING:
 
663
                                case SCE_H_SINGLESTRING:
 
664
                                case SCE_H_COMMENT:
 
665
                                case SCE_H_CDATA:
 
666
                                case SCE_H_VALUE: /* really? */
 
667
                                case SCE_H_SGML_DEFAULT:
 
668
                                case SCE_H_SGML_COMMENT:
 
669
                                case SCE_H_SGML_DOUBLESTRING:
 
670
                                case SCE_H_SGML_SIMPLESTRING:
 
671
                                case SCE_H_SGML_1ST_PARAM_COMMENT:
 
672
                                case SCE_HJ_DEFAULT:
 
673
                                case SCE_HJ_COMMENT:
 
674
                                case SCE_HJ_COMMENTLINE:
 
675
                                case SCE_HJ_COMMENTDOC:
 
676
                                case SCE_HJ_DOUBLESTRING:
 
677
                                case SCE_HJ_SINGLESTRING:
 
678
                                case SCE_HJ_STRINGEOL:
 
679
                                case SCE_HB_DEFAULT:
 
680
                                case SCE_HB_COMMENTLINE:
 
681
                                case SCE_HB_STRING:
 
682
                                case SCE_HB_STRINGEOL:
 
683
                                case SCE_HBA_DEFAULT:
 
684
                                case SCE_HBA_COMMENTLINE:
 
685
                                case SCE_HBA_STRING:
 
686
                                case SCE_HBA_STRINGEOL:
 
687
                                case SCE_HJA_DEFAULT:
 
688
                                case SCE_HJA_COMMENT:
 
689
                                case SCE_HJA_COMMENTLINE:
 
690
                                case SCE_HJA_COMMENTDOC:
 
691
                                case SCE_HJA_DOUBLESTRING:
 
692
                                case SCE_HJA_SINGLESTRING:
 
693
                                case SCE_HJA_STRINGEOL:
 
694
                                case SCE_HP_DEFAULT:
 
695
                                case SCE_HP_COMMENTLINE:
 
696
                                case SCE_HP_STRING:
 
697
                                case SCE_HP_CHARACTER:
 
698
                                case SCE_HP_TRIPLE:
 
699
                                case SCE_HP_TRIPLEDOUBLE:
 
700
                                case SCE_HPA_DEFAULT:
 
701
                                case SCE_HPA_COMMENTLINE:
 
702
                                case SCE_HPA_STRING:
 
703
                                case SCE_HPA_CHARACTER:
 
704
                                case SCE_HPA_TRIPLE:
 
705
                                case SCE_HPA_TRIPLEDOUBLE:
 
706
                                case SCE_HPHP_DEFAULT:
 
707
                                case SCE_HPHP_SIMPLESTRING:
 
708
                                case SCE_HPHP_HSTRING:
 
709
                                case SCE_HPHP_COMMENT:
 
710
                                case SCE_HPHP_COMMENTLINE:
 
711
                                        return TRUE;
 
712
                                default:
 
713
                                        return FALSE;
 
714
                        }
 
715
                        break;
 
716
                }
 
717
                case SCLEX_LATEX:
 
718
                {
 
719
                        switch (style)
 
720
                        {
 
721
                                case SCE_L_DEFAULT:
 
722
                                case SCE_L_COMMENT:
 
723
                                        return TRUE;
 
724
                                default:
 
725
                                        return FALSE;
 
726
                        }
 
727
                        break;
 
728
                }
 
729
                case SCLEX_LUA:
 
730
                {
 
731
                        switch (style)
 
732
                        {
 
733
                                case SCE_LUA_DEFAULT:
 
734
                                case SCE_LUA_COMMENT:
 
735
                                case SCE_LUA_COMMENTLINE:
 
736
                                case SCE_LUA_COMMENTDOC:
 
737
                                case SCE_LUA_STRING:
 
738
                                case SCE_LUA_CHARACTER:
 
739
                                case SCE_LUA_LITERALSTRING:
 
740
                                case SCE_LUA_STRINGEOL:
 
741
                                        return TRUE;
 
742
                                default:
 
743
                                        return FALSE;
 
744
                        }
 
745
                        break;
 
746
                }
 
747
                case SCLEX_MAKEFILE:
 
748
                {
 
749
                        switch (style)
 
750
                        {
 
751
                                case SCE_MAKE_DEFAULT:
 
752
                                case SCE_MAKE_COMMENT:
 
753
                                        return TRUE;
 
754
                                default:
 
755
                                        return FALSE;
 
756
                        }
 
757
                        break;
 
758
                }
 
759
                case SCLEX_MATLAB:
 
760
                {
 
761
                        switch (style)
 
762
                        {
 
763
                                case SCE_MATLAB_DEFAULT:
 
764
                                case SCE_MATLAB_COMMENT:
 
765
                                case SCE_MATLAB_STRING:
 
766
                                case SCE_MATLAB_DOUBLEQUOTESTRING:
 
767
                                        return TRUE;
 
768
                                default:
 
769
                                        return FALSE;
 
770
                        }
 
771
                        break;
 
772
                }
 
773
                case SCLEX_NSIS:
 
774
                {
 
775
                        switch (style)
 
776
                        {
 
777
                                case SCE_NSIS_DEFAULT:
 
778
                                case SCE_NSIS_COMMENT:
 
779
                                case SCE_NSIS_STRINGDQ:
 
780
                                case SCE_NSIS_STRINGLQ:
 
781
                                case SCE_NSIS_STRINGRQ:
 
782
                                case SCE_NSIS_STRINGVAR:
 
783
                                case SCE_NSIS_COMMENTBOX:
 
784
                                        return TRUE;
 
785
                                default:
 
786
                                        return FALSE;
 
787
                        }
 
788
                        break;
 
789
                }
 
790
                case SCLEX_PERL:
 
791
                {
 
792
                        switch (style)
 
793
                        {
 
794
                                case SCE_PL_DEFAULT:
 
795
                                case SCE_PL_COMMENTLINE:
 
796
                                case SCE_PL_STRING:
 
797
                                case SCE_PL_CHARACTER:
 
798
                                case SCE_PL_POD:
 
799
                                case SCE_PL_POD_VERB:
 
800
                                case SCE_PL_LONGQUOTE:
 
801
                                /* do we want SCE_PL_STRING_* too? */
 
802
                                        return TRUE;
 
803
                                default:
 
804
                                        return FALSE;
 
805
                        }
 
806
                        break;
 
807
                }
 
808
                case SCLEX_PO:
 
809
                {
 
810
                        switch (style)
 
811
                        {
 
812
                                case SCE_PO_DEFAULT:
 
813
                                case SCE_PO_COMMENT:
 
814
                                case SCE_PO_MSGID_TEXT:
 
815
                                case SCE_PO_MSGSTR_TEXT:
 
816
                                case SCE_PO_MSGCTXT_TEXT:
 
817
                                        return TRUE;
 
818
                                default:
 
819
                                        return FALSE;
 
820
                        }
 
821
                        break;
 
822
                }
 
823
                case SCLEX_PROPERTIES:
 
824
                {
 
825
                        switch (style)
 
826
                        {
 
827
                                case SCE_PROPS_DEFAULT:
 
828
                                case SCE_PROPS_COMMENT:
 
829
                                        return TRUE;
 
830
                                default:
 
831
                                        return FALSE;
 
832
                        }
 
833
                        break;
 
834
                }
 
835
                case SCLEX_PYTHON:
 
836
                {
 
837
                        switch (style)
 
838
                        {
 
839
                                case SCE_P_DEFAULT:
 
840
                                case SCE_P_COMMENTLINE:
 
841
                                case SCE_P_STRING:
 
842
                                case SCE_P_CHARACTER:
 
843
                                case SCE_P_TRIPLE:
 
844
                                case SCE_P_TRIPLEDOUBLE:
 
845
                                case SCE_P_COMMENTBLOCK:
 
846
                                case SCE_P_STRINGEOL:
 
847
                                        return TRUE;
 
848
                                default:
 
849
                                        return FALSE;
 
850
                        }
 
851
                        break;
 
852
                }
 
853
                case SCLEX_R:
 
854
                {
 
855
                        switch (style)
 
856
                        {
 
857
                                case SCE_R_DEFAULT:
 
858
                                case SCE_R_COMMENT:
 
859
                                case SCE_R_STRING:
 
860
                                case SCE_R_STRING2:
 
861
                                        return TRUE;
 
862
                                default:
 
863
                                        return FALSE;
 
864
                        }
 
865
                        break;
 
866
                }
 
867
                case SCLEX_RUBY:
 
868
                {
 
869
                        switch (style)
 
870
                        {
 
871
                                case SCE_RB_DEFAULT:
 
872
                                case SCE_RB_COMMENTLINE:
 
873
                                case SCE_RB_STRING:
 
874
                                case SCE_RB_CHARACTER:
 
875
                                case SCE_RB_POD:
 
876
                                        return TRUE;
 
877
                                default:
 
878
                                        return FALSE;
 
879
                        }
 
880
                        break;
 
881
                }
 
882
                case SCLEX_SQL:
 
883
                {
 
884
                        switch (style)
 
885
                        {
 
886
                                case SCE_SQL_DEFAULT:
 
887
                                case SCE_SQL_COMMENT:
 
888
                                case SCE_SQL_COMMENTLINE:
 
889
                                case SCE_SQL_COMMENTDOC:
 
890
                                case SCE_SQL_STRING:
 
891
                                case SCE_SQL_CHARACTER:
 
892
                                case SCE_SQL_SQLPLUS_COMMENT:
 
893
                                        return TRUE;
 
894
                                default:
 
895
                                        return FALSE;
 
896
                        }
 
897
                        break;
 
898
                }
 
899
                case SCLEX_TCL:
 
900
                {
 
901
                        switch (style)
 
902
                        {
 
903
                                case SCE_TCL_DEFAULT:
 
904
                                case SCE_TCL_COMMENT:
 
905
                                case SCE_TCL_COMMENTLINE:
 
906
                                case SCE_TCL_IN_QUOTE:
 
907
                                        return TRUE;
 
908
                                default:
 
909
                                        return FALSE;
 
910
                        }
 
911
                        break;
 
912
                }
 
913
                case SCLEX_VHDL:
 
914
                {
 
915
                        switch (style)
 
916
                        {
 
917
                                case SCE_VHDL_DEFAULT:
 
918
                                case SCE_VHDL_COMMENT:
 
919
                                case SCE_VHDL_COMMENTLINEBANG:
 
920
                                case SCE_VHDL_STRING:
 
921
                                case SCE_VHDL_STRINGEOL:
 
922
                                        return TRUE;
 
923
                                default:
 
924
                                        return FALSE;
 
925
                        }
 
926
                        break;
 
927
                }
 
928
                case SCLEX_YAML:
 
929
                {
 
930
                        switch (style)
 
931
                        {
 
932
                                case SCE_YAML_DEFAULT:
 
933
                                case SCE_YAML_COMMENT:
 
934
                                case SCE_YAML_TEXT:
 
935
                                        return TRUE;
 
936
                                default:
 
937
                                        return FALSE;
 
938
                        }
 
939
                        break;
 
940
                }
 
941
        }
 
942
        /* if the current lexer was not handled, let's say the passed position contains
 
943
         * valid text to not ignore more than we want */
 
944
        return TRUE;
 
945
}
 
946
 
 
947