| blob | f64ad5671f07dff77bae621d15c527aa8aac621c |
1 ---
4 ---
6 doc/help.etx | 258 +
7 source/Makefile.common | 4
8 source/Makefile.dependencies | 11
9 source/highlightData.c | 13
10 source/macro.c | 107
11 source/menu.c | 65
12 source/nedit.h | 6
13 source/patternMatch.c | 2202 ++++++++++++
14 source/patternMatch.h | 170
15 source/patternMatchData.c | 7780 +++++++++++++++++++++++++++++++++++++++++++
16 source/patternMatchData.h | 24
17 source/preferences.c | 170
18 source/preferences.h | 4
19 source/search.c | 231 -
20 source/smartIndent.c | 7
21 source/window.c | 18
22 16 files changed, 10773 insertions(+), 297 deletions(-)
24 diff --quilt old/doc/help.etx new/doc/help.etx
25 --- old/doc/help.etx
26 +++ new/doc/help.etx
27 @@ -867,12 +867,13 @@ Programming with NEdit
28 ----------------------
30 Though general in appearance, NEdit has many features intended specifically
31 for programmers. Major programming-related topics are listed in separate
32 sections under the heading: "Features for Programming": Syntax_Highlighting_,
33 - Tabs/Emulated_Tabs_, Finding_Declarations_(ctags)_, Calltips_, and
34 - Auto/Smart_Indent_. Minor topics related to programming are discussed below:
35 + Tabs/Emulated_Tabs_, Matching_Parentheses_, Finding_Declarations_(ctags)_,
36 + Calltips_, and Auto/Smart_Indent_. Minor topics related to programming are
37 + discussed below:
39 3>Language Modes
41 When NEdit initially reads a file, it attempts to determine whether the file
42 is in one of the computer languages that it knows about. Knowing what language
43 @@ -926,30 +927,10 @@ Programming with NEdit
44 Search menu and enter a line number and a column number separated by a
45 comma. (e.g. Enter "100,12" for line 100 column 12.) If you want to go to
46 a column on the current line just leave out the line number. (e.g. Enter
47 ",45" to go the column 45 on the current line.)
49 -3>Matching Parentheses
50 -
51 - To help you inspect nested parentheses, brackets, braces, quotes, and other
52 - characters, NEdit has both an automatic parenthesis matching mode, and a Goto
53 - Matching command. Automatic parenthesis matching is activated when you type,
54 - or move the insertion cursor after a parenthesis, bracket, or brace. It
55 - momentarily highlights either the opposite character ('Delimiter') or the
56 - entire expression ('Range') when the opposite character is visible in the
57 - window. To find a matching character anywhere in the file, select it or
58 - position the cursor after it, and choose Goto Matching from the Search menu.
59 - If the character matches itself, such as a quote or slash, select the first
60 - character of the pair. NEdit will match {, (, [, <, ", ', `, /, and \.
61 - Holding the Shift key while typing the accelerator key (Shift+Ctrl+M, by
62 - default), will select all of the text between the matching characters.
63 -
64 - When syntax highlighting is enabled, the matching routines can optionally
65 - make use of the syntax information for improved accuracy. In that case,
66 - a brace inside a highlighted string will not match a brace inside a comment,
67 - for instance.
68 -
69 3>Opening Included Files
71 The Open Selected command in the File menu understands the C preprocessor's
72 #include syntax, so selecting an #include line and invoking Open Selected will
73 generally find the file referred to, unless doing so depends on the settings of
74 @@ -1223,10 +1204,43 @@ Syntax Highlighting
75 is scrolled in to view. Depending on your system, and the highlight patterns
76 you are using, this may or may not be noticeable. A typing delay is also
77 possible, but unlikely if you are only using the built-in patterns.
78 ----------------------------------------------------------------------
80 +Matching Parentheses
81 +--------------------
82 +
83 +3>Matching Parentheses (Patterns)
84 +
85 + To help you inspect nested parentheses (e.g. brackets, braces, quotes
86 + etc.) or nested constructs (e.g. "begin" .. "end"), NEdit has both an
87 + automatic parenthesis matching mode, and a Goto Matching command.
88 +
89 + A matching pattern can be a single character (like '(', ')'), a literal
90 + string (like '#ifdef', '#endif') or a regular expression (like
91 + '\</.*\>').
92 +
93 + Automatic parenthesis matching is activated when you type, or move the
94 + insertion cursor after a parenthesis, bracket, or brace. It momentarily
95 + highlights either the opposite pattern ('Delimiter') or the entire expression
96 + ('Range') when the opposite pattern is visible in the window. To find a
97 + matching pattern anywhere in the file, select it or position the cursor after
98 + it, and choose Goto Matching from the Search menu. If the pattern matches
99 + itself, such as a quote or slash, select the first pattern of the pair.
100 + Holding the Shift key while typing the accelerator key (Shift+Ctrl+M, by
101 + default), will select all of the text between the matching patterns.
102 +
103 + When syntax highlighting is enabled, the matching routines can optionally
104 + make use of the syntax information for improved accuracy. In that case,
105 + a brace inside a highlighted string will not match a brace inside a comment,
106 + for instance.
107 +
108 + Matching patterns are language dependent. Matching patterns can be
109 + configured by the user. If no matching patterns are available for the
110 + language that you want to use, you can create new patterns relatively quickly.
111 + The Help section "Matching_Patterns_" under "Customizing", has details.
112 +
113 Finding Declarations (ctags)
114 ----------------------------
116 NEdit can process tags files generated using the Unix _ctags command or the
117 Exuberant Ctags program. Ctags creates index files correlating names of
118 @@ -2581,13 +2595,10 @@ Macro Subroutines
120 **$show_matching**
121 Contains the current preference for showing matching pairs,
122 such as "[]" and "{}" pairs. Can be "off", "delimiter", or "range".
124 -**$match_syntax_based**
125 - Whether pair matching should use syntax information, if available.
126 -
127 **$statistics_line**
128 Has a value of 1 if the statistics line is shown, otherwise 0.
130 **$sub_sep**
131 Contains the value of the array sub-script separation string.
132 @@ -2698,10 +2709,19 @@ Macro Subroutines
134 **get_character( position )**
135 Returns the single character at the position indicated by the first argument
136 to the routine from the current window.
138 +**get_matching( position )**
139 + Find a matching pattern string related to the given position.
140 + Returns info about matching pattern within an array. The array has
141 + the following keys: **pos** (position of the first character of the
142 + matching pattern), **len** (length of the matching pattern), **direction**
143 + (direction where the matching pattern was found: ~0~ = forward;
144 + ~1~ = backward). If no matching pattern was found, then array element
145 + of **pos** holds ~-1~, **len** holds ~0~ and **direction** holds ~-1~.
146 +
147 **get_range( start, end )**
148 Returns the text between a starting and ending position from the current
149 window.
151 **get_selection()**
152 @@ -3416,13 +3436,10 @@ Action Routines
153 If no parameters are supplied the option is toggled.
155 **set_show_matching( "off" | "delimiter" | "range" )**
156 Set show matching (...) mode for the current window.
158 -**set_match_syntax_based( [0 | 1] )**
159 - Set whether matching should be syntax based for the current window.
160 -
161 **set_statistics_line( [0 | 1] )**
162 Show or hide the statistics line for the current window.
163 A value of 0 turns it off and a value of 1 turns it on.
164 If no parameters are supplied the option is toggled.
166 @@ -3934,14 +3951,10 @@ Preferences
167 range between them, when one of these characters is typed, or when the
168 insertion cursor is positioned after it. Delimiter only highlights the
169 matching delimiter, while Range highlights the whole range of text between
170 the matching delimiters.
172 - Optionally, the matching can make use of syntax information if syntax
173 - highlighting is enabled. Alternatively, the matching is purely character
174 - based. In general, syntax based matching results in fewer false matches.
175 -
176 **Overtype**
177 In overtype mode, new characters entered replace the characters in front of
178 the insertion cursor, rather than being inserted before them.
180 **Read Only**
181 @@ -5044,10 +5057,189 @@ Smart Indent Macros
182 before the character is inserted into the buffer. You can do just about
183 anything here, but keep in mind that this macro is executed for every
184 keystroke typed, so if you try to get too fancy, you may degrade performance.
185 ----------------------------------------------------------------------
187 +Matching Patterns
188 +-----------------
189 +
190 +3>Writing Matching Pattern Sets
191 +
192 + Matching Patterns Sets are groups of single characters (like '(', ')'),
193 + literal strings (like '#ifdef', '#endif') or a regular expressions (like
194 + '\</.*\>'), which match to each other.
195 +
196 + Examples: An open bracket '(' belongs a closing one ')'.
197 + Or: '#ifdef'(start), '#ifndef'(alternative start), '#ifndef' (another
198 + alternative start),'#elif' (optional), '#else' (optional), '#endif' (end)
199 + define a "#ifdef statement matching pattern".
200 +
201 + "Opposite pattern highlighting" or "Goto Matching" features are implemented
202 + in NEdit using this matching pattern sets (see Matching_Parentheses_ under
203 + the heading of Features for Programming).
204 +
205 + During definition of a new language mode a standard matching pattern set
206 + is assigned to this new language mode.
207 +
208 + To modify a matching pattern set, select "Matching Patterns ..." from
209 + "Show Matching (..)" sub-section of the "Default Settings" sub-menu
210 + of the "Preferences" menu.
211 +
212 + A matching pattern set is a collection of matching patterns.
213 +
214 + A matching pattern usually consists out of string patterns.
215 +
216 + The name of a matching pattern set needs to be defined within field "Matching
217 + Pattern Name".
218 +
219 +4>Attributes of matching pattern
220 +
221 + A matching pattern holds two types of attributes:
222 +
223 +* "Matching Pattern Type" and
224 +* "Global Attributes"
225 +
226 + The matching pattern type specifies the kind of the matching pattern
227 + entry:
228 +
229 +* "Individual" or
230 +* "Sub-pattern" or
231 +* "Context group"
232 +
233 + Each matching pattern can be defined as "Individual" or as "Sub-pattern".
234 + A "Sub-pattern" belongs to a context group. A context group is simply a
235 + collection of sub-patterns.
236 +
237 + During search for a corresponding pattern, an "Individual" matching pattern
238 + does not care about nesting of other matching patterns.
239 +
240 + If a matching pattern out of a "Context group" is searched, then all
241 + sub-pattern sets defined in this group are taken into account during the
242 + search.
243 +
244 + In fact, "Individual" matching pattern search is faster than "Context group" /
245 + "Sub-pattern" search. "Context group" / "Sub-pattern" search results in fewer
246 + false matches.
247 +
248 + To define a context group, set "Matching Pattern Type" to "Context group".
249 + Select out of "Sub-Pattern Name" pop-up field all sub-patterns, which
250 + should be placed into this group. **Note**: all "Sub-pattern" used by a context
251 + group must be defined **before** the context group itself.
252 +
253 + "Global Attributes" of a matching pattern are
254 +
255 +* "Skip content between start / end pattern"
256 +* "Flash matching pattern"
257 +* "Syntax based"
258 +
259 + If "Skip content between start / end pattern" is checked, then all text
260 + between the first / last string pattern of the related matching pattern is
261 + not scanned for other string patterns. This is useful for specifying comments.
262 +
263 + "Flash matching pattern" indicates, if the string patterns are flashed during
264 + typing. If not checked, then only the "Goto Matching" feature works for the
265 + related matching pattern. Note: if lots of "Flash matching pattern" are
266 + specified, then this may slow down the performance of NEdit: after each
267 + character typed all "Flash matching pattern" are scanned for being
268 + applicable ...
269 +
270 + "Syntax based" defines, if the matching pattern can make use of syntax
271 + information if syntax highlighting is enabled. Alternatively, the matching is
272 + purely character based. In general, syntax based matching results in fewer
273 + false matches.
274 +
275 +4>Content of matching pattern
276 +
277 + An "Individual" pattern or a "Sub-pattern" may consist out of only one string
278 + pattern (e.g. double quotes '"'). Such a pattern is called "mono pattern".
279 + You can imagine, that a match for a mono pattern is hard to find. A matching
280 + mono pattern search is always started in forward direction. If no match is
281 + found in forward direction, a backward search is started. If the "Global
282 + Attribute" "Syntax based" is selected for a mono pattern, then the character
283 + before / after the match is checked to have the same highlighting style than
284 + the pattern itself. This may help to determine the correct match for a mono
285 + pattern.
286 +
287 + Usually a matching pattern holds two string patterns (e.g. 'begin' and
288 + 'end'). One ('begin') is the start pattern. The other one ('end') is the
289 + end pattern. If the cursor is located behind the start pattern, then a
290 + corresponding end pattern is searched (in forward direction). If the
291 + cursor is located behind the end pattern, then a start pattern is search
292 + (in backward direction):
293 +
294 +! +--> start ---> end --+
295 +! +-----------<---------+
296 +
297 + Alternative start / end patterns can be defined. In this case one of the
298 + start / end patterns must be in front of the cursor to detect one of the
299 + related end / start patterns:
300 +
301 +! +-> start1 -+ +-> end1 -+
302 +! +-+-> start2 -+---+ +--+
303 +! + +-> start3 -+ +-> end2 -+ |
304 +! +---------------<-------------+
305 +
306 + At least also "middle" patterns can be defined (e.g. middle patterns
307 + 'elif' or 'else'). If the cursor is located behind a middle pattern then a
308 + next middle pattern or the end pattern is searched in forward direction:
309 +
310 +! +-----<-----+
311 +! +--> start -+-> middle -+-> end --+
312 +! +-----------<---------------------+
313 +
314 +4>String pattern
315 +
316 + A string pattern holds three attributes:
317 +
318 +* "String Pattern Type"
319 +* "Word Boundary"
320 +* "String Attributes"
321 +
322 + String Pattern Type specifies if the related string pattern is
323 + a "start", middle, or "end" pattern (see above).
324 +
325 + Word boundary defines, if before / after a string pattern a delimiter must be
326 + located ("Both" = pattern is framed by delimiters. "Left" = before pattern
327 + must be a delimiter. "Right" = after pattern must be a delimiter. "None" =
328 + there must be no delimiter before or after pattern).
329 +
330 + There are two "String Attributes":
331 +
332 +* "Case Sensitive"
333 +* "Regular Expression"
334 +
335 + If "Case Sensitive" is checked (= default), then the matching pattern search
336 + concerning this string pattern differs between upper / lower case of the
337 + characters. If "Case Sensitive" is not set, then the case of the checked
338 + characters is not considered.
339 +
340 + "Regular Expression" indicates, that string pattern is treated as
341 + regular expression (if "Regular Expression" is checked) or as literal
342 + string (if "Regular Expression" is not checked).
343 +
344 +4>Regular Expression String Pattern
345 +
346 + Syntax of regular expression is described by NEdit Help menu item
347 + Regular_Expressions_. Following deviations from this syntax are
348 + existing concerning string patterns:
349 +
350 +5>Capturing Parentheses
351 +
352 + Capturing Parentheses inside string patterns are of the form `(*n<regex>)',
353 + where n = 1 .. 9. Standard "capturing parentheses" of form `(<regex>)' are
354 + treated as "non-capturing parentheses" by the matching pattern feature.
355 + "n" defines the **global** backreference number, which can be used inside any string
356 + pattern of the same matching pattern (= set of string patterns). So
357 + matching patterns like "\<(*1[^/>])\>" (start string pattern) and "\</\1\>"
358 + (end string pattern) are possible. This matching pattern will match e.g.
359 + <body> .. </body> but will not match <body> .. </head>.
360 +
361 +5>Non-Capturing Parentheses
362 +
363 + As described above: parentheses constructs like (<regex>) are treated
364 + as `(?:<regex>)' (non-capturing parentheses) by the matching pattern feature.
365 +
366 NEdit Command Line
367 ------------------
369 .. ? help !!#ifndef VMS
370 **nedit** [-**read**] [-**create**] [-**line** n | +n] [-**server**]
371 @@ -6074,10 +6266,11 @@ Problems/Defects
372 .. Menu: Features for Programming # features
373 .. Menu: Programming with NEdit # programmer
374 .. Menu: Tabs/Emulated Tabs # tabs
375 .. Menu: Auto/Smart Indent # indent
376 .. Menu: Syntax Highlighting # syntax
377 +.. Menu: Matching Parentheses # pattern_matching
378 .. Menu: Finding Declarations (ctags) # tags
379 .. Menu: Calltips # calltips
381 .. Menu: Regular Expressions # regex
382 .. Menu: Basic Regular Expression Syntax # basicSyntax
383 @@ -6101,10 +6294,11 @@ Problems/Defects
384 .. Menu: Preferences # preferences
385 .. Menu: X Resources # resources
386 .. Menu: Key Binding # binding
387 .. Menu: Highlighting Patterns # patterns
388 .. Menu: Smart Indent Macros # smart_indent
389 +.. Menu: Matching Patterns # matching_patterns
391 .. Menu: NEdit Command Line # command_line
392 .. Menu: Client/Server Mode # server
393 .. Menu: Cr_a_sh Recovery # recovery
394 .. Menu: ---------------------------------- # separator1
395 diff --quilt old/source/Makefile.common new/source/Makefile.common
396 --- old/source/Makefile.common
397 +++ new/source/Makefile.common
398 @@ -7,10 +7,11 @@ OBJS = nedit.o file.o menu.o window.o se
399 help.o preferences.o tags.o userCmds.o shell.o regularExp.o macro.o \
400 text.o textSel.o textDisp.o textBuf.o textDrag.o server.o highlight.o \
401 highlightData.o interpret.o parse.o smartIndent.o regexConvert.o \
402 rbTree.o windowTitle.o calltips.o server_common.o rangeset.o
403 OBJS += backup.o
404 +OBJS += patternMatch.o patternMatchData.o
406 XLTLIB = ../Xlt/libXlt.a
407 XMLLIB = ../Microline/XmL/libXmL.a
409 .c.o:
410 @@ -36,10 +37,13 @@ smartIndent.o: smartIndent.c
411 $(CC) $(CFLAGS) $(BIGGER_STRINGS) -c smartIndent.c -o $@
413 highlightData.o: highlightData.c
414 $(CC) $(CFLAGS) $(BIGGER_STRINGS) -c highlightData.c -o $@
416 +patternMatchData.o: patternMatchData.c
417 + $(CC) $(CFLAGS) $(BIGGER_STRINGS) -c patternMatchData.c -o $@
418 +
419 help_topic.h help_data.h: ../doc/help.etx
420 (cd ..; $(MAKE) docs)
422 clean:
423 rm -f $(OBJS) nedit nc nc.o parse.c linkdate.o
424 diff --quilt old/source/Makefile.dependencies new/source/Makefile.dependencies
425 --- old/source/Makefile.dependencies
426 +++ new/source/Makefile.dependencies
427 @@ -84,5 +84,16 @@ window.o: window.c window.h nedit.h text
428 ../util/fileUtils.h ../util/utils.h
429 windowTitle.o: windowTitle.c windowTitle.h nedit.h textBuf.h \
430 preferences.h help.h help_topic.h ../util/prefFile.h ../util/misc.h \
431 ../util/DialogF.h ../util/utils.h ../util/fileUtils.h \
432 ../util/clearcase.h
433 +patternMatch.o: patternMatch.c regularExp.h \
434 + textBuf.h search.h window.h preferences.h highlight.h\
435 + patternMatch.h patternMatchData.h
436 +patternMatchData.o: patternMatchData.c ../util/DialogF.h ../util/misc.h \
437 + ../util/managedList.h regularExp.h textBuf.h nedit.h window.h \
438 + preferences.h help.h file.h textP.h patternMatch.h patternMatchData.h
439 +macro.o: patternMatch.h regularExp.h
440 +menu.o: patternMatchData.h
441 +preferences.o: patternMatchData.h
442 +search.o: patternMatch.h
443 +window.o: patternMatchData.h
444 diff --quilt old/source/highlightData.c new/source/highlightData.c
445 --- old/source/highlightData.c
446 +++ new/source/highlightData.c
447 @@ -549,11 +549,11 @@ static char *DefaultPatternSets[] = {
448 README:\"NEdit Macro syntax highlighting patterns, version 2.6, maintainer Thorsten Haude, nedit at thorstenhau.de\":::Flag::D\n\
449 Comment:\"#\":\"$\"::Comment::\n\
450 Built-in Misc Vars:\"(?<!\\Y)\\$(?:active_pane|args|calltip_ID|column|cursor|display_width|empty_array|file_name|file_path|language_mode|line|locked|max_font_width|min_font_width|modified|n_display_lines|n_panes|rangeset_list|read_only|selection_(?:start|end|left|right)|server_name|text_length|top_line|transient|VERSION|NEDIT_HOME)>\":::Identifier::\n\
451 Built-in Pref Vars:\"(?<!\\Y)\\$(?:auto_indent|em_tab_dist|file_format|font_name|font_name_bold|font_name_bold_italic|font_name_italic|highlight_syntax|incremental_backup|incremental_search_line|make_backup_copy|match_syntax_based|overtype_mode|show_line_numbers|show_matching|statistics_line|tab_dist|use_tabs|wrap_margin|wrap_text)>\":::Identifier2::\n\
452 Built-in Special Vars:\"(?<!\\Y)\\$(?:[1-9]|list_dialog_button|n_args|read_status|search_end|shell_cmd_status|string_dialog_button|sub_sep)>\":::String1::\n\
453 - Built-in Subrs:\"<(?:append_file|beep|call|calltip|clipboard_to_string|dialog|filename_dialog|focus_window|get_character|get_pattern_(by_name|at_pos)|get_range|get_selection|get_style_(by_name|at_pos)|getenv|highlight_calltip_line|kill_calltip|length|list_dialog|max|min|rangeset_(?:add|create|destroy|get_by_name|includes|info|invert|range|set_color|set_mode|set_name|subtract)|read_file|replace_in_string|replace_range|replace_selection|replace_substring|search|search_string|select|select_rectangle|set_cursor_pos|set_transient|shell_command|split|string_compare|string_dialog|string_to_clipboard|substring|t_print|tolower|toupper|typeof|valid_number|write_file)(?=\\s*\\()\":::Subroutine::\n\
454 + Built-in Subrs:\"<(?:append_file|beep|call|calltip|clipboard_to_string|dialog|filename_dialog|focus_window|get_character|get_pattern_(by_name|at_pos)|get_range|get_selection|get_style_(by_name|at_pos)|getenv|highlight_calltip_line|kill_calltip|length|list_dialog|max|min|rangeset_(?:add|create|destroy|get_by_name|includes|info|invert|range|set_color|set_mode|set_name|subtract)|read_file|replace_in_string|replace_range|replace_selection|replace_substring|search|search_string|select|select_rectangle|set_cursor_pos|get_matching|set_transient|shell_command|split|string_compare|string_dialog|string_to_clipboard|substring|t_print|tolower|toupper|typeof|valid_number|write_file)(?=\\s*\\()\":::Subroutine::\n\
455 Menu Actions:\"<(?:new(?:_tab|_opposite)?|open|open-dialog|open_dialog|open-selected|open_selected|close|save|save-as|save_as|save-as-dialog|save_as_dialog|revert-to-saved|revert_to_saved|revert_to_saved_dialog|include-file|include_file|include-file-dialog|include_file_dialog|load-macro-file|load_macro_file|load-macro-file-dialog|load_macro_file_dialog|load-tags-file|load_tags_file|load-tags-file-dialog|load_tags_file_dialog|unload_tags_file|load_tips_file|load_tips_file_dialog|unload_tips_file|print|print-selection|print_selection|exit|undo|redo|delete|select-all|select_all|shift-left|shift_left|shift-left-by-tab|shift_left_by_tab|shift-right|shift_right|shift-right-by-tab|shift_right_by_tab|find|find-dialog|find_dialog|find-again|find_again|find-selection|find_selection|find_incremental|start_incremental_find|replace|replace-dialog|replace_dialog|replace-all|replace_all|replace-in-selection|replace_in_selection|replace-again|replace_again|replace_find|replace_find_same|replace_find_again|goto-line-number|goto_line_number|goto-line-number-dialog|goto_line_number_dialog|goto-selected|goto_selected|mark|mark-dialog|mark_dialog|goto-mark|goto_mark|goto-mark-dialog|goto_mark_dialog|match|select_to_matching|goto_matching|find-definition|find_definition|show_tip|split-pane|split_pane|close-pane|close_pane|detach_document(?:_dialog)?|move_document_dialog|(?:next|previous|last)_document|uppercase|lowercase|fill-paragraph|fill_paragraph|control-code-dialog|control_code_dialog|filter-selection-dialog|filter_selection_dialog|filter-selection|filter_selection|execute-command|execute_command|execute-command-dialog|execute_command_dialog|execute-command-line|execute_command_line|shell-menu-command|shell_menu_command|macro-menu-command|macro_menu_command|bg_menu_command|post_window_bg_menu|post_tab_context_menu|beginning-of-selection|beginning_of_selection|end-of-selection|end_of_selection|repeat_macro|repeat_dialog|raise_window|focus_pane|set_statistics_line|set_incremental_search_line|set_show_line_numbers|set_auto_indent|set_wrap_text|set_wrap_margin|set_highlight_syntax|set_make_backup_copy|set_incremental_backup|set_show_matching|set_match_syntax_based|set_overtype_mode|set_locked|set_tab_dist|set_em_tab_dist|set_use_tabs|set_fonts|set_language_mode)(?=\\s*\\()\":::Subroutine::\n\
456 Text Actions:\"<(?:self-insert|self_insert|grab-focus|grab_focus|extend-adjust|extend_adjust|extend-start|extend_start|extend-end|extend_end|secondary-adjust|secondary_adjust|secondary-or-drag-adjust|secondary_or_drag_adjust|secondary-start|secondary_start|secondary-or-drag-start|secondary_or_drag_start|process-bdrag|process_bdrag|move-destination|move_destination|move-to|move_to|move-to-or-end-drag|move_to_or_end_drag|end_drag|copy-to|copy_to|copy-to-or-end-drag|copy_to_or_end_drag|exchange|process-cancel|process_cancel|paste-clipboard|paste_clipboard|copy-clipboard|copy_clipboard|cut-clipboard|cut_clipboard|copy-primary|copy_primary|cut-primary|cut_primary|newline|newline-and-indent|newline_and_indent|newline-no-indent|newline_no_indent|delete-selection|delete_selection|delete-previous-character|delete_previous_character|delete-next-character|delete_next_character|delete-previous-word|delete_previous_word|delete-next-word|delete_next_word|delete-to-start-of-line|delete_to_start_of_line|delete-to-end-of-line|delete_to_end_of_line|forward-character|forward_character|backward-character|backward_character|key-select|key_select|process-up|process_up|process-down|process_down|process-shift-up|process_shift_up|process-shift-down|process_shift_down|process-home|process_home|forward-word|forward_word|backward-word|backward_word|forward-paragraph|forward_paragraph|backward-paragraph|backward_paragraph|beginning-of-line|beginning_of_line|end-of-line|end_of_line|beginning-of-file|beginning_of_file|end-of-file|end_of_file|next-page|next_page|previous-page|previous_page|page-left|page_left|page-right|page_right|toggle-overstrike|toggle_overstrike|scroll-up|scroll_up|scroll-down|scroll_down|scroll_left|scroll_right|scroll-to-line|scroll_to_line|select-all|select_all|deselect-all|deselect_all|focusIn|focusOut|process-return|process_return|process-tab|process_tab|insert-string|insert_string|mouse_pan)(?=\\s*\\()\":::Subroutine::\n\
457 Macro Hooks:\"<(?:post_open|pre_open|post_save|cursor_moved|modified|focus|losing_focus)_hook(?=\\s*\\()\":::Subroutine1::\n\
458 Keyword:\"<(?:break|continue|define|delete|else|for|if|in|return|while)>\":::Keyword::\n\
459 Braces:\"[{}\\[\\]]\":::Keyword::\n\
460 @@ -2342,12 +2342,13 @@ void EditHighlightPatterns(WindowInfo *w
461 XmNtopPosition, 1,
462 XmNrightAttachment, XmATTACH_POSITION,
463 XmNrightPosition, 99,
464 NULL);
466 + /* Pattern Match Feature: don't include "PLAIN" (4th parameter) */
467 HighlightDialog.lmPulldown = CreateLanguageModeMenu(lmForm, langModeCB,
468 - NULL);
469 + NULL, FALSE);
470 n = 0;
471 XtSetArg(args[n], XmNspacing, 0); n++;
472 XtSetArg(args[n], XmNmarginWidth, 0); n++;
473 XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
474 XtSetArg(args[n], XmNleftAttachment, XmATTACH_POSITION); n++;
475 @@ -2877,12 +2878,13 @@ void UpdateLanguageModeMenu(void)
477 if (HighlightDialog.shell == NULL)
478 return;
480 oldMenu = HighlightDialog.lmPulldown;
481 + /* Pattern Match Feature: don't include "PLAIN" (4th parameter) */
482 HighlightDialog.lmPulldown = CreateLanguageModeMenu(
483 - XtParent(XtParent(oldMenu)), langModeCB, NULL);
484 + XtParent(XtParent(oldMenu)), langModeCB, NULL, FALSE);
485 XtVaSetValues(XmOptionButtonGadget(HighlightDialog.lmOptMenu),
486 XmNsubMenuId, HighlightDialog.lmPulldown, NULL);
487 SetLangModeMenu(HighlightDialog.lmOptMenu, HighlightDialog.langModeName);
489 XtDestroyWidget(oldMenu);
490 @@ -2937,10 +2939,13 @@ static void langModeCB(Widget w, XtPoint
491 "Discard Changes", "Cancel", HighlightDialog.langModeName);
492 if (resp == 3)
493 {
494 SetLangModeMenu(HighlightDialog.lmOptMenu,
495 HighlightDialog.langModeName);
496 +
497 + freePatternSet(newPatSet);
498 +
499 return;
500 }
501 if (resp == 1)
502 {
503 updatePatternSet();
504 @@ -3036,10 +3041,12 @@ static void restoreCB(Widget w, XtPointe
505 "Are you sure you want to discard\n"
506 "all changes to syntax highlighting\n"
507 "patterns for language mode %s?", "Discard", "Cancel",
508 HighlightDialog.langModeName) == 2)
509 {
510 + freePatternSet(defaultPatSet);
511 +
512 return;
513 }
515 /* if a stored version of the pattern set exists, replace it, if it
516 doesn't, add a new one */
517 diff --quilt old/source/macro.c new/source/macro.c
518 --- old/source/macro.c
519 +++ new/source/macro.c
520 @@ -37,13 +37,15 @@ static const char CVSID[] = "$Id: macro.
521 #include "highlight.h"
522 #include "interpret.h"
523 #include "macro.h"
524 #include "nedit.h"
525 #include "parse.h"
526 +#include "patternMatch.h"
527 #include "preferences.h"
528 #include "rangeset.h"
529 #include "rbTree.h"
530 +#include "regularExp.h"
531 #include "search.h"
532 #include "selection.h"
533 #include "server.h"
534 #include "shell.h"
535 #include "smartIndent.h"
536 @@ -296,12 +298,10 @@ static int makeBackupCopyMV(WindowInfo *
537 DataValue *result, char **errMsg);
538 static int incBackupMV(WindowInfo *window, DataValue *argList, int nArgs,
539 DataValue *result, char **errMsg);
540 static int showMatchingMV(WindowInfo *window, DataValue *argList, int nArgs,
541 DataValue *result, char **errMsg);
542 -static int matchSyntaxBasedMV(WindowInfo *window, DataValue *argList, int nArgs,
543 - DataValue *result, char **errMsg);
544 static int overTypeModeMV(WindowInfo *window, DataValue *argList, int nArgs,
545 DataValue *result, char **errMsg);
546 static int readOnlyMV(WindowInfo *window, DataValue *argList, int nArgs,
547 DataValue *result, char **errMsg);
548 static int lockedMV(WindowInfo *window, DataValue *argList, int nArgs,
549 @@ -415,10 +415,14 @@ static int filenameDialogMS(WindowInfo*
550 static int callMS(WindowInfo *window, DataValue *argList,
551 int nArgs, DataValue *result, char **errMsg);
552 static int typeofMS(WindowInfo* window, DataValue* argList, int nArgs,
553 DataValue* result, char** errMsg);
555 +/* Pattern Match Feature */
556 +static int getMatchingMS(WindowInfo *window, DataValue *argList, int nArgs,
557 + DataValue *result, char **errMsg);
558 +
559 /* Built-in subroutines and variables for the macro language */
560 static const BuiltInSubrName MacroSubrs[] = {
561 { "length", lengthMS },
562 { "get_range", getRangeMS },
563 { "t_print", tPrintMS },
564 @@ -476,10 +480,11 @@ static const BuiltInSubrName MacroSubrs[
565 { "get_style_by_name", getStyleByNameMS },
566 { "get_style_at_pos", getStyleAtPosMS },
567 { "filename_dialog", filenameDialogMS },
568 { "call", callMS },
569 { "typeof", typeofMS },
570 + { "get_matching", getMatchingMS },
571 { NULL, NULL } /* sentinel */
572 };
574 static const BuiltInSubrName SpecialVars[] = {
575 { "$cursor", cursorMV },
576 @@ -505,11 +510,10 @@ static const BuiltInSubrName SpecialVars
577 { "$wrap_text", wrapTextMV },
578 { "$highlight_syntax", highlightSyntaxMV },
579 { "$make_backup_copy", makeBackupCopyMV },
580 { "$incremental_backup", incBackupMV },
581 { "$show_matching", showMatchingMV },
582 - { "$match_syntax_based", matchSyntaxBasedMV },
583 { "$overtype_mode", overTypeModeMV },
584 { "$read_only", readOnlyMV },
585 { "$locked", lockedMV },
586 { "$file_format", fileFormatMV },
587 { "$font_name", fontNameMV },
588 @@ -4547,20 +4551,10 @@ static int showMatchingMV(WindowInfo *wi
589 result->val.str.rep = res;
590 result->val.str.len = strlen(res);
591 return True;
592 }
594 -static int matchSyntaxBasedMV(WindowInfo *window, DataValue *argList, int nArgs,
595 - DataValue *result, char **errMsg)
596 -{
597 - result->tag = INT_TAG;
598 - result->val.n = window->matchSyntaxBased ? 1 : 0;
599 - return True;
600 -}
601 -
602 -
603 -
604 static int overTypeModeMV(WindowInfo *window, DataValue *argList, int nArgs,
605 DataValue *result, char **errMsg)
606 {
607 result->tag = INT_TAG;
608 result->val.n = window->overstrike ? 1 : 0;
609 @@ -6006,10 +6000,97 @@ static int typeofMS(WindowInfo* window,
610 }
612 return True;
613 }
615 +/*
616 +** Pattern Match Feature:
617 +** Find a matching pattern string related to the given position.
618 +**
619 +** Syntax:
620 +** get_matching(position)
621 +**
622 +** Returns info about matching pattern within an array. The array has
623 +** the following keys: "pos" (position of the first character of the
624 +** matching pattern), "len" (length of the matching pattern), "direction"
625 +** (direction where the matching pattern was found: "0" = forward;
626 +** "1" = backward). If no matching pattern was found, then array element
627 +** of "pos" holds "-1", "len" holds "0" and "direction" holds "-1".
628 +**
629 +*/
630 +static int getMatchingMS(WindowInfo *window, DataValue *argList, int nArgs,
631 + DataValue *result, char **errMsg)
632 +{
633 + int startPos;
634 + int matchPos, matchLen;
635 + int direction;
636 + textBuffer *buf = window->buffer;
637 + DataValue dv;
638 +
639 + /*
640 + * Perform syntax & semantic check
641 + */
642 + if (nArgs != 1 )
643 + return wrongNArgsErr(errMsg);
644 +
645 + if (!readIntArg(argList[0], &startPos, errMsg))
646 + return False;
647 +
648 + startPos ++;
649 +
650 + /*
651 + * do the search; provide default values, if search fails
652 + */
653 + if (!FindMatchingString(window, MT_MACRO, &startPos, 0, buf->length,
654 + &matchPos, &matchLen, &direction))
655 + {
656 + matchPos = -1;
657 + matchLen = 0;
658 + direction = -1;
659 + }
660 +
661 + /*
662 + * initialize array holding info about matching string
663 + */
664 + result->tag = ARRAY_TAG;
665 + result->val.arrayPtr = ArrayNew();
666 +
667 + /*
668 + * the following array entries will be integers
669 + */
670 + dv.tag = INT_TAG;
671 +
672 + /*
673 + * insert match position
674 + */
675 + dv.val.n = matchPos;
676 + if (!ArrayInsert(result, PERM_ALLOC_STR("pos"), &dv))
677 + {
678 + M_ARRAY_INSERT_FAILURE();
679 + }
680 +
681 + /*
682 + * insert length of matching pattern
683 + */
684 + dv.val.n = matchLen;
685 + if (!ArrayInsert(result, PERM_ALLOC_STR("len"), &dv))
686 + {
687 + M_ARRAY_INSERT_FAILURE();
688 + }
689 +
690 + /*
691 + * insert direction where the matching pattern was found
692 + */
693 + dv.val.n = direction;
694 + if (!ArrayInsert(result, PERM_ALLOC_STR("direction"), &dv))
695 + {
696 + M_ARRAY_INSERT_FAILURE();
697 + }
698 +
699 + return True;
700 +}
701 +
702 static int wrongNArgsErr(char **errMsg)
703 {
704 *errMsg = "Wrong number of arguments to function %s";
705 return False;
706 }
707 diff --quilt old/source/menu.c new/source/menu.c
708 --- old/source/menu.c
709 +++ new/source/menu.c
710 @@ -47,10 +47,11 @@ static const char CVSID[] = "$Id: menu.c
711 #include "userCmds.h"
712 #include "shell.h"
713 #include "macro.h"
714 #include "highlight.h"
715 #include "highlightData.h"
716 +#include "patternMatchData.h"
717 #include "interpret.h"
718 #include "smartIndent.h"
719 #include "windowTitle.h"
720 #include "regularExp.h"
721 #include "../util/getfiles.h"
722 @@ -131,11 +132,10 @@ static void fontCB(Widget w, WindowInfo
723 static void tabsCB(Widget w, WindowInfo *window, caddr_t callData);
724 static void backlightCharsCB(Widget w, WindowInfo *window, caddr_t callData);
725 static void showMatchingOffCB(Widget w, WindowInfo *window, caddr_t callData);
726 static void showMatchingDelimitCB(Widget w, WindowInfo *window, caddr_t callData);
727 static void showMatchingRangeCB(Widget w, WindowInfo *window, caddr_t callData);
728 -static void matchSyntaxBasedCB(Widget w, WindowInfo *window, caddr_t callData);
729 static void statsCB(Widget w, WindowInfo *window, caddr_t callData);
730 static void autoIndentOffDefCB(Widget w, WindowInfo *window, caddr_t callData);
731 static void autoIndentDefCB(Widget w, WindowInfo *window, caddr_t callData);
732 static void smartIndentDefCB(Widget w, WindowInfo *window, caddr_t callData);
733 static void autoSaveDefCB(Widget w, WindowInfo *window, caddr_t callData);
734 @@ -158,13 +158,13 @@ static void pathInWindowsMenuDefCB(Widge
735 static void customizeTitleDefCB(Widget w, WindowInfo *window, caddr_t callData);
736 static void tabsDefCB(Widget w, WindowInfo *window, caddr_t callData);
737 static void showMatchingOffDefCB(Widget w, WindowInfo *window, caddr_t callData);
738 static void showMatchingDelimitDefCB(Widget w, WindowInfo *window, caddr_t callData);
739 static void showMatchingRangeDefCB(Widget w, WindowInfo *window, caddr_t callData);
740 -static void matchSyntaxBasedDefCB(Widget w, WindowInfo *window, caddr_t callData);
741 static void highlightOffDefCB(Widget w, WindowInfo *window, caddr_t callData);
742 static void highlightDefCB(Widget w, WindowInfo *window, caddr_t callData);
743 +static void matchPatternsDefCB(Widget w, WindowInfo *window, caddr_t callData);
744 static void backlightCharsDefCB(Widget w, WindowInfo *window, caddr_t callData);
745 static void fontDefCB(Widget w, WindowInfo *window, caddr_t callData);
746 static void colorDefCB(Widget w, WindowInfo *window, caddr_t callData);
747 static void smartTagsDefCB(Widget parent, XtPointer client_data, XtPointer call_data);
748 static void showAllTagsDefCB(Widget parent, XtPointer client_data, XtPointer call_data);
749 @@ -408,12 +408,10 @@ static void setMakeBackupCopyAP(Widget w
750 Cardinal *nArgs);
751 static void setIncrementalBackupAP(Widget w, XEvent *event, String *args,
752 Cardinal *nArgs);
753 static void setShowMatchingAP(Widget w, XEvent *event, String *args,
754 Cardinal *nArgs);
755 -static void setMatchSyntaxBasedAP(Widget w, XEvent *event, String *args,
756 - Cardinal *nArgs);
757 static void setOvertypeModeAP(Widget w, XEvent *event, String *args,
758 Cardinal *nArgs);
759 static void setLockedAP(Widget w, XEvent *event, String *args,
760 Cardinal *nArgs);
761 static void setTransientAP(Widget text, XEvent* event, String* args,
762 @@ -583,11 +581,10 @@ static XtActionsRec Actions[] = {
763 #ifndef VMS
764 {"set_make_backup_copy", setMakeBackupCopyAP},
765 #endif
766 {"set_incremental_backup", setIncrementalBackupAP},
767 {"set_show_matching", setShowMatchingAP},
768 - {"set_match_syntax_based", setMatchSyntaxBasedAP},
769 {"set_overtype_mode", setOvertypeModeAP},
770 {"set_locked", setLockedAP},
771 {"set_transient", setTransientAP},
772 {"set_tab_dist", setTabDistAP},
773 {"set_em_tab_dist", setEmTabDistAP},
774 @@ -1030,14 +1027,13 @@ Widget CreateMenuBar(Widget parent, Wind
775 "delimiter", "Delimiter", 'D', showMatchingDelimitDefCB, window,
776 GetPrefShowMatching() == FLASH_DELIMIT, SHORT);
777 window->showMatchingRangeDefItem = createMenuRadioToggle(subSubPane,
778 "range", "Range", 'R', showMatchingRangeDefCB, window,
779 GetPrefShowMatching() == FLASH_RANGE, SHORT);
780 - createMenuSeparator(subSubPane, "sep", SHORT);
781 - window->matchSyntaxBasedDefItem = createMenuToggle(subSubPane,
782 - "matchSyntax", "Syntax Based", 'S', matchSyntaxBasedDefCB, window,
783 - GetPrefMatchSyntaxBased(), SHORT);
784 + createMenuSeparator(subSubPane, "sep1", SHORT);
785 + createMenuItem(subSubPane, "matchPatterns", "Matching Patterns...",
786 + 'M', matchPatternsDefCB, window, FULL);
788 /* Show Hidden Files */
789 window->showHiddenFilesItem = createMenuToggle(subPane,
790 "showHiddenFilesItem", "Show hidden Files", 'y', showHiddenFilesCB,
791 NULL, GetPrefShowHiddenFiles(), FULL);
792 @@ -1160,14 +1156,10 @@ Widget CreateMenuBar(Widget parent, Wind
793 "delimiter", "Delimiter", 'D', showMatchingDelimitCB, window,
794 window->showMatchingStyle == FLASH_DELIMIT, SHORT);
795 window->showMatchingRangeItem = createMenuRadioToggle(subPane, "range",
796 "Range", 'R', showMatchingRangeCB, window,
797 window->showMatchingStyle == FLASH_RANGE, SHORT);
798 - createMenuSeparator(subPane, "sep", SHORT);
799 - window->matchSyntaxBasedItem = createMenuToggle(subPane, "matchSyntax",
800 - "Syntax Based", 'S', matchSyntaxBasedCB, window,
801 - window->matchSyntaxBased, SHORT);
803 #ifndef SGI_CUSTOM
804 createMenuSeparator(menuPane, "sep2", SHORT);
805 window->overtypeModeItem = createMenuToggle(menuPane, "overtype", "Overtype", 'O',
806 doActionCB, "set_overtype_mode", False, SHORT);
807 @@ -1695,28 +1687,10 @@ static void showMatchingRangeCB(Widget w
808 ((XmAnyCallbackStruct *)callData)->event);
809 XtCallActionProc(WidgetToWindow(menu)->lastFocus, "set_show_matching",
810 ((XmAnyCallbackStruct *)callData)->event, params, 1);
811 }
813 -static void matchSyntaxBasedCB(Widget w, WindowInfo *window, caddr_t callData)
814 -{
815 - Widget menu = MENU_WIDGET(w);
816 -
817 - window = WidgetToWindow(menu);
818 -
819 -#ifdef SGI_CUSTOM
820 - if (shortPrefAskDefault(window->shell, w, "Match Syntax Based")) {
821 - matchSyntaxBasedDefCB(w, window, callData);
822 - SaveNEditPrefs(window->shell, GetPrefShortMenus());
823 - }
824 -#endif
825 - HidePointerOnKeyedEvent(WidgetToWindow(menu)->lastFocus,
826 - ((XmAnyCallbackStruct *)callData)->event);
827 - XtCallActionProc(WidgetToWindow(menu)->lastFocus, "set_match_syntax_based",
828 - ((XmAnyCallbackStruct *)callData)->event, NULL, 0);
829 -}
830 -
831 static void fontCB(Widget w, WindowInfo *window, caddr_t callData)
832 {
833 ChooseFonts(WidgetToWindow(MENU_WIDGET(w)), True);
834 }
836 @@ -2041,22 +2015,18 @@ static void showMatchingRangeDefCB(Widge
837 XmToggleButtonSetState(win->showMatchingDelimitDefItem, False, False);
838 XmToggleButtonSetState(win->showMatchingRangeDefItem, True, False);
839 }
840 }
842 -static void matchSyntaxBasedDefCB(Widget w, WindowInfo *window, caddr_t callData)
843 +static void matchPatternsDefCB(Widget w, WindowInfo *window, caddr_t callData)
844 {
845 - WindowInfo *win;
846 -
847 - int state = XmToggleButtonGetState(w);
848 + Widget menu = MENU_WIDGET(w);
849 + WindowInfo *activeWindow = WidgetToWindow(menu);
851 - /* Set the preference and make the other windows' menus agree */
852 - SetPrefMatchSyntaxBased(state);
853 - for (win=WindowList; win!=NULL; win=win->next) {
854 - if (IsTopDocument(win))
855 - XmToggleButtonSetState(win->matchSyntaxBasedDefItem, state, False);
856 - }
857 + HidePointerOnKeyedEvent(activeWindow->lastFocus,
858 + ((XmAnyCallbackStruct *)callData)->event);
859 + EditMatchPatterns(activeWindow);
860 }
862 static void backlightCharsDefCB(Widget w, WindowInfo *window, caddr_t callData)
863 {
864 WindowInfo *win;
865 @@ -4297,23 +4267,10 @@ static void setShowMatchingAP(Widget w,
866 else {
867 fprintf(stderr, "nedit: set_show_matching requires argument\n");
868 }
869 }
871 -static void setMatchSyntaxBasedAP(Widget w, XEvent *event, String *args,
872 - Cardinal *nArgs)
873 -{
874 - WindowInfo *window = WidgetToWindow(w);
875 - Boolean newState;
876 -
877 - ACTION_BOOL_PARAM_OR_TOGGLE(newState, *nArgs, args, window->matchSyntaxBased, "set_match_syntax_based");
878 -
879 - if (IsTopDocument(window))
880 - XmToggleButtonSetState(window->matchSyntaxBasedItem, newState, False);
881 - window->matchSyntaxBased = newState;
882 -}
883 -
884 static void setOvertypeModeAP(Widget w, XEvent *event, String *args,
885 Cardinal *nArgs)
886 {
887 WindowInfo *window = WidgetToWindow(w);
888 Boolean newState;
889 diff --quilt old/source/nedit.h new/source/nedit.h
890 --- old/source/nedit.h
891 +++ new/source/nedit.h
892 @@ -364,11 +364,10 @@ typedef struct _WindowInfo {
893 Widget iSearchLineItem;
894 Widget lineNumsItem;
895 Widget showMatchingOffItem;
896 Widget showMatchingDelimitItem;
897 Widget showMatchingRangeItem;
898 - Widget matchSyntaxBasedItem;
899 Widget overtypeModeItem;
900 Widget highlightItem;
901 Widget windowMenuPane;
902 Widget shellMenuPane;
903 Widget macroMenuPane;
904 @@ -390,11 +389,10 @@ typedef struct _WindowInfo {
905 Widget newlineWrapDefItem;
906 Widget contWrapDefItem;
907 Widget showMatchingOffDefItem;
908 Widget showMatchingDelimitDefItem;
909 Widget showMatchingRangeDefItem;
910 - Widget matchSyntaxBasedDefItem;
911 Widget highlightOffDefItem;
912 Widget highlightDefItem;
913 Widget backlightCharsItem;
914 Widget backlightCharsDefItem;
915 Widget searchDlogsDefItem;
916 @@ -510,11 +508,10 @@ typedef struct _WindowInfo {
917 ALWAYS, ON-WRAP as enums */
918 Boolean overstrike; /* is overstrike mode turned on ? */
919 char showMatchingStyle; /* How to show matching parens:
920 NO_FLASH, FLASH_DELIMIT, or
921 FLASH_RANGE */
922 - char matchSyntaxBased; /* Use syntax info to show matching */
923 Boolean showStats; /* is stats line supposed to be shown */
924 Boolean showISearchLine; /* is incr. search line to be shown */
925 Boolean showLineNumbers; /* is the line number display shown */
926 Boolean highlightSyntax; /* is syntax highlighting turned on? */
927 Boolean backlightChars; /* is char backlighting turned on? */
928 @@ -556,10 +553,13 @@ typedef struct _WindowInfo {
929 incremental search bar */
930 Bool iSearchLastLiteralCase; /* idem, for literal mode */
931 Bool findLastRegexCase; /* idem, for regex mode in find dialog */
932 Bool findLastLiteralCase; /* idem, for literal mode */
934 + /* Pattern Match Feature */
935 + void *stringMatchTable; /* match pattern info related to this window */
936 +
937 #ifdef REPLACE_SCOPE
938 int replaceScope; /* Current scope for replace dialog */
939 Widget replaceScopeWinToggle; /* Scope for replace = window */
940 Widget replaceScopeSelToggle; /* Scope for replace = selection */
941 Widget replaceScopeMultiToggle;/* Scope for replace = multiple files */
942 diff --quilt /dev/null new/source/patternMatch.c
943 --- /dev/null
944 +++ new/source/patternMatch.c
945 @@ -0,0 +1,2202 @@
946 +static const char CVSID[] = "$Id: patternMatch.c,v 1.4 2003/10/27 21:59:14 uleh Exp $";
947 +/*******************************************************************************
948 +* *
949 +* patternMatch.c -- Nirvana Editor pattern matching functions *
950 +* *
951 +* Copyright (C) 2003-2004, Uwe Lehnert *
952 +* *
953 +* This is free software; you can redistribute it and/or modify it under the *
954 +* terms of the GNU General Public License as published by the Free Software *
955 +* Foundation; either version 2 of the License, or (at your option) any later *
956 +* version. In addition, you may distribute versions of this program linked to *
957 +* Motif or Open Motif. See README for details. *
958 +* *
959 +* This software is distributed in the hope that it will be useful, but WITHOUT *
960 +* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or *
961 +* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License *
962 +* for more details. *
963 +* *
964 +* You should have received a copy of the GNU General Public License along with *
965 +* software; if not, write to the Free Software Foundation, Inc., 59 Temple *
966 +* Place, Suite 330, Boston, MA 02111-1307 USA *
967 +* *
968 +* Nirvana Text Editor *
969 +* October 27, 2004 *
970 +* *
971 +* Written by Uwe Lehnert *
972 +* *
973 +*******************************************************************************/
974 +
975 +#ifdef HAVE_CONFIG_H
976 +#include "../config.h"
977 +#endif
978 +
979 +#include <stdlib.h>
980 +#include <stdio.h>
981 +#include <limits.h>
982 +#include <string.h>
983 +#include <ctype.h>
984 +
985 +#ifdef VMS
986 +#include "../util/VMSparam.h"
987 +#else
988 +#ifndef __MVS__
989 +#include <sys/param.h>
990 +#endif
991 +#endif /*VMS*/
992 +
993 +#include "regularExp.h"
994 +#include "textBuf.h"
995 +#include "search.h"
996 +#include "window.h"
997 +#include "preferences.h"
998 +#include "highlight.h"
999 +
1000 +#include "patternMatch.h"
1001 +#include "patternMatchData.h"
1002 +
1003 +#ifdef HAVE_DEBUG_H
1004 +#include "../debug.h"
1005 +#endif
1006 +
1007 +#define MAX_NESTED_PATTERNS 100
1008 +
1009 +#define IGNORE_HIGHLIGHT_CODE -1
1010 +
1011 +typedef struct _SearchRegionInfo {
1012 + WindowInfo *sriWindow;
1013 + char *sriText;
1014 + char sriPrevChar;
1015 + char sriSuccChar;
1016 + int sriStartOfTextPos;
1017 +} SearchRegionInfo;
1018 +
1019 +typedef struct _FoundStringInfo {
1020 + char *fsiStartPtr;
1021 + char *fsiEndPtr;
1022 + int fsiLength;
1023 + char fsiPrevChar;
1024 + char fsiSuccChar;
1025 + const char *fsiDelimiters;
1026 +} FoundStringInfo;
1027 +
1028 +typedef struct _BackRefInfo {
1029 + int briAvailable;
1030 + int briCaseInsensitive;
1031 + char *briStartPtr[MAX_GLOBAL_BACK_REF_ID];
1032 + char *briEndPtr[MAX_GLOBAL_BACK_REF_ID];
1033 +} BackRefInfo;
1034 +
1035 +typedef struct _MatchingElementInfo {
1036 + MatchPatternTableElement *meiElement;
1037 + PatternReference meiPatRef;
1038 + int meiDirection;
1039 + int meiHighLightCode;
1040 + int meiAbsStartPos;
1041 + int meiLength;
1042 + BackRefInfo meiBackRefInfo;
1043 +} MatchingElementInfo;
1044 +
1045 +typedef struct _PatternStackElement {
1046 + PatternReference psePatRef;
1047 + int pseHighLightCode;
1048 + BackRefInfo pseBackRefInfo;
1049 +} PatternStackElement;
1050 +
1051 +/*
1052 + * Prototypes of local functions
1053 + */
1054 +void adaptPatternPositions(
1055 + MatchingType matchingType,
1056 + int direction,
1057 + int *charPos,
1058 + int startPatternLength,
1059 + int *matchPos,
1060 + int matchedPatternLength);
1061 +
1062 +static int findMatchingStringElement(
1063 + StringMatchTable *smTable,
1064 + SearchRegionInfo *searchRegion,
1065 + MatchingElementInfo *matchInfo,
1066 + int *charPos,
1067 + const char *delimiters);
1068 +
1069 +static PatternElementMonoInfo determineMonoPatInfo(
1070 + WindowInfo *window,
1071 + int patHighLightCode,
1072 + int leftPos,
1073 + int rightPos,
1074 + PatternElementKind *patElementKind);
1075 +
1076 +static void assignBackRefInfo(
1077 + StringPattern *strPat,
1078 + BackRefInfo *backRefInfo);
1079 +static int doesBackRefInfoMatch(
1080 + BackRefInfo *backRefInfo1,
1081 + BackRefInfo *backRefInfo2);
1082 +static int compareBackRef(
1083 + char *startPtr1,
1084 + char *endPtr1,
1085 + char *startPtr2,
1086 + char *endPtr2,
1087 + int caseInsensitive);
1088 +
1089 +static int doesPatternElementMatch(
1090 + PatternElement *patElement,
1091 + FoundStringInfo *foundStringInfo,
1092 + BackRefInfo *backRefInfo);
1093 +static int doesMPTableElementMatch(
1094 + MatchPatternTableElement *element,
1095 + FoundStringInfo *foundStringInfo,
1096 + PatternElementKind *patternElementKind,
1097 + int *patternElementIdx,
1098 + BackRefInfo *backRefInfo);
1099 +static int getPatternInfo(
1100 + MatchPatternTable *table,
1101 + FoundStringInfo *foundStringInfo,
1102 + PatternReference *patRef,
1103 + BackRefInfo *backRefInfo);
1104 +
1105 +static int isPartOfPattern(
1106 + MatchPatternTable *table,
1107 + int parentElementIdx,
1108 + int childElementIdx,
1109 + PatternElementKind patElementKind);
1110 +static int isPartOfPatternElementSet(
1111 + PatternElementSet *patElementSet,
1112 + int patternElementIdx);
1113 +static int isPartOfMiddlePatternElementSet(
1114 + PatternElementSet *patElementSet,
1115 + int patternElementIdx);
1116 +static void considerNextPatternReference(
1117 + MatchPatternTable *table,
1118 + PatternReference *startPatRef,
1119 + PatternReference nxtPatRef,
1120 + int groupIdx);
1121 +
1122 +static int searchPatternForward(
1123 + MatchPatternTable *table,
1124 + regexp *compiledRE,
1125 + SearchRegionInfo *searchRegion,
1126 + const char *delimiters,
1127 + int beginPos,
1128 + int *matchEndPos,
1129 + PatternReference *patRef,
1130 + int *highLightCode,
1131 + BackRefInfo *backRefInfo);
1132 +static int searchPatternBackward(
1133 + MatchPatternTable *table,
1134 + regexp *compiledRE,
1135 + SearchRegionInfo *searchRegion,
1136 + const char *delimiters,
1137 + int beginPos,
1138 + PatternReference *patRef,
1139 + int *highLightCode,
1140 + int *matchedPatternLength,
1141 + BackRefInfo *backRefInfo);
1142 +
1143 +static int parseStringElementForward(
1144 + MatchingElementInfo *matchInfo,
1145 + SearchRegionInfo *searchRegion,
1146 + int relCharPos,
1147 + int *matchPos,
1148 + int *matchedPatternLength,
1149 + const char *delimiters);
1150 +static int findRelatedForwardPattern(
1151 + StringMatchTable *table,
1152 + SearchRegionInfo *searchRegion,
1153 + const char *delimiters,
1154 + PatternReference beginPatRef,
1155 + int beginPatHighLightCode,
1156 + BackRefInfo *beginPatBackRefInfo,
1157 + int beginPos,
1158 + int *matchEndPos);
1159 +
1160 +static int parseStringElementBackward(
1161 + MatchingElementInfo *matchInfo,
1162 + SearchRegionInfo *searchRegion,
1163 + int relCharPos,
1164 + int *matchPos,
1165 + int *matchedPatternLength,
1166 + const char *delimiters);
1167 +static int findRelatedStartPattern(
1168 + StringMatchTable *table,
1169 + SearchRegionInfo *searchRegion,
1170 + const char *delimiters,
1171 + PatternReference beginPatRef,
1172 + int beginPatHighLightCode,
1173 + BackRefInfo *beginPatBackRefInfo,
1174 + int beginPos,
1175 + int *matchedPatternLength);
1176 +static void considerStackPatReference(
1177 + PatternElementSet *patSet,
1178 + int stackElementIdx,
1179 + int *foundElementIdx);
1180 +
1181 +static int getPatternLocatedAtPos(
1182 + regexp *usedPatRE,
1183 + MatchPatternTable *table,
1184 + SearchRegionInfo *searchRegion,
1185 + int *relBeginPos,
1186 + MatchingElementInfo *matchInfo,
1187 + const char *delimiters);
1188 +static int getMatchedElementInfo(
1189 + WindowInfo *window,
1190 + MatchPatternTable *table,
1191 + FoundStringInfo *foundStringInfo,
1192 + MatchingElementInfo *matchInfo);
1193 +
1194 +static PatternElement *getPatternOfReference(
1195 + MatchPatternTable *table,
1196 + PatternReference patRef);
1197 +
1198 +#ifdef DEBUG_FIND
1199 +static char *getPatternForDebug(
1200 + MatchPatternTable *table,
1201 + PatternReference patRef );
1202 +static char *patElemKindToString(
1203 + PatternElementKind patElemKind);
1204 +static void printFoundStringForDebug(
1205 + WindowInfo *window,
1206 + int absStartPos,
1207 + int length);
1208 +#endif
1209 +
1210 +/*
1211 +** Try to find a matching pattern string related to the given "charPos"
1212 +** inside the given range (defined by startLimit & endLimit).
1213 +** Determine the matching position & the match pattern length (depending
1214 +** on given matchingType), if a matching pattern was found.
1215 +** Returns true, if a matching pattern string was found.
1216 +*/
1217 +int FindMatchingString(
1218 + WindowInfo *window,
1219 + MatchingType matchingType,
1220 + int *charPos,
1221 + int startLimit,
1222 + int endLimit,
1223 + int *matchPos,
1224 + int *matchedPatternLength,
1225 + int *direction)
1226 +{
1227 + StringMatchTable *smTable = (StringMatchTable *)window->stringMatchTable;
1228 + const char *delimiters;
1229 + SearchRegionInfo searchRegion;
1230 + MatchingElementInfo matchInfo;
1231 + int matchingPatternFound = FALSE;
1232 + int relCharPos;
1233 +
1234 + if (smTable == NULL || smTable->smtAllPatRE == NULL)
1235 + {
1236 + /*
1237 + * No match pattern table available:
1238 + */
1239 + return FALSE;
1240 + }
1241 +
1242 + /*
1243 + * Get delimiters related to window
1244 + */
1245 + delimiters = GetWindowDelimiters(window);
1246 + if (delimiters == NULL)
1247 + delimiters = GetPrefDelimiters();
1248 +
1249 + /*
1250 + * Select the start pattern reg. exp. to use
1251 + */
1252 + if (matchingType == MT_FLASH_RANGE ||
1253 + matchingType == MT_FLASH_DELIMIT)
1254 + {
1255 + smTable->smtUsedPatRE = smTable->smtFlashPatRE;
1256 + }
1257 + else
1258 + {
1259 + smTable->smtUsedPatRE = smTable->smtAllPatRE;
1260 + }
1261 +
1262 + /*
1263 + * Get a copy of the text buffer area to parse
1264 + */
1265 + searchRegion.sriWindow = window;
1266 + searchRegion.sriText = BufGetRange(window->buffer, startLimit, endLimit);
1267 + searchRegion.sriPrevChar = BufGetCharacter(window->buffer, startLimit - 1);
1268 + searchRegion.sriSuccChar = BufGetCharacter(window->buffer, endLimit);
1269 + searchRegion.sriStartOfTextPos = startLimit;
1270 +
1271 + relCharPos = *charPos - startLimit;
1272 +
1273 + /*
1274 + * Try to find a matching pattern string using string match table
1275 + * of window
1276 + */
1277 + if (findMatchingStringElement(
1278 + smTable,
1279 + &searchRegion,
1280 + &matchInfo,
1281 + &relCharPos,
1282 + delimiters ))
1283 + {
1284 +#ifdef DEBUG_FIND
1285 + printf("--- Start at : ");
1286 + printFoundStringForDebug(
1287 + window,
1288 + matchInfo.meiAbsStartPos,
1289 + matchInfo.meiLength);
1290 + printf(" ---\n");
1291 +#endif
1292 + if (matchInfo.meiDirection == SEARCH_FORWARD)
1293 + {
1294 + matchingPatternFound =
1295 + parseStringElementForward(
1296 + &matchInfo,
1297 + &searchRegion,
1298 + relCharPos,
1299 + matchPos,
1300 + matchedPatternLength,
1301 + delimiters );
1302 + }
1303 + else
1304 + {
1305 + matchingPatternFound =
1306 + parseStringElementBackward(
1307 + &matchInfo,
1308 + &searchRegion,
1309 + relCharPos,
1310 + matchPos,
1311 + matchedPatternLength,
1312 + delimiters );
1313 + }
1314 +
1315 + if (matchingPatternFound)
1316 + {
1317 + /*
1318 + * Calc. abs. start char pos. (may have been changed if
1319 + * cursor was located inside a string pattern). Adapt
1320 + * pattern positions depending on matchingType.
1321 + */
1322 + *charPos = relCharPos + startLimit;
1323 + *direction = matchInfo.meiDirection;
1324 +
1325 + adaptPatternPositions(
1326 + matchingType,
1327 + matchInfo.meiDirection,
1328 + charPos,
1329 + matchInfo.meiLength,
1330 + matchPos,
1331 + *matchedPatternLength);
1332 + }
1333 + }
1334 +
1335 + XtFree(searchRegion.sriText);
1336 +
1337 + return matchingPatternFound;
1338 +}
1339 +
1340 +/*
1341 +** Adapt match pattern position / start position depending on the
1342 +** given matching type.
1343 +*/
1344 +void adaptPatternPositions(
1345 + MatchingType matchingType,
1346 + int direction,
1347 + int *charPos,
1348 + int startPatternLength,
1349 + int *matchPos,
1350 + int matchedPatternLength)
1351 +{
1352 + switch (matchingType)
1353 + {
1354 + case MT_FLASH_DELIMIT:
1355 + case MT_MACRO:
1356 + if (direction == SEARCH_FORWARD)
1357 + {
1358 + (*matchPos) -= matchedPatternLength - 1;
1359 + }
1360 + break;
1361 +
1362 + case MT_FLASH_RANGE:
1363 + case MT_SELECT:
1364 + if (direction == SEARCH_FORWARD)
1365 + {
1366 + (*charPos) -= startPatternLength;
1367 + }
1368 + else
1369 + {
1370 + (*charPos) --;
1371 + }
1372 + break;
1373 +
1374 + case MT_GOTO:
1375 + if (direction == SEARCH_FORWARD)
1376 + {
1377 + (*matchPos) ++;
1378 + }
1379 + else
1380 + {
1381 + (*matchPos) += matchedPatternLength;
1382 + }
1383 + break;
1384 + }
1385 +}
1386 +
1387 +/*
1388 +** Try to find a string pattern at given buffer position 'charPos'.
1389 +** A string pattern is found, if pattern is located before 'charPos' or
1390 +** 'charPos' is located within a pattern.
1391 +** If a string pattern is found, then search direction and string pattern
1392 +** reference / properties are determined.
1393 +** Returns true, if a string pattern was found.
1394 +*/
1395 +static int findMatchingStringElement(
1396 + StringMatchTable *smTable,
1397 + SearchRegionInfo *searchRegion,
1398 + MatchingElementInfo *matchInfo,
1399 + int *charPos,
1400 + const char *delimiters)
1401 +{
1402 + if (getPatternLocatedAtPos(
1403 + smTable->smtUsedPatRE,
1404 + smTable->smtAllPatterns,
1405 + searchRegion,
1406 + charPos,
1407 + matchInfo,
1408 + delimiters))
1409 + {
1410 + /*
1411 + * Pattern found -> define search direction:
1412 + * - START & MIDDLE pattern: matching pattern is searched in
1413 + * forward direction
1414 + * - END pattern: matching pattern is searched in backward
1415 + * direction
1416 + */
1417 + if (matchInfo->meiPatRef.prKind == PEK_END)
1418 + matchInfo->meiDirection = SEARCH_BACKWARD;
1419 + else
1420 + matchInfo->meiDirection = SEARCH_FORWARD;
1421 +
1422 + return TRUE;
1423 + }
1424 +
1425 + return FALSE;
1426 +}
1427 +
1428 +/*
1429 +** Return mono pattern info depending on highlight codes
1430 +** of left / right side of string pattern. Update pattern
1431 +** kind if applicable.
1432 +*/
1433 +static PatternElementMonoInfo determineMonoPatInfo(
1434 + WindowInfo *window,
1435 + int patHighLightCode,
1436 + int leftPos,
1437 + int rightPos,
1438 + PatternElementKind *patElementKind)
1439 +{
1440 + int leftSideHasSameHC;
1441 + int rightSideHasSameHC;
1442 +
1443 + /*
1444 + * Determine, if left side holds same highlight code than
1445 + * found string pattern
1446 + */
1447 + if (leftPos >= 0)
1448 + leftSideHasSameHC =
1449 + (HighlightCodeOfPos(window, leftPos) == patHighLightCode);
1450 + else
1451 + leftSideHasSameHC = FALSE;
1452 +
1453 + /*
1454 + * Determine, if right side holds same highlight code than
1455 + * found string pattern
1456 + */
1457 + if (rightPos < window->buffer->length)
1458 + rightSideHasSameHC =
1459 + (HighlightCodeOfPos(window, rightPos) == patHighLightCode);
1460 + else
1461 + rightSideHasSameHC = FALSE;
1462 +
1463 + if ((rightSideHasSameHC && leftSideHasSameHC) ||
1464 + (!rightSideHasSameHC && !leftSideHasSameHC))
1465 + {
1466 + return PEMI_MONO_AMBIGUOUS_SYNTAX;
1467 + }
1468 + else if (leftSideHasSameHC)
1469 + {
1470 + *patElementKind = PEK_END;
1471 + return PEMI_MONO_DEFINITE_SYNTAX;
1472 + }
1473 + else
1474 + {
1475 + *patElementKind = PEK_START;
1476 + return PEMI_MONO_DEFINITE_SYNTAX;
1477 + }
1478 +}
1479 +
1480 +/*
1481 +** Get backref info out of found string pattern and
1482 +** put it into given backRefInfo.
1483 +*/
1484 +static void assignBackRefInfo(
1485 + StringPattern *strPat,
1486 + BackRefInfo *backRefInfo)
1487 +{
1488 + int i;
1489 + int localId;
1490 + regexp *patRE = strPat->spTextRE;
1491 +
1492 + backRefInfo->briAvailable = FALSE;
1493 + backRefInfo->briCaseInsensitive = strPat->spCaseInsensitive;
1494 +
1495 + for (i=0; i<MAX_GLOBAL_BACK_REF_ID; i++)
1496 + {
1497 + localId = strPat->spGlobalToLocalBackRef[i];
1498 +
1499 + if (localId != NO_LOCAL_BACK_REF_ID)
1500 + {
1501 + backRefInfo->briAvailable = TRUE;
1502 +
1503 + backRefInfo->briStartPtr[i] = patRE->startp[localId];
1504 + backRefInfo->briEndPtr[i] = patRE->endp[localId];
1505 + }
1506 + else
1507 + {
1508 + backRefInfo->briStartPtr[i] = NULL;
1509 + backRefInfo->briEndPtr[i] = NULL;
1510 + }
1511 + }
1512 +}
1513 +
1514 +/*
1515 +** Check, if given backref infos match.
1516 +** Returns true, if backref infos match.
1517 +*/
1518 +static int doesBackRefInfoMatch(
1519 + BackRefInfo *backRefInfo1,
1520 + BackRefInfo *backRefInfo2)
1521 +{
1522 + int i;
1523 +
1524 + /*
1525 + * if min. one string pattern doesn't hold backref info, then nothing
1526 + * could be compared -> both string pattern are matching.
1527 + */
1528 + if (!backRefInfo1->briAvailable || !backRefInfo2->briAvailable)
1529 + return TRUE;
1530 +
1531 + for (i=0; i < MAX_GLOBAL_BACK_REF_ID; i++)
1532 + {
1533 + if (!compareBackRef(
1534 + backRefInfo1->briStartPtr[i],
1535 + backRefInfo1->briEndPtr[i],
1536 + backRefInfo2->briStartPtr[i],
1537 + backRefInfo2->briEndPtr[i],
1538 + backRefInfo1->briCaseInsensitive || backRefInfo2->briCaseInsensitive))
1539 + {
1540 + return FALSE;
1541 + }
1542 + }
1543 +
1544 + return TRUE;
1545 +}
1546 +
1547 +/*
1548 +** Compares two backref content.
1549 +** Returns true, if backref contents match.
1550 +*/
1551 +static int compareBackRef(
1552 + char *startPtr1,
1553 + char *endPtr1,
1554 + char *startPtr2,
1555 + char *endPtr2,
1556 + int caseInsensitive)
1557 +{
1558 + char *s1;
1559 + char *s2;
1560 +
1561 + if (startPtr1 == NULL && startPtr2 == NULL)
1562 + return TRUE;
1563 +
1564 + if (startPtr1 == NULL || startPtr2 == NULL)
1565 + return FALSE;
1566 +
1567 + if ((endPtr1 - startPtr1) != (endPtr2 - startPtr2))
1568 + return FALSE;
1569 +
1570 + s1 = startPtr1;
1571 + s2 = startPtr2;
1572 +
1573 + if (caseInsensitive)
1574 + {
1575 + while (s1 != endPtr1)
1576 + {
1577 + if (tolower((unsigned char)*s1++) != tolower((unsigned char)*s2++))
1578 + return FALSE;
1579 + }
1580 + }
1581 + else
1582 + {
1583 + while (s1 != endPtr1)
1584 + {
1585 + if (*s1++ != *s2++)
1586 + return FALSE;
1587 + }
1588 + }
1589 + return TRUE;
1590 +}
1591 +
1592 +/*
1593 +** Verify if given pattern element is located between given
1594 +** start / end pointer of "foundStringInfo". Assign backreference
1595 +** information, if pattern element matches.
1596 +** Returns true, if given pattern element matches.
1597 +*/
1598 +static int doesPatternElementMatch(
1599 + PatternElement *patElement,
1600 + FoundStringInfo *foundStringInfo,
1601 + BackRefInfo *backRefInfo)
1602 +{
1603 + char *s;
1604 + char *p;
1605 + StringPattern *strPat;
1606 + int elementMatch;
1607 +
1608 + switch (patElement->peType)
1609 + {
1610 + case PET_SINGLE:
1611 + strPat = &patElement->peVal.peuSingle;
1612 + break;
1613 + case PET_MULTIPLE:
1614 + strPat = &patElement->peVal.peuMulti.mpStringPattern;
1615 + break;
1616 + default:
1617 + return FALSE;
1618 + }
1619 +
1620 + if (strPat->spRegularExpression)
1621 + {
1622 + /*
1623 + * check reg. expression:
1624 + */
1625 + elementMatch =
1626 + ExecRE(
1627 + strPat->spTextRE,
1628 + foundStringInfo->fsiStartPtr,
1629 + foundStringInfo->fsiEndPtr,
1630 + FALSE,
1631 + foundStringInfo->fsiPrevChar,
1632 + foundStringInfo->fsiSuccChar,
1633 + foundStringInfo->fsiDelimiters,
1634 + NULL,
1635 + NULL);
1636 +
1637 + if (elementMatch)
1638 + assignBackRefInfo(strPat, backRefInfo);
1639 +
1640 + return elementMatch;
1641 + }
1642 + else
1643 + {
1644 + backRefInfo->briAvailable = FALSE;
1645 +
1646 + /*
1647 + * check literal string:
1648 + */
1649 + p = strPat->spText;
1650 +
1651 + /*
1652 + * if length of found string is different from length of
1653 + * given string pattern, then there is no match.
1654 + */
1655 + if (strPat->spLength != foundStringInfo->fsiLength)
1656 + return FALSE;
1657 +
1658 + s = foundStringInfo->fsiStartPtr;
1659 +
1660 + if (strPat->spCaseInsensitive)
1661 + {
1662 + while (s != foundStringInfo->fsiEndPtr)
1663 + {
1664 + if (tolower((unsigned char)*s++) != *p++)
1665 + return FALSE;
1666 + }
1667 + }
1668 + else
1669 + {
1670 + while (s != foundStringInfo->fsiEndPtr)
1671 + {
1672 + if (*s++ != *p++)
1673 + return FALSE;
1674 + }
1675 + }
1676 + }
1677 +
1678 + return TRUE;
1679 +}
1680 +
1681 +/*
1682 +** Verify if a pattern element of given MatchPatternTableElement is
1683 +** located between given start / end pointer of "foundStringInfo".
1684 +** Returns true, if so.
1685 +*/
1686 +static int doesMPTableElementMatch(
1687 + MatchPatternTableElement *element,
1688 + FoundStringInfo *foundStringInfo,
1689 + PatternElementKind *patternElementKind,
1690 + int *patternElementIdx,
1691 + BackRefInfo *backRefInfo)
1692 +{
1693 + int i;
1694 +
1695 + for (i=0; i<element->mpteAll.pesNumberOfPattern; i ++)
1696 + {
1697 + if (doesPatternElementMatch(
1698 + element->mpteAll.pesPattern[i],
1699 + foundStringInfo,
1700 + backRefInfo))
1701 + {
1702 + *patternElementKind = element->mpteAll.pesPattern[i]->peKind;
1703 + *patternElementIdx = i;
1704 +
1705 + return TRUE;
1706 + }
1707 + }
1708 +
1709 + return FALSE;
1710 +}
1711 +
1712 +/*
1713 +** Determine the pattern element of given MatchPatternTable, which is
1714 +** located between given start / end pointer of "foundStringInfo".
1715 +** Setup related pattern element reference.
1716 +** Returns true, if a pattern element was found.
1717 +*/
1718 +static int getPatternInfo(
1719 + MatchPatternTable *table,
1720 + FoundStringInfo *foundStringInfo,
1721 + PatternReference *patRef,
1722 + BackRefInfo *backRefInfo)
1723 +{
1724 + int i;
1725 +
1726 + for (i=0; i<table->mptNumberOfElements; i++)
1727 + {
1728 + if (doesMPTableElementMatch(
1729 + table->mptElements[i],
1730 + foundStringInfo,
1731 + &patRef->prKind,
1732 + &patRef->prPatternIdx,
1733 + backRefInfo))
1734 + {
1735 + patRef->prElementIdx = i;
1736 +
1737 + return TRUE;
1738 + }
1739 + }
1740 +
1741 + /*
1742 + * Should never been reached !
1743 + */
1744 + patRef->prElementIdx = NO_ELEMENT_IDX;
1745 + patRef->prKind = PEK_UNKNOWN;
1746 + patRef->prPatternIdx = NO_PATTERN_IDX;
1747 +
1748 + return FALSE;
1749 +}
1750 +
1751 +/*
1752 +** Check, if given child pattern element is part of given
1753 +** parent pattern element.
1754 +** Returns true, if child is part of parent.
1755 +*/
1756 +static int isPartOfPattern(
1757 + MatchPatternTable *table,
1758 + int parentElementIdx,
1759 + int childElementIdx,
1760 + PatternElementKind patElementKind)
1761 +{
1762 + MatchPatternTableElement *parent = table->mptElements[parentElementIdx];
1763 + MatchPatternTableElement *child = table->mptElements[childElementIdx];
1764 +
1765 + if (childElementIdx == parentElementIdx)
1766 + return TRUE;
1767 +
1768 + if (patElementKind == PEK_START)
1769 + {
1770 + if (isPartOfPatternElementSet(&parent->mpteStart, childElementIdx))
1771 + return TRUE;
1772 +
1773 + return( isPartOfPatternElementSet(&child->mpteStart, parentElementIdx) );
1774 + }
1775 + else if (patElementKind == PEK_END)
1776 + {
1777 + if (isPartOfPatternElementSet(&parent->mpteEnd, childElementIdx))
1778 + return TRUE;
1779 +
1780 + return( isPartOfPatternElementSet(&child->mpteEnd, parentElementIdx) );
1781 + }
1782 + else
1783 + {
1784 + /*
1785 + * Given child pattern element is middle pattern: the given pattern element
1786 + * is part of parent pattern, if it's a reference of a middle pattern
1787 + */
1788 + if (isPartOfMiddlePatternElementSet(&parent->mpteMiddle, childElementIdx))
1789 + return TRUE;
1790 +
1791 + return( isPartOfMiddlePatternElementSet(&child->mpteMiddle, parentElementIdx) );
1792 + }
1793 +}
1794 +
1795 +/*
1796 +** Check, if given pattern element is part of given pattern element set.
1797 +** Returns true, if so.
1798 +*/
1799 +static int isPartOfPatternElementSet(
1800 + PatternElementSet *patElementSet,
1801 + int patternElementIdx)
1802 +{
1803 + PatternElement *patElement;
1804 + int i;
1805 +
1806 + for (i=0; i<patElementSet->pesNumberOfPattern; i++)
1807 + {
1808 + if (patElementSet->pesPattern[i]->peType == PET_REFERENCE)
1809 + {
1810 + patElement = patElementSet->pesPattern[i];
1811 +
1812 + if (patElement->peVal.peuRef.prElementIdx == patternElementIdx)
1813 + {
1814 + return TRUE;
1815 + }
1816 + }
1817 + }
1818 +
1819 + return FALSE;
1820 +}
1821 +
1822 +/*
1823 +** Verify, if given pattern element is part of middle pattern set.
1824 +** That's the case, if an element of the pattern set is reference
1825 +** of a middle pattern, which fits to given pattern element.
1826 +** Returns true, if pattern element is part of middle pattern set.
1827 + */
1828 +static int isPartOfMiddlePatternElementSet(
1829 + PatternElementSet *patElementSet,
1830 + int patternElementIdx)
1831 +{
1832 + PatternElement *patElement;
1833 + int i;
1834 +
1835 + for (i=0; i<patElementSet->pesNumberOfPattern; i++)
1836 + {
1837 + if (patElementSet->pesPattern[i]->peType == PET_REFERENCE)
1838 + {
1839 + patElement = patElementSet->pesPattern[i];
1840 +
1841 + if (patElement->peVal.peuRef.prElementIdx == patternElementIdx &&
1842 + patElement->peKind == PEK_MIDDLE)
1843 + {
1844 + return TRUE;
1845 + }
1846 + }
1847 + }
1848 +
1849 + return FALSE;
1850 +}
1851 +
1852 +/*
1853 +** Update start pattern reference depending on next pattern located
1854 +** after start pattern.
1855 +*/
1856 +static void considerNextPatternReference(
1857 + MatchPatternTable *table,
1858 + PatternReference *startPatRef,
1859 + PatternReference nxtPatRef,
1860 + int groupIdx)
1861 +{
1862 + MatchPatternTableElement *tabElement;
1863 + PatternElement *startPat;
1864 + MultiPattern *multiStartPat;
1865 + PatternReference patRef;
1866 + int i;
1867 +
1868 + /*
1869 + * startPatRef needs no adaption, if element index of start pattern
1870 + * and next pattern are equal (i.e. start and next pattern belong
1871 + * to same pattern element).
1872 + */
1873 + if (startPatRef->prElementIdx == nxtPatRef.prElementIdx)
1874 + return;
1875 +
1876 + /*
1877 + * Verify, if start pattern belongs to multiple pattern elements
1878 + * (like "ELSE .. FI" & "ELSE .. ESAC").
1879 + */
1880 + startPat = getPatternOfReference( table, *startPatRef );
1881 +
1882 + if (startPat->peType == PET_MULTIPLE)
1883 + {
1884 + /*
1885 + * Check, if next pattern fits to one of the references of
1886 + * the start multi pattern. If so: adapt start pattern reference.
1887 + */
1888 + multiStartPat = &startPat->peVal.peuMulti;
1889 +
1890 + for (i=0; i<multiStartPat->mpNumberOfReferences; i ++)
1891 + {
1892 + patRef = multiStartPat->mpRefList[i];
1893 + tabElement = table->mptElements[patRef.prElementIdx];
1894 +
1895 + if (nxtPatRef.prElementIdx == patRef.prElementIdx &&
1896 + tabElement->mpteGroup == groupIdx)
1897 + {
1898 + *startPatRef = patRef;
1899 + return;
1900 + }
1901 + }
1902 + }
1903 +}
1904 +
1905 +/*
1906 +** Search for a string pattern in forward direction, starting at
1907 +** given beginPos. Determine related pattern reference of a found
1908 +** string pattern.
1909 +** Returns true, if a next string pattern was found.
1910 +*/
1911 +static int searchPatternForward(
1912 + MatchPatternTable *table,
1913 + regexp *compiledRE,
1914 + SearchRegionInfo *searchRegion,
1915 + const char *delimiters,
1916 + int beginPos,
1917 + int *matchEndPos,
1918 + PatternReference *patRef,
1919 + int *highLightCode,
1920 + BackRefInfo *backRefInfo)
1921 +{
1922 + FoundStringInfo foundStringInfo;
1923 + int matchStartPos;
1924 + int absMatchStartPos;
1925 + MatchPatternTableElement *matchedElement;
1926 +
1927 + *matchEndPos = -1;
1928 +
1929 + patRef->prElementIdx = NO_ELEMENT_IDX;
1930 + patRef->prKind = PEK_UNKNOWN;
1931 + patRef->prPatternIdx = NO_PATTERN_IDX;
1932 +
1933 + *highLightCode = IGNORE_HIGHLIGHT_CODE;
1934 +
1935 + if (ExecRE(
1936 + compiledRE,
1937 + searchRegion->sriText + beginPos,
1938 + NULL,
1939 + FALSE,
1940 + beginPos==0 ? searchRegion->sriPrevChar : searchRegion->sriText[beginPos-1],
1941 + searchRegion->sriSuccChar,
1942 + delimiters,
1943 + searchRegion->sriText,
1944 + NULL))
1945 + {
1946 + foundStringInfo.fsiStartPtr = compiledRE->startp[0];
1947 + foundStringInfo.fsiEndPtr = compiledRE->endp[0];
1948 + foundStringInfo.fsiLength =
1949 + foundStringInfo.fsiEndPtr - foundStringInfo.fsiStartPtr;
1950 +
1951 + foundStringInfo.fsiPrevChar =
1952 + foundStringInfo.fsiStartPtr == searchRegion->sriText ?
1953 + searchRegion->sriPrevChar : *(foundStringInfo.fsiStartPtr - 1);
1954 +
1955 + foundStringInfo.fsiSuccChar =
1956 + *(foundStringInfo.fsiEndPtr) == '\0' ?
1957 + searchRegion->sriSuccChar : *(foundStringInfo.fsiEndPtr);
1958 +
1959 + foundStringInfo.fsiDelimiters = delimiters;
1960 +
1961 + if (getPatternInfo(
1962 + table,
1963 + &foundStringInfo,
1964 + patRef,
1965 + backRefInfo))
1966 + {
1967 + /*
1968 + * Next string pattern was found in forward direction and
1969 + * a pattern reference could be assigned to: calculate
1970 + * relative & absolute match positions.
1971 + */
1972 + matchStartPos = foundStringInfo.fsiStartPtr - searchRegion->sriText;
1973 + *matchEndPos = foundStringInfo.fsiEndPtr - searchRegion->sriText;
1974 +
1975 + absMatchStartPos = matchStartPos + searchRegion->sriStartOfTextPos;
1976 +
1977 + matchedElement = table->mptElements[patRef->prElementIdx];
1978 +
1979 + /*
1980 + * get highlight code of found string pattern, if applicable
1981 + */
1982 + if (!matchedElement->mpteIgnoreHighLightInfo)
1983 + {
1984 + *highLightCode =
1985 + HighlightCodeOfPos(searchRegion->sriWindow, absMatchStartPos);
1986 + }
1987 +
1988 + /*
1989 + * setup mono pattern info of found string pattern
1990 + */
1991 + if (matchedElement->mpteIsMonoPattern)
1992 + {
1993 + if (matchedElement->mpteIgnoreHighLightInfo)
1994 + {
1995 + patRef->prMonoInfo = PEMI_MONO_NOT_SYNTAX_BASED;
1996 + }
1997 + else
1998 + {
1999 + /*
2000 + * determine mono pattern info depending on highLightCodes
2001 + * before / after found string pattern.
2002 + */
2003 + patRef->prMonoInfo =
2004 + determineMonoPatInfo(
2005 + searchRegion->sriWindow,
2006 + *highLightCode,
2007 + absMatchStartPos - 1,
2008 + *matchEndPos + searchRegion->sriStartOfTextPos,
2009 + &patRef->prKind);
2010 + }
2011 + }
2012 + else
2013 + {
2014 + patRef->prMonoInfo = PEMI_NOT_MONO;
2015 + }
2016 +
2017 + return matchStartPos;
2018 + }
2019 + else
2020 + {
2021 + /*
2022 + * Found string can't be assigned to a pattern element
2023 + * (should never occur).
2024 + */
2025 + return -1;
2026 + }
2027 + }
2028 + else
2029 + {
2030 + /*
2031 + * No next string pattern is found in forward direction.
2032 + */
2033 + return -1;
2034 + }
2035 +}
2036 +
2037 +/*
2038 +** Search for a string pattern in backward direction, starting at
2039 +** given beginPos. Determine related pattern reference of a found
2040 +** string pattern.
2041 +** Returns true, if a next string pattern was found.
2042 +*/
2043 +static int searchPatternBackward(
2044 + MatchPatternTable *table,
2045 + regexp *compiledRE,
2046 + SearchRegionInfo *searchRegion,
2047 + const char *delimiters,
2048 + int beginPos,
2049 + PatternReference *patRef,
2050 + int *highLightCode,
2051 + int *matchedPatternLength,
2052 + BackRefInfo *backRefInfo)
2053 +{
2054 + FoundStringInfo foundStringInfo;
2055 + int matchStartPos;
2056 + int absMatchStartPos;
2057 + MatchPatternTableElement *matchedElement;
2058 +
2059 + patRef->prElementIdx = NO_ELEMENT_IDX;
2060 + patRef->prKind = PEK_UNKNOWN;
2061 + patRef->prPatternIdx = NO_PATTERN_IDX;
2062 +
2063 + *highLightCode = IGNORE_HIGHLIGHT_CODE;
2064 +
2065 + if (ExecRE(
2066 + compiledRE,
2067 + searchRegion->sriText,
2068 + searchRegion->sriText + beginPos,
2069 + TRUE,
2070 + searchRegion->sriPrevChar,
2071 + searchRegion->sriText[beginPos] == '\0' ?
2072 + searchRegion->sriSuccChar : searchRegion->sriText[beginPos + 1],
2073 + delimiters,
2074 + searchRegion->sriText,
2075 + NULL))
2076 + {
2077 + foundStringInfo.fsiStartPtr = compiledRE->startp[0];
2078 + foundStringInfo.fsiEndPtr = compiledRE->endp[0];
2079 + foundStringInfo.fsiLength =
2080 + foundStringInfo.fsiEndPtr - foundStringInfo.fsiStartPtr;
2081 +
2082 + foundStringInfo.fsiPrevChar =
2083 + foundStringInfo.fsiStartPtr == searchRegion->sriText ?
2084 + searchRegion->sriPrevChar : *(foundStringInfo.fsiStartPtr - 1);
2085 +
2086 + foundStringInfo.fsiSuccChar =
2087 + *(foundStringInfo.fsiEndPtr) == '\0' ?
2088 + searchRegion->sriSuccChar : *(foundStringInfo.fsiEndPtr);
2089 +
2090 + foundStringInfo.fsiDelimiters = delimiters;
2091 +
2092 + if (getPatternInfo(
2093 + table,
2094 + &foundStringInfo,
2095 + patRef,
2096 + backRefInfo))
2097 + {
2098 + /*
2099 + * Next string pattern was found in backward direction and
2100 + * a pattern reference could be assigned to: calculate
2101 + * relative & absolute match positions.
2102 + */
2103 + matchStartPos = foundStringInfo.fsiStartPtr - searchRegion->sriText;
2104 + *matchedPatternLength = foundStringInfo.fsiLength;
2105 +
2106 + absMatchStartPos = matchStartPos + searchRegion->sriStartOfTextPos;
2107 +
2108 + matchedElement = table->mptElements[patRef->prElementIdx];
2109 +
2110 + /*
2111 + * get highlight code of found string pattern, if applicable
2112 + */
2113 + if (!matchedElement->mpteIgnoreHighLightInfo)
2114 + {
2115 + *highLightCode =
2116 + HighlightCodeOfPos(searchRegion->sriWindow, absMatchStartPos);
2117 + }
2118 +
2119 + /*
2120 + * setup mono pattern info of found string pattern
2121 + */
2122 + if (matchedElement->mpteIsMonoPattern)
2123 + {
2124 + if (matchedElement->mpteIgnoreHighLightInfo)
2125 + {
2126 + patRef->prMonoInfo = PEMI_MONO_NOT_SYNTAX_BASED;
2127 + }
2128 + else
2129 + {
2130 + /*
2131 + * determine mono pattern info depending on highLightCodes
2132 + * before / after found string pattern.
2133 + */
2134 + patRef->prMonoInfo =
2135 + determineMonoPatInfo(
2136 + searchRegion->sriWindow,
2137 + *highLightCode,
2138 + absMatchStartPos - 1,
2139 + absMatchStartPos + *matchedPatternLength,
2140 + &patRef->prKind);
2141 + }
2142 + }
2143 + else
2144 + {
2145 + patRef->prMonoInfo = PEMI_NOT_MONO;
2146 + }
2147 +
2148 + return matchStartPos;
2149 + }
2150 + else
2151 + {
2152 + /*
2153 + * Found string can't be assigned to a pattern element
2154 + * (should never occur).
2155 + */
2156 + return -1;
2157 + }
2158 + }
2159 + else
2160 + {
2161 + /*
2162 + * No next string pattern is found in backward direction.
2163 + */
2164 + return -1;
2165 + }
2166 +}
2167 +
2168 +/*
2169 +** Find matching pattern related to given pattern (stored in
2170 +** 'matchInfo') in forward direction by considering the rules stored in
2171 +** string match table of given window. Determine match position (= abs.
2172 +** pos. of last character of matching string) and length of matching
2173 +** string. If a mono matching pattern couldn't be found in forward
2174 +** direction, then try finding it in backward direction (if found in
2175 +** backward direction, then match position indicates the 1st char. of
2176 +** matching string).
2177 +** Returns true, if a matching pattern was found.
2178 +*/
2179 +static int parseStringElementForward(
2180 + MatchingElementInfo *matchInfo,
2181 + SearchRegionInfo *searchRegion,
2182 + int relCharPos,
2183 + int *matchPos,
2184 + int *matchedPatternLength,
2185 + const char *delimiters)
2186 +{
2187 + StringMatchTable *smTable =
2188 + (StringMatchTable *)searchRegion->sriWindow->stringMatchTable;
2189 + MatchPatternTableElement *matchElement = matchInfo->meiElement;
2190 + int beginPos = relCharPos;
2191 + int endStartPos;
2192 + int startStartPos;
2193 + int endEndPos;
2194 + int matchingPatternFound = FALSE;
2195 +
2196 + /*
2197 + * Find matching pattern within text buffer area to parse in
2198 + * forward direction.
2199 + */
2200 + endStartPos =
2201 + findRelatedForwardPattern(
2202 + smTable,
2203 + searchRegion,
2204 + delimiters,
2205 + matchInfo->meiPatRef,
2206 + matchInfo->meiHighLightCode,
2207 + &matchInfo->meiBackRefInfo,
2208 + beginPos,
2209 + &endEndPos);
2210 +
2211 + if (endEndPos != -1)
2212 + {
2213 + *matchPos = endEndPos - 1 + searchRegion->sriStartOfTextPos;
2214 + *matchedPatternLength = endEndPos - endStartPos;
2215 +
2216 + matchingPatternFound = TRUE;
2217 + }
2218 + else if (matchElement->mpteIsMonoPattern)
2219 + {
2220 + /*
2221 + * mono pattern: forward find fails -> try backward direction.
2222 + * Calc. relative position of 1st char. before found string pattern.
2223 + */
2224 + beginPos = beginPos - matchInfo->meiLength - 1;
2225 +
2226 + if (beginPos > 0)
2227 + {
2228 + startStartPos =
2229 + findRelatedStartPattern(
2230 + smTable,
2231 + searchRegion,
2232 + delimiters,
2233 + matchInfo->meiPatRef,
2234 + matchInfo->meiHighLightCode,
2235 + &matchInfo->meiBackRefInfo,
2236 + beginPos,
2237 + matchedPatternLength);
2238 +
2239 + if (startStartPos != -1)
2240 + {
2241 + matchInfo->meiDirection = SEARCH_BACKWARD;
2242 +
2243 + *matchPos = startStartPos + searchRegion->sriStartOfTextPos;
2244 +
2245 + matchingPatternFound = TRUE;
2246 + }
2247 + }
2248 + }
2249 +
2250 + return matchingPatternFound;
2251 +}
2252 +
2253 +/*
2254 +** Find matching pattern related to given begin pattern reference
2255 +** in forward direction by considering the rules stored in given
2256 +** string match table. Determine match position (= relative
2257 +** pos. of last character of matching string).
2258 +** Returns -1, if no matching pattern was found. Else the relative
2259 +** position of 1st char. of matching string is returned.
2260 +*/
2261 +static int findRelatedForwardPattern(
2262 + StringMatchTable *table,
2263 + SearchRegionInfo *searchRegion,
2264 + const char *delimiters,
2265 + PatternReference beginPatRef,
2266 + int beginPatHighLightCode,
2267 + BackRefInfo *beginPatBackRefInfo,
2268 + int beginPos,
2269 + int *matchEndPos)
2270 +{
2271 + MatchPatternTable *patTable = table->smtAllPatterns;
2272 + int startPos = beginPos;
2273 + int nxtPatStartPos = 0;
2274 + int nxtPatEndPos = 0;
2275 + PatternReference nxtPatRef;
2276 + int nxtPatHighLightCode;
2277 + BackRefInfo nxtPatBackRefInfo;
2278 + PatternStackElement stack[MAX_NESTED_PATTERNS];
2279 + int stackIdx = 0;
2280 + PatternReference startPatRef;
2281 + MatchPatternTableElement *currentElement;
2282 + int groupIdx;
2283 + regexp *groupPatRE;
2284 + regexp *currentPatRE;
2285 + int skipToEnd = FALSE;
2286 + int beginPatternIsMono;
2287 +
2288 +#ifdef DEBUG_FIND
2289 + printf("Forward Start Pos: %d K: %s EI: %d PI: %d HC: %d <%s>\n",
2290 + startPos,
2291 + patElemKindToString(beginPatRef.prKind),
2292 + beginPatRef.prElementIdx,
2293 + beginPatRef.prPatternIdx,
2294 + beginPatHighLightCode,
2295 + getPatternForDebug(patTable, beginPatRef) );
2296 +#endif
2297 +
2298 + /*
2299 + * put begin pattern info on stack
2300 + */
2301 + stack[stackIdx].psePatRef = beginPatRef;
2302 + stack[stackIdx].pseHighLightCode = beginPatHighLightCode;
2303 + stack[stackIdx].pseBackRefInfo = *beginPatBackRefInfo;
2304 + stackIdx ++;
2305 +
2306 + currentElement = patTable->mptElements[beginPatRef.prElementIdx];
2307 +
2308 + beginPatternIsMono = currentElement->mpteIsMonoPattern;
2309 +
2310 + groupIdx = currentElement->mpteGroup;
2311 +
2312 + /*
2313 + * no next pattern can be found, if there is no group assigned
2314 + * to begin pattern (should never occur)
2315 + */
2316 + if (groupIdx == NO_GROUP_IDX)
2317 + {
2318 + *matchEndPos = -1;
2319 +
2320 + return -1;
2321 + }
2322 +
2323 + /*
2324 + * Remember pattern (= keywords) regular expression of context
2325 + * group related to begin pattern. Use it for forward search.
2326 + */
2327 + groupPatRE = table->smtGroups[groupIdx]->mpgeKeywordRE;
2328 + currentPatRE = groupPatRE;
2329 +
2330 + /*
2331 + * Use start / end pattern regular expression if skip to end is
2332 + * set for begin pattern.
2333 + */
2334 + if (currentElement->mpteSkipBtwnStartEnd)
2335 + {
2336 + currentPatRE = currentElement->mpteStartEndRE;
2337 + skipToEnd = TRUE;
2338 + }
2339 +
2340 + while (stackIdx > 0 && nxtPatStartPos != -1)
2341 + {
2342 + /*
2343 + * Search for next string pattern in forward direction.
2344 + */
2345 + nxtPatStartPos =
2346 + searchPatternForward(
2347 + patTable,
2348 + currentPatRE,
2349 + searchRegion,
2350 + delimiters,
2351 + startPos,
2352 + &nxtPatEndPos,
2353 + &nxtPatRef,
2354 + &nxtPatHighLightCode,
2355 + &nxtPatBackRefInfo );
2356 +
2357 + startPatRef = stack[stackIdx-1].psePatRef;
2358 +
2359 + if (nxtPatStartPos == -1)
2360 + {
2361 + /*
2362 + * no next pattern found -> leave loop
2363 + */
2364 +#ifdef DEBUG_FIND
2365 + printf(" SI: %d [start K: %s EI: %d PI %d] Pos: %d --> no next pat. found\n",
2366 + stackIdx,
2367 + patElemKindToString(startPatRef.prKind),
2368 + startPatRef.prElementIdx,
2369 + startPatRef.prPatternIdx,
2370 + startPos);
2371 +#endif
2372 + break;
2373 + }
2374 +
2375 + /*
2376 + * Update start pattern reference depending on next pattern
2377 + * located after start pattern.
2378 + */
2379 + considerNextPatternReference(
2380 + patTable,
2381 + &startPatRef,
2382 + nxtPatRef,
2383 + groupIdx );
2384 +
2385 + /*
2386 + * If current found match pattern table element is a mono pattern and
2387 + * skip to start pattern is active, then the found pattern string is
2388 + * a END one in case of ambiguous or no syntax was detected.
2389 + */
2390 + if (skipToEnd &&
2391 + (nxtPatRef.prMonoInfo == PEMI_MONO_AMBIGUOUS_SYNTAX ||
2392 + nxtPatRef.prMonoInfo == PEMI_MONO_NOT_SYNTAX_BASED))
2393 + {
2394 + nxtPatRef.prKind = PEK_END;
2395 + }
2396 +
2397 +#ifdef DEBUG_FIND
2398 + printf(" SI: %d [start K: %s EI: %d PI %d] Pos: %d-%d K: %s EI: %d PI: %d HC: %d f=<%s> ",
2399 + stackIdx,
2400 + patElemKindToString(startPatRef.prKind),
2401 + startPatRef.prElementIdx,
2402 + startPatRef.prPatternIdx,
2403 + nxtPatStartPos,
2404 + nxtPatEndPos,
2405 + patElemKindToString(nxtPatRef.prKind),
2406 + nxtPatRef.prElementIdx,
2407 + nxtPatRef.prPatternIdx,
2408 + nxtPatHighLightCode,
2409 + getPatternForDebug(patTable, nxtPatRef) );
2410 + printFoundStringForDebug(
2411 + searchRegion->sriWindow,
2412 + nxtPatStartPos + searchRegion->sriStartOfTextPos,
2413 + nxtPatEndPos - nxtPatStartPos);
2414 + printf("\n");
2415 +#endif
2416 +
2417 + if (nxtPatRef.prKind == PEK_START)
2418 + {
2419 + if (stackIdx >= MAX_NESTED_PATTERNS)
2420 + {
2421 +#ifdef DEBUG_FIND
2422 + printf("FORWARD: MAX. NESTED PATTERN DEPTH REACHED !\n");
2423 +#endif
2424 + nxtPatStartPos = -1;
2425 + nxtPatEndPos = -1;
2426 + }
2427 + else if (!skipToEnd)
2428 + {
2429 + /*
2430 + * Put next pattern on stack, if contents between start /
2431 + * end shouldn't be skipped (if "skipToEnd" is set,
2432 + * a (usually illegal) start pattern to skip inside the
2433 + * skipped one is found (e.g. \* \* ..)
2434 + */
2435 + stack[stackIdx].psePatRef = nxtPatRef;
2436 + stack[stackIdx].pseHighLightCode = nxtPatHighLightCode;
2437 + stack[stackIdx].pseBackRefInfo = nxtPatBackRefInfo;
2438 + stackIdx ++;
2439 +
2440 + currentElement = patTable->mptElements[nxtPatRef.prElementIdx];
2441 +
2442 + /*
2443 + * Use start / end pattern regular expression if skip to
2444 + * end is set for found start pattern.
2445 + */
2446 + if (currentElement->mpteSkipBtwnStartEnd)
2447 + {
2448 + currentPatRE = currentElement->mpteStartEndRE;
2449 + skipToEnd = TRUE;
2450 + }
2451 + }
2452 + else if (beginPatternIsMono)
2453 + {
2454 + /*
2455 + * skip to end is set and a mono pattern start is reached:
2456 + * trigger backward search by returning "not found"
2457 + */
2458 +#ifdef DEBUG_FIND
2459 + printf(" ---> mono pattern (re-)start -> trigger backward search\n");
2460 +#endif
2461 + nxtPatStartPos = -1;
2462 + nxtPatEndPos = -1;
2463 + }
2464 +#ifdef DEBUG_FIND
2465 + else
2466 + {
2467 + printf(" ---> skip to end: illegal (re-)start pattern !\n");
2468 + }
2469 +#endif
2470 + }
2471 + else if (nxtPatRef.prKind == PEK_END)
2472 + {
2473 + /*
2474 + * ignore current found pattern, if it doesn't fit to the prev.
2475 + * opened one.
2476 + */
2477 + if (isPartOfPattern(
2478 + patTable,
2479 + nxtPatRef.prElementIdx,
2480 + startPatRef.prElementIdx,
2481 + PEK_END) &&
2482 + (stack[stackIdx - 1].pseHighLightCode == nxtPatHighLightCode ||
2483 + stack[stackIdx - 1].pseHighLightCode == IGNORE_HIGHLIGHT_CODE ||
2484 + nxtPatHighLightCode == IGNORE_HIGHLIGHT_CODE) &&
2485 + doesBackRefInfoMatch(
2486 + &stack[stackIdx - 1].pseBackRefInfo,
2487 + &nxtPatBackRefInfo))
2488 + {
2489 + /*
2490 + * use context group pattern again, if end pattern to skip
2491 + * to was found.
2492 + */
2493 + if (skipToEnd)
2494 + {
2495 + currentPatRE = groupPatRE;
2496 + skipToEnd = FALSE;
2497 + }
2498 +
2499 + /*
2500 + * pop. related start pattern from stack.
2501 + */
2502 + stackIdx --;
2503 + }
2504 + }
2505 + else if (!skipToEnd)
2506 + {
2507 + /*
2508 + * middle pattern was found: ignore it, if found middle pattern
2509 + * doesn't belong to begin pattern.
2510 + */
2511 + if (stackIdx == 1 &&
2512 + isPartOfPattern(
2513 + patTable,
2514 + startPatRef.prElementIdx,
2515 + nxtPatRef.prElementIdx,
2516 + nxtPatRef.prKind) &&
2517 + (beginPatHighLightCode == nxtPatHighLightCode ||
2518 + beginPatHighLightCode == IGNORE_HIGHLIGHT_CODE ||
2519 + nxtPatHighLightCode == IGNORE_HIGHLIGHT_CODE) &&
2520 + doesBackRefInfoMatch(
2521 + beginPatBackRefInfo,
2522 + &nxtPatBackRefInfo))
2523 +
2524 + {
2525 + stackIdx --;
2526 + }
2527 + }
2528 +
2529 + startPos = nxtPatEndPos;
2530 + }
2531 +
2532 + *matchEndPos = nxtPatEndPos;
2533 +
2534 + return nxtPatStartPos;
2535 +}
2536 +
2537 +/*
2538 +** Find matching pattern related to given pattern (stored in
2539 +** 'matchInfo') in backward direction by considering the rules stored in
2540 +** string match table of given window. Determine match position (= abs.
2541 +** pos. of 1st character of matching string) and length of matching
2542 +** string.
2543 +** Returns true, if a matching pattern was found.
2544 +*/
2545 +static int parseStringElementBackward(
2546 + MatchingElementInfo *matchInfo,
2547 + SearchRegionInfo *searchRegion,
2548 + int relCharPos,
2549 + int *matchPos,
2550 + int *matchedPatternLength,
2551 + const char *delimiters)
2552 +{
2553 + StringMatchTable *smTable =
2554 + (StringMatchTable *)searchRegion->sriWindow->stringMatchTable;
2555 + int beginPos;
2556 + int startStartPos;
2557 + int matchingPatternFound = FALSE;
2558 +
2559 + /*
2560 + * determine begin of search in string buffer (= relative position
2561 + * of 1st char. before found string pattern.)
2562 + */
2563 + beginPos = relCharPos - matchInfo->meiLength - 1;
2564 +
2565 + if (beginPos < 0)
2566 + return FALSE;
2567 +
2568 + /*
2569 + * Find matching pattern within text buffer area to parse in
2570 + * backward direction.
2571 + */
2572 + startStartPos =
2573 + findRelatedStartPattern(
2574 + smTable,
2575 + searchRegion,
2576 + delimiters,
2577 + matchInfo->meiPatRef,
2578 + matchInfo->meiHighLightCode,
2579 + &matchInfo->meiBackRefInfo,
2580 + beginPos,
2581 + matchedPatternLength);
2582 +
2583 + if (startStartPos != -1)
2584 + {
2585 + *matchPos = startStartPos + searchRegion->sriStartOfTextPos;
2586 + matchingPatternFound = TRUE;
2587 + }
2588 +
2589 + return matchingPatternFound;
2590 +}
2591 +
2592 +/*
2593 +** Find matching pattern related to given begin pattern reference
2594 +** in backward direction by considering the rules stored in given
2595 +** string match table. Determine match position (= relative
2596 +** pos. of 1st character of matching string).
2597 +** Returns -1, if no matching pattern was found. Else the relative
2598 +** position of 1st char. of matching string is returned.
2599 +*/
2600 +static int findRelatedStartPattern(
2601 + StringMatchTable *table,
2602 + SearchRegionInfo *searchRegion,
2603 + const char *delimiters,
2604 + PatternReference beginPatRef,
2605 + int beginPatHighLightCode,
2606 + BackRefInfo *beginPatBackRefInfo,
2607 + int beginPos,
2608 + int *matchedPatternLength)
2609 +{
2610 + MatchPatternTable *patTable = table->smtAllPatterns;
2611 + int startPos = beginPos;
2612 + int prevStartPos = 0;
2613 + PatternReference prevPatRef;
2614 + int prevPatHighLightCode;
2615 + BackRefInfo prevPatBackRefInfo;
2616 + PatternStackElement stack[MAX_NESTED_PATTERNS];
2617 + int stackIdx = 0;
2618 + MatchPatternTableElement *currentElement;
2619 + int groupIdx;
2620 + regexp *groupPatRE;
2621 + regexp *currentPatRE;
2622 + int skipToStart = FALSE;
2623 +
2624 + /*
2625 + * put begin pattern info on stack
2626 + */
2627 + stack[stackIdx].psePatRef = beginPatRef;
2628 + stack[stackIdx].pseHighLightCode = beginPatHighLightCode;
2629 + stack[stackIdx].pseBackRefInfo = *beginPatBackRefInfo;
2630 + stackIdx ++;
2631 +
2632 + currentElement = patTable->mptElements[beginPatRef.prElementIdx];
2633 +
2634 +#ifdef DEBUG_FIND
2635 + printf("Backward Start Pos: %d K: %s EI: %d PI: %d HC: %d <%s>\n",
2636 + startPos,
2637 + patElemKindToString(beginPatRef.prKind),
2638 + beginPatRef.prElementIdx,
2639 + beginPatRef.prPatternIdx,
2640 + beginPatHighLightCode,
2641 + getPatternForDebug(patTable, beginPatRef) );
2642 +#endif
2643 +
2644 + groupIdx = currentElement->mpteGroup;
2645 +
2646 + /*
2647 + * no start pattern can be found, if there is no group assigned
2648 + * to begin pattern (should never occur)
2649 + */
2650 + if (groupIdx == NO_GROUP_IDX)
2651 + {
2652 + return -1;
2653 + }
2654 +
2655 + /*
2656 + * Remember pattern (= keywords) regular expression of context
2657 + * group related to begin pattern. Use it for backward search.
2658 + */
2659 + groupPatRE = table->smtGroups[groupIdx]->mpgeKeywordRE;
2660 + currentPatRE = groupPatRE;
2661 +
2662 + /*
2663 + * Use start / end pattern regular expression if skip to start is
2664 + * set for begin pattern.
2665 + */
2666 + if (currentElement->mpteSkipBtwnStartEnd)
2667 + {
2668 + currentPatRE = currentElement->mpteStartEndRE;
2669 + skipToStart = TRUE;
2670 + }
2671 +
2672 + while (stackIdx > 0 && prevStartPos != -1)
2673 + {
2674 + /*
2675 + * Search for previous string pattern in backward direction.
2676 + */
2677 + prevStartPos =
2678 + searchPatternBackward(
2679 + patTable,
2680 + currentPatRE,
2681 + searchRegion,
2682 + delimiters,
2683 + startPos,
2684 + &prevPatRef,
2685 + &prevPatHighLightCode,
2686 + matchedPatternLength,
2687 + &prevPatBackRefInfo );
2688 +
2689 + if (prevStartPos == -1)
2690 + {
2691 + /*
2692 + * no previous pattern found -> leave loop
2693 + */
2694 +#ifdef DEBUG_FIND
2695 + printf(" SI: %d [K: %s start EI: %d PI %d] Pos: %d --> no next pat. found\n",
2696 + stackIdx,
2697 + patElemKindToString(stack[stackIdx -1].psePatRef.prKind),
2698 + stack[stackIdx -1].psePatRef.prElementIdx,
2699 + stack[stackIdx -1].psePatRef.prPatternIdx,
2700 + startPos);
2701 +#endif
2702 + break;
2703 + }
2704 +
2705 + /*
2706 + * Update previous pattern reference depending on last stack
2707 + * pattern, which is located in text puffer after previous
2708 + * start pattern.
2709 + */
2710 + considerNextPatternReference(
2711 + patTable,
2712 + &prevPatRef,
2713 + stack[stackIdx - 1].psePatRef,
2714 + groupIdx);
2715 +
2716 + /*
2717 + * If current found match pattern table element is a mono pattern and
2718 + * skip to start pattern is active, then the found pattern string is
2719 + * a START one in case of ambiguous or no syntax was detected.
2720 + */
2721 + if (skipToStart &&
2722 + (prevPatRef.prMonoInfo == PEMI_MONO_AMBIGUOUS_SYNTAX ||
2723 + prevPatRef.prMonoInfo == PEMI_MONO_NOT_SYNTAX_BASED))
2724 + {
2725 + prevPatRef.prKind = PEK_START;
2726 + }
2727 +
2728 +#ifdef DEBUG_FIND
2729 + printf(" SI: %d [K: %s start EI: %d PI %d] Pos: %d K: %s EI: %d PI: %d HC: %d f=<%s> ",
2730 + stackIdx,
2731 + patElemKindToString(stack[stackIdx -1].psePatRef.prKind),
2732 + stack[stackIdx -1].psePatRef.prElementIdx,
2733 + stack[stackIdx -1].psePatRef.prPatternIdx,
2734 + prevStartPos,
2735 + patElemKindToString(prevPatRef.prKind),
2736 + prevPatRef.prElementIdx,
2737 + prevPatRef.prPatternIdx,
2738 + prevPatHighLightCode,
2739 + getPatternForDebug(patTable, prevPatRef) );
2740 + printFoundStringForDebug(
2741 + searchRegion->sriWindow,
2742 + prevStartPos + searchRegion->sriStartOfTextPos,
2743 + *matchedPatternLength);
2744 + printf("\n");
2745 +#endif
2746 +
2747 + if (prevPatRef.prKind == PEK_START)
2748 + {
2749 + /*
2750 + * If the end pattern of the previous pattern set is a reference,
2751 + * then the prev. element index is the one of the ref. (due to this
2752 + * string was found before and was stored on stack)
2753 + */
2754 + if (patTable->mptElements[prevPatRef.prElementIdx]->mpteGroup == groupIdx)
2755 + {
2756 + considerStackPatReference(
2757 + &patTable->mptElements[prevPatRef.prElementIdx]->mpteEnd,
2758 + stack[stackIdx - 1].psePatRef.prElementIdx,
2759 + &prevPatRef.prElementIdx);
2760 + }
2761 +
2762 + /*
2763 + * Ignore current found pattern, if it doesn't fit to the prev.
2764 + * opened one.
2765 + */
2766 + if (stack[stackIdx - 1].psePatRef.prElementIdx == prevPatRef.prElementIdx &&
2767 + (stack[stackIdx - 1].pseHighLightCode == prevPatHighLightCode ||
2768 + stack[stackIdx - 1].pseHighLightCode == IGNORE_HIGHLIGHT_CODE ||
2769 + prevPatHighLightCode == IGNORE_HIGHLIGHT_CODE) &&
2770 + doesBackRefInfoMatch(
2771 + &stack[stackIdx - 1].pseBackRefInfo,
2772 + &prevPatBackRefInfo))
2773 + {
2774 + /*
2775 + * use context group pattern again, if start pattern
2776 + * to skip to was found.
2777 + */
2778 + if (skipToStart)
2779 + {
2780 + currentPatRE = groupPatRE;
2781 + skipToStart = FALSE;
2782 + }
2783 +
2784 + /*
2785 + * pop. related end pattern from stack.
2786 + */
2787 + stackIdx --;
2788 + }
2789 + }
2790 + else if (prevPatRef.prKind == PEK_END)
2791 + {
2792 + if (stackIdx >= MAX_NESTED_PATTERNS)
2793 + {
2794 +#ifdef DEBUG_FIND
2795 + printf("BACKWARD: MAX. NESTED PATTERN DEPTH REACHED !\n");
2796 +#endif
2797 + prevStartPos = -1;
2798 + }
2799 + else if (!skipToStart)
2800 + {
2801 + /*
2802 + * Put prev. pattern on stack, if contents between start /
2803 + * end shouldn't be skipped (if "skipToStart" is set,
2804 + * a (usually illegal) end pattern to skip inside the
2805 + * skipped one is found (e.g. *\ *\ ..)
2806 + */
2807 + stack[stackIdx].psePatRef = prevPatRef;
2808 + stack[stackIdx].pseHighLightCode = prevPatHighLightCode;
2809 + stack[stackIdx].pseBackRefInfo = prevPatBackRefInfo;
2810 + stackIdx ++;
2811 +
2812 + currentElement =
2813 + patTable->mptElements[prevPatRef.prElementIdx];
2814 +
2815 + /*
2816 + * Use start / end pattern regular expression if skip to
2817 + * end is set for found end pattern.
2818 + */
2819 + if (currentElement->mpteSkipBtwnStartEnd)
2820 + {
2821 + currentPatRE = currentElement->mpteStartEndRE;
2822 + skipToStart = TRUE;
2823 + }
2824 + }
2825 + }
2826 + startPos = prevStartPos - 1;
2827 + }
2828 +
2829 + return prevStartPos;
2830 +}
2831 +
2832 +/*
2833 +** Adapt found pattern element index depending on
2834 +** the info stored on (last) stack element and
2835 +** a given pattern set (belonging to the found pattern).
2836 +*/
2837 +static void considerStackPatReference(
2838 + PatternElementSet *patSet,
2839 + int stackElementIdx,
2840 + int *foundElementIdx)
2841 +{
2842 + PatternElement *patElement;
2843 + int i;
2844 +
2845 + /*
2846 + * If found pattern index already indicates, that found pattern
2847 + * belongs to pattern set stored on stack, then no adaption is needed
2848 + */
2849 + if (*foundElementIdx == stackElementIdx)
2850 + return;
2851 +
2852 + /*
2853 + * Check all elements of given pattern element set:
2854 + */
2855 + for (i=0; i < patSet->pesNumberOfPattern; i++)
2856 + {
2857 + patElement = patSet->pesPattern[i];
2858 +
2859 + /*
2860 + * If this set element is a reference and this reference fits
2861 + * to the element stored on stack, then adapt found element index:
2862 + * indicate, that found pattern belongs to pattern set stored on stack
2863 + */
2864 + if (patElement->peType == PET_REFERENCE &&
2865 + patElement->peVal.peuRef.prElementIdx == stackElementIdx)
2866 + {
2867 + *foundElementIdx = stackElementIdx;
2868 +
2869 + return;
2870 + }
2871 + }
2872 +}
2873 +
2874 +/*
2875 +** Determines, if a string pattern is located at the given position
2876 +** "relBeginPos" in the given "searchRegion". A string pattern is
2877 +** found, if the pattern is located just before given position
2878 +** "relBeginPos" OR if "relBeginPos" is located within a string pattern.
2879 +**
2880 +** Returns true, if the given "pattern" is located at
2881 +** "relBeginPos". "matchInfo" holds all info needed about matched
2882 +** "start" string pattern.
2883 +*/
2884 +static int getPatternLocatedAtPos(
2885 + regexp *usedPatRE,
2886 + MatchPatternTable *table,
2887 + SearchRegionInfo *searchRegion,
2888 + int *relBeginPos,
2889 + MatchingElementInfo *matchInfo,
2890 + const char *delimiters)
2891 +{
2892 + int searchStartPos = *relBeginPos;
2893 + PatternReference *patRef = &matchInfo->meiPatRef;
2894 + FoundStringInfo foundStringInfo;
2895 + int relMatchStartPos;
2896 + int relMatchEndPos;
2897 +
2898 + patRef->prElementIdx = NO_ELEMENT_IDX;
2899 + patRef->prKind = PEK_UNKNOWN;
2900 + patRef->prPatternIdx = NO_PATTERN_IDX;
2901 +
2902 + matchInfo->meiHighLightCode = IGNORE_HIGHLIGHT_CODE;
2903 + matchInfo->meiAbsStartPos = -1;
2904 + matchInfo->meiLength = 0;
2905 +
2906 + /*
2907 + * No backward search possible, if we are at beginning of
2908 + * search region
2909 + */
2910 + if (searchStartPos == 0)
2911 + return FALSE;
2912 +
2913 + /*
2914 + * Search in backward direction for 1st occurance of a string pattern
2915 + * starting one char before "searchStartPos".
2916 + */
2917 + if (ExecRE(
2918 + usedPatRE,
2919 + searchRegion->sriText,
2920 + searchRegion->sriText + searchStartPos - 1,
2921 + TRUE,
2922 + searchRegion->sriPrevChar,
2923 + searchRegion->sriText[searchStartPos],
2924 + delimiters,
2925 + searchRegion->sriText,
2926 + NULL))
2927 + {
2928 + /*
2929 + * String pattern was found:
2930 + */
2931 + foundStringInfo.fsiStartPtr = usedPatRE->startp[0];
2932 + foundStringInfo.fsiEndPtr = usedPatRE->endp[0];
2933 + foundStringInfo.fsiLength =
2934 + foundStringInfo.fsiEndPtr - foundStringInfo.fsiStartPtr;
2935 +
2936 + relMatchEndPos = foundStringInfo.fsiEndPtr - searchRegion->sriText;
2937 + relMatchStartPos = foundStringInfo.fsiStartPtr - searchRegion->sriText;
2938 +
2939 + /*
2940 + * Is found pattern located exactly one char before "relBeginPos" OR
2941 + * is "relBeginPos" located within found string pattern ?
2942 + * Note: "relMatchEndPos" indicates 1st pos. in "sriText"
2943 + * which does *not* belong to found string anymore.
2944 + */
2945 + if ((*relBeginPos == relMatchEndPos) ||
2946 + (*relBeginPos >= relMatchStartPos &&
2947 + *relBeginPos < relMatchEndPos))
2948 + {
2949 + *relBeginPos = relMatchEndPos;
2950 +
2951 + /*
2952 + * Determine match element info related to found string.
2953 + */
2954 + matchInfo->meiAbsStartPos =
2955 + foundStringInfo.fsiStartPtr - searchRegion->sriText +
2956 + searchRegion->sriStartOfTextPos;
2957 + matchInfo->meiLength = foundStringInfo.fsiLength;
2958 +
2959 + foundStringInfo.fsiPrevChar =
2960 + foundStringInfo.fsiStartPtr == searchRegion->sriText ?
2961 + searchRegion->sriPrevChar : *(foundStringInfo.fsiStartPtr - 1);
2962 +
2963 + foundStringInfo.fsiSuccChar =
2964 + *(foundStringInfo.fsiEndPtr) == '\0' ?
2965 + searchRegion->sriSuccChar : *(foundStringInfo.fsiEndPtr);
2966 +
2967 + foundStringInfo.fsiDelimiters = delimiters;
2968 +
2969 + return(
2970 + getMatchedElementInfo(
2971 + searchRegion->sriWindow,
2972 + table,
2973 + &foundStringInfo,
2974 + matchInfo));
2975 + }
2976 + }
2977 +
2978 + return FALSE;
2979 +}
2980 +
2981 +/*
2982 +** Get all needed info related to matched "start" string pattern
2983 +** (given by parameter "foundStringInfo").
2984 +**
2985 +** Returns true, if info was determined successfully.
2986 +*/
2987 +static int getMatchedElementInfo(
2988 + WindowInfo *window,
2989 + MatchPatternTable *table,
2990 + FoundStringInfo *foundStringInfo,
2991 + MatchingElementInfo *matchInfo)
2992 +{
2993 + PatternReference *patRef = &matchInfo->meiPatRef;
2994 + int absMatchStartPos = matchInfo->meiAbsStartPos;
2995 + MatchPatternTableElement *matchedElement;
2996 +
2997 + if (getPatternInfo(
2998 + table,
2999 + foundStringInfo,
3000 + patRef,
3001 + &matchInfo->meiBackRefInfo))
3002 + {
3003 + /*
3004 + * A pattern reference could be assigned to found string:
3005 + */
3006 + matchedElement = table->mptElements[patRef->prElementIdx];
3007 +
3008 + matchInfo->meiElement = matchedElement;
3009 +
3010 + /*
3011 + * get highlight code of found string pattern, if applicable
3012 + */
3013 + if (!matchedElement->mpteIgnoreHighLightInfo)
3014 + {
3015 + matchInfo->meiHighLightCode =
3016 + HighlightCodeOfPos(window, absMatchStartPos);
3017 + }
3018 +
3019 + /*
3020 + * setup mono pattern info of found string pattern
3021 + */
3022 + if (matchedElement->mpteIsMonoPattern)
3023 + {
3024 + if (matchedElement->mpteIgnoreHighLightInfo)
3025 + {
3026 + patRef->prMonoInfo = PEMI_MONO_NOT_SYNTAX_BASED;
3027 + }
3028 + else
3029 + {
3030 + /*
3031 + * determine mono pattern info depending on highLightCodes
3032 + * before / after found string pattern.
3033 + */
3034 + patRef->prMonoInfo =
3035 + determineMonoPatInfo(
3036 + window,
3037 + matchInfo->meiHighLightCode,
3038 + absMatchStartPos - 1,
3039 + absMatchStartPos + matchInfo->meiLength,
3040 + &patRef->prKind);
3041 + }
3042 + }
3043 + else
3044 + {
3045 + patRef->prMonoInfo = PEMI_NOT_MONO;
3046 + }
3047 +
3048 + return TRUE;
3049 + }
3050 + else
3051 + {
3052 + /*
3053 + * Found string can't be assigned to a pattern element
3054 + * (should never occur).
3055 + */
3056 + return FALSE;
3057 + }
3058 +}
3059 +
3060 +/*
3061 +** Returns string pattern of given pattern element.
3062 +*/
3063 +StringPattern *GetStringPattern(
3064 + MatchPatternTable *table,
3065 + PatternElement *pattern )
3066 +{
3067 + switch (pattern->peType)
3068 + {
3069 + case PET_SINGLE:
3070 + return &pattern->peVal.peuSingle;
3071 + break;
3072 +
3073 + case PET_MULTIPLE:
3074 + return &pattern->peVal.peuMulti.mpStringPattern;
3075 + break;
3076 +
3077 + case PET_REFERENCE:
3078 + return GetStringPattern(
3079 + table,
3080 + getPatternOfReference(table, pattern->peVal.peuRef));
3081 + break;
3082 + }
3083 +
3084 + /*
3085 + * never reached; just to make compiler happy
3086 + */
3087 + return NULL;
3088 +}
3089 +
3090 +/*
3091 +** Returns pattern element of given pattern reference.
3092 +*/
3093 +static PatternElement *getPatternOfReference(
3094 + MatchPatternTable *table,
3095 + PatternReference patRef)
3096 +{
3097 + MatchPatternTableElement **element = table->mptElements;
3098 +
3099 + return element[ patRef.prElementIdx ]->mpteAll.pesPattern[patRef.prPatternIdx];
3100 +}
3101 +
3102 +#ifdef DEBUG_FIND
3103 +static char *getPatternForDebug(
3104 + MatchPatternTable *table,
3105 + PatternReference patRef )
3106 +{
3107 + if (patRef.prElementIdx < 0)
3108 + {
3109 + return "---";
3110 + }
3111 +
3112 + return
3113 + GetStringPattern(
3114 + table,
3115 + getPatternOfReference(table, patRef))->spText;
3116 +}
3117 +
3118 +static char *patElemKindToString(
3119 + PatternElementKind patElemKind)
3120 +{
3121 + if (patElemKind == PEK_START)
3122 + return "START";
3123 + else if (patElemKind == PEK_MIDDLE)
3124 + return "MIDDLE";
3125 + else if (patElemKind == PEK_END)
3126 + return "END";
3127 + else
3128 + return "UNKNOWN";
3129 +}
3130 +
3131 +static void printFoundStringForDebug(
3132 + WindowInfo *window,
3133 + int absStartPos,
3134 + int length)
3135 +{
3136 + char *foundStr =
3137 + BufGetRange( window->buffer, absStartPos, absStartPos + length);
3138 +
3139 + printf("%d (abs.) <%s>",
3140 + absStartPos,
3141 + foundStr);
3142 +
3143 + XtFree(foundStr);
3144 +}
3145 +#endif
3146 +
3147 +
3148 diff --quilt /dev/null new/source/patternMatch.h
3149 --- /dev/null
3150 +++ new/source/patternMatch.h
3151 @@ -0,0 +1,170 @@
3152 +/* $Id: patternMatch.h,v 1.2 2003/10/11 16:45:25 uleh Exp $ */
3153 +
3154 +#ifndef NEDIT_PATTERNMATCH_H_INCLUDED
3155 +#define NEDIT_PATTERNMATCH_H_INCLUDED
3156 +
3157 +#include "regularExp.h"
3158 +
3159 +#define NO_GROUP_IDX -1
3160 +#define NO_ELEMENT_IDX -1
3161 +#define NO_PATTERN_IDX -1
3162 +
3163 +#define MAX_GLOBAL_BACK_REF_ID 9
3164 +#define NO_LOCAL_BACK_REF_ID -1
3165 +
3166 +typedef enum {
3167 + PEK_UNKNOWN,
3168 + PEK_START,
3169 + PEK_END,
3170 + PEK_MIDDLE
3171 +} PatternElementKind;
3172 +
3173 +typedef enum {
3174 + PEMI_NOT_MONO,
3175 + PEMI_MONO_NOT_SYNTAX_BASED,
3176 + PEMI_MONO_AMBIGUOUS_SYNTAX,
3177 + PEMI_MONO_DEFINITE_SYNTAX
3178 +} PatternElementMonoInfo;
3179 +
3180 +typedef struct _PatternReference {
3181 + PatternElementKind prKind;
3182 + PatternElementMonoInfo prMonoInfo;
3183 + int prElementIdx;
3184 + int prPatternIdx;
3185 +} PatternReference;
3186 +
3187 +typedef enum {
3188 + MPT_INDIVIDUAL,
3189 + MPT_SUB,
3190 + MPT_GROUP
3191 +} MatchPatternType;
3192 +
3193 +typedef struct _MatchPatternSequenceElement {
3194 + char *mpseName;
3195 + MatchPatternType mpseType;
3196 + int mpseIndex;
3197 +} MatchPatternSequenceElement;
3198 +
3199 +typedef struct _MatchPatternGroupElement {
3200 + char *mpgeName;
3201 + int mpgeNumberOfSubPatterns;
3202 + char **mpgeSubPatternIds;
3203 + regexp *mpgeKeywordRE;
3204 +} MatchPatternGroupElement;
3205 +
3206 +typedef enum {
3207 + PWB_NONE,
3208 + PWB_LEFT,
3209 + PWB_RIGHT,
3210 + PWB_BOTH
3211 +} PatternWordBoundary;
3212 +
3213 +typedef struct _StrPatBackRefElement{
3214 + int spbreLocalBackRefID;
3215 + char *spbreRegExpText;
3216 +} StrPatBackRefElement;
3217 +
3218 +typedef struct _StringPattern {
3219 + char *spText;
3220 + int spLength;
3221 + PatternWordBoundary spWordBoundary;
3222 + int spCaseInsensitive;
3223 + int spRegularExpression;
3224 + regexp *spTextRE;
3225 + char *spOrigText;
3226 + int spBackRefParsed;
3227 + int spBackRefResolved;
3228 + StrPatBackRefElement spOwnGlobalBackRef[MAX_GLOBAL_BACK_REF_ID];
3229 + int spGlobalToLocalBackRef[MAX_GLOBAL_BACK_REF_ID];
3230 +} StringPattern;
3231 +
3232 +typedef struct _MultiPattern {
3233 + StringPattern mpStringPattern;
3234 + int mpNumberOfReferences;
3235 + PatternReference *mpRefList;
3236 +} MultiPattern;
3237 +
3238 +typedef enum {
3239 + PET_SINGLE,
3240 + PET_MULTIPLE,
3241 + PET_REFERENCE
3242 +} PatternElementType;
3243 +
3244 +typedef struct _PatternElement {
3245 + int peIndex;
3246 + PatternElementKind peKind;
3247 + PatternElementType peType;
3248 + union {
3249 + StringPattern peuSingle;
3250 + MultiPattern peuMulti;
3251 + PatternReference peuRef;
3252 + } peVal;
3253 +} PatternElement;
3254 +
3255 +typedef struct _PatternElementSet {
3256 + int pesNumberOfPattern;
3257 + PatternElement **pesPattern;
3258 +} PatternElementSet;
3259 +
3260 +typedef struct _GlobalBackRefElement{
3261 + StringPattern *gbreDefByStrPat;
3262 + char *gbreRegExpText;
3263 +} GlobalBackRefElement;
3264 +
3265 +typedef struct _MatchPatternTableElement {
3266 + char *mpteName;
3267 + int mpteIndex;
3268 + MatchPatternType mpteType;
3269 + int mpteGroup;
3270 + PatternElementSet mpteAll;
3271 + PatternElementSet mpteStart;
3272 + PatternElementSet mpteMiddle;
3273 + PatternElementSet mpteEnd;
3274 + int mpteFlash;
3275 + int mpteIsMonoPattern;
3276 + int mpteSkipBtwnStartEnd;
3277 + int mpteIgnoreHighLightInfo;
3278 + regexp *mpteStartEndRE;
3279 + GlobalBackRefElement mpteGlobalBackRef[MAX_GLOBAL_BACK_REF_ID];
3280 +} MatchPatternTableElement;
3281 +
3282 +typedef struct _MatchPatternTable {
3283 + int mptNumberOfElements;
3284 + MatchPatternTableElement **mptElements;
3285 +} MatchPatternTable;
3286 +
3287 +typedef struct _StringMatchTable {
3288 + char *smtLanguageMode;
3289 + MatchPatternTable *smtAllPatterns;
3290 + regexp *smtAllPatRE;
3291 + regexp *smtFlashPatRE;
3292 + regexp *smtUsedPatRE;
3293 + int smtNumberOfGroups;
3294 + MatchPatternGroupElement **smtGroups;
3295 + int smtNumberOfSeqElements;
3296 + MatchPatternSequenceElement **smtSequence;
3297 +} StringMatchTable;
3298 +
3299 +typedef enum {
3300 + MT_FLASH_DELIMIT,
3301 + MT_FLASH_RANGE,
3302 + MT_SELECT,
3303 + MT_GOTO,
3304 + MT_MACRO
3305 +} MatchingType;
3306 +
3307 +int FindMatchingString(
3308 + WindowInfo *window,
3309 + MatchingType matchingType,
3310 + int *charPos,
3311 + int startLimit,
3312 + int endLimit,
3313 + int *matchPos,
3314 + int *matchLength,
3315 + int *direction);
3316 +
3317 +StringPattern *GetStringPattern(
3318 + MatchPatternTable *table,
3319 + PatternElement *pattern);
3320 +
3321 +#endif /* NEDIT_PATTERNMATCH_H_INCLUDED */
3322 diff --quilt /dev/null new/source/patternMatchData.c
3323 --- /dev/null
3324 +++ new/source/patternMatchData.c
3325 @@ -0,0 +1,7780 @@
3326 +static const char CVSID[] = "$Id: patternMatchData.c,v 1.4 2004/10/27 21:57:12 uleh Exp $";
3327 +/*******************************************************************************
3328 +* *
3329 +* patternMatchData.c -- Maintain and allow user to edit a matching pattern list*
3330 +* used for pattern matching *
3331 +* *
3332 +* Copyright (C) 2003-2004, Uwe Lehnert *
3333 +* *
3334 +* This is free software; you can redistribute it and/or modify it under the *
3335 +* terms of the GNU General Public License as published by the Free Software *
3336 +* Foundation; either version 2 of the License, or (at your option) any later *
3337 +* version. In addition, you may distribute versions of this program linked to *
3338 +* Motif or Open Motif. See README for details. *
3339 +* *
3340 +* This software is distributed in the hope that it will be useful, but WITHOUT *
3341 +* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or *
3342 +* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License *
3343 +* for more details. *
3344 +* *
3345 +* You should have received a copy of the GNU General Public License along with *
3346 +* software; if not, write to the Free Software Foundation, Inc., 59 Temple *
3347 +* Place, Suite 330, Boston, MA 02111-1307 USA *
3348 +* *
3349 +* Nirvana Text Editor *
3350 +* October 27, 2004 *
3351 +* *
3352 +* Written by Uwe Lehnert *
3353 +* *
3354 +*******************************************************************************/
3355 +#ifdef HAVE_CONFIG_H
3356 +#include "../config.h"
3357 +#endif
3358 +
3359 +#include <stdlib.h>
3360 +#include <stdio.h>
3361 +#include <limits.h>
3362 +#include <string.h>
3363 +#include <ctype.h>
3364 +
3365 +#ifdef VMS
3366 +#include "../util/VMSparam.h"
3367 +#else
3368 +#ifndef __MVS__
3369 +#include <sys/param.h>
3370 +#endif
3371 +#endif /*VMS*/
3372 +
3373 +#include <Xm/Xm.h>
3374 +#include <Xm/Form.h>
3375 +#include <Xm/Frame.h>
3376 +#include <Xm/Text.h>
3377 +#include <Xm/LabelG.h>
3378 +#include <Xm/PushB.h>
3379 +#include <Xm/PushBG.h>
3380 +#include <Xm/ToggleB.h>
3381 +#include <Xm/RowColumn.h>
3382 +#include <Xm/SeparatoG.h>
3383 +
3384 +#include "../util/misc.h"
3385 +#include "../util/DialogF.h"
3386 +#include "../util/managedList.h"
3387 +
3388 +#include "regularExp.h"
3389 +#include "textBuf.h"
3390 +#include "nedit.h"
3391 +#include "window.h"
3392 +#include "preferences.h"
3393 +#include "help.h"
3394 +#include "file.h"
3395 +#include "textP.h"
3396 +
3397 +#include "patternMatch.h"
3398 +#include "patternMatchData.h"
3399 +
3400 +#ifdef HAVE_DEBUG_H
3401 +#include "../debug.h"
3402 +#endif
3403 +
3404 +/*
3405 + * local synonyms
3406 + */
3407 +#define MAX_LOCAL_BACK_REF_ID 9
3408 +#define LOCAL_BACK_REF_ID_USED -2
3409 +
3410 +#define MAX_NUMBER_MIDDLE_PATTERN 10
3411 +#define MAX_STRING_PATTERNS 30
3412 +#define MAX_NBR_MATCH_PATTERNS 50
3413 +#define MAX_NBR_MATCH_PATTERN_GROUPS 50
3414 +#define MAX_NBR_SEQ_ELEMENTS MAX_NBR_MATCH_PATTERNS + MAX_NBR_MATCH_PATTERN_GROUPS
3415 +
3416 +#define MATCH_PAT_NAME_LBL_TXT "Matching Pattern Name"
3417 +#define STRING_PATTERNS_LBL_TXT "String Patterns"
3418 +
3419 +#define BORDER 4
3420 +#define LIST_RIGHT 41
3421 +#define PLAIN_LM_STRING "PLAIN"
3422 +
3423 +#define SPNM_NONE_SELECTED "none selected"
3424 +
3425 +#define KEEP_LANGUAGE_MODE True
3426 +#define DISCARD_LANGUAGE_MODE False
3427 +
3428 +#define STRING_PATTERN_DIALOG True
3429 +#define CONTEXT_GROUP_DIALOG False
3430 +
3431 +/*
3432 + * local data definitions
3433 + */
3434 +typedef struct _ErrorInfo {
3435 + char *eiDetail;
3436 + char *eiLanguageMode;
3437 + char *eiMPTabElementName;
3438 + char *eiStringPatText;
3439 + char *eiRegExpCompileMsg;
3440 + int eiBackRefNbr;
3441 +} ErrorInfo;
3442 +
3443 +typedef struct _BackRefBracketInfo {
3444 + int brbiGlobalId;
3445 + char *brbiContentStart;
3446 + int brbiNestingLevel;
3447 +} BackRefBracketInfo;
3448 +
3449 +typedef struct _RegExpStringInfo {
3450 + int resiNbrOfAddedMultiPat;
3451 + PatternReference **resiAddedMultiPat;
3452 + char *resiNoneWBRegExpString;
3453 + char *resiLeftWBRegExpString;
3454 + char *resiRightWBRegExpString;
3455 + char *resiBothWBRegExpString;
3456 + int resiLocalBackRefID;
3457 +} RegExpStringInfo;
3458 +
3459 +typedef struct _ReadMatchPatternInfo {
3460 + int rmpiNbrOfElements;
3461 + MatchPatternTableElement *rmpiElement[MAX_NBR_MATCH_PATTERNS];
3462 + int rmpiNbrOfGroups;
3463 + MatchPatternGroupElement *rmpiGroup[MAX_NBR_MATCH_PATTERN_GROUPS];
3464 + int rmpiNbrOfSeqElements;
3465 + MatchPatternSequenceElement *rmpiSequence[MAX_NBR_SEQ_ELEMENTS];
3466 + regexp *rmpiAllPatRE;
3467 + regexp *rmpiFlashPatRE;
3468 +} ReadMatchPatternInfo;
3469 +
3470 +typedef struct _DialogStringPatternElement {
3471 + char *dspeText;
3472 + PatternElementKind dspeKind;
3473 + PatternWordBoundary dspeWordBoundary;
3474 + int dspeCaseInsensitive;
3475 + int dspeRegularExpression;
3476 +} DialogStringPatternElement;
3477 +
3478 +typedef struct _DialogStringPatterns {
3479 + int dspNumberOfPatterns;
3480 + DialogStringPatternElement *dspElements[MAX_STRING_PATTERNS];
3481 +} DialogStringPatterns;
3482 +
3483 +typedef struct _DialogMatchPatternTableElement {
3484 + char *dmpteName;
3485 + MatchPatternType dmpteType;
3486 + DialogStringPatterns dmptePatterns;
3487 + int dmpteSkipBtwnStartEnd;
3488 + int dmpteIgnoreHighLightInfo;
3489 + int dmpteFlash;
3490 +} DialogMatchPatternTableElement;
3491 +
3492 +typedef struct _DialogMatchPatternGroupElement {
3493 + char *dmpgeName;
3494 + int dmpgeNumberOfSubPatterns;
3495 + char *dmpgeSubPatternIds[MAX_NBR_MATCH_PATTERNS];
3496 +} DialogMatchPatternGroupElement;
3497 +
3498 +typedef struct _DialogMatchPatternSequenceElement {
3499 + char *dmpseName;
3500 + MatchPatternType dmpseType;
3501 + int dmpseValid;
3502 + void *dmpsePtr;
3503 +} DialogMatchPatternSequenceElement;
3504 +
3505 +typedef struct _DialogMatchPatternInfo {
3506 + int dmpiNbrOfSeqElements;
3507 + DialogMatchPatternSequenceElement *dmpiSequence[MAX_NBR_SEQ_ELEMENTS];
3508 +} DialogMatchPatternInfo;
3509 +
3510 +typedef enum {
3511 + DMPTR_OK,
3512 + DMPTR_EMPTY,
3513 + DMPTR_INCOMPLETE
3514 +} DMPTranslationResult;
3515 +
3516 +typedef struct _NameList {
3517 + int nlNumber;
3518 + char *nlId[MAX_NBR_SEQ_ELEMENTS + 1];
3519 +} NameList;
3520 +
3521 +/*
3522 + * prototypes of local functions
3523 + */
3524 +static void treatDuplicatedPattern(
3525 + MatchPatternTable *table,
3526 + PatternElement *prevPattern,
3527 + PatternReference prevPatRef,
3528 + PatternElement *lastPattern,
3529 + PatternReference lastPatRef);
3530 +static void treatDuplicatedPatternElements(
3531 + MatchPatternTable *table,
3532 + MatchPatternTableElement *prevElement,
3533 + int prevElementIdx,
3534 + PatternElement *lastPattern,
3535 + PatternReference lastPatRef);
3536 +static void treatDuplicatedMTElements(
3537 + MatchPatternTable *table,
3538 + MatchPatternTableElement *prevElement,
3539 + int prevElementIdx,
3540 + MatchPatternTableElement *lastElement,
3541 + int lastElementIdx);
3542 +static void treatDuplicatedMTEntries(
3543 + MatchPatternTableElement **element,
3544 + int nbrOfElements);
3545 +
3546 +static int createStrPatRegExpOfElement(
3547 + ReadMatchPatternInfo *readPatInfo,
3548 + MatchPatternTableElement *element,
3549 + ErrorInfo *errInfo);
3550 +static int createStrPatRegExp(
3551 + StringPattern *strPat,
3552 + ErrorInfo *errInfo);
3553 +static void adaptCompileMsg(
3554 + char *compileMsg,
3555 + int *globalToLocalBackRef);
3556 +static int localToGlobalBackRef(
3557 + int *globalToLocalBackRef,
3558 + int localId);
3559 +static int createStartEndRegExp(
3560 + ReadMatchPatternInfo *readMatchPatternInfo,
3561 + MatchPatternTableElement *element,
3562 + ErrorInfo *errInfo);
3563 +static int createGroupRegExp(
3564 + ReadMatchPatternInfo *readPatInfo,
3565 + MatchPatternGroupElement *group,
3566 + ErrorInfo *errInfo);
3567 +static void setupRegExpStringBuffers(
3568 + ReadMatchPatternInfo *readMatchPatternInfo,
3569 + RegExpStringInfo *regExpStringInfo);
3570 +static void addSMTRegExpString(
3571 + char *result,
3572 + char *partToAdd,
3573 + const char *postfix);
3574 +static void composeStartEndRegExpString(
3575 + ReadMatchPatternInfo *readMatchPatternInfo,
3576 + MatchPatternTableElement *element,
3577 + char **regExpString);
3578 +static void addElementToRegExpString(
3579 + MatchPatternTableElement *element,
3580 + ReadMatchPatternInfo *readMatchPatternInfo,
3581 + RegExpStringInfo *regExpStringInfo);
3582 +static void addUniquePatternToRegExpString(
3583 + PatternElement *patElement,
3584 + PatternReference *patElementReference,
3585 + ReadMatchPatternInfo *readMatchPatternInfo,
3586 + RegExpStringInfo *regExpStringInfo);
3587 +static void addPatternToRegExpString(
3588 + StringPattern *pattern,
3589 + RegExpStringInfo *regExpStringInfo);
3590 +static char *adaptLocalBackRefs(
3591 + char *regExpText,
3592 + int *commonLocalId);
3593 +static void scanForLocalBackRefs(
3594 + char *regExpText,
3595 + int *localBackRefList);
3596 +static int isMultiPatternNotAdded(
3597 + RegExpStringInfo *regExpStringInfo,
3598 + PatternReference *toBeAddedPR);
3599 +static void catSMTRegExpStrings(
3600 + RegExpStringInfo *regExpStringInfo,
3601 + char **regExpString);
3602 +static void freeRegExpStringInfo(
3603 + RegExpStringInfo *regExpStringInfo);
3604 +static int totalKeywordOfTableLen(
3605 + ReadMatchPatternInfo *info,
3606 + int *nbrOfMultiPatterns);
3607 +static int totalMatchPatternTableElementLen(
3608 + ReadMatchPatternInfo *info,
3609 + MatchPatternTableElement *element,
3610 + int *nbrOfMultiPatterns);
3611 +static int patternElementLen(
3612 + ReadMatchPatternInfo *info,
3613 + PatternElement *patElement,
3614 + int *nbrOfMultiPatterns);
3615 +
3616 +static void parseMatchingPatternSetError(
3617 + const char *stringStart,
3618 + const char *stoppedAt,
3619 + ErrorInfo *errInfo);
3620 +static void dialogMatchingPatternSetError(
3621 + char *title,
3622 + ErrorInfo *errInfo);
3623 +
3624 +static char *createMatchPatternsString(
3625 + StringMatchTable *table,
3626 + char *indentStr);
3627 +static char *createPatternElementString(
3628 + MatchPatternTable *table,
3629 + PatternElement *pat);
3630 +
3631 +static StringMatchTable *readDefaultStringMatchTable(const char *langModeName);
3632 +static int isDefaultMatchPatternTable(StringMatchTable *table);
3633 +
3634 +static void freeReadMatchPatternInfo( ReadMatchPatternInfo *readPatInfo );
3635 +static void freeStringMatchTable( StringMatchTable *table );
3636 +static void freeMatchPatternTableElement( MatchPatternTableElement *element );
3637 +static void freePatternElement( PatternElement *element );
3638 +static void freeStringPattern( StringPattern *strPat );
3639 +static void freeMatchPatternGroupElement( MatchPatternGroupElement *group );
3640 +static void freeMatchPatternSequenceElement( MatchPatternSequenceElement *sequence );
3641 +
3642 +static StringMatchTable *readMatchPatternSet(char **inPtr);
3643 +static StringMatchTable *readMatchPatternSetContent(
3644 + char **inPtr,
3645 + char *stringStart,
3646 + char *languageMode);
3647 +static int createRegExpOfPatterns(
3648 + ReadMatchPatternInfo *readPatInfo,
3649 + ErrorInfo *errInfo);
3650 +static int createRegExpOfAllPatterns(
3651 + ReadMatchPatternInfo *readPatInfo,
3652 + ErrorInfo *errInfo);
3653 +static int createRegExpOfStrPatterns(
3654 + ReadMatchPatternInfo *readPatInfo,
3655 + ErrorInfo *errInfo);
3656 +static StringMatchTable *createStringMatchTable(
3657 + ReadMatchPatternInfo *readPatInfo,
3658 + char *languageMode);
3659 +static int readMatchPatternEntry(
3660 + char **inPtr,
3661 + ErrorInfo *errInfo,
3662 + ReadMatchPatternInfo *info);
3663 +static void recordPatternSequence(
3664 + ReadMatchPatternInfo *info,
3665 + char *name,
3666 + MatchPatternType type,
3667 + int index);
3668 +static int assignIndividualGroup(
3669 + ReadMatchPatternInfo *info,
3670 + char **errMsg,
3671 + MatchPatternTableElement *element);
3672 +static MatchPatternTableElement *getPatternOfName(
3673 + ReadMatchPatternInfo *info,
3674 + char *subPatToSearch);
3675 +static MatchPatternGroupElement *readMatchPatternGroup(
3676 + char **inPtr,
3677 + ErrorInfo *errInfo,
3678 + char *name,
3679 + ReadMatchPatternInfo *info);
3680 +static int readPatternElement(
3681 + char **inPtr,
3682 + char **errMsg,
3683 + PatternElement **pattern);
3684 +static PatternElement *createPatternElement(
3685 + char *patternText,
3686 + PatternElementKind patternKind,
3687 + PatternWordBoundary wordBoundary,
3688 + int caseInsensitive,
3689 + int regularExpression);
3690 +
3691 +static int createGlobalBackRefList(
3692 + ReadMatchPatternInfo *readPatInfo,
3693 + MatchPatternTableElement *element,
3694 + ErrorInfo *errInfo);
3695 +StringPattern *getReadStringPattern(
3696 + ReadMatchPatternInfo *readPatInfo,
3697 + PatternElement *pattern );
3698 +static PatternElement *getReadPatternOfReference(
3699 + ReadMatchPatternInfo *readPatInfo,
3700 + PatternReference *patRef);
3701 +static char *replaceCapturingParentheses(
3702 + const char *source);
3703 +static int parseGlobalBackRefs(
3704 + StringPattern *strPat,
3705 + GlobalBackRefElement *backRefList,
3706 + ErrorInfo *errInfo);
3707 +static int updateGlobalBackRefs(
3708 + StringPattern *strPat,
3709 + GlobalBackRefElement *backRefList,
3710 + ErrorInfo *errInfo);
3711 +static char *createBackRefRegExpText(
3712 + const char *start,
3713 + const char *end);
3714 +static int resolveGlobalBackRefs(
3715 + ReadMatchPatternInfo *readPatInfo,
3716 + MatchPatternTableElement *element,
3717 + ErrorInfo *errInfo);
3718 +static int resolveGlobalBackRefsOfStrPat(
3719 + StringPattern *strPat,
3720 + GlobalBackRefElement *backRefList,
3721 + ErrorInfo *errInfo);
3722 +static char *substituteGlobalBackRef(
3723 + StringPattern *strPat,
3724 + char *subsPtr,
3725 + int globalId,
3726 + int *localId,
3727 + GlobalBackRefElement *backRefList,
3728 + ErrorInfo *errInfo);
3729 +static char *replaceBackRefIdByRegExp(
3730 + StringPattern *strPat,
3731 + char *replaceStartPtr,
3732 + char *regExp);
3733 +static char *convertGlobalToLocalBackRef(
3734 + StringPattern *strPat,
3735 + char *convertPtr);
3736 +
3737 +static MatchPatternTableElement *readMatchPatternTableElement(
3738 + char **inPtr,
3739 + char **errMsg,
3740 + char *name,
3741 + MatchPatternType type);
3742 +static int sortReadPatternElementSet(
3743 + PatternElementSet *allPat,
3744 + char **errMsg,
3745 + MatchPatternTableElement *result);
3746 +static void countPatternElementKind(
3747 + PatternElementSet *allPat,
3748 + MatchPatternTableElement *result);
3749 +static void sortPatternElementSet(
3750 + PatternElementSet *allPat,
3751 + MatchPatternTableElement *result);
3752 +static void copyPatternSet(
3753 + PatternElementSet *sourcePS,
3754 + PatternElementSet *destPS);
3755 +
3756 +static int getMPSName(
3757 + char **inPtr,
3758 + ErrorInfo *errInfo,
3759 + char **name );
3760 +static int getMPSTypeAttribute(
3761 + char **inPtr,
3762 + ErrorInfo *errInfo,
3763 + MatchPatternType *type);
3764 +static int getMPSGlobalAttribute(
3765 + char **inPtr,
3766 + char **errMsg,
3767 + int *isMonoPattern,
3768 + int *comment,
3769 + int *flash,
3770 + int *ignoreHighLightInfo);
3771 +static int getMPSPatternAttribute(
3772 + char **inPtr,
3773 + char **errMsg,
3774 + PatternElementKind *patternKind,
3775 + PatternWordBoundary *wordBoundary,
3776 + int *caseInsensitive,
3777 + int *regularExpression);
3778 +
3779 +static void copyStringMatchTableForDialog(
3780 + StringMatchTable *sourceTable,
3781 + DialogMatchPatternInfo *dialogTable );
3782 +static void *copyMatchPatternElementForDialog(
3783 + MatchPatternTable *table,
3784 + int sourceElementIdx);
3785 +static void copyPatternForDialog(
3786 + MatchPatternTable *table,
3787 + PatternElement *sourcePattern,
3788 + DialogStringPatternElement **dialogPattern );
3789 +static void *copyGroupElementForDialog(
3790 + MatchPatternGroupElement *sourceGroup);
3791 +static void copySequenceElementForDialog(
3792 + StringMatchTable *sourceTable,
3793 + MatchPatternSequenceElement *sourceSeqElement,
3794 + DialogMatchPatternSequenceElement **dialogSeqElement );
3795 +static DialogMatchPatternSequenceElement *copyDialogSequenceElement(
3796 + DialogMatchPatternSequenceElement *sourceSeq);
3797 +static void freeDialogMatchPatternElement(
3798 + DialogMatchPatternTableElement *dialogElement );
3799 +static void freeDialogStringPatternElement(
3800 + DialogStringPatternElement *element);
3801 +static void freeDialogGroupElement(
3802 + DialogMatchPatternGroupElement *dialogGroup );
3803 +static void freeDialogSequenceElement(
3804 + DialogMatchPatternSequenceElement *dialogSeq );
3805 +
3806 +static void copyDialogStringPatternsFromTable(
3807 + DialogMatchPatternTableElement *tableElement,
3808 + DialogStringPatterns *destPatterns);
3809 +static void copyDialogStringPatterns(
3810 + DialogStringPatterns *sourcePatterns,
3811 + DialogStringPatterns *destPatterns);
3812 +static void freeDialogStringPatterns(
3813 + DialogStringPatterns *patterns);
3814 +
3815 +static DialogStringPatternElement *copyDialogStringPatternElement(
3816 + DialogStringPatternElement *sourceElement);
3817 +
3818 +static void copyDialogPatternNamesFromGroup(
3819 + DialogMatchPatternGroupElement *group,
3820 + DialogStringPatterns *destPatterns);
3821 +static DialogStringPatternElement *copyDialogPatternName(
3822 + char *sourcePatternId);
3823 +static void copyDialogPatternNamesToGroup(
3824 + DialogStringPatterns *sourceNames,
3825 + DialogMatchPatternGroupElement *destGroup);
3826 +
3827 +static void setDialogType(int dialogShowsStringPattern);
3828 +static void setSensitiveWordBoundaryBox(int enable);
3829 +
3830 +static void *getStringPatternDisplayedCB(void *oldItem, int explicitRequest, int *abort,
3831 + void *cbArg);
3832 +static void setStringPatternDisplayedCB(void *item, void *cbArg);
3833 +static void freeStringPatternItemCB(void *item);
3834 +
3835 +static void *getMatchPatternDisplayedCB(void *oldItem, int explicitRequest, int *abort,
3836 + void *cbArg);
3837 +static void setMatchPatternDisplayedCB(void *item, void *cbArg);
3838 +static void freeMatchPatternItemCB(void *item);
3839 +static int deleteMatchPatternItemCB(int itemIndex, void *cbArg);
3840 +
3841 +static void matchPatternLangModeCB(Widget w, XtPointer clientData, XtPointer callData);
3842 +static void pmLanguageModeDialogCB(Widget w, XtPointer clientData, XtPointer callData);
3843 +
3844 +static void destroyCB(Widget w, XtPointer clientData, XtPointer callData);
3845 +static void okCB(Widget w, XtPointer clientData, XtPointer callData);
3846 +static void applyCB(Widget w, XtPointer clientData, XtPointer callData);
3847 +static void checkCB(Widget w, XtPointer clientData, XtPointer callData);
3848 +static void restoreCB(Widget w, XtPointer clientData, XtPointer callData);
3849 +static void deleteCB(Widget w, XtPointer clientData, XtPointer callData);
3850 +static void closeCB(Widget w, XtPointer clientData, XtPointer callData);
3851 +static void helpCB(Widget w, XtPointer clientData, XtPointer callData);
3852 +
3853 +static void matchPatTypeCB(Widget w, XtPointer clientData, XtPointer callData);
3854 +static void strPatRegExpressionCB(Widget w, XtPointer clientData, XtPointer callData);
3855 +static void changeExistingSubPattern(char *warnTitle);
3856 +static void changeStringPatternToGroup(void);
3857 +static void changeGroupToStringPattern(char *warnTitle);
3858 +
3859 +static Widget createSubPatternNameMenu(
3860 + Widget parent,
3861 + char *currentSubPatName,
3862 + int allSubPatterns);
3863 +static void setupSubPatternNameList(
3864 + char *currentSubPatName,
3865 + int allSubPatterns,
3866 + NameList *nameList);
3867 +static void createSubPatNameMenuEntry(
3868 + Widget menu,
3869 + char *subPatName);
3870 +static void setSubPatternNameMenu(
3871 + const char *subPatName);
3872 +static void updateSubPatternNameMenu(
3873 + char *currentSubPatName,
3874 + int allSubPatterns);
3875 +static char *getSelectedSubPatternName(void);
3876 +static int isSubPatternNameInCurStrPat(
3877 + char *subPatName);
3878 +
3879 +static DialogMatchPatternSequenceElement *readMatchPatternFields(int silent);
3880 +static int isStartPatternElementAvailable(
3881 + DialogStringPatterns *dialogPatterns);
3882 +static DialogStringPatternElement *readStringPatternFrameFields(int silent);
3883 +
3884 +static int matchPatternDialogEmpty(void);
3885 +static int stringPatternFrameEmpty(void);
3886 +static int stringPatternFieldsEmpty(
3887 + int strPatIsRelatedToGroup);
3888 +
3889 +static int getAndUpdateStringMatchTable(void);
3890 +static void updateStringMatchTable(
3891 + StringMatchTable *newTable);
3892 +
3893 +static StringMatchTable *getDialogStringMatchTable(
3894 + DMPTranslationResult *result);
3895 +static StringMatchTable *translateDialogStringMatchTable(
3896 + DialogMatchPatternInfo *dialogTable,
3897 + DMPTranslationResult *result);
3898 +static MatchPatternTableElement *translateDialogMatchPatternTableElement(
3899 + DialogMatchPatternTableElement *dialogElement);
3900 +static void translateDialogPatterns(
3901 + DialogStringPatterns *dialogPatterns,
3902 + MatchPatternTableElement *newElement);
3903 +static MatchPatternGroupElement *translateDialogMatchPatternGroupElement(
3904 + ReadMatchPatternInfo *info,
3905 + DialogMatchPatternGroupElement *dialogGroup);
3906 +static void sortDialogPatternElementSet(
3907 + PatternElementSet *allPat,
3908 + MatchPatternTableElement *result);
3909 +
3910 +static int stringMatchTableDiffer(
3911 + StringMatchTable *oldTable,
3912 + StringMatchTable *newTable);
3913 +
3914 +static int patternElementDiffer(
3915 + PatternElement *oldPE,
3916 + MatchPatternTable *oldTab,
3917 + PatternElement *newPE,
3918 + MatchPatternTable *newTab);
3919 +
3920 +static DialogMatchPatternGroupElement *getDialogGroupUsingMatchPattern(
3921 + char *matchPatternName);
3922 +static void removeMatchPatternFromGroup(
3923 + char *matchPatternName,
3924 + DialogMatchPatternGroupElement *group);
3925 +static void removeMatchPatternFromAllGroups(
3926 + char *matchPatternName);
3927 +static void renameMatchPatternInGroup(
3928 + char *oldMatchPatternName,
3929 + char *newMatchPatternName,
3930 + DialogMatchPatternGroupElement *group);
3931 +static void renameMatchPatternInAllGroups(
3932 + char *oldMatchPatternName,
3933 + char *newMatchPatternName);
3934 +
3935 +static void freeVariableDialogData(
3936 + int keepLanguageModeName);
3937 +
3938 +static void initGlobalBackRefList(
3939 + GlobalBackRefElement *list);
3940 +static void initStrPatBackRefList(
3941 + StringPattern *strPat);
3942 +
3943 +StringPattern *getUniqueStringPattern(
3944 + PatternElement *pattern );
3945 +
3946 +static void initErrorInfo(
3947 + ErrorInfo *errInfo);
3948 +static void freeErrorInfo(
3949 + ErrorInfo *errInfo);
3950 +
3951 +static void freeXtPtr(void **ptr);
3952 +static void freePtr(void **ptr);
3953 +
3954 +/*
3955 + * matching pattern dialog information
3956 + */
3957 +static struct {
3958 + Widget mpdShell;
3959 + Widget mpdLmOptMenu;
3960 + Widget mpdLmPulldown;
3961 + Widget mpdMatchPatternNamesListW;
3962 + Widget mpdMatchPatternNameLbl;
3963 + Widget mpdMatchPatternNameW;
3964 + Widget mptbIndividualW;
3965 + Widget mptbSubPatternW;
3966 + Widget mptbContextGroupW;
3967 + Widget mpdGlobalAttributesLbl;
3968 + Widget gabSkipBtwStartEndW;
3969 + Widget gabFlashW;
3970 + Widget gabSyntaxBasedW;
3971 + Widget mpdStringPatternsLbl;
3972 + Widget mpdStringPatternsListW;
3973 + Widget mpdStringPatternTypeLbl;
3974 + Widget sptStartW;
3975 + Widget sptMiddleW;
3976 + Widget sptEndW;
3977 + Widget mpdWordBoundaryLbl;
3978 + Widget wbbBothW;
3979 + Widget wbbLeftW;
3980 + Widget wbbRightW;
3981 + Widget wbbNoneW;
3982 + Widget mpdStringAttributesLbl;
3983 + Widget sabCaseSensitiveW;
3984 + Widget sabRegularExpressionW;
3985 + Widget mpdStringPatternLbl;
3986 + Widget mpdStringPatternW;
3987 + Widget mpdSubPatNamesLbl;
3988 + Widget mpdSubPatNamesOptMenu;
3989 + Widget mpdSubPatNamesPulldown;
3990 + char *mpdLangModeName;
3991 + DialogMatchPatternSequenceElement *currentDmptSeqElement;
3992 + DialogMatchPatternTableElement *currentDmptElement;
3993 + DialogMatchPatternGroupElement *currentDmptGroup;
3994 + DialogStringPatterns currentStringPatterns;
3995 + DialogMatchPatternInfo mpdTable;
3996 + int mpdStringPatternIsDisplayed;
3997 +} MatchPatternDialog =
3998 + {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
3999 + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
4000 + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
4001 + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
4002 + NULL, NULL, NULL, NULL,
4003 + {0, {NULL}},
4004 + {0, {NULL}},
4005 + True
4006 + };
4007 +
4008 +/*
4009 + * Matching pattern sources loaded from the nedit resources file or set
4010 + * by the user
4011 + */
4012 +static int NbrMatchTables = 0;
4013 +static StringMatchTable *MatchTables[MAX_LANGUAGE_MODES];
4014 +
4015 +/*
4016 + * Syntax:
4017 + * LanguagePatternSet ::=
4018 + * LanguageName{PatternStatement..}
4019 + *
4020 + * PatternStatement ::=
4021 + * name:[s]:[c][f][m][p][u]:([s|m|e][w|l|r][i]:"pattern":)..)\n)|
4022 + * name:g:"sub-pattern name":..\n..
4023 + *
4024 + * TypeAttribute:
4025 + * s : sub-pattern (pattern is only matched, if part of a pattern group).
4026 + * g : pattern (context) group (i.e. a sequence of sub-patterns).
4027 + * default: individual pattern (pattern is matched individually).
4028 + * GlobalAttribute:
4029 + * c : the content between start and end pattern is skipped
4030 + * during parsing (e.g. pattern encloses a comment).
4031 + * f : flash matching pattern (if not set, then only jump
4032 + * to matching pattern is supported).
4033 + * m : mono pattern - set exist out of only one single pattern
4034 + * (start pattern = end pattern; e.g. quotes like ")
4035 + * p : ignore highlight info code of single patterns of this set
4036 + * ("plain").
4037 + * StringPatternKind:
4038 + * s : start string pattern.
4039 + * m : middle string pattern.
4040 + * e : end string pattern.
4041 + * WordBoundaryAttribute:
4042 + * w : pattern is word (i.e. before and after pattern
4043 + * there must be a delimiter).
4044 + * l : before pattern must be a delimiter (left side).
4045 + * r : after pattern must be a delimiter (right side).
4046 + * default: neither before nor after pattern must be a delimiter.
4047 + * StringAttribute:
4048 + * i : pattern is case insensitive (if not set: pattern is
4049 + * case sensitive).
4050 + * x : pattern is regular expression (if not set: pattern is
4051 + * literal string).
4052 + *
4053 + * \n : end of pattern
4054 + */
4055 +
4056 +static char *DefaultStringMatchTable[] = {
4057 + "PLAIN{"
4058 + "Round braces::fp:s:\"(\":e:\")\":\n"
4059 + "Curly braces::fp:s:\"{\":e:\"}\":\n"
4060 + "Squared braces::fp:s:\"[\":e:\"]\":\n"
4061 + "Sharp braces::fp:s:\"<\":e:\">\":\n}",
4062 + "C++{"
4063 + "Comment:s:cf:s:\"/*\":e:\"*/\":\n"
4064 + "Double Quotes:s:cmf:s:\"\"\"\":\n"
4065 + "Single Quotes:s:cmf:s:\"'\":\n"
4066 + "Round braces:s:f:s:\"(\":e:\")\":\n"
4067 + "Curly braces:s:f:s:\"{\":e:\"}\":\n"
4068 + "Squared braces:s:f:s:\"[\":e:\"]\":\n"
4069 + "#ifdef statement:s:f:sx:\"#\\s*ifdef\":sx:\"#\\s*ifndef\":sx:\"#\\s*if\":mx:\"#\\s*elif\":mx:\"#\\s*else\":ex:\"#\\s*endif\":\n"
4070 + "#if group:g:Comment:Double Quotes:Single Quotes:#ifdef statement:\n"
4071 + "Braces:g:Comment:Double Quotes:Single Quotes:Curly braces:Round braces:Squared braces:\n}",
4072 + "C{"
4073 + "Comment:s:cf:s:\"/*\":e:\"*/\":\n"
4074 + "Double Quotes:s:cmf:s:\"\"\"\":\n"
4075 + "Single Quotes:s:cmf:s:\"'\":\n"
4076 + "Round braces:s:f:s:\"(\":e:\")\":\n"
4077 + "Curly braces:s:f:s:\"{\":e:\"}\":\n"
4078 + "Squared braces:s:f:s:\"[\":e:\"]\":\n"
4079 + "#ifdef statement:s:f:sx:\"#\\s*ifdef\":sx:\"#\\s*ifndef\":sx:\"#\\s*if\":mx:\"#\\s*elif\":mx:\"#\\s*else\":ex:\"#\\s*endif\":\n"
4080 + "#if group:g:Comment:Double Quotes:Single Quotes:#ifdef statement:\n"
4081 + "Braces:g:Comment:Double Quotes:Single Quotes:Curly braces:Round braces:Squared braces:\n}",
4082 + "CSS{"
4083 + "comment:s:cf:s:\"/*\":e:\"*/\":\n"
4084 + "curly braces:s:f:s:\"{\":e:\"}\":\n"
4085 + "round braces:s:f:s:\"(\":e:\")\":\n"
4086 + "double quotes:s:cfm:s:\"\"\"\":\n"
4087 + "single quotes:s:cfm:s:\"'\":\n"
4088 + "braces:g:comment:single quotes:double quotes:curly braces:round braces:\n}",
4089 + "Csh{"
4090 + "Double Quotes:s:cmf:s:\"\"\"\":\n"
4091 + "Single Quotes:s:cmf:s:\"'\":\n"
4092 + "Squared braces:s:f:s:\"[\":e:\"]\":\n"
4093 + "Round braces:s:f:s:\"(\":e:\")\":\n"
4094 + "Curly braces:s:f:s:\"{\":e:\"}\":\n"
4095 + "if statement:s:f:sw:\"if\":mw:\"else\":ew:\"endif\":\n"
4096 + "switch statement:s:f:sw:\"switch\":mw:\"case\":mw:\"default\":ew:\"endsw\":\n"
4097 + "foreach statement:s:f:sw:\"for\":ew:\"end\":\n"
4098 + "while statement:s:f:sw:\"while\":ew:\"end\":\n"
4099 + "statement group:g:Double Quotes:Single Quotes:if statement:switch statement:foreach statement:while statement:\n"
4100 + "Braces:g:Double Quotes:Single Quotes:Squared braces:Round braces:Curly braces:\n}",
4101 + "Java{"
4102 + "Comment:s:cf:s:\"/*\":e:\"*/\":\n"
4103 + "Double Quotes:s:cmf:s:\"\"\"\":\n"
4104 + "Single Quotes:s:cmf:s:\"'\":\n"
4105 + "Round braces:s:f:s:\"(\":e:\")\":\n"
4106 + "Curly braces:s:f:s:\"{\":e:\"}\":\n"
4107 + "Squared braces:s:f:s:\"[\":e:\"]\":\n"
4108 + "Braces:g:Comment:Double Quotes:Single Quotes:Curly braces:Round braces:Squared braces:\n}",
4109 + "JavaScript{"
4110 + "Comment:s:cf:s:\"/*\":e:\"*/\":\n"
4111 + "Double Quotes:s:cmf:s:\"\"\"\":\n"
4112 + "Single Quotes:s:cmf:s:\"'\":\n"
4113 + "Round braces:s:f:s:\"(\":e:\")\":\n"
4114 + "Curly braces:s:f:s:\"{\":e:\"}\":\n"
4115 + "Squared braces:s:f:s:\"[\":e:\"]\":\n"
4116 + "Braces:g:Comment:Double Quotes:Single Quotes:Curly braces:Round braces:Squared braces:\n}",
4117 + "Makefile{"
4118 + "Double Quotes:s:cmf:s:\"\"\"\":\n"
4119 + "Single Quotes:s:cmf:s:\"'\":\n"
4120 + "Round braces:s:f:s:\"(\":e:\")\":\n"
4121 + "Curly braces:s:f:s:\"{\":e:\"}\":\n"
4122 + "Braces:g:Double Quotes:Single Quotes:Curly braces:Round braces:\n}",
4123 + "NEdit Macro{"
4124 + "Double Quotes:s:cmf:s:\"\"\"\":\n"
4125 + "Round braces:s:f:s:\"(\":e:\")\":\n"
4126 + "Curly braces:s:f:s:\"{\":e:\"}\":\n"
4127 + "Squared braces:s:f:s:\"[\":e:\"]\":\n"
4128 + "Braces:g:Double Quotes:Curly braces:Round braces:Squared braces:\n}",
4129 + "Pascal{"
4130 + "Single Quotes:s:cmf:s:\"'\":\n"
4131 + "Comment1:s:cf:s:\"(*\":e:\"*)\":\n"
4132 + "Comment2:s:cf:s:\"{\":e:\"}\":\n"
4133 + "Round braces:s:f:s:\"(\":e:\")\":\n"
4134 + "Squared braces:s:f:s:\"[\":e:\"]\":\n"
4135 + "Block:s:f:swi:\"begin\":ewi:\"end\":\n"
4136 + "Case:s:fp:swi:\"case\":ewi:\"end\":\n"
4137 + "Record:s:f:swi:\"record\":ewi:\"end\":\n"
4138 + "Statement:g:Comment1:Comment2:Single Quotes:Block:Case:Record:\n"
4139 + "Braces:g:Comment1:Comment2:Single Quotes:Round braces:Squared braces:\n}",
4140 + "Perl{"
4141 + "Comment:s:cf:s:\"/*\":e:\"*/\":\n"
4142 + "Double Quotes:s:cmf:s:\"\"\"\":\n"
4143 + "Single Quotes:s:cmf:s:\"'\":\n"
4144 + "Round braces:s:f:s:\"(\":e:\")\":\n"
4145 + "Curly braces:s:f:s:\"{\":e:\"}\":\n"
4146 + "Squared braces:s:f:s:\"[\":e:\"]\":\n"
4147 + "Braces:g:Comment:Double Quotes:Single Quotes:Curly braces:Round braces:Squared braces:\n}",
4148 + "SGML HTML{"
4149 + "Double Quotes:s:cmf:s:\"\"\"\":\n"
4150 + "Single Quotes:s:cmf:s:\"'\":\n"
4151 + "Sharp braces:s:f:s:\"<\":e:\">\":\n"
4152 + "Round braces:s:f:s:\"(\":e:\")\":\n"
4153 + "Curly braces:s:f:s:\"{\":e:\"}\":\n"
4154 + "Squared braces:s:f:s:\"[\":e:\"]\":\n"
4155 + "Braces:g:Double Quotes:Single Quotes:Sharp braces:Curly braces:Round braces:Squared braces:\n}",
4156 + "Sh Ksh Bash{"
4157 + "Double Quotes:s:cmf:s:\"\"\"\":\n"
4158 + "Single Quotes:s:cmf:s:\"'\":\n"
4159 + "Back Quotes:s:cfm:s:\"`\":\n"
4160 + "Round braces:s:f:s:\"(\":e:\")\":\n"
4161 + "Curly braces:s:f:s:\"{\":e:\"}\":\n"
4162 + "Squared braces:s:f:s:\"[\":e:\"]\":\n"
4163 + "if statement:s:f:sw:\"if\":mw:\"elif\":mw:\"else\":ew:\"fi\":\n"
4164 + "case statement:s:f:sw:\"case\":ew:\"esac\":\n"
4165 + "for statement:s:f:sw:\"for\":mw:\"do\":ew:\"done\":\n"
4166 + "while statement:s:f:sw:\"while\":mw:\"do\":ew:\"done\":\n"
4167 + "statement group:g:Double Quotes:Single Quotes:if statement:case statement:for statement:while statement:\n"
4168 + "Braces:g:Double Quotes:Single Quotes:Back Quotes:Squared braces:Round braces:Curly braces:\n}",
4169 + "XML{"
4170 + "round braces:s:f:s:\"(\":e:\")\":\n"
4171 + "comment:s:cf:s:\"<!--\":e:\"-->\":\n"
4172 + "cdata + ignore:s:cf:sx:\"\\<!\\[((?icdata)|(\\s*IGNORE\\s*))\\[\":ex:\"\\]\\]\\>\":\n"
4173 + "short element:s:cf:sx:\"(?n\\<[\\l_][^@$%/\"\"';!>\\s]*(?=[^>]*/\\>))\":ex:\"/\\>\":\n"
4174 + "element pair:s:f:sx:\"(?n\\<(*1[\\l|_][^@$%/\"\"';!>\\s]*)\\>)\":sx:\"(?n\\<(*1[\\l|_][^@$%/\"\"';!>\\s]*)(?=[^>]*[^/]\\>))\":eix:\"\\</\\1\\>\":\n"
4175 + "processing instruction:s:f:sx:\"\\<\\?\\S+\":ex:\"\\?\\>\":\n"
4176 + "double quotes:s:cmf:s:\"\"\"\":\n"
4177 + "single quotes:s:cmf:s:\"'\":\n"
4178 + "tags:g:comment:double quotes:single quotes:round braces:cdata + ignore:element pair:short element:processing instruction:\n}",
4179 + };
4180 +
4181 +static char *StandardStringMatchTable =
4182 + "{Round braces::fp:s:\"(\":e:\")\":\n"
4183 + "Curly braces::fp:s:\"{\":e:\"}\":\n"
4184 + "Squared braces::fp:s:\"[\":e:\"]\":\n}";
4185 +
4186 +/*
4187 +** Return string match table related to given language mode name.
4188 +** Return NULL, if no table is found.
4189 +*/
4190 +void *FindStringMatchTable(const char *langModeName)
4191 +{
4192 + const char *nameToSearch;
4193 + int i;
4194 +
4195 + if (langModeName == NULL)
4196 + nameToSearch = PLAIN_LM_STRING;
4197 + else
4198 + nameToSearch = langModeName;
4199 +
4200 + for (i=0; i<NbrMatchTables; i++)
4201 + if (!strcmp(nameToSearch, MatchTables[i]->smtLanguageMode))
4202 + return (void *)MatchTables[i];
4203 + return NULL;
4204 +}
4205 +
4206 +/*
4207 +** Change the language mode name of string match tables for language
4208 +** "oldName" to "newName" in both the stored tables, and the table
4209 +** currently being edited in the dialog.
4210 +*/
4211 +void RenameStringMatchTable(const char *oldName, const char *newName)
4212 +{
4213 + int i;
4214 +
4215 + for (i=0; i<NbrMatchTables; i++)
4216 + {
4217 + if (!strcmp(oldName, MatchTables[i]->smtLanguageMode))
4218 + {
4219 + XtFree(MatchTables[i]->smtLanguageMode);
4220 + MatchTables[i]->smtLanguageMode = XtNewString(newName);
4221 + }
4222 + }
4223 + if (MatchPatternDialog.mpdShell != NULL)
4224 + {
4225 + if (!strcmp(MatchPatternDialog.mpdLangModeName, oldName))
4226 + {
4227 + XtFree(MatchPatternDialog.mpdLangModeName);
4228 + MatchPatternDialog.mpdLangModeName = XtNewString(newName);
4229 + }
4230 + }
4231 +}
4232 +
4233 +/*
4234 +** Delete string match table related to given language mode name.
4235 +*/
4236 +void DeleteStringMatchTable(const char *langModeName)
4237 +{
4238 + int i;
4239 +
4240 + for (i=0; i<NbrMatchTables; i++)
4241 + {
4242 + if (!strcmp(langModeName, MatchTables[i]->smtLanguageMode))
4243 + {
4244 + /*
4245 + * free (delete) existing matching pattern
4246 + */
4247 + freeStringMatchTable(MatchTables[i]);
4248 + memmove(
4249 + &MatchTables[i],
4250 + &MatchTables[i+1],
4251 + (NbrMatchTables-1 - i) * sizeof(StringMatchTable *));
4252 + NbrMatchTables--;
4253 + break;
4254 + }
4255 + }
4256 +}
4257 +
4258 +/*
4259 +** Assign a standard string match table to a given new language mode.
4260 +*/
4261 +void AssignStandardStringMatchTable(const char *langModeName)
4262 +{
4263 + char *list;
4264 + StringMatchTable *newTable;
4265 +
4266 + /*
4267 + * assign standard table for new language mode
4268 + * add table to end
4269 + */
4270 + list = StandardStringMatchTable;
4271 + newTable =
4272 + readMatchPatternSetContent(&list, list, XtNewString(langModeName));
4273 +
4274 + /*
4275 + * add table to end
4276 + */
4277 + MatchTables[NbrMatchTables++] = newTable;
4278 +}
4279 +
4280 +/*
4281 +** Returns True if there is a string match table, or potential table
4282 +** not yet committed in the match pattern dialog for a language mode,
4283 +*/
4284 +int LMHasStringMatchTable(const char *languageMode)
4285 +{
4286 + StringMatchTable *table = FindStringMatchTable(languageMode);
4287 +
4288 + if (table != NULL && table->smtNumberOfSeqElements != 0)
4289 + return True;
4290 + return MatchPatternDialog.mpdShell != NULL &&
4291 + !strcmp(MatchPatternDialog.mpdLangModeName, languageMode) &&
4292 + MatchPatternDialog.mpdTable.dmpiNbrOfSeqElements != 0;
4293 +}
4294 +
4295 +/*
4296 +** Read a string representing string matching pattern sets and add them
4297 +** to the StringMatchTable list of loaded string match patterns.
4298 +** Returns true, if read of string was successful.
4299 +*/
4300 +int LoadMatchPatternString(char *inString)
4301 +{
4302 + char *inPtr = inString;
4303 + StringMatchTable *table;
4304 + int i;
4305 +
4306 + for (;;)
4307 + {
4308 + /*
4309 + * read each matching pattern set
4310 + */
4311 + table = readMatchPatternSet(&inPtr);
4312 +
4313 + if (table != NULL)
4314 + {
4315 + /*
4316 + * add/change the pattern set in the list
4317 + */
4318 + for (i=0; i<NbrMatchTables; i++)
4319 + {
4320 + if (!strcmp(MatchTables[i]->smtLanguageMode, table->smtLanguageMode))
4321 + {
4322 + freeStringMatchTable(MatchTables[i]);
4323 + MatchTables[i] = table;
4324 + break;
4325 + }
4326 + }
4327 + if (i == NbrMatchTables)
4328 + {
4329 + MatchTables[NbrMatchTables++] = table;
4330 + if (NbrMatchTables > MAX_LANGUAGE_MODES)
4331 + {
4332 + return False;
4333 + }
4334 + }
4335 + }
4336 +
4337 + /*
4338 + * find end of this pattern. if the string ends here, we're done
4339 + */
4340 + inPtr = strstr(inPtr, "\n");
4341 + if (inPtr == NULL)
4342 + {
4343 + return True;
4344 + }
4345 +
4346 + /*
4347 + * skip newline, tabs & spaces in front of next pattern.
4348 + * if the string ends here, we're done
4349 + */
4350 + inPtr += strspn(inPtr, " \t\n");
4351 + if (*inPtr == '\0')
4352 + {
4353 + return True;
4354 + }
4355 + }
4356 +}
4357 +
4358 +/*
4359 +** Create a string in the correct format for the matchPatterns resource,
4360 +** containing all of the matching pattern information from the stored
4361 +** matching pattern sets for this NEdit session.
4362 +*/
4363 +char *WriteMatchPatternString(void)
4364 +{
4365 + char *outStr, *str, *escapedStr;
4366 + textBuffer *outBuf;
4367 + int i, written = False;
4368 + StringMatchTable *table;
4369 +
4370 + outBuf = BufCreate();
4371 +
4372 + for (i=0; i<NbrMatchTables; i++)
4373 + {
4374 + table = MatchTables[i];
4375 +
4376 + written = True;
4377 +
4378 + BufInsert(outBuf, outBuf->length, table->smtLanguageMode);
4379 + BufInsert(outBuf, outBuf->length, ":");
4380 +
4381 + if (isDefaultMatchPatternTable(table))
4382 + {
4383 + BufInsert(outBuf, outBuf->length, "Default\n\t");
4384 + }
4385 + else
4386 + {
4387 + BufInsert(outBuf, outBuf->length, "{\n");
4388 + BufInsert(outBuf, outBuf->length,
4389 + str = createMatchPatternsString(table, "\t\t"));
4390 + XtFree(str);
4391 + BufInsert(outBuf, outBuf->length, "\t}\n\t");
4392 + }
4393 + }
4394 +
4395 + /*
4396 + * Get the output string, and lop off the trailing newline and tab
4397 + */
4398 + outStr = BufGetRange(outBuf, 0, outBuf->length - (written?2:0));
4399 + BufFree(outBuf);
4400 +
4401 + /*
4402 + * Protect newlines and backslashes from translation by the resource
4403 + * reader
4404 + */
4405 + escapedStr = EscapeSensitiveChars(outStr);
4406 +
4407 + XtFree(outStr);
4408 +
4409 + return escapedStr;
4410 +}
4411 +
4412 +/*
4413 +** Check, if last pattern is a duplicate of a previous pattern.
4414 +** Convert last pattern to a reference, if so.
4415 +*/
4416 +static void treatDuplicatedPattern(
4417 + MatchPatternTable *table,
4418 + PatternElement *prevPattern,
4419 + PatternReference prevPatRef,
4420 + PatternElement *lastPattern,
4421 + PatternReference lastPatRef)
4422 +{
4423 + StringPattern *prevStringPat;
4424 + StringPattern *lastStringPat;
4425 + StringPattern *stringPat;
4426 + PatternReference *oldList;
4427 + int nbrOfRef;
4428 +
4429 + /*
4430 + * No duplicate check needed, if previous pattern is a reference,
4431 + * due to the related multi pattern element is checked before.
4432 + */
4433 + if (prevPattern->peType == PET_REFERENCE)
4434 + return;
4435 +
4436 + prevStringPat = GetStringPattern(table, prevPattern);
4437 + lastStringPat = GetStringPattern(table, lastPattern);
4438 +
4439 + if (!AllocatedStringsDiffer(prevStringPat->spText, lastStringPat->spText) &&
4440 + !AllocatedStringsDiffer(prevStringPat->spOrigText, lastStringPat->spOrigText) &&
4441 + prevStringPat->spWordBoundary == lastStringPat->spWordBoundary &&
4442 + prevStringPat->spCaseInsensitive == lastStringPat->spCaseInsensitive &&
4443 + prevStringPat->spRegularExpression == lastStringPat->spRegularExpression)
4444 + {
4445 + /*
4446 + * Patterns are identical: Is prevPattern already a multi pattern ?
4447 + */
4448 + if (prevPattern->peType == PET_MULTIPLE)
4449 + {
4450 + /*
4451 + * just add ref. to "lastPattern" to the ref. list
4452 + */
4453 + (prevPattern->peVal.peuMulti.mpNumberOfReferences) ++;
4454 + nbrOfRef = prevPattern->peVal.peuMulti.mpNumberOfReferences;
4455 + oldList = prevPattern->peVal.peuMulti.mpRefList;
4456 + prevPattern->peVal.peuMulti.mpRefList =
4457 + (PatternReference *)XtMalloc( nbrOfRef * sizeof(PatternReference) );
4458 + memcpy(
4459 + prevPattern->peVal.peuMulti.mpRefList,
4460 + oldList,
4461 + (nbrOfRef-1) * sizeof(PatternReference) );
4462 + prevPattern->peVal.peuMulti.mpRefList[nbrOfRef-1] = lastPatRef;
4463 + XtFree( (char *)oldList );
4464 + }
4465 + else
4466 + {
4467 + /*
4468 + * convert prev. single pattern to multi pattern
4469 + */
4470 + stringPat = &prevPattern->peVal.peuSingle;
4471 + prevPattern->peType = PET_MULTIPLE;
4472 + prevPattern->peVal.peuMulti.mpStringPattern = *stringPat;
4473 + prevPattern->peVal.peuMulti.mpNumberOfReferences = 1;
4474 + prevPattern->peVal.peuMulti.mpRefList =
4475 + (PatternReference *)XtMalloc( sizeof(PatternReference) );
4476 + prevPattern->peVal.peuMulti.mpRefList[0] = lastPatRef;
4477 + }
4478 +
4479 + /*
4480 + * convert last single pattern to reference
4481 + */
4482 + freeStringPattern( &(lastPattern->peVal.peuSingle) );
4483 + lastPattern->peType = PET_REFERENCE;
4484 + lastPattern->peVal.peuRef = prevPatRef;
4485 + }
4486 +}
4487 +
4488 +/*
4489 +** Check, if last pattern is a duplicate of a pattern stored within a
4490 +** previous match pattern table element.
4491 +** Convert last pattern to a reference, if so.
4492 +*/
4493 +static void treatDuplicatedPatternElements(
4494 + MatchPatternTable *table,
4495 + MatchPatternTableElement *prevElement,
4496 + int prevElementIdx,
4497 + PatternElement *lastPattern,
4498 + PatternReference lastPatRef)
4499 +{
4500 + int i;
4501 + PatternReference prevPatRef;
4502 +
4503 + prevPatRef.prElementIdx = prevElementIdx;
4504 +
4505 + for (i=0; i<prevElement->mpteAll.pesNumberOfPattern; i++)
4506 + {
4507 + prevPatRef.prPatternIdx = i;
4508 + treatDuplicatedPattern(
4509 + table,
4510 + prevElement->mpteAll.pesPattern[i],
4511 + prevPatRef,
4512 + lastPattern,
4513 + lastPatRef);
4514 + }
4515 +}
4516 +
4517 +/*
4518 +** Check, if a pattern of last match pattern table element is a
4519 +** duplicate of a pattern stored within a previous match pattern table
4520 +** element.
4521 +** Convert duplicated last patterns to references, if so.
4522 +*/
4523 +static void treatDuplicatedMTElements(
4524 + MatchPatternTable *table,
4525 + MatchPatternTableElement *prevElement,
4526 + int prevElementIdx,
4527 + MatchPatternTableElement *lastElement,
4528 + int lastElementIdx)
4529 +{
4530 + int i;
4531 + PatternReference lastPatRef;
4532 +
4533 + lastPatRef.prElementIdx = lastElementIdx;
4534 +
4535 + for (i=0; i<lastElement->mpteAll.pesNumberOfPattern; i++)
4536 + {
4537 + lastPatRef.prPatternIdx = i;
4538 + treatDuplicatedPatternElements(
4539 + table,
4540 + prevElement,
4541 + prevElementIdx,
4542 + lastElement->mpteAll.pesPattern[i],
4543 + lastPatRef);
4544 + }
4545 +}
4546 +
4547 +/*
4548 +** Convert all duplicated patterns of given match pattern table to
4549 +** references.
4550 +*/
4551 +static void treatDuplicatedMTEntries(
4552 + MatchPatternTableElement **element,
4553 + int nbrOfElements)
4554 +{
4555 + int i;
4556 + MatchPatternTableElement *lastElement;
4557 + int lastElementIdx;
4558 + MatchPatternTable table;
4559 +
4560 + if (nbrOfElements < 2)
4561 + return;
4562 +
4563 + lastElementIdx = nbrOfElements - 1;
4564 + lastElement = element[lastElementIdx];
4565 +
4566 + table.mptElements = element;
4567 + table.mptNumberOfElements = nbrOfElements;
4568 +
4569 + for (i=0; i<nbrOfElements-1; i ++)
4570 + {
4571 + treatDuplicatedMTElements( &table, element[i], i, lastElement, lastElementIdx );
4572 + }
4573 +}
4574 +
4575 +/*
4576 +** Compile regular expressions of all string patterns of given
4577 +** match pattern table element.
4578 +** Returns true, if compilation fails.
4579 +*/
4580 +static int createStrPatRegExpOfElement(
4581 + ReadMatchPatternInfo *readPatInfo,
4582 + MatchPatternTableElement *element,
4583 + ErrorInfo *errInfo)
4584 +{
4585 + int i;
4586 + StringPattern *strPat;
4587 +
4588 + for (i=0; i<element->mpteAll.pesNumberOfPattern; i++)
4589 + {
4590 + strPat = getReadStringPattern(readPatInfo, element->mpteAll.pesPattern[i]);
4591 +
4592 + /*
4593 + * if current string pattern holds a regular expression, then
4594 + * compile it
4595 + */
4596 + if (strPat->spRegularExpression)
4597 + {
4598 + if (createStrPatRegExp(strPat, errInfo))
4599 + {
4600 + /*
4601 + * compilation was not successful
4602 + */
4603 + errInfo->eiMPTabElementName = XtNewString(element->mpteName);
4604 + return True;
4605 + }
4606 + }
4607 + }
4608 +
4609 + return False;
4610 +}
4611 +
4612 +/*
4613 +** Compile regular expressions of given string pattern.
4614 +** Returns true, if compilation fails.
4615 +*/
4616 +static int createStrPatRegExp(
4617 + StringPattern *strPat,
4618 + ErrorInfo *errInfo)
4619 +{
4620 + char *regExpString;
4621 + char *compileMsg;
4622 +
4623 + /*
4624 + * compose regular expression for start string pattern.
4625 + */
4626 + if( strPat->spCaseInsensitive)
4627 + {
4628 + /*
4629 + * Add '(?i .. )' to given text for case insensitive search.
4630 + * Allocate buffer to hold 5 more char than text length
4631 + * (4 char '(?i)' + \0 char.
4632 + */
4633 + regExpString = XtMalloc(strPat->spLength + 5);
4634 + strcpy(regExpString, "(?i");
4635 + strcat(regExpString, strPat->spText);
4636 + strcat(regExpString, ")");
4637 + }
4638 + else
4639 + {
4640 + regExpString = strPat->spText;
4641 + }
4642 +
4643 + /*
4644 + * compile regular expression & free allocated string buffer,
4645 + * if applicable.
4646 + */
4647 + strPat->spTextRE =
4648 + CompileRE(regExpString, &compileMsg, REDFLT_STANDARD);
4649 +
4650 + if (strPat->spTextRE == NULL)
4651 + {
4652 + /*
4653 + * compilation was not successful: adapt error reason by
4654 + * converting local backrefs to global ones.
4655 + */
4656 + adaptCompileMsg(compileMsg, strPat->spGlobalToLocalBackRef);
4657 +
4658 + errInfo->eiRegExpCompileMsg = compileMsg;
4659 + errInfo->eiStringPatText = XtNewString(strPat->spOrigText);
4660 + }
4661 +
4662 + if (strPat->spCaseInsensitive)
4663 + XtFree( regExpString );
4664 +
4665 + return (strPat->spTextRE == NULL);
4666 +}
4667 +
4668 +/*
4669 +** adapt regular expression compilation message by converting local
4670 +** backrefs to global ones.
4671 +*/
4672 +static void adaptCompileMsg(
4673 + char *compileMsg,
4674 + int *globalToLocalBackRef)
4675 +{
4676 + int localId;
4677 + int globalId;
4678 + char *s = compileMsg;
4679 +
4680 + while (*s != '\0')
4681 + {
4682 + if (*s == '\\')
4683 + {
4684 + if (isdigit((unsigned char)*(s+1)))
4685 + {
4686 + /*
4687 + * \n (n=1..9) found: substitute local by global back ref.
4688 + */
4689 + s ++;
4690 +
4691 + localId =
4692 + (int)((unsigned char)*s - (unsigned char)'0');
4693 +
4694 + globalId = localToGlobalBackRef(globalToLocalBackRef, localId);
4695 +
4696 + *s = (char)((int)('0') + globalId);
4697 + }
4698 + else if (*(s+1) != '\0')
4699 + s ++;
4700 + }
4701 + s ++;
4702 + }
4703 +}
4704 +
4705 +/*
4706 +** translate given local backref to global backref by using
4707 +** given globalToLocalBackRef list.
4708 +*/
4709 +static int localToGlobalBackRef(
4710 + int *globalToLocalBackRef,
4711 + int localId)
4712 +{
4713 + int i;
4714 +
4715 + for (i=0; i < MAX_GLOBAL_BACK_REF_ID; i++)
4716 + {
4717 + if (globalToLocalBackRef[i] == localId)
4718 + return i+1;
4719 + }
4720 +
4721 + return 0;
4722 +}
4723 +
4724 +/*
4725 +** Create a regular expression holding keywords of given start & end
4726 +** pattern set.
4727 +** Returns true, if creation of regular expression has failed.
4728 +*/
4729 +static int createStartEndRegExp(
4730 + ReadMatchPatternInfo *readMatchPatternInfo,
4731 + MatchPatternTableElement *element,
4732 + ErrorInfo *errInfo)
4733 +{
4734 + char *regExpString;
4735 + char *compileMsg;
4736 +
4737 + /*
4738 + * compose regular expression for start / end pattern.
4739 + */
4740 + composeStartEndRegExpString(
4741 + readMatchPatternInfo,
4742 + element,
4743 + ®ExpString);
4744 +
4745 + /*
4746 + * compile regular expression & free allocated string buffer.
4747 + */
4748 + element->mpteStartEndRE =
4749 + CompileRE(regExpString, &compileMsg, REDFLT_STANDARD);
4750 +
4751 + XtFree( regExpString );
4752 +
4753 + if( element->mpteStartEndRE == NULL)
4754 + {
4755 + errInfo->eiRegExpCompileMsg = compileMsg;
4756 + errInfo->eiDetail = "Error compiling start / end reg. exp.";
4757 + }
4758 +
4759 + return (element->mpteStartEndRE == NULL);
4760 +}
4761 +
4762 +/*
4763 +** Create a regular expression holding keywords of given group element.
4764 +** Returns true, if creation of regular expression has failed.
4765 +*/
4766 +static int createGroupRegExp(
4767 + ReadMatchPatternInfo *readPatInfo,
4768 + MatchPatternGroupElement *group,
4769 + ErrorInfo *errInfo)
4770 +{
4771 + int i;
4772 + MatchPatternTableElement *element;
4773 + RegExpStringInfo regExpStringInfo;
4774 + char *regExpString;
4775 + regexp *keywordRE;
4776 + char *compileMsg;
4777 +
4778 + /*
4779 + * Allocate buffers for keyword regular expression of this group.
4780 + */
4781 + setupRegExpStringBuffers(
4782 + readPatInfo,
4783 + ®ExpStringInfo);
4784 +
4785 + for (i=0; i<group->mpgeNumberOfSubPatterns; i++)
4786 + {
4787 + element = getPatternOfName(readPatInfo, group->mpgeSubPatternIds[i]);
4788 + /*
4789 + * Add the keywords of the sub pattern to the keyword regular
4790 + * expression string buffer of new group.
4791 + */
4792 + addElementToRegExpString(
4793 + element,
4794 + readPatInfo,
4795 + ®ExpStringInfo);
4796 + }
4797 +
4798 + /*
4799 + * Assemble and compile the resulting keyword regular expression string.
4800 + */
4801 + catSMTRegExpStrings(
4802 + ®ExpStringInfo,
4803 + ®ExpString);
4804 +
4805 + keywordRE = CompileRE(regExpString, &compileMsg, REDFLT_STANDARD);
4806 +
4807 + XtFree( regExpString );
4808 +
4809 + if (keywordRE == NULL)
4810 + {
4811 + errInfo->eiMPTabElementName = XtNewString(group->mpgeName);
4812 + errInfo->eiRegExpCompileMsg = compileMsg;
4813 + errInfo->eiDetail = "Group: Compile reg. exp. error";
4814 + }
4815 +
4816 + group->mpgeKeywordRE = keywordRE;
4817 +
4818 + return (keywordRE == NULL);
4819 +}
4820 +
4821 +/*
4822 +** Allocate memory for regular expression strings to be
4823 +** created out of read match pattern info.
4824 +*/
4825 +static void setupRegExpStringBuffers(
4826 + ReadMatchPatternInfo *readMatchPatternInfo,
4827 + RegExpStringInfo *regExpStringInfo)
4828 +{
4829 + int totalLen;
4830 + int nbrOfMultiPatterns;
4831 + int sizeOfPatRefs;
4832 +
4833 + /*
4834 + * determine total length of pattern characters to determine
4835 + * the size of a string buffer for the regular expression to
4836 + * compose. Count number of total multi patterns, too.
4837 + */
4838 + totalLen =
4839 + totalKeywordOfTableLen( readMatchPatternInfo, &nbrOfMultiPatterns );
4840 +
4841 + /*
4842 + * allocate memory to store added multi pattern references (to avoid
4843 + * duplicated keywords strings later on).
4844 + */
4845 + sizeOfPatRefs = sizeof(PatternReference *) * nbrOfMultiPatterns;
4846 +
4847 + regExpStringInfo->resiAddedMultiPat =
4848 + (PatternReference **)XtMalloc( sizeOfPatRefs );
4849 +
4850 + regExpStringInfo->resiNbrOfAddedMultiPat = 0;
4851 +
4852 + /*
4853 + * init. ID of capturing local backrefs
4854 + */
4855 + regExpStringInfo->resiLocalBackRefID = 1;
4856 +
4857 + /*
4858 + * allocate & init. string buffers for regular expression:
4859 + * 3 times the size + x of all pattern characters (due to
4860 + * a.) each char may need to be escaped
4861 + * b.) '<(?:', ')>', ')' and '|' need to be added.
4862 + */
4863 + regExpStringInfo->resiNoneWBRegExpString = XtMalloc( 3 * totalLen );
4864 + regExpStringInfo->resiLeftWBRegExpString = XtMalloc( 3 * totalLen + 5 );
4865 + regExpStringInfo->resiRightWBRegExpString = XtMalloc( 3 * totalLen + 5 );
4866 + regExpStringInfo->resiBothWBRegExpString = XtMalloc( 3 * totalLen + 6 );
4867 +
4868 + strcpy( regExpStringInfo->resiNoneWBRegExpString, "" );
4869 + strcpy( regExpStringInfo->resiLeftWBRegExpString, "" );
4870 + strcpy( regExpStringInfo->resiRightWBRegExpString, "" );
4871 + strcpy( regExpStringInfo->resiBothWBRegExpString, "" );
4872 +}
4873 +
4874 +/*
4875 +** Concatenate given 'partToAdd' string to result string, separated
4876 +** by an OR ('|'). Add 'postfix' at end of result string.
4877 +*/
4878 +static void addSMTRegExpString(
4879 + char *result,
4880 + char *partToAdd,
4881 + const char *postfix)
4882 +{
4883 + if (strlen(partToAdd) != 0)
4884 + {
4885 + if (strlen(result) != 0)
4886 + {
4887 + strcat( result, "|" );
4888 + }
4889 +
4890 + strcat( result, partToAdd );
4891 +
4892 + strcat( result, postfix );
4893 + }
4894 +
4895 +}
4896 +
4897 +/*
4898 +** Return a string representing given string match table.
4899 +*/
4900 +static char *createMatchPatternsString(
4901 + StringMatchTable *table,
4902 + char *indentStr)
4903 +{
4904 + char *outStr, *str;
4905 + textBuffer *outBuf;
4906 + int i, j;
4907 + MatchPatternSequenceElement *seq;
4908 + MatchPatternTableElement *element;
4909 + MatchPatternGroupElement *group;
4910 +
4911 + outBuf = BufCreate();
4912 +
4913 + for (i=0; i<table->smtNumberOfSeqElements; i++)
4914 + {
4915 + seq = table->smtSequence[i];
4916 +
4917 + BufInsert(outBuf, outBuf->length, indentStr);
4918 + BufInsert(outBuf, outBuf->length, seq->mpseName);
4919 + BufInsert(outBuf, outBuf->length, ":");
4920 +
4921 + if (seq->mpseType == MPT_GROUP)
4922 + {
4923 + BufInsert(outBuf, outBuf->length, "g:");
4924 +
4925 + group = table->smtGroups[seq->mpseIndex];
4926 +
4927 + for (j=0; j < group->mpgeNumberOfSubPatterns; j ++)
4928 + {
4929 + BufInsert(outBuf, outBuf->length, group->mpgeSubPatternIds[j]);
4930 + BufInsert(outBuf, outBuf->length, ":");
4931 + }
4932 + }
4933 + else
4934 + {
4935 + if (seq->mpseType == MPT_SUB)
4936 + {
4937 + BufInsert(outBuf, outBuf->length, "s");
4938 + }
4939 + BufInsert(outBuf, outBuf->length, ":");
4940 +
4941 + element = table->smtAllPatterns->mptElements[seq->mpseIndex];
4942 +
4943 + /*
4944 + * write global attributes
4945 + */
4946 + if (element->mpteSkipBtwnStartEnd)
4947 + BufInsert(outBuf, outBuf->length, "c");
4948 + if (element->mpteFlash)
4949 + BufInsert(outBuf, outBuf->length, "f");
4950 + if (element->mpteIsMonoPattern)
4951 + BufInsert(outBuf, outBuf->length, "m");
4952 + if (element->mpteIgnoreHighLightInfo)
4953 + BufInsert(outBuf, outBuf->length, "p");
4954 + BufInsert(outBuf, outBuf->length, ":");
4955 +
4956 + /*
4957 + * write string patterns
4958 + */
4959 + for (j=0; j < element->mpteAll.pesNumberOfPattern; j ++)
4960 + {
4961 + BufInsert(
4962 + outBuf,
4963 + outBuf->length,
4964 + str =
4965 + createPatternElementString(
4966 + table->smtAllPatterns,
4967 + element->mpteAll.pesPattern[j]));
4968 + XtFree(str);
4969 + }
4970 + }
4971 +
4972 + BufInsert(outBuf, outBuf->length, "\n");
4973 + }
4974 +
4975 + outStr = BufGetAll(outBuf);
4976 + BufFree(outBuf);
4977 +
4978 + return outStr;
4979 +}
4980 +
4981 +/*
4982 +** Return a string representing given pattern element.
4983 +*/
4984 +static char *createPatternElementString(
4985 + MatchPatternTable *table,
4986 + PatternElement *pat)
4987 +{
4988 + char *outStr, *str;
4989 + textBuffer *outBuf;
4990 + StringPattern *strPat;
4991 +
4992 + outBuf = BufCreate();
4993 +
4994 + strPat = GetStringPattern(table, pat);
4995 +
4996 + /*
4997 + * write string pattern kind
4998 + */
4999 + if (pat->peKind == PEK_START)
5000 + BufInsert(outBuf, outBuf->length, "s");
5001 + else if (pat->peKind == PEK_MIDDLE)
5002 + BufInsert(outBuf, outBuf->length, "m");
5003 + else if (pat->peKind == PEK_END)
5004 + BufInsert(outBuf, outBuf->length, "e");
5005 +
5006 + /*
5007 + * write word boundary
5008 + */
5009 + if (strPat->spWordBoundary == PWB_BOTH)
5010 + BufInsert(outBuf, outBuf->length, "w");
5011 + else if (strPat->spWordBoundary == PWB_LEFT)
5012 + BufInsert(outBuf, outBuf->length, "l");
5013 + else if (strPat->spWordBoundary == PWB_RIGHT)
5014 + BufInsert(outBuf, outBuf->length, "r");
5015 +
5016 + /*
5017 + * write case insensitive flag
5018 + */
5019 + if (strPat->spCaseInsensitive)
5020 + BufInsert(outBuf, outBuf->length, "i");
5021 +
5022 + /*
5023 + * write regular expression flag
5024 + */
5025 + if (strPat->spRegularExpression)
5026 + BufInsert(outBuf, outBuf->length, "x");
5027 +
5028 + BufInsert(outBuf, outBuf->length, ":");
5029 +
5030 + /*
5031 + * write pattern string
5032 + */
5033 + if( strPat->spOrigText != NULL)
5034 + BufInsert(
5035 + outBuf,
5036 + outBuf->length,
5037 + str = MakeQuotedString(strPat->spOrigText));
5038 + else
5039 + BufInsert(
5040 + outBuf,
5041 + outBuf->length,
5042 + str = MakeQuotedString(strPat->spText));
5043 + XtFree(str);
5044 +
5045 + BufInsert(outBuf, outBuf->length, ":");
5046 +
5047 + outStr = BufGetAll(outBuf);
5048 + BufFree(outBuf);
5049 +
5050 + return outStr;
5051 +}
5052 +
5053 +/*
5054 +** Given a language mode name, determine if there is a default (built-in)
5055 +** string match table available for that language mode, and if so, read it and
5056 +** return a new allocated copy of it. The returned pattern set should be
5057 +** freed by the caller with freeStringMatchTable().
5058 +*/
5059 +static StringMatchTable *readDefaultStringMatchTable(const char *langModeName)
5060 +{
5061 + int i, modeNameLen;
5062 + char *list;
5063 +
5064 + modeNameLen = strlen(langModeName);
5065 +
5066 + for (i=0; i<(int)XtNumber(DefaultStringMatchTable); i++)
5067 + {
5068 + if (!strncmp(langModeName, DefaultStringMatchTable[i], modeNameLen) &&
5069 + DefaultStringMatchTable[i][modeNameLen] == '{')
5070 + {
5071 + list = DefaultStringMatchTable[i];
5072 + return readMatchPatternSet(&list);
5073 + }
5074 + }
5075 +
5076 + list = StandardStringMatchTable;
5077 + return readMatchPatternSetContent(&list, list, XtNewString(langModeName));
5078 +}
5079 +
5080 +/*
5081 +** Return true, if table exactly matches one of the default matching
5082 +** pattern tables.
5083 +*/
5084 +static int isDefaultMatchPatternTable(StringMatchTable *table)
5085 +{
5086 + StringMatchTable *defaultTable;
5087 + int retVal;
5088 +
5089 + defaultTable = readDefaultStringMatchTable(table->smtLanguageMode);
5090 +
5091 + if (defaultTable == NULL)
5092 + return False;
5093 +
5094 + retVal = !stringMatchTableDiffer(table, defaultTable);
5095 +
5096 + freeStringMatchTable(defaultTable);
5097 +
5098 + return retVal;
5099 +}
5100 +
5101 +/*
5102 +** Read in a string match pattern table character string,
5103 +** and advance *inPtr beyond it.
5104 +** Returns NULL and outputs an error to stderr on failure.
5105 +*/
5106 +static StringMatchTable *readMatchPatternSet(char **inPtr)
5107 +{
5108 + char *languageMode;
5109 + StringMatchTable *table = NULL;
5110 + char *stringStart = *inPtr;
5111 + ErrorInfo errInfo;
5112 +
5113 + initErrorInfo(&errInfo);
5114 +
5115 + /*
5116 + * remove leading whitespace
5117 + */
5118 + *inPtr += strspn(*inPtr, " \t\n");
5119 +
5120 + /*
5121 + * read language mode field
5122 + */
5123 + languageMode = ReadSymbolicField(inPtr);
5124 +
5125 + /*
5126 + * look for initial brace
5127 + */
5128 + if (**inPtr == ':')
5129 + {
5130 + (*inPtr) ++;
5131 + /*
5132 + * look for "Default" keyword, and if it's there, return the default
5133 + * pattern set
5134 + */
5135 + if (!strncmp(*inPtr, "Default", 7))
5136 + {
5137 + *inPtr += 7;
5138 + table = readDefaultStringMatchTable(languageMode);
5139 + XtFree(languageMode);
5140 +
5141 + return table;
5142 + }
5143 + }
5144 +
5145 + table = readMatchPatternSetContent(inPtr, stringStart, languageMode);
5146 +
5147 + if (table == NULL)
5148 + XtFree(languageMode);
5149 +
5150 + return table;
5151 +}
5152 +
5153 +/*
5154 +** Read in a content string ("{..}") of match pattern table,
5155 +** and advance *inPtr beyond it.
5156 +** Returns NULL and outputs an error to stderr on failure.
5157 +*/
5158 +static StringMatchTable *readMatchPatternSetContent(
5159 + char **inPtr,
5160 + char *stringStart,
5161 + char *languageMode)
5162 +{
5163 + ReadMatchPatternInfo readPatInfo;
5164 + StringMatchTable *table = NULL;
5165 + ErrorInfo errInfo;
5166 + int successful = True;
5167 + int endOfPatternSet = False;
5168 +
5169 + initErrorInfo(&errInfo);
5170 +
5171 + /*
5172 + * look for initial brace
5173 + */
5174 + if (**inPtr != '{')
5175 + {
5176 + errInfo.eiLanguageMode = XtNewString(languageMode);
5177 + errInfo.eiDetail = "pattern list must begin with \"{\"";
5178 + parseMatchingPatternSetError(stringStart, *inPtr, &errInfo );
5179 +
5180 + return NULL;
5181 + }
5182 +
5183 + (*inPtr)++;
5184 +
5185 + readPatInfo.rmpiNbrOfElements = 0;
5186 + readPatInfo.rmpiNbrOfGroups = 0;
5187 + readPatInfo.rmpiNbrOfSeqElements = 0;
5188 + readPatInfo.rmpiAllPatRE = NULL;
5189 + readPatInfo.rmpiFlashPatRE = NULL;
5190 +
5191 + /*
5192 + * parse each pattern in the list
5193 + */
5194 + while (successful && !endOfPatternSet)
5195 + {
5196 + *inPtr += strspn(*inPtr, " \t\n");
5197 + if (**inPtr == '\0')
5198 + {
5199 + errInfo.eiLanguageMode = XtNewString(languageMode);
5200 + errInfo.eiDetail = "end of pattern list not found";
5201 + parseMatchingPatternSetError(stringStart, *inPtr, &errInfo);
5202 + successful = False;
5203 + }
5204 + else if (**inPtr == '}')
5205 + {
5206 + (*inPtr)++;
5207 + endOfPatternSet = True;
5208 + }
5209 + else
5210 + {
5211 + if (!readMatchPatternEntry(inPtr, &errInfo, &readPatInfo))
5212 + {
5213 + errInfo.eiLanguageMode = XtNewString(languageMode);
5214 + parseMatchingPatternSetError(stringStart, *inPtr, &errInfo);
5215 + successful = False;
5216 + }
5217 + }
5218 + }
5219 +
5220 + if (successful)
5221 + {
5222 + /*
5223 + * compile regular expressions of read patterns
5224 + */
5225 + if (createRegExpOfPatterns(&readPatInfo, &errInfo))
5226 + {
5227 + parseMatchingPatternSetError(stringStart, *inPtr, &errInfo);
5228 + successful = False;
5229 + }
5230 + }
5231 +
5232 + if (successful)
5233 + {
5234 + return createStringMatchTable(&readPatInfo, languageMode);
5235 + }
5236 + else
5237 + {
5238 + /*
5239 + * free memory of already read patterns
5240 + */
5241 + freeReadMatchPatternInfo(&readPatInfo);
5242 +
5243 + return NULL;
5244 + }
5245 +
5246 + return table;
5247 +}
5248 +
5249 +/*
5250 +** Create a reg. exp. of all patterns contained
5251 +** in given read match pattern info.
5252 +*/
5253 +static int createRegExpOfPatterns(
5254 + ReadMatchPatternInfo *readPatInfo,
5255 + ErrorInfo *errInfo)
5256 +{
5257 + if (createRegExpOfStrPatterns(readPatInfo, errInfo))
5258 + return True;
5259 +
5260 + if (createRegExpOfAllPatterns(readPatInfo, errInfo))
5261 + return True;
5262 +
5263 + return False;
5264 +}
5265 +
5266 +/*
5267 +** Create a "total pattern reg. exp." of all patterns / flash patterns
5268 +** contained in given read match pattern info.
5269 +** Returns true, if create of reg. exp. has failed.
5270 +*/
5271 +static int createRegExpOfAllPatterns(
5272 + ReadMatchPatternInfo *readPatInfo,
5273 + ErrorInfo *errInfo)
5274 +{
5275 + int i;
5276 + RegExpStringInfo allPatRegExpSI;
5277 + RegExpStringInfo flashPatRegExpSI;
5278 + MatchPatternTableElement *element;
5279 + char *regExpString;
5280 + char *compileMsg;
5281 +
5282 + /*
5283 + * Allocate buffers for keyword regular expressions.
5284 + */
5285 + setupRegExpStringBuffers(readPatInfo, &allPatRegExpSI);
5286 + setupRegExpStringBuffers(readPatInfo, &flashPatRegExpSI);
5287 +
5288 + for (i=0; i < readPatInfo->rmpiNbrOfElements; i ++)
5289 + {
5290 + element = readPatInfo->rmpiElement[i];
5291 +
5292 + /*
5293 + * Add the keywords of the matching pattern to the keyword
5294 + * regular expression string buffer of all patterns.
5295 + */
5296 + addElementToRegExpString(
5297 + element,
5298 + readPatInfo,
5299 + &allPatRegExpSI);
5300 +
5301 + /*
5302 + * If flash attribute is set, then add the keywords of the
5303 + * matching pattern also to the keyword regular expression
5304 + * string buffer of flash patterns.
5305 + */
5306 + if (element->mpteFlash)
5307 + {
5308 + addElementToRegExpString(
5309 + element,
5310 + readPatInfo,
5311 + &flashPatRegExpSI);
5312 + }
5313 + }
5314 +
5315 + /*
5316 + * Assemble and compile the resulting all keywords reg. exp. string.
5317 + */
5318 + catSMTRegExpStrings(
5319 + &allPatRegExpSI,
5320 + ®ExpString);
5321 +
5322 + readPatInfo->rmpiAllPatRE =
5323 + CompileRE(regExpString, &compileMsg, REDFLT_STANDARD);
5324 +
5325 + XtFree( regExpString );
5326 +
5327 + if (readPatInfo->rmpiAllPatRE == NULL)
5328 + {
5329 + errInfo->eiRegExpCompileMsg = compileMsg;
5330 + errInfo->eiDetail = "All patterns: compile reg. exp. error";
5331 + return True;
5332 + }
5333 +
5334 + /*
5335 + * Assemble and compile the resulting flash keywords reg. exp. string.
5336 + */
5337 + catSMTRegExpStrings(
5338 + &flashPatRegExpSI,
5339 + ®ExpString);
5340 +
5341 + readPatInfo->rmpiFlashPatRE =
5342 + CompileRE(regExpString, &compileMsg, REDFLT_STANDARD);
5343 +
5344 + XtFree( regExpString );
5345 +
5346 + if (readPatInfo->rmpiFlashPatRE == NULL)
5347 + {
5348 + errInfo->eiRegExpCompileMsg = compileMsg;
5349 + errInfo->eiDetail = "Flash patterns: compile reg. exp. error";
5350 + return True;
5351 + }
5352 +
5353 + /*
5354 + * Pattern reg. exp. successful created:
5355 + */
5356 + return False;
5357 +}
5358 +
5359 +/*
5360 +** Create reg. exp. of single patterns contained in given
5361 +** read match pattern info.
5362 +** Returns true, if create of reg. exp. has failed.
5363 +*/
5364 +static int createRegExpOfStrPatterns(
5365 + ReadMatchPatternInfo *readPatInfo,
5366 + ErrorInfo *errInfo)
5367 +{
5368 + int i;
5369 + MatchPatternTableElement *element;
5370 + MatchPatternGroupElement *group;
5371 +
5372 + /*
5373 + * create global backref list of all elements of read info
5374 + */
5375 + for (i=0; i < readPatInfo->rmpiNbrOfElements; i ++)
5376 + {
5377 + element = readPatInfo->rmpiElement[i];
5378 +
5379 + if (!createGlobalBackRefList(readPatInfo, element, errInfo))
5380 + return True;
5381 + }
5382 +
5383 + /*
5384 + * resolve global backrefs of all elements of read info
5385 + */
5386 + for (i=0; i < readPatInfo->rmpiNbrOfElements; i ++)
5387 + {
5388 + element = readPatInfo->rmpiElement[i];
5389 +
5390 + if (!resolveGlobalBackRefs(readPatInfo, element, errInfo))
5391 + return True;
5392 + }
5393 +
5394 + /*
5395 + * compile reg. exp. of all elements of read info
5396 + */
5397 + for (i=0; i < readPatInfo->rmpiNbrOfElements; i ++)
5398 + {
5399 + element = readPatInfo->rmpiElement[i];
5400 +
5401 + if (createStrPatRegExpOfElement(readPatInfo, element, errInfo))
5402 + return True;
5403 +
5404 + /*
5405 + * create start / end reg. exp. if applicable.
5406 + */
5407 + if (element->mpteSkipBtwnStartEnd)
5408 + {
5409 + if (createStartEndRegExp(readPatInfo, element, errInfo))
5410 + return True;
5411 + }
5412 + }
5413 +
5414 + /*
5415 + * compile reg. exp. of all groups of read info
5416 + */
5417 + for (i=0; i < readPatInfo->rmpiNbrOfGroups; i ++)
5418 + {
5419 + group = readPatInfo->rmpiGroup[i];
5420 +
5421 + if (createGroupRegExp(readPatInfo, group, errInfo))
5422 + {
5423 + return True;
5424 + }
5425 + }
5426 +
5427 + return False;
5428 +}
5429 +
5430 +/*
5431 +** Create a string match table out of read match pattern info.
5432 +*/
5433 +static StringMatchTable *createStringMatchTable(
5434 + ReadMatchPatternInfo *readPatInfo,
5435 + char *languageMode)
5436 +{
5437 + StringMatchTable *table;
5438 + MatchPatternTable *patTable;
5439 + int sizeOfElements;
5440 +
5441 + table = (StringMatchTable *)XtMalloc(sizeof(StringMatchTable));
5442 + table->smtLanguageMode = languageMode;
5443 +
5444 + /*
5445 + * allocate a more appropriately sized list to return matching patterns
5446 + */
5447 + patTable = (MatchPatternTable *)XtMalloc(sizeof(MatchPatternTable));
5448 + patTable->mptNumberOfElements = readPatInfo->rmpiNbrOfElements;
5449 +
5450 + if (readPatInfo->rmpiNbrOfElements > 0)
5451 + {
5452 + sizeOfElements =
5453 + sizeof(MatchPatternTableElement *) * readPatInfo->rmpiNbrOfElements;
5454 + patTable->mptElements =
5455 + (MatchPatternTableElement **)XtMalloc(sizeOfElements);
5456 + memcpy(patTable->mptElements, readPatInfo->rmpiElement, sizeOfElements);
5457 + }
5458 + else
5459 + {
5460 + patTable->mptElements = NULL;
5461 + }
5462 +
5463 + table->smtAllPatterns = patTable;
5464 +
5465 + table->smtAllPatRE = readPatInfo->rmpiAllPatRE;
5466 + table->smtFlashPatRE = readPatInfo->rmpiFlashPatRE;
5467 + table->smtUsedPatRE = NULL;
5468 +
5469 + /*
5470 + * allocate a more appropriately sized list to return matching pattern groups
5471 + */
5472 + table->smtNumberOfGroups = readPatInfo->rmpiNbrOfGroups;
5473 + if (readPatInfo->rmpiNbrOfGroups > 0)
5474 + {
5475 + sizeOfElements =
5476 + sizeof(MatchPatternGroupElement *) * readPatInfo->rmpiNbrOfGroups;
5477 + table->smtGroups =
5478 + (MatchPatternGroupElement **)XtMalloc(sizeOfElements);
5479 + memcpy(table->smtGroups, readPatInfo->rmpiGroup, sizeOfElements);
5480 + }
5481 + else
5482 + {
5483 + table->smtGroups = NULL;
5484 + }
5485 + /*
5486 + * allocate a more appropriately sized list to return matching pattern sequence
5487 + */
5488 + table->smtNumberOfSeqElements = readPatInfo->rmpiNbrOfSeqElements;
5489 + if (readPatInfo->rmpiNbrOfSeqElements > 0)
5490 + {
5491 + sizeOfElements =
5492 + sizeof(MatchPatternSequenceElement *) * readPatInfo->rmpiNbrOfSeqElements;
5493 + table->smtSequence =
5494 + (MatchPatternSequenceElement **)XtMalloc(sizeOfElements);
5495 + memcpy(table->smtSequence, readPatInfo->rmpiSequence, sizeOfElements);
5496 + }
5497 + else
5498 + {
5499 + table->smtSequence = NULL;
5500 + }
5501 +
5502 + return table;
5503 +}
5504 +
5505 +/*
5506 +** Read one match pattern entry of a match pattern string.
5507 +** Returns true, if read was successful.
5508 +*/
5509 +static int readMatchPatternEntry(
5510 + char **inPtr,
5511 + ErrorInfo *errInfo,
5512 + ReadMatchPatternInfo *info)
5513 +{
5514 + char *name;
5515 + MatchPatternType type;
5516 + MatchPatternGroupElement *readGroup;
5517 + MatchPatternTableElement *readElement;
5518 +
5519 + if (!getMPSName( inPtr, errInfo, &name ))
5520 + {
5521 + return False;
5522 + }
5523 +
5524 + if (!getMPSTypeAttribute( inPtr, errInfo, &type ))
5525 + {
5526 + errInfo->eiMPTabElementName = XtNewString(name);
5527 + return False;
5528 + }
5529 +
5530 + if (type == MPT_GROUP)
5531 + {
5532 + if (info->rmpiNbrOfGroups >= MAX_NBR_MATCH_PATTERN_GROUPS)
5533 + {
5534 + errInfo->eiMPTabElementName = XtNewString(name);
5535 + errInfo->eiDetail = "max number of match pattern groups exceeded";
5536 + return False;
5537 + }
5538 +
5539 + readGroup = readMatchPatternGroup( inPtr, errInfo, name, info );
5540 +
5541 + if (readGroup == NULL)
5542 + {
5543 + errInfo->eiMPTabElementName = XtNewString(name);
5544 + XtFree( name );
5545 + }
5546 + else
5547 + {
5548 + info->rmpiGroup[info->rmpiNbrOfGroups ++] = readGroup;
5549 +
5550 + recordPatternSequence( info, name, type, info->rmpiNbrOfGroups-1 );
5551 + }
5552 +
5553 + return (readGroup != NULL);
5554 + }
5555 + else
5556 + {
5557 + if (info->rmpiNbrOfElements >= MAX_NBR_MATCH_PATTERNS)
5558 + {
5559 + errInfo->eiMPTabElementName = XtNewString(name);
5560 + errInfo->eiDetail = "max number of match patterns exceeded";
5561 + XtFree( name );
5562 + return False;
5563 + }
5564 +
5565 + readElement =
5566 + readMatchPatternTableElement( inPtr, &errInfo->eiDetail, name, type );
5567 +
5568 + if (readElement == NULL)
5569 + {
5570 + errInfo->eiMPTabElementName = XtNewString(name);
5571 + XtFree( name );
5572 + }
5573 + else
5574 + {
5575 + readElement->mpteIndex = info->rmpiNbrOfElements;
5576 +
5577 + info->rmpiElement[info->rmpiNbrOfElements ++] = readElement;
5578 +
5579 + if (type == MPT_INDIVIDUAL)
5580 + {
5581 + if (!assignIndividualGroup( info, &errInfo->eiDetail, readElement ))
5582 + {
5583 + errInfo->eiMPTabElementName = XtNewString(name);
5584 + return False;
5585 + }
5586 + }
5587 +
5588 + treatDuplicatedMTEntries(
5589 + info->rmpiElement, info->rmpiNbrOfElements );
5590 +
5591 + recordPatternSequence( info, name, type, info->rmpiNbrOfElements-1 );
5592 + }
5593 +
5594 + return (readElement != NULL);
5595 + }
5596 +}
5597 +
5598 +/*
5599 +** Record match pattern sequence for display of match pattern dialog.
5600 +*/
5601 +static void recordPatternSequence(
5602 + ReadMatchPatternInfo *info,
5603 + char *name,
5604 + MatchPatternType type,
5605 + int index)
5606 +{
5607 + MatchPatternSequenceElement *sequence;
5608 +
5609 + sequence =
5610 + (MatchPatternSequenceElement *)XtMalloc( sizeof(MatchPatternSequenceElement) );
5611 +
5612 + sequence->mpseName = XtNewString(name);
5613 + sequence->mpseType = type;
5614 + sequence->mpseIndex = index;
5615 +
5616 + info->rmpiSequence[info->rmpiNbrOfSeqElements ++] = sequence;
5617 +}
5618 +
5619 +/*
5620 +** Assign a new group to an individual match pattern.
5621 +** Returns true, if assignment was successful.
5622 +*/
5623 +static int assignIndividualGroup(
5624 + ReadMatchPatternInfo *info,
5625 + char **errMsg,
5626 + MatchPatternTableElement *element)
5627 +{
5628 + MatchPatternGroupElement *group = NULL;
5629 +
5630 + if (info->rmpiNbrOfGroups >= MAX_NBR_MATCH_PATTERN_GROUPS)
5631 + {
5632 + *errMsg = "max. number of matching pattern groups exceeded\n";
5633 + return False;
5634 + }
5635 +
5636 + /*
5637 + * Assign the index of new group to the individual matching pattern
5638 + */
5639 + element->mpteGroup = info->rmpiNbrOfGroups;
5640 +
5641 + /*
5642 + * Allocate memory for the matching pattern group and copy the
5643 + * info into this group element.
5644 + */
5645 + group =
5646 + (MatchPatternGroupElement *)XtMalloc( sizeof(MatchPatternGroupElement) );
5647 +
5648 + group->mpgeName = NULL;
5649 + group->mpgeKeywordRE = NULL;
5650 +
5651 + /*
5652 + * remember name of match pattern table element, which is
5653 + * represented by this group.
5654 + */
5655 + group->mpgeNumberOfSubPatterns = 1;
5656 + group->mpgeSubPatternIds = (char **)XtMalloc( sizeof(char *) );
5657 + group->mpgeSubPatternIds[0] = XtNewString(element->mpteName);
5658 +
5659 + info->rmpiGroup[info->rmpiNbrOfGroups ++] = group;
5660 +
5661 + return True;
5662 +}
5663 +
5664 +/*
5665 +** Get the match pattern table element of given 'patToSearch'
5666 +** name.
5667 +** Returns NULL, if no element was found.
5668 +*/
5669 +static MatchPatternTableElement *getPatternOfName(
5670 + ReadMatchPatternInfo *info,
5671 + char *patToSearch)
5672 +{
5673 + int i;
5674 + MatchPatternTableElement *element;
5675 +
5676 + for (i=0; i<info->rmpiNbrOfElements; i ++)
5677 + {
5678 + element = info->rmpiElement[i];
5679 +
5680 + if (strcmp( element->mpteName, patToSearch ) == 0)
5681 + {
5682 + /*
5683 + * Related sub-pattern found:
5684 + */
5685 + return element;
5686 + }
5687 + }
5688 +
5689 + /*
5690 + * No sub-pattern found:
5691 + */
5692 + return NULL;
5693 +}
5694 +
5695 +/*
5696 +** Read match pattern group of given match pattern string.
5697 +** Returns NULL, if read fails.
5698 +*/
5699 +static MatchPatternGroupElement *readMatchPatternGroup(
5700 + char **inPtr,
5701 + ErrorInfo *errInfo,
5702 + char *name,
5703 + ReadMatchPatternInfo *info)
5704 +{
5705 + int i;
5706 + int error = False;
5707 + char *patNameInPtr;
5708 + char *subPatName;
5709 + MatchPatternTableElement *subPatElement;
5710 + int numberOfRelatedSubPattern = 0;
5711 + char *relatedSubPatternId[MAX_NBR_MATCH_PATTERNS];
5712 + int sizeOfIds;
5713 + MatchPatternGroupElement *group = NULL;
5714 +
5715 + /*
5716 + * Read sub-matching patterns of this group.
5717 + */
5718 + while (**inPtr != '\n' && !error)
5719 + {
5720 + /*
5721 + * Read next pattern name from inPtr.
5722 + */
5723 + patNameInPtr = *inPtr;
5724 + subPatName = ReadSymbolicField(inPtr);
5725 +
5726 + if (subPatName == NULL)
5727 + {
5728 + errInfo->eiDetail = "Sub-Matching Pattern Name expected";
5729 + error = True;
5730 + }
5731 + else
5732 + {
5733 + /*
5734 + * Get matching pattern related to sub-matching pattern name.
5735 + */
5736 + subPatElement =
5737 + getPatternOfName( info, subPatName );
5738 +
5739 + if (subPatElement == NULL)
5740 + {
5741 + errInfo->eiStringPatText = XtNewString(subPatName);
5742 + errInfo->eiDetail = "Sub-Matching Pattern not defined before";
5743 + error = True;
5744 + }
5745 + else if (numberOfRelatedSubPattern >= MAX_NBR_MATCH_PATTERNS)
5746 + {
5747 + errInfo->eiDetail = "Group holds too many Sub-Matching Patterns";
5748 + error = True;
5749 + }
5750 + else if (subPatElement->mpteType != MPT_SUB)
5751 + {
5752 + errInfo->eiStringPatText = XtNewString(subPatName);
5753 + errInfo->eiDetail = "Not a Sub-Matching Pattern";
5754 + error = True;
5755 + }
5756 + else
5757 + {
5758 + /*
5759 + * Remember sub-matching pattern ID
5760 + */
5761 + relatedSubPatternId[numberOfRelatedSubPattern ++] = subPatName;
5762 +
5763 + /*
5764 + * Assign the index of this group to the sub-matching pattern
5765 + * if no group index was assigned before.
5766 + */
5767 + if (subPatElement->mpteGroup == NO_GROUP_IDX)
5768 + {
5769 + subPatElement->mpteGroup = info->rmpiNbrOfGroups;
5770 + }
5771 + }
5772 +
5773 + /*
5774 + * Skip to the start of the next matching pattern name.
5775 + */
5776 + if (!error && !SkipDelimiter(inPtr, &errInfo->eiDetail))
5777 + {
5778 + error = True;
5779 + }
5780 + }
5781 + }
5782 +
5783 + if (error)
5784 + {
5785 + for (i=0; i < numberOfRelatedSubPattern; i++)
5786 + {
5787 + XtFree( relatedSubPatternId[i] );
5788 + }
5789 +
5790 + return NULL;
5791 + }
5792 + else
5793 + {
5794 + /*
5795 + * Allocate memory for the matching pattern group and copy the
5796 + * info into this group element.
5797 + */
5798 + group =
5799 + (MatchPatternGroupElement *)XtMalloc( sizeof(MatchPatternGroupElement) );
5800 +
5801 + group->mpgeName = name;
5802 + group->mpgeKeywordRE = NULL;
5803 +
5804 + /*
5805 + * Allocate memory for the sub-matching pattern IDs & copy
5806 + * related sub-matching pattern into the group element.
5807 + */
5808 + sizeOfIds = sizeof(char *) * numberOfRelatedSubPattern;
5809 + group->mpgeSubPatternIds = (char **)XtMalloc( sizeOfIds );
5810 +
5811 + memcpy(group->mpgeSubPatternIds, relatedSubPatternId, sizeOfIds);
5812 +
5813 + group->mpgeNumberOfSubPatterns = numberOfRelatedSubPattern;
5814 +
5815 + return group;
5816 + }
5817 +}
5818 +
5819 +/*
5820 +** Read one match pattern element from given match pattern string.
5821 +** Returns true, if read was successful.
5822 +*/
5823 +static int readPatternElement(
5824 + char **inPtr,
5825 + char **errMsg,
5826 + PatternElement **pattern)
5827 +{
5828 + PatternElementKind patternKind;
5829 + PatternWordBoundary wordBoundary;
5830 + int caseInsensitive;
5831 + int regularExpression;
5832 + char *string;
5833 +
5834 + if (!getMPSPatternAttribute(
5835 + inPtr,
5836 + errMsg,
5837 + &patternKind,
5838 + &wordBoundary,
5839 + &caseInsensitive,
5840 + ®ularExpression ))
5841 + {
5842 + return False;
5843 + }
5844 +
5845 + if (!ReadQuotedString(inPtr, errMsg, &string))
5846 + {
5847 + return False;
5848 + }
5849 +
5850 + if (!SkipDelimiter(inPtr, errMsg))
5851 + {
5852 + XtFree( string );
5853 + return False;
5854 + }
5855 +
5856 + *pattern =
5857 + createPatternElement(
5858 + string,
5859 + patternKind,
5860 + wordBoundary,
5861 + caseInsensitive,
5862 + regularExpression);
5863 +
5864 + return True;
5865 +}
5866 +
5867 +/*
5868 +** Create a pattern element.
5869 +*/
5870 +static PatternElement *createPatternElement(
5871 + char *patternText,
5872 + PatternElementKind patternKind,
5873 + PatternWordBoundary wordBoundary,
5874 + int caseInsensitive,
5875 + int regularExpression)
5876 +{
5877 + PatternElement *pattern;
5878 + char *s;
5879 +
5880 + /*
5881 + * Convert pattern text to lower case, if case insensitive
5882 + * attribute is set.
5883 + */
5884 + if (caseInsensitive)
5885 + {
5886 + for (s = patternText; *s != '\0'; s ++)
5887 + {
5888 + *s = tolower(*s);
5889 + }
5890 + }
5891 +
5892 + /*
5893 + * Allocate memory for the new pattern element and init. / copy
5894 + * related info into this pattern element.
5895 + */
5896 + pattern = (PatternElement *)XtMalloc( sizeof(PatternElement) );
5897 +
5898 + initStrPatBackRefList(&pattern->peVal.peuSingle);
5899 +
5900 + pattern->peKind = patternKind;
5901 + pattern->peIndex = NO_PATTERN_IDX;
5902 + pattern->peType = PET_SINGLE;
5903 +
5904 + pattern->peVal.peuSingle.spLength = strlen(patternText);
5905 + pattern->peVal.peuSingle.spBackRefParsed = False;
5906 + pattern->peVal.peuSingle.spBackRefResolved = False;
5907 +
5908 + pattern->peVal.peuSingle.spCaseInsensitive = caseInsensitive;
5909 + pattern->peVal.peuSingle.spRegularExpression = regularExpression;
5910 + pattern->peVal.peuSingle.spTextRE = NULL;
5911 +
5912 + /*
5913 + * Store original string of regular expression patterns due to
5914 + * it may be later adapted (e.g. due to global backrefs etc.).
5915 + */
5916 + if (regularExpression)
5917 + {
5918 + pattern->peVal.peuSingle.spOrigText = patternText;
5919 + pattern->peVal.peuSingle.spText = NULL;
5920 + pattern->peVal.peuSingle.spWordBoundary = PWB_NONE;
5921 + }
5922 + else
5923 + {
5924 + pattern->peVal.peuSingle.spOrigText = NULL;
5925 + pattern->peVal.peuSingle.spText = patternText;
5926 + pattern->peVal.peuSingle.spWordBoundary = wordBoundary;
5927 + }
5928 +
5929 + return pattern;
5930 +}
5931 +
5932 +/*
5933 +** Create a list holding all global backref definitions of given
5934 +** match pattern table element. The list is stored in this given
5935 +** element.
5936 +** Returns true, if list was successfully created.
5937 +*/
5938 +static int createGlobalBackRefList(
5939 + ReadMatchPatternInfo *readPatInfo,
5940 + MatchPatternTableElement *element,
5941 + ErrorInfo *errInfo)
5942 +{
5943 + int i;
5944 + StringPattern *strPat;
5945 +
5946 + for (i=0; i<element->mpteAll.pesNumberOfPattern; i++)
5947 + {
5948 + strPat = getReadStringPattern(readPatInfo, element->mpteAll.pesPattern[i]);
5949 +
5950 + if (strPat->spRegularExpression)
5951 + {
5952 + if (strPat->spBackRefParsed)
5953 + {
5954 + /*
5955 + * Global backrefs or this string pattern already parsed:
5956 + * just merge string pattern list with elements one.
5957 + */
5958 + if (!updateGlobalBackRefs(
5959 + strPat,
5960 + element->mpteGlobalBackRef,
5961 + errInfo))
5962 + {
5963 + return False;
5964 + }
5965 + }
5966 + else
5967 + {
5968 + /*
5969 + * parse string pattern for global backrefs and
5970 + * merge string pattern list with elements one.
5971 + */
5972 + if (!parseGlobalBackRefs(
5973 + strPat,
5974 + element->mpteGlobalBackRef,
5975 + errInfo))
5976 + {
5977 + return False;
5978 + }
5979 + }
5980 + }
5981 + }
5982 +
5983 + return True;
5984 +}
5985 +
5986 +/*
5987 +** Returns read string pattern of given pattern element.
5988 +*/
5989 +StringPattern *getReadStringPattern(
5990 + ReadMatchPatternInfo *readPatInfo,
5991 + PatternElement *pattern )
5992 +{
5993 + switch (pattern->peType)
5994 + {
5995 + case PET_SINGLE:
5996 + return &pattern->peVal.peuSingle;
5997 + break;
5998 +
5999 + case PET_MULTIPLE:
6000 + return &pattern->peVal.peuMulti.mpStringPattern;
6001 + break;
6002 +
6003 + case PET_REFERENCE:
6004 + return getReadStringPattern(
6005 + readPatInfo,
6006 + getReadPatternOfReference(readPatInfo, &pattern->peVal.peuRef));
6007 + break;
6008 + }
6009 +
6010 + /*
6011 + * never reached; just to make compiler happy
6012 + */
6013 + return NULL;
6014 +}
6015 +
6016 +/*
6017 +** Returns read pattern element of given pattern reference.
6018 +*/
6019 +static PatternElement *getReadPatternOfReference(
6020 + ReadMatchPatternInfo *readPatInfo,
6021 + PatternReference *patRef)
6022 +{
6023 + MatchPatternTableElement **element = readPatInfo->rmpiElement;
6024 +
6025 + return element[ patRef->prElementIdx ]->mpteAll.pesPattern[patRef->prPatternIdx];
6026 +}
6027 +
6028 +/*
6029 +** Allocate a new copy of given string and substitute each capturing
6030 +** parentheses inside given string by a non-capturing one.
6031 +** Returns resulting string.
6032 +*/
6033 +static char *replaceCapturingParentheses(
6034 + const char *source)
6035 +{
6036 + char *destination;
6037 + const char *s;
6038 + char *d;
6039 + int nbrOfOpenBraces = 0;
6040 +
6041 + s = source;
6042 +
6043 + /*
6044 + * count number of open braces
6045 + */
6046 + while (*s != '\0')
6047 + {
6048 + if (*s++ == '(')
6049 + nbrOfOpenBraces ++;
6050 + }
6051 +
6052 + /*
6053 + * allocate memory for substitued reg. exp. text
6054 + */
6055 + destination = XtMalloc(strlen(source) + 2*nbrOfOpenBraces);
6056 +
6057 + /*
6058 + * substitute each capturing open brace by a non-capturing one
6059 + */
6060 + s = source;
6061 + d = destination;
6062 +
6063 + while (*s != '\0')
6064 + {
6065 + if (*s == '\\')
6066 + {
6067 + *d++ = *s++;
6068 +
6069 + if (*s != '\0')
6070 + *d++ = *s++;
6071 + }
6072 + else if (*s == '(')
6073 + {
6074 + *d++ = *s++;
6075 +
6076 + if (*s != '?' && *s != '*')
6077 + {
6078 + *d++ = '?';
6079 + *d++ = ':';
6080 + }
6081 + }
6082 + else
6083 + {
6084 + *d++ = *s++;
6085 + }
6086 + }
6087 +
6088 + *d = '\0';
6089 +
6090 + return destination;
6091 +}
6092 +
6093 +/*
6094 +** Parse given string pattern for global backrefs definitions
6095 +** (syntax: "(*n", where n=1..9). Add found global backrefs to
6096 +** given backRefList.
6097 +** Returns false, if parse fails.
6098 +*/
6099 +static int parseGlobalBackRefs(
6100 + StringPattern *strPat,
6101 + GlobalBackRefElement *backRefList,
6102 + ErrorInfo *errInfo)
6103 +{
6104 + char *s;
6105 + char *backRefContent;
6106 + int nestingLevel = 0;
6107 + int stackIdx = -1;
6108 + BackRefBracketInfo backRefInfo[MAX_GLOBAL_BACK_REF_ID+1];
6109 + StrPatBackRefElement *curStrPatBRE;
6110 +
6111 + strPat->spText = replaceCapturingParentheses(strPat->spOrigText);
6112 + strPat->spLength = strlen(strPat->spText);
6113 + strPat->spBackRefParsed = True;
6114 +
6115 + s = strPat->spText;
6116 +
6117 + while (*s != '\0')
6118 + {
6119 + if (*s == '\\')
6120 + {
6121 + /*
6122 + * Ignore escaped characters
6123 + */
6124 + if (*(s+1) != '\0')
6125 + s ++;
6126 + }
6127 + else if (*s == '(')
6128 + {
6129 + if (*(s+1) == '*')
6130 + {
6131 + if (isdigit((unsigned char)*(s+2)))
6132 + {
6133 + /*
6134 + * Global backref. definition start found:
6135 + */
6136 + stackIdx ++;
6137 +
6138 + backRefInfo[stackIdx].brbiGlobalId =
6139 + (int)((unsigned char)*(s+2) - (unsigned char)'0') - 1;
6140 +
6141 + if(backRefInfo[stackIdx].brbiGlobalId < 0)
6142 + {
6143 + errInfo->eiStringPatText = XtNewString(strPat->spOrigText);
6144 + errInfo->eiDetail = "Backref '0' not allowed";
6145 + return False;
6146 + }
6147 +
6148 + backRefInfo[stackIdx].brbiContentStart = s+3;
6149 + backRefInfo[stackIdx].brbiNestingLevel = nestingLevel;
6150 + s ++;
6151 + }
6152 + s ++;
6153 + }
6154 + nestingLevel ++;
6155 + }
6156 + else if (*s == ')')
6157 + {
6158 + nestingLevel --;
6159 + if (stackIdx != -1 &&
6160 + backRefInfo[stackIdx].brbiNestingLevel == nestingLevel)
6161 + {
6162 + /*
6163 + * Global backref. definition end found: add it to
6164 + * backref. list of string pattern.
6165 + */
6166 + curStrPatBRE =
6167 + &strPat->spOwnGlobalBackRef[backRefInfo[stackIdx].brbiGlobalId];
6168 +
6169 + backRefContent =
6170 + createBackRefRegExpText(
6171 + backRefInfo[stackIdx].brbiContentStart,
6172 + s);
6173 +
6174 + if (curStrPatBRE->spbreRegExpText != NULL)
6175 + {
6176 + errInfo->eiStringPatText = XtNewString(strPat->spOrigText);
6177 + errInfo->eiBackRefNbr = backRefInfo[stackIdx].brbiGlobalId + 1;
6178 + errInfo->eiDetail = "already defined before";
6179 + XtFree(backRefContent);
6180 + return False;
6181 + }
6182 + else
6183 + {
6184 + curStrPatBRE->spbreRegExpText = backRefContent;
6185 + }
6186 +
6187 + stackIdx --;
6188 + }
6189 + }
6190 + s ++;
6191 + }
6192 +
6193 + /*
6194 + * Merge global backref. list of string pattern with given backRefList.
6195 + */
6196 + return updateGlobalBackRefs(
6197 + strPat,
6198 + backRefList,
6199 + errInfo);
6200 +}
6201 +
6202 +/*
6203 +** Merge global backref. list of given string pattern with given backRefList.
6204 +** Returns false, if merge fails.
6205 +*/
6206 +static int updateGlobalBackRefs(
6207 + StringPattern *strPat,
6208 + GlobalBackRefElement *backRefList,
6209 + ErrorInfo *errInfo)
6210 +{
6211 + int i;
6212 + StrPatBackRefElement *curStrPatBRE;
6213 + GlobalBackRefElement *curGlobalBRE;
6214 +
6215 + for (i=0;i < MAX_GLOBAL_BACK_REF_ID; i ++)
6216 + {
6217 + curStrPatBRE = &strPat->spOwnGlobalBackRef[i];
6218 +
6219 + if (curStrPatBRE->spbreRegExpText != NULL)
6220 + {
6221 + curGlobalBRE = &backRefList[i];
6222 +
6223 + if (curGlobalBRE->gbreDefByStrPat != NULL)
6224 + {
6225 + if (strcmp(curGlobalBRE->gbreRegExpText, curStrPatBRE->spbreRegExpText) != 0)
6226 + {
6227 + errInfo->eiStringPatText = XtNewString(strPat->spOrigText);
6228 + errInfo->eiBackRefNbr = i+1;
6229 + errInfo->eiDetail = "already defined before";
6230 +
6231 + return False;
6232 + }
6233 + }
6234 + else
6235 + {
6236 + curGlobalBRE->gbreDefByStrPat = strPat;
6237 + curGlobalBRE->gbreRegExpText = curStrPatBRE->spbreRegExpText;
6238 + }
6239 + }
6240 + }
6241 +
6242 + return True;
6243 +}
6244 +
6245 +/*
6246 +** Allocate and return a new string holding content of
6247 +** global backref. definition.
6248 +*/
6249 +static char *createBackRefRegExpText(
6250 + const char *start,
6251 + const char *end)
6252 +{
6253 + int len = end - start;
6254 + char *regExpText = XtMalloc( len+1 );
6255 +
6256 + memcpy( regExpText, start, len );
6257 +
6258 + regExpText[len] = '\0';
6259 +
6260 + return regExpText;
6261 +}
6262 +
6263 +/*
6264 +** Resolve all global backrefs of given match pattern table element.
6265 +** Returns false, if resolve fails.
6266 +*/
6267 +static int resolveGlobalBackRefs(
6268 + ReadMatchPatternInfo *readPatInfo,
6269 + MatchPatternTableElement *element,
6270 + ErrorInfo *errInfo)
6271 +{
6272 + int i;
6273 + StringPattern *strPat;
6274 +
6275 + for (i=0; i<element->mpteAll.pesNumberOfPattern; i++)
6276 + {
6277 + strPat = getReadStringPattern(readPatInfo, element->mpteAll.pesPattern[i]);
6278 +
6279 + if (strPat->spRegularExpression && !strPat->spBackRefResolved)
6280 + {
6281 + if (!resolveGlobalBackRefsOfStrPat(strPat, element->mpteGlobalBackRef, errInfo))
6282 + return False;
6283 +
6284 + strPat->spBackRefResolved = True;
6285 + }
6286 + }
6287 +
6288 + return True;
6289 +}
6290 +
6291 +/*
6292 +** Resolve global backrefs of given string pattern.
6293 +** Returns false, if resolve fails.
6294 +*/
6295 +static int resolveGlobalBackRefsOfStrPat(
6296 + StringPattern *strPat,
6297 + GlobalBackRefElement *backRefList,
6298 + ErrorInfo *errInfo)
6299 +{
6300 + char *s;
6301 + int globalId;
6302 + int localId = 1;
6303 +
6304 + s = strPat->spText;
6305 +
6306 + while (*s != '\0')
6307 + {
6308 + if (*s == '\\')
6309 + {
6310 + if (isdigit((unsigned char)*(s+1)))
6311 + {
6312 + /*
6313 + * \n (n=1..9) found: substitute global backref.
6314 + */
6315 + globalId =
6316 + (int)((unsigned char)*(s+1) - (unsigned char)'0') - 1;
6317 +
6318 + if(globalId < 0)
6319 + {
6320 + errInfo->eiStringPatText = XtNewString(strPat->spOrigText);
6321 + errInfo->eiDetail = "backref '\\0' not allowed";
6322 + return False;
6323 + }
6324 +
6325 + s = substituteGlobalBackRef(strPat, s, globalId, &localId, backRefList, errInfo);
6326 +
6327 + if (s == NULL)
6328 + return False;
6329 + }
6330 + else if (*(s+1) != '\0')
6331 + s ++;
6332 + }
6333 + else if (*s == '(')
6334 + {
6335 + if (*(s+1) == '*')
6336 + {
6337 + if (isdigit((unsigned char)*(s+2)))
6338 + {
6339 + /*
6340 + * "(*n" (n=1..9) found: substitute global backref. definition.
6341 + */
6342 + globalId =
6343 + (int)((unsigned char)*(s+2) - (unsigned char)'0') - 1;
6344 +
6345 + strPat->spOwnGlobalBackRef[globalId].spbreLocalBackRefID = localId;
6346 + strPat->spGlobalToLocalBackRef[globalId] = localId;
6347 +
6348 + localId ++;
6349 +
6350 + s = convertGlobalToLocalBackRef(strPat, s);
6351 + }
6352 + else
6353 + {
6354 + s ++;
6355 + }
6356 + }
6357 + }
6358 + s ++;
6359 + }
6360 +
6361 + return True;
6362 +}
6363 +
6364 +/*
6365 +** Substitute global backref (\n, n=1..9) located at given "subsPtr"
6366 +** by its definition or by a local backref.
6367 +** Returns
6368 +** - NULL, if substitute fails or
6369 +** - substituted string pointer, where scan shall continue with.
6370 +*/
6371 +static char *substituteGlobalBackRef(
6372 + StringPattern *strPat,
6373 + char *subsPtr,
6374 + int globalId,
6375 + int *localId,
6376 + GlobalBackRefElement *backRefList,
6377 + ErrorInfo *errInfo)
6378 +{
6379 + StrPatBackRefElement *strPatBackRef = &strPat->spOwnGlobalBackRef[globalId];
6380 + char *s;
6381 +
6382 + if (strPatBackRef->spbreRegExpText == NULL)
6383 + {
6384 + /*
6385 + * given global backref definition is not located in given
6386 + * string pattern -> replace backref ID by backref reg. exp.
6387 + */
6388 + if (backRefList[globalId].gbreRegExpText == NULL)
6389 + {
6390 + errInfo->eiStringPatText = XtNewString(strPat->spOrigText);
6391 + errInfo->eiBackRefNbr = globalId + 1;
6392 + errInfo->eiDetail = "not defined within any string pattern";
6393 + return NULL;
6394 + }
6395 +
6396 + if (strPat->spGlobalToLocalBackRef[globalId] == NO_LOCAL_BACK_REF_ID)
6397 + {
6398 + /*
6399 + * 1st occurence of global backref ID in this pattern ->
6400 + * replace global backref ID by backref reg. exp.
6401 + */
6402 + s = replaceBackRefIdByRegExp(strPat, subsPtr, backRefList[globalId].gbreRegExpText);
6403 +
6404 + strPat->spGlobalToLocalBackRef[globalId] = *localId;
6405 + (*localId) ++;
6406 + }
6407 + else
6408 + {
6409 + /*
6410 + * next occurence of global backref ID in this pattern ->
6411 + * replace global backref ID by local one
6412 + */
6413 + s = subsPtr + 1;
6414 + *s = (char)((int)('0') + strPat->spGlobalToLocalBackRef[globalId]);
6415 + }
6416 + }
6417 + else
6418 + {
6419 + /*
6420 + * given global backref definition is located in given string pattern
6421 + */
6422 + if (strPatBackRef->spbreLocalBackRefID == NO_LOCAL_BACK_REF_ID)
6423 + {
6424 + errInfo->eiStringPatText = XtNewString(strPat->spOrigText);
6425 + errInfo->eiBackRefNbr = globalId + 1;
6426 + errInfo->eiDetail = "not defined before";
6427 + return NULL;
6428 + }
6429 +
6430 + /*
6431 + * replace global backref ID by local one
6432 + */
6433 + s = subsPtr + 1;
6434 + *s = (char)((int)('0') + strPatBackRef->spbreLocalBackRefID);
6435 + }
6436 +
6437 + return s;
6438 +}
6439 +
6440 +/*
6441 +** Replace global backref ID ("\n", n=1..9), located at given
6442 +** replaceStartPtr, by its definition (given by regExp parameter).
6443 +** Returns string pointer, where scan shall continue with
6444 +*/
6445 +static char *replaceBackRefIdByRegExp(
6446 + StringPattern *strPat,
6447 + char *replaceStartPtr,
6448 + char *regExp)
6449 +{
6450 + char *oldText = strPat->spText;
6451 + char *newText;
6452 + char *n;
6453 + char *continueScanPtr;
6454 + int oldLen = strlen(oldText);
6455 + int regExpLen = strlen(regExp);
6456 + int replacePos = replaceStartPtr - oldText;
6457 + int remainingLen = oldLen-replacePos-2;
6458 +
6459 + /*
6460 + * replace "\n" - located at replaceStartPtr - by "(regExp)"
6461 + */
6462 + newText = XtMalloc(oldLen + regExpLen + 3);
6463 +
6464 + memcpy(newText, oldText, replacePos);
6465 + n = newText + replacePos;
6466 + *n = '(';
6467 + continueScanPtr = n;
6468 + n ++;
6469 + memcpy(n, regExp, regExpLen);
6470 + n += regExpLen;
6471 + *n = ')';
6472 + n ++;
6473 + memcpy(n, replaceStartPtr+2, remainingLen);
6474 + *(n + remainingLen) = '\0';
6475 +
6476 + XtFree(oldText);
6477 +
6478 + strPat->spText = newText;
6479 + strPat->spLength = strlen(newText);
6480 +
6481 + return continueScanPtr;
6482 +}
6483 +
6484 +/*
6485 +** Convert global backref definition ("(*n", n=1..9), located at given
6486 +** convertPtr, by capturing parentheses "(".
6487 +** Returns string pointer, where scan shall continue with
6488 +*/
6489 +static char *convertGlobalToLocalBackRef(
6490 + StringPattern *strPat,
6491 + char *convertPtr)
6492 +{
6493 + char *oldText = strPat->spText;
6494 + char *newText;
6495 + int oldLen = strlen(oldText);
6496 + int convertPos = convertPtr - oldText;
6497 +
6498 + /*
6499 + * replace "(*n" - located at convertPtr - by "("
6500 + */
6501 + newText = XtMalloc(oldLen - 1);
6502 +
6503 + memcpy(newText, oldText, convertPos+1);
6504 + memcpy(newText+convertPos+1, convertPtr+3, oldLen-convertPos-3);
6505 +
6506 + *(newText + oldLen - 2) = '\0';
6507 +
6508 + XtFree(oldText);
6509 +
6510 + strPat->spText = newText;
6511 + strPat->spLength = strlen(newText);
6512 +
6513 + return newText + convertPos;
6514 +}
6515 +
6516 +/*
6517 +** Read a match pattern table element from given input string.
6518 +** Return NULL, if read fails.
6519 +*/
6520 +static MatchPatternTableElement *readMatchPatternTableElement(
6521 + char **inPtr,
6522 + char **errMsg,
6523 + char *name,
6524 + MatchPatternType type)
6525 +{
6526 + int error = False;
6527 + PatternElement *pattern;
6528 + PatternElement *allPat[MAX_STRING_PATTERNS];
6529 + int nbrOfPat = 0;
6530 + int sizeOfPat;
6531 + MatchPatternTableElement *result;
6532 + int isMonoPattern;
6533 + int skipBtwStartEnd;
6534 + int flash;
6535 + int ignoreHighLightInfo;
6536 + int i;
6537 +
6538 + if (!getMPSGlobalAttribute(
6539 + inPtr,
6540 + errMsg,
6541 + &isMonoPattern,
6542 + &skipBtwStartEnd,
6543 + &flash,
6544 + &ignoreHighLightInfo ))
6545 + {
6546 + return NULL;
6547 + }
6548 +
6549 + /*
6550 + * read all patterns
6551 + */
6552 + while (**inPtr != '\n' && !error)
6553 + {
6554 + if (!readPatternElement( inPtr, errMsg, &pattern ))
6555 + {
6556 + error = True;
6557 + }
6558 + else if (nbrOfPat >= MAX_STRING_PATTERNS)
6559 + {
6560 + *errMsg = "max. number of string patterns exceeded";
6561 + error = True;
6562 + }
6563 + else
6564 + {
6565 + pattern->peIndex = nbrOfPat;
6566 +
6567 + allPat[nbrOfPat ++] = pattern;
6568 + }
6569 + }
6570 +
6571 + if (error)
6572 + {
6573 + for (i=0; i < nbrOfPat; i ++)
6574 + freePatternElement( allPat[i] );
6575 +
6576 + return NULL;
6577 + }
6578 +
6579 + if (nbrOfPat == 0)
6580 + {
6581 + *errMsg = "min. one string pattern needed";
6582 + return NULL;
6583 + }
6584 +
6585 + /*
6586 + * allocate & init. MatchPatternTableElement
6587 + */
6588 + result =
6589 + (MatchPatternTableElement *)XtMalloc(sizeof(MatchPatternTableElement));
6590 +
6591 + result->mpteName = name;
6592 + result->mpteIndex = NO_ELEMENT_IDX;
6593 + result->mpteType = type;
6594 + result->mpteGroup = NO_GROUP_IDX;
6595 +
6596 + sizeOfPat = sizeof(PatternElement *) * nbrOfPat;
6597 + result->mpteAll.pesPattern = (PatternElement **)XtMalloc( sizeOfPat );
6598 +
6599 + memcpy(result->mpteAll.pesPattern, allPat, sizeOfPat);
6600 +
6601 + result->mpteAll.pesNumberOfPattern = nbrOfPat;
6602 +
6603 + result->mpteIsMonoPattern = isMonoPattern;
6604 + result->mpteSkipBtwnStartEnd = skipBtwStartEnd;
6605 + result->mpteFlash = flash;
6606 + result->mpteIgnoreHighLightInfo = ignoreHighLightInfo;
6607 +
6608 + result->mpteStartEndRE = NULL;
6609 +
6610 + initGlobalBackRefList( result->mpteGlobalBackRef );
6611 +
6612 + /*
6613 + * sort start / end / middle pattern
6614 + */
6615 + error = !sortReadPatternElementSet( &result->mpteAll, errMsg, result );
6616 +
6617 + if (error)
6618 + {
6619 + freeMatchPatternTableElement( result );
6620 + return NULL;
6621 + }
6622 + else
6623 + {
6624 + return result;
6625 + }
6626 +}
6627 +
6628 +/*
6629 + * Sort read pattern element set into start, middle & end arrays.
6630 + * Validate "monopattern" attribute.
6631 + * Returns true, if validation was successful.
6632 + */
6633 +static int sortReadPatternElementSet(
6634 + PatternElementSet *allPat,
6635 + char **errMsg,
6636 + MatchPatternTableElement *result)
6637 +{
6638 + int sizeOfPat;
6639 + int isMonoPattern = result->mpteIsMonoPattern;
6640 +
6641 + /*
6642 + * count number of start, middle & end pattern elements.
6643 + */
6644 + countPatternElementKind( allPat, result );
6645 +
6646 + /*
6647 + * validate and allocate pattern elements.
6648 + */
6649 + if (result->mpteStart.pesNumberOfPattern != 0)
6650 + {
6651 + sizeOfPat = sizeof(PatternElement *) * result->mpteStart.pesNumberOfPattern;
6652 + result->mpteStart.pesPattern = (PatternElement **)XtMalloc( sizeOfPat );
6653 + }
6654 + else
6655 + {
6656 + *errMsg = "min. one start pattern needed";
6657 + return False;
6658 + }
6659 +
6660 + if (isMonoPattern &&
6661 + (result->mpteMiddle.pesNumberOfPattern != 0 ||
6662 + result->mpteEnd.pesNumberOfPattern !=0))
6663 + {
6664 + *errMsg = "mono pattern: only start pattern(s) allowed due to attribute [m]";
6665 + return False;
6666 + }
6667 +
6668 + if (result->mpteMiddle.pesNumberOfPattern != 0)
6669 + {
6670 + sizeOfPat = sizeof(PatternElement *) * result->mpteMiddle.pesNumberOfPattern;
6671 + result->mpteMiddle.pesPattern = (PatternElement **)XtMalloc( sizeOfPat );
6672 + }
6673 +
6674 + if (result->mpteEnd.pesNumberOfPattern != 0)
6675 + {
6676 + sizeOfPat = sizeof(PatternElement *) * result->mpteEnd.pesNumberOfPattern;
6677 + result->mpteEnd.pesPattern = (PatternElement **)XtMalloc( sizeOfPat );
6678 + }
6679 + else
6680 + {
6681 + if (!isMonoPattern)
6682 + {
6683 + *errMsg = "min. one end pattern needed";
6684 + return False;
6685 + }
6686 + }
6687 +
6688 + /*
6689 + * sort pattern elements into start, middle & end arrays.
6690 + */
6691 + sortPatternElementSet( allPat, result );
6692 +
6693 + if (isMonoPattern)
6694 + {
6695 + copyPatternSet( &result->mpteStart, &result->mpteEnd );
6696 + }
6697 +
6698 + return True;
6699 +}
6700 +
6701 +/*
6702 + * Count number of start, middle & end patterns stored in "allPat".
6703 + */
6704 +static void countPatternElementKind(
6705 + PatternElementSet *allPat,
6706 + MatchPatternTableElement *result)
6707 +{
6708 + int i;
6709 +
6710 + result->mpteStart.pesNumberOfPattern = 0;
6711 + result->mpteEnd.pesNumberOfPattern = 0;
6712 + result->mpteMiddle.pesNumberOfPattern = 0;
6713 +
6714 + result->mpteStart.pesPattern = NULL;
6715 + result->mpteEnd.pesPattern = NULL;
6716 + result->mpteMiddle.pesPattern = NULL;
6717 +
6718 + for (i=0; i < allPat->pesNumberOfPattern; i ++)
6719 + {
6720 + switch (allPat->pesPattern[i]->peKind)
6721 + {
6722 + case PEK_START:
6723 + result->mpteStart.pesNumberOfPattern ++;
6724 + break;
6725 + case PEK_MIDDLE:
6726 + result->mpteMiddle.pesNumberOfPattern ++;
6727 + break;
6728 + case PEK_END:
6729 + result->mpteEnd.pesNumberOfPattern ++;
6730 + break;
6731 + default:;
6732 + }
6733 + }
6734 +}
6735 +
6736 +/*
6737 + * Sort start, middle & end pattern elements into related arrays.
6738 + */
6739 +static void sortPatternElementSet(
6740 + PatternElementSet *allPat,
6741 + MatchPatternTableElement *result)
6742 +{
6743 + int i;
6744 + int s,m,e;
6745 +
6746 + for (i=0, s=0, m=0, e=0; i < allPat->pesNumberOfPattern; i ++)
6747 + {
6748 + switch (allPat->pesPattern[i]->peKind)
6749 + {
6750 + case PEK_START:
6751 + result->mpteStart.pesPattern[s ++] = allPat->pesPattern[i];
6752 + break;
6753 + case PEK_MIDDLE:
6754 + result->mpteMiddle.pesPattern[m ++] = allPat->pesPattern[i];
6755 + break;
6756 + case PEK_END:
6757 + result->mpteEnd.pesPattern[e ++] = allPat->pesPattern[i];
6758 + break;
6759 + default:;
6760 + }
6761 + }
6762 +}
6763 +
6764 +static void copyPatternSet(
6765 + PatternElementSet *sourcePS,
6766 + PatternElementSet *destPS)
6767 +{
6768 + int sizeOfPat;
6769 +
6770 + destPS->pesNumberOfPattern = sourcePS->pesNumberOfPattern;
6771 +
6772 + sizeOfPat = sizeof(PatternElement *) * destPS->pesNumberOfPattern;
6773 + destPS->pesPattern = (PatternElement **)XtMalloc( sizeOfPat );
6774 +
6775 + memcpy(destPS->pesPattern, sourcePS->pesPattern, sizeOfPat);
6776 +}
6777 +
6778 +/*
6779 +** Free the allocated memory contained in a ReadMatchPatternInfo data structure
6780 +*/
6781 +static void freeReadMatchPatternInfo( ReadMatchPatternInfo *readPatInfo )
6782 +{
6783 + int i;
6784 +
6785 + for (i=0; i<readPatInfo->rmpiNbrOfElements; i++)
6786 + freeMatchPatternTableElement(readPatInfo->rmpiElement[i]);
6787 +
6788 + for (i=0; i<readPatInfo->rmpiNbrOfGroups; i++)
6789 + freeMatchPatternGroupElement(readPatInfo->rmpiGroup[i]);
6790 +
6791 + for (i=0; i<readPatInfo->rmpiNbrOfSeqElements; i++)
6792 + freeMatchPatternSequenceElement(readPatInfo->rmpiSequence[i]);
6793 +
6794 + freePtr((void **)&readPatInfo->rmpiAllPatRE);
6795 +
6796 + freePtr((void **)&readPatInfo->rmpiFlashPatRE);
6797 +}
6798 +
6799 +/*
6800 +** Free the allocated memory contained in a StringMatchTable data structure
6801 +*/
6802 +static void freeStringMatchTable( StringMatchTable *table )
6803 +{
6804 + MatchPatternTable *patTable;
6805 + int i;
6806 +
6807 + if (table == NULL)
6808 + return;
6809 +
6810 + XtFree(table->smtLanguageMode);
6811 +
6812 + /*
6813 + * Free all matching patterns
6814 + */
6815 + patTable = table->smtAllPatterns;
6816 +
6817 + for (i=0; i<patTable->mptNumberOfElements; i++)
6818 + freeMatchPatternTableElement(patTable->mptElements[i]);
6819 +
6820 + XtFree((char *)patTable);
6821 +
6822 + /*
6823 + * Free matching pattern group elements
6824 + */
6825 + for (i=0; i<table->smtNumberOfGroups; i++)
6826 + freeMatchPatternGroupElement(table->smtGroups[i]);
6827 +
6828 + /*
6829 + * Free matching pattern sequence elements
6830 + */
6831 + for (i=0; i<table->smtNumberOfSeqElements; i++)
6832 + freeMatchPatternSequenceElement(table->smtSequence[i]);
6833 +
6834 + /*
6835 + * Free keyword reg. expressions
6836 + */
6837 + freePtr((void **)&table->smtAllPatRE);
6838 +
6839 + freePtr((void **)&table->smtFlashPatRE);
6840 +
6841 + XtFree((char *)table);
6842 +}
6843 +
6844 +/*
6845 +** Free the allocated memory contained in a MatchPatternTableElement data structure
6846 +*/
6847 +static void freeMatchPatternTableElement( MatchPatternTableElement *element )
6848 +{
6849 + int i;
6850 +
6851 + XtFree(element->mpteName);
6852 +
6853 + for (i=0; i<element->mpteAll.pesNumberOfPattern; i++)
6854 + {
6855 + freePatternElement(element->mpteAll.pesPattern[i]);
6856 + }
6857 +
6858 + freePtr((void **)&element->mpteStartEndRE);
6859 +
6860 + freeXtPtr((void **)&element->mpteStart.pesPattern);
6861 +
6862 + freeXtPtr((void **)&element->mpteMiddle.pesPattern);
6863 +
6864 + freeXtPtr((void **)&element->mpteEnd.pesPattern);
6865 +
6866 + XtFree((char *)element);
6867 +}
6868 +
6869 +/*
6870 +** Free the allocated memory contained in a PatternElement data structure
6871 +*/
6872 +static void freePatternElement( PatternElement *element )
6873 +{
6874 + if (element->peType == PET_SINGLE)
6875 + freeStringPattern( &(element->peVal.peuSingle) );
6876 + else if (element->peType == PET_MULTIPLE)
6877 + {
6878 + freeStringPattern( &(element->peVal.peuMulti.mpStringPattern) );
6879 + XtFree( (char *)element->peVal.peuMulti.mpRefList );
6880 + }
6881 +
6882 + XtFree( (char *)element );
6883 +}
6884 +
6885 +/*
6886 +** Free the allocated memory contained in a StringPattern data structure
6887 +*/
6888 +static void freeStringPattern( StringPattern *strPat )
6889 +{
6890 + int i;
6891 +
6892 + freeXtPtr((void **)&strPat->spText);
6893 + freeXtPtr((void **)&strPat->spOrigText);
6894 +
6895 + freePtr((void **)&strPat->spTextRE);
6896 +
6897 + for (i=0; i < MAX_GLOBAL_BACK_REF_ID; i++)
6898 + freeXtPtr((void **)&strPat->spOwnGlobalBackRef[i].spbreRegExpText);
6899 +}
6900 +
6901 +/*
6902 +** Free the allocated memory contained in a MatchPatternGroupElement data structure
6903 +*/
6904 +static void freeMatchPatternGroupElement( MatchPatternGroupElement *group )
6905 +{
6906 + int i;
6907 +
6908 + freeXtPtr((void **)&group->mpgeName);
6909 +
6910 + freePtr((void **)&group->mpgeKeywordRE);
6911 +
6912 + if (group->mpgeSubPatternIds != NULL)
6913 + {
6914 + for (i=0; i < group->mpgeNumberOfSubPatterns; i++)
6915 + {
6916 + XtFree(group->mpgeSubPatternIds[i]);
6917 + }
6918 + XtFree((char *)group->mpgeSubPatternIds);
6919 + }
6920 +
6921 + XtFree((char *)group);
6922 +}
6923 +
6924 +/*
6925 +** Free the allocated memory contained in a MatchPatternSequenceElement data structure
6926 +*/
6927 +static void freeMatchPatternSequenceElement( MatchPatternSequenceElement *sequence )
6928 +{
6929 + XtFree( sequence->mpseName );
6930 +
6931 + XtFree( (char *)sequence );
6932 +}
6933 +
6934 +
6935 +/*
6936 +** Format a matching pattern set parse error.
6937 +*/
6938 +static void parseMatchingPatternSetError(
6939 + const char *stringStart,
6940 + const char *stoppedAt,
6941 + ErrorInfo *errInfo)
6942 +{
6943 + char *message = "";
6944 + int msgLen;
6945 + char *errorInForm = "matching pattern of \"%s\"";
6946 + char *errorIn;
6947 +
6948 + if (errInfo->eiLanguageMode == NULL)
6949 + {
6950 + errorIn = "matching pattern";
6951 + }
6952 + else
6953 + {
6954 + errorIn = XtMalloc(strlen(errorInForm) + strlen(errInfo->eiLanguageMode)+1);
6955 + sprintf(errorIn, "matching pattern of \"%s\"", errInfo->eiLanguageMode);
6956 + }
6957 +
6958 + if (errInfo->eiRegExpCompileMsg != NULL)
6959 + {
6960 + /*
6961 + * Error message of form:
6962 + * "MP \"eiMPTabElementName\", SP \"eiStringPatText\": eiRegExpCompileMsg" or
6963 + * "MP \"eiMPTabElementName\" - eiDetail: eiRegExpCompileMsg"
6964 + */
6965 +
6966 + msgLen = strlen(errInfo->eiRegExpCompileMsg) + 1;
6967 +
6968 + if (errInfo->eiMPTabElementName != NULL)
6969 + msgLen += strlen(errInfo->eiMPTabElementName) + 10;
6970 +
6971 + if (errInfo->eiDetail != NULL)
6972 + {
6973 + msgLen += strlen(errInfo->eiDetail + 2);
6974 + }
6975 + else
6976 + {
6977 + if (errInfo->eiStringPatText != NULL)
6978 + msgLen += strlen(errInfo->eiStringPatText) + 9;
6979 + }
6980 +
6981 + message = XtMalloc(msgLen);
6982 +
6983 + strcpy(message, "");
6984 +
6985 + if (errInfo->eiMPTabElementName != NULL)
6986 + sprintf( message, "MP \"%s\"", errInfo->eiMPTabElementName);
6987 +
6988 + if (errInfo->eiDetail == NULL)
6989 + {
6990 + if (errInfo->eiStringPatText != NULL)
6991 + sprintf( message, "%s, SP \"%s\"", message, errInfo->eiStringPatText);
6992 + }
6993 + else
6994 + {
6995 + if (strlen(message) != 0)
6996 + strcat(message, " - ");
6997 +
6998 + strcat(message, errInfo->eiDetail);
6999 + }
7000 +
7001 + if (strlen(message) != 0)
7002 + strcat(message, ": ");
7003 +
7004 + strcat(message, errInfo->eiRegExpCompileMsg);
7005 + }
7006 + else if (errInfo->eiDetail != NULL)
7007 + {
7008 + /*
7009 + * Error message of form:
7010 + * "MP \"eiMPTabElementName\", SP \"eiStringPatText\": Backref %d eiDetail
7011 + */
7012 + msgLen = strlen(errInfo->eiDetail) + 1;
7013 +
7014 + if (errInfo->eiMPTabElementName != NULL)
7015 + msgLen += strlen(errInfo->eiMPTabElementName) + 7;
7016 + if (errInfo->eiStringPatText != NULL)
7017 + msgLen += strlen(errInfo->eiStringPatText) + 9;
7018 + if (errInfo->eiBackRefNbr != 0)
7019 + msgLen += 15;
7020 +
7021 + message = XtMalloc(msgLen);
7022 +
7023 + strcpy(message, "");
7024 +
7025 + if (errInfo->eiMPTabElementName != NULL)
7026 + sprintf( message, "MP \"%s\"", errInfo->eiMPTabElementName);
7027 + if (errInfo->eiStringPatText != NULL)
7028 + sprintf( message, "%s, SP \"%s\"", message, errInfo->eiStringPatText);
7029 +
7030 + if (strlen(message) != 0)
7031 + strcat(message, ": ");
7032 +
7033 + if (errInfo->eiBackRefNbr != 0)
7034 + sprintf( message, "%s Backref %d ", message, errInfo->eiBackRefNbr);
7035 +
7036 + strcat(message, errInfo->eiDetail);
7037 + }
7038 +
7039 + ParseError(NULL, stringStart, stoppedAt, errorIn, message);
7040 +
7041 + if (errInfo->eiRegExpCompileMsg != NULL || errInfo->eiDetail != NULL)
7042 + {
7043 + XtFree(message);
7044 + }
7045 +
7046 + if (errInfo->eiLanguageMode != NULL)
7047 + {
7048 + XtFree(errorIn);
7049 + }
7050 +
7051 + freeErrorInfo(errInfo);
7052 + initErrorInfo(errInfo);
7053 +}
7054 +
7055 +/*
7056 + * Pop-up a warning dialog showing a matching pattern set error.
7057 + */
7058 +static void dialogMatchingPatternSetError(
7059 + char *title,
7060 + ErrorInfo *errInfo)
7061 +{
7062 + char *message;
7063 + int msgLen = 1;
7064 +
7065 + /*
7066 + * Error message of form:
7067 + * "Name : \"eiMPTabElementName\"\n
7068 + * "String: \"eiStringPatText\"\n
7069 + * eiDetail\n
7070 + * eiRegExpCompileMsg\n"
7071 + */
7072 +
7073 + if (errInfo->eiMPTabElementName != NULL)
7074 + msgLen += strlen(errInfo->eiMPTabElementName) + 15;
7075 + if (errInfo->eiStringPatText != NULL)
7076 + msgLen += strlen(errInfo->eiStringPatText) + 15;
7077 + if (errInfo->eiDetail != NULL)
7078 + msgLen += strlen(errInfo->eiDetail) + 15;
7079 + if (errInfo->eiBackRefNbr != 0)
7080 + msgLen += 15;
7081 + if (errInfo->eiRegExpCompileMsg != NULL)
7082 + msgLen += strlen(errInfo->eiRegExpCompileMsg) + 15;
7083 +
7084 + message = XtMalloc(msgLen);
7085 +
7086 + strcpy(message, "");
7087 +
7088 + if (errInfo->eiMPTabElementName != NULL)
7089 + sprintf( message, "%sName : \"%s\"\n", message, errInfo->eiMPTabElementName);
7090 + if (errInfo->eiStringPatText != NULL)
7091 + sprintf( message, "%sPattern: \"%s\"\n", message, errInfo->eiStringPatText);
7092 + if (errInfo->eiBackRefNbr != 0)
7093 + sprintf( message, "%sBackref %d ", message, errInfo->eiBackRefNbr);
7094 + if (errInfo->eiDetail != NULL)
7095 + sprintf( message, "%s%s\n", message, errInfo->eiDetail);
7096 + if (errInfo->eiRegExpCompileMsg != NULL)
7097 + sprintf( message, "%s%s\n", message, errInfo->eiRegExpCompileMsg);
7098 +
7099 + DialogF(
7100 + DF_WARN, MatchPatternDialog.mpdShell, 1,
7101 + title,
7102 + "%s(language mode '%s')",
7103 + "OK",
7104 + message,
7105 + errInfo->eiLanguageMode);
7106 +
7107 + XtFree(message);
7108 +
7109 + freeErrorInfo(errInfo);
7110 + initErrorInfo(errInfo);
7111 +}
7112 +
7113 +/*
7114 +** Get matching pattern set name.
7115 +** Syntax:
7116 +** patternName ::= "name:"
7117 +** Returns true, if get was successful.
7118 +*/
7119 +static int getMPSName(
7120 + char **inPtr,
7121 + ErrorInfo *errInfo,
7122 + char **name )
7123 +{
7124 + char *dummy;
7125 + char *field = ReadSymbolicField(inPtr);
7126 +
7127 + if (field == NULL)
7128 + {
7129 + errInfo->eiDetail = "matching pattern name missing";
7130 + return False;
7131 + }
7132 +
7133 + if (!SkipDelimiter(inPtr, &dummy))
7134 + {
7135 + errInfo->eiMPTabElementName = XtNewString(field);
7136 + errInfo->eiDetail = "':' missing after matching pattern name";
7137 + XtFree( field );
7138 + return False;
7139 + }
7140 +
7141 + *name = field;
7142 +
7143 + return True;
7144 +}
7145 +
7146 +/*
7147 +** Get matching pattern set type attribute.
7148 +** TypeAttribute ::=
7149 +** [s|g]:
7150 +**
7151 +** s : sub-pattern (pattern is only matched, if part of a pattern group).
7152 +** g : pattern (context) group (i.e. a sequence of sub-patterns).
7153 +** default: individual pattern (pattern is not part of a group and is
7154 +** matched individually.
7155 +** Returns true, if get was successful.
7156 +*/
7157 +static int getMPSTypeAttribute(
7158 + char **inPtr,
7159 + ErrorInfo *errInfo,
7160 + MatchPatternType *type)
7161 +{
7162 + char *field = ReadSymbolicField(inPtr);
7163 + int successful = True;
7164 +
7165 + *type = MPT_INDIVIDUAL;
7166 +
7167 + if (field != NULL)
7168 + {
7169 + switch (*field)
7170 + {
7171 + case 'g':
7172 + *type = MPT_GROUP;
7173 + break;
7174 + case 's':
7175 + *type = MPT_SUB;
7176 + break;
7177 + default:
7178 + errInfo->eiDetail = "unknown matching pattern type attribute";
7179 + successful = False;
7180 + }
7181 + }
7182 +
7183 + if (successful)
7184 + {
7185 + if (!SkipDelimiter(inPtr, &errInfo->eiDetail))
7186 + {
7187 + successful = False;
7188 + }
7189 + }
7190 +
7191 + freeXtPtr((void **)&field);
7192 +
7193 + return successful;
7194 +}
7195 +
7196 +/*
7197 +** Syntax:
7198 +**
7199 +** GlobalAttribute ::=
7200 +** [c][f][m][p][u]:
7201 +**
7202 +** c : the content between start and end pattern is skipped
7203 +** during parsing (e.g. pattern encloses a comment).
7204 +** f : flash matching pattern (if not set, then only jump
7205 +** to matching pattern is supported).
7206 +** m : mono pattern - set exist out of only one single pattern
7207 +** (start pattern = end pattern; e.g. quotes like ")
7208 +** p : ignore highlight info code of single patterns of this set
7209 +** ("plain").
7210 +**
7211 +** Returns TRUE, if global attribute was successful read.
7212 +*/
7213 +static int getMPSGlobalAttribute(
7214 + char **inPtr,
7215 + char **errMsg,
7216 + int *isMonoPattern,
7217 + int *comment,
7218 + int *flash,
7219 + int *ignoreHighLightInfo)
7220 +{
7221 + char *field = ReadSymbolicField(inPtr);
7222 + char *attribute;
7223 + int successful = True;
7224 +
7225 + *isMonoPattern = False;
7226 + *comment = False;
7227 + *flash = False;
7228 + *ignoreHighLightInfo = False;
7229 +
7230 + if (field != NULL)
7231 + {
7232 + attribute = field;
7233 + while (*attribute != '\0' && successful)
7234 + {
7235 + switch (*attribute)
7236 + {
7237 + case 'c':
7238 + *comment = True;
7239 + break;
7240 + case 'f':
7241 + *flash = True;
7242 + break;
7243 + case 'm':
7244 + *isMonoPattern = True;
7245 + break;
7246 + case 'p':
7247 + *ignoreHighLightInfo = True;
7248 + break;
7249 + default:
7250 + *errMsg = "unknown global attribute";
7251 + successful = False;
7252 + }
7253 + attribute ++;
7254 + }
7255 + }
7256 +
7257 + if (successful)
7258 + {
7259 + if (!SkipDelimiter(inPtr, errMsg))
7260 + {
7261 + successful = False;
7262 + }
7263 + }
7264 +
7265 + freeXtPtr((void **)&field);
7266 +
7267 + return successful;
7268 +}
7269 +
7270 +/*
7271 +** Get matching pattern set attribute.
7272 +**
7273 +** Syntax:
7274 +**
7275 +** patternAttribute ::=
7276 +** [s|m|e][w|l|r][i]:
7277 +**
7278 +** StringPatternKind:
7279 +** s : start string pattern.
7280 +** m : middle string pattern.
7281 +** e : end string pattern.
7282 +** WordBoundaryAttribute:
7283 +** w : pattern is word (i.e. before and after pattern
7284 +** there must be a delimiter).
7285 +** l : before pattern must be a delimiter (left side).
7286 +** r : after pattern must be a delimiter (right side).
7287 +** default: neither before nor after pattern must be a delimiter.
7288 +** StringAttribute:
7289 +** i : pattern is case insensitive (if not set: pattern is
7290 +** case sensitive).
7291 +** x : pattern is regular expression (if not set: pattern is
7292 +** literal string).
7293 +**
7294 +** Returns TRUE, if pattern attribute was successful read.
7295 +*/
7296 +static int getMPSPatternAttribute(
7297 + char **inPtr,
7298 + char **errMsg,
7299 + PatternElementKind *patternKind,
7300 + PatternWordBoundary *wordBoundary,
7301 + int *caseInsensitive,
7302 + int *regularExpression)
7303 +{
7304 + char *field = ReadSymbolicField(inPtr);
7305 + char *attribute;
7306 + int successful = True;
7307 +
7308 + *patternKind = PEK_UNKNOWN;
7309 + *wordBoundary = PWB_NONE;
7310 + *caseInsensitive = False;
7311 + *regularExpression = False;
7312 +
7313 + if (field != NULL)
7314 + {
7315 + attribute = field;
7316 + while (*attribute != '\0' && successful)
7317 + {
7318 + switch (*attribute)
7319 + {
7320 + case 'e':
7321 + *patternKind = PEK_END;
7322 + break;
7323 + case 'i':
7324 + *caseInsensitive = True;
7325 + break;
7326 + case 'l':
7327 + *wordBoundary = PWB_LEFT;
7328 + break;
7329 + case 'm':
7330 + *patternKind = PEK_MIDDLE;
7331 + break;
7332 + case 'r':
7333 + *wordBoundary = PWB_RIGHT;
7334 + break;
7335 + case 's':
7336 + *patternKind = PEK_START;
7337 + break;
7338 + case 'w':
7339 + *wordBoundary = PWB_BOTH;
7340 + break;
7341 + case 'x':
7342 + *regularExpression = True;
7343 + break;
7344 + default:
7345 + *errMsg = "unknown string pattern attribute";
7346 + successful = False;
7347 + }
7348 + attribute ++;
7349 + }
7350 + }
7351 +
7352 + if (successful)
7353 + {
7354 + if (!SkipDelimiter(inPtr, errMsg))
7355 + {
7356 + successful = False;
7357 + }
7358 + }
7359 +
7360 + freeXtPtr((void **)&field);
7361 +
7362 + return successful;
7363 +}
7364 +
7365 +/*
7366 +** Returns the (to be reserved) reg. ex. length of an pattern element.
7367 +** Update total number of multi patterns, too.
7368 +*/
7369 +static int patternElementLen(
7370 + ReadMatchPatternInfo *info,
7371 + PatternElement *patElement,
7372 + int *nbrOfMultiPatterns)
7373 +{
7374 + PatternElement *referredElement;
7375 + StringPattern *strPat = NULL;
7376 + int patElementLen;
7377 +
7378 + switch (patElement->peType)
7379 + {
7380 + case PET_SINGLE:
7381 + strPat = &patElement->peVal.peuSingle;
7382 + break;
7383 +
7384 + case PET_MULTIPLE:
7385 + strPat = &patElement->peVal.peuMulti.mpStringPattern;
7386 +
7387 + (*nbrOfMultiPatterns) ++;
7388 +
7389 + break;
7390 +
7391 + case PET_REFERENCE:
7392 + referredElement =
7393 + info->rmpiElement[patElement->peVal.peuRef.prElementIdx]->
7394 + mpteAll.pesPattern[patElement->peVal.peuRef.prPatternIdx];
7395 +
7396 + strPat = &referredElement->peVal.peuMulti.mpStringPattern;
7397 + break;
7398 + }
7399 +
7400 + /*
7401 + * reserve additional 4 characters ("(?i)") for case insensitive search
7402 + */
7403 + if (strPat->spCaseInsensitive)
7404 + patElementLen = strPat->spLength + 4;
7405 + else
7406 + patElementLen = strPat->spLength;
7407 +
7408 + /*
7409 + * reserve additional 4 characters ("(?:)") for regular expression
7410 + */
7411 + if (strPat->spRegularExpression)
7412 + patElementLen += 4;
7413 +
7414 + return patElementLen;
7415 +}
7416 +
7417 +/*
7418 +** Returns the (to be reserved) total reg. ex. length of given
7419 +** MatchPatternTableElement. Update total number of multi patterns, too.
7420 +*/
7421 +static int totalMatchPatternTableElementLen(
7422 + ReadMatchPatternInfo *info,
7423 + MatchPatternTableElement *element,
7424 + int *nbrOfMultiPatterns)
7425 +{
7426 + int i;
7427 + int totalLen = 0;
7428 +
7429 + for (i=0; i<element->mpteAll.pesNumberOfPattern; i ++)
7430 + {
7431 + totalLen +=
7432 + patternElementLen(
7433 + info,
7434 + element->mpteAll.pesPattern[i],
7435 + nbrOfMultiPatterns );
7436 + }
7437 +
7438 + return totalLen;
7439 +}
7440 +
7441 +/*
7442 +** Returns the (to be reserved) total reg. ex. length of given
7443 +** read match pattern info. Counts total number of multi patterns, too.
7444 +*/
7445 +static int totalKeywordOfTableLen(
7446 + ReadMatchPatternInfo *info,
7447 + int *nbrOfMultiPatterns)
7448 +{
7449 + int i;
7450 + int totalLen = 0;
7451 +
7452 + *nbrOfMultiPatterns = 0;
7453 +
7454 + for (i=0; i<info->rmpiNbrOfElements; i ++)
7455 + {
7456 + totalLen +=
7457 + totalMatchPatternTableElementLen(
7458 + info,
7459 + info->rmpiElement[i],
7460 + nbrOfMultiPatterns);
7461 + }
7462 +
7463 + return totalLen;
7464 +}
7465 +
7466 +/*
7467 +** Add given StringPattern to given reg. ex. strings
7468 +*/
7469 +static void addPatternToRegExpString(
7470 + StringPattern *pattern,
7471 + RegExpStringInfo *regExpStringInfo)
7472 +{
7473 + char *r = NULL, *s;
7474 + char *adaptedRegExpText = NULL;
7475 + int prevLen = 0;
7476 +
7477 + /*
7478 + * Select the buffer, where the pattern needs to be added
7479 + * to (depending on its word boundary). Prepare the buffer
7480 + * by evtl. adding a prefix, if related buffer is empty.
7481 + */
7482 + switch (pattern->spWordBoundary)
7483 + {
7484 + case PWB_NONE:
7485 + prevLen = strlen( regExpStringInfo->resiNoneWBRegExpString );
7486 +
7487 + r = regExpStringInfo->resiNoneWBRegExpString + strlen( regExpStringInfo->resiNoneWBRegExpString );
7488 + break;
7489 + case PWB_LEFT:
7490 + prevLen = strlen( regExpStringInfo->resiLeftWBRegExpString );
7491 + if (prevLen == 0)
7492 + {
7493 + strcpy( regExpStringInfo->resiLeftWBRegExpString, "<(?:" );
7494 + }
7495 + r = regExpStringInfo->resiLeftWBRegExpString + strlen( regExpStringInfo->resiLeftWBRegExpString );
7496 + break;
7497 + case PWB_RIGHT:
7498 + prevLen = strlen( regExpStringInfo->resiRightWBRegExpString );
7499 + if (prevLen == 0)
7500 + {
7501 + strcpy( regExpStringInfo->resiRightWBRegExpString, "(?:" );
7502 + }
7503 + r = regExpStringInfo->resiRightWBRegExpString + strlen( regExpStringInfo->resiRightWBRegExpString );
7504 + break;
7505 + case PWB_BOTH:
7506 + prevLen = strlen( regExpStringInfo->resiBothWBRegExpString );
7507 + if (prevLen == 0)
7508 + {
7509 + strcpy( regExpStringInfo->resiBothWBRegExpString, "<(?:" );
7510 + }
7511 + r = regExpStringInfo->resiBothWBRegExpString + strlen( regExpStringInfo->resiBothWBRegExpString );
7512 + break;
7513 + }
7514 +
7515 + /*
7516 + * add an "or" if there is already a pattern in the buffer
7517 + */
7518 + if (prevLen != 0)
7519 + {
7520 + *r++ = '|';
7521 + }
7522 +
7523 + /*
7524 + * add "(?i" to order case insensitive search
7525 + */
7526 + if (pattern->spCaseInsensitive)
7527 + {
7528 + *r++ = '(';
7529 + *r++ = '?';
7530 + *r++ = 'i';
7531 + }
7532 +
7533 + /*
7534 + * add "(?:" to group this regular expression
7535 + */
7536 + if (pattern->spRegularExpression)
7537 + {
7538 + *r++ = '(';
7539 + *r++ = '?';
7540 + *r++ = ':';
7541 +
7542 + adaptedRegExpText =
7543 + adaptLocalBackRefs(
7544 + pattern->spText,
7545 + ®ExpStringInfo->resiLocalBackRefID);
7546 +
7547 + s = adaptedRegExpText;
7548 + }
7549 + else
7550 + {
7551 + s = pattern->spText;
7552 + }
7553 +
7554 + /*
7555 + * add the pattern characters - evtl. escaped, if special
7556 + * regular expression symbols & pattern is no reg. exp. -
7557 + * to the buffer:
7558 + */
7559 +
7560 + while (*s != '\0')
7561 + {
7562 + if (!pattern->spRegularExpression)
7563 + {
7564 + switch (*s)
7565 + {
7566 + case '(':
7567 + case ')':
7568 + case '-':
7569 + case '[':
7570 + case ']':
7571 + case '<':
7572 + case '>':
7573 + case '{':
7574 + case '}':
7575 + case '.':
7576 + case '\\':
7577 + case '|':
7578 + case '^':
7579 + case '$':
7580 + case '*':
7581 + case '+':
7582 + case '?':
7583 + case '&':
7584 + *r++ = '\\';
7585 + break;
7586 + };
7587 + }
7588 +
7589 + *r++ = *s++;
7590 + }
7591 +
7592 + /*
7593 + * close "reg. exp. group" bracket
7594 + */
7595 + if (pattern->spRegularExpression)
7596 + {
7597 + *r++ = ')';
7598 +
7599 + XtFree(adaptedRegExpText);
7600 + }
7601 +
7602 + /*
7603 + * close case insensitive search bracket
7604 + */
7605 + if (pattern->spCaseInsensitive)
7606 + {
7607 + *r++ = ')';
7608 + }
7609 +
7610 + /*
7611 + * terminate added string
7612 + */
7613 + *r = '\0';
7614 +}
7615 +
7616 +/*
7617 +** Adapt local backrefs inside given regExpText by common local IDs.
7618 +** Returns new allocated reg. exp. string holding common local backrefs.
7619 +*/
7620 +static char *adaptLocalBackRefs(
7621 + char *regExpText,
7622 + int *commonLocalId)
7623 +{
7624 + int id;
7625 + int ownLocalId = 0;
7626 + char *s = regExpText;
7627 + char *newRegExpText = XtMalloc(strlen(regExpText)*3);
7628 + char *n = newRegExpText;
7629 + int localBackRefList[MAX_LOCAL_BACK_REF_ID];
7630 +
7631 + /*
7632 + * put all local backrefs into "localBackRefList".
7633 + */
7634 + scanForLocalBackRefs(regExpText, localBackRefList);
7635 +
7636 + while (*s != '\0')
7637 + {
7638 + *n++ = *s;
7639 +
7640 + if (*s == '\\')
7641 + {
7642 + s++;
7643 +
7644 + if (isdigit((unsigned char)*s))
7645 + {
7646 + /*
7647 + * \n (n=1..9) found: replace local backref.
7648 + * by "common local ID"
7649 + */
7650 + id =
7651 + (int)((unsigned char)*s - (unsigned char)'0') - 1;
7652 +
7653 + if (localBackRefList[id] != NO_LOCAL_BACK_REF_ID &&
7654 + localBackRefList[id] != LOCAL_BACK_REF_ID_USED)
7655 + {
7656 + *n++ = (char)((int)('0') + localBackRefList[id]);
7657 + }
7658 + else
7659 + {
7660 + *n++ = '0';
7661 + }
7662 +
7663 + s ++;
7664 + }
7665 + else if (*s != '\0')
7666 + {
7667 + /*
7668 + * copy escaped character
7669 + */
7670 + *n++ = *s++;
7671 + }
7672 + }
7673 + else if (*s == '(')
7674 + {
7675 + s ++;
7676 +
7677 + if (*s == '?')
7678 + {
7679 + /*
7680 + * non capturing parentheses found -> just copy it
7681 + */
7682 + *n++ = *s++;
7683 + }
7684 + else
7685 + {
7686 + /*
7687 + * capturing parentheses found:
7688 + */
7689 + if (localBackRefList[ownLocalId] == LOCAL_BACK_REF_ID_USED)
7690 + {
7691 + /*
7692 + * backref used within given reg. exp. text:
7693 + * remember common local id for replacement later on
7694 + */
7695 + localBackRefList[ownLocalId] = *commonLocalId;
7696 + (*commonLocalId) ++;
7697 + ownLocalId ++;
7698 + }
7699 + else
7700 + {
7701 + /*
7702 + * backref not used within given reg. exp. text:
7703 + * replace capturing parentheses by non capturing one
7704 + */
7705 + *n++ = '?';
7706 + *n++ = ':';
7707 + }
7708 + }
7709 + }
7710 + else
7711 + {
7712 + s ++;
7713 + }
7714 + }
7715 +
7716 + /*
7717 + * terminate adapted string
7718 + */
7719 + *n = '\0';
7720 +
7721 + return newRegExpText;
7722 +}
7723 +
7724 +/*
7725 +** Get all local backrefs of given regExpText and put them into
7726 +** given localBackRefList.
7727 +*/
7728 +static void scanForLocalBackRefs(
7729 + char *regExpText,
7730 + int *localBackRefList)
7731 +{
7732 + int i;
7733 + int localId;
7734 + char *s = regExpText;
7735 +
7736 + for (i=0; i<MAX_LOCAL_BACK_REF_ID; i++)
7737 + {
7738 + localBackRefList[i] = NO_LOCAL_BACK_REF_ID;
7739 + }
7740 +
7741 + while (*s != '\0')
7742 + {
7743 + if (*s == '\\')
7744 + {
7745 + if (isdigit((unsigned char)*(s+1)))
7746 + {
7747 + /*
7748 + * \n (n=1..9) found: flag usage in local backref list
7749 + */
7750 + localId =
7751 + (int)((unsigned char)*(s+1) - (unsigned char)'0') - 1;
7752 +
7753 + localBackRefList[localId] = LOCAL_BACK_REF_ID_USED;
7754 +
7755 + s ++;
7756 + }
7757 + else if (*(s+1) != '\0')
7758 + s ++;
7759 + }
7760 + s ++;
7761 + }
7762 +}
7763 +
7764 +/*
7765 +** Returns true, if string of given multi pattern reference was
7766 +** not added to regExpStringInfo.
7767 +*/
7768 +static int isMultiPatternNotAdded(
7769 + RegExpStringInfo *regExpStringInfo,
7770 + PatternReference *toBeAddedPR)
7771 +{
7772 + int i;
7773 + PatternReference *addedPR;
7774 + PatternReference *newPR;
7775 +
7776 + for (i=0; i < regExpStringInfo->resiNbrOfAddedMultiPat; i++)
7777 + {
7778 + addedPR = regExpStringInfo->resiAddedMultiPat[i];
7779 +
7780 + if (addedPR->prElementIdx == toBeAddedPR->prElementIdx &&
7781 + addedPR->prPatternIdx == toBeAddedPR->prPatternIdx)
7782 + {
7783 + return False;
7784 + }
7785 + }
7786 +
7787 + newPR = (PatternReference *)XtMalloc(sizeof(PatternReference));
7788 +
7789 + *newPR = *toBeAddedPR;
7790 +
7791 + regExpStringInfo->resiAddedMultiPat[regExpStringInfo->resiNbrOfAddedMultiPat ++] = newPR;
7792 +
7793 + return True;
7794 +}
7795 +
7796 +/*
7797 +** add given PatternElement to given reg. exp. strings
7798 +*/
7799 +static void addUniquePatternToRegExpString(
7800 + PatternElement *patElement,
7801 + PatternReference *patElementReference,
7802 + ReadMatchPatternInfo *readMatchPatternInfo,
7803 + RegExpStringInfo *regExpStringInfo)
7804 +{
7805 + PatternElement *referredElement;
7806 + PatternReference referredPatReference;
7807 +
7808 + switch (patElement->peType)
7809 + {
7810 + case PET_SINGLE:
7811 + addPatternToRegExpString(
7812 + &(patElement->peVal.peuSingle),
7813 + regExpStringInfo);
7814 + break;
7815 +
7816 + case PET_MULTIPLE:
7817 + /*
7818 + * add element to reg. exp. string only, if it was
7819 + * not added before.
7820 + */
7821 + if (isMultiPatternNotAdded(regExpStringInfo, patElementReference))
7822 + {
7823 + addPatternToRegExpString(
7824 + &(patElement->peVal.peuMulti.mpStringPattern),
7825 + regExpStringInfo);
7826 + }
7827 + break;
7828 +
7829 + case PET_REFERENCE:
7830 + /*
7831 + * add referred element to reg. exp. string only, if related
7832 + * multi pattern was not added before.
7833 + */
7834 + referredPatReference = patElement->peVal.peuRef;
7835 +
7836 + referredElement =
7837 + readMatchPatternInfo->rmpiElement[referredPatReference.prElementIdx]->
7838 + mpteAll.pesPattern[referredPatReference.prPatternIdx];
7839 +
7840 + if (isMultiPatternNotAdded(regExpStringInfo, &referredPatReference))
7841 + {
7842 + addPatternToRegExpString(
7843 + &(referredElement->peVal.peuMulti.mpStringPattern),
7844 + regExpStringInfo);
7845 + }
7846 + break;
7847 + }
7848 +}
7849 +
7850 +/*
7851 +** add given MatchPatternTableElement to given reg. ex. strings
7852 +*/
7853 +static void addElementToRegExpString(
7854 + MatchPatternTableElement *element,
7855 + ReadMatchPatternInfo *readMatchPatternInfo,
7856 + RegExpStringInfo *regExpStringInfo)
7857 +{
7858 + int i;
7859 + PatternReference elementRef;
7860 +
7861 + elementRef.prElementIdx = element->mpteIndex;
7862 +
7863 + for (i=0; i<element->mpteAll.pesNumberOfPattern; i ++)
7864 + {
7865 + elementRef.prPatternIdx = i;
7866 +
7867 + addUniquePatternToRegExpString(
7868 + element->mpteAll.pesPattern[i],
7869 + &elementRef,
7870 + readMatchPatternInfo,
7871 + regExpStringInfo);
7872 + }
7873 +}
7874 +
7875 +/*
7876 +** Concatenate strings stored by regExpStringInfo.
7877 +** Free given regExpStringInfo afterwards.
7878 +** Returns resulting string.
7879 +*/
7880 +static void catSMTRegExpStrings(
7881 + RegExpStringInfo *regExpStringInfo,
7882 + char **regExpString)
7883 +{
7884 + int resultingLen;
7885 +
7886 + /*
7887 + * allocate & init. a buffer for the resulting regular expression
7888 + */
7889 + resultingLen =
7890 + strlen( regExpStringInfo->resiNoneWBRegExpString ) +
7891 + strlen( regExpStringInfo->resiLeftWBRegExpString ) +
7892 + strlen( regExpStringInfo->resiRightWBRegExpString ) +
7893 + strlen( regExpStringInfo->resiBothWBRegExpString ) + 5;
7894 +
7895 + *regExpString = XtMalloc( resultingLen );
7896 +
7897 + strcpy( *regExpString, "" );
7898 +
7899 + /*
7900 + * add the single parts to the resulting regular expression
7901 + * (= cat of parts separated by an "or")
7902 + */
7903 + addSMTRegExpString( *regExpString, regExpStringInfo->resiNoneWBRegExpString, "" );
7904 + addSMTRegExpString( *regExpString, regExpStringInfo->resiLeftWBRegExpString, ")" );
7905 + addSMTRegExpString( *regExpString, regExpStringInfo->resiRightWBRegExpString, ")>" );
7906 + addSMTRegExpString( *regExpString, regExpStringInfo->resiBothWBRegExpString, ")>" );
7907 +
7908 + /*
7909 + * free buffers
7910 + */
7911 + freeRegExpStringInfo( regExpStringInfo );
7912 +}
7913 +
7914 +/*
7915 +** Free the allocated memory contained in a RegExpStringInfo data structure
7916 +*/
7917 +static void freeRegExpStringInfo(
7918 + RegExpStringInfo *regExpStringInfo)
7919 +{
7920 + int i;
7921 +
7922 + XtFree( regExpStringInfo->resiNoneWBRegExpString );
7923 + XtFree( regExpStringInfo->resiLeftWBRegExpString );
7924 + XtFree( regExpStringInfo->resiRightWBRegExpString );
7925 + XtFree( regExpStringInfo->resiBothWBRegExpString );
7926 +
7927 + for (i=0; i < regExpStringInfo->resiNbrOfAddedMultiPat; i ++)
7928 + XtFree( (char *)regExpStringInfo->resiAddedMultiPat[i] );
7929 +
7930 + XtFree( (char *)regExpStringInfo->resiAddedMultiPat);
7931 +}
7932 +
7933 +/*
7934 +** Compose regular expression for start / end pattern.
7935 +*/
7936 +static void composeStartEndRegExpString(
7937 + ReadMatchPatternInfo *readMatchPatternInfo,
7938 + MatchPatternTableElement *element,
7939 + char **regExpString)
7940 +{
7941 + int i;
7942 + RegExpStringInfo regExpStringInfo;
7943 + PatternReference elementRef;
7944 + PatternElementSet startPat = element->mpteStart;
7945 + PatternElementSet endPat = element->mpteEnd;
7946 +
7947 + /*
7948 + * Allocate buffers for keyword regular expression.
7949 + */
7950 + setupRegExpStringBuffers(
7951 + readMatchPatternInfo,
7952 + ®ExpStringInfo);
7953 +
7954 + /*
7955 + * Treat start / end element of MatchPatternTableElement
7956 + */
7957 +
7958 + elementRef.prElementIdx = element->mpteIndex;
7959 +
7960 + for (i=0; i < startPat.pesNumberOfPattern; i ++)
7961 + {
7962 + elementRef.prPatternIdx = startPat.pesPattern[i]->peIndex;
7963 +
7964 + addUniquePatternToRegExpString(
7965 + startPat.pesPattern[i],
7966 + &elementRef,
7967 + readMatchPatternInfo,
7968 + ®ExpStringInfo);
7969 + }
7970 +
7971 + for (i=0; i < endPat.pesNumberOfPattern; i ++)
7972 + {
7973 + elementRef.prPatternIdx = endPat.pesPattern[i]->peIndex;
7974 +
7975 + addUniquePatternToRegExpString(
7976 + endPat.pesPattern[i],
7977 + &elementRef,
7978 + readMatchPatternInfo,
7979 + ®ExpStringInfo);
7980 + }
7981 +
7982 + /*
7983 + * Assemble the resulting regular expression
7984 + */
7985 + catSMTRegExpStrings(
7986 + ®ExpStringInfo,
7987 + regExpString);
7988 +}
7989 +
7990 +static void copyStringMatchTableForDialog(
7991 + StringMatchTable *sourceTable,
7992 + DialogMatchPatternInfo *dialogTable )
7993 +{
7994 + int i;
7995 +
7996 + /*
7997 + * if no source table exist (yet), then set nbr. of elements / groups to 0
7998 + */
7999 + if (sourceTable == NULL)
8000 + {
8001 + dialogTable->dmpiNbrOfSeqElements = 0;
8002 +
8003 + return;
8004 + }
8005 +
8006 + /*
8007 + * copy matching pattern sequence
8008 + */
8009 + dialogTable->dmpiNbrOfSeqElements = sourceTable->smtNumberOfSeqElements;
8010 +
8011 + for (i=0; i < sourceTable->smtNumberOfSeqElements; i ++)
8012 + {
8013 + copySequenceElementForDialog(
8014 + sourceTable,
8015 + sourceTable->smtSequence[i],
8016 + &dialogTable->dmpiSequence[i] );
8017 + }
8018 +}
8019 +
8020 +static void *copyMatchPatternElementForDialog(
8021 + MatchPatternTable *table,
8022 + int sourceElementIdx)
8023 +{
8024 + int i;
8025 + int patIdx = 0;
8026 + MatchPatternTableElement *sourceElement;
8027 + DialogMatchPatternTableElement *destination;
8028 +
8029 + sourceElement = table->mptElements[sourceElementIdx];
8030 +
8031 + destination =
8032 + (DialogMatchPatternTableElement *)XtMalloc( sizeof(DialogMatchPatternTableElement) );
8033 +
8034 + destination->dmpteName = XtNewString(sourceElement->mpteName);
8035 + destination->dmpteType = sourceElement->mpteType;
8036 + destination->dmpteSkipBtwnStartEnd = sourceElement->mpteSkipBtwnStartEnd;
8037 + destination->dmpteIgnoreHighLightInfo = sourceElement->mpteIgnoreHighLightInfo;
8038 + destination->dmpteFlash = sourceElement->mpteFlash;
8039 +
8040 + for (i=0; i<sourceElement->mpteAll.pesNumberOfPattern; i++)
8041 + {
8042 + copyPatternForDialog(
8043 + table,
8044 + sourceElement->mpteAll.pesPattern[i],
8045 + &destination->dmptePatterns.dspElements[patIdx ++]);
8046 + }
8047 +
8048 + destination->dmptePatterns.dspNumberOfPatterns = patIdx;
8049 +
8050 + return (void *)destination;
8051 +}
8052 +
8053 +static void copyPatternForDialog(
8054 + MatchPatternTable *table,
8055 + PatternElement *sourcePattern,
8056 + DialogStringPatternElement **dialogPattern )
8057 +{
8058 + DialogStringPatternElement *newPat;
8059 + StringPattern *strSourcePat = GetStringPattern( table, sourcePattern );
8060 +
8061 + newPat = (DialogStringPatternElement *)XtMalloc(sizeof(DialogStringPatternElement));
8062 + *dialogPattern = newPat;
8063 +
8064 + if( strSourcePat->spOrigText != NULL)
8065 + newPat->dspeText = XtNewString(strSourcePat->spOrigText);
8066 + else
8067 + newPat->dspeText = XtNewString(strSourcePat->spText);
8068 +
8069 + newPat->dspeKind = sourcePattern->peKind;
8070 + newPat->dspeWordBoundary = strSourcePat->spWordBoundary;
8071 + newPat->dspeCaseInsensitive = strSourcePat->spCaseInsensitive;
8072 + newPat->dspeRegularExpression = strSourcePat->spRegularExpression;
8073 +}
8074 +
8075 +static void *copyGroupElementForDialog(
8076 + MatchPatternGroupElement *sourceGroup)
8077 +{
8078 + int i;
8079 + DialogMatchPatternGroupElement *destination;
8080 +
8081 + destination =
8082 + (DialogMatchPatternGroupElement *)XtMalloc( sizeof(DialogMatchPatternGroupElement) );
8083 +
8084 + destination->dmpgeName = XtNewString(sourceGroup->mpgeName);
8085 + destination->dmpgeNumberOfSubPatterns = sourceGroup->mpgeNumberOfSubPatterns;
8086 +
8087 + for ( i=0; i<destination->dmpgeNumberOfSubPatterns; i ++)
8088 + {
8089 + destination->dmpgeSubPatternIds[i] =
8090 + XtNewString(sourceGroup->mpgeSubPatternIds[i]);
8091 + }
8092 +
8093 + return destination;
8094 +}
8095 +
8096 +static void copySequenceElementForDialog(
8097 + StringMatchTable *sourceTable,
8098 + MatchPatternSequenceElement *sourceSeqElement,
8099 + DialogMatchPatternSequenceElement **dialogSeqElement )
8100 +{
8101 + DialogMatchPatternSequenceElement *destSeqElement;
8102 +
8103 + destSeqElement =
8104 + (DialogMatchPatternSequenceElement *)XtMalloc( sizeof(DialogMatchPatternSequenceElement) );
8105 +
8106 + *dialogSeqElement = destSeqElement;
8107 +
8108 + destSeqElement->dmpseName = XtNewString(sourceSeqElement->mpseName);
8109 + destSeqElement->dmpseType = sourceSeqElement->mpseType;
8110 + destSeqElement->dmpseValid = True;
8111 +
8112 + if (destSeqElement->dmpseType == MPT_GROUP)
8113 + {
8114 + destSeqElement->dmpsePtr =
8115 + copyGroupElementForDialog(
8116 + sourceTable->smtGroups[sourceSeqElement->mpseIndex]);
8117 + }
8118 + else
8119 + {
8120 + destSeqElement->dmpsePtr =
8121 + copyMatchPatternElementForDialog(
8122 + sourceTable->smtAllPatterns,
8123 + sourceSeqElement->mpseIndex);
8124 + }
8125 +}
8126 +
8127 +static DialogMatchPatternSequenceElement *copyDialogSequenceElement(
8128 + DialogMatchPatternSequenceElement *sourceSeq)
8129 +{
8130 + DialogMatchPatternSequenceElement *destSeq;
8131 +
8132 + destSeq =
8133 + (DialogMatchPatternSequenceElement *)XtMalloc(sizeof(DialogMatchPatternSequenceElement));
8134 +
8135 + destSeq->dmpseName = XtNewString(sourceSeq->dmpseName);
8136 + destSeq->dmpseType = sourceSeq->dmpseType;
8137 + destSeq->dmpseValid = True;
8138 +
8139 + destSeq->dmpsePtr = sourceSeq->dmpsePtr;
8140 +
8141 + return destSeq;
8142 +}
8143 +
8144 +static void freeDialogMatchPatternElement(
8145 + DialogMatchPatternTableElement *dialogElement )
8146 +{
8147 + int i;
8148 +
8149 + for (i=0; i<dialogElement->dmptePatterns.dspNumberOfPatterns; i ++)
8150 + {
8151 + freeDialogStringPatternElement(
8152 + dialogElement->dmptePatterns.dspElements[i]);
8153 + }
8154 +
8155 + freeXtPtr((void **)&dialogElement->dmpteName);
8156 +
8157 + freeXtPtr((void **)&dialogElement);
8158 +}
8159 +
8160 +static void freeDialogStringPatternElement(
8161 + DialogStringPatternElement *element)
8162 +{
8163 + freeXtPtr((void **)&element->dspeText);
8164 +
8165 + freeXtPtr((void **)&element);
8166 +}
8167 +
8168 +static void freeDialogGroupElement(
8169 + DialogMatchPatternGroupElement *dialogGroup )
8170 +{
8171 + int i;
8172 +
8173 + for (i=0; i<dialogGroup->dmpgeNumberOfSubPatterns; i ++)
8174 + {
8175 + freeXtPtr((void **)&dialogGroup->dmpgeSubPatternIds[i]);
8176 + }
8177 +
8178 + freeXtPtr((void **)&dialogGroup->dmpgeName);
8179 +
8180 + freeXtPtr((void **)&dialogGroup);
8181 +}
8182 +
8183 +static void freeDialogSequenceElement(
8184 + DialogMatchPatternSequenceElement *dialogSeq )
8185 +{
8186 + freeXtPtr((void **)&dialogSeq->dmpseName);
8187 +
8188 + if (dialogSeq->dmpseType == MPT_GROUP)
8189 + {
8190 + freeDialogGroupElement(
8191 + (DialogMatchPatternGroupElement *)dialogSeq->dmpsePtr );
8192 + }
8193 + else
8194 + {
8195 + freeDialogMatchPatternElement(
8196 + (DialogMatchPatternTableElement *)dialogSeq->dmpsePtr );
8197 + }
8198 +
8199 + freeXtPtr((void **)&dialogSeq);
8200 +}
8201 +
8202 +static void copyDialogStringPatternsFromTable(
8203 + DialogMatchPatternTableElement *tableElement,
8204 + DialogStringPatterns *destPatterns)
8205 +{
8206 + int i;
8207 +
8208 + destPatterns->dspNumberOfPatterns =
8209 + tableElement->dmptePatterns.dspNumberOfPatterns;
8210 +
8211 + for (i=0; i<destPatterns->dspNumberOfPatterns; i++)
8212 + {
8213 + destPatterns->dspElements[i] =
8214 + copyDialogStringPatternElement(
8215 + tableElement->dmptePatterns.dspElements[i] );
8216 + }
8217 +}
8218 +
8219 +static void copyDialogStringPatterns(
8220 + DialogStringPatterns *sourcePatterns,
8221 + DialogStringPatterns *destPatterns)
8222 +{
8223 + int i;
8224 +
8225 + destPatterns->dspNumberOfPatterns =
8226 + sourcePatterns->dspNumberOfPatterns;
8227 +
8228 + for (i=0; i<destPatterns->dspNumberOfPatterns; i++)
8229 + {
8230 + destPatterns->dspElements[i] =
8231 + copyDialogStringPatternElement(
8232 + sourcePatterns->dspElements[i] );
8233 + }
8234 +}
8235 +
8236 +static void freeDialogStringPatterns(
8237 + DialogStringPatterns *patterns)
8238 +{
8239 + int i;
8240 +
8241 + for (i=0; i<patterns->dspNumberOfPatterns; i++)
8242 + {
8243 + freeDialogStringPatternElement(patterns->dspElements[i]);
8244 + }
8245 +
8246 + patterns->dspNumberOfPatterns = 0;
8247 +}
8248 +
8249 +static DialogStringPatternElement *copyDialogStringPatternElement(
8250 + DialogStringPatternElement *sourceElement)
8251 +{
8252 + DialogStringPatternElement *newPatElement;
8253 +
8254 + newPatElement = (DialogStringPatternElement *)XtMalloc(sizeof(DialogStringPatternElement));
8255 +
8256 + newPatElement->dspeText = XtNewString(sourceElement->dspeText);
8257 + newPatElement->dspeKind = sourceElement->dspeKind;
8258 + newPatElement->dspeWordBoundary = sourceElement->dspeWordBoundary;
8259 + newPatElement->dspeCaseInsensitive = sourceElement->dspeCaseInsensitive;
8260 + newPatElement->dspeRegularExpression = sourceElement->dspeRegularExpression;
8261 +
8262 + return newPatElement;
8263 +}
8264 +
8265 +static void copyDialogPatternNamesFromGroup(
8266 + DialogMatchPatternGroupElement *group,
8267 + DialogStringPatterns *destPatterns)
8268 +{
8269 + int i;
8270 +
8271 + destPatterns->dspNumberOfPatterns =
8272 + group->dmpgeNumberOfSubPatterns;
8273 +
8274 + for (i=0; i<destPatterns->dspNumberOfPatterns; i++)
8275 + {
8276 + destPatterns->dspElements[i] =
8277 + copyDialogPatternName(
8278 + group->dmpgeSubPatternIds[i] );
8279 + }
8280 +}
8281 +
8282 +static DialogStringPatternElement *copyDialogPatternName(
8283 + char *sourcePatternId)
8284 +{
8285 + DialogStringPatternElement *newPatElement;
8286 +
8287 + newPatElement = (DialogStringPatternElement *)XtMalloc(sizeof(DialogStringPatternElement));
8288 +
8289 + newPatElement->dspeText = XtNewString(sourcePatternId);
8290 + newPatElement->dspeKind = PEK_START;
8291 + newPatElement->dspeWordBoundary = PWB_NONE;
8292 + newPatElement->dspeCaseInsensitive = False;
8293 + newPatElement->dspeRegularExpression = False;
8294 +
8295 + return newPatElement;
8296 +}
8297 +
8298 +static void copyDialogPatternNamesToGroup(
8299 + DialogStringPatterns *sourceNames,
8300 + DialogMatchPatternGroupElement *destGroup)
8301 +{
8302 + int i;
8303 +
8304 + destGroup->dmpgeNumberOfSubPatterns =
8305 + sourceNames->dspNumberOfPatterns;
8306 +
8307 + for (i=0; i<destGroup->dmpgeNumberOfSubPatterns; i++)
8308 + {
8309 + destGroup->dmpgeSubPatternIds[i] =
8310 + XtNewString(
8311 + sourceNames->dspElements[i]->dspeText);
8312 + }
8313 +}
8314 +
8315 +
8316 +/*
8317 +** Present a dialog for editing matching pattern information
8318 +*/
8319 +void EditMatchPatterns(WindowInfo *window)
8320 +{
8321 + Widget form, lmOptMenu;
8322 + Widget lmForm;
8323 + Widget okBtn, applyBtn, checkBtn, deleteBtn, closeBtn, helpBtn;
8324 + Widget restoreBtn, lmBtn;
8325 + Widget matchPatternsForm, matchPatternsFrame, matchPatternsLbl;
8326 + Widget matchPatternTypeBox, matchPatternTypeLbl;
8327 + Widget globalAttributesBox;
8328 + Widget stringPatternsFrame, stringPatternsForm;
8329 + Widget stringPatternTypeBox;
8330 + Widget wordBoundaryBox;
8331 + Widget stringAttributesBox;
8332 + StringMatchTable *table;
8333 + XmString s1;
8334 + int n;
8335 + Arg args[20];
8336 +
8337 + /*
8338 + * if the dialog is already displayed, just pop it to the top and return
8339 + */
8340 + if (MatchPatternDialog.mpdShell != NULL)
8341 + {
8342 + RaiseDialogWindow(MatchPatternDialog.mpdShell);
8343 + return;
8344 + }
8345 +
8346 + /*
8347 + * decide on an initial language mode
8348 + */
8349 + MatchPatternDialog.mpdLangModeName =
8350 + XtNewString(
8351 + window->languageMode == PLAIN_LANGUAGE_MODE ?
8352 + PLAIN_LM_STRING : LanguageModeName(window->languageMode));
8353 +
8354 + /*
8355 + * find the associated matching pattern table to edit
8356 + */
8357 + table = (StringMatchTable *)FindStringMatchTable(MatchPatternDialog.mpdLangModeName);
8358 +
8359 + /*
8360 + * copy the list of patterns to one that the user can freely edit
8361 + */
8362 + copyStringMatchTableForDialog( table, &MatchPatternDialog.mpdTable );
8363 +
8364 + /*
8365 + * init. status information of dialog
8366 + */
8367 + MatchPatternDialog.currentDmptSeqElement = NULL;
8368 + MatchPatternDialog.currentDmptElement = NULL;
8369 + MatchPatternDialog.currentDmptGroup = NULL;
8370 +
8371 + MatchPatternDialog.currentStringPatterns.dspNumberOfPatterns = 0;
8372 + MatchPatternDialog.mpdStringPatternIsDisplayed = True;
8373 +
8374 + /*
8375 + * Create a form widget in an application shell
8376 + */
8377 + n = 0;
8378 + XtSetArg(args[n], XmNdeleteResponse, XmDO_NOTHING); n++;
8379 + XtSetArg(args[n], XmNiconName, "Matching Patterns"); n++;
8380 + XtSetArg(args[n], XmNtitle, "Matching (Parenthesis) Patterns"); n++;
8381 + MatchPatternDialog.mpdShell = CreateShellWithBestVis(APP_NAME, APP_CLASS,
8382 + applicationShellWidgetClass, TheDisplay, args, n);
8383 + AddSmallIcon(MatchPatternDialog.mpdShell);
8384 + form = XtVaCreateManagedWidget("editMatchPatterns", xmFormWidgetClass,
8385 + MatchPatternDialog.mpdShell, XmNautoUnmanage, False,
8386 + XmNresizePolicy, XmRESIZE_NONE, NULL);
8387 + XtAddCallback(form, XmNdestroyCallback, destroyCB, NULL);
8388 + AddMotifCloseCallback(MatchPatternDialog.mpdShell, closeCB, NULL);
8389 +
8390 + lmForm = XtVaCreateManagedWidget("lmForm", xmFormWidgetClass,
8391 + form,
8392 + XmNleftAttachment, XmATTACH_POSITION,
8393 + XmNleftPosition, 1,
8394 + XmNtopAttachment, XmATTACH_POSITION,
8395 + XmNtopPosition, 1,
8396 + XmNrightAttachment, XmATTACH_POSITION,
8397 + XmNrightPosition, 99, NULL);
8398 +
8399 + MatchPatternDialog.mpdLmPulldown =
8400 + CreateLanguageModeMenu(lmForm, matchPatternLangModeCB, NULL, True);
8401 +
8402 + n = 0;
8403 + XtSetArg(args[n], XmNspacing, 0); n++;
8404 + XtSetArg(args[n], XmNmarginWidth, 0); n++;
8405 + XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
8406 + XtSetArg(args[n], XmNleftAttachment, XmATTACH_POSITION); n++;
8407 + XtSetArg(args[n], XmNleftPosition, 50); n++;
8408 + XtSetArg(args[n], XmNsubMenuId, MatchPatternDialog.mpdLmPulldown); n++;
8409 + lmOptMenu = XmCreateOptionMenu(lmForm, "langModeOptMenu", args, n);
8410 + XtManageChild(lmOptMenu);
8411 + MatchPatternDialog.mpdLmOptMenu = lmOptMenu;
8412 +
8413 + XtVaCreateManagedWidget("lmLbl", xmLabelGadgetClass, lmForm,
8414 + XmNlabelString, s1=XmStringCreateSimple("Language Mode:"),
8415 + XmNmnemonic, 'M',
8416 + XmNuserData, XtParent(MatchPatternDialog.mpdLmOptMenu),
8417 + XmNalignment, XmALIGNMENT_END,
8418 + XmNrightAttachment, XmATTACH_POSITION,
8419 + XmNrightPosition, 50,
8420 + XmNtopAttachment, XmATTACH_FORM,
8421 + XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET,
8422 + XmNbottomWidget, lmOptMenu, NULL);
8423 + XmStringFree(s1);
8424 +
8425 + lmBtn = XtVaCreateManagedWidget("lmBtn", xmPushButtonWidgetClass, lmForm,
8426 + XmNlabelString, s1=MKSTRING("Add / Modify\nLanguage Mode..."),
8427 + XmNmnemonic, 'A',
8428 + XmNrightAttachment, XmATTACH_FORM,
8429 + XmNtopAttachment, XmATTACH_FORM, NULL);
8430 + XtAddCallback(lmBtn, XmNactivateCallback, pmLanguageModeDialogCB, NULL);
8431 + XmStringFree(s1);
8432 +
8433 + okBtn = XtVaCreateManagedWidget("ok", xmPushButtonWidgetClass, form,
8434 + XmNlabelString, s1=XmStringCreateSimple("OK"),
8435 + XmNleftAttachment, XmATTACH_POSITION,
8436 + XmNleftPosition, 1,
8437 + XmNrightAttachment, XmATTACH_POSITION,
8438 + XmNrightPosition, 13,
8439 + XmNbottomAttachment, XmATTACH_FORM,
8440 + XmNbottomOffset, BORDER, NULL);
8441 + XtAddCallback(okBtn, XmNactivateCallback, okCB, NULL);
8442 + XmStringFree(s1);
8443 +
8444 + applyBtn = XtVaCreateManagedWidget("apply", xmPushButtonWidgetClass, form,
8445 + XmNlabelString, s1=XmStringCreateSimple("Apply"),
8446 + XmNmnemonic, 'y',
8447 + XmNleftAttachment, XmATTACH_POSITION,
8448 + XmNleftPosition, 13,
8449 + XmNrightAttachment, XmATTACH_POSITION,
8450 + XmNrightPosition, 26,
8451 + XmNbottomAttachment, XmATTACH_FORM,
8452 + XmNbottomOffset, BORDER, NULL);
8453 + XtAddCallback(applyBtn, XmNactivateCallback, applyCB, NULL);
8454 + XmStringFree(s1);
8455 +
8456 + checkBtn = XtVaCreateManagedWidget("check", xmPushButtonWidgetClass, form,
8457 + XmNlabelString, s1=XmStringCreateSimple("Check"),
8458 + XmNmnemonic, 'k',
8459 + XmNleftAttachment, XmATTACH_POSITION,
8460 + XmNleftPosition, 26,
8461 + XmNrightAttachment, XmATTACH_POSITION,
8462 + XmNrightPosition, 39,
8463 + XmNbottomAttachment, XmATTACH_FORM,
8464 + XmNbottomOffset, BORDER, NULL);
8465 + XtAddCallback(checkBtn, XmNactivateCallback, checkCB, NULL);
8466 + XmStringFree(s1);
8467 +
8468 + deleteBtn = XtVaCreateManagedWidget("delete", xmPushButtonWidgetClass, form,
8469 + XmNlabelString, s1=XmStringCreateSimple("Delete"),
8470 + XmNmnemonic, 'D',
8471 + XmNleftAttachment, XmATTACH_POSITION,
8472 + XmNleftPosition, 39,
8473 + XmNrightAttachment, XmATTACH_POSITION,
8474 + XmNrightPosition, 52,
8475 + XmNbottomAttachment, XmATTACH_FORM,
8476 + XmNbottomOffset, BORDER, NULL);
8477 + XtAddCallback(deleteBtn, XmNactivateCallback, deleteCB, NULL);
8478 + XmStringFree(s1);
8479 +
8480 + restoreBtn = XtVaCreateManagedWidget("restore", xmPushButtonWidgetClass, form,
8481 + XmNlabelString, s1=XmStringCreateSimple("Restore Defaults"),
8482 + XmNmnemonic, 'f',
8483 + XmNleftAttachment, XmATTACH_POSITION,
8484 + XmNleftPosition, 52,
8485 + XmNrightAttachment, XmATTACH_POSITION,
8486 + XmNrightPosition, 73,
8487 + XmNbottomAttachment, XmATTACH_FORM,
8488 + XmNbottomOffset, BORDER, NULL);
8489 + XtAddCallback(restoreBtn, XmNactivateCallback, restoreCB, NULL);
8490 + XmStringFree(s1);
8491 +
8492 + closeBtn = XtVaCreateManagedWidget("close", xmPushButtonWidgetClass,
8493 + form,
8494 + XmNlabelString, s1=XmStringCreateSimple("Close"),
8495 + XmNleftAttachment, XmATTACH_POSITION,
8496 + XmNleftPosition, 73,
8497 + XmNrightAttachment, XmATTACH_POSITION,
8498 + XmNrightPosition, 86,
8499 + XmNbottomAttachment, XmATTACH_FORM,
8500 + XmNbottomOffset, BORDER, NULL);
8501 + XtAddCallback(closeBtn, XmNactivateCallback, closeCB, NULL);
8502 + XmStringFree(s1);
8503 +
8504 + helpBtn = XtVaCreateManagedWidget("help", xmPushButtonWidgetClass,
8505 + form,
8506 + XmNlabelString, s1=XmStringCreateSimple("Help"),
8507 + XmNmnemonic, 'H',
8508 + XmNleftAttachment, XmATTACH_POSITION,
8509 + XmNleftPosition, 86,
8510 + XmNrightAttachment, XmATTACH_POSITION,
8511 + XmNrightPosition, 99,
8512 + XmNbottomAttachment, XmATTACH_FORM,
8513 + XmNbottomOffset, BORDER, NULL);
8514 + XtAddCallback(helpBtn, XmNactivateCallback, helpCB, NULL);
8515 + XmStringFree(s1);
8516 +
8517 + stringPatternsFrame = XtVaCreateManagedWidget("stringPatternsFrame", xmFrameWidgetClass,
8518 + form,
8519 + XmNleftAttachment, XmATTACH_POSITION,
8520 + XmNleftPosition, 1,
8521 + XmNrightAttachment, XmATTACH_POSITION,
8522 + XmNrightPosition, 99,
8523 + XmNbottomAttachment, XmATTACH_WIDGET,
8524 + XmNbottomWidget, okBtn,
8525 + XmNbottomOffset, BORDER, NULL);
8526 + stringPatternsForm = XtVaCreateManagedWidget("stringPatternsForm", xmFormWidgetClass,
8527 + stringPatternsFrame, NULL);
8528 + MatchPatternDialog.mpdStringPatternsLbl = XtVaCreateManagedWidget("mpdStringPatternsLbl", xmLabelGadgetClass,
8529 + stringPatternsFrame,
8530 + XmNlabelString, s1=XmStringCreateSimple(STRING_PATTERNS_LBL_TXT),
8531 + XmNmarginHeight, 0,
8532 + XmNchildType, XmFRAME_TITLE_CHILD, NULL);
8533 + XmStringFree(s1);
8534 +
8535 + n = 0;
8536 + XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
8537 + XtSetArg(args[n], XmNleftAttachment, XmATTACH_POSITION); n++;
8538 + XtSetArg(args[n], XmNleftPosition, 1); n++;
8539 + XtSetArg(args[n], XmNrightAttachment, XmATTACH_POSITION); n++;
8540 + XtSetArg(args[n], XmNrightPosition, LIST_RIGHT-1); n++;
8541 + XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); n++;
8542 + XtSetArg(args[n], XmNbottomOffset, BORDER); n++;
8543 + MatchPatternDialog.mpdStringPatternsListW =
8544 + CreateManagedList(stringPatternsForm, "stringPatternsList", args,
8545 + n, (void **)MatchPatternDialog.currentStringPatterns.dspElements,
8546 + &MatchPatternDialog.currentStringPatterns.dspNumberOfPatterns,
8547 + MAX_STRING_PATTERNS, 18,
8548 + getStringPatternDisplayedCB, NULL,
8549 + setStringPatternDisplayedCB, NULL,
8550 + freeStringPatternItemCB);
8551 + XtVaSetValues(MatchPatternDialog.mpdStringPatternsLbl, XmNuserData, MatchPatternDialog.mpdStringPatternsListW, NULL);
8552 +
8553 + MatchPatternDialog.mpdStringPatternTypeLbl = XtVaCreateManagedWidget("mpdStringPatternTypeLbl", xmLabelGadgetClass,
8554 + stringPatternsForm,
8555 + XmNlabelString, s1=XmStringCreateSimple("String Pattern Type:"),
8556 + XmNmarginHeight, 0,
8557 + XmNalignment, XmALIGNMENT_BEGINNING,
8558 + XmNleftAttachment, XmATTACH_POSITION,
8559 + XmNleftPosition, LIST_RIGHT,
8560 + XmNtopAttachment, XmATTACH_FORM, NULL);
8561 + XmStringFree(s1);
8562 +
8563 + stringPatternTypeBox = XtVaCreateManagedWidget("stringPatternTypeBox", xmRowColumnWidgetClass,
8564 + stringPatternsForm,
8565 + XmNorientation, XmHORIZONTAL,
8566 + XmNpacking, XmPACK_TIGHT,
8567 + XmNradioBehavior, True,
8568 + XmNleftAttachment, XmATTACH_POSITION,
8569 + XmNleftPosition, LIST_RIGHT,
8570 + XmNtopAttachment, XmATTACH_WIDGET,
8571 + XmNtopWidget, MatchPatternDialog.mpdStringPatternTypeLbl, NULL);
8572 + MatchPatternDialog.sptStartW = XtVaCreateManagedWidget("sptStartW",
8573 + xmToggleButtonWidgetClass, stringPatternTypeBox,
8574 + XmNset, True,
8575 + XmNmarginHeight, 0,
8576 + XmNlabelString, s1=XmStringCreateSimple(
8577 + "Start"),
8578 + NULL);
8579 + XmStringFree(s1);
8580 + MatchPatternDialog.sptMiddleW = XtVaCreateManagedWidget("sptMiddleW",
8581 + xmToggleButtonWidgetClass, stringPatternTypeBox,
8582 + XmNmarginHeight, 0,
8583 + XmNlabelString, s1=XmStringCreateSimple(
8584 + "Middle"),
8585 + NULL);
8586 + XmStringFree(s1);
8587 + MatchPatternDialog.sptEndW = XtVaCreateManagedWidget("sptEndW",
8588 + xmToggleButtonWidgetClass, stringPatternTypeBox,
8589 + XmNmarginHeight, 0,
8590 + XmNlabelString, s1=XmStringCreateSimple(
8591 + "End"),
8592 + NULL);
8593 + XmStringFree(s1);
8594 +
8595 + MatchPatternDialog.mpdWordBoundaryLbl = XtVaCreateManagedWidget("mpdWordBoundaryLbl", xmLabelGadgetClass,
8596 + stringPatternsForm,
8597 + XmNlabelString, s1=XmStringCreateSimple("Word boundary:"),
8598 + XmNmarginHeight, 0,
8599 + XmNalignment, XmALIGNMENT_BEGINNING,
8600 + XmNleftAttachment, XmATTACH_POSITION,
8601 + XmNleftPosition, LIST_RIGHT,
8602 + XmNtopAttachment, XmATTACH_WIDGET,
8603 + XmNtopWidget, stringPatternTypeBox,
8604 + NULL);
8605 + XmStringFree(s1);
8606 +
8607 + wordBoundaryBox = XtVaCreateManagedWidget("wordBoundaryBox", xmRowColumnWidgetClass,
8608 + stringPatternsForm,
8609 + XmNorientation, XmHORIZONTAL,
8610 + XmNpacking, XmPACK_TIGHT,
8611 + XmNradioBehavior, True,
8612 + XmNleftAttachment, XmATTACH_POSITION,
8613 + XmNleftPosition, LIST_RIGHT,
8614 + XmNtopAttachment, XmATTACH_WIDGET,
8615 + XmNtopWidget, MatchPatternDialog.mpdWordBoundaryLbl, NULL);
8616 + MatchPatternDialog.wbbBothW = XtVaCreateManagedWidget("wbbBothW",
8617 + xmToggleButtonWidgetClass, wordBoundaryBox,
8618 + XmNset, True,
8619 + XmNmarginHeight, 0,
8620 + XmNlabelString, s1=XmStringCreateSimple(
8621 + "Both (pattern is word)"),
8622 + NULL);
8623 + XmStringFree(s1);
8624 + MatchPatternDialog.wbbLeftW = XtVaCreateManagedWidget("wbbLeftW",
8625 + xmToggleButtonWidgetClass, wordBoundaryBox,
8626 + XmNmarginHeight, 0,
8627 + XmNlabelString, s1=XmStringCreateSimple(
8628 + "Left"),
8629 + NULL);
8630 + XmStringFree(s1);
8631 + MatchPatternDialog.wbbRightW = XtVaCreateManagedWidget("wbbRightW",
8632 + xmToggleButtonWidgetClass, wordBoundaryBox,
8633 + XmNmarginHeight, 0,
8634 + XmNlabelString, s1=XmStringCreateSimple(
8635 + "Right"),
8636 + NULL);
8637 + XmStringFree(s1);
8638 + MatchPatternDialog.wbbNoneW = XtVaCreateManagedWidget("wbbNoneW",
8639 + xmToggleButtonWidgetClass, wordBoundaryBox,
8640 + XmNmarginHeight, 0,
8641 + XmNlabelString, s1=XmStringCreateSimple(
8642 + "None"),
8643 + NULL);
8644 + XmStringFree(s1);
8645 +
8646 + MatchPatternDialog.mpdStringAttributesLbl = XtVaCreateManagedWidget("mpdStringAttributesLbl", xmLabelGadgetClass,
8647 + stringPatternsForm,
8648 + XmNlabelString, s1=XmStringCreateSimple("String Attributes:"),
8649 + XmNmarginHeight, 0,
8650 + XmNalignment, XmALIGNMENT_BEGINNING,
8651 + XmNleftAttachment, XmATTACH_POSITION,
8652 + XmNleftPosition, LIST_RIGHT,
8653 + XmNtopAttachment, XmATTACH_WIDGET,
8654 + XmNtopWidget, wordBoundaryBox, NULL);
8655 + XmStringFree(s1);
8656 +
8657 + stringAttributesBox = XtVaCreateManagedWidget("stringAttributesBox", xmRowColumnWidgetClass,
8658 + stringPatternsForm,
8659 + XmNorientation, XmHORIZONTAL,
8660 + XmNpacking, XmPACK_TIGHT,
8661 + XmNleftAttachment, XmATTACH_POSITION,
8662 + XmNleftPosition, LIST_RIGHT,
8663 + XmNtopAttachment, XmATTACH_WIDGET,
8664 + XmNtopWidget, MatchPatternDialog.mpdStringAttributesLbl, NULL);
8665 + MatchPatternDialog.sabRegularExpressionW = XtVaCreateManagedWidget("sabRegularExpressionW",
8666 + xmToggleButtonWidgetClass, stringAttributesBox,
8667 + XmNset, False,
8668 + XmNmarginHeight, 0,
8669 + XmNlabelString, s1=XmStringCreateSimple(
8670 + "Regular Expression"),
8671 + NULL);
8672 + XmStringFree(s1);
8673 + XtAddCallback(MatchPatternDialog.sabRegularExpressionW, XmNvalueChangedCallback,
8674 + strPatRegExpressionCB, NULL);
8675 + MatchPatternDialog.sabCaseSensitiveW = XtVaCreateManagedWidget("sabCaseSensitiveW",
8676 + xmToggleButtonWidgetClass, stringAttributesBox,
8677 + XmNset, True,
8678 + XmNmarginHeight, 0,
8679 + XmNlabelString, s1=XmStringCreateSimple(
8680 + "Case Sensitive"),
8681 + NULL);
8682 + XmStringFree(s1);
8683 +
8684 + MatchPatternDialog.mpdStringPatternLbl = XtVaCreateManagedWidget("mpdStringPatternLbl", xmLabelGadgetClass,
8685 + stringPatternsForm,
8686 + XmNlabelString, s1=XmStringCreateSimple("String Pattern"),
8687 + XmNmnemonic, 'S',
8688 + XmNalignment, XmALIGNMENT_BEGINNING,
8689 + XmNleftAttachment, XmATTACH_POSITION,
8690 + XmNleftPosition, LIST_RIGHT,
8691 + XmNtopAttachment, XmATTACH_WIDGET,
8692 + XmNtopWidget, stringAttributesBox,
8693 + XmNtopOffset, BORDER,
8694 + NULL);
8695 + XmStringFree(s1);
8696 +
8697 + MatchPatternDialog.mpdStringPatternW = XtVaCreateManagedWidget("mpdStringPatternW", xmTextWidgetClass,
8698 + stringPatternsForm,
8699 + XmNleftAttachment, XmATTACH_POSITION,
8700 + XmNleftPosition, LIST_RIGHT,
8701 + XmNtopAttachment, XmATTACH_WIDGET,
8702 + XmNtopWidget, MatchPatternDialog.mpdStringPatternLbl,
8703 + XmNrightAttachment, XmATTACH_FORM,
8704 + XmNrightOffset, BORDER,
8705 + NULL);
8706 + RemapDeleteKey(MatchPatternDialog.mpdStringPatternW);
8707 + XtVaSetValues(MatchPatternDialog.mpdStringPatternLbl, XmNuserData, MatchPatternDialog.mpdStringPatternW, NULL);
8708 +
8709 + MatchPatternDialog.mpdSubPatNamesLbl = XtVaCreateManagedWidget("mpdSubPatNamesLbl", xmLabelGadgetClass,
8710 + stringPatternsForm,
8711 + XmNlabelString, s1=XmStringCreateSimple("Sub-Pattern Name"),
8712 + XmNmnemonic, 't',
8713 + XmNalignment, XmALIGNMENT_BEGINNING,
8714 + XmNleftAttachment, XmATTACH_POSITION,
8715 + XmNleftPosition, LIST_RIGHT,
8716 + XmNtopAttachment, XmATTACH_WIDGET,
8717 + XmNtopWidget, MatchPatternDialog.mpdStringPatternW,
8718 + XmNtopOffset, BORDER,
8719 + NULL);
8720 + XmStringFree(s1);
8721 +
8722 + MatchPatternDialog.mpdSubPatNamesPulldown =
8723 + createSubPatternNameMenu(stringPatternsForm, NULL, False);
8724 +
8725 + n = 0;
8726 + XtSetArg(args[n], XmNspacing, 0); n++;
8727 + XtSetArg(args[n], XmNmarginWidth, 0); n++;
8728 + XtSetArg(args[n], XmNresizeWidth, True); n++;
8729 + XtSetArg(args[n], XmNresizeHeight, True); n++;
8730 + XtSetArg(args[n], XmNnavigationType, XmTAB_GROUP); n++;
8731 + XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
8732 + XtSetArg(args[n], XmNtopWidget, MatchPatternDialog.mpdSubPatNamesLbl); n++;
8733 + XtSetArg(args[n], XmNleftAttachment, XmATTACH_POSITION); n++;
8734 + XtSetArg(args[n], XmNleftPosition, LIST_RIGHT); n++;
8735 + XtSetArg(args[n], XmNsubMenuId, MatchPatternDialog.mpdSubPatNamesPulldown); n++;
8736 + MatchPatternDialog.mpdSubPatNamesOptMenu =
8737 + XmCreateOptionMenu(stringPatternsForm, "subPatNamesOptMenu", args, n);
8738 + XtManageChild(MatchPatternDialog.mpdSubPatNamesOptMenu);
8739 +
8740 + XtVaSetValues(
8741 + MatchPatternDialog.mpdSubPatNamesLbl,
8742 + XmNuserData, XtParent(MatchPatternDialog.mpdSubPatNamesOptMenu),
8743 + NULL);
8744 +
8745 + XtSetSensitive(MatchPatternDialog.mpdSubPatNamesLbl, False);
8746 + XtSetSensitive(MatchPatternDialog.mpdSubPatNamesOptMenu, False);
8747 +
8748 + matchPatternsFrame = XtVaCreateManagedWidget("matchPatternsFrame", xmFrameWidgetClass,
8749 + form,
8750 + XmNleftAttachment, XmATTACH_POSITION,
8751 + XmNleftPosition, 1,
8752 + XmNtopAttachment, XmATTACH_WIDGET,
8753 + XmNtopWidget, lmForm,
8754 + XmNrightAttachment, XmATTACH_POSITION,
8755 + XmNrightPosition, 99,
8756 + XmNbottomAttachment, XmATTACH_WIDGET,
8757 + XmNbottomWidget, stringPatternsFrame,
8758 + XmNbottomOffset, BORDER, NULL);
8759 + matchPatternsForm = XtVaCreateManagedWidget("matchPatternsForm", xmFormWidgetClass,
8760 + matchPatternsFrame, NULL);
8761 + matchPatternsLbl = XtVaCreateManagedWidget("matchPatternsLbl", xmLabelGadgetClass,
8762 + matchPatternsFrame,
8763 + XmNlabelString, s1=XmStringCreateSimple("Matching Patterns"),
8764 + XmNmnemonic, 'P',
8765 + XmNmarginHeight, 0,
8766 + XmNchildType, XmFRAME_TITLE_CHILD, NULL);
8767 + XmStringFree(s1);
8768 +
8769 + matchPatternTypeLbl = XtVaCreateManagedWidget("matchPatternTypeLbl", xmLabelGadgetClass,
8770 + matchPatternsForm,
8771 + XmNlabelString, s1=XmStringCreateSimple("Matching Pattern Type:"),
8772 + XmNmarginHeight, 0,
8773 + XmNalignment, XmALIGNMENT_BEGINNING,
8774 + XmNleftAttachment, XmATTACH_POSITION,
8775 + XmNleftPosition, LIST_RIGHT,
8776 + XmNtopAttachment, XmATTACH_FORM, NULL);
8777 + XmStringFree(s1);
8778 +
8779 + matchPatternTypeBox = XtVaCreateManagedWidget("matchPatternTypeBox", xmRowColumnWidgetClass,
8780 + matchPatternsForm,
8781 + XmNpacking, XmPACK_COLUMN,
8782 + XmNradioBehavior, True,
8783 + XmNleftAttachment, XmATTACH_POSITION,
8784 + XmNleftPosition, LIST_RIGHT,
8785 + XmNtopAttachment, XmATTACH_WIDGET,
8786 + XmNtopWidget, matchPatternTypeLbl, NULL);
8787 + MatchPatternDialog.mptbIndividualW = XtVaCreateManagedWidget("mptbIndividualW",
8788 + xmToggleButtonWidgetClass, matchPatternTypeBox,
8789 + XmNset, True,
8790 + XmNmarginHeight, 0,
8791 + XmNlabelString, s1=XmStringCreateSimple(
8792 + "Individual"),
8793 + XmNmnemonic, 'I', NULL);
8794 + XmStringFree(s1);
8795 + XtAddCallback(MatchPatternDialog.mptbIndividualW, XmNvalueChangedCallback,
8796 + matchPatTypeCB, NULL);
8797 + MatchPatternDialog.mptbSubPatternW = XtVaCreateManagedWidget("mptbSubPatternW",
8798 + xmToggleButtonWidgetClass, matchPatternTypeBox,
8799 + XmNmarginHeight, 0,
8800 + XmNlabelString, s1=XmStringCreateSimple(
8801 + "Sub-pattern (belongs to context group)"),
8802 + XmNmnemonic, 'u', NULL);
8803 + XmStringFree(s1);
8804 + XtAddCallback(MatchPatternDialog.mptbSubPatternW, XmNvalueChangedCallback,
8805 + matchPatTypeCB, NULL);
8806 + MatchPatternDialog.mptbContextGroupW = XtVaCreateManagedWidget("mptbContextGroupW",
8807 + xmToggleButtonWidgetClass, matchPatternTypeBox,
8808 + XmNmarginHeight, 0,
8809 + XmNlabelString, s1=XmStringCreateSimple(
8810 + "Context group"),
8811 + XmNmnemonic, 'g', NULL);
8812 + XmStringFree(s1);
8813 + XtAddCallback(MatchPatternDialog.mptbContextGroupW, XmNvalueChangedCallback,
8814 + matchPatTypeCB, NULL);
8815 +
8816 + MatchPatternDialog.mpdGlobalAttributesLbl = XtVaCreateManagedWidget("mpdGlobalAttributesLbl",
8817 + xmLabelGadgetClass, matchPatternsForm,
8818 + XmNlabelString, s1=XmStringCreateSimple("Global Attributes:"),
8819 + XmNmarginHeight, 0,
8820 + XmNalignment, XmALIGNMENT_BEGINNING,
8821 + XmNleftAttachment, XmATTACH_POSITION,
8822 + XmNleftPosition, LIST_RIGHT,
8823 + XmNtopAttachment, XmATTACH_WIDGET,
8824 + XmNtopOffset, BORDER,
8825 + XmNtopWidget, matchPatternTypeBox, NULL);
8826 + XmStringFree(s1);
8827 +
8828 + globalAttributesBox = XtVaCreateManagedWidget("globalAttributesBox", xmRowColumnWidgetClass,
8829 + matchPatternsForm,
8830 + XmNpacking, XmPACK_COLUMN,
8831 + XmNleftAttachment, XmATTACH_POSITION,
8832 + XmNleftPosition, LIST_RIGHT,
8833 + XmNtopAttachment, XmATTACH_WIDGET,
8834 + XmNtopWidget, MatchPatternDialog.mpdGlobalAttributesLbl, NULL);
8835 + MatchPatternDialog.gabSkipBtwStartEndW = XtVaCreateManagedWidget("gabSkipBtwStartEndW",
8836 + xmToggleButtonWidgetClass, globalAttributesBox,
8837 + XmNmarginHeight, 0,
8838 + XmNlabelString, s1=XmStringCreateSimple(
8839 + "Skip content between start / end pattern"),
8840 + XmNmnemonic, 'c', NULL);
8841 + XmStringFree(s1);
8842 + MatchPatternDialog.gabFlashW = XtVaCreateManagedWidget("gabFlashW",
8843 + xmToggleButtonWidgetClass, globalAttributesBox,
8844 + XmNset, True,
8845 + XmNmarginHeight, 0,
8846 + XmNlabelString, s1=XmStringCreateSimple(
8847 + "Flash matching pattern"),
8848 + XmNmnemonic, 'l', NULL);
8849 + XmStringFree(s1);
8850 + MatchPatternDialog.gabSyntaxBasedW = XtVaCreateManagedWidget("gabSyntaxBasedW",
8851 + xmToggleButtonWidgetClass, globalAttributesBox,
8852 + XmNset, True,
8853 + XmNmarginHeight, 0,
8854 + XmNlabelString, s1=XmStringCreateSimple(
8855 + "Syntax based"),
8856 + XmNmnemonic, 'b', NULL);
8857 + XmStringFree(s1);
8858 +
8859 + MatchPatternDialog.mpdMatchPatternNameLbl = XtVaCreateManagedWidget("mpdMatchPatternNameLbl", xmLabelGadgetClass,
8860 + matchPatternsForm,
8861 + XmNlabelString, s1=XmStringCreateSimple(MATCH_PAT_NAME_LBL_TXT),
8862 + XmNmnemonic, 'N',
8863 + XmNalignment, XmALIGNMENT_BEGINNING,
8864 + XmNleftAttachment, XmATTACH_POSITION,
8865 + XmNleftPosition, LIST_RIGHT,
8866 + XmNtopAttachment, XmATTACH_WIDGET,
8867 + XmNtopWidget, globalAttributesBox,
8868 + XmNtopOffset, BORDER, NULL);
8869 + XmStringFree(s1);
8870 +
8871 + MatchPatternDialog.mpdMatchPatternNameW = XtVaCreateManagedWidget("mpdMatchPatternNameW", xmTextWidgetClass,
8872 + matchPatternsForm,
8873 + XmNleftAttachment, XmATTACH_POSITION,
8874 + XmNleftPosition, LIST_RIGHT,
8875 + XmNtopAttachment, XmATTACH_WIDGET,
8876 + XmNtopWidget, MatchPatternDialog.mpdMatchPatternNameLbl,
8877 + XmNrightAttachment, XmATTACH_FORM,
8878 + XmNrightOffset, BORDER,
8879 + XmNbottomAttachment, XmATTACH_FORM,
8880 + XmNbottomOffset, BORDER,
8881 + NULL);
8882 + RemapDeleteKey(MatchPatternDialog.mpdMatchPatternNameW);
8883 + XtVaSetValues(MatchPatternDialog.mpdMatchPatternNameLbl, XmNuserData, MatchPatternDialog.mpdMatchPatternNameW, NULL);
8884 +
8885 + n = 0;
8886 + XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
8887 + XtSetArg(args[n], XmNleftAttachment, XmATTACH_POSITION); n++;
8888 + XtSetArg(args[n], XmNleftPosition, 1); n++;
8889 + XtSetArg(args[n], XmNrightAttachment, XmATTACH_POSITION); n++;
8890 + XtSetArg(args[n], XmNrightPosition, LIST_RIGHT-1); n++;
8891 + XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); n++;
8892 +
8893 + XtSetArg(args[n], XmNbottomOffset, BORDER); n++;
8894 + MatchPatternDialog.mpdMatchPatternNamesListW =
8895 + CreateManagedList(
8896 + matchPatternsForm, "mpdMatchPatternNamesListW",
8897 + args, n,
8898 + (void **)MatchPatternDialog.mpdTable.dmpiSequence, &MatchPatternDialog.mpdTable.dmpiNbrOfSeqElements,
8899 + MAX_NBR_MATCH_PATTERNS, 18,
8900 + getMatchPatternDisplayedCB, NULL,
8901 + setMatchPatternDisplayedCB, NULL,
8902 + freeMatchPatternItemCB);
8903 + AddDeleteConfirmCB(MatchPatternDialog.mpdMatchPatternNamesListW, deleteMatchPatternItemCB, NULL);
8904 +
8905 + XtVaSetValues(matchPatternsLbl, XmNuserData, MatchPatternDialog.mpdMatchPatternNamesListW, NULL);
8906 +
8907 + /*
8908 + * set initial default button
8909 + */
8910 + XtVaSetValues(form, XmNdefaultButton, okBtn, NULL);
8911 + XtVaSetValues(form, XmNcancelButton, closeBtn, NULL);
8912 +
8913 + /*
8914 + * handle mnemonic selection of buttons and focus to dialog
8915 + */
8916 + AddDialogMnemonicHandler(form, False);
8917 +
8918 + /*
8919 + * fill in the dialog information for the selected language mode
8920 + */
8921 + SetLangModeMenu(MatchPatternDialog.mpdLmOptMenu, MatchPatternDialog.mpdLangModeName);
8922 +
8923 + /*
8924 + * realize all of the widgets in the new dialog
8925 + */
8926 + RealizeWithoutForcingPosition(MatchPatternDialog.mpdShell);
8927 +}
8928 +
8929 +/*
8930 +** Modify match pattern dialog depending on showing a string pattern
8931 +** or a context group.
8932 +*/
8933 +static void setDialogType(int dialogShowsStringPattern)
8934 +{
8935 + char *matchPatternNameText;
8936 + char *strPatCxtGrpListText;
8937 + XmString s1;
8938 + int regularExpression =
8939 + XmToggleButtonGetState(MatchPatternDialog.sabRegularExpressionW);
8940 +
8941 + /*
8942 + * check, if dialog mode needs to be switched
8943 + */
8944 + if (MatchPatternDialog.mpdStringPatternIsDisplayed == dialogShowsStringPattern)
8945 + {
8946 + return;
8947 + }
8948 +
8949 + if (dialogShowsStringPattern)
8950 + {
8951 + matchPatternNameText = MATCH_PAT_NAME_LBL_TXT;
8952 + strPatCxtGrpListText = STRING_PATTERNS_LBL_TXT;
8953 + }
8954 + else
8955 + {
8956 + matchPatternNameText = "Context Group Name";
8957 + strPatCxtGrpListText = "Related Sub-Patterns";
8958 + }
8959 +
8960 + XtSetSensitive(MatchPatternDialog.mpdGlobalAttributesLbl, dialogShowsStringPattern);
8961 + XtSetSensitive(MatchPatternDialog.gabSkipBtwStartEndW, dialogShowsStringPattern);
8962 + XtSetSensitive(MatchPatternDialog.gabFlashW, dialogShowsStringPattern);
8963 + XtSetSensitive(MatchPatternDialog.gabSyntaxBasedW, dialogShowsStringPattern);
8964 +
8965 + XtSetSensitive(MatchPatternDialog.mpdStringPatternTypeLbl, dialogShowsStringPattern);
8966 + XtSetSensitive(MatchPatternDialog.sptStartW, dialogShowsStringPattern);
8967 + XtSetSensitive(MatchPatternDialog.sptMiddleW, dialogShowsStringPattern);
8968 + XtSetSensitive(MatchPatternDialog.sptEndW, dialogShowsStringPattern);
8969 +
8970 + setSensitiveWordBoundaryBox( dialogShowsStringPattern && !regularExpression );
8971 +
8972 + XtSetSensitive(MatchPatternDialog.mpdStringAttributesLbl, dialogShowsStringPattern);
8973 + XtSetSensitive(MatchPatternDialog.sabCaseSensitiveW, dialogShowsStringPattern);
8974 + XtSetSensitive(MatchPatternDialog.sabRegularExpressionW, dialogShowsStringPattern);
8975 +
8976 + XtSetSensitive(MatchPatternDialog.mpdStringPatternLbl, dialogShowsStringPattern);
8977 + XtSetSensitive(MatchPatternDialog.mpdStringPatternW, dialogShowsStringPattern);
8978 +
8979 + XtSetSensitive(MatchPatternDialog.mpdSubPatNamesLbl, !dialogShowsStringPattern);
8980 + XtSetSensitive(MatchPatternDialog.mpdSubPatNamesOptMenu, !dialogShowsStringPattern);
8981 +
8982 + XtVaSetValues(
8983 + MatchPatternDialog.mpdMatchPatternNameLbl,
8984 + XmNlabelString, s1=XmStringCreateSimple(matchPatternNameText),
8985 + NULL);
8986 + XmStringFree(s1);
8987 +
8988 + XtVaSetValues(
8989 + MatchPatternDialog.mpdStringPatternsLbl,
8990 + XmNlabelString, s1=XmStringCreateSimple(strPatCxtGrpListText),
8991 + NULL);
8992 + XmStringFree(s1);
8993 +
8994 + MatchPatternDialog.mpdStringPatternIsDisplayed = dialogShowsStringPattern;
8995 +}
8996 +
8997 +static void setSensitiveWordBoundaryBox(int enable)
8998 +{
8999 + XtSetSensitive(MatchPatternDialog.mpdWordBoundaryLbl, enable);
9000 + XtSetSensitive(MatchPatternDialog.wbbBothW , enable);
9001 + XtSetSensitive(MatchPatternDialog.wbbLeftW , enable);
9002 + XtSetSensitive(MatchPatternDialog.wbbRightW, enable);
9003 + XtSetSensitive(MatchPatternDialog.wbbNoneW , enable);
9004 +}
9005 +
9006 +static void matchPatternLangModeCB(Widget w, XtPointer clientData, XtPointer callData)
9007 +{
9008 + char *modeName;
9009 + StringMatchTable *oldTable, *newTable;
9010 + StringMatchTable emptyTable = {"", NULL, NULL, NULL, NULL, 0, NULL, 0, NULL};
9011 + StringMatchTable *table;
9012 + DMPTranslationResult translResult;
9013 + int resp;
9014 +
9015 + /*
9016 + * Get the newly selected mode name. If it's the same, do nothing
9017 + */
9018 + XtVaGetValues(w, XmNuserData, &modeName, NULL);
9019 + if (!strcmp(modeName, MatchPatternDialog.mpdLangModeName))
9020 + return;
9021 +
9022 + /*
9023 + * Look up the original version of the patterns being edited
9024 + */
9025 + oldTable = (StringMatchTable *)FindStringMatchTable(MatchPatternDialog.mpdLangModeName);
9026 + if (oldTable == NULL)
9027 + oldTable = &emptyTable;
9028 +
9029 + /*
9030 + * Get the current information displayed by the dialog. If it's bad,
9031 + * give the user the chance to throw it out or go back and fix it. If
9032 + * it has changed, give the user the chance to apply discard or cancel.
9033 + */
9034 + newTable = getDialogStringMatchTable(&translResult);
9035 +
9036 + if (translResult == DMPTR_EMPTY)
9037 + {
9038 + newTable = &emptyTable;
9039 + }
9040 +
9041 + if (newTable == NULL)
9042 + {
9043 + if (DialogF(
9044 + DF_WARN, MatchPatternDialog.mpdShell, 2,
9045 + "Incomplete Matching Patterns for Language Mode",
9046 + "Discard incomplete entry for language mode '%s'?",
9047 + "Keep", "Discard",
9048 + MatchPatternDialog.mpdLangModeName) == 1)
9049 + {
9050 + SetLangModeMenu(
9051 + MatchPatternDialog.mpdLmOptMenu,
9052 + MatchPatternDialog.mpdLangModeName);
9053 +
9054 + return;
9055 + }
9056 + }
9057 + else if (stringMatchTableDiffer(oldTable, newTable))
9058 + {
9059 + if (newTable == &emptyTable)
9060 + newTable = NULL;
9061 +
9062 + resp =
9063 + DialogF(
9064 + DF_WARN, MatchPatternDialog.mpdShell, 3,
9065 + "Change Language Mode",
9066 + "Apply changes for language mode '%s'?",
9067 + "Apply Changes", "Discard Changes", "Cancel",
9068 + MatchPatternDialog.mpdLangModeName);
9069 +
9070 + if (resp == 3)
9071 + {
9072 + SetLangModeMenu(
9073 + MatchPatternDialog.mpdLmOptMenu,
9074 + MatchPatternDialog.mpdLangModeName);
9075 +
9076 + freeStringMatchTable( newTable );
9077 +
9078 + return;
9079 + }
9080 + else if (resp == 1)
9081 + {
9082 + updateStringMatchTable( newTable );
9083 +
9084 + /*
9085 + * Don't free the new table due to it's stored in MatchTables now
9086 + */
9087 + newTable = NULL;
9088 + }
9089 + }
9090 +
9091 + if (newTable != NULL && newTable != &emptyTable)
9092 + freeStringMatchTable(newTable);
9093 +
9094 + /*
9095 + * Free the old dialog information
9096 + */
9097 + freeVariableDialogData(DISCARD_LANGUAGE_MODE);
9098 +
9099 + /*
9100 + * Fill the dialog with the new language mode information
9101 + */
9102 + MatchPatternDialog.mpdLangModeName = XtNewString(modeName);
9103 +
9104 + /*
9105 + * Find the associated matching pattern table to edit
9106 + */
9107 + table = (StringMatchTable *)FindStringMatchTable(MatchPatternDialog.mpdLangModeName);
9108 +
9109 + /*
9110 + * Copy the list of patterns to one that the user can freely edit
9111 + */
9112 + copyStringMatchTableForDialog( table, &MatchPatternDialog.mpdTable );
9113 +
9114 + /*
9115 + * Update dialog fields
9116 + */
9117 + ChangeManagedListData(MatchPatternDialog.mpdMatchPatternNamesListW);
9118 + ChangeManagedListData(MatchPatternDialog.mpdStringPatternsListW);
9119 +}
9120 +
9121 +static void pmLanguageModeDialogCB(Widget w, XtPointer clientData, XtPointer callData)
9122 +{
9123 + EditLanguageModes();
9124 +}
9125 +
9126 +/*
9127 +** If a matching pattern dialog is up, ask to have the option menu for
9128 +** chosing language mode updated (via a call to CreateLanguageModeMenu)
9129 +*/
9130 +void UpdateLanguageModeMenuMatchPattern(void)
9131 +{
9132 + Widget oldMenu;
9133 +
9134 + if (MatchPatternDialog.mpdShell == NULL)
9135 + return;
9136 +
9137 + oldMenu = MatchPatternDialog.mpdLmPulldown;
9138 + /*
9139 + * don't include "PLAIN" (4th parameter) in LM menu
9140 + */
9141 + MatchPatternDialog.mpdLmPulldown = CreateLanguageModeMenu(
9142 + XtParent(XtParent(oldMenu)), matchPatternLangModeCB, NULL, False);
9143 + XtVaSetValues(XmOptionButtonGadget(MatchPatternDialog.mpdLmOptMenu),
9144 + XmNsubMenuId, MatchPatternDialog.mpdLmPulldown, NULL);
9145 + SetLangModeMenu(MatchPatternDialog.mpdLmOptMenu, MatchPatternDialog.mpdLangModeName);
9146 +
9147 + XtDestroyWidget(oldMenu);
9148 +}
9149 +
9150 +static void *getMatchPatternDisplayedCB(void *oldItem, int explicitRequest, int *abort,
9151 + void *cbArg)
9152 +{
9153 + DialogMatchPatternSequenceElement *newSeq;
9154 +
9155 + /*
9156 + * If the dialog is currently displaying the "new" entry and the
9157 + * fields are empty, that's just fine
9158 + */
9159 + if (oldItem == NULL && matchPatternDialogEmpty())
9160 + return NULL;
9161 +
9162 + /*
9163 + * Read string patterns / sub-pattern names area first
9164 + */
9165 + UpdateManagedList(MatchPatternDialog.mpdStringPatternsListW, True);
9166 +
9167 + /*
9168 + * If there are no problems reading the data, just return it
9169 + */
9170 + newSeq = readMatchPatternFields(True);
9171 + if (newSeq != NULL)
9172 + return (void *)newSeq;
9173 +
9174 + /*
9175 + * If there are problems, and the user didn't ask for the fields to be
9176 + * read, give more warning
9177 + */
9178 + if (!explicitRequest)
9179 + {
9180 + if (DialogF(
9181 + DF_WARN, MatchPatternDialog.mpdShell, 2,
9182 + "Discard Matching Pattern Entry",
9183 + "Discard incomplete entry\nfor current matching pattern?",
9184 + "Keep", "Discard") == 2)
9185 + {
9186 + return oldItem == NULL
9187 + ? NULL
9188 + : (void *)copyDialogSequenceElement(
9189 + (DialogMatchPatternSequenceElement *)oldItem);
9190 + }
9191 + }
9192 +
9193 + /*
9194 + * read data again without "silent" mode to display warning
9195 + */
9196 + newSeq = readMatchPatternFields(False);
9197 + *abort = True;
9198 +
9199 + return NULL;
9200 +}
9201 +
9202 +static void setMatchPatternDisplayedCB(void *item, void *cbArg)
9203 +{
9204 + DialogMatchPatternSequenceElement *seqElement;
9205 + DialogMatchPatternTableElement *element;
9206 + DialogMatchPatternGroupElement *group;
9207 + int isGroup;
9208 +
9209 + seqElement = (DialogMatchPatternSequenceElement *)item;
9210 +
9211 + MatchPatternDialog.currentDmptSeqElement = seqElement;
9212 +
9213 + if (item == NULL)
9214 + {
9215 + MatchPatternDialog.currentDmptElement = NULL;
9216 + MatchPatternDialog.currentDmptGroup = NULL;
9217 +
9218 + XmTextSetString(MatchPatternDialog.mpdMatchPatternNameW, "");
9219 + RadioButtonChangeState(MatchPatternDialog.mptbIndividualW, True, True);
9220 + RadioButtonChangeState(MatchPatternDialog.gabSkipBtwStartEndW, False, False);
9221 + RadioButtonChangeState(MatchPatternDialog.gabFlashW, True, False);
9222 + RadioButtonChangeState(MatchPatternDialog.gabSyntaxBasedW, True, False);
9223 +
9224 + freeDialogStringPatterns(
9225 + &MatchPatternDialog.currentStringPatterns);
9226 +
9227 + ChangeManagedListData(MatchPatternDialog.mpdStringPatternsListW);
9228 +
9229 + setDialogType( STRING_PATTERN_DIALOG );
9230 + }
9231 + else
9232 + {
9233 + isGroup = (seqElement->dmpseType == MPT_GROUP);
9234 +
9235 + XmTextSetString(MatchPatternDialog.mpdMatchPatternNameW, seqElement->dmpseName);
9236 +
9237 + if (seqElement->dmpseType == MPT_INDIVIDUAL)
9238 + RadioButtonChangeState(MatchPatternDialog.mptbIndividualW, True, True);
9239 + else if (seqElement->dmpseType == MPT_SUB)
9240 + RadioButtonChangeState(MatchPatternDialog.mptbSubPatternW, True, True);
9241 + else
9242 + RadioButtonChangeState(MatchPatternDialog.mptbContextGroupW, True, True);
9243 +
9244 + freeDialogStringPatterns(
9245 + &MatchPatternDialog.currentStringPatterns);
9246 +
9247 + if (isGroup)
9248 + {
9249 + group = (DialogMatchPatternGroupElement *)seqElement->dmpsePtr;
9250 + MatchPatternDialog.currentDmptElement = NULL;
9251 + MatchPatternDialog.currentDmptGroup = group;
9252 +
9253 + copyDialogPatternNamesFromGroup(
9254 + group,
9255 + &MatchPatternDialog.currentStringPatterns);
9256 + }
9257 + else
9258 + {
9259 + element = (DialogMatchPatternTableElement *)seqElement->dmpsePtr;
9260 + MatchPatternDialog.currentDmptElement = element;
9261 + MatchPatternDialog.currentDmptGroup = NULL;
9262 +
9263 + RadioButtonChangeState(
9264 + MatchPatternDialog.gabSkipBtwStartEndW,
9265 + element->dmpteSkipBtwnStartEnd,
9266 + False);
9267 + RadioButtonChangeState(
9268 + MatchPatternDialog.gabFlashW,
9269 + element->dmpteFlash,
9270 + False);
9271 + RadioButtonChangeState(
9272 + MatchPatternDialog.gabSyntaxBasedW,
9273 + !element->dmpteIgnoreHighLightInfo,
9274 + False);
9275 +
9276 + copyDialogStringPatternsFromTable(
9277 + element,
9278 + &MatchPatternDialog.currentStringPatterns);
9279 + }
9280 +
9281 + setDialogType( !isGroup );
9282 +
9283 + ChangeManagedListData(MatchPatternDialog.mpdStringPatternsListW);
9284 + }
9285 +}
9286 +
9287 +static void freeMatchPatternItemCB(void *item)
9288 +{
9289 + freeDialogSequenceElement((DialogMatchPatternSequenceElement *)item);
9290 +}
9291 +
9292 +/*
9293 +** Use "delete confirm" to delete matching pattern name from
9294 +** any group of this matching pattern set, in case of sub-pattern.
9295 +** Always confirm the delete.
9296 +*/
9297 +static int deleteMatchPatternItemCB(int itemIndex, void *cbArg)
9298 +{
9299 + DialogMatchPatternSequenceElement *seqElement;
9300 +
9301 + seqElement = MatchPatternDialog.mpdTable.dmpiSequence[itemIndex];
9302 +
9303 + if (seqElement->dmpseType == MPT_SUB)
9304 + {
9305 + removeMatchPatternFromAllGroups( seqElement->dmpseName );
9306 + }
9307 +
9308 + return True;
9309 +}
9310 +
9311 +static void *getStringPatternDisplayedCB(void *oldItem, int explicitRequest, int *abort,
9312 + void *cbArg)
9313 +{
9314 + DialogStringPatternElement *newPat;
9315 + int isRelatedToGroup = !MatchPatternDialog.mpdStringPatternIsDisplayed;
9316 +
9317 + /*
9318 + * If the string pattern frame is currently displaying the "new" entry and the
9319 + * fields are empty, that's just fine
9320 + */
9321 + if (oldItem == NULL && stringPatternFieldsEmpty(isRelatedToGroup))
9322 + return NULL;
9323 +
9324 + /*
9325 + * If there are no problems reading the data, just return it
9326 + */
9327 + newPat = readStringPatternFrameFields(True);
9328 + if (newPat != NULL)
9329 + return (void *)newPat;
9330 +
9331 + /*
9332 + * If there are problems, and the user didn't ask for the fields to be
9333 + * read, give more warning
9334 + */
9335 +
9336 + if (!explicitRequest)
9337 + {
9338 + if (DialogF(
9339 + DF_WARN, MatchPatternDialog.mpdShell, 2,
9340 + "Discard String Pattern Entry",
9341 + "Discard incomplete entry\nfor current string pattern?",
9342 + "Keep", "Discard") == 2)
9343 + {
9344 + return oldItem == NULL
9345 + ? NULL
9346 + : (void *)copyDialogStringPatternElement(
9347 + (DialogStringPatternElement *)oldItem);
9348 + }
9349 + }
9350 +
9351 + /*
9352 + * read data again without "silent" mode to display warning
9353 + */
9354 + newPat = readStringPatternFrameFields(False);
9355 + *abort = True;
9356 +
9357 + return NULL;
9358 +}
9359 +
9360 +static void setStringPatternDisplayedCB(void *item, void *cbArg)
9361 +{
9362 + DialogStringPatternElement *element = (DialogStringPatternElement *)item;
9363 + PatternElementKind peKind;
9364 + PatternWordBoundary wordBoundary;
9365 + int isRelatedToGroup = !MatchPatternDialog.mpdStringPatternIsDisplayed;
9366 +
9367 + if (item == NULL)
9368 + {
9369 + if (isRelatedToGroup)
9370 + {
9371 + updateSubPatternNameMenu(NULL, False);
9372 + }
9373 + else
9374 + {
9375 + XmTextSetString(MatchPatternDialog.mpdStringPatternW, "");
9376 +
9377 + setSensitiveWordBoundaryBox( True );
9378 +
9379 + RadioButtonChangeState(MatchPatternDialog.wbbBothW, True, True);
9380 +
9381 + /*
9382 + * type of "new" string pattern:
9383 + * preset "start", if no string pattern exists at all;
9384 + * else select "end"
9385 + */
9386 + if (MatchPatternDialog.currentStringPatterns.dspNumberOfPatterns == 0)
9387 + RadioButtonChangeState(MatchPatternDialog.sptStartW, True, True);
9388 + else
9389 + RadioButtonChangeState(MatchPatternDialog.sptEndW, True, True);
9390 +
9391 + RadioButtonChangeState(MatchPatternDialog.sabCaseSensitiveW, True, False);
9392 + RadioButtonChangeState(MatchPatternDialog.sabRegularExpressionW, False, False);
9393 + }
9394 + }
9395 + else
9396 + {
9397 + if (isRelatedToGroup)
9398 + {
9399 + updateSubPatternNameMenu(element->dspeText, False);
9400 + }
9401 + else
9402 + {
9403 + XmTextSetString(MatchPatternDialog.mpdStringPatternW, element->dspeText);
9404 +
9405 + peKind = element->dspeKind;
9406 + wordBoundary = element->dspeWordBoundary;
9407 +
9408 + if (peKind == PEK_START)
9409 + RadioButtonChangeState(MatchPatternDialog.sptStartW, True, True);
9410 + else if (peKind == PEK_MIDDLE)
9411 + RadioButtonChangeState(MatchPatternDialog.sptMiddleW, True, True);
9412 + else
9413 + RadioButtonChangeState(MatchPatternDialog.sptEndW, True, True);
9414 +
9415 + if (wordBoundary == PWB_BOTH)
9416 + RadioButtonChangeState(MatchPatternDialog.wbbBothW, True, True);
9417 + else if (wordBoundary == PWB_LEFT)
9418 + RadioButtonChangeState(MatchPatternDialog.wbbLeftW, True, True);
9419 + else if (wordBoundary == PWB_RIGHT)
9420 + RadioButtonChangeState(MatchPatternDialog.wbbRightW, True, True);
9421 + else
9422 + RadioButtonChangeState(MatchPatternDialog.wbbNoneW, True, True);
9423 +
9424 + RadioButtonChangeState(
9425 + MatchPatternDialog.sabCaseSensitiveW,
9426 + !element->dspeCaseInsensitive,
9427 + False);
9428 +
9429 + RadioButtonChangeState(
9430 + MatchPatternDialog.sabRegularExpressionW,
9431 + element->dspeRegularExpression,
9432 + False);
9433 +
9434 + setSensitiveWordBoundaryBox( !element->dspeRegularExpression );
9435 + }
9436 + }
9437 +}
9438 +
9439 +static void freeStringPatternItemCB(void *item)
9440 +{
9441 + DialogStringPatternElement *patElement;
9442 +
9443 + patElement = (DialogStringPatternElement *)item;
9444 +
9445 + freeDialogStringPatternElement(patElement);
9446 +}
9447 +
9448 +static void destroyCB(Widget w, XtPointer clientData, XtPointer callData)
9449 +{
9450 + freeVariableDialogData(DISCARD_LANGUAGE_MODE);
9451 +
9452 + MatchPatternDialog.mpdShell = NULL;
9453 +}
9454 +
9455 +static void okCB(Widget w, XtPointer clientData, XtPointer callData)
9456 +{
9457 + /*
9458 + * change the matching pattern
9459 + */
9460 + if (!getAndUpdateStringMatchTable())
9461 + return;
9462 +
9463 + /*
9464 + * pop down and destroy the dialog
9465 + */
9466 + XtDestroyWidget(MatchPatternDialog.mpdShell);
9467 +}
9468 +
9469 +static void applyCB(Widget w, XtPointer clientData, XtPointer callData)
9470 +{
9471 + /*
9472 + * change the matching pattern
9473 + */
9474 + getAndUpdateStringMatchTable();
9475 +}
9476 +
9477 +static void checkCB(Widget w, XtPointer clientData, XtPointer callData)
9478 +{
9479 + StringMatchTable *newTable;
9480 + DMPTranslationResult translResult;
9481 +
9482 + /*
9483 + * Get the current information displayed by the dialog.
9484 + * If a new table is available, then the test is passed successfully.
9485 + */
9486 + newTable = getDialogStringMatchTable(&translResult);
9487 +
9488 + if (newTable != NULL)
9489 + {
9490 + DialogF(
9491 + DF_INF, MatchPatternDialog.mpdShell, 1,
9492 + "Matching Patterns Checked",
9493 + "Matching Patterns checked without error",
9494 + "OK");
9495 +
9496 + freeStringMatchTable(newTable);
9497 + }
9498 +}
9499 +
9500 +static void restoreCB(Widget w, XtPointer clientData, XtPointer callData)
9501 +{
9502 + StringMatchTable *defaultTable;
9503 +
9504 + defaultTable = readDefaultStringMatchTable(MatchPatternDialog.mpdLangModeName);
9505 +
9506 + if (defaultTable == NULL)
9507 + {
9508 + DialogF(
9509 + DF_WARN, MatchPatternDialog.mpdShell, 1,
9510 + "No Default Matching Pattern",
9511 + "There is no default matching pattern set\nfor language mode %s",
9512 + "OK",
9513 + MatchPatternDialog.mpdLangModeName);
9514 +
9515 + return;
9516 + }
9517 +
9518 + if (DialogF(
9519 + DF_WARN, MatchPatternDialog.mpdShell, 2,
9520 + "Discard Changes",
9521 + "Are you sure you want to discard\n"
9522 + "all changes to matching patterns\n"
9523 + "for language mode %s?",
9524 + "Discard", "Cancel",
9525 + MatchPatternDialog.mpdLangModeName) == 2)
9526 + {
9527 + freeStringMatchTable(defaultTable);
9528 +
9529 + return;
9530 + }
9531 +
9532 + /*
9533 + * if a stored version of the matching pattern set exists, replace it.
9534 + * if it doesn't, add a new one.
9535 + */
9536 + updateStringMatchTable( defaultTable );
9537 +
9538 + /*
9539 + * free the old dialog information
9540 + */
9541 + freeVariableDialogData(KEEP_LANGUAGE_MODE);
9542 +
9543 + /*
9544 + * update the dialog
9545 + */
9546 + copyStringMatchTableForDialog( defaultTable, &MatchPatternDialog.mpdTable );
9547 +
9548 + ChangeManagedListData(MatchPatternDialog.mpdMatchPatternNamesListW);
9549 + ChangeManagedListData(MatchPatternDialog.mpdStringPatternsListW);
9550 +}
9551 +
9552 +static void deleteCB(Widget w, XtPointer clientData, XtPointer callData)
9553 +{
9554 + if (DialogF(
9555 + DF_WARN, MatchPatternDialog.mpdShell, 2,
9556 + "Delete Matching Patterns",
9557 + "Are you sure you want to delete\n"
9558 + "all matching patterns for\n"
9559 + "language mode %s?",
9560 + "Yes, Delete", "Cancel",
9561 + MatchPatternDialog.mpdLangModeName) == 2)
9562 + {
9563 + return;
9564 + }
9565 +
9566 + /*
9567 + * if a stored version of the matching pattern exists, delete it from the list
9568 + */
9569 + DeleteStringMatchTable(MatchPatternDialog.mpdLangModeName);
9570 +
9571 + /*
9572 + * free the old dialog information
9573 + */
9574 + freeVariableDialogData(KEEP_LANGUAGE_MODE);
9575 +
9576 + /*
9577 + * clear out the dialog
9578 + */
9579 + ChangeManagedListData(MatchPatternDialog.mpdMatchPatternNamesListW);
9580 + ChangeManagedListData(MatchPatternDialog.mpdStringPatternsListW);
9581 +}
9582 +
9583 +static void closeCB(Widget w, XtPointer clientData, XtPointer callData)
9584 +{
9585 + /*
9586 + * pop down and destroy the dialog
9587 + */
9588 + XtDestroyWidget(MatchPatternDialog.mpdShell);
9589 +}
9590 +
9591 +static void helpCB(Widget w, XtPointer clientData, XtPointer callData)
9592 +{
9593 +
9594 + Help(HELP_MATCHING_PATTERNS);
9595 +
9596 +}
9597 +
9598 +static void strPatRegExpressionCB(Widget w, XtPointer clientData, XtPointer callData)
9599 +{
9600 + int regularExpression =
9601 + XmToggleButtonGetState(MatchPatternDialog.sabRegularExpressionW);
9602 +
9603 + setSensitiveWordBoundaryBox( !regularExpression );
9604 +
9605 + if (regularExpression)
9606 + RadioButtonChangeState(MatchPatternDialog.sabCaseSensitiveW, True, False);
9607 +}
9608 +
9609 +static void matchPatTypeCB(Widget w, XtPointer clientData, XtPointer callData)
9610 +{
9611 + if (MatchPatternDialog.currentDmptSeqElement != NULL)
9612 + {
9613 + if (XmToggleButtonGetState(MatchPatternDialog.mptbContextGroupW))
9614 + {
9615 + if (MatchPatternDialog.currentDmptSeqElement->dmpseType == MPT_SUB)
9616 + {
9617 + changeExistingSubPattern("Change to Context Group");
9618 + }
9619 +
9620 + if (XmToggleButtonGetState(MatchPatternDialog.mptbContextGroupW) &&
9621 + MatchPatternDialog.currentDmptSeqElement->dmpseType != MPT_GROUP)
9622 + {
9623 + changeStringPatternToGroup();
9624 + }
9625 + }
9626 + else if (XmToggleButtonGetState(MatchPatternDialog.mptbIndividualW))
9627 + {
9628 + if (MatchPatternDialog.currentDmptSeqElement->dmpseType == MPT_SUB)
9629 + {
9630 + changeExistingSubPattern("Change to Individual Matching Pattern");
9631 + }
9632 + else if (MatchPatternDialog.currentDmptSeqElement->dmpseType == MPT_GROUP)
9633 + {
9634 + changeGroupToStringPattern("Change to Individual Matching Pattern");
9635 + }
9636 + }
9637 + else if (XmToggleButtonGetState(MatchPatternDialog.mptbSubPatternW))
9638 + {
9639 + if (MatchPatternDialog.currentDmptSeqElement->dmpseType == MPT_GROUP)
9640 + {
9641 + changeGroupToStringPattern("Change to Sub-Matching Pattern");
9642 + }
9643 + }
9644 + }
9645 +
9646 + /*
9647 + * if context group button is (still) selected, then update labels etc.
9648 + */
9649 + if (XmToggleButtonGetState(MatchPatternDialog.mptbContextGroupW))
9650 + {
9651 + setDialogType(CONTEXT_GROUP_DIALOG);
9652 + }
9653 + else
9654 + {
9655 + setDialogType(STRING_PATTERN_DIALOG);
9656 + }
9657 +
9658 + /*
9659 + * if a "new" entry is selected in matching patterns names list, then provide a
9660 + * list of all sub-pattern names
9661 + */
9662 + if (MatchPatternDialog.currentDmptSeqElement == NULL)
9663 + {
9664 + updateSubPatternNameMenu(NULL, True);
9665 + }
9666 +}
9667 +
9668 +static void changeExistingSubPattern(
9669 + char *warnTitle)
9670 +{
9671 + DialogMatchPatternGroupElement *group;
9672 + int resp;
9673 +
9674 + group =
9675 + getDialogGroupUsingMatchPattern(
9676 + MatchPatternDialog.currentDmptElement->dmpteName );
9677 +
9678 + while ( group != NULL )
9679 + {
9680 + resp =
9681 + DialogF(
9682 + DF_WARN, MatchPatternDialog.mpdShell, 3,
9683 + warnTitle,
9684 + "Sub-pattern '%s' is used at least\n"
9685 + "by context group '%s'.\n\n"
9686 + "Remove this sub-pattern from this resp. all context group(s) ?",
9687 + "No, Keep", "Yes, Remove", "Yes, Remove All",
9688 + MatchPatternDialog.currentDmptElement->dmpteName,
9689 + group->dmpgeName);
9690 +
9691 + if (resp == 1)
9692 + {
9693 + RadioButtonChangeState(MatchPatternDialog.mptbSubPatternW, True, True);
9694 +
9695 + return;
9696 + }
9697 + else if (resp == 2)
9698 + {
9699 + removeMatchPatternFromGroup(
9700 + MatchPatternDialog.currentDmptElement->dmpteName,
9701 + group);
9702 +
9703 + /*
9704 + * look for evtl. next context group holding this matching pattern
9705 + */
9706 + group =
9707 + getDialogGroupUsingMatchPattern(
9708 + MatchPatternDialog.currentDmptElement->dmpteName );
9709 + }
9710 + else
9711 + {
9712 + /*
9713 + * remove this matching pattern form all context groups
9714 + */
9715 + removeMatchPatternFromAllGroups(
9716 + MatchPatternDialog.currentDmptElement->dmpteName);
9717 +
9718 + return;
9719 + }
9720 + }
9721 +}
9722 +
9723 +static void changeStringPatternToGroup(void)
9724 +{
9725 + int resp;
9726 + int isSubPattern;
9727 +
9728 + if (MatchPatternDialog.currentStringPatterns.dspNumberOfPatterns != 0)
9729 + {
9730 + resp =
9731 + DialogF(
9732 + DF_WARN, MatchPatternDialog.mpdShell, 2,
9733 + "Change to Context Group",
9734 + "All string patterns of '%s'\n"
9735 + "need to be discarded.\n\n"
9736 + "Discard related string patterns ?",
9737 + "No, Keep", "Yes, Discard",
9738 + MatchPatternDialog.currentDmptElement->dmpteName);
9739 +
9740 + if (resp == 1)
9741 + {
9742 + isSubPattern = (MatchPatternDialog.currentDmptElement->dmpteType == MPT_SUB);
9743 +
9744 + if (isSubPattern)
9745 + RadioButtonChangeState(MatchPatternDialog.mptbSubPatternW, True, True);
9746 + else
9747 + RadioButtonChangeState(MatchPatternDialog.mptbIndividualW, True, True);
9748 +
9749 + return;
9750 + }
9751 +
9752 + /*
9753 + * remove string patterns & update dialog fields
9754 + */
9755 + freeDialogStringPatterns(&MatchPatternDialog.currentStringPatterns);
9756 +
9757 + ChangeManagedListData(MatchPatternDialog.mpdStringPatternsListW);
9758 + }
9759 +
9760 + /*
9761 + * invalidate this sub-/individual pattern
9762 + */
9763 + MatchPatternDialog.currentDmptSeqElement->dmpseValid = False;
9764 +
9765 + /*
9766 + * update sub-pattern menu due to change to context group
9767 + */
9768 + updateSubPatternNameMenu(NULL, True);
9769 +}
9770 +
9771 +static void changeGroupToStringPattern(
9772 + char *warnTitle)
9773 +{
9774 + int resp;
9775 +
9776 + if (MatchPatternDialog.currentStringPatterns.dspNumberOfPatterns == 0)
9777 + return;
9778 +
9779 + resp =
9780 + DialogF(
9781 + DF_WARN, MatchPatternDialog.mpdShell, 2,
9782 + warnTitle,
9783 + "Content of context group '%s'\n"
9784 + "needs to be discarded.\n\n"
9785 + "Discard content ?",
9786 + "No, Keep", "Yes, Discard",
9787 + MatchPatternDialog.currentDmptGroup->dmpgeName);
9788 +
9789 + if (resp == 1)
9790 + {
9791 + RadioButtonChangeState(MatchPatternDialog.mptbContextGroupW, True, True);
9792 + }
9793 + else
9794 + {
9795 + /*
9796 + * remove string patterns & update dialog fields
9797 + */
9798 + freeDialogStringPatterns(&MatchPatternDialog.currentStringPatterns);
9799 +
9800 + ChangeManagedListData(MatchPatternDialog.mpdStringPatternsListW);
9801 + }
9802 +}
9803 +
9804 +/*
9805 +** Create a pulldown menu pane with the names of the sub-patterns of
9806 +** the current matching pattern set.
9807 +*/
9808 +static Widget createSubPatternNameMenu(
9809 + Widget parent,
9810 + char *currentSubPatName,
9811 + int allSubPatterns)
9812 +{
9813 + NameList nameList;
9814 + Widget menu;
9815 + int i;
9816 +
9817 + setupSubPatternNameList(currentSubPatName, allSubPatterns, &nameList);
9818 +
9819 + menu = CreatePulldownMenu(parent, "subPatternNames", NULL, 0);
9820 +
9821 + for (i=0; i<nameList.nlNumber; i++)
9822 + {
9823 + createSubPatNameMenuEntry(menu, nameList.nlId[i]);
9824 + }
9825 +
9826 + return menu;
9827 +}
9828 +
9829 +static void setupSubPatternNameList(
9830 + char *currentSubPatName,
9831 + int allSubPatterns,
9832 + NameList *nameList)
9833 +{
9834 + int n = 0;
9835 + int i;
9836 + DialogMatchPatternSequenceElement *seq;
9837 + int isRelatedToGroup = !MatchPatternDialog.mpdStringPatternIsDisplayed;
9838 +
9839 + if (isRelatedToGroup || allSubPatterns)
9840 + {
9841 + /*
9842 + * add "none selected" (default) item
9843 + */
9844 + nameList->nlId[n ++] = SPNM_NONE_SELECTED;
9845 +
9846 + /*
9847 + * add one item for each (not assigned) sub-pattern name
9848 + */
9849 + for (i=0; i<MatchPatternDialog.mpdTable.dmpiNbrOfSeqElements; i++)
9850 + {
9851 + seq = MatchPatternDialog.mpdTable.dmpiSequence[i];
9852 +
9853 + if (seq->dmpseType == MPT_SUB &&
9854 + seq->dmpseValid &&
9855 + (allSubPatterns ||
9856 + (!isSubPatternNameInCurStrPat(seq->dmpseName) ||
9857 + (currentSubPatName != NULL &&
9858 + (strcmp(seq->dmpseName, currentSubPatName) == 0))) ))
9859 + {
9860 + nameList->nlId[n ++] = seq->dmpseName;
9861 + }
9862 + }
9863 + }
9864 + else
9865 + {
9866 + nameList->nlId[n ++] = "none available ";
9867 + }
9868 +
9869 + nameList->nlNumber = n;
9870 +}
9871 +
9872 +/*
9873 +** Create a menu entry with the names of one sub-pattern.
9874 +** XmNuserData of this item contains the sub-pattern name.
9875 +*/
9876 +static void createSubPatNameMenuEntry(
9877 + Widget menu,
9878 + char *subPatName)
9879 +{
9880 + Widget btn;
9881 + XmString s1;
9882 +
9883 + btn = XtVaCreateManagedWidget("subPattern", xmPushButtonGadgetClass,
9884 + menu,
9885 + XmNlabelString, s1=XmStringCreateSimple(subPatName),
9886 + XmNmarginHeight, 0,
9887 + XmNuserData, (void *)subPatName, NULL);
9888 + XmStringFree(s1);
9889 +}
9890 +
9891 +/*
9892 +** Set the sub-patterns menu to show a particular sub-pattern name
9893 +*/
9894 +static void setSubPatternNameMenu(
9895 + const char *subPatName)
9896 +{
9897 + int i;
9898 + Cardinal nItems;
9899 + WidgetList items;
9900 + Widget pulldown, selectedItem;
9901 + char *itemName;
9902 +
9903 + XtVaGetValues(MatchPatternDialog.mpdSubPatNamesOptMenu, XmNsubMenuId, &pulldown, NULL);
9904 + XtVaGetValues(pulldown, XmNchildren, &items, XmNnumChildren, &nItems, NULL);
9905 +
9906 + if (nItems == 0)
9907 + return;
9908 +
9909 + selectedItem = items[0];
9910 +
9911 + /*
9912 + * if no subPatName is given, then select first item of option menu
9913 + */
9914 + if (subPatName != NULL)
9915 + {
9916 + for (i=0; i<(int)nItems; i++)
9917 + {
9918 + if (items[i] != NULL && !items[i]->core.being_destroyed)
9919 + {
9920 + XtVaGetValues(items[i], XmNuserData, &itemName, NULL);
9921 + if (!strcmp(itemName, subPatName))
9922 + {
9923 + selectedItem = items[i];
9924 + break;
9925 + }
9926 + }
9927 + }
9928 + }
9929 +
9930 + XtVaSetValues(MatchPatternDialog.mpdSubPatNamesOptMenu, XmNmenuHistory, selectedItem, NULL);
9931 +}
9932 +
9933 +/*
9934 +** Update sub-pattern names menu, e.g. when a new sub-pattern is defined
9935 +*/
9936 +static void updateSubPatternNameMenu(
9937 + char *currentSubPatName,
9938 + int allSubPatterns)
9939 +{
9940 + NameList nameList;
9941 + WidgetList items;
9942 + Cardinal nItems;
9943 + int n;
9944 + XmString st1;
9945 +
9946 + setupSubPatternNameList(currentSubPatName, allSubPatterns, &nameList);
9947 +
9948 + /*
9949 + * Go thru all of the items in the sub-pattern names menu
9950 + * and rename them to match the current sub-patterns.
9951 + * Delete any extras.
9952 + */
9953 + XtVaGetValues(
9954 + MatchPatternDialog.mpdSubPatNamesPulldown,
9955 + XmNchildren, &items,
9956 + XmNnumChildren, &nItems,
9957 + NULL);
9958 +
9959 + for (n=0; n<(int)nItems; n++)
9960 + {
9961 + if (n >= nameList.nlNumber)
9962 + {
9963 + /*
9964 + * unmanaging before destroying stops parent from displaying
9965 + */
9966 + XtUnmanageChild(items[n]);
9967 + XtDestroyWidget(items[n]);
9968 + }
9969 + else
9970 + {
9971 + if (items[n] == NULL || items[n]->core.being_destroyed)
9972 + {
9973 + /*
9974 + * create a new entry (widget) if this one is not existing or
9975 + * if it is marked as to be destroyed
9976 + */
9977 + createSubPatNameMenuEntry(
9978 + MatchPatternDialog.mpdSubPatNamesPulldown, nameList.nlId[n]);
9979 + }
9980 + else
9981 + {
9982 + XtVaSetValues(
9983 + items[n],
9984 + XmNlabelString, st1=XmStringCreateSimple(nameList.nlId[n]),
9985 + XmNuserData, (void *)nameList.nlId[n],
9986 + NULL);
9987 +
9988 + XmStringFree(st1);
9989 + }
9990 + }
9991 + }
9992 +
9993 + /*
9994 + * add new items for remaining sub-patterns names
9995 + */
9996 + for (n=(int)nItems; n<nameList.nlNumber; n++)
9997 + {
9998 + createSubPatNameMenuEntry(
9999 + MatchPatternDialog.mpdSubPatNamesPulldown, nameList.nlId[n]);
10000 + }
10001 +
10002 + /*
10003 + * select entry shown in sub-pattern name option menu
10004 + */
10005 + setSubPatternNameMenu(currentSubPatName);
10006 +}
10007 +
10008 +static char *getSelectedSubPatternName(void)
10009 +{
10010 + Widget selectedItem;
10011 + char *itemName;
10012 +
10013 + XtVaGetValues(MatchPatternDialog.mpdSubPatNamesOptMenu, XmNmenuHistory, &selectedItem, NULL);
10014 + XtVaGetValues(selectedItem, XmNuserData, &itemName, NULL);
10015 +
10016 + return itemName;
10017 +}
10018 +
10019 +static int isSubPatternNameInCurStrPat(
10020 + char *subPatName)
10021 +{
10022 + int i;
10023 + DialogStringPatterns *curPatNames = &MatchPatternDialog.currentStringPatterns;
10024 +
10025 + for (i=0; i<curPatNames->dspNumberOfPatterns; i++)
10026 + {
10027 + if (strcmp(curPatNames->dspElements[i]->dspeText, subPatName) == 0)
10028 + return True;
10029 + }
10030 +
10031 + return False;
10032 +}
10033 +
10034 +/*
10035 +** Read the matching pattern fields of the matching pattern dialog and produce an
10036 +** allocated DialogMatchPatternSequenceElement structure reflecting the contents.
10037 +** Pop up dialogs telling the user what's wrong (Passing "silent" as True,
10038 +** suppresses these dialogs).
10039 +** Returns NULL on error.
10040 +*/
10041 +static DialogMatchPatternSequenceElement *readMatchPatternFields(int silent)
10042 +{
10043 + int isGroup;
10044 + char *name;
10045 + char *nameLabel;
10046 + char *nameTitle;
10047 + char *contentTitle;
10048 + char *contentWarningText;
10049 + DialogMatchPatternSequenceElement *newSeq;
10050 + DialogMatchPatternTableElement *newElement;
10051 + DialogMatchPatternGroupElement *newGroup;
10052 +
10053 + if (XmToggleButtonGetState(MatchPatternDialog.mptbContextGroupW))
10054 + {
10055 + nameLabel = "context group name";
10056 + nameTitle = "Context Group Name";
10057 + contentTitle = "Context Group Content";
10058 + contentWarningText = "Please assign min. 1\nsub-pattern";
10059 + isGroup = True;
10060 + }
10061 + else
10062 + {
10063 + nameLabel = "matching pattern name";
10064 + nameTitle = "Matching Pattern Name";
10065 + contentTitle = "Matching Pattern Content";
10066 + contentWarningText = "Please specify min. 1\nstring pattern";
10067 + isGroup = False;
10068 + }
10069 +
10070 + name =
10071 + ReadSymbolicFieldTextWidget(
10072 + MatchPatternDialog.mpdMatchPatternNameW,
10073 + nameLabel,
10074 + silent);
10075 +
10076 + if (name == NULL)
10077 + {
10078 + return NULL;
10079 + }
10080 + else if (*name == '\0')
10081 + {
10082 + if (!silent)
10083 + {
10084 + DialogF(
10085 + DF_WARN, MatchPatternDialog.mpdShell, 1,
10086 + nameTitle,
10087 + "Please specify a valid name",
10088 + "OK");
10089 + XmProcessTraversal(MatchPatternDialog.mpdMatchPatternNameW, XmTRAVERSE_CURRENT);
10090 + }
10091 + XtFree(name);
10092 + return NULL;
10093 + }
10094 +
10095 + if (MatchPatternDialog.currentStringPatterns.dspNumberOfPatterns == 0)
10096 + {
10097 + if (!silent)
10098 + {
10099 + DialogF(
10100 + DF_WARN, MatchPatternDialog.mpdShell, 1,
10101 + contentTitle,
10102 + contentWarningText,
10103 + "OK");
10104 + }
10105 + XtFree(name);
10106 + return NULL;
10107 + }
10108 + else
10109 + {
10110 + if (!isGroup &&
10111 + !isStartPatternElementAvailable(&MatchPatternDialog.currentStringPatterns))
10112 + {
10113 + if (!silent)
10114 + {
10115 + DialogF(
10116 + DF_WARN, MatchPatternDialog.mpdShell, 1,
10117 + contentTitle,
10118 + "Please specify min. 1 string pattern\nof type 'start'",
10119 + "OK");
10120 + }
10121 + XtFree(name);
10122 + return NULL;
10123 + }
10124 + }
10125 +
10126 + if (MatchPatternDialog.currentDmptElement != NULL &&
10127 + MatchPatternDialog.currentDmptElement->dmpteType == MPT_SUB &&
10128 + strcmp(MatchPatternDialog.currentDmptElement->dmpteName, name) != 0)
10129 + {
10130 + renameMatchPatternInAllGroups(
10131 + MatchPatternDialog.currentDmptElement->dmpteName,
10132 + name);
10133 + }
10134 +
10135 + newSeq =
10136 + (DialogMatchPatternSequenceElement *)XtMalloc(sizeof(DialogMatchPatternSequenceElement));
10137 +
10138 + newSeq->dmpseName = name;
10139 + newSeq->dmpseValid = True;
10140 +
10141 + if (isGroup)
10142 + {
10143 + newSeq->dmpseType = MPT_GROUP;
10144 +
10145 + newGroup =
10146 + (DialogMatchPatternGroupElement *)XtMalloc(sizeof(DialogMatchPatternGroupElement));
10147 +
10148 + newGroup->dmpgeName = XtNewString(name);
10149 +
10150 + copyDialogPatternNamesToGroup(
10151 + &MatchPatternDialog.currentStringPatterns,
10152 + newGroup);
10153 +
10154 + newSeq->dmpsePtr = (void *)newGroup;
10155 + }
10156 + else
10157 + {
10158 + if (XmToggleButtonGetState(MatchPatternDialog.mptbIndividualW))
10159 + newSeq->dmpseType = MPT_INDIVIDUAL;
10160 + else
10161 + newSeq->dmpseType = MPT_SUB;
10162 +
10163 + newElement =
10164 + (DialogMatchPatternTableElement *)XtMalloc(sizeof(DialogMatchPatternTableElement));
10165 +
10166 + newElement->dmpteName = XtNewString(name);
10167 + newElement->dmpteType = newSeq->dmpseType;
10168 +
10169 + newElement->dmpteSkipBtwnStartEnd =
10170 + XmToggleButtonGetState(MatchPatternDialog.gabSkipBtwStartEndW);
10171 +
10172 + newElement->dmpteFlash =
10173 + XmToggleButtonGetState(MatchPatternDialog.gabFlashW);
10174 +
10175 + newElement->dmpteIgnoreHighLightInfo =
10176 + !XmToggleButtonGetState(MatchPatternDialog.gabSyntaxBasedW);
10177 +
10178 + copyDialogStringPatterns(
10179 + &MatchPatternDialog.currentStringPatterns,
10180 + &newElement->dmptePatterns);
10181 +
10182 + newSeq->dmpsePtr = (void *)newElement;
10183 + }
10184 +
10185 + return newSeq;
10186 +}
10187 +
10188 +/*
10189 +** Check, if min. 1 string pattern of type 'start' is
10190 +** available within dialog.
10191 +** Returns True, if min. 1 start string pattern is
10192 +** populated in dialog.
10193 +*/
10194 +static int isStartPatternElementAvailable(
10195 + DialogStringPatterns *dialogPatterns)
10196 +{
10197 + int i;
10198 +
10199 + for (i=0; i < dialogPatterns->dspNumberOfPatterns; i++)
10200 + {
10201 + if (dialogPatterns->dspElements[i]->dspeKind == PEK_START)
10202 + return True;
10203 + }
10204 +
10205 + return False;
10206 +}
10207 +
10208 +/*
10209 +** Read the string pattern fields of the string pattern frame and produce an
10210 +** allocated DialogStringPatternElement structure reflecting the contents.
10211 +** Pop up dialogs telling the user what's wrong (Passing "silent" as True,
10212 +** suppresses these dialogs).
10213 +** Returns NULL on error.
10214 +*/
10215 +static DialogStringPatternElement *readStringPatternFrameFields(int silent)
10216 +{
10217 + char *stringPatText;
10218 + DialogStringPatternElement *newPatElement;
10219 + int isRelatedToGroup = !MatchPatternDialog.mpdStringPatternIsDisplayed;
10220 +
10221 + if (isRelatedToGroup)
10222 + {
10223 + stringPatText = getSelectedSubPatternName();
10224 + if (strcmp(stringPatText, SPNM_NONE_SELECTED) == 0)
10225 + {
10226 + return NULL;
10227 + }
10228 +
10229 + stringPatText = XtNewString(stringPatText);
10230 + }
10231 + else
10232 + {
10233 + stringPatText =
10234 + XmTextGetString(MatchPatternDialog.mpdStringPatternW);
10235 +
10236 + if (stringPatText == NULL)
10237 + {
10238 + return NULL;
10239 + }
10240 + else if (*stringPatText == '\0')
10241 + {
10242 + if (!silent)
10243 + {
10244 + DialogF(
10245 + DF_WARN, MatchPatternDialog.mpdShell, 1,
10246 + "String Pattern",
10247 + "Please specify string\npattern content",
10248 + "OK");
10249 + XmProcessTraversal(MatchPatternDialog.mpdStringPatternW, XmTRAVERSE_CURRENT);
10250 + }
10251 + XtFree(stringPatText);
10252 + return NULL;
10253 + }
10254 + }
10255 +
10256 + newPatElement = (DialogStringPatternElement *)XtMalloc(sizeof(DialogStringPatternElement));
10257 +
10258 + newPatElement->dspeText = stringPatText;
10259 +
10260 + if (isRelatedToGroup)
10261 + {
10262 + newPatElement->dspeKind = PEK_START;
10263 + newPatElement->dspeWordBoundary = PWB_NONE;
10264 + newPatElement->dspeCaseInsensitive = False;
10265 + newPatElement->dspeRegularExpression = False;
10266 + }
10267 + else
10268 + {
10269 + newPatElement->dspeRegularExpression =
10270 + XmToggleButtonGetState(MatchPatternDialog.sabRegularExpressionW);
10271 +
10272 + if (XmToggleButtonGetState(MatchPatternDialog.sptStartW))
10273 + newPatElement->dspeKind = PEK_START;
10274 + else if (XmToggleButtonGetState(MatchPatternDialog.sptMiddleW))
10275 + newPatElement->dspeKind = PEK_MIDDLE;
10276 + else
10277 + newPatElement->dspeKind = PEK_END;
10278 +
10279 + if (newPatElement->dspeRegularExpression)
10280 + newPatElement->dspeWordBoundary = PWB_NONE;
10281 + else if (XmToggleButtonGetState(MatchPatternDialog.wbbBothW))
10282 + newPatElement->dspeWordBoundary = PWB_BOTH;
10283 + else if (XmToggleButtonGetState(MatchPatternDialog.wbbLeftW))
10284 + newPatElement->dspeWordBoundary = PWB_LEFT;
10285 + else if (XmToggleButtonGetState(MatchPatternDialog.wbbRightW))
10286 + newPatElement->dspeWordBoundary = PWB_RIGHT;
10287 + else
10288 + newPatElement->dspeWordBoundary = PWB_NONE;
10289 +
10290 + newPatElement->dspeCaseInsensitive =
10291 + !XmToggleButtonGetState(MatchPatternDialog.sabCaseSensitiveW);
10292 + }
10293 +
10294 + return newPatElement;
10295 +}
10296 +
10297 +/*
10298 +** Returns true if the pattern fields of the matching pattern dialog are set to
10299 +** the default ("New" pattern) state.
10300 +*/
10301 +static int matchPatternDialogEmpty(void)
10302 +{
10303 + return
10304 + TextWidgetIsBlank(MatchPatternDialog.mpdMatchPatternNameW) &&
10305 + XmToggleButtonGetState(MatchPatternDialog.mptbIndividualW) &&
10306 + XmToggleButtonGetState(MatchPatternDialog.gabFlashW) &&
10307 + XmToggleButtonGetState(MatchPatternDialog.gabSyntaxBasedW) &&
10308 + stringPatternFrameEmpty();
10309 +}
10310 +
10311 +/*
10312 +** Returns true if the string pattern frame of the matching pattern dialog is set to
10313 +** the default state.
10314 +*/
10315 +static int stringPatternFrameEmpty(void)
10316 +{
10317 + return
10318 + stringPatternFieldsEmpty(False) &&
10319 + MatchPatternDialog.currentStringPatterns.dspNumberOfPatterns == 0;
10320 +}
10321 +
10322 +/*
10323 +** Returns true if the string pattern fields of the string pattern frame are set to
10324 +** the default state.
10325 +*/
10326 +static int stringPatternFieldsEmpty(
10327 + int strPatIsRelatedToGroup)
10328 +{
10329 + if (strPatIsRelatedToGroup)
10330 + {
10331 + return(
10332 + strcmp( getSelectedSubPatternName(), SPNM_NONE_SELECTED ) == 0);
10333 + }
10334 + else
10335 + {
10336 + return
10337 + TextWidgetIsBlank(MatchPatternDialog.mpdStringPatternW) &&
10338 + XmToggleButtonGetState(MatchPatternDialog.wbbBothW) &&
10339 + XmToggleButtonGetState(MatchPatternDialog.sabCaseSensitiveW) &&
10340 + !XmToggleButtonGetState(MatchPatternDialog.sabRegularExpressionW);
10341 + }
10342 +}
10343 +
10344 +/*
10345 +** Get the current content of the matching pattern dialog.
10346 +** If the matching pattern is o.k., then update & apply it
10347 +** to any window which is currently using the matching pattern.
10348 +** If it's bad, then only report it.
10349 +*/
10350 +static int getAndUpdateStringMatchTable(void)
10351 +{
10352 + StringMatchTable *newTable;
10353 + DMPTranslationResult translResult;
10354 +
10355 + /*
10356 + * Get the current information displayed by the dialog. If it's bad,
10357 + * report it to the user & return.
10358 + */
10359 + newTable = getDialogStringMatchTable(&translResult);
10360 +
10361 + if (newTable == NULL && translResult != DMPTR_EMPTY)
10362 + {
10363 + DialogF(
10364 + DF_WARN, MatchPatternDialog.mpdShell, 1,
10365 + "Incomplete Matching Patterns for Language Mode",
10366 + "Incomplete matching patterns for language mode '%s'.\n"
10367 + "Please complete them first",
10368 + "OK",
10369 + MatchPatternDialog.mpdLangModeName);
10370 +
10371 + return False;
10372 + }
10373 +
10374 + /*
10375 + * change the matching pattern
10376 + */
10377 + updateStringMatchTable( newTable );
10378 +
10379 + return True;
10380 +}
10381 +
10382 +/*
10383 +** Update the matching pattern set being edited in the matching pattern dialog
10384 +** with the information that the dialog is currently displaying, and
10385 +** apply changes to any window which is currently using the matching pattern.
10386 +*/
10387 +static void updateStringMatchTable(
10388 + StringMatchTable *newTable)
10389 +{
10390 + WindowInfo *window;
10391 + int i;
10392 +
10393 + /*
10394 + * Find the matching pattern being modified
10395 + */
10396 + for (i=0; i<NbrMatchTables; i++)
10397 + {
10398 + if (!strcmp(MatchPatternDialog.mpdLangModeName, MatchTables[i]->smtLanguageMode))
10399 + {
10400 + /*
10401 + * replace existing matching pattern
10402 + */
10403 + freeStringMatchTable(MatchTables[i]);
10404 + MatchTables[i] = newTable;
10405 + break;
10406 + }
10407 + }
10408 +
10409 + if (i == NbrMatchTables)
10410 + {
10411 + /*
10412 + * new match table for language mode -> add it to end
10413 + */
10414 + MatchTables[NbrMatchTables++] = newTable;
10415 + }
10416 +
10417 + /*
10418 + * Find windows that are currently using this matching pattern set and
10419 + * update this windows
10420 + */
10421 + for (window=WindowList; window!=NULL; window=window->next)
10422 + {
10423 + if ((window->languageMode == PLAIN_LANGUAGE_MODE &&
10424 + !strcmp(PLAIN_LM_STRING, newTable->smtLanguageMode)) ||
10425 + (window->languageMode != PLAIN_LANGUAGE_MODE &&
10426 + !strcmp(LanguageModeName(window->languageMode), newTable->smtLanguageMode)))
10427 + {
10428 + window->stringMatchTable = newTable;
10429 + }
10430 + }
10431 +
10432 + /*
10433 + * Note that preferences have been changed
10434 + */
10435 + MarkPrefsChanged();
10436 +}
10437 +
10438 +static StringMatchTable *getDialogStringMatchTable(
10439 + DMPTranslationResult *result)
10440 +{
10441 + int matchPatListIdx =
10442 + ManagedListSelectedIndex(MatchPatternDialog.mpdMatchPatternNamesListW);
10443 + int stringPatListIdx =
10444 + ManagedListSelectedIndex(MatchPatternDialog.mpdStringPatternsListW);
10445 +
10446 + /*
10447 + * Get the current content of the matching pattern dialog fields
10448 + */
10449 + if (!UpdateManagedList(MatchPatternDialog.mpdStringPatternsListW, True))
10450 + {
10451 + *result = DMPTR_INCOMPLETE;
10452 +
10453 + return NULL;
10454 + }
10455 +
10456 + if (!UpdateManagedList(MatchPatternDialog.mpdMatchPatternNamesListW, True))
10457 + {
10458 + *result = DMPTR_INCOMPLETE;
10459 +
10460 + return NULL;
10461 + }
10462 +
10463 + SelectManagedListItem(MatchPatternDialog.mpdMatchPatternNamesListW, matchPatListIdx);
10464 + SelectManagedListItem(MatchPatternDialog.mpdStringPatternsListW, stringPatListIdx);
10465 +
10466 + /*
10467 + * Translate dialog match table to string match table
10468 + */
10469 + return translateDialogStringMatchTable(&MatchPatternDialog.mpdTable, result);
10470 +}
10471 +
10472 +static StringMatchTable *translateDialogStringMatchTable(
10473 + DialogMatchPatternInfo *dialogTable,
10474 + DMPTranslationResult *result)
10475 +{
10476 + ReadMatchPatternInfo readPatInfo;
10477 + DialogMatchPatternSequenceElement *seq;
10478 + MatchPatternTableElement *newPatElement;
10479 + MatchPatternGroupElement *newGroupElement;
10480 + char *errMsg;
10481 + ErrorInfo errInfo;
10482 + int i;
10483 +
10484 + initErrorInfo(&errInfo);
10485 +
10486 + readPatInfo.rmpiNbrOfElements = 0;
10487 + readPatInfo.rmpiNbrOfGroups = 0;
10488 + readPatInfo.rmpiNbrOfSeqElements = 0;
10489 + readPatInfo.rmpiAllPatRE = NULL;
10490 + readPatInfo.rmpiFlashPatRE = NULL;
10491 +
10492 + /*
10493 + * if no dialog patterns are defined, return "empty" table
10494 + */
10495 + if (dialogTable->dmpiNbrOfSeqElements == 0)
10496 + {
10497 + *result = DMPTR_EMPTY;
10498 +
10499 + return createStringMatchTable(
10500 + &readPatInfo,
10501 + XtNewString(MatchPatternDialog.mpdLangModeName));
10502 + }
10503 +
10504 + /*
10505 + * translate dialog matching pattern elements
10506 + */
10507 + for (i=0; i < dialogTable->dmpiNbrOfSeqElements; i++)
10508 + {
10509 + seq = dialogTable->dmpiSequence[i];
10510 +
10511 + if (seq->dmpseType == MPT_GROUP)
10512 + {
10513 + newGroupElement =
10514 + translateDialogMatchPatternGroupElement(
10515 + &readPatInfo,
10516 + (DialogMatchPatternGroupElement *)seq->dmpsePtr);
10517 +
10518 + if (newGroupElement == NULL)
10519 + {
10520 + freeReadMatchPatternInfo(&readPatInfo);
10521 +
10522 + *result = DMPTR_INCOMPLETE;
10523 +
10524 + return NULL;
10525 + }
10526 +
10527 + readPatInfo.rmpiGroup[readPatInfo.rmpiNbrOfGroups ++] =
10528 + newGroupElement;
10529 +
10530 + recordPatternSequence(
10531 + &readPatInfo,
10532 + seq->dmpseName,
10533 + seq->dmpseType,
10534 + readPatInfo.rmpiNbrOfGroups-1 );
10535 + }
10536 + else
10537 + {
10538 + newPatElement =
10539 + translateDialogMatchPatternTableElement(
10540 + (DialogMatchPatternTableElement *)seq->dmpsePtr);
10541 +
10542 + newPatElement->mpteIndex = readPatInfo.rmpiNbrOfElements;
10543 +
10544 + readPatInfo.rmpiElement[readPatInfo.rmpiNbrOfElements ++] =
10545 + newPatElement;
10546 +
10547 + if (newPatElement->mpteType == MPT_INDIVIDUAL)
10548 + {
10549 + if (!assignIndividualGroup(&readPatInfo, &errMsg, newPatElement))
10550 + {
10551 + DialogF(
10552 + DF_WARN, MatchPatternDialog.mpdShell, 1,
10553 + "Assign reg. exp.",
10554 + "%s\n(Pattern: '%s')",
10555 + "OK",
10556 + errMsg,
10557 + newPatElement->mpteName);
10558 +
10559 + freeReadMatchPatternInfo(&readPatInfo);
10560 +
10561 + *result = DMPTR_INCOMPLETE;
10562 +
10563 + return NULL;
10564 + }
10565 + }
10566 +
10567 + treatDuplicatedMTEntries(readPatInfo.rmpiElement, readPatInfo.rmpiNbrOfElements);
10568 +
10569 + recordPatternSequence(
10570 + &readPatInfo,
10571 + seq->dmpseName,
10572 + seq->dmpseType,
10573 + newPatElement->mpteIndex );
10574 + }
10575 + }
10576 +
10577 + /*
10578 + * compile reg. expressions of "read" patterns
10579 + */
10580 + if (createRegExpOfPatterns( &readPatInfo, &errInfo ))
10581 + {
10582 + errInfo.eiLanguageMode = XtNewString(MatchPatternDialog.mpdLangModeName);
10583 + dialogMatchingPatternSetError(
10584 + "Assign all patterns reg. exp.",
10585 + &errInfo);
10586 +
10587 + freeReadMatchPatternInfo(&readPatInfo);
10588 +
10589 + *result = DMPTR_INCOMPLETE;
10590 +
10591 + return NULL;
10592 + }
10593 +
10594 + *result = DMPTR_OK;
10595 +
10596 + return createStringMatchTable(
10597 + &readPatInfo,
10598 + XtNewString(MatchPatternDialog.mpdLangModeName));
10599 +}
10600 +
10601 +static MatchPatternTableElement *translateDialogMatchPatternTableElement(
10602 + DialogMatchPatternTableElement *dialogElement)
10603 +{
10604 + MatchPatternTableElement *newElement;
10605 +
10606 + newElement =
10607 + (MatchPatternTableElement *)XtMalloc(sizeof(MatchPatternTableElement));
10608 +
10609 + newElement->mpteName = XtNewString(dialogElement->dmpteName);
10610 + newElement->mpteIndex = NO_ELEMENT_IDX;
10611 + newElement->mpteType = dialogElement->dmpteType;
10612 + newElement->mpteGroup = NO_GROUP_IDX;
10613 +
10614 + translateDialogPatterns(&dialogElement->dmptePatterns, newElement);
10615 +
10616 + newElement->mpteSkipBtwnStartEnd = dialogElement->dmpteSkipBtwnStartEnd;
10617 + newElement->mpteFlash = dialogElement->dmpteFlash;
10618 + newElement->mpteIgnoreHighLightInfo = dialogElement->dmpteIgnoreHighLightInfo;
10619 + newElement->mpteStartEndRE = NULL;
10620 +
10621 + initGlobalBackRefList( newElement->mpteGlobalBackRef );
10622 +
10623 + return newElement;
10624 +}
10625 +
10626 +static void translateDialogPatterns(
10627 + DialogStringPatterns *dialogPatterns,
10628 + MatchPatternTableElement *newElement)
10629 +{
10630 + int sizeOfPat;
10631 + int i;
10632 +
10633 + /*
10634 + * allocate memory for patterns
10635 + */
10636 + newElement->mpteAll.pesNumberOfPattern = dialogPatterns->dspNumberOfPatterns;
10637 +
10638 + sizeOfPat =
10639 + sizeof(PatternElement *) * dialogPatterns->dspNumberOfPatterns;
10640 +
10641 + newElement->mpteAll.pesPattern = (PatternElement **)XtMalloc(sizeOfPat);
10642 +
10643 + /*
10644 + * assign dialog patterns to patterns of MatchPatternTableElement
10645 + */
10646 + for (i=0; i < dialogPatterns->dspNumberOfPatterns; i++)
10647 + {
10648 + newElement->mpteAll.pesPattern[i] =
10649 + createPatternElement(
10650 + XtNewString(dialogPatterns->dspElements[i]->dspeText),
10651 + dialogPatterns->dspElements[i]->dspeKind,
10652 + dialogPatterns->dspElements[i]->dspeWordBoundary,
10653 + dialogPatterns->dspElements[i]->dspeCaseInsensitive,
10654 + dialogPatterns->dspElements[i]->dspeRegularExpression);
10655 +
10656 + newElement->mpteAll.pesPattern[i]->peIndex = i;
10657 + }
10658 +
10659 + /*
10660 + * sort pattern elements into start, middle & end arrays
10661 + */
10662 + sortDialogPatternElementSet( &newElement->mpteAll, newElement );
10663 +
10664 + /*
10665 + * determine mono pattern
10666 + */
10667 + if (newElement->mpteEnd.pesNumberOfPattern == 0)
10668 + {
10669 + newElement->mpteIsMonoPattern = True;
10670 +
10671 + copyPatternSet( &newElement->mpteStart, &newElement->mpteEnd );
10672 + }
10673 + else
10674 + {
10675 + newElement->mpteIsMonoPattern = False;
10676 + }
10677 +}
10678 +
10679 +/*
10680 + * Sort dialog pattern element set into start, middle & end arrays.
10681 + */
10682 +static void sortDialogPatternElementSet(
10683 + PatternElementSet *allPat,
10684 + MatchPatternTableElement *result)
10685 +{
10686 + int sizeOfPat;
10687 +
10688 + /*
10689 + * count number of start, middle & end pattern elements
10690 + */
10691 + countPatternElementKind( allPat, result );
10692 +
10693 + /*
10694 + * allocate pattern elements
10695 + */
10696 + sizeOfPat = sizeof(PatternElement *) * result->mpteStart.pesNumberOfPattern;
10697 + result->mpteStart.pesPattern = (PatternElement **)XtMalloc( sizeOfPat );
10698 +
10699 + if (result->mpteMiddle.pesNumberOfPattern != 0)
10700 + {
10701 + sizeOfPat = sizeof(PatternElement *) * result->mpteMiddle.pesNumberOfPattern;
10702 + result->mpteMiddle.pesPattern = (PatternElement **)XtMalloc( sizeOfPat );
10703 + }
10704 +
10705 + if (result->mpteEnd.pesNumberOfPattern != 0)
10706 + {
10707 + sizeOfPat = sizeof(PatternElement *) * result->mpteEnd.pesNumberOfPattern;
10708 + result->mpteEnd.pesPattern = (PatternElement **)XtMalloc( sizeOfPat );
10709 + }
10710 +
10711 + /*
10712 + * sort pattern elements into start, middle & end arrays
10713 + */
10714 + sortPatternElementSet( allPat, result );
10715 +}
10716 +
10717 +static MatchPatternGroupElement *translateDialogMatchPatternGroupElement(
10718 + ReadMatchPatternInfo *info,
10719 + DialogMatchPatternGroupElement *dialogGroup)
10720 +{
10721 + int i;
10722 + int error = False;
10723 + MatchPatternTableElement *subPatElement;
10724 + int sizeOfIds;
10725 + MatchPatternGroupElement *group;
10726 +
10727 + /*
10728 + * Allocate memory for the matching pattern group. Copy name & number of
10729 + * sub patterns.
10730 + */
10731 + group =
10732 + (MatchPatternGroupElement *)XtMalloc( sizeof(MatchPatternGroupElement) );
10733 +
10734 + group->mpgeName = XtNewString(dialogGroup->dmpgeName);
10735 + group->mpgeNumberOfSubPatterns = dialogGroup->dmpgeNumberOfSubPatterns;
10736 + group->mpgeKeywordRE = NULL;
10737 +
10738 + /*
10739 + * Allocate memory for the sub-matching pattern IDs
10740 + */
10741 + sizeOfIds = sizeof(char *) * group->mpgeNumberOfSubPatterns;
10742 + group->mpgeSubPatternIds = (char **)XtMalloc( sizeOfIds );
10743 +
10744 + for (i=0; i < group->mpgeNumberOfSubPatterns; i ++)
10745 + {
10746 + /*
10747 + * Remember sub-matching pattern ID
10748 + */
10749 + group->mpgeSubPatternIds[i] = XtNewString(dialogGroup->dmpgeSubPatternIds[i]);
10750 +
10751 + /*
10752 + * Assign the index of this group to the sub-matching pattern
10753 + * if no group index was assigned before.
10754 + */
10755 + subPatElement =
10756 + getPatternOfName( info, dialogGroup->dmpgeSubPatternIds[i]);
10757 +
10758 + if (subPatElement == NULL)
10759 + {
10760 + DialogF(
10761 + DF_WARN, MatchPatternDialog.mpdShell, 1,
10762 + "Group Compilation",
10763 + "Group '%s':\nsub-matching pattern '%s' not defined before",
10764 + "OK",
10765 + group->mpgeName,
10766 + dialogGroup->dmpgeSubPatternIds[i]);
10767 +
10768 + error = True;
10769 + }
10770 + else
10771 + {
10772 + if (subPatElement->mpteGroup == NO_GROUP_IDX)
10773 + {
10774 + subPatElement->mpteGroup = info->rmpiNbrOfGroups;
10775 + }
10776 + }
10777 + }
10778 +
10779 + if (error)
10780 + {
10781 + freeMatchPatternGroupElement(group);
10782 +
10783 + return NULL;
10784 + }
10785 +
10786 + return group;
10787 +}
10788 +
10789 +static int stringMatchTableDiffer(
10790 + StringMatchTable *oldTable,
10791 + StringMatchTable *newTable)
10792 +{
10793 + int i, j;
10794 + MatchPatternTable *oldPatTab = oldTable->smtAllPatterns;
10795 + MatchPatternTable *newPatTab = newTable->smtAllPatterns;
10796 + MatchPatternTableElement *oldPat;
10797 + MatchPatternTableElement *newPat;
10798 + MatchPatternGroupElement *oldGroup;
10799 + MatchPatternGroupElement *newGroup;
10800 + MatchPatternSequenceElement *oldSeq;
10801 + MatchPatternSequenceElement *newSeq;
10802 +
10803 + if (oldTable->smtNumberOfSeqElements != newTable->smtNumberOfSeqElements)
10804 + return True;
10805 +
10806 + for (i=0; i < oldTable->smtNumberOfSeqElements; i++)
10807 + {
10808 + oldSeq = oldTable->smtSequence[i];
10809 + newSeq = newTable->smtSequence[i];
10810 +
10811 + if (AllocatedStringsDiffer(oldSeq->mpseName, newSeq->mpseName))
10812 + return True;
10813 + if (oldSeq->mpseType != newSeq->mpseType)
10814 + return True;
10815 +
10816 + if (oldSeq->mpseType == MPT_GROUP)
10817 + {
10818 + oldGroup = oldTable->smtGroups[oldSeq->mpseIndex];
10819 + newGroup = newTable->smtGroups[newSeq->mpseIndex];
10820 +
10821 + if (AllocatedStringsDiffer(oldGroup->mpgeName, newGroup->mpgeName))
10822 + return True;
10823 +
10824 + if (oldGroup->mpgeNumberOfSubPatterns != newGroup->mpgeNumberOfSubPatterns)
10825 + return True;
10826 +
10827 + for (j=0; j < oldGroup->mpgeNumberOfSubPatterns; j++)
10828 + {
10829 + if (AllocatedStringsDiffer(
10830 + oldGroup->mpgeSubPatternIds[j],
10831 + newGroup->mpgeSubPatternIds[j]))
10832 + return True;
10833 + }
10834 + }
10835 + else
10836 + {
10837 + oldPat = oldPatTab->mptElements[oldSeq->mpseIndex];
10838 + newPat = newPatTab->mptElements[newSeq->mpseIndex];
10839 +
10840 + if (AllocatedStringsDiffer(oldPat->mpteName, newPat->mpteName))
10841 + return True;
10842 +
10843 + if (oldPat->mpteType != newPat->mpteType)
10844 + return True;
10845 +
10846 + if (oldPat->mpteGroup != newPat->mpteGroup)
10847 + return True;
10848 +
10849 + if (oldPat->mpteAll.pesNumberOfPattern != newPat->mpteAll.pesNumberOfPattern)
10850 + return True;
10851 +
10852 + for (j=0; j < oldPat->mpteAll.pesNumberOfPattern; j ++)
10853 + {
10854 + if (patternElementDiffer(
10855 + oldPat->mpteAll.pesPattern[j], oldPatTab,
10856 + newPat->mpteAll.pesPattern[j], newPatTab ) )
10857 + return True;
10858 + }
10859 +
10860 + if (oldPat->mpteIsMonoPattern != newPat->mpteIsMonoPattern)
10861 + return True;
10862 +
10863 + if (oldPat->mpteSkipBtwnStartEnd != newPat->mpteSkipBtwnStartEnd)
10864 + return True;
10865 +
10866 + if (oldPat->mpteIgnoreHighLightInfo != newPat->mpteIgnoreHighLightInfo)
10867 + return True;
10868 +
10869 + if (oldPat->mpteFlash != newPat->mpteFlash)
10870 + return True;
10871 + }
10872 + }
10873 +
10874 + return False;
10875 +}
10876 +
10877 +static int patternElementDiffer(
10878 + PatternElement *oldPE,
10879 + MatchPatternTable *oldTab,
10880 + PatternElement *newPE,
10881 + MatchPatternTable *newTab)
10882 +{
10883 + StringPattern *oldSP;
10884 + StringPattern *newSP;
10885 +
10886 + oldSP = GetStringPattern(oldTab, oldPE);
10887 + newSP = GetStringPattern(newTab, newPE);
10888 +
10889 + if (AllocatedStringsDiffer(oldSP->spText, newSP->spText))
10890 + return True;
10891 + if (AllocatedStringsDiffer(oldSP->spOrigText, newSP->spOrigText))
10892 + return True;
10893 + if (oldPE->peKind != newPE->peKind)
10894 + return True;
10895 + if (oldSP->spWordBoundary != newSP->spWordBoundary)
10896 + return True;
10897 + if (oldSP->spCaseInsensitive != newSP->spCaseInsensitive)
10898 + return True;
10899 + if (oldSP->spRegularExpression != newSP->spRegularExpression)
10900 + return True;
10901 +
10902 + return False;
10903 +}
10904 +
10905 +static DialogMatchPatternGroupElement *getDialogGroupUsingMatchPattern(
10906 + char *matchPatternName)
10907 +{
10908 + DialogMatchPatternSequenceElement *seq;
10909 + DialogMatchPatternGroupElement *group;
10910 + int i, j;
10911 +
10912 + for (i=0; i < MatchPatternDialog.mpdTable.dmpiNbrOfSeqElements; i ++)
10913 + {
10914 + seq = MatchPatternDialog.mpdTable.dmpiSequence[i];
10915 +
10916 + if (seq->dmpseType == MPT_GROUP)
10917 + {
10918 + group = (DialogMatchPatternGroupElement *)seq->dmpsePtr;
10919 +
10920 + for (j=0; j < group->dmpgeNumberOfSubPatterns; j ++)
10921 + {
10922 + if (strcmp(group->dmpgeSubPatternIds[j], matchPatternName) == 0)
10923 + return group;
10924 + }
10925 + }
10926 + }
10927 +
10928 + return NULL;
10929 +}
10930 +
10931 +static void removeMatchPatternFromGroup(
10932 + char *matchPatternName,
10933 + DialogMatchPatternGroupElement *group)
10934 +{
10935 + int i;
10936 +
10937 + for (i=0; i < group->dmpgeNumberOfSubPatterns; i ++)
10938 + {
10939 + if (strcmp(group->dmpgeSubPatternIds[i], matchPatternName) == 0)
10940 + {
10941 + /*
10942 + * remove existing matching pattern name from sub-pattern list
10943 + */
10944 + freeXtPtr((void **)&group->dmpgeSubPatternIds[i]);
10945 + memmove(
10946 + &group->dmpgeSubPatternIds[i],
10947 + &group->dmpgeSubPatternIds[i+1],
10948 + (group->dmpgeNumberOfSubPatterns-1 - i) * sizeof(char *));
10949 + group->dmpgeNumberOfSubPatterns --;
10950 +
10951 + return;
10952 + }
10953 + }
10954 +}
10955 +
10956 +static void removeMatchPatternFromAllGroups(
10957 + char *matchPatternName)
10958 +{
10959 + DialogMatchPatternSequenceElement *seq;
10960 + DialogMatchPatternGroupElement *group;
10961 + int i;
10962 +
10963 + for (i=0; i < MatchPatternDialog.mpdTable.dmpiNbrOfSeqElements; i ++)
10964 + {
10965 + seq = MatchPatternDialog.mpdTable.dmpiSequence[i];
10966 +
10967 + if (seq->dmpseType == MPT_GROUP)
10968 + {
10969 + group = (DialogMatchPatternGroupElement *)seq->dmpsePtr;
10970 +
10971 + removeMatchPatternFromGroup(matchPatternName, group);
10972 + }
10973 + }
10974 +}
10975 +
10976 +static void renameMatchPatternInGroup(
10977 + char *oldMatchPatternName,
10978 + char *newMatchPatternName,
10979 + DialogMatchPatternGroupElement *group)
10980 +{
10981 + int i;
10982 +
10983 + for (i=0; i < group->dmpgeNumberOfSubPatterns; i ++)
10984 + {
10985 + if (strcmp(group->dmpgeSubPatternIds[i], oldMatchPatternName) == 0)
10986 + {
10987 + /*
10988 + * rename existing matching pattern name in sub-pattern list
10989 + */
10990 + freeXtPtr((void **)&group->dmpgeSubPatternIds[i]);
10991 +
10992 + group->dmpgeSubPatternIds[i] =
10993 + XtNewString(newMatchPatternName);
10994 +
10995 + return;
10996 + }
10997 + }
10998 +}
10999 +
11000 +static void renameMatchPatternInAllGroups(
11001 + char *oldMatchPatternName,
11002 + char *newMatchPatternName)
11003 +{
11004 + DialogMatchPatternSequenceElement *seq;
11005 + DialogMatchPatternGroupElement *group;
11006 + int i;
11007 +
11008 + for (i=0; i < MatchPatternDialog.mpdTable.dmpiNbrOfSeqElements; i ++)
11009 + {
11010 + seq = MatchPatternDialog.mpdTable.dmpiSequence[i];
11011 +
11012 + if (seq->dmpseType == MPT_GROUP)
11013 + {
11014 + group = (DialogMatchPatternGroupElement *)seq->dmpsePtr;
11015 +
11016 + renameMatchPatternInGroup(
11017 + oldMatchPatternName,
11018 + newMatchPatternName,
11019 + group);
11020 + }
11021 + }
11022 +}
11023 +
11024 +static void freeVariableDialogData(
11025 + int keepLanguageModeName)
11026 +{
11027 + int i;
11028 +
11029 + if (!keepLanguageModeName)
11030 + freeXtPtr((void **)&MatchPatternDialog.mpdLangModeName);
11031 +
11032 + for (i=0; i < MatchPatternDialog.mpdTable.dmpiNbrOfSeqElements; i ++)
11033 + {
11034 + freeDialogSequenceElement(
11035 + MatchPatternDialog.mpdTable.dmpiSequence[i] );
11036 + }
11037 +
11038 + MatchPatternDialog.mpdTable.dmpiNbrOfSeqElements = 0;
11039 +
11040 + freeDialogStringPatterns(
11041 + &MatchPatternDialog.currentStringPatterns);
11042 +}
11043 +
11044 +static void initGlobalBackRefList(
11045 + GlobalBackRefElement *list)
11046 +{
11047 + int i;
11048 +
11049 + for (i=0; i < MAX_GLOBAL_BACK_REF_ID; i++)
11050 + {
11051 + list[i].gbreDefByStrPat = NULL;
11052 + list[i].gbreRegExpText = NULL;
11053 + }
11054 +}
11055 +
11056 +static void initStrPatBackRefList(
11057 + StringPattern *strPat)
11058 +{
11059 + int i;
11060 +
11061 + for (i=0; i < MAX_GLOBAL_BACK_REF_ID; i++)
11062 + {
11063 + strPat->spOwnGlobalBackRef[i].spbreRegExpText = NULL;
11064 + strPat->spOwnGlobalBackRef[i].spbreLocalBackRefID = NO_LOCAL_BACK_REF_ID;
11065 +
11066 + strPat->spGlobalToLocalBackRef[i] = NO_LOCAL_BACK_REF_ID;
11067 + }
11068 +}
11069 +
11070 +static void initErrorInfo(
11071 + ErrorInfo *errInfo)
11072 +{
11073 + errInfo->eiDetail = NULL;
11074 + errInfo->eiLanguageMode = NULL;
11075 + errInfo->eiMPTabElementName = NULL;
11076 + errInfo->eiStringPatText = NULL;
11077 + errInfo->eiRegExpCompileMsg = NULL;
11078 + errInfo->eiBackRefNbr = 0;
11079 +}
11080 +
11081 +static void freeErrorInfo(
11082 + ErrorInfo *errInfo)
11083 +{
11084 + freeXtPtr((void **)&errInfo->eiLanguageMode);
11085 + freeXtPtr((void **)&errInfo->eiMPTabElementName);
11086 + freeXtPtr((void **)&errInfo->eiStringPatText);
11087 +}
11088 +
11089 +static void freeXtPtr(void **ptr)
11090 +{
11091 + if (*ptr != NULL)
11092 + {
11093 + XtFree((char *)*ptr);
11094 + *ptr = NULL;
11095 + }
11096 +}
11097 +
11098 +static void freePtr(void **ptr)
11099 +{
11100 + if (*ptr != NULL)
11101 + {
11102 + free((char *)*ptr);
11103 + *ptr = NULL;
11104 + }
11105 +}
11106 diff --quilt /dev/null new/source/patternMatchData.h
11107 --- /dev/null
11108 +++ new/source/patternMatchData.h
11109 @@ -0,0 +1,24 @@
11110 +/* $Id: patternMatchData.h,v 1.3 2003/12/12 16:45:25 uleh Exp $ */
11111 +
11112 +#ifndef NEDIT_PATTERNMATCHDATA_H_INCLUDED
11113 +#define NEDIT_PATTERNMATCHDATA_H_INCLUDED
11114 +
11115 +void *FindStringMatchTable(const char *langModeName);
11116 +
11117 +void RenameStringMatchTable(const char *oldName, const char *newName);
11118 +
11119 +void DeleteStringMatchTable(const char *langModeName);
11120 +
11121 +void AssignStandardStringMatchTable(const char *langModeName);
11122 +
11123 +int LMHasStringMatchTable(const char *languageMode);
11124 +
11125 +int LoadMatchPatternString(char *inString);
11126 +
11127 +char *WriteMatchPatternString(void);
11128 +
11129 +void EditMatchPatterns(WindowInfo *window);
11130 +
11131 +void UpdateLanguageModeMenuMatchPattern(void);
11132 +
11133 +#endif /* NEDIT_PATTERNMATCHDATA_H_INCLUDED */
11134 diff --quilt old/source/preferences.c new/source/preferences.c
11135 --- old/source/preferences.c
11136 +++ new/source/preferences.c
11137 @@ -45,10 +45,14 @@ static const char CVSID[] = "$Id: prefer
11138 #include "regularExp.h"
11139 #include "smartIndent.h"
11140 #include "windowTitle.h"
11141 #include "server.h"
11142 #include "tags.h"
11143 +
11144 +/* Pattern Match Feature */
11145 +#include "patternMatchData.h"
11146 +
11147 #include "../util/prefFile.h"
11148 #include "../util/misc.h"
11149 #include "../util/DialogF.h"
11150 #include "../util/managedList.h"
11151 #include "../util/fontsel.h"
11152 @@ -277,11 +281,10 @@ static struct prefData {
11153 int textCols; /* initial window width in characters */
11154 int tabDist; /* number of characters between tab stops */
11155 int emTabDist; /* non-zero tab dist. if emulated tabs are on */
11156 int insertTabs; /* whether to use tabs for padding */
11157 int showMatchingStyle; /* how to flash matching parenthesis */
11158 - int matchSyntaxBased; /* use syntax info to match parenthesis */
11159 int highlightSyntax; /* whether to highlight syntax by default */
11160 int smartTags; /* look for tag in current window first */
11161 int alwaysCheckRelativeTagsSpecs; /* for every new opened file of session */
11162 int stickyCaseSenseBtn; /* whether Case Word Btn is sticky to Regex Btn */
11163 int prefFileRead; /* detects whether a .nedit existed */
11164 @@ -348,10 +351,11 @@ static struct {
11165 char *language;
11166 char *styles;
11167 char *smartIndent;
11168 char *smartIndentCommon;
11169 char *shell;
11170 + char *matchPattern;
11171 } TempStringPrefs;
11173 /* preference descriptions for SavePreferences and RestorePreferences. */
11174 static PrefDescripRec PrefDescrip[] = {
11175 {"fileVersion", "FileVersion" , PREF_STRING, "", PrefData.fileVersion,
11176 @@ -853,10 +857,76 @@ static PrefDescripRec PrefDescrip[] = {
11177 C++:Default\n\
11178 Python:Default\n\
11179 Matlab:Default", &TempStringPrefs.smartIndent, NULL, True},
11180 {"smartIndentInitCommon", "SmartIndentInitCommon", PREF_ALLOC_STRING,
11181 "Default", &TempStringPrefs.smartIndentCommon, NULL, True},
11182 +/* Pattern Match Feature: matchPatterns resource added */
11183 +#ifdef VMS
11184 +/* The VAX compiler can't compile Java-Script's definition in highlightData.c */
11185 + {"matchPatterns", "MatchPatterns", PREF_ALLOC_STRING,
11186 + "PLAIN:Default\n\
11187 + Ada:Default\n\
11188 + Awk:Default\n\
11189 + C++:Default\n\
11190 + C:Default\n\
11191 + CSS:Default\n\
11192 + Csh:Default\n\
11193 + Fortran:Default\n\
11194 + Java:Default\n\
11195 + LaTeX:Default\n\
11196 + Lex:Default\n\
11197 + Makefile:Default\n\
11198 + Matlab:Default\n\
11199 + NEdit Macro:Default\n\
11200 + Pascal:Default\n\
11201 + Perl:Default\n\
11202 + PostScript:Default\n\
11203 + Python:Default\n\
11204 + Regex:Default\n\
11205 + SGML HTML:Default\n\
11206 + SQL:Default\n\
11207 + Sh Ksh Bash:Default\n\
11208 + Tcl:Default\n\
11209 + VHDL:Default\n\
11210 + Verilog:Default\n\
11211 + XML:Default\n\
11212 + X Resources:Default\n\
11213 + Yacc:Default\n",
11214 + &TempStringPrefs.matchPattern, NULL, True},
11215 +#else
11216 + {"matchPatterns", "MatchPatterns", PREF_ALLOC_STRING,
11217 + "PLAIN:Default\n\
11218 + Ada:Default\n\
11219 + Awk:Default\n\
11220 + C++:Default\n\
11221 + C:Default\n\
11222 + CSS:Default\n\
11223 + Csh:Default\n\
11224 + Fortran:Default\n\
11225 + Java:Default\n\
11226 + JavaScript:Default\n\
11227 + LaTeX:Default\n\
11228 + Lex:Default\n\
11229 + Makefile:Default\n\
11230 + Matlab:Default\n\
11231 + NEdit Macro:Default\n\
11232 + Pascal:Default\n\
11233 + Perl:Default\n\
11234 + PostScript:Default\n\
11235 + Python:Default\n\
11236 + Regex:Default\n\
11237 + SGML HTML:Default\n\
11238 + SQL:Default\n\
11239 + Sh Ksh Bash:Default\n\
11240 + Tcl:Default\n\
11241 + VHDL:Default\n\
11242 + Verilog:Default\n\
11243 + XML:Default\n\
11244 + X Resources:Default\n\
11245 + Yacc:Default\n",
11246 + &TempStringPrefs.matchPattern, NULL, True},
11247 +#endif
11248 {"autoWrap", "AutoWrap", PREF_ENUM, "Continuous",
11249 &PrefData.wrapStyle, AutoWrapTypes, True},
11250 {"wrapMargin", "WrapMargin", PREF_INT, "0",
11251 &PrefData.wrapMargin, NULL, True},
11252 {"showWrapMargin", "ShowWrapMargin", PREF_ENUM, "Never",
11253 @@ -869,12 +939,10 @@ static PrefDescripRec PrefDescrip[] = {
11254 &PrefData.openInTab, NULL, True},
11255 {"saveOldVersion", "SaveOldVersion", PREF_BOOLEAN, "False",
11256 &PrefData.saveOldVersion, NULL, True},
11257 {"showMatching", "ShowMatching", PREF_ENUM, "Delimiter",
11258 &PrefData.showMatchingStyle, ShowMatchingTypes, True},
11259 - {"matchSyntaxBased", "MatchSyntaxBased", PREF_BOOLEAN, "True",
11260 - &PrefData.matchSyntaxBased, NULL, True},
11261 {"highlightSyntax", "HighlightSyntax", PREF_BOOLEAN, "True",
11262 &PrefData.highlightSyntax, NULL, True},
11263 {"backlightChars", "BacklightChars", PREF_BOOLEAN, "False",
11264 &PrefData.backlightChars, NULL, True},
11265 {"backlightCharTypes", "BacklightCharTypes", PREF_ALLOC_STRING,
11266 @@ -1245,10 +1313,11 @@ static void lmDestroyCB(Widget w, XtPoin
11267 static void lmOkCB(Widget w, XtPointer clientData, XtPointer callData);
11268 static void lmApplyCB(Widget w, XtPointer clientData, XtPointer callData);
11269 static void lmCloseCB(Widget w, XtPointer clientData, XtPointer callData);
11270 static int lmDeleteConfirmCB(int itemIndex, void *cbArg);
11271 static int updateLMList(void);
11272 +static int isOldLanguageMode(const char *lmDialogName, const char *oldModeName);
11273 static languageModeRec *copyLanguageModeRec(languageModeRec *lm);
11274 static void *lmGetDisplayedCB(void *oldItem, int explicitRequest, int *abort,
11275 void *cbArg);
11276 static void lmSetDisplayedCB(void *item, void *cbArg);
11277 static languageModeRec *readLMDialogFields(int silent);
11278 @@ -1432,10 +1501,15 @@ static void translatePrefFormats(int con
11279 if (TempStringPrefs.smartIndentCommon != NULL) {
11280 LoadSmartIndentCommonString(TempStringPrefs.smartIndentCommon);
11281 XtFree(TempStringPrefs.smartIndentCommon);
11282 TempStringPrefs.smartIndentCommon = NULL;
11283 }
11284 + if (TempStringPrefs.matchPattern != NULL) {
11285 + LoadMatchPatternString(TempStringPrefs.matchPattern);
11286 + XtFree(TempStringPrefs.matchPattern);
11287 + TempStringPrefs.matchPattern = NULL;
11288 + }
11290 /* translate the font names into fontLists suitable for the text widget */
11291 font = XLoadQueryFont(TheDisplay, PrefData.fontString);
11292 PrefData.fontList = font==NULL ? NULL :
11293 XmFontListCreate(font, XmSTRING_DEFAULT_CHARSET);
11294 @@ -1511,10 +1585,11 @@ void SaveNEditPrefs(Widget parent, int q
11295 TempStringPrefs.highlight = WriteHighlightString();
11296 TempStringPrefs.language = writeLanguageModesString();
11297 TempStringPrefs.styles = WriteStylesString();
11298 TempStringPrefs.smartIndent = WriteSmartIndentString();
11299 TempStringPrefs.smartIndentCommon = WriteSmartIndentCommonString();
11300 + TempStringPrefs.matchPattern = WriteMatchPatternString();
11301 strcpy(PrefData.fileVersion, PREF_FILE_VERSION);
11303 if (!SavePreferences(XtDisplay(parent), prefFileName, HeaderText,
11304 PrefDescrip, XtNumber(PrefDescrip)))
11305 {
11306 @@ -1530,10 +1605,11 @@ void SaveNEditPrefs(Widget parent, int q
11307 XtFree(TempStringPrefs.highlight);
11308 XtFree(TempStringPrefs.language);
11309 XtFree(TempStringPrefs.styles);
11310 XtFree(TempStringPrefs.smartIndent);
11311 XtFree(TempStringPrefs.smartIndentCommon);
11312 + XtFree(TempStringPrefs.matchPattern);
11314 PrefsHaveChanged = False;
11315 }
11317 /*
11318 @@ -1926,20 +2002,10 @@ int GetPrefShowMatching(void)
11319 if (PrefData.showMatchingStyle >= N_SHOW_MATCHING_STYLES)
11320 PrefData.showMatchingStyle -= N_SHOW_MATCHING_STYLES;
11321 return PrefData.showMatchingStyle;
11322 }
11324 -void SetPrefMatchSyntaxBased(int state)
11325 -{
11326 - setIntPref(&PrefData.matchSyntaxBased, state);
11327 -}
11328 -
11329 -int GetPrefMatchSyntaxBased(void)
11330 -{
11331 - return PrefData.matchSyntaxBased;
11332 -}
11333 -
11334 void SetPrefHighlightSyntax(Boolean state)
11335 {
11336 setIntPref(&PrefData.highlightSyntax, state);
11337 }
11339 @@ -3496,10 +3562,25 @@ static int lmDeleteConfirmCB(int itemInd
11340 "Auto Indent -> Program Smart Indent,\n"
11341 "before proceeding here.", "OK");
11342 return False;
11343 }
11345 + /* Pattern Match Feature: don't allow deletion if data will be lost */
11346 + if (LMHasStringMatchTable(LMDialog.languageModeList[itemIndex]->name))
11347 + {
11348 + DialogF(DF_WARN, LMDialog.shell, 1, "Matching Patterns exist",
11349 + "This language mode has matching patterns\n"
11350 + "defined. Please delete the patterns first,\n"
11351 + "in Preferences -> Default Settings ->\n"
11352 + "Show Matching (..) -> Matching Patterns ..,\n"
11353 + "before proceeding here.", "Dismiss");
11354 + return False;
11355 + }
11356 +
11357 + /* delete "empty" string match table related to language mode to be deleted */
11358 + DeleteStringMatchTable(LMDialog.languageModeList[itemIndex]->name);
11359 +
11360 return True;
11361 }
11363 /*
11364 ** Apply the changes that the user has made in the language modes dialog to the
11365 @@ -3516,19 +3597,19 @@ static int updateLMList(void)
11366 /* Get the current contents of the dialog fields */
11367 if (!UpdateManagedList(LMDialog.managedListW, True))
11368 return False;
11370 /* Fix up language mode indices in all open windows (which may change
11371 - if the currently selected mode is deleted or has changed position),
11372 - and update word delimiters */
11373 + if the currently selected mode is renamed, deleted or has changed
11374 + position), and update word delimiters */
11375 for (window=WindowList; window!=NULL; window=window->next) {
11376 if (window->languageMode != PLAIN_LANGUAGE_MODE) {
11377 oldLanguageMode = window->languageMode;
11378 oldModeName = LanguageModes[window->languageMode]->name;
11379 window->languageMode = PLAIN_LANGUAGE_MODE;
11380 for (i=0; i<LMDialog.nLanguageModes; i++) {
11381 - if (!strcmp(oldModeName, LMDialog.languageModeList[i]->name)) {
11382 + if (isOldLanguageMode(LMDialog.languageModeList[i]->name, oldModeName)) {
11383 newDelimiters = LMDialog.languageModeList[i]->delimiters;
11384 if (newDelimiters == NULL)
11385 newDelimiters = GetPrefDelimiters();
11386 XtVaSetValues(window->textArea, textNwordDelimiters,
11387 newDelimiters, NULL);
11388 @@ -3554,10 +3635,11 @@ static int updateLMList(void)
11389 if (strchr(LMDialog.languageModeList[i]->name, ':') != NULL) {
11390 char *newName = strrchr(LMDialog.languageModeList[i]->name, ':')+1;
11391 *strchr(LMDialog.languageModeList[i]->name, ':') = '\0';
11392 RenameHighlightPattern(LMDialog.languageModeList[i]->name, newName);
11393 RenameSmartIndentMacros(LMDialog.languageModeList[i]->name, newName);
11394 + RenameStringMatchTable(LMDialog.languageModeList[i]->name, newName);
11395 memmove(LMDialog.languageModeList[i]->name, newName,
11396 strlen(newName) + 1);
11397 ChangeManagedListData(LMDialog.managedListW);
11398 }
11399 }
11400 @@ -3571,31 +3653,62 @@ static int updateLMList(void)
11402 /* Update user menu info to update language mode dependencies of
11403 user menu items */
11404 UpdateUserMenuInfo();
11406 + /* Pattern Match Feature: assign standard string match table to new
11407 + language modes */
11408 + for (i=0; i<NLanguageModes; i++) {
11409 + if (FindStringMatchTable(LanguageModeName(i)) == NULL)
11410 + AssignStandardStringMatchTable(LanguageModeName(i));
11411 + }
11412 +
11413 /* Update the menus in the window menu bars and load any needed
11414 - calltips files */
11415 + calltips files and reassign string match tables */
11416 for (window=WindowList; window!=NULL; window=window->next) {
11417 updateLanguageModeSubmenu(window);
11418 if (window->languageMode != PLAIN_LANGUAGE_MODE &&
11419 LanguageModes[window->languageMode]->defTipsFile != NULL)
11420 AddTagsFile(LanguageModes[window->languageMode]->defTipsFile, TIP);
11421 +
11422 + window->stringMatchTable =
11423 + FindStringMatchTable(LanguageModeName(window->languageMode));
11424 +
11425 /* cache user menus: Rebuild all user menus of this window */
11426 RebuildAllMenus(window);
11427 }
11429 /* If a syntax highlighting dialog is up, update its menu */
11430 UpdateLanguageModeMenu();
11431 /* The same for the smart indent macro dialog */
11432 UpdateLangModeMenuSmartIndent();
11433 + /* The same for the match pattern dialog */
11434 + UpdateLanguageModeMenuMatchPattern();
11435 /* Note that preferences have been changed */
11436 MarkPrefsChanged();
11438 return True;
11439 }
11441 +/*
11442 +** Returns true, if the given old language mode name matches the
11443 +** given (new) language mode dialog name.
11444 +*/
11445 +static int isOldLanguageMode(const char *lmDialogName, const char *oldModeName)
11446 +{
11447 + char *c = strchr(lmDialogName, ':');
11448 + int isOldMode = !strcmp(oldModeName, lmDialogName);
11449 +
11450 + if (!isOldMode && c != NULL) {
11451 + *c = '\0';
11452 + isOldMode = !strcmp(lmDialogName, oldModeName);
11453 + *c = ':';
11454 + }
11455 +
11456 + return isOldMode;
11457 +}
11458 +
11459 static void *lmGetDisplayedCB(void *oldItem, int explicitRequest, int *abort,
11460 void *cbArg)
11461 {
11462 languageModeRec *lm, *oldLM = (languageModeRec *)oldItem;
11463 char *tempName;
11464 @@ -4585,10 +4698,14 @@ static void reapplyLanguageMode(WindowIn
11465 /* Decref oldMode's default calltips file if needed */
11466 if (oldMode != PLAIN_LANGUAGE_MODE && LanguageModes[oldMode]->defTipsFile) {
11467 DeleteTagsFile( LanguageModes[oldMode]->defTipsFile, TIP, False );
11468 }
11470 + /* Pattern Match Feature: Assign the match pattern related to
11471 + the language mode */
11472 + window->stringMatchTable = FindStringMatchTable(LanguageModeName(mode));
11473 +
11474 /* Set delimiters for all text widgets */
11475 if (mode == PLAIN_LANGUAGE_MODE || LanguageModes[mode]->delimiters == NULL)
11476 delimiters = GetPrefDelimiters();
11477 else
11478 delimiters = LanguageModes[mode]->delimiters;
11479 @@ -5202,18 +5319,35 @@ char *ReadSymbolicFieldTextWidget(Widget
11480 }
11482 /*
11483 ** Create a pulldown menu pane with the names of the current language modes.
11484 ** XmNuserData for each item contains the language mode name.
11485 +** Pattern Match Feature: if "includePlain" is set, then 1st menu entry
11486 +** holds "PLAIN".
11487 */
11488 -Widget CreateLanguageModeMenu(Widget parent, XtCallbackProc cbProc, void *cbArg)
11489 +Widget CreateLanguageModeMenu(
11490 + Widget parent,
11491 + XtCallbackProc cbProc,
11492 + void *cbArg,
11493 + int includePlain)
11494 {
11495 Widget menu, btn;
11496 int i;
11497 XmString s1;
11499 menu = CreatePulldownMenu(parent, "languageModes", NULL, 0);
11500 +
11501 + if (includePlain) {
11502 + btn = XtVaCreateManagedWidget("languageMode", xmPushButtonGadgetClass,
11503 + menu,
11504 + XmNlabelString, s1=XmStringCreateSimple("PLAIN"),
11505 + XmNmarginHeight, 0,
11506 + XmNuserData, (void *)"PLAIN", NULL);
11507 + XmStringFree(s1);
11508 + XtAddCallback(btn, XmNactivateCallback, cbProc, cbArg);
11509 + }
11510 +
11511 for (i=0; i<NLanguageModes; i++) {
11512 btn = XtVaCreateManagedWidget("languageMode", xmPushButtonGadgetClass,
11513 menu,
11514 XmNlabelString, s1=XmStringCreateSimple(LanguageModes[i]->name),
11515 XmNmarginHeight, 0,
11516 diff --quilt old/source/preferences.h new/source/preferences.h
11517 --- old/source/preferences.h
11518 +++ new/source/preferences.h
11519 @@ -109,12 +109,10 @@ void SetPrefEmTabDist(int tabDist);
11520 int GetPrefEmTabDist(int langMode);
11521 void SetPrefInsertTabs(int state);
11522 int GetPrefInsertTabs(void);
11523 void SetPrefShowMatching(int state);
11524 int GetPrefShowMatching(void);
11525 -void SetPrefMatchSyntaxBased(int state);
11526 -int GetPrefMatchSyntaxBased(void);
11527 void SetPrefHighlightSyntax(Boolean state);
11528 Boolean GetPrefHighlightSyntax(void);
11529 void SetPrefBacklightChars(int state);
11530 int GetPrefBacklightChars(void);
11531 void SetPrefBacklightCharTypes(char *types);
11532 @@ -189,11 +187,11 @@ int AllocatedStringsDiffer(const char *s
11533 void SetLanguageMode(WindowInfo *window, int mode, int forceNewDefaults);
11534 int FindLanguageMode(const char *languageName);
11535 void UnloadLanguageModeTipsFile(WindowInfo *window);
11536 void DetermineLanguageMode(WindowInfo *window, int forceNewDefaults);
11537 Widget CreateLanguageModeMenu(Widget parent, XtCallbackProc cbProc,
11538 - void *cbArg);
11539 + void *cbArg, int includePlain);
11540 void SetLangModeMenu(Widget optMenu, const char *modeName);
11541 void CreateLanguageModeSubMenu(WindowInfo* window, const Widget parent,
11542 const char* name, const char* label, const char mnemonic);
11543 void SetPrefFindReplaceUsesSelection(int state);
11544 int GetPrefFindReplaceUsesSelection(void);
11545 diff --quilt old/source/search.c new/source/search.c
11546 --- old/source/search.c
11547 +++ new/source/search.c
11548 @@ -83,10 +83,11 @@ static const char CVSID[] = "$Id: search
11550 #ifdef HAVE_DEBUG_H
11551 #include "../debug.h"
11552 #endif
11554 +#include "patternMatch.h"
11556 int NHist = 0;
11558 typedef struct _SelectionInfo {
11559 int done;
11560 @@ -171,10 +172,11 @@ static void freeWritableWindowsCB(Widget
11561 XmAnyCallbackStruct *callData);
11562 static void checkMultiReplaceListForDoomedW(WindowInfo* window,
11563 WindowInfo* doomedWindow);
11564 static void removeDoomedWindowFromList(WindowInfo* window, int index);
11565 static void unmanageReplaceDialogs(const WindowInfo *window);
11566 +static int getPosForMatchingCharacter(WindowInfo *window);
11567 static void flashTimeoutProc(XtPointer clientData, XtIntervalId *id);
11568 static void eraseFlash(WindowInfo *window);
11569 static int getReplaceDlogInfo(WindowInfo *window, int *direction,
11570 char *searchString, char *replaceString, int *searchType);
11571 static int getFindDlogInfo(WindowInfo *window, int *direction,
11572 @@ -211,13 +213,10 @@ static void downCaseString(char *outStri
11573 static void resetFindTabGroup(WindowInfo *window);
11574 static void resetReplaceTabGroup(WindowInfo *window);
11575 static int searchMatchesSelection(WindowInfo *window, const char *searchString,
11576 int searchType, int *left, int *right, int *searchExtentBW,
11577 int *searchExtentFW);
11578 -static int findMatchingChar(WindowInfo *window, char toMatch,
11579 - void *toMatchStyle, int charPos, int startLimit, int endLimit,
11580 - int *matchPos);
11581 static Boolean replaceUsingRE(const char* searchStr, const char* replaceStr,
11582 const char* sourceStr, int beginPos, char* destStr, int maxDestLen,
11583 int prevChar, const char* delimiters, int defaultFlags);
11584 static void saveSearchHistory(const char *searchString,
11585 const char *replaceString, int searchType, int isIncremental);
11586 @@ -251,28 +250,10 @@ typedef struct _charMatchTable {
11587 char c;
11588 char match;
11589 char direction;
11590 } charMatchTable;
11592 -#define N_MATCH_CHARS 13
11593 -#define N_FLASH_CHARS 6
11594 -static charMatchTable MatchingChars[N_MATCH_CHARS] = {
11595 - {'{', '}', SEARCH_FORWARD},
11596 - {'}', '{', SEARCH_BACKWARD},
11597 - {'(', ')', SEARCH_FORWARD},
11598 - {')', '(', SEARCH_BACKWARD},
11599 - {'[', ']', SEARCH_FORWARD},
11600 - {']', '[', SEARCH_BACKWARD},
11601 - {'<', '>', SEARCH_FORWARD},
11602 - {'>', '<', SEARCH_BACKWARD},
11603 - {'/', '/', SEARCH_FORWARD},
11604 - {'"', '"', SEARCH_FORWARD},
11605 - {'\'', '\'', SEARCH_FORWARD},
11606 - {'`', '`', SEARCH_FORWARD},
11607 - {'\\', '\\', SEARCH_FORWARD},
11608 -};
11609 -
11610 /*
11611 ** Definitions for the search method strings, used as arguments for
11612 ** macro search subroutines and search action routines
11613 */
11614 static char *searchTypeStrings[] = {
11615 @@ -3345,22 +3326,22 @@ static void iSearchTextKeyEH(Widget w, W
11616 XmTextSetInsertionPosition(window->iSearchText,
11617 XmTextGetLastPosition(window->iSearchText));
11618 }
11620 /*
11621 -** Check the character before the insertion cursor of textW and flash
11622 -** matching parenthesis, brackets, or braces, by temporarily highlighting
11623 -** the matching character (a timer procedure is scheduled for removing the
11624 -** highlights)
11625 +** Check the characters before the insertion cursor of textW and flash
11626 +** matching patterns (parenthesis e.g. brackets, braces ..) by temporarily
11627 +** highlighting matching characters (a timer procedure is scheduled for
11628 +** removing the highlights)
11629 */
11630 void FlashMatching(WindowInfo *window, Widget textW)
11631 {
11632 - char c;
11633 - void *style;
11634 - int pos, matchIndex;
11635 - int startPos, endPos, searchPos, matchPos;
11636 + int pos;
11637 + int direction;
11638 + int startPos, endPos, matchPos, matchLen;
11639 int constrain;
11640 + MatchingType matchingType;
11642 /* if a marker is already drawn, erase it and cancel the timeout */
11643 if (window->flashTimeoutID != 0) {
11644 eraseFlash(window);
11645 XtRemoveTimeOut(window->flashTimeoutID);
11646 @@ -3374,52 +3355,47 @@ void FlashMatching(WindowInfo *window, W
11648 /* don't flash matching characters if there's a selection */
11649 if (window->buffer->primary.selected)
11650 return;
11652 - /* get the character to match and the position to start from */
11653 - pos = TextGetCursorPos(textW) - 1;
11654 + /* get the position to start from */
11655 + pos = TextGetCursorPos(textW);
11656 if (pos < 0)
11657 return;
11658 - c = BufGetCharacter(window->buffer, pos);
11659 - style = GetHighlightInfo(window, pos);
11660 -
11661 - /* is the character one we want to flash? */
11662 - for (matchIndex = 0; matchIndex<N_FLASH_CHARS; matchIndex++) {
11663 - if (MatchingChars[matchIndex].c == c)
11664 - break;
11665 - }
11666 - if (matchIndex == N_FLASH_CHARS)
11667 - return;
11669 /* constrain the search to visible text only when in single-pane mode
11670 AND using delimiter flashing (otherwise search the whole buffer) */
11671 constrain = ((window->nPanes == 0) &&
11672 (window->showMatchingStyle == FLASH_DELIMIT));
11674 - if (MatchingChars[matchIndex].direction == SEARCH_BACKWARD) {
11675 startPos = constrain ? TextFirstVisiblePos(textW) : 0;
11676 - endPos = pos;
11677 - searchPos = endPos;
11678 - } else {
11679 - startPos = pos;
11680 endPos = constrain ? TextLastVisiblePos(textW) :
11681 window->buffer->length;
11682 - searchPos = startPos;
11683 +
11684 + /* cursor pos. must be between start / end pos. */
11685 + if (pos < startPos || pos > endPos)
11686 + return;
11687 +
11688 + /* Pattern Match Feature: determine matching type
11689 + (here: flash delimiter or range) */
11690 + if (window->showMatchingStyle == FLASH_DELIMIT) {
11691 + matchingType = MT_FLASH_DELIMIT;
11692 + } else {
11693 + matchingType = MT_FLASH_RANGE;
11694 }
11696 - /* do the search */
11697 - if (!findMatchingChar(window, c, style, searchPos, startPos, endPos,
11698 - &matchPos))
11699 + /* Pattern Match Feature: do the search */
11700 + if (!FindMatchingString(window, matchingType, &pos, startPos, endPos,
11701 + &matchPos, &matchLen, &direction))
11702 return;
11704 if (window->showMatchingStyle == FLASH_DELIMIT) {
11705 - /* Highlight either the matching character ... */
11706 - BufHighlight(window->buffer, matchPos, matchPos+1);
11707 + /* Highlight either the matching characters ... */
11708 + BufHighlight(window->buffer, matchPos, matchPos + matchLen);
11709 } else {
11710 /* ... or the whole range. */
11711 - if (MatchingChars[matchIndex].direction == SEARCH_BACKWARD) {
11712 + if (direction == SEARCH_BACKWARD) {
11713 BufHighlight(window->buffer, matchPos, pos+1);
11714 } else {
11715 BufHighlight(window->buffer, matchPos+1, pos);
11716 }
11717 }
11718 @@ -3429,159 +3405,86 @@ void FlashMatching(WindowInfo *window, W
11719 XtWidgetToApplicationContext(window->shell), 1500,
11720 flashTimeoutProc, window);
11721 window->flashPos = matchPos;
11722 }
11724 -void SelectToMatchingCharacter(WindowInfo *window)
11725 +/*
11726 +** Pattern Match Feature:
11727 +** get position of the character to match from the selection, or
11728 +** the character before the insert point if nothing is selected.
11729 +**
11730 +*/
11731 +static int getPosForMatchingCharacter(WindowInfo *window)
11732 {
11733 + int pos;
11734 int selStart, selEnd;
11735 - int startPos, endPos, matchPos;
11736 textBuffer *buf = window->buffer;
11738 - /* get the character to match and its position from the selection, or
11739 - the character before the insert point if nothing is selected.
11740 - Give up if too many characters are selected */
11741 - if (!GetSimpleSelection(buf, &selStart, &selEnd)) {
11742 - selEnd = TextGetCursorPos(window->lastFocus);
11743 - if (window->overstrike)
11744 - selEnd += 1;
11745 - selStart = selEnd - 1;
11746 - if (selStart < 0) {
11747 - XBell(TheDisplay, 0);
11748 - return;
11749 - }
11750 + if (GetSimpleSelection(buf, &selStart, &selEnd)) {
11751 + pos = selEnd;
11752 }
11753 - if ((selEnd - selStart) != 1) {
11754 - XBell(TheDisplay, 0);
11755 - return;
11756 + else {
11757 + pos = TextGetCursorPos(window->lastFocus);
11758 }
11759 -
11760 +
11761 + return pos;
11762 +}
11763 +
11764 +void SelectToMatchingCharacter(WindowInfo *window)
11765 +{
11766 + int pos;
11767 + int startPos, endPos, matchPos, matchLen;
11768 + int direction;
11769 + textBuffer *buf = window->buffer;
11770 +
11771 + /* Pattern Match Feature: get position of the character to match */
11772 + pos = getPosForMatchingCharacter( window );
11773 +
11774 /* Search for it in the buffer */
11775 - if (!findMatchingChar(window, BufGetCharacter(buf, selStart),
11776 - GetHighlightInfo(window, selStart), selStart, 0, buf->length, &matchPos)) {
11777 + if (!FindMatchingString(window, MT_SELECT, &pos, 0,
11778 + buf->length, &matchPos, &matchLen, &direction)) {
11779 XBell(TheDisplay, 0);
11780 return;
11781 }
11782 - startPos = (matchPos > selStart) ? selStart : matchPos;
11783 - endPos = (matchPos > selStart) ? matchPos : selStart;
11784 + startPos = (matchPos > pos) ? pos : matchPos;
11785 + endPos = (matchPos > pos) ? matchPos : pos;
11787 /* select the text between the matching characters */
11788 XtVaSetValues(window->lastFocus, textNautoShowInsertPos, False, NULL);
11789 BufSelect(buf, startPos, endPos+1);
11790 MakeSelectionVisible(window, window->lastFocus);
11791 XtVaSetValues(window->lastFocus, textNautoShowInsertPos, True, NULL);
11792 }
11794 void GotoMatchingCharacter(WindowInfo *window)
11795 {
11796 - int selStart, selEnd;
11797 - int matchPos;
11798 + int pos;
11799 + int matchPos, matchLen;
11800 + int direction;
11801 textBuffer *buf = window->buffer;
11803 - /* get the character to match and its position from the selection, or
11804 - the character before the insert point if nothing is selected.
11805 - Give up if too many characters are selected */
11806 - if (!GetSimpleSelection(buf, &selStart, &selEnd)) {
11807 - selEnd = TextGetCursorPos(window->lastFocus);
11808 - if (window->overstrike)
11809 - selEnd += 1;
11810 - selStart = selEnd - 1;
11811 - if (selStart < 0) {
11812 - XBell(TheDisplay, 0);
11813 - return;
11814 - }
11815 - }
11816 - if ((selEnd - selStart) != 1) {
11817 - XBell(TheDisplay, 0);
11818 - return;
11819 - }
11820 + /* Pattern Match Feature: get position of the character to match */
11821 + pos = getPosForMatchingCharacter( window );
11823 /* Search for it in the buffer */
11824 - if (!findMatchingChar(window, BufGetCharacter(buf, selStart),
11825 - GetHighlightInfo(window, selStart), selStart, 0,
11826 - buf->length, &matchPos)) {
11827 + if (!FindMatchingString(window, MT_GOTO, &pos, 0,
11828 + buf->length, &matchPos, &matchLen, &direction)) {
11829 XBell(TheDisplay, 0);
11830 return;
11831 }
11833 /* temporarily shut off autoShowInsertPos before setting the cursor
11834 position so MakeSelectionVisible gets a chance to place the cursor
11835 string at a pleasing position on the screen (otherwise, the cursor would
11836 be automatically scrolled on screen and MakeSelectionVisible would do
11837 nothing) */
11838 XtVaSetValues(window->lastFocus, textNautoShowInsertPos, False, NULL);
11839 - TextSetCursorPos(window->lastFocus, matchPos+1);
11840 + TextSetCursorPos(window->lastFocus, matchPos);
11841 MakeSelectionVisible(window, window->lastFocus);
11842 XtVaSetValues(window->lastFocus, textNautoShowInsertPos, True, NULL);
11843 }
11845 -static int findMatchingChar(WindowInfo *window, char toMatch,
11846 - void* styleToMatch, int charPos, int startLimit, int endLimit,
11847 - int *matchPos)
11848 -{
11849 - int nestDepth, matchIndex, direction, beginPos, pos;
11850 - char matchChar, c;
11851 - void *style = NULL;
11852 - textBuffer *buf = window->buffer;
11853 - int matchSyntaxBased = window->matchSyntaxBased;
11854 -
11855 - /* If we don't match syntax based, fake a matching style. */
11856 - if (!matchSyntaxBased) style = styleToMatch;
11857 -
11858 - /* Look up the matching character and match direction */
11859 - for (matchIndex = 0; matchIndex<N_MATCH_CHARS; matchIndex++) {
11860 - if (MatchingChars[matchIndex].c == toMatch)
11861 - break;
11862 - }
11863 - if (matchIndex == N_MATCH_CHARS)
11864 - return FALSE;
11865 - matchChar = MatchingChars[matchIndex].match;
11866 - direction = MatchingChars[matchIndex].direction;
11867 -
11868 - /* find it in the buffer */
11869 - beginPos = (direction==SEARCH_FORWARD) ? charPos+1 : charPos-1;
11870 - nestDepth = 1;
11871 - if (direction == SEARCH_FORWARD) {
11872 - for (pos=beginPos; pos<endLimit; pos++) {
11873 - c=BufGetCharacter(buf, pos);
11874 - if (c == matchChar) {
11875 - if (matchSyntaxBased) style = GetHighlightInfo(window, pos);
11876 - if (style == styleToMatch) {
11877 - nestDepth--;
11878 - if (nestDepth == 0) {
11879 - *matchPos = pos;
11880 - return TRUE;
11881 - }
11882 - }
11883 - } else if (c == toMatch) {
11884 - if (matchSyntaxBased) style = GetHighlightInfo(window, pos);
11885 - if (style == styleToMatch)
11886 - nestDepth++;
11887 - }
11888 - }
11889 - } else { /* SEARCH_BACKWARD */
11890 - for (pos=beginPos; pos>=startLimit; pos--) {
11891 - c=BufGetCharacter(buf, pos);
11892 - if (c == matchChar) {
11893 - if (matchSyntaxBased) style = GetHighlightInfo(window, pos);
11894 - if (style == styleToMatch) {
11895 - nestDepth--;
11896 - if (nestDepth == 0) {
11897 - *matchPos = pos;
11898 - return TRUE;
11899 - }
11900 - }
11901 - } else if (c == toMatch) {
11902 - if (matchSyntaxBased) style = GetHighlightInfo(window, pos);
11903 - if (style == styleToMatch)
11904 - nestDepth++;
11905 - }
11906 - }
11907 - }
11908 - return FALSE;
11909 -}
11910 -
11911 /*
11912 ** Xt timer procedure for erasing the matching parenthesis marker.
11913 */
11914 static void flashTimeoutProc(XtPointer clientData, XtIntervalId *id)
11915 {
11916 diff --quilt old/source/smartIndent.c new/source/smartIndent.c
11917 --- old/source/smartIndent.c
11918 +++ new/source/smartIndent.c
11919 @@ -978,13 +978,13 @@ void EditSmartIndentMacros(WindowInfo *w
11920 XmNleftPosition, 1,
11921 XmNtopAttachment, XmATTACH_POSITION,
11922 XmNtopPosition, 1,
11923 XmNrightAttachment, XmATTACH_POSITION,
11924 XmNrightPosition, 99, NULL);
11925 -
11926 + /* Pattern Match Feature: don't include "PLAIN" (4th parameter) */
11927 SmartIndentDialog.lmPulldown = CreateLanguageModeMenu(lmForm, langModeCB,
11928 - NULL);
11929 + NULL, FALSE);
11930 n = 0;
11931 XtSetArg(args[n], XmNspacing, 0); n++;
11932 XtSetArg(args[n], XmNmarginWidth, 0); n++;
11933 XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
11934 XtSetArg(args[n], XmNleftAttachment, XmATTACH_POSITION); n++;
11935 @@ -2150,12 +2150,13 @@ void UpdateLangModeMenuSmartIndent(void)
11937 if (SmartIndentDialog.shell == NULL)
11938 return;
11940 oldMenu = SmartIndentDialog.lmPulldown;
11941 + /* Pattern Match Feature: don't include "PLAIN" (4th parameter) */
11942 SmartIndentDialog.lmPulldown = CreateLanguageModeMenu(
11943 - XtParent(XtParent(oldMenu)), langModeCB, NULL);
11944 + XtParent(XtParent(oldMenu)), langModeCB, NULL, FALSE);
11945 XtVaSetValues(XmOptionButtonGadget(SmartIndentDialog.lmOptMenu),
11946 XmNsubMenuId, SmartIndentDialog.lmPulldown, NULL);
11947 SetLangModeMenu(SmartIndentDialog.lmOptMenu, SmartIndentDialog.langModeName);
11949 XtDestroyWidget(oldMenu);
11950 diff --quilt old/source/window.c new/source/window.c
11951 --- old/source/window.c
11952 +++ new/source/window.c
11953 @@ -53,10 +53,11 @@ static const char CVSID[] = "$Id: window
11954 #include "nedit.bm"
11955 #include "n.bm"
11956 #include "windowTitle.h"
11957 #include "interpret.h"
11958 #include "rangeset.h"
11959 +#include "patternMatchData.h"
11960 #include "../util/clearcase.h"
11961 #include "../util/misc.h"
11962 #include "../util/fileUtils.h"
11963 #include "../util/utils.h"
11964 #include "../util/fileUtils.h"
11965 @@ -272,11 +273,10 @@ WindowInfo *CreateWindow(const char *nam
11966 window->saveOldVersion = GetPrefSaveOldVersion();
11967 window->wrapMode = GetPrefWrap(PLAIN_LANGUAGE_MODE);
11968 window->showWrapMargin = GetPrefShowWrapMargin();
11969 window->overstrike = False;
11970 window->showMatchingStyle = GetPrefShowMatching();
11971 - window->matchSyntaxBased = GetPrefMatchSyntaxBased();
11972 window->showStats = GetPrefStatsLine();
11973 window->showISearchLine = GetPrefISearchLine();
11974 window->showLineNumbers = GetPrefLineNums();
11975 window->highlightSyntax = GetPrefHighlightSyntax();
11976 window->backlightCharTypes = NULL;
11977 @@ -311,10 +311,14 @@ WindowInfo *CreateWindow(const char *nam
11978 window->highlightData = NULL;
11979 window->shellCmdData = NULL;
11980 window->macroCmdData = NULL;
11981 window->smartIndentData = NULL;
11982 window->languageMode = PLAIN_LANGUAGE_MODE;
11983 +
11984 + /* Pattern Match Feature: assign "PLAIN" string match table*/
11985 + window->stringMatchTable = FindStringMatchTable(NULL);
11986 +
11987 window->iSearchHistIndex = 0;
11988 window->iSearchStartPos = -1;
11989 window->replaceLastRegexCase = TRUE;
11990 window->replaceLastLiteralCase = FALSE;
11991 window->iSearchLastRegexCase = TRUE;
11992 @@ -3430,11 +3434,10 @@ WindowInfo* CreateDocument(WindowInfo* s
11993 window->saveOldVersion = GetPrefSaveOldVersion();
11994 window->wrapMode = GetPrefWrap(PLAIN_LANGUAGE_MODE);
11995 window->showWrapMargin = GetPrefShowWrapMargin();
11996 window->overstrike = False;
11997 window->showMatchingStyle = GetPrefShowMatching();
11998 - window->matchSyntaxBased = GetPrefMatchSyntaxBased();
11999 window->highlightSyntax = GetPrefHighlightSyntax();
12000 window->backlightCharTypes = NULL;
12001 window->backlightChars = GetPrefBacklightChars();
12002 if (window->backlightChars) {
12003 char *cTypes = GetPrefBacklightCharTypes();
12004 @@ -3465,10 +3468,16 @@ WindowInfo* CreateDocument(WindowInfo* s
12005 window->highlightData = NULL;
12006 window->shellCmdData = NULL;
12007 window->macroCmdData = NULL;
12008 window->smartIndentData = NULL;
12009 window->languageMode = PLAIN_LANGUAGE_MODE;
12010 +
12011 + /*
12012 + * Pattern Match Feature:
12013 + */
12014 + window->stringMatchTable = FindStringMatchTable(NULL);
12015 +
12016 window->iSearchHistIndex = 0;
12017 window->iSearchStartPos = -1;
12018 window->replaceLastRegexCase = TRUE;
12019 window->replaceLastLiteralCase = FALSE;
12020 window->iSearchLastRegexCase = TRUE;
12021 @@ -3857,11 +3866,10 @@ void RefreshMenuToggleStates(WindowInfo
12022 #ifndef VMS
12023 XmToggleButtonSetState(window->saveLastItem, window->saveOldVersion, False);
12024 #endif
12025 XmToggleButtonSetState(window->autoSaveItem, window->autoSave, False);
12026 XmToggleButtonSetState(window->overtypeModeItem, window->overstrike, False);
12027 - XmToggleButtonSetState(window->matchSyntaxBasedItem, window->matchSyntaxBased, False);
12028 XmToggleButtonSetState(window->readOnlyItem, IS_USER_LOCKED(window->lockReasons), False);
12029 XmToggleButtonSetState(window->transientItem, window->transient, False);
12031 XtSetSensitive(window->smartIndentItem,
12032 SmartIndentMacrosAvailable(LanguageModeName(window->languageMode)));
12033 @@ -4421,10 +4429,13 @@ static void cloneDocument(WindowInfo *wi
12034 window->languageMode = orgWin->languageMode;
12035 window->highlightSyntax = orgWin->highlightSyntax;
12036 if (window->highlightSyntax)
12037 StartHighlighting(window, False);
12039 + /* recycle the pattern match data */
12040 + window->stringMatchTable = orgWin->stringMatchTable;
12041 +
12042 /* copy states of original document */
12043 window->filenameSet = orgWin->filenameSet;
12044 window->fileFormat = orgWin->fileFormat;
12045 window->lastModTime = orgWin->lastModTime;
12046 window->fileChanged = orgWin->fileChanged;
12047 @@ -4438,11 +4449,10 @@ static void cloneDocument(WindowInfo *wi
12048 window->autoSave = orgWin->autoSave;
12049 window->saveOldVersion = orgWin->saveOldVersion;
12050 window->wrapMode = orgWin->wrapMode;
12051 SetOverstrike(window, orgWin->overstrike);
12052 window->showMatchingStyle = orgWin->showMatchingStyle;
12053 - window->matchSyntaxBased = orgWin->matchSyntaxBased;
12054 #if 0
12055 window->showStats = orgWin->showStats;
12056 window->showISearchLine = orgWin->showISearchLine;
12057 window->showLineNumbers = orgWin->showLineNumbers;
12058 window->modeMessageDisplayed = orgWin->modeMessageDisplayed;