mirror of
https://github.com/MidnightCommander/mc
synced 2024-12-22 20:36:50 +03:00
f21564b9e6
highlighting. * edit/Makefile.am: Add choosesyntax.c. * edit/edit.c (edit_init): Set option_auto_syntax to 1 on every invokation of the editor. * edit/edit.h: Pass char*** to edit_load_syntax(). Add parameters for syntax dialog and override. * edit/editmenu.c (menu_options): Add menu option to override syntax hightlighting. * edit/editoptions.c (edit_options_dialog): Pass option_syntax_type to edit_load_syntax(). * edit/syntax.c (edit_read_syntax_file): Dynamically allocate and fill syntax list pnames. * edit/syntax.c (edit_load_syntax): Use char*** for syntax list. * src/wtools.h: #include "widget.h" and remove redundant declarations of Dlg_head and WListbox.
1164 lines
28 KiB
C
1164 lines
28 KiB
C
/* editor syntax highlighting.
|
|
|
|
Copyright (C) 1996, 1997, 1998 the Free Software Foundation
|
|
|
|
Authors: 1998 Paul Sheer
|
|
|
|
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 2 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, write to the Free Software
|
|
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
|
|
02110-1301, USA.
|
|
*/
|
|
|
|
#include <config.h>
|
|
#include <stdio.h>
|
|
#include <stdarg.h>
|
|
#include <sys/types.h>
|
|
#include <unistd.h>
|
|
#include <string.h>
|
|
#include <ctype.h>
|
|
#include <errno.h>
|
|
#include <sys/stat.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include "../src/global.h"
|
|
|
|
#include "edit.h"
|
|
#include "edit-widget.h"
|
|
#include "../src/color.h" /* use_colors */
|
|
#include "../src/main.h" /* mc_home */
|
|
#include "../src/wtools.h" /* message() */
|
|
|
|
/* bytes */
|
|
#define SYNTAX_MARKER_DENSITY 512
|
|
|
|
/*
|
|
Mispelled words are flushed from the syntax highlighting rules
|
|
when they have been around longer than
|
|
TRANSIENT_WORD_TIME_OUT seconds. At a cursor rate of 30
|
|
chars per second and say 3 chars + a space per word, we can
|
|
accumulate 450 words absolute max with a value of 60. This is
|
|
below this limit of 1024 words in a context.
|
|
*/
|
|
#define TRANSIENT_WORD_TIME_OUT 60
|
|
|
|
#define UNKNOWN_FORMAT "unknown"
|
|
|
|
#define MAX_WORDS_PER_CONTEXT 1024
|
|
#define MAX_CONTEXTS 128
|
|
|
|
#define RULE_ON_LEFT_BORDER 1
|
|
#define RULE_ON_RIGHT_BORDER 2
|
|
|
|
#define SYNTAX_TOKEN_STAR '\001'
|
|
#define SYNTAX_TOKEN_PLUS '\002'
|
|
#define SYNTAX_TOKEN_BRACKET '\003'
|
|
#define SYNTAX_TOKEN_BRACE '\004'
|
|
|
|
struct key_word {
|
|
char *keyword;
|
|
unsigned char first;
|
|
char *whole_word_chars_left;
|
|
char *whole_word_chars_right;
|
|
int line_start;
|
|
int color;
|
|
};
|
|
|
|
struct context_rule {
|
|
char *left;
|
|
unsigned char first_left;
|
|
char *right;
|
|
unsigned char first_right;
|
|
char line_start_left;
|
|
char line_start_right;
|
|
int between_delimiters;
|
|
char *whole_word_chars_left;
|
|
char *whole_word_chars_right;
|
|
char *keyword_first_chars;
|
|
int spelling;
|
|
/* first word is word[1] */
|
|
struct key_word **keyword;
|
|
};
|
|
|
|
struct _syntax_marker {
|
|
long offset;
|
|
struct syntax_rule rule;
|
|
struct _syntax_marker *next;
|
|
};
|
|
|
|
int option_syntax_highlighting = 1;
|
|
int option_auto_syntax = 1;
|
|
char *option_syntax_type = NULL;
|
|
|
|
#define syntax_g_free(x) do {g_free(x); (x)=0;} while (0)
|
|
|
|
static gint
|
|
mc_defines_destroy (gpointer key, gpointer value, gpointer data)
|
|
{
|
|
char **values = value;
|
|
|
|
(void) data;
|
|
|
|
g_free (key);
|
|
while (*values)
|
|
g_free (*values++);
|
|
g_free (value);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
/* Completely destroys the defines tree */
|
|
static inline void
|
|
destroy_defines (GTree **defines)
|
|
{
|
|
g_tree_traverse (*defines, mc_defines_destroy, G_POST_ORDER, NULL);
|
|
g_tree_destroy (*defines);
|
|
*defines = 0;
|
|
}
|
|
|
|
static void
|
|
subst_defines (GTree *defines, char **argv, char **argv_end)
|
|
{
|
|
char **t, **p;
|
|
int argc;
|
|
while (*argv && argv < argv_end) {
|
|
if ((t = g_tree_lookup (defines, *argv))) {
|
|
int count = 0;
|
|
/* Count argv array members */
|
|
argc = 0;
|
|
for (p = &argv[1]; *p; p++)
|
|
argc++;
|
|
/* Count members of definition array */
|
|
for (p = t; *p; p++)
|
|
count++;
|
|
p = &argv[count + argc];
|
|
/* Buffer overflow or infinitive loop in define */
|
|
if (p >= argv_end)
|
|
break;
|
|
/* Move rest of argv after definition members */
|
|
while (argc >= 0)
|
|
*p-- = argv[argc-- + 1];
|
|
/* Copy definition members to argv */
|
|
for (p = argv; *t; *p++ = *t++);
|
|
}
|
|
argv++;
|
|
}
|
|
}
|
|
|
|
static long
|
|
compare_word_to_right (WEdit *edit, long i, const char *text,
|
|
const char *whole_left, const char *whole_right,
|
|
int line_start)
|
|
{
|
|
const unsigned char *p, *q;
|
|
int c, d, j;
|
|
if (!*text)
|
|
return -1;
|
|
c = edit_get_byte (edit, i - 1);
|
|
if (line_start)
|
|
if (c != '\n')
|
|
return -1;
|
|
if (whole_left)
|
|
if (strchr (whole_left, c))
|
|
return -1;
|
|
for (p = (unsigned char *) text, q = p + strlen ((char *) p); p < q; p++, i++) {
|
|
switch (*p) {
|
|
case SYNTAX_TOKEN_STAR:
|
|
if (++p > q)
|
|
return -1;
|
|
for (;;) {
|
|
c = edit_get_byte (edit, i);
|
|
if (!*p)
|
|
if (whole_right)
|
|
if (!strchr (whole_right, c))
|
|
break;
|
|
if (c == *p)
|
|
break;
|
|
if (c == '\n')
|
|
return -1;
|
|
i++;
|
|
}
|
|
break;
|
|
case SYNTAX_TOKEN_PLUS:
|
|
if (++p > q)
|
|
return -1;
|
|
j = 0;
|
|
for (;;) {
|
|
c = edit_get_byte (edit, i);
|
|
if (c == *p) {
|
|
j = i;
|
|
if (*p == *text && !p[1]) /* handle eg '+' and @+@ keywords properly */
|
|
break;
|
|
}
|
|
if (j && strchr ((char *) p + 1, c)) /* c exists further down, so it will get matched later */
|
|
break;
|
|
if (c == '\n' || c == '\t' || c == ' ') {
|
|
if (!*p) {
|
|
i--;
|
|
break;
|
|
}
|
|
if (!j)
|
|
return -1;
|
|
i = j;
|
|
break;
|
|
}
|
|
if (whole_right)
|
|
if (!strchr (whole_right, c)) {
|
|
if (!*p) {
|
|
i--;
|
|
break;
|
|
}
|
|
if (!j)
|
|
return -1;
|
|
i = j;
|
|
break;
|
|
}
|
|
i++;
|
|
}
|
|
break;
|
|
case SYNTAX_TOKEN_BRACKET:
|
|
if (++p > q)
|
|
return -1;
|
|
c = -1;
|
|
for (;; i++) {
|
|
d = c;
|
|
c = edit_get_byte (edit, i);
|
|
for (j = 0; p[j] != SYNTAX_TOKEN_BRACKET && p[j]; j++)
|
|
if (c == p[j])
|
|
goto found_char2;
|
|
break;
|
|
found_char2:
|
|
; /* dummy command */
|
|
}
|
|
i--;
|
|
while (*p != SYNTAX_TOKEN_BRACKET && p <= q)
|
|
p++;
|
|
if (p > q)
|
|
return -1;
|
|
if (p[1] == d)
|
|
i--;
|
|
break;
|
|
case SYNTAX_TOKEN_BRACE:
|
|
if (++p > q)
|
|
return -1;
|
|
c = edit_get_byte (edit, i);
|
|
for (; *p != SYNTAX_TOKEN_BRACE && *p; p++)
|
|
if (c == *p)
|
|
goto found_char3;
|
|
return -1;
|
|
found_char3:
|
|
while (*p != SYNTAX_TOKEN_BRACE && p < q)
|
|
p++;
|
|
break;
|
|
default:
|
|
if (*p != edit_get_byte (edit, i))
|
|
return -1;
|
|
}
|
|
}
|
|
if (whole_right)
|
|
if (strchr (whole_right, edit_get_byte (edit, i)))
|
|
return -1;
|
|
return i;
|
|
}
|
|
|
|
static inline const char *xx_strchr (const unsigned char *s, int c)
|
|
{
|
|
while (*s >= '\005' && *s != (unsigned char) c) {
|
|
s++;
|
|
}
|
|
return (const char *) s;
|
|
}
|
|
|
|
static inline struct syntax_rule apply_rules_going_right (WEdit * edit, long i, struct syntax_rule rule)
|
|
{
|
|
struct context_rule *r;
|
|
int contextchanged = 0, c;
|
|
int found_right = 0, found_left = 0, keyword_foundleft = 0, keyword_foundright = 0;
|
|
int is_end;
|
|
long end = 0;
|
|
struct syntax_rule _rule = rule;
|
|
if (!(c = edit_get_byte (edit, i)))
|
|
return rule;
|
|
is_end = (rule.end == (unsigned char) i);
|
|
/* check to turn off a keyword */
|
|
if (_rule.keyword) {
|
|
if (edit_get_byte (edit, i - 1) == '\n')
|
|
_rule.keyword = 0;
|
|
if (is_end) {
|
|
_rule.keyword = 0;
|
|
keyword_foundleft = 1;
|
|
}
|
|
}
|
|
/* check to turn off a context */
|
|
if (_rule.context && !_rule.keyword) {
|
|
long e;
|
|
r = edit->rules[_rule.context];
|
|
if (r->first_right == c && !(rule.border & RULE_ON_RIGHT_BORDER) && (e = compare_word_to_right (edit, i, r->right, r->whole_word_chars_left, r->whole_word_chars_right, r->line_start_right)) > 0) {
|
|
_rule.end = e;
|
|
found_right = 1;
|
|
_rule.border = RULE_ON_RIGHT_BORDER;
|
|
if (r->between_delimiters)
|
|
_rule.context = 0;
|
|
} else if (is_end && rule.border & RULE_ON_RIGHT_BORDER) {
|
|
/* always turn off a context at 4 */
|
|
found_left = 1;
|
|
_rule.border = 0;
|
|
if (!keyword_foundleft)
|
|
_rule.context = 0;
|
|
} else if (is_end && rule.border & RULE_ON_LEFT_BORDER) {
|
|
/* never turn off a context at 2 */
|
|
found_left = 1;
|
|
_rule.border = 0;
|
|
}
|
|
}
|
|
/* check to turn on a keyword */
|
|
if (!_rule.keyword) {
|
|
const char *p;
|
|
p = (r = edit->rules[_rule.context])->keyword_first_chars;
|
|
if (p)
|
|
while (*(p = xx_strchr ((unsigned char *) p + 1, c))) {
|
|
struct key_word *k;
|
|
int count;
|
|
long e;
|
|
count = p - r->keyword_first_chars;
|
|
k = r->keyword[count];
|
|
e = compare_word_to_right (edit, i, k->keyword, k->whole_word_chars_left, k->whole_word_chars_right, k->line_start);
|
|
if (e > 0) {
|
|
end = e;
|
|
_rule.end = e;
|
|
_rule.keyword = count;
|
|
keyword_foundright = 1;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
/* check to turn on a context */
|
|
if (!_rule.context) {
|
|
if (!found_left && is_end) {
|
|
if (rule.border & RULE_ON_RIGHT_BORDER) {
|
|
_rule.border = 0;
|
|
_rule.context = 0;
|
|
contextchanged = 1;
|
|
_rule.keyword = 0;
|
|
} else if (rule.border & RULE_ON_LEFT_BORDER) {
|
|
r = edit->rules[_rule._context];
|
|
_rule.border = 0;
|
|
if (r->between_delimiters) {
|
|
long e;
|
|
_rule.context = _rule._context;
|
|
contextchanged = 1;
|
|
_rule.keyword = 0;
|
|
if (r->first_right == c && (e = compare_word_to_right (edit, i, r->right, r->whole_word_chars_left, r->whole_word_chars_right, r->line_start_right)) >= end) {
|
|
_rule.end = e;
|
|
found_right = 1;
|
|
_rule.border = RULE_ON_RIGHT_BORDER;
|
|
_rule.context = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (!found_right) {
|
|
int count;
|
|
struct context_rule **rules = edit->rules;
|
|
for (count = 1; rules[count]; count++) {
|
|
r = rules[count];
|
|
if (r->first_left == c) {
|
|
long e;
|
|
e = compare_word_to_right (edit, i, r->left, r->whole_word_chars_left, r->whole_word_chars_right, r->line_start_left);
|
|
if (e >= end && (!_rule.keyword || keyword_foundright)) {
|
|
_rule.end = e;
|
|
found_right = 1;
|
|
_rule.border = RULE_ON_LEFT_BORDER;
|
|
_rule._context = count;
|
|
if (!r->between_delimiters)
|
|
if (!_rule.keyword) {
|
|
_rule.context = count;
|
|
contextchanged = 1;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
/* check again to turn on a keyword if the context switched */
|
|
if (contextchanged && !_rule.keyword) {
|
|
const char *p;
|
|
p = (r = edit->rules[_rule.context])->keyword_first_chars;
|
|
while (*(p = xx_strchr ((unsigned char *) p + 1, c))) {
|
|
struct key_word *k;
|
|
int count;
|
|
long e;
|
|
count = p - r->keyword_first_chars;
|
|
k = r->keyword[count];
|
|
e = compare_word_to_right (edit, i, k->keyword, k->whole_word_chars_left, k->whole_word_chars_right, k->line_start);
|
|
if (e > 0) {
|
|
_rule.end = e;
|
|
_rule.keyword = count;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return _rule;
|
|
}
|
|
|
|
static struct syntax_rule edit_get_rule (WEdit * edit, long byte_index)
|
|
{
|
|
long i;
|
|
if (byte_index > edit->last_get_rule) {
|
|
for (i = edit->last_get_rule + 1; i <= byte_index; i++) {
|
|
edit->rule = apply_rules_going_right (edit, i, edit->rule);
|
|
if (i > (edit->syntax_marker ? edit->syntax_marker->offset + SYNTAX_MARKER_DENSITY : SYNTAX_MARKER_DENSITY)) {
|
|
struct _syntax_marker *s;
|
|
s = edit->syntax_marker;
|
|
edit->syntax_marker = g_malloc0 (sizeof (struct _syntax_marker));
|
|
edit->syntax_marker->next = s;
|
|
edit->syntax_marker->offset = i;
|
|
edit->syntax_marker->rule = edit->rule;
|
|
}
|
|
}
|
|
} else if (byte_index < edit->last_get_rule) {
|
|
struct _syntax_marker *s;
|
|
for (;;) {
|
|
if (!edit->syntax_marker) {
|
|
memset (&edit->rule, 0, sizeof (edit->rule));
|
|
for (i = -1; i <= byte_index; i++)
|
|
edit->rule = apply_rules_going_right (edit, i, edit->rule);
|
|
break;
|
|
}
|
|
if (byte_index >= edit->syntax_marker->offset) {
|
|
edit->rule = edit->syntax_marker->rule;
|
|
for (i = edit->syntax_marker->offset + 1; i <= byte_index; i++)
|
|
edit->rule = apply_rules_going_right (edit, i, edit->rule);
|
|
break;
|
|
}
|
|
s = edit->syntax_marker->next;
|
|
syntax_g_free (edit->syntax_marker);
|
|
edit->syntax_marker = s;
|
|
}
|
|
}
|
|
edit->last_get_rule = byte_index;
|
|
return edit->rule;
|
|
}
|
|
|
|
static void translate_rule_to_color (WEdit * edit, struct syntax_rule rule, int *color)
|
|
{
|
|
struct key_word *k;
|
|
k = edit->rules[rule.context]->keyword[rule.keyword];
|
|
*color = k->color;
|
|
}
|
|
|
|
void edit_get_syntax_color (WEdit * edit, long byte_index, int *color)
|
|
{
|
|
if (edit->rules && byte_index < edit->last_byte &&
|
|
option_syntax_highlighting && use_colors) {
|
|
translate_rule_to_color (edit, edit_get_rule (edit, byte_index), color);
|
|
} else {
|
|
*color = use_colors ? EDITOR_NORMAL_COLOR_INDEX : 0;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
Returns 0 on error/eof or a count of the number of bytes read
|
|
including the newline. Result must be free'd.
|
|
In case of an error, *line will not be modified.
|
|
*/
|
|
static int read_one_line (char **line, FILE * f)
|
|
{
|
|
GString *p = g_string_new ("");
|
|
int c, r = 0;
|
|
|
|
for (;;) {
|
|
c = fgetc (f);
|
|
if (c == EOF) {
|
|
if (ferror (f)) {
|
|
if (errno == EINTR)
|
|
continue;
|
|
r = 0;
|
|
}
|
|
break;
|
|
}
|
|
r++;
|
|
/* handle all of \r\n, \r, \n correctly. */
|
|
if (c == '\r') {
|
|
if ( (c = fgetc (f)) == '\n')
|
|
r++;
|
|
else
|
|
ungetc (c, f);
|
|
break;
|
|
}
|
|
if (c == '\n')
|
|
break;
|
|
|
|
g_string_append_c (p, c);
|
|
}
|
|
if (r != 0) {
|
|
*line = p->str;
|
|
g_string_free (p, FALSE);
|
|
} else {
|
|
g_string_free (p, TRUE);
|
|
}
|
|
return r;
|
|
}
|
|
|
|
static char *convert (char *s)
|
|
{
|
|
char *r, *p;
|
|
p = r = s;
|
|
while (*s) {
|
|
switch (*s) {
|
|
case '\\':
|
|
s++;
|
|
switch (*s) {
|
|
case ' ':
|
|
*p = ' ';
|
|
s--;
|
|
break;
|
|
case 'n':
|
|
*p = '\n';
|
|
break;
|
|
case 'r':
|
|
*p = '\r';
|
|
break;
|
|
case 't':
|
|
*p = '\t';
|
|
break;
|
|
case 's':
|
|
*p = ' ';
|
|
break;
|
|
case '*':
|
|
*p = '*';
|
|
break;
|
|
case '\\':
|
|
*p = '\\';
|
|
break;
|
|
case '[':
|
|
case ']':
|
|
*p = SYNTAX_TOKEN_BRACKET;
|
|
break;
|
|
case '{':
|
|
case '}':
|
|
*p = SYNTAX_TOKEN_BRACE;
|
|
break;
|
|
case 0:
|
|
*p = *s;
|
|
return r;
|
|
default:
|
|
*p = *s;
|
|
break;
|
|
}
|
|
break;
|
|
case '*':
|
|
*p = SYNTAX_TOKEN_STAR;
|
|
break;
|
|
case '+':
|
|
*p = SYNTAX_TOKEN_PLUS;
|
|
break;
|
|
default:
|
|
*p = *s;
|
|
break;
|
|
}
|
|
s++;
|
|
p++;
|
|
}
|
|
*p = '\0';
|
|
return r;
|
|
}
|
|
|
|
#define whiteness(x) ((x) == '\t' || (x) == '\n' || (x) == ' ')
|
|
|
|
static int get_args (char *l, char **args, int args_size)
|
|
{
|
|
int argc = 0;
|
|
while (argc < args_size) {
|
|
char *p = l;
|
|
while (*p && whiteness (*p))
|
|
p++;
|
|
if (!*p)
|
|
break;
|
|
for (l = p + 1; *l && !whiteness (*l); l++);
|
|
if (*l)
|
|
*l++ = '\0';
|
|
args[argc++] = convert (p);
|
|
}
|
|
args[argc] = (char *) NULL;
|
|
return argc;
|
|
}
|
|
|
|
#define free_args(x)
|
|
#define break_a {result=line;break;}
|
|
#define check_a {if(!*a){result=line;break;}}
|
|
#define check_not_a {if(*a){result=line;break;}}
|
|
|
|
static int
|
|
this_try_alloc_color_pair (const char *fg, const char *bg)
|
|
{
|
|
char f[80], b[80], *p;
|
|
if (bg)
|
|
if (!*bg)
|
|
bg = 0;
|
|
if (fg)
|
|
if (!*fg)
|
|
fg = 0;
|
|
if (fg) {
|
|
g_strlcpy (f, fg, sizeof (f));
|
|
p = strchr (f, '/');
|
|
if (p)
|
|
*p = '\0';
|
|
fg = f;
|
|
}
|
|
if (bg) {
|
|
g_strlcpy (b, bg, sizeof (b));
|
|
p = strchr (b, '/');
|
|
if (p)
|
|
*p = '\0';
|
|
bg = b;
|
|
}
|
|
return try_alloc_color_pair (fg, bg);
|
|
}
|
|
|
|
static char *error_file_name = 0;
|
|
|
|
static FILE *open_include_file (const char *filename)
|
|
{
|
|
FILE *f;
|
|
|
|
syntax_g_free (error_file_name);
|
|
error_file_name = g_strdup (filename);
|
|
if (*filename == PATH_SEP)
|
|
return fopen (filename, "r");
|
|
|
|
g_free (error_file_name);
|
|
error_file_name = g_strconcat (home_dir, EDIT_DIR PATH_SEP_STR,
|
|
filename, (char *) NULL);
|
|
f = fopen (error_file_name, "r");
|
|
if (f)
|
|
return f;
|
|
|
|
g_free (error_file_name);
|
|
error_file_name = g_strconcat (mc_home, PATH_SEP_STR "syntax" PATH_SEP_STR,
|
|
filename, (char *) NULL);
|
|
return fopen (error_file_name, "r");
|
|
}
|
|
|
|
/* returns line number on error */
|
|
static int
|
|
edit_read_syntax_rules (WEdit *edit, FILE *f, char **args, int args_size)
|
|
{
|
|
FILE *g = 0;
|
|
char *fg, *bg;
|
|
char last_fg[32] = "", last_bg[32] = "";
|
|
char whole_right[512];
|
|
char whole_left[512];
|
|
char *l = 0;
|
|
int save_line = 0, line = 0;
|
|
struct context_rule **r, *c = 0;
|
|
int num_words = -1, num_contexts = -1;
|
|
int result = 0;
|
|
int argc;
|
|
int i, j;
|
|
int alloc_contexts = MAX_CONTEXTS,
|
|
alloc_words_per_context = MAX_WORDS_PER_CONTEXT,
|
|
max_alloc_words_per_context = MAX_WORDS_PER_CONTEXT;
|
|
|
|
args[0] = 0;
|
|
|
|
strcpy (whole_left, "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_01234567890");
|
|
strcpy (whole_right, "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_01234567890");
|
|
|
|
r = edit->rules = g_malloc (alloc_contexts * sizeof (struct context_rule *));
|
|
|
|
if (!edit->defines)
|
|
edit->defines = g_tree_new ((GCompareFunc) strcmp);
|
|
|
|
for (;;) {
|
|
char **a;
|
|
line++;
|
|
l = 0;
|
|
if (!read_one_line (&l, f)) {
|
|
if (g) {
|
|
fclose (f);
|
|
f = g;
|
|
g = 0;
|
|
line = save_line + 1;
|
|
syntax_g_free (error_file_name);
|
|
syntax_g_free (l);
|
|
if (!read_one_line (&l, f))
|
|
break;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
argc = get_args (l, args, args_size);
|
|
a = args + 1;
|
|
if (!args[0]) {
|
|
/* do nothing */
|
|
} else if (!strcmp (args[0], "include")) {
|
|
if (g || argc != 2) {
|
|
result = line;
|
|
break;
|
|
}
|
|
g = f;
|
|
f = open_include_file (args[1]);
|
|
if (!f) {
|
|
syntax_g_free (error_file_name);
|
|
result = line;
|
|
break;
|
|
}
|
|
save_line = line;
|
|
line = 0;
|
|
} else if (!strcmp (args[0], "wholechars")) {
|
|
check_a;
|
|
if (!strcmp (*a, "left")) {
|
|
a++;
|
|
g_strlcpy (whole_left, *a, sizeof (whole_left));
|
|
} else if (!strcmp (*a, "right")) {
|
|
a++;
|
|
g_strlcpy (whole_right, *a, sizeof (whole_right));
|
|
} else {
|
|
g_strlcpy (whole_left, *a, sizeof (whole_left));
|
|
g_strlcpy (whole_right, *a, sizeof (whole_right));
|
|
}
|
|
a++;
|
|
check_not_a;
|
|
} else if (!strcmp (args[0], "context")) {
|
|
check_a;
|
|
if (num_contexts == -1) {
|
|
if (strcmp (*a, "default")) { /* first context is the default */
|
|
break_a;
|
|
}
|
|
a++;
|
|
c = r[0] = g_malloc0 (sizeof (struct context_rule));
|
|
c->left = g_strdup (" ");
|
|
c->right = g_strdup (" ");
|
|
num_contexts = 0;
|
|
} else {
|
|
/* Terminate previous context. */
|
|
r[num_contexts - 1]->keyword[num_words] = NULL;
|
|
c = r[num_contexts] = g_malloc0 (sizeof (struct context_rule));
|
|
if (!strcmp (*a, "exclusive")) {
|
|
a++;
|
|
c->between_delimiters = 1;
|
|
}
|
|
check_a;
|
|
if (!strcmp (*a, "whole")) {
|
|
a++;
|
|
c->whole_word_chars_left = g_strdup (whole_left);
|
|
c->whole_word_chars_right = g_strdup (whole_right);
|
|
} else if (!strcmp (*a, "wholeleft")) {
|
|
a++;
|
|
c->whole_word_chars_left = g_strdup (whole_left);
|
|
} else if (!strcmp (*a, "wholeright")) {
|
|
a++;
|
|
c->whole_word_chars_right = g_strdup (whole_right);
|
|
}
|
|
check_a;
|
|
if (!strcmp (*a, "linestart")) {
|
|
a++;
|
|
c->line_start_left = 1;
|
|
}
|
|
check_a;
|
|
c->left = g_strdup (*a++);
|
|
check_a;
|
|
if (!strcmp (*a, "linestart")) {
|
|
a++;
|
|
c->line_start_right = 1;
|
|
}
|
|
check_a;
|
|
c->right = g_strdup (*a++);
|
|
c->first_left = *c->left;
|
|
c->first_right = *c->right;
|
|
}
|
|
c->keyword = g_malloc (alloc_words_per_context * sizeof (struct key_word *));
|
|
num_words = 1;
|
|
c->keyword[0] = g_malloc0 (sizeof (struct key_word));
|
|
subst_defines (edit->defines, a, &args[1024]);
|
|
fg = *a;
|
|
if (*a)
|
|
a++;
|
|
bg = *a;
|
|
if (*a)
|
|
a++;
|
|
g_strlcpy (last_fg, fg ? fg : "", sizeof (last_fg));
|
|
g_strlcpy (last_bg, bg ? bg : "", sizeof (last_bg));
|
|
c->keyword[0]->color = this_try_alloc_color_pair (fg, bg);
|
|
c->keyword[0]->keyword = g_strdup (" ");
|
|
check_not_a;
|
|
|
|
alloc_words_per_context = MAX_WORDS_PER_CONTEXT;
|
|
if (++num_contexts >= alloc_contexts) {
|
|
struct context_rule **tmp;
|
|
|
|
alloc_contexts += 128;
|
|
tmp = g_realloc (r, alloc_contexts * sizeof (struct context_rule *));
|
|
r = tmp;
|
|
}
|
|
} else if (!strcmp (args[0], "spellcheck")) {
|
|
if (!c) {
|
|
result = line;
|
|
break;
|
|
}
|
|
c->spelling = 1;
|
|
} else if (!strcmp (args[0], "keyword")) {
|
|
struct key_word *k;
|
|
if (num_words == -1)
|
|
break_a;
|
|
check_a;
|
|
k = r[num_contexts - 1]->keyword[num_words] = g_malloc0 (sizeof (struct key_word));
|
|
if (!strcmp (*a, "whole")) {
|
|
a++;
|
|
k->whole_word_chars_left = g_strdup (whole_left);
|
|
k->whole_word_chars_right = g_strdup (whole_right);
|
|
} else if (!strcmp (*a, "wholeleft")) {
|
|
a++;
|
|
k->whole_word_chars_left = g_strdup (whole_left);
|
|
} else if (!strcmp (*a, "wholeright")) {
|
|
a++;
|
|
k->whole_word_chars_right = g_strdup (whole_right);
|
|
}
|
|
check_a;
|
|
if (!strcmp (*a, "linestart")) {
|
|
a++;
|
|
k->line_start = 1;
|
|
}
|
|
check_a;
|
|
if (!strcmp (*a, "whole")) {
|
|
break_a;
|
|
}
|
|
k->keyword = g_strdup (*a++);
|
|
k->first = *k->keyword;
|
|
subst_defines (edit->defines, a, &args[1024]);
|
|
fg = *a;
|
|
if (*a)
|
|
a++;
|
|
bg = *a;
|
|
if (*a)
|
|
a++;
|
|
if (!fg)
|
|
fg = last_fg;
|
|
if (!bg)
|
|
bg = last_bg;
|
|
k->color = this_try_alloc_color_pair (fg, bg);
|
|
check_not_a;
|
|
|
|
if (++num_words >= alloc_words_per_context) {
|
|
struct key_word **tmp;
|
|
|
|
alloc_words_per_context += 1024;
|
|
|
|
if (alloc_words_per_context > max_alloc_words_per_context)
|
|
max_alloc_words_per_context = alloc_words_per_context;
|
|
|
|
tmp = g_realloc (c->keyword, alloc_words_per_context * sizeof (struct key_word *));
|
|
c->keyword = tmp;
|
|
}
|
|
} else if (*(args[0]) == '#') {
|
|
/* do nothing for comment */
|
|
} else if (!strcmp (args[0], "file")) {
|
|
break;
|
|
} else if (!strcmp (args[0], "define")) {
|
|
char *key = *a++;
|
|
char **argv;
|
|
|
|
if (argc < 3)
|
|
break_a;
|
|
if ((argv = g_tree_lookup (edit->defines, key))) {
|
|
mc_defines_destroy (NULL, argv, NULL);
|
|
} else {
|
|
key = g_strdup (key);
|
|
}
|
|
argv = g_new (char *, argc - 1);
|
|
g_tree_insert (edit->defines, key, argv);
|
|
while (*a) {
|
|
*argv++ = g_strdup (*a++);
|
|
};
|
|
*argv = NULL;
|
|
} else { /* anything else is an error */
|
|
break_a;
|
|
}
|
|
free_args (args);
|
|
syntax_g_free (l);
|
|
}
|
|
free_args (args);
|
|
syntax_g_free (l);
|
|
|
|
/* Terminate context array. */
|
|
if (num_contexts > 0) {
|
|
r[num_contexts - 1]->keyword[num_words] = NULL;
|
|
r[num_contexts] = NULL;
|
|
}
|
|
|
|
if (!edit->rules[0])
|
|
syntax_g_free (edit->rules);
|
|
|
|
if (result)
|
|
return result;
|
|
|
|
if (num_contexts == -1) {
|
|
return line;
|
|
}
|
|
|
|
{
|
|
char *first_chars, *p;
|
|
|
|
first_chars = g_malloc (max_alloc_words_per_context + 2);
|
|
|
|
for (i = 0; edit->rules[i]; i++) {
|
|
c = edit->rules[i];
|
|
p = first_chars;
|
|
*p++ = (char) 1;
|
|
for (j = 1; c->keyword[j]; j++)
|
|
*p++ = c->keyword[j]->first;
|
|
*p = '\0';
|
|
c->keyword_first_chars = g_strdup (first_chars);
|
|
}
|
|
|
|
g_free (first_chars);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
void edit_free_syntax_rules (WEdit * edit)
|
|
{
|
|
int i, j;
|
|
if (!edit)
|
|
return;
|
|
if (edit->defines)
|
|
destroy_defines (&edit->defines);
|
|
if (!edit->rules)
|
|
return;
|
|
edit_get_rule (edit, -1);
|
|
syntax_g_free (edit->syntax_type);
|
|
edit->syntax_type = 0;
|
|
for (i = 0; edit->rules[i]; i++) {
|
|
if (edit->rules[i]->keyword) {
|
|
for (j = 0; edit->rules[i]->keyword[j]; j++) {
|
|
syntax_g_free (edit->rules[i]->keyword[j]->keyword);
|
|
syntax_g_free (edit->rules[i]->keyword[j]->whole_word_chars_left);
|
|
syntax_g_free (edit->rules[i]->keyword[j]->whole_word_chars_right);
|
|
syntax_g_free (edit->rules[i]->keyword[j]);
|
|
}
|
|
}
|
|
syntax_g_free (edit->rules[i]->left);
|
|
syntax_g_free (edit->rules[i]->right);
|
|
syntax_g_free (edit->rules[i]->whole_word_chars_left);
|
|
syntax_g_free (edit->rules[i]->whole_word_chars_right);
|
|
syntax_g_free (edit->rules[i]->keyword);
|
|
syntax_g_free (edit->rules[i]->keyword_first_chars);
|
|
syntax_g_free (edit->rules[i]);
|
|
}
|
|
while (edit->syntax_marker) {
|
|
struct _syntax_marker *s = edit->syntax_marker->next;
|
|
syntax_g_free (edit->syntax_marker);
|
|
edit->syntax_marker = s;
|
|
}
|
|
syntax_g_free (edit->rules);
|
|
}
|
|
|
|
/* returns -1 on file error, line number on error in file syntax */
|
|
static int
|
|
edit_read_syntax_file (WEdit * edit, char ***pnames, const char *syntax_file,
|
|
const char *editor_file, const char *first_line,
|
|
const char *type)
|
|
{
|
|
/* Using a low value for NENTRIES for testing purposes. NENTRIES should be set
|
|
to a more sensible value (30 - 100) before the release of 4.6.2. (leonardjo) */
|
|
#define NENTRIES 3
|
|
FILE *f, *g = NULL;
|
|
regex_t r;
|
|
regmatch_t pmatch[1];
|
|
char *args[1024], *l = 0;
|
|
int line = 0;
|
|
int argc;
|
|
int result = 0;
|
|
int count = 0;
|
|
char *lib_file;
|
|
int found = 0;
|
|
char **tmpnames = NULL;
|
|
|
|
f = fopen (syntax_file, "r");
|
|
if (!f){
|
|
lib_file = concat_dir_and_file (mc_home, "syntax" PATH_SEP_STR "Syntax");
|
|
f = fopen (lib_file, "r");
|
|
g_free (lib_file);
|
|
if (!f)
|
|
return -1;
|
|
}
|
|
args[0] = 0;
|
|
for (;;) {
|
|
line++;
|
|
syntax_g_free (l);
|
|
if (!read_one_line (&l, f))
|
|
break;
|
|
argc = get_args (l, args, 1023); /* Final NULL */
|
|
if (!args[0])
|
|
continue;
|
|
/* Looking for `include ...` lines before first `file ...` ones */
|
|
if (!found && !strcmp (args[0], "include")) {
|
|
if (g)
|
|
continue;
|
|
if (!args[1] || !(g = open_include_file (args[1]))) {
|
|
result = line;
|
|
break;
|
|
}
|
|
goto found_type;
|
|
}
|
|
/* looking for `file ...' lines only */
|
|
if (strcmp (args[0], "file")) {
|
|
continue;
|
|
}
|
|
found = 1;
|
|
/* must have two args or report error */
|
|
if (!args[1] || !args[2]) {
|
|
result = line;
|
|
break;
|
|
}
|
|
if (pnames && *pnames) {
|
|
/* 1: just collecting a list of names of rule sets */
|
|
/* Reallocate the list if required */
|
|
if (count % NENTRIES == 0) {
|
|
if ((tmpnames = (char**) g_realloc (*pnames, (count + NENTRIES
|
|
+ 1) * sizeof (char*))) != NULL)
|
|
*pnames = tmpnames;
|
|
else
|
|
abort ();
|
|
}
|
|
(*pnames)[count++] = g_strdup (args[2]);
|
|
(*pnames)[count] = NULL;
|
|
} else if (type) {
|
|
/* 2: rule set was explicitly specified by the caller */
|
|
if (!strcmp (type, args[2]))
|
|
goto found_type;
|
|
} else if (editor_file && edit) {
|
|
/* 3: auto-detect rule set from regular expressions */
|
|
int q;
|
|
if (regcomp (&r, args[1], REG_EXTENDED)) {
|
|
result = line;
|
|
break;
|
|
}
|
|
/* does filename match arg 1 ? */
|
|
q = !regexec (&r, editor_file, 1, pmatch, 0);
|
|
regfree (&r);
|
|
if (!q && args[3]) {
|
|
if (regcomp (&r, args[3], REG_EXTENDED)) {
|
|
result = line;
|
|
break;
|
|
}
|
|
/* does first line match arg 3 ? */
|
|
q = !regexec (&r, first_line, 1, pmatch, 0);
|
|
regfree (&r);
|
|
}
|
|
if (q) {
|
|
int line_error;
|
|
char *syntax_type;
|
|
found_type:
|
|
syntax_type = args[2];
|
|
line_error = edit_read_syntax_rules (edit, g ? g : f, args, 1023);
|
|
if (line_error) {
|
|
if (!error_file_name) /* an included file */
|
|
result = line + line_error;
|
|
else
|
|
result = line_error;
|
|
} else {
|
|
syntax_g_free (edit->syntax_type);
|
|
edit->syntax_type = g_strdup (syntax_type);
|
|
/* if there are no rules then turn off syntax highlighting for speed */
|
|
if (!g && !edit->rules[1])
|
|
if (!edit->rules[0]->keyword[1] && !edit->rules[0]->spelling) {
|
|
edit_free_syntax_rules (edit);
|
|
break;
|
|
}
|
|
}
|
|
if (g) {
|
|
fclose (g);
|
|
g = NULL;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
syntax_g_free (l);
|
|
fclose (f);
|
|
return result;
|
|
}
|
|
|
|
static char *get_first_editor_line (WEdit * edit)
|
|
{
|
|
int i;
|
|
static char s[256];
|
|
s[0] = '\0';
|
|
if (!edit)
|
|
return s;
|
|
for (i = 0; i < 255; i++) {
|
|
s[i] = edit_get_byte (edit, i);
|
|
if (s[i] == '\n') {
|
|
s[i] = '\0';
|
|
break;
|
|
}
|
|
}
|
|
s[255] = '\0';
|
|
return s;
|
|
}
|
|
|
|
/*
|
|
* Load rules into edit struct. Either edit or *pnames must be NULL. If
|
|
* edit is NULL, a list of types will be stored into names. If type is
|
|
* NULL, then the type will be selected according to the filename.
|
|
*/
|
|
void
|
|
edit_load_syntax (WEdit *edit, char ***pnames, const char *type)
|
|
{
|
|
int r;
|
|
char *f = NULL;
|
|
|
|
if (option_auto_syntax)
|
|
type = NULL;
|
|
|
|
edit_free_syntax_rules (edit);
|
|
|
|
if (!use_colors)
|
|
return;
|
|
|
|
if (!option_syntax_highlighting && (!pnames || !*pnames))
|
|
return;
|
|
|
|
if (edit) {
|
|
if (!edit->filename)
|
|
return;
|
|
if (!*edit->filename && !type)
|
|
return;
|
|
}
|
|
f = concat_dir_and_file (home_dir, SYNTAX_FILE);
|
|
r = edit_read_syntax_file (edit, pnames, f, edit ? edit->filename : 0,
|
|
get_first_editor_line (edit), type);
|
|
if (r == -1) {
|
|
edit_free_syntax_rules (edit);
|
|
message (D_ERROR, _(" Load syntax file "),
|
|
_(" Cannot open file %s \n %s "), f,
|
|
unix_error_string (errno));
|
|
} else if (r) {
|
|
edit_free_syntax_rules (edit);
|
|
message (D_ERROR, _(" Load syntax file "),
|
|
_(" Error in file %s on line %d "),
|
|
error_file_name ? error_file_name : f, r);
|
|
syntax_g_free (error_file_name);
|
|
} else {
|
|
/* succeeded */
|
|
}
|
|
g_free (f);
|
|
}
|