projects / catagits/Gitalist.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | history | HEAD
Add built local::lib
[catagits/Gitalist.git] / local-lib5 / lib / perl5 / Syntax / Highlight / Engine / Kate / Logtalk.pm
CommitLineData
3fea05b9 1# Copyright (c) 2005 - 2006 Hans Jeuken. All rights reserved.
2# This program is free software; you can redistribute it and/or
3# modify it under the same terms as Perl itself.
4
5# This file was generated from the 'logtalk.xml' file of the syntax highlight
6# engine of the kate text editor (http://www.kate-editor.org
7
8#kate xml version 1.40
9#kate version 2.4
10#kate author Paulo Moura (pmoura@logtalk.org)
11#generated: Sun Feb 3 22:02:05 2008, localtime
12
13package Syntax::Highlight::Engine::Kate::Logtalk;
14
15our $VERSION = '0.06';
16
17use strict;
18use warnings;
19use base('Syntax::Highlight::Engine::Kate::Template');
20
21sub new {
22 my $proto = shift;
23 my $class = ref($proto) || $proto;
24 my $self = $class->SUPER::new(@_);
25 $self->attributes({
26 'Built-in' => 'Keyword',
27 'Comment' => 'Comment',
28 'Directive' => 'Keyword',
29 'Normal' => 'Normal',
30 'Number' => 'DecVal',
31 'Operator' => 'DataType',
32 'String' => 'String',
33 'Variable' => 'Others',
34 });
35 $self->contextdata({
36 'atom' => {
37 callback => \&parseatom,
38 attribute => 'String',
39 },
40 'directive' => {
41 callback => \&parsedirective,
42 attribute => 'Directive',
43 },
44 'entityrelations' => {
45 callback => \&parseentityrelations,
46 attribute => 'Normal',
47 },
48 'multiline comment' => {
49 callback => \&parsemultilinecomment,
50 attribute => 'Comment',
51 },
52 'normal' => {
53 callback => \&parsenormal,
54 attribute => 'Normal',
55 },
56 'single line comment' => {
57 callback => \&parsesinglelinecomment,
58 attribute => 'Comment',
59 lineending => '#pop',
60 },
61 'string' => {
62 callback => \&parsestring,
63 attribute => 'String',
64 },
65 });
66 $self->deliminators('\\s||\\.|\\(|\\)|:|\\!|\\+|,|-|<|=|>|\\%|\\&|\\*|\\/|;|\\?|\\[|\\]|\\^|\\{|\\||\\}|\\~|\\\\');
67 $self->basecontext('normal');
68 $self->keywordscase(1);
69 $self->initialize;
70 bless ($self, $class);
71 return $self;
72}
73
74sub language {
75 return 'Logtalk';
76}
77
78sub parseatom {
79 my ($self, $text) = @_;
80 # attribute => 'String'
81 # char => '''
82 # context => '#pop'
83 # type => 'DetectChar'
84 if ($self->testDetectChar($text, '\'', 0, 0, 0, undef, 0, '#pop', 'String')) {
85 return 1
86 }
87 return 0;
88};
89
90sub parsedirective {
91 my ($self, $text) = @_;
92 # String => '\b(category|object|protocol)(?=[(])'
93 # attribute => 'Directive'
94 # beginRegion => 'Entity'
95 # context => 'entityrelations'
96 # type => 'RegExpr'
97 if ($self->testRegExpr($text, '\\b(category|object|protocol)(?=[(])', 0, 0, 0, undef, 0, 'entityrelations', 'Directive')) {
98 return 1
99 }
100 # String => '\bend_(category|object|protocol)[.]'
101 # attribute => 'Directive'
102 # context => '#pop'
103 # endRegion => 'Entity'
104 # type => 'RegExpr'
105 if ($self->testRegExpr($text, '\\bend_(category|object|protocol)[.]', 0, 0, 0, undef, 0, '#pop', 'Directive')) {
106 return 1
107 }
108 # String => '\bp(ublic|r(otected|ivate))(?=[(])'
109 # attribute => 'Directive'
110 # context => '#pop'
111 # type => 'RegExpr'
112 if ($self->testRegExpr($text, '\\bp(ublic|r(otected|ivate))(?=[(])', 0, 0, 0, undef, 0, '#pop', 'Directive')) {
113 return 1
114 }
115 # String => '\bencoding(?=[(])'
116 # attribute => 'Directive'
117 # context => '#pop'
118 # type => 'RegExpr'
119 if ($self->testRegExpr($text, '\\bencoding(?=[(])', 0, 0, 0, undef, 0, '#pop', 'Directive')) {
120 return 1
121 }
122 # String => '\bin(fo|itialization)(?=[(])'
123 # attribute => 'Directive'
124 # context => '#pop'
125 # type => 'RegExpr'
126 if ($self->testRegExpr($text, '\\bin(fo|itialization)(?=[(])', 0, 0, 0, undef, 0, '#pop', 'Directive')) {
127 return 1
128 }
129 # String => '\bdynamic[.]'
130 # attribute => 'Directive'
131 # context => '#pop'
132 # type => 'RegExpr'
133 if ($self->testRegExpr($text, '\\bdynamic[.]', 0, 0, 0, undef, 0, '#pop', 'Directive')) {
134 return 1
135 }
136 # String => '\b(alias|d(ynamic|iscontiguous)|m(etapredicate|ode|ultifile))(?=[(])'
137 # attribute => 'Directive'
138 # context => '#pop'
139 # type => 'RegExpr'
140 if ($self->testRegExpr($text, '\\b(alias|d(ynamic|iscontiguous)|m(etapredicate|ode|ultifile))(?=[(])', 0, 0, 0, undef, 0, '#pop', 'Directive')) {
141 return 1
142 }
143 # String => '\bop(?=[(])'
144 # attribute => 'Directive'
145 # context => '#pop'
146 # type => 'RegExpr'
147 if ($self->testRegExpr($text, '\\bop(?=[(])', 0, 0, 0, undef, 0, '#pop', 'Directive')) {
148 return 1
149 }
150 # String => '\b(calls|uses)(?=[(])'
151 # attribute => 'Directive'
152 # context => '#pop'
153 # type => 'RegExpr'
154 if ($self->testRegExpr($text, '\\b(calls|uses)(?=[(])', 0, 0, 0, undef, 0, '#pop', 'Directive')) {
155 return 1
156 }
157 return 0;
158};
159
160sub parseentityrelations {
161 my ($self, $text) = @_;
162 # String => '\b(extends|i(nstantiates|mp(lements|orts))|specializes)(?=[(])'
163 # attribute => 'Directive'
164 # context => '#stay'
165 # type => 'RegExpr'
166 if ($self->testRegExpr($text, '\\b(extends|i(nstantiates|mp(lements|orts))|specializes)(?=[(])', 0, 0, 0, undef, 0, '#stay', 'Directive')) {
167 return 1
168 }
169 # attribute => 'Normal'
170 # char => ')'
171 # char1 => '.'
172 # context => 'normal'
173 # type => 'Detect2Chars'
174 if ($self->testDetect2Chars($text, ')', '.', 0, 0, 0, undef, 0, 'normal', 'Normal')) {
175 return 1
176 }
177 return 0;
178};
179
180sub parsemultilinecomment {
181 my ($self, $text) = @_;
182 # attribute => 'Comment'
183 # char => '*'
184 # char1 => '/'
185 # context => '#pop'
186 # endRegion => 'Comment'
187 # type => 'Detect2Chars'
188 if ($self->testDetect2Chars($text, '*', '/', 0, 0, 0, undef, 0, '#pop', 'Comment')) {
189 return 1
190 }
191 return 0;
192};
193
194sub parsenormal {
195 my ($self, $text) = @_;
196 # String => '^\s*:-'
197 # attribute => 'Normal'
198 # context => 'directive'
199 # type => 'RegExpr'
200 if ($self->testRegExpr($text, '^\\s*:-', 0, 0, 0, undef, 0, 'directive', 'Normal')) {
201 return 1
202 }
203 # String => '\b(after|before)(?=[(])'
204 # attribute => 'Built-in'
205 # context => '#stay'
206 # type => 'RegExpr'
207 if ($self->testRegExpr($text, '\\b(after|before)(?=[(])', 0, 0, 0, undef, 0, '#stay', 'Built-in')) {
208 return 1
209 }
210 # String => '\b(parameter|this|se(lf|nder))(?=[(])'
211 # attribute => 'Built-in'
212 # context => '#stay'
213 # type => 'RegExpr'
214 if ($self->testRegExpr($text, '\\b(parameter|this|se(lf|nder))(?=[(])', 0, 0, 0, undef, 0, '#stay', 'Built-in')) {
215 return 1
216 }
217 # String => '\b(current_predicate|predicate_property)(?=[(])'
218 # attribute => 'Built-in'
219 # context => '#stay'
220 # type => 'RegExpr'
221 if ($self->testRegExpr($text, '\\b(current_predicate|predicate_property)(?=[(])', 0, 0, 0, undef, 0, '#stay', 'Built-in')) {
222 return 1
223 }
224 # String => '\b(expand_term|phrase)(?=[(])'
225 # attribute => 'Built-in'
226 # context => '#stay'
227 # type => 'RegExpr'
228 if ($self->testRegExpr($text, '\\b(expand_term|phrase)(?=[(])', 0, 0, 0, undef, 0, '#stay', 'Built-in')) {
229 return 1
230 }
231 # String => '\b(abolish|c(reate|urrent))_(object|protocol|category)(?=[(])'
232 # attribute => 'Built-in'
233 # context => '#stay'
234 # type => 'RegExpr'
235 if ($self->testRegExpr($text, '\\b(abolish|c(reate|urrent))_(object|protocol|category)(?=[(])', 0, 0, 0, undef, 0, '#stay', 'Built-in')) {
236 return 1
237 }
238 # String => '\b(object|protocol|category)_property(?=[(])'
239 # attribute => 'Built-in'
240 # context => '#stay'
241 # type => 'RegExpr'
242 if ($self->testRegExpr($text, '\\b(object|protocol|category)_property(?=[(])', 0, 0, 0, undef, 0, '#stay', 'Built-in')) {
243 return 1
244 }
245 # String => '\bextends_(object|protocol)(?=[(])'
246 # attribute => 'Built-in'
247 # context => '#stay'
248 # type => 'RegExpr'
249 if ($self->testRegExpr($text, '\\bextends_(object|protocol)(?=[(])', 0, 0, 0, undef, 0, '#stay', 'Built-in')) {
250 return 1
251 }
252 # String => '\bimplements_protocol(?=[(])'
253 # attribute => 'Built-in'
254 # context => '#stay'
255 # type => 'RegExpr'
256 if ($self->testRegExpr($text, '\\bimplements_protocol(?=[(])', 0, 0, 0, undef, 0, '#stay', 'Built-in')) {
257 return 1
258 }
259 # String => '\b(instantiates|specializes)_class(?=[(])'
260 # attribute => 'Built-in'
261 # context => '#stay'
262 # type => 'RegExpr'
263 if ($self->testRegExpr($text, '\\b(instantiates|specializes)_class(?=[(])', 0, 0, 0, undef, 0, '#stay', 'Built-in')) {
264 return 1
265 }
266 # String => '\bimports_category(?=[(])'
267 # attribute => 'Built-in'
268 # context => '#stay'
269 # type => 'RegExpr'
270 if ($self->testRegExpr($text, '\\bimports_category(?=[(])', 0, 0, 0, undef, 0, '#stay', 'Built-in')) {
271 return 1
272 }
273 # String => '\b(current_event|(abolish|define)_events)(?=[(])'
274 # attribute => 'Built-in'
275 # context => '#stay'
276 # type => 'RegExpr'
277 if ($self->testRegExpr($text, '\\b(current_event|(abolish|define)_events)(?=[(])', 0, 0, 0, undef, 0, '#stay', 'Built-in')) {
278 return 1
279 }
280 # String => '\b(current|set)_logtalk_flag(?=[(])'
281 # attribute => 'Built-in'
282 # context => '#stay'
283 # type => 'RegExpr'
284 if ($self->testRegExpr($text, '\\b(current|set)_logtalk_flag(?=[(])', 0, 0, 0, undef, 0, '#stay', 'Built-in')) {
285 return 1
286 }
287 # String => '\blogtalk_(compile|l(ibrary_path|oad))(?=[(])'
288 # attribute => 'Built-in'
289 # context => '#stay'
290 # type => 'RegExpr'
291 if ($self->testRegExpr($text, '\\blogtalk_(compile|l(ibrary_path|oad))(?=[(])', 0, 0, 0, undef, 0, '#stay', 'Built-in')) {
292 return 1
293 }
294 # String => '\b(clause|retract(all)?)(?=[(])'
295 # attribute => 'Built-in'
296 # context => '#stay'
297 # type => 'RegExpr'
298 if ($self->testRegExpr($text, '\\b(clause|retract(all)?)(?=[(])', 0, 0, 0, undef, 0, '#stay', 'Built-in')) {
299 return 1
300 }
301 # String => '\ba(bolish|ssert(a|z))(?=[(])'
302 # attribute => 'Built-in'
303 # context => '#stay'
304 # type => 'RegExpr'
305 if ($self->testRegExpr($text, '\\ba(bolish|ssert(a|z))(?=[(])', 0, 0, 0, undef, 0, '#stay', 'Built-in')) {
306 return 1
307 }
308 # String => '\b(ca(ll|tch)|throw)(?=[(])'
309 # attribute => 'Built-in'
310 # context => '#stay'
311 # type => 'RegExpr'
312 if ($self->testRegExpr($text, '\\b(ca(ll|tch)|throw)(?=[(])', 0, 0, 0, undef, 0, '#stay', 'Built-in')) {
313 return 1
314 }
315 # String => '\b(fail|true)\b'
316 # attribute => 'Built-in'
317 # context => '#stay'
318 # type => 'RegExpr'
319 if ($self->testRegExpr($text, '\\b(fail|true)\\b', 0, 0, 0, undef, 0, '#stay', 'Built-in')) {
320 return 1
321 }
322 # String => '\b((bag|set)of|f(ind|or)all)(?=[(])'
323 # attribute => 'Built-in'
324 # context => '#stay'
325 # type => 'RegExpr'
326 if ($self->testRegExpr($text, '\\b((bag|set)of|f(ind|or)all)(?=[(])', 0, 0, 0, undef, 0, '#stay', 'Built-in')) {
327 return 1
328 }
329 # String => '\bunify_with_occurs_check(?=[(])'
330 # attribute => 'Built-in'
331 # context => '#stay'
332 # type => 'RegExpr'
333 if ($self->testRegExpr($text, '\\bunify_with_occurs_check(?=[(])', 0, 0, 0, undef, 0, '#stay', 'Built-in')) {
334 return 1
335 }
336 # String => '\b(functor|arg|copy_term)(?=[(])'
337 # attribute => 'Built-in'
338 # context => '#stay'
339 # type => 'RegExpr'
340 if ($self->testRegExpr($text, '\\b(functor|arg|copy_term)(?=[(])', 0, 0, 0, undef, 0, '#stay', 'Built-in')) {
341 return 1
342 }
343 # String => '\b(rem|mod|abs|sign)(?=[(])'
344 # attribute => 'Built-in'
345 # context => '#stay'
346 # type => 'RegExpr'
347 if ($self->testRegExpr($text, '\\b(rem|mod|abs|sign)(?=[(])', 0, 0, 0, undef, 0, '#stay', 'Built-in')) {
348 return 1
349 }
350 # String => '\bfloat(_(integer|fractional)_part)?(?=[(])'
351 # attribute => 'Built-in'
352 # context => '#stay'
353 # type => 'RegExpr'
354 if ($self->testRegExpr($text, '\\bfloat(_(integer|fractional)_part)?(?=[(])', 0, 0, 0, undef, 0, '#stay', 'Built-in')) {
355 return 1
356 }
357 # String => '\b(floor|truncate|round|ceiling)(?=[(])'
358 # attribute => 'Built-in'
359 # context => '#stay'
360 # type => 'RegExpr'
361 if ($self->testRegExpr($text, '\\b(floor|truncate|round|ceiling)(?=[(])', 0, 0, 0, undef, 0, '#stay', 'Built-in')) {
362 return 1
363 }
364 # String => '\b(cos|atan|exp|log|s(in|qrt))(?=[(])'
365 # attribute => 'Built-in'
366 # context => '#stay'
367 # type => 'RegExpr'
368 if ($self->testRegExpr($text, '\\b(cos|atan|exp|log|s(in|qrt))(?=[(])', 0, 0, 0, undef, 0, '#stay', 'Built-in')) {
369 return 1
370 }
371 # String => '\b(var|atom(ic)?|integer|float|compound|n(onvar|umber))(?=[(])'
372 # attribute => 'Built-in'
373 # context => '#stay'
374 # type => 'RegExpr'
375 if ($self->testRegExpr($text, '\\b(var|atom(ic)?|integer|float|compound|n(onvar|umber))(?=[(])', 0, 0, 0, undef, 0, '#stay', 'Built-in')) {
376 return 1
377 }
378 # String => '\b(current|set)_(in|out)put(?=[(])'
379 # attribute => 'Built-in'
380 # context => '#stay'
381 # type => 'RegExpr'
382 if ($self->testRegExpr($text, '\\b(current|set)_(in|out)put(?=[(])', 0, 0, 0, undef, 0, '#stay', 'Built-in')) {
383 return 1
384 }
385 # String => '\b(open|close)(?=[(])'
386 # attribute => 'Built-in'
387 # context => '#stay'
388 # type => 'RegExpr'
389 if ($self->testRegExpr($text, '\\b(open|close)(?=[(])', 0, 0, 0, undef, 0, '#stay', 'Built-in')) {
390 return 1
391 }
392 # String => '\bflush_output(?=[(])'
393 # attribute => 'Built-in'
394 # context => '#stay'
395 # type => 'RegExpr'
396 if ($self->testRegExpr($text, '\\bflush_output(?=[(])', 0, 0, 0, undef, 0, '#stay', 'Built-in')) {
397 return 1
398 }
399 # String => '\bflush_output\b'
400 # attribute => 'Built-in'
401 # context => '#stay'
402 # type => 'RegExpr'
403 if ($self->testRegExpr($text, '\\bflush_output\\b', 0, 0, 0, undef, 0, '#stay', 'Built-in')) {
404 return 1
405 }
406 # String => '\b(stream_property|at_end_of_stream|set_stream_position)(?=[(])'
407 # attribute => 'Built-in'
408 # context => '#stay'
409 # type => 'RegExpr'
410 if ($self->testRegExpr($text, '\\b(stream_property|at_end_of_stream|set_stream_position)(?=[(])', 0, 0, 0, undef, 0, '#stay', 'Built-in')) {
411 return 1
412 }
413 # String => '\b(nl|(get|peek|put)_(byte|c(har|ode)))(?=[(])'
414 # attribute => 'Built-in'
415 # context => '#stay'
416 # type => 'RegExpr'
417 if ($self->testRegExpr($text, '\\b(nl|(get|peek|put)_(byte|c(har|ode)))(?=[(])', 0, 0, 0, undef, 0, '#stay', 'Built-in')) {
418 return 1
419 }
420 # String => '\bnl\b'
421 # attribute => 'Built-in'
422 # context => '#stay'
423 # type => 'RegExpr'
424 if ($self->testRegExpr($text, '\\bnl\\b', 0, 0, 0, undef, 0, '#stay', 'Built-in')) {
425 return 1
426 }
427 # String => '\bread(_term)?(?=[(])'
428 # attribute => 'Built-in'
429 # context => '#stay'
430 # type => 'RegExpr'
431 if ($self->testRegExpr($text, '\\bread(_term)?(?=[(])', 0, 0, 0, undef, 0, '#stay', 'Built-in')) {
432 return 1
433 }
434 # String => '\bwrite(q|_(canonical|term))?(?=[(])'
435 # attribute => 'Built-in'
436 # context => '#stay'
437 # type => 'RegExpr'
438 if ($self->testRegExpr($text, '\\bwrite(q|_(canonical|term))?(?=[(])', 0, 0, 0, undef, 0, '#stay', 'Built-in')) {
439 return 1
440 }
441 # String => '\b(current_)?op(?=[(])'
442 # attribute => 'Built-in'
443 # context => '#stay'
444 # type => 'RegExpr'
445 if ($self->testRegExpr($text, '\\b(current_)?op(?=[(])', 0, 0, 0, undef, 0, '#stay', 'Built-in')) {
446 return 1
447 }
448 # String => '\b(current_)?char_conversion(?=[(])'
449 # attribute => 'Built-in'
450 # context => '#stay'
451 # type => 'RegExpr'
452 if ($self->testRegExpr($text, '\\b(current_)?char_conversion(?=[(])', 0, 0, 0, undef, 0, '#stay', 'Built-in')) {
453 return 1
454 }
455 # String => '\batom_(length|c(hars|o(ncat|des)))(?=[(])'
456 # attribute => 'Built-in'
457 # context => '#stay'
458 # type => 'RegExpr'
459 if ($self->testRegExpr($text, '\\batom_(length|c(hars|o(ncat|des)))(?=[(])', 0, 0, 0, undef, 0, '#stay', 'Built-in')) {
460 return 1
461 }
462 # String => '\b(char_code|sub_atom)(?=[(])'
463 # attribute => 'Built-in'
464 # context => '#stay'
465 # type => 'RegExpr'
466 if ($self->testRegExpr($text, '\\b(char_code|sub_atom)(?=[(])', 0, 0, 0, undef, 0, '#stay', 'Built-in')) {
467 return 1
468 }
469 # String => '\bnumber_c(hars|odes)(?=[(])'
470 # attribute => 'Built-in'
471 # context => '#stay'
472 # type => 'RegExpr'
473 if ($self->testRegExpr($text, '\\bnumber_c(hars|odes)(?=[(])', 0, 0, 0, undef, 0, '#stay', 'Built-in')) {
474 return 1
475 }
476 # String => '\b(set|current)_prolog_flag(?=[(])'
477 # attribute => 'Built-in'
478 # context => '#stay'
479 # type => 'RegExpr'
480 if ($self->testRegExpr($text, '\\b(set|current)_prolog_flag(?=[(])', 0, 0, 0, undef, 0, '#stay', 'Built-in')) {
481 return 1
482 }
483 # String => '\bhalt\b'
484 # attribute => 'Built-in'
485 # context => '#stay'
486 # type => 'RegExpr'
487 if ($self->testRegExpr($text, '\\bhalt\\b', 0, 0, 0, undef, 0, '#stay', 'Built-in')) {
488 return 1
489 }
490 # String => '\bhalt(?=[(])'
491 # attribute => 'Built-in'
492 # context => '#stay'
493 # type => 'RegExpr'
494 if ($self->testRegExpr($text, '\\bhalt(?=[(])', 0, 0, 0, undef, 0, '#stay', 'Built-in')) {
495 return 1
496 }
497 # String => '\b[A-Z_]\w*'
498 # attribute => 'Variable'
499 # context => '#stay'
500 # type => 'RegExpr'
501 if ($self->testRegExpr($text, '\\b[A-Z_]\\w*', 0, 0, 0, undef, 0, '#stay', 'Variable')) {
502 return 1
503 }
504 # attribute => 'Comment'
505 # char => '%'
506 # context => 'single line comment'
507 # type => 'DetectChar'
508 if ($self->testDetectChar($text, '%', 0, 0, 0, undef, 0, 'single line comment', 'Comment')) {
509 return 1
510 }
511 # attribute => 'Comment'
512 # beginRegion => 'Comment'
513 # char => '/'
514 # char1 => '*'
515 # context => 'multiline comment'
516 # type => 'Detect2Chars'
517 if ($self->testDetect2Chars($text, '/', '*', 0, 0, 0, undef, 0, 'multiline comment', 'Comment')) {
518 return 1
519 }
520 # attribute => 'String'
521 # char => '"'
522 # context => 'string'
523 # type => 'DetectChar'
524 if ($self->testDetectChar($text, '"', 0, 0, 0, undef, 0, 'string', 'String')) {
525 return 1
526 }
527 # attribute => 'String'
528 # char => '''
529 # context => 'atom'
530 # type => 'DetectChar'
531 if ($self->testDetectChar($text, '\'', 0, 0, 0, undef, 0, 'atom', 'String')) {
532 return 1
533 }
534 # String => '0'.'
535 # attribute => 'Number'
536 # context => '#stay'
537 # type => 'RegExpr'
538 if ($self->testRegExpr($text, '0\'.', 0, 0, 0, undef, 0, '#stay', 'Number')) {
539 return 1
540 }
541 # String => '0b[0-1]+'
542 # attribute => 'Number'
543 # context => '#stay'
544 # type => 'RegExpr'
545 if ($self->testRegExpr($text, '0b[0-1]+', 0, 0, 0, undef, 0, '#stay', 'Number')) {
546 return 1
547 }
548 # String => '0o[0-7]+'
549 # attribute => 'Number'
550 # context => '#stay'
551 # type => 'RegExpr'
552 if ($self->testRegExpr($text, '0o[0-7]+', 0, 0, 0, undef, 0, '#stay', 'Number')) {
553 return 1
554 }
555 # String => '0x[0-9a-fA-F]+'
556 # attribute => 'Number'
557 # context => '#stay'
558 # type => 'RegExpr'
559 if ($self->testRegExpr($text, '0x[0-9a-fA-F]+', 0, 0, 0, undef, 0, '#stay', 'Number')) {
560 return 1
561 }
562 # String => '\d+(\.\d+)?([eE]([-+])?\d+)?'
563 # attribute => 'Number'
564 # context => '#stay'
565 # type => 'RegExpr'
566 if ($self->testRegExpr($text, '\\d+(\\.\\d+)?([eE]([-+])?\\d+)?', 0, 0, 0, undef, 0, '#stay', 'Number')) {
567 return 1
568 }
569 # attribute => 'Operator'
570 # char => ':'
571 # char1 => ':'
572 # context => '#stay'
573 # type => 'Detect2Chars'
574 if ($self->testDetect2Chars($text, ':', ':', 0, 0, 0, undef, 0, '#stay', 'Operator')) {
575 return 1
576 }
577 # attribute => 'Operator'
578 # char => '^'
579 # char1 => '^'
580 # context => '#stay'
581 # type => 'Detect2Chars'
582 if ($self->testDetect2Chars($text, '^', '^', 0, 0, 0, undef, 0, '#stay', 'Operator')) {
583 return 1
584 }
585 # attribute => 'Operator'
586 # beginRegion => 'external'
587 # char => '{'
588 # context => '#stay'
589 # type => 'DetectChar'
590 if ($self->testDetectChar($text, '{', 0, 0, 0, undef, 0, '#stay', 'Operator')) {
591 return 1
592 }
593 # attribute => 'Operator'
594 # char => '}'
595 # context => '#stay'
596 # endRegion => 'external'
597 # type => 'DetectChar'
598 if ($self->testDetectChar($text, '}', 0, 0, 0, undef, 0, '#stay', 'Operator')) {
599 return 1
600 }
601 # String => '\bonce(?=[(])'
602 # attribute => 'Built-in'
603 # context => '#stay'
604 # type => 'RegExpr'
605 if ($self->testRegExpr($text, '\\bonce(?=[(])', 0, 0, 0, undef, 0, '#stay', 'Built-in')) {
606 return 1
607 }
608 # String => '\brepeat\b'
609 # attribute => 'Built-in'
610 # context => '#stay'
611 # type => 'RegExpr'
612 if ($self->testRegExpr($text, '\\brepeat\\b', 0, 0, 0, undef, 0, '#stay', 'Built-in')) {
613 return 1
614 }
615 # attribute => 'Operator'
616 # char => '>'
617 # char1 => '>'
618 # context => '#stay'
619 # type => 'Detect2Chars'
620 if ($self->testDetect2Chars($text, '>', '>', 0, 0, 0, undef, 0, '#stay', 'Operator')) {
621 return 1
622 }
623 # attribute => 'Operator'
624 # char => '<'
625 # char1 => '<'
626 # context => '#stay'
627 # type => 'Detect2Chars'
628 if ($self->testDetect2Chars($text, '<', '<', 0, 0, 0, undef, 0, '#stay', 'Operator')) {
629 return 1
630 }
631 # attribute => 'Operator'
632 # char => '/'
633 # char1 => '\'
634 # context => '#stay'
635 # type => 'Detect2Chars'
636 if ($self->testDetect2Chars($text, '/', '\\', 0, 0, 0, undef, 0, '#stay', 'Operator')) {
637 return 1
638 }
639 # attribute => 'Operator'
640 # char => '\'
641 # char1 => '/'
642 # context => '#stay'
643 # type => 'Detect2Chars'
644 if ($self->testDetect2Chars($text, '\\', '/', 0, 0, 0, undef, 0, '#stay', 'Operator')) {
645 return 1
646 }
647 # attribute => 'Operator'
648 # char => '\'
649 # char1 => '\'
650 # context => '#stay'
651 # type => 'Detect2Chars'
652 if ($self->testDetect2Chars($text, '\\', '\\', 0, 0, 0, undef, 0, '#stay', 'Operator')) {
653 return 1
654 }
655 # String => '\bis\b'
656 # attribute => 'Operator'
657 # context => '#stay'
658 # type => 'RegExpr'
659 if ($self->testRegExpr($text, '\\bis\\b', 0, 0, 0, undef, 0, '#stay', 'Operator')) {
660 return 1
661 }
662 # String => '=:='
663 # attribute => 'Operator'
664 # context => '#stay'
665 # type => 'StringDetect'
666 if ($self->testStringDetect($text, '=:=', 0, 0, 0, undef, 0, '#stay', 'Operator')) {
667 return 1
668 }
669 # String => '=\='
670 # attribute => 'Operator'
671 # context => '#stay'
672 # type => 'StringDetect'
673 if ($self->testStringDetect($text, '=\\=', 0, 0, 0, undef, 0, '#stay', 'Operator')) {
674 return 1
675 }
676 # attribute => 'Operator'
677 # char => '<'
678 # context => '#stay'
679 # type => 'DetectChar'
680 if ($self->testDetectChar($text, '<', 0, 0, 0, undef, 0, '#stay', 'Operator')) {
681 return 1
682 }
683 # attribute => 'Operator'
684 # char => '='
685 # char1 => '<'
686 # context => '#stay'
687 # type => 'Detect2Chars'
688 if ($self->testDetect2Chars($text, '=', '<', 0, 0, 0, undef, 0, '#stay', 'Operator')) {
689 return 1
690 }
691 # attribute => 'Operator'
692 # char => '>'
693 # context => '#stay'
694 # type => 'DetectChar'
695 if ($self->testDetectChar($text, '>', 0, 0, 0, undef, 0, '#stay', 'Operator')) {
696 return 1
697 }
698 # attribute => 'Operator'
699 # char => '>'
700 # char1 => '='
701 # context => '#stay'
702 # type => 'Detect2Chars'
703 if ($self->testDetect2Chars($text, '>', '=', 0, 0, 0, undef, 0, '#stay', 'Operator')) {
704 return 1
705 }
706 # String => '=..'
707 # attribute => 'Operator'
708 # context => '#stay'
709 # type => 'StringDetect'
710 if ($self->testStringDetect($text, '=..', 0, 0, 0, undef, 0, '#stay', 'Operator')) {
711 return 1
712 }
713 # attribute => 'Operator'
714 # char => '='
715 # context => '#stay'
716 # type => 'DetectChar'
717 if ($self->testDetectChar($text, '=', 0, 0, 0, undef, 0, '#stay', 'Operator')) {
718 return 1
719 }
720 # attribute => 'Operator'
721 # char => '\'
722 # char1 => '='
723 # context => '#stay'
724 # type => 'Detect2Chars'
725 if ($self->testDetect2Chars($text, '\\', '=', 0, 0, 0, undef, 0, '#stay', 'Operator')) {
726 return 1
727 }
728 # attribute => 'Operator'
729 # char => '='
730 # char1 => '='
731 # context => '#stay'
732 # type => 'Detect2Chars'
733 if ($self->testDetect2Chars($text, '=', '=', 0, 0, 0, undef, 0, '#stay', 'Operator')) {
734 return 1
735 }
736 # String => '\=='
737 # attribute => 'Operator'
738 # context => '#stay'
739 # type => 'StringDetect'
740 if ($self->testStringDetect($text, '\\==', 0, 0, 0, undef, 0, '#stay', 'Operator')) {
741 return 1
742 }
743 # String => '@=<'
744 # attribute => 'Operator'
745 # context => '#stay'
746 # type => 'StringDetect'
747 if ($self->testStringDetect($text, '@=<', 0, 0, 0, undef, 0, '#stay', 'Operator')) {
748 return 1
749 }
750 # attribute => 'Operator'
751 # char => '@'
752 # char1 => '<'
753 # context => '#stay'
754 # type => 'Detect2Chars'
755 if ($self->testDetect2Chars($text, '@', '<', 0, 0, 0, undef, 0, '#stay', 'Operator')) {
756 return 1
757 }
758 # String => '@>='
759 # attribute => 'Operator'
760 # context => '#stay'
761 # type => 'StringDetect'
762 if ($self->testStringDetect($text, '@>=', 0, 0, 0, undef, 0, '#stay', 'Operator')) {
763 return 1
764 }
765 # attribute => 'Operator'
766 # char => '@'
767 # char1 => '>'
768 # context => '#stay'
769 # type => 'Detect2Chars'
770 if ($self->testDetect2Chars($text, '@', '>', 0, 0, 0, undef, 0, '#stay', 'Operator')) {
771 return 1
772 }
773 # attribute => 'Operator'
774 # char => '/'
775 # char1 => '/'
776 # context => '#stay'
777 # type => 'Detect2Chars'
778 if ($self->testDetect2Chars($text, '/', '/', 0, 0, 0, undef, 0, '#stay', 'Operator')) {
779 return 1
780 }
781 # String => '+-*/'
782 # attribute => 'Operator'
783 # context => '#stay'
784 # type => 'AnyChar'
785 if ($self->testAnyChar($text, '+-*/', 0, 0, undef, 0, '#stay', 'Operator')) {
786 return 1
787 }
788 # String => '\b(mod|rem)\b'
789 # attribute => 'Operator'
790 # context => '#stay'
791 # type => 'RegExpr'
792 if ($self->testRegExpr($text, '\\b(mod|rem)\\b', 0, 0, 0, undef, 0, '#stay', 'Operator')) {
793 return 1
794 }
795 # attribute => 'Operator'
796 # char => '*'
797 # char1 => '*'
798 # context => '#stay'
799 # type => 'Detect2Chars'
800 if ($self->testDetect2Chars($text, '*', '*', 0, 0, 0, undef, 0, '#stay', 'Operator')) {
801 return 1
802 }
803 # String => '-->'
804 # attribute => 'Operator'
805 # context => '#stay'
806 # type => 'StringDetect'
807 if ($self->testStringDetect($text, '-->', 0, 0, 0, undef, 0, '#stay', 'Operator')) {
808 return 1
809 }
810 # String => '!;'
811 # attribute => 'Operator'
812 # context => '#stay'
813 # type => 'AnyChar'
814 if ($self->testAnyChar($text, '!;', 0, 0, undef, 0, '#stay', 'Operator')) {
815 return 1
816 }
817 # attribute => 'Operator'
818 # char => '-'
819 # char1 => '>'
820 # context => '#stay'
821 # type => 'Detect2Chars'
822 if ($self->testDetect2Chars($text, '-', '>', 0, 0, 0, undef, 0, '#stay', 'Operator')) {
823 return 1
824 }
825 # attribute => 'Operator'
826 # char => '\'
827 # char1 => '+'
828 # context => '#stay'
829 # type => 'Detect2Chars'
830 if ($self->testDetect2Chars($text, '\\', '+', 0, 0, 0, undef, 0, '#stay', 'Operator')) {
831 return 1
832 }
833 # String => '?@'
834 # attribute => 'Operator'
835 # context => '#stay'
836 # type => 'AnyChar'
837 if ($self->testAnyChar($text, '?@', 0, 0, undef, 0, '#stay', 'Operator')) {
838 return 1
839 }
840 # attribute => 'Normal'
841 # char => ':'
842 # char1 => '-'
843 # context => '#stay'
844 # firstNonSpace => 'false'
845 # type => 'Detect2Chars'
846 if ($self->testDetect2Chars($text, ':', '-', 0, 0, 0, undef, 0, '#stay', 'Normal')) {
847 return 1
848 }
849 # String => '\b[a-z]\w*'
850 # attribute => 'Normal'
851 # context => '#stay'
852 # type => 'RegExpr'
853 if ($self->testRegExpr($text, '\\b[a-z]\\w*', 0, 0, 0, undef, 0, '#stay', 'Normal')) {
854 return 1
855 }
856 return 0;
857};
858
859sub parsesinglelinecomment {
860 my ($self, $text) = @_;
861 return 0;
862};
863
864sub parsestring {
865 my ($self, $text) = @_;
866 # attribute => 'String'
867 # char => '"'
868 # context => '#pop'
869 # type => 'DetectChar'
870 if ($self->testDetectChar($text, '"', 0, 0, 0, undef, 0, '#pop', 'String')) {
871 return 1
872 }
873 return 0;
874};
875
876
8771;
878
879__END__
880
881=head1 NAME
882
883Syntax::Highlight::Engine::Kate::Logtalk - a Plugin for Logtalk syntax highlighting
884
885=head1 SYNOPSIS
886
887 require Syntax::Highlight::Engine::Kate::Logtalk;
888 my $sh = new Syntax::Highlight::Engine::Kate::Logtalk([
889 ]);
890
891=head1 DESCRIPTION
892
893Syntax::Highlight::Engine::Kate::Logtalk is a plugin module that provides syntax highlighting
894for Logtalk to the Syntax::Haghlight::Engine::Kate highlighting engine.
895
896This code is generated from the syntax definition files used
897by the Kate project.
898It works quite fine, but can use refinement and optimization.
899
900It inherits Syntax::Higlight::Engine::Kate::Template. See also there.
901
902=cut
903
904=head1 AUTHOR
905
906Hans Jeuken (haje <at> toneel <dot> demon <dot> nl)
907
908=cut
909
910=head1 BUGS
911
912Unknown. If you find any, please contact the author
913
914=cut
915
Git web viewer in Catalyst