home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1999 mARCH / PCWK3A99.iso / Linux / DDD331 / DDD-3_1_.000 / DDD-3_1_ / ddd-3.1.1 / ddd / rxscan.L < prev    next >
Text File  |  1998-11-16  |  12KB  |  358 lines
  1. /* $Id: rxscan.L,v 1.72 1998/11/16 14:32:51 zeller Exp $ -*- C++ -*- */
  2. /* DDD regexp scanner */
  3.  
  4. %{
  5. // Copyright (C) 1997-1998 Technische Universitaet Braunschweig, Germany.
  6. // Written by Andreas Zeller <zeller@ips.cs.tu-bs.de>.
  7. // 
  8. // This file is part of DDD.
  9. // 
  10. // DDD is free software; you can redistribute it and/or
  11. // modify it under the terms of the GNU General Public
  12. // License as published by the Free Software Foundation; either
  13. // version 2 of the License, or (at your option) any later version.
  14. // 
  15. // DDD is distributed in the hope that it will be useful,
  16. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  17. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  18. // See the GNU General Public License for more details.
  19. // 
  20. // You should have received a copy of the GNU General Public
  21. // License along with DDD -- see the file COPYING.
  22. // If not, write to the Free Software Foundation, Inc.,
  23. // 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  24. // 
  25. // DDD is the data display debugger.
  26. // For details, see the DDD World-Wide-Web page, 
  27. // `http://www.cs.tu-bs.de/softech/ddd/',
  28. // or send a mail to the DDD developers <ddd@ips.cs.tu-bs.de>.
  29.  
  30. char rxscan_rcsid[] = 
  31.     "$Id: rxscan.L,v 1.72 1998/11/16 14:32:51 zeller Exp $";
  32.  
  33. // Maximal length of a token when using LEX.
  34. #define MAX_LEX_TOKEN_SIZE 8192
  35.  
  36. // I think that even a low limit of, say, 200 characters or less will
  37. // make DDD work just fine.  Please note that MAX_LEX_TOKEN_SIZE
  38. // effectively limits the length of the input to be matched, so if you
  39. // set it to 4000, only the first 4000 characters of GDB output will be
  40. // matched; the remaining ones will be ignored (by the regexp matcher,
  41. // not by DDD).
  42. //
  43. // In most cases, it does not matter whether the first 80 or 200 or 8192
  44. // characters of some GDB output are matched by the regular expression.
  45. // I have run DDD with a deliberately low limit of 80 characters, and run
  46. // into no problems whatsoever, even if only the first 80 characters were
  47. // ever matched.  The reason is that most DDD regexps that go this far
  48. // have the form `<something>.*', and it does not matter whether the
  49. // trailing `.*' matches 80 or 8192 characters.  So, in practice, raising
  50. // or lowering the MAX_LEX_TOKEN_SIZE won't make a big difference unless
  51. // you make it lower than 20 characters or so.  (8192 is just to stay on
  52. // the safe side; I don't have the time to verify all DDD regexps.)
  53.  
  54.  
  55. static const char *the_prefix;    // Prefix
  56. static const char *the_text;    // Pointer to next text character
  57. static int the_length;        // Number of characters to read
  58.  
  59. // Input routines
  60.  
  61. #ifdef FLEX_SCANNER
  62. // The way FLEX wants input
  63. #undef YY_INPUT
  64. #define YY_INPUT(buf, result, max_size) \
  65. {\
  66.     int k = 0; \
  67.     while (*the_prefix != '\0' && k < max_size) \
  68.         buf[k++] = *the_prefix++; \
  69. \
  70.     int len = min(max_size, the_length); \
  71.     if (len == 0) \
  72.         result = YY_NULL; \
  73.     else \
  74.     {\
  75.         int j = 0;\
  76.         char *bb = buf + k;\
  77.     while (j < len) \
  78.         bb[j++] = *the_text++; \
  79.         the_length -= len; \
  80.     result = k + len; \
  81.     }\
  82. }
  83. #define YY_NO_UNPUT
  84.  
  85. // Reset the scanner
  86. static void reset_scanner() { yyrestart(yyin); }
  87.  
  88. #else // !defined(FLEX_SCANNER)
  89.  
  90. // Input routines for SUN lex and likewise
  91. static char pushback[BUFSIZ];
  92. static char *pushback_ptr = pushback;
  93.  
  94. inline int do_unput(char c)
  95. {
  96.     if (c != 0)
  97.     *pushback_ptr++ = c;
  98.  
  99.     return c;
  100. }
  101.  
  102. static int do_input() 
  103. {
  104.     if (pushback_ptr != pushback)
  105.     return *--pushback_ptr;
  106.  
  107.     if (*the_prefix != '\0')
  108.     return *the_prefix++;
  109.  
  110.     if (the_length == 0)
  111.     return 0;
  112.  
  113.     the_length--;
  114.     return *the_text++;
  115. }
  116.  
  117. #ifdef input
  118. #undef input
  119. #define input do_input
  120. #endif
  121.  
  122. #ifdef unput
  123. #undef unput
  124. #define unput do_unput
  125. #endif
  126.  
  127. // Reset the scanner
  128. static void reset_scanner() { pushback_ptr = pushback; }
  129.  
  130. #endif // !defined(FLEX_SCANNER)
  131.  
  132.  
  133. #define YY_SKIP_YYWRAP
  134. extern "C" int yywrap()
  135. {
  136.     return 1;
  137. }
  138.  
  139. // Returning values
  140. #ifdef FLEX_SCANNER
  141.  
  142. #define YY_DECL static const regex *yylex YY_PROTO(( void ))
  143. #define RETURN(x) return x
  144.  
  145. #else
  146.  
  147. // Ordinary LEX uses `int yylex()'
  148. #define RETURN(x) return x ? 1 : 0
  149.  
  150. #endif
  151.  
  152.  
  153.  
  154. // Buffer size.  FLEX can match tokens of arbitrary length (all praise
  155. // FLEX!), but classical LEX has a limit of YYLMAX characters.
  156. // Attempt to raise this to some larger value.
  157. #if !defined(FLEX_SCANNER) && defined(YYLMAX)
  158. #if YYLMAX < MAX_LEX_TOKEN_SIZE
  159. #undef YYLMAX
  160. #define YYLMAX MAX_LEX_TOKEN_SIZE
  161. #endif
  162. #endif
  163.  
  164.  
  165.  
  166. // Anything not in the list is `not matched'
  167. #ifdef ECHO
  168. #undef ECHO
  169. #endif
  170. #define ECHO                 RETURN(0)
  171.  
  172. #ifdef FLEX_SCANNER
  173. // #defining YY_BREAK to empty disables warnings about unreachable breaks.
  174. #define YY_BREAK DO_NOT_BREAK
  175. #define DO_NOT_BREAK
  176. #define BREAK break;
  177. #endif // FLEX_SCANNER
  178. %}
  179.  
  180. /* Addresses -- in various formats */
  181. A    (0x[0-9a-fA-F]+|0[0-9a-fA-F]+[hH]|H\'[0-9a-fA-F]+|00+|[(]nil[)]|NIL|null|@[0-9a-fA-F]+|16_[0-9a-f]+)
  182.  
  183. /* Simple prefix of address */
  184. a    [0H@]
  185.  
  186. /* Whitespace */
  187. w    [ \f\t]
  188.  
  189. /* Optional Whitespace */
  190. _    [ \f\t]*
  191.  
  192. /* Non-empty sequence of Whitespace */
  193. W    [ \f\t]+
  194.  
  195. /* Digit */
  196. d    [0-9]
  197.  
  198. /* Non-empty sequence of digits */
  199. D    [0-9]+
  200.  
  201. /* Positive number */
  202. P    [1-9][0-9]*
  203.  
  204. /* Hex address */
  205. x    (0(0|x)[0-9a-f]+|[(]nil[)]|NIL|null)
  206.  
  207. /* An arbitrary character */
  208. c    (.|\n)
  209.  
  210. /* A sequence of arbitrary characters */
  211. C    (.|\n)*
  212.  
  213. /* `virtual table', in all variants */
  214. V    v(irtual{W})?t(a)?bl(e)?
  215.  
  216. /* A `standard' identifier.  Also includes Perl identifiers. */
  217. I    ([A-Za-z_$@%][A-Za-z0-9_$]*|[$]([^ \n\t\f]|[0-9]+))
  218.  
  219. /* A Java class identifier */
  220. J    [A-Za-z_$][A-Za-z0-9_$.]*
  221.  
  222. /* This lexer is quite huge.  SunOS lex and AIX lex wants some extra sizes. */
  223. %e 5000
  224. %k 10000
  225. %p 15000
  226. %a 25000
  227. %n 5000
  228. %o 35000
  229.  
  230. %%
  231. 01address{W}{A}                RETURN(&rxaddr);
  232. 02{A}                      RETURN(&rxaddress);
  233. 03{A}{w}in{w}                  RETURN(&rxaddress_in);
  234. 04{a}                         RETURN(&rxaddress_start);
  235. 05[A-Za-z]+                RETURN(&rxalpha);
  236. 06[0-9A-Za-z]+                RETURN(&rxalphanum);
  237. 07[(][^0-9][^)]*[)]            RETURN(&rxarglist);
  238. 08[)]?{d}*[1-9]-?{_}\,{_}{d}*[1-9]-?[(]?{W}ta{W}{C}    RETURN(&rxat);
  239. 09{w}?                    RETURN(&rxblank);
  240. 10[ ]+                     RETURN(&rxblanks);
  241. 11{W}                    RETURN(&rxblanks_or_tabs);
  242. 12{_}([th]*(b|bre|brea|break|b[a-z])|cl|cle|clea|clear|d[a-z]|info{W}(li|lin|line)|ignore|cond|condition|when|stop)({W}{C})?    RETURN(&rxbreak_cmd);
  243. 13{_}cd({W}{C})?            RETURN(&rxcd_cmd);
  244. 14[^:]*:[^:]*:{_}{D}{C}            RETURN(&rxcolons);
  245. 15{C}:{C}core{C}             RETURN(&rxcore);
  246. 16{_}(attach|core(-file)?)({W}{C})?    RETURN(&rxcore_cmd);
  247. 17\r\r*\n                RETURN(&rxcrlf);
  248. 18{_}[a-z ]*display({W}{C})?        RETURN(&rxdata);
  249. 19[^ \t\n)}][^=\n]*{w}={w}        RETURN(&rxdbx_begin_of_display);
  250. 20[(]{P}[)]{w}                RETURN(&rxdbx_begin_of_display_info);
  251. 21[a-zA-Z_$0-9]*`            RETURN(&rxdbx_scope);
  252. 22[a-zA-Z_$][a-zA-Z_$0-9]*[(]{C}[)]{C}([[]{C}[]]|\,{w}line{w}{C})    RETURN(&rxdbxframe);
  253. 23[a-zA-Z_$][^[]*:{_}{P}{W}{C}        RETURN(&rxdbxfunc);
  254. 24{C}line{W}{P}{W}in{W}(file{W})?\"[^\"]*\"\n{C}    RETURN(&rxdbxfunc2);
  255. 25[[][^\133]*:{P}[^\133]*[]]{C}        RETURN(&rxdbxpos);
  256. 26dbx:{W}warning:.*option{W}only{W}recognized{W}for.*\n    RETURN(&rxdbxwarn1);
  257. 27dbx:{W}warning:.*unknown{W}language.*\n    RETURN(&rxdbxwarn2);
  258. 28{_}(debug|givenfile)({W}{C})?        RETURN(&rxdebug_cmd);
  259. 29{W}no{W}tnedneped{W}            RETURN(&rxdep);
  260. 30{_}disable{W}display({W}{C})?        RETURN(&rxdisable);
  261. 31{_}(disp(lay)?|plot)({W}{C})?        RETURN(&rxdisplay);
  262. 32{_}(disp(lay)?|plot){W}        RETURN(&rxdisplay_cmd);
  263. 33{_}(disp(lay)?|plot){W}{C}        RETURN(&rxdisplay_cmd_and_args);
  264. 34Do{_}n['o]t                RETURN(&rxdont);
  265. 35\/[^/]*[^/.]\/[.][.]\/        RETURN(&rxdotdot);
  266. 36-?(({D}\.{d}*)|({D})|(\.{D}))([eE][+-]?{D})?    RETURN(&rxdouble);
  267. 37{_}do(wn)?({W}{C})?            RETURN(&rxdown_cmd);
  268. 38{_}enable{W}display({W}{C})?    RETURN(&rxenable);
  269. 39[^{};,\n= ]+{W}={W}[^{}();,\n= ]+{W}={W}{C} RETURN(&rxeqeq);
  270. 40{_}file({W}{C})?            RETURN(&rxfile_cmd);
  271. 41[^ "'`/]*\/                RETURN(&rxfilepath);
  272. 42{_}use{W}{C}                RETURN(&rxuse_cmd);
  273. 43#{D}{W}{A}                RETURN(&rxframe_addr);
  274. 44{_}(up|do|down|f|fra|fram|frame|suspend|resume|top|V)({W}{C})? RETURN(&rxframe_cmd);
  275. 45[a-zA-Z0-9_$][(]            RETURN(&rxfunction_call);
  276. 46{P}:{W}[^ ]                RETURN(&rxgdb_begin_of_display);
  277. 47{P}:{w}{w}{w}                RETURN(&rxgdb_begin_of_display_info);
  278. 48{P}                     RETURN(&rxgdb_disp_nr);
  279. 49{C}((class|interface)[(]{J}[)]|[(]{J}:{P}[)]) RETURN(&rxjdbpos);
  280. 50{_}graph{W}{C}            RETURN(&rxgraph_cmd);
  281. 51{I}                    RETURN(&rxidentifier);
  282. 52[[]-?{D}]{C}                RETURN(&rxindex);
  283. 53-?{D}                     RETURN(&rxint);
  284. 54([a-zA-Z]+{W}[a-zA-Z]+{C}|{C}[a-zA-Z]+{W}[a-zA-Z]+(\.|>)?)\n?  RETURN(&rxinvalid_value);
  285. 55{_}(func|v){W}{C}             RETURN(&rxlookup_cmd);
  286. 56[a-z]+                 RETURN(&rxlowercase);
  287. 57\(\*{C}\*\){C}            RETURN(&rxm3comment);
  288. 58{_}(sh{W}|!)?make({W}{C})?        RETURN(&rxmake_cmd);
  289. 59members{w}of{w}.+:{w}?\n        RETURN(&rxmembers_of_nl);
  290. 60\[-?{D}\.\.-?{D}\]            RETURN(&rxmore_than_one);
  291. 61[^ ]+:{D}\n                RETURN(&rxname_colon_int_nl);
  292. 62{W}\n{W}                RETURN(&rxnl);
  293. 63\n[1-9]                 RETURN(&rxnl_int);
  294. 64\n{_}{A}                 RETURN(&rxnladdress);
  295. 65\n{_}{A}{w}in{w}             RETURN(&rxnladdress_in);
  296. 66\n{c}[*]                 RETURN(&rxnlstar);
  297. 67no[nt][ -]?(0|zero|null)        RETURN(&rxnonzero1);
  298. 68!={_}(0|zero|null)            RETURN(&rxnonzero2);
  299. 69{_}(echo|help|show|info|where|shell|sh|x)({W}{C})?    RETURN(&rxnop_cmd);
  300. 70@{D}@                    RETURN(&rxnum);
  301. 71{_}(info{W}line)({W}{C})?        RETURN(&rxop_cmd);
  302. 72-[bcdeiIopPrRsx]            RETURN(&rxoptions);
  303. 73Line{W}number{W}{D}{W}is{W}out{W}of{W}range{W}for{W} RETURN(&rxout_of_range);
  304. 74{_}(dir|directory|path)({W}{C})?    RETURN(&rxpath_cmd);
  305. 75\$pc{_}={_}{A}            RETURN(&rxpc);
  306. 76[a-zA-Z][a-zA-Z0-9 ]*[a-zA-Z0-9][[][1-9][0-9]*[]][ ] RETURN(&rxjdbprompt);
  307. 77[ ][]][0-9]*[1-9][[][a-zA-Z0-9][a-zA-Z0-9 ]*[a-zA-Z] RETURN(&rxjdbprompt_reverse);
  308. 78Process{W}{D}:{_}            RETURN(&rxprocess1);
  309. 79Process{W}{D}:            RETURN(&rxprocess2);
  310. 80[(][^ )]*db[^)]*[)]{w}        RETURN(&rxprompt);
  311. 81{C}[(]END[)].*            RETURN(&rxq);
  312. 82@{_}{x}{_}:{C}             RETURN(&rxreference);
  313. 83{_}refresh({W}{C})?            RETURN(&rxrefresh_cmd);
  314. 84{C}([(]press{W}RETURN[)]|Hit{W}RETURN{W}to{W}continue|Type{W}<return>{W}to{W}continue|More{W}[(]n{W}if{W}no[)][?]|{W}cont:{W}).* RETURN(&rxreturn);
  315. 85{_}(r|rer|rerun|ru|run|R)({W}{C})? RETURN(&rxrun_cmd);
  316. 86{_}(r|ru|run|rer|rerun|c|cont|contin|continu|continue|sig|sign|signa|signal|u|unt|unti|until|s|si|step|stepi|n|ni|next|nexti|j|ju|jump|k|ki|kill|fin|fini|finis|finish|R|S)({W}{C})?    RETURN(&rxrunning_cmd);
  317. 87Select{w}one{w}of{w}\[{D}{w}-{w}{D}\]:{w}    RETURN(&rxselect);
  318. 88;{_}[}]                RETURN(&rxsemicolon_and_brace);
  319. 89[^-_a-zA-Z0-9]            RETURN(&rxsep);
  320. 90{_}(set{W}var[a-z]*|assign|pq)({W}{C})?    RETURN(&rxset1_cmd);
  321. 91{_}(set|p|print|output){W}[^=]+=[^=]{C}    RETURN(&rxset2_cmd);
  322. 92{_}set{W}args({W}{C})?        RETURN(&rxset_args_cmd);
  323. 93{_}(set|dbxenv|O){W}{C}         RETURN(&rxsetting_cmd);
  324. 94([][a-zA-Z0-9_$@%().`]|->|::)*    RETURN(&rxsimple);
  325. 95{_}disp(lay){W}[^ ]+            RETURN(&rxsingle_display_cmd);
  326. 96{C}(--More--|line{w}{d}).*         RETURN(&rxspace);
  327. 97Breakpoint{W}{P}\,{W}{A}        RETURN(&rxstopped_addr);
  328. 98{x}?{_}([(]|[{]|record\n|RECORD\n|RECORD{w}|OBJECT{w}|struct|class|interface|union){C}    RETURN(&rxstruct_begin);
  329. 99(>|[[][1-9][0-9]*[]])[ ]              RETURN(&rxjdbprompt_nothread);
  330. A0([)]|[}]|end\n|END\n|end;|END;)    RETURN(&rxstruct_end);
  331. A1{x}?{_}(record\n|RECORD\n|RECORD{w}|OBJECT{w}|struct|class|interface|union){C} RETURN(&rxstruct_keyword_begin);
  332. A2([Tt]he{W})?[Pp]rogram{W}(exited|terminated|is{W}not{W}being{W}run|no{W}longer{W}exists){C} RETURN(&rxterminated);
  333. A3{_}(thread|threadgroup|suspend|resume)({W}{C})? RETURN(&rxthread_cmd);
  334. A4{_}(delete{W}|un)display({W}{C})?    RETURN(&rxundisplay);
  335. A5{_}up({W}{C})?            RETURN(&rxup_cmd);
  336. A6[A-Z]+                RETURN(&rxuppercase);
  337. A7{A}{W}<[^ \n>]*{W}{V}>[^{},]*[{]{C}     RETURN(&rxvtable);
  338. A8{D}{W}{V}{W}entries\,                RETURN(&rxvtable_entries);
  339. A9[ \n\t\r\v\f]+             RETURN(&rxwhite);
  340. B0{C}Standard{W}input:{W}END{C}     RETURN(&rxxdb);
  341. B1[^ \t]*:.*:{w}{P}[: ]{C}             RETURN(&rxxdbpos);
  342. B2[<]repeats{W}{P}{W}times[>]           RETURN(&rxrepeats);
  343. B3(::|`)?{I}(([.]|->|::|`){I})*        RETURN(&rxchain);
  344. B4{W}ni{W}nehw{W}(ro{W}won{W})?         RETURN(&rxwhen);
  345. B5Breakpoint{W}{P}\,{W}            RETURN(&rxstopped_func);
  346. B6#{D}{W}{I}[^ \f\t\n]*{W}[(]        RETURN(&rxframe_func);
  347. B7{_}(define|document){W}{C}        RETURN(&rxdefine_cmd);
  348. B8{_}(l|li|lis|list)({W}{C})?         RETURN(&rxlist_cmd);
  349. B9{D}{_}\,{_}{D}             RETURN(&rxlist_range);
  350. C0[^:]*:{P}                 RETURN(&rxfilepos);
  351. C1{_}{I}[^({\n=]*:[(]            RETURN(&rxdbx_baseclass);
  352. C2{_}[^=]+=[^=]{C}            RETURN(&rxset3_cmd);
  353. C3{_}DB<+[0-9]*>+{_}            RETURN(&rxperlprompt);
  354. C4[^(]*::[^(]*[(][^:]*:{P}[)]:.*    RETURN(&rxperlpos);
  355. C5{I}[(]{A}[)]                RETURN(&rxperlref);
  356. (.|\n)                        RETURN(0);  // Anything else
  357. %%
  358.