1 /* editor syntax highlighting.
3 Copyright (C) 1996, 1997, 1998, 2001, 2002, 2003, 2004, 2005, 2006,
4 2007 Free Software Foundation, Inc.
6 Authors: 1998 Paul Sheer
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
25 * \brief Source: editor syntax highlighting
28 * \author Mikhail Pobolovets
31 * Mispelled words are flushed from the syntax highlighting rules
32 * when they have been around longer than
33 * TRANSIENT_WORD_TIME_OUT seconds. At a cursor rate of 30
34 * chars per second and say 3 chars + a space per word, we can
35 * accumulate 450 words absolute max with a value of 60. This is
36 * below this limit of 1024 words in a context.
43 #include <sys/types.h>
51 #include "lib/global.h"
52 #include "lib/search.h" /* search engine */
54 #include "lib/strutil.h" /* utf string functions */
56 #include "src/main.h" /* mc_home */
57 #include "src/wtools.h" /* message() */
59 #include "edit-impl.h"
60 #include "edit-widget.h"
64 #define SYNTAX_MARKER_DENSITY 512
66 #define TRANSIENT_WORD_TIME_OUT 60
68 #define UNKNOWN_FORMAT "unknown"
70 #define MAX_WORDS_PER_CONTEXT 1024
71 #define MAX_CONTEXTS 128
73 #define RULE_ON_LEFT_BORDER 1
74 #define RULE_ON_RIGHT_BORDER 2
76 #define SYNTAX_TOKEN_STAR '\001'
77 #define SYNTAX_TOKEN_PLUS '\002'
78 #define SYNTAX_TOKEN_BRACKET '\003'
79 #define SYNTAX_TOKEN_BRACE '\004'
85 char *whole_word_chars_left
;
86 char *whole_word_chars_right
;
94 unsigned char first_left
;
96 unsigned char first_right
;
98 char line_start_right
;
99 int between_delimiters
;
100 char *whole_word_chars_left
;
101 char *whole_word_chars_right
;
102 char *keyword_first_chars
;
104 /* first word is word[1] */
105 struct key_word
**keyword
;
108 struct _syntax_marker
111 struct syntax_rule rule
;
112 struct _syntax_marker
*next
;
115 int option_syntax_highlighting
= 1;
116 int option_auto_syntax
= 1;
119 mc_defines_destroy (gpointer key
, gpointer value
, gpointer data
)
121 char **values
= value
;
133 /* Completely destroys the defines tree */
135 destroy_defines (GTree
** defines
)
137 g_tree_foreach (*defines
, mc_defines_destroy
, NULL
);
138 g_tree_destroy (*defines
);
142 /* Wrapper for case insensitive mode */
144 xx_tolower (WEdit
* edit
, int c
)
146 return edit
->is_case_insensitive
? tolower (c
) : c
;
150 subst_defines (GTree
* defines
, char **argv
, char **argv_end
)
155 while (*argv
!= NULL
&& argv
< argv_end
)
157 t
= g_tree_lookup (defines
, *argv
);
162 /* Count argv array members */
164 for (p
= &argv
[1]; *p
!= NULL
; p
++)
167 /* Count members of definition array */
168 for (p
= t
; *p
!= NULL
; p
++)
170 p
= &argv
[count
+ argc
];
172 /* Buffer overflow or infinitive loop in define */
176 /* Move rest of argv after definition members */
178 *p
-- = argv
[argc
-- + 1];
180 /* Copy definition members to argv */
181 for (p
= argv
; *t
!= NULL
; *p
++ = *t
++)
189 compare_word_to_right (WEdit
* edit
, long i
, const char *text
,
190 const char *whole_left
, const char *whole_right
, int line_start
)
192 const unsigned char *p
, *q
;
198 c
= xx_tolower (edit
, edit_get_byte (edit
, i
- 1));
199 if (line_start
!= 0 && c
!= '\n')
201 if (whole_left
!= NULL
&& strchr (whole_left
, c
) != NULL
)
204 for (p
= (unsigned char *) text
, q
= p
+ str_term_width1 ((char *) p
); p
< q
; p
++, i
++)
208 case SYNTAX_TOKEN_STAR
:
213 c
= xx_tolower (edit
, edit_get_byte (edit
, i
));
214 if (*p
== '\0' && whole_right
!= NULL
&& strchr (whole_right
, c
) == NULL
)
223 case SYNTAX_TOKEN_PLUS
:
229 c
= xx_tolower (edit
, edit_get_byte (edit
, i
));
233 if (*p
== *text
&& p
[1] == '\0') /* handle eg '+' and @+@ keywords properly */
236 if (j
&& strchr ((char *) p
+ 1, c
)) /* c exists further down, so it will get matched later */
238 if (c
== '\n' || c
== '\t' || c
== ' ')
250 if (whole_right
!= NULL
&& (strchr (whole_right
, c
) == NULL
))
265 case SYNTAX_TOKEN_BRACKET
:
272 c
= xx_tolower (edit
, edit_get_byte (edit
, i
));
273 for (j
= 0; p
[j
] != SYNTAX_TOKEN_BRACKET
&& p
[j
]; j
++)
278 ; /* dummy command */
281 while (*p
!= SYNTAX_TOKEN_BRACKET
&& p
<= q
)
288 case SYNTAX_TOKEN_BRACE
:
291 c
= xx_tolower (edit
, edit_get_byte (edit
, i
));
292 for (; *p
!= SYNTAX_TOKEN_BRACE
&& *p
; p
++)
297 while (*p
!= SYNTAX_TOKEN_BRACE
&& p
< q
)
301 if (*p
!= xx_tolower (edit
, edit_get_byte (edit
, i
)))
305 if (whole_right
!= NULL
&& strchr (whole_right
, xx_tolower (edit
, edit_get_byte (edit
, i
))) != NULL
)
311 xx_strchr (WEdit
* edit
, const unsigned char *s
, int char_byte
)
313 while (*s
>= '\005' && xx_tolower (edit
, *s
) != char_byte
)
316 return (const char *) s
;
319 static struct syntax_rule
320 apply_rules_going_right (WEdit
* edit
, long i
, struct syntax_rule rule
)
322 struct context_rule
*r
;
324 gboolean contextchanged
= FALSE
;
325 gboolean found_left
= FALSE
, found_right
= FALSE
;
326 gboolean keyword_foundleft
= FALSE
, keyword_foundright
= FALSE
;
329 struct syntax_rule _rule
= rule
;
331 c
= xx_tolower (edit
, edit_get_byte (edit
, i
));
334 is_end
= (rule
.end
== (unsigned char) i
);
336 /* check to turn off a keyword */
339 if (edit_get_byte (edit
, i
- 1) == '\n')
344 keyword_foundleft
= TRUE
;
348 /* check to turn off a context */
349 if (_rule
.context
&& !_rule
.keyword
)
353 r
= edit
->rules
[_rule
.context
];
354 if (r
->first_right
== c
&& !(rule
.border
& RULE_ON_RIGHT_BORDER
)
356 compare_word_to_right (edit
, i
, r
->right
, r
->whole_word_chars_left
,
357 r
->whole_word_chars_right
, r
->line_start_right
)) > 0)
361 _rule
.border
= RULE_ON_RIGHT_BORDER
;
362 if (r
->between_delimiters
)
365 else if (is_end
&& rule
.border
& RULE_ON_RIGHT_BORDER
)
367 /* always turn off a context at 4 */
370 if (!keyword_foundleft
)
373 else if (is_end
&& rule
.border
& RULE_ON_LEFT_BORDER
)
375 /* never turn off a context at 2 */
381 /* check to turn on a keyword */
386 r
= edit
->rules
[_rule
.context
];
387 p
= r
->keyword_first_chars
;
390 while (*(p
= xx_strchr (edit
, (unsigned char *) p
+ 1, c
)) != '\0')
396 count
= p
- r
->keyword_first_chars
;
397 k
= r
->keyword
[count
];
398 e
= compare_word_to_right (edit
, i
, k
->keyword
, k
->whole_word_chars_left
,
399 k
->whole_word_chars_right
, k
->line_start
);
404 _rule
.keyword
= count
;
405 keyword_foundright
= TRUE
;
411 /* check to turn on a context */
414 if (!found_left
&& is_end
)
416 if (rule
.border
& RULE_ON_RIGHT_BORDER
)
420 contextchanged
= TRUE
;
424 else if (rule
.border
& RULE_ON_LEFT_BORDER
)
426 r
= edit
->rules
[_rule
._context
];
428 if (r
->between_delimiters
)
430 _rule
.context
= _rule
._context
;
431 contextchanged
= TRUE
;
434 if (r
->first_right
== c
)
438 e
= compare_word_to_right (edit
, i
, r
->right
, r
->whole_word_chars_left
,
439 r
->whole_word_chars_right
,
440 r
->line_start_right
);
445 _rule
.border
= RULE_ON_RIGHT_BORDER
;
456 struct context_rule
**rules
= edit
->rules
;
458 for (count
= 1; rules
[count
]; count
++)
461 if (r
->first_left
== c
)
465 e
= compare_word_to_right (edit
, i
, r
->left
, r
->whole_word_chars_left
,
466 r
->whole_word_chars_right
, r
->line_start_left
);
467 if (e
>= end
&& (!_rule
.keyword
|| keyword_foundright
))
471 _rule
.border
= RULE_ON_LEFT_BORDER
;
472 _rule
._context
= count
;
473 if (!r
->between_delimiters
&& !_rule
.keyword
)
475 _rule
.context
= count
;
476 contextchanged
= TRUE
;
485 /* check again to turn on a keyword if the context switched */
486 if (contextchanged
&& !_rule
.keyword
)
490 r
= edit
->rules
[_rule
.context
];
491 p
= r
->keyword_first_chars
;
493 while (*(p
= xx_strchr (edit
, (unsigned char *) p
+ 1, c
)) != '\0')
499 count
= p
- r
->keyword_first_chars
;
500 k
= r
->keyword
[count
];
501 e
= compare_word_to_right (edit
, i
, k
->keyword
, k
->whole_word_chars_left
,
502 k
->whole_word_chars_right
, k
->line_start
);
506 _rule
.keyword
= count
;
515 static struct syntax_rule
516 edit_get_rule (WEdit
* edit
, long byte_index
)
520 if (byte_index
> edit
->last_get_rule
)
522 for (i
= edit
->last_get_rule
+ 1; i
<= byte_index
; i
++)
524 edit
->rule
= apply_rules_going_right (edit
, i
, edit
->rule
);
526 (edit
->syntax_marker
? edit
->syntax_marker
->offset
+
527 SYNTAX_MARKER_DENSITY
: SYNTAX_MARKER_DENSITY
))
529 struct _syntax_marker
*s
;
531 s
= edit
->syntax_marker
;
532 edit
->syntax_marker
= g_malloc (sizeof (struct _syntax_marker
));
533 edit
->syntax_marker
->next
= s
;
534 edit
->syntax_marker
->offset
= i
;
535 edit
->syntax_marker
->rule
= edit
->rule
;
539 else if (byte_index
< edit
->last_get_rule
)
541 struct _syntax_marker
*s
;
545 if (!edit
->syntax_marker
)
547 memset (&edit
->rule
, 0, sizeof (edit
->rule
));
548 for (i
= -1; i
<= byte_index
; i
++)
549 edit
->rule
= apply_rules_going_right (edit
, i
, edit
->rule
);
552 if (byte_index
>= edit
->syntax_marker
->offset
)
554 edit
->rule
= edit
->syntax_marker
->rule
;
555 for (i
= edit
->syntax_marker
->offset
+ 1; i
<= byte_index
; i
++)
556 edit
->rule
= apply_rules_going_right (edit
, i
, edit
->rule
);
559 s
= edit
->syntax_marker
->next
;
560 g_free (edit
->syntax_marker
);
561 edit
->syntax_marker
= s
;
564 edit
->last_get_rule
= byte_index
;
569 translate_rule_to_color (WEdit
* edit
, struct syntax_rule rule
, int *color
)
571 *color
= edit
->rules
[rule
.context
]->keyword
[rule
.keyword
]->color
;
575 edit_get_syntax_color (WEdit
* edit
, long byte_index
, int *color
)
577 if (!tty_use_colors ())
579 else if (edit
->rules
&& byte_index
< edit
->last_byte
&& option_syntax_highlighting
)
580 translate_rule_to_color (edit
, edit_get_rule (edit
, byte_index
), color
);
582 *color
= EDITOR_NORMAL_COLOR
;
587 Returns 0 on error/eof or a count of the number of bytes read
588 including the newline. Result must be free'd.
589 In case of an error, *line will not be modified.
592 read_one_line (char **line
, FILE * f
)
597 /* not reallocate string too often */
598 p
= g_string_sized_new (64);
617 /* handle all of \r\n, \r, \n correctly. */
630 g_string_append_c (p
, c
);
633 *line
= g_string_free (p
, FALSE
);
635 g_string_free (p
, TRUE
);
678 *p
= SYNTAX_TOKEN_BRACKET
;
682 *p
= SYNTAX_TOKEN_BRACE
;
693 *p
= SYNTAX_TOKEN_STAR
;
696 *p
= SYNTAX_TOKEN_PLUS
;
709 #define whiteness(x) ((x) == '\t' || (x) == '\n' || (x) == ' ')
712 get_args (char *l
, char **args
, int args_size
)
716 while (argc
< args_size
)
719 while (*p
!= '\0' && whiteness (*p
))
723 for (l
= p
+ 1; *l
!= '\0' && !whiteness (*l
); l
++)
727 args
[argc
++] = convert (p
);
729 args
[argc
] = (char *) NULL
;
734 #define break_a {result=line;break;}
735 #define check_a {if(!*a){result=line;break;}}
736 #define check_not_a {if(*a){result=line;break;}}
739 this_try_alloc_color_pair (const char *fg
, const char *bg
)
741 char f
[80], b
[80], *p
;
743 if (bg
!= NULL
&& *bg
== '\0')
745 if (fg
!= NULL
&& *fg
== '\0')
749 g_strlcpy (f
, fg
, sizeof (f
));
757 g_strlcpy (b
, bg
, sizeof (b
));
763 return tty_try_alloc_color_pair (fg
, bg
);
766 static char *error_file_name
= NULL
;
769 open_include_file (const char *filename
)
773 MC_PTR_FREE (error_file_name
);
774 error_file_name
= g_strdup (filename
);
775 if (g_path_is_absolute (filename
))
776 return fopen (filename
, "r");
778 g_free (error_file_name
);
779 error_file_name
= g_strconcat (home_dir
, PATH_SEP_STR EDIT_DIR PATH_SEP_STR
,
780 filename
, (char *) NULL
);
781 f
= fopen (error_file_name
, "r");
785 g_free (error_file_name
);
786 error_file_name
= g_strconcat (mc_home
, PATH_SEP_STR
, "syntax", PATH_SEP_STR
,
787 filename
, (char *) NULL
);
788 f
= fopen (error_file_name
, "r");
792 g_free (error_file_name
);
793 error_file_name
= g_strconcat (mc_home_alt
, PATH_SEP_STR
"syntax" PATH_SEP_STR
,
794 filename
, (char *) NULL
);
796 return fopen (error_file_name
, "r");
800 xx_lowerize_line (WEdit
* edit
, char *line
, size_t len
)
802 if (edit
->is_case_insensitive
)
805 for (i
= 0; i
< len
; ++i
)
806 line
[i
] = tolower (line
[i
]);
810 /* returns line number on error */
812 edit_read_syntax_rules (WEdit
* edit
, FILE * f
, char **args
, int args_size
)
816 char last_fg
[32] = "", last_bg
[32] = "";
817 char whole_right
[512];
818 char whole_left
[512];
820 int save_line
= 0, line
= 0;
821 struct context_rule
**r
, *c
= NULL
;
822 int num_words
= -1, num_contexts
= -1;
826 int alloc_contexts
= MAX_CONTEXTS
,
827 alloc_words_per_context
= MAX_WORDS_PER_CONTEXT
,
828 max_alloc_words_per_context
= MAX_WORDS_PER_CONTEXT
;
831 edit
->is_case_insensitive
= FALSE
;
833 strcpy (whole_left
, "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_01234567890");
834 strcpy (whole_right
, "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_01234567890");
836 r
= edit
->rules
= g_malloc0 (alloc_contexts
* sizeof (struct context_rule
*));
839 edit
->defines
= g_tree_new ((GCompareFunc
) strcmp
);
849 len
= read_one_line (&l
, f
);
857 line
= save_line
+ 1;
858 MC_PTR_FREE (error_file_name
);
860 len
= read_one_line (&l
, f
);
864 xx_lowerize_line (edit
, l
, len
);
873 xx_lowerize_line (edit
, l
, len
);
875 argc
= get_args (l
, args
, args_size
);
881 else if (!strcmp (args
[0], "include"))
889 f
= open_include_file (args
[1]);
892 MC_PTR_FREE (error_file_name
);
899 else if (!strcmp (args
[0], "caseinsensitive"))
901 edit
->is_case_insensitive
= TRUE
;
903 else if (!strcmp (args
[0], "wholechars"))
906 if (!strcmp (*a
, "left"))
909 g_strlcpy (whole_left
, *a
, sizeof (whole_left
));
911 else if (!strcmp (*a
, "right"))
914 g_strlcpy (whole_right
, *a
, sizeof (whole_right
));
918 g_strlcpy (whole_left
, *a
, sizeof (whole_left
));
919 g_strlcpy (whole_right
, *a
, sizeof (whole_right
));
924 else if (!strcmp (args
[0], "context"))
927 if (num_contexts
== -1)
929 if (strcmp (*a
, "default"))
930 { /* first context is the default */
934 c
= r
[0] = g_malloc0 (sizeof (struct context_rule
));
935 c
->left
= g_strdup (" ");
936 c
->right
= g_strdup (" ");
941 /* Terminate previous context. */
942 r
[num_contexts
- 1]->keyword
[num_words
] = NULL
;
943 c
= r
[num_contexts
] = g_malloc0 (sizeof (struct context_rule
));
944 if (!strcmp (*a
, "exclusive"))
947 c
->between_delimiters
= 1;
950 if (!strcmp (*a
, "whole"))
953 c
->whole_word_chars_left
= g_strdup (whole_left
);
954 c
->whole_word_chars_right
= g_strdup (whole_right
);
956 else if (!strcmp (*a
, "wholeleft"))
959 c
->whole_word_chars_left
= g_strdup (whole_left
);
961 else if (!strcmp (*a
, "wholeright"))
964 c
->whole_word_chars_right
= g_strdup (whole_right
);
967 if (!strcmp (*a
, "linestart"))
970 c
->line_start_left
= 1;
973 c
->left
= g_strdup (*a
++);
975 if (!strcmp (*a
, "linestart"))
978 c
->line_start_right
= 1;
981 c
->right
= g_strdup (*a
++);
982 c
->first_left
= *c
->left
;
983 c
->first_right
= *c
->right
;
985 c
->keyword
= g_malloc (alloc_words_per_context
* sizeof (struct key_word
*));
987 c
->keyword
[0] = g_malloc0 (sizeof (struct key_word
));
988 subst_defines (edit
->defines
, a
, &args
[1024]);
995 g_strlcpy (last_fg
, fg
? fg
: "", sizeof (last_fg
));
996 g_strlcpy (last_bg
, bg
? bg
: "", sizeof (last_bg
));
997 c
->keyword
[0]->color
= this_try_alloc_color_pair (fg
, bg
);
998 c
->keyword
[0]->keyword
= g_strdup (" ");
1001 alloc_words_per_context
= MAX_WORDS_PER_CONTEXT
;
1002 if (++num_contexts
>= alloc_contexts
)
1004 struct context_rule
**tmp
;
1006 alloc_contexts
+= 128;
1007 tmp
= g_realloc (r
, alloc_contexts
* sizeof (struct context_rule
*));
1011 else if (!strcmp (args
[0], "spellcheck"))
1020 else if (!strcmp (args
[0], "keyword"))
1024 if (num_words
== -1)
1027 k
= r
[num_contexts
- 1]->keyword
[num_words
] = g_malloc0 (sizeof (struct key_word
));
1028 if (!strcmp (*a
, "whole"))
1031 k
->whole_word_chars_left
= g_strdup (whole_left
);
1032 k
->whole_word_chars_right
= g_strdup (whole_right
);
1034 else if (!strcmp (*a
, "wholeleft"))
1037 k
->whole_word_chars_left
= g_strdup (whole_left
);
1039 else if (!strcmp (*a
, "wholeright"))
1042 k
->whole_word_chars_right
= g_strdup (whole_right
);
1045 if (!strcmp (*a
, "linestart"))
1051 if (!strcmp (*a
, "whole"))
1055 k
->keyword
= g_strdup (*a
++);
1056 k
->first
= *k
->keyword
;
1057 subst_defines (edit
->defines
, a
, &args
[1024]);
1068 k
->color
= this_try_alloc_color_pair (fg
, bg
);
1071 if (++num_words
>= alloc_words_per_context
)
1073 struct key_word
**tmp
;
1075 alloc_words_per_context
+= 1024;
1077 if (alloc_words_per_context
> max_alloc_words_per_context
)
1078 max_alloc_words_per_context
= alloc_words_per_context
;
1080 tmp
= g_realloc (c
->keyword
, alloc_words_per_context
* sizeof (struct key_word
*));
1084 else if (*(args
[0]) == '#')
1086 /* do nothing for comment */
1088 else if (!strcmp (args
[0], "file"))
1092 else if (!strcmp (args
[0], "define"))
1099 argv
= g_tree_lookup (edit
->defines
, key
);
1101 mc_defines_destroy (NULL
, argv
, NULL
);
1103 key
= g_strdup (key
);
1105 argv
= g_new (char *, argc
- 1);
1106 g_tree_insert (edit
->defines
, key
, argv
);
1109 *argv
++ = g_strdup (*a
++);
1114 { /* anything else is an error */
1123 /* Terminate context array. */
1124 if (num_contexts
> 0)
1126 r
[num_contexts
- 1]->keyword
[num_words
] = NULL
;
1127 r
[num_contexts
] = NULL
;
1130 if (!edit
->rules
[0])
1131 MC_PTR_FREE (edit
->rules
);
1136 if (num_contexts
== -1)
1142 char *first_chars
, *p
;
1144 first_chars
= g_malloc0 (max_alloc_words_per_context
+ 2);
1146 for (i
= 0; edit
->rules
[i
]; i
++)
1151 for (j
= 1; c
->keyword
[j
]; j
++)
1152 *p
++ = c
->keyword
[j
]->first
;
1154 c
->keyword_first_chars
= g_strdup (first_chars
);
1157 g_free (first_chars
);
1164 edit_free_syntax_rules (WEdit
* edit
)
1171 destroy_defines (&edit
->defines
);
1175 edit_get_rule (edit
, -1);
1176 MC_PTR_FREE (edit
->syntax_type
);
1178 for (i
= 0; edit
->rules
[i
]; i
++)
1180 if (edit
->rules
[i
]->keyword
)
1182 for (j
= 0; edit
->rules
[i
]->keyword
[j
]; j
++)
1184 MC_PTR_FREE (edit
->rules
[i
]->keyword
[j
]->keyword
);
1185 MC_PTR_FREE (edit
->rules
[i
]->keyword
[j
]->whole_word_chars_left
);
1186 MC_PTR_FREE (edit
->rules
[i
]->keyword
[j
]->whole_word_chars_right
);
1187 MC_PTR_FREE (edit
->rules
[i
]->keyword
[j
]);
1190 MC_PTR_FREE (edit
->rules
[i
]->left
);
1191 MC_PTR_FREE (edit
->rules
[i
]->right
);
1192 MC_PTR_FREE (edit
->rules
[i
]->whole_word_chars_left
);
1193 MC_PTR_FREE (edit
->rules
[i
]->whole_word_chars_right
);
1194 MC_PTR_FREE (edit
->rules
[i
]->keyword
);
1195 MC_PTR_FREE (edit
->rules
[i
]->keyword_first_chars
);
1196 MC_PTR_FREE (edit
->rules
[i
]);
1199 while (edit
->syntax_marker
)
1201 struct _syntax_marker
*s
= edit
->syntax_marker
->next
;
1202 g_free (edit
->syntax_marker
);
1203 edit
->syntax_marker
= s
;
1206 MC_PTR_FREE (edit
->rules
);
1207 tty_color_free_all_tmp ();
1210 /* returns -1 on file error, line number on error in file syntax */
1212 edit_read_syntax_file (WEdit
* edit
, char ***pnames
, const char *syntax_file
,
1213 const char *editor_file
, const char *first_line
, const char *type
)
1217 char *args
[1024], *l
= NULL
;
1222 gboolean found
= FALSE
;
1223 char **tmpnames
= NULL
;
1225 f
= fopen (syntax_file
, "r");
1228 lib_file
= concat_dir_and_file (mc_home
, "Syntax");
1229 f
= fopen (lib_file
, "r");
1240 if (read_one_line (&l
, f
) == 0)
1242 (void) get_args (l
, args
, 1023); /* Final NULL */
1243 if (args
[0] == NULL
)
1246 /* Looking for `include ...` lines before first `file ...` ones */
1247 if (!found
&& strcmp (args
[0], "include") == 0)
1252 if (!args
[1] || !(g
= open_include_file (args
[1])))
1260 /* looking for `file ...' lines only */
1261 if (strcmp (args
[0], "file") != 0)
1266 /* must have two args or report error */
1267 if (!args
[1] || !args
[2])
1272 if (pnames
&& *pnames
)
1274 /* 1: just collecting a list of names of rule sets */
1275 /* Reallocate the list if required */
1276 if (count
% NENTRIES
== 0)
1279 (char **) g_try_realloc (*pnames
, (count
+ NENTRIES
+ 1) * sizeof (char *));
1280 if (tmpnames
== NULL
)
1284 (*pnames
)[count
++] = g_strdup (args
[2]);
1285 (*pnames
)[count
] = NULL
;
1289 /* 2: rule set was explicitly specified by the caller */
1290 if (strcmp (type
, args
[2]) == 0)
1293 else if (editor_file
&& edit
)
1295 /* 3: auto-detect rule set from regular expressions */
1298 q
= mc_search (args
[1], editor_file
, MC_SEARCH_T_REGEX
);
1299 /* does filename match arg 1 ? */
1302 /* does first line match arg 3 ? */
1303 q
= mc_search (args
[3], first_line
, MC_SEARCH_T_REGEX
);
1310 syntax_type
= args
[2];
1311 line_error
= edit_read_syntax_rules (edit
, g
? g
: f
, args
, 1023);
1314 if (!error_file_name
) /* an included file */
1315 result
= line
+ line_error
;
1317 result
= line_error
;
1321 MC_PTR_FREE (edit
->syntax_type
);
1322 edit
->syntax_type
= g_strdup (syntax_type
);
1323 /* if there are no rules then turn off syntax highlighting for speed */
1324 if (!g
&& !edit
->rules
[1])
1325 if (!edit
->rules
[0]->keyword
[1] && !edit
->rules
[0]->spelling
)
1327 edit_free_syntax_rules (edit
);
1346 get_first_editor_line (WEdit
* edit
)
1355 for (i
= 0; i
< sizeof (s
) - 1; i
++)
1357 s
[i
] = edit_get_byte (edit
, i
);
1364 s
[sizeof (s
) - 1] = '\0';
1369 * Load rules into edit struct. Either edit or *pnames must be NULL. If
1370 * edit is NULL, a list of types will be stored into names. If type is
1371 * NULL, then the type will be selected according to the filename.
1374 edit_load_syntax (WEdit
* edit
, char ***pnames
, const char *type
)
1379 if (option_auto_syntax
)
1382 edit_free_syntax_rules (edit
);
1384 if (!tty_use_colors ())
1387 if (!option_syntax_highlighting
&& (!pnames
|| !*pnames
))
1392 if (!edit
->filename
)
1394 if (!*edit
->filename
&& !type
)
1397 f
= concat_dir_and_file (home_dir
, EDIT_SYNTAX_FILE
);
1398 r
= edit_read_syntax_file (edit
, pnames
, f
, edit
? edit
->filename
: 0,
1399 get_first_editor_line (edit
), type
);
1402 edit_free_syntax_rules (edit
);
1403 message (D_ERROR
, _("Load syntax file"),
1404 _("Cannot open file %s\n%s"), f
, unix_error_string (errno
));
1408 edit_free_syntax_rules (edit
);
1409 message (D_ERROR
, _("Load syntax file"),
1410 _("Error in file %s on line %d"), error_file_name
? error_file_name
: f
, r
);
1411 MC_PTR_FREE (error_file_name
);
1418 edit_get_syntax_type (const WEdit
* edit
)
1420 return edit
->syntax_type
;