![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to flexdef.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / pgrm / lex|
Return to flexdef.h CVS log | Up to [CSRG BSD Unix] / 43BSDReno / pgrm / lex |
1.1 ! root 1: /*- ! 2: * Copyright (c) 1990 The Regents of the University of California. ! 3: * All rights reserved. ! 4: * ! 5: * This code is derived from software contributed to Berkeley by ! 6: * Vern Paxson. ! 7: * ! 8: * The United States Government has rights in this work pursuant ! 9: * to contract no. DE-AC03-76SF00098 between the United States ! 10: * Department of Energy and the University of California. ! 11: * ! 12: * Redistribution and use in source and binary forms are permitted provided ! 13: * that: (1) source distributions retain this entire copyright notice and ! 14: * comment, and (2) distributions including binaries display the following ! 15: * acknowledgement: ``This product includes software developed by the ! 16: * University of California, Berkeley and its contributors'' in the ! 17: * documentation or other materials provided with the distribution and in ! 18: * all advertising materials mentioning features or use of this software. ! 19: * Neither the name of the University nor the names of its contributors may ! 20: * be used to endorse or promote products derived from this software without ! 21: * specific prior written permission. ! 22: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED ! 23: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF ! 24: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. ! 25: * ! 26: * @(#)flexdef.h 5.3 (Berkeley) 6/18/90 ! 27: */ ! 28: ! 29: /* flexdef - definitions file for flex */ ! 30: ! 31: #ifndef FILE ! 32: #include <stdio.h> ! 33: #endif ! 34: ! 35: /* always be prepared to generate an 8-bit scanner */ ! 36: #define FLEX_8_BIT_CHARS ! 37: ! 38: #ifdef FLEX_8_BIT_CHARS ! 39: #define CSIZE 256 ! 40: #define Char unsigned char ! 41: #else ! 42: #define Char char ! 43: #define CSIZE 128 ! 44: #endif ! 45: ! 46: /* size of input alphabet - should be size of ASCII set */ ! 47: #ifndef DEFAULT_CSIZE ! 48: #define DEFAULT_CSIZE 128 ! 49: #endif ! 50: ! 51: #ifndef PROTO ! 52: #ifdef __STDC__ ! 53: #define PROTO(proto) proto ! 54: #else ! 55: #define PROTO(proto) () ! 56: #endif ! 57: #endif ! 58: ! 59: #include <string.h> ! 60: ! 61: #ifdef AMIGA ! 62: #define bzero(s, n) setmem((char *)(s), n, '\0') ! 63: #ifndef abs ! 64: #define abs(x) ((x) < 0 ? -(x) : (x)) ! 65: #endif ! 66: #else ! 67: #define bzero(s, n) (void) memset((char *)(s), '\0', n) ! 68: #endif ! 69: ! 70: #ifdef VMS ! 71: #define unlink delete ! 72: #define SHORT_FILE_NAMES ! 73: #endif ! 74: ! 75: char *malloc(), *realloc(); ! 76: ! 77: ! 78: /* maximum line length we'll have to deal with */ ! 79: #define MAXLINE BUFSIZ ! 80: ! 81: /* maximum size of file name */ ! 82: #define FILENAMESIZE 1024 ! 83: ! 84: #ifndef min ! 85: #define min(x,y) ((x) < (y) ? (x) : (y)) ! 86: #endif ! 87: #ifndef max ! 88: #define max(x,y) ((x) > (y) ? (x) : (y)) ! 89: #endif ! 90: ! 91: #ifdef MS_DOS ! 92: #ifndef abs ! 93: #define abs(x) ((x) < 0 ? -(x) : (x)) ! 94: #endif ! 95: #define SHORT_FILE_NAMES ! 96: #endif ! 97: ! 98: #define true 1 ! 99: #define false 0 ! 100: ! 101: ! 102: /* special chk[] values marking the slots taking by end-of-buffer and action ! 103: * numbers ! 104: */ ! 105: #define EOB_POSITION -1 ! 106: #define ACTION_POSITION -2 ! 107: ! 108: /* number of data items per line for -f output */ ! 109: #define NUMDATAITEMS 10 ! 110: ! 111: /* number of lines of data in -f output before inserting a blank line for ! 112: * readability. ! 113: */ ! 114: #define NUMDATALINES 10 ! 115: ! 116: /* transition_struct_out() definitions */ ! 117: #define TRANS_STRUCT_PRINT_LENGTH 15 ! 118: ! 119: /* returns true if an nfa state has an epsilon out-transition slot ! 120: * that can be used. This definition is currently not used. ! 121: */ ! 122: #define FREE_EPSILON(state) \ ! 123: (transchar[state] == SYM_EPSILON && \ ! 124: trans2[state] == NO_TRANSITION && \ ! 125: finalst[state] != state) ! 126: ! 127: /* returns true if an nfa state has an epsilon out-transition character ! 128: * and both slots are free ! 129: */ ! 130: #define SUPER_FREE_EPSILON(state) \ ! 131: (transchar[state] == SYM_EPSILON && \ ! 132: trans1[state] == NO_TRANSITION) \ ! 133: ! 134: /* maximum number of NFA states that can comprise a DFA state. It's real ! 135: * big because if there's a lot of rules, the initial state will have a ! 136: * huge epsilon closure. ! 137: */ ! 138: #define INITIAL_MAX_DFA_SIZE 750 ! 139: #define MAX_DFA_SIZE_INCREMENT 750 ! 140: ! 141: ! 142: /* a note on the following masks. They are used to mark accepting numbers ! 143: * as being special. As such, they implicitly limit the number of accepting ! 144: * numbers (i.e., rules) because if there are too many rules the rule numbers ! 145: * will overload the mask bits. Fortunately, this limit is \large/ (0x2000 == ! 146: * 8192) so unlikely to actually cause any problems. A check is made in ! 147: * new_rule() to ensure that this limit is not reached. ! 148: */ ! 149: ! 150: /* mask to mark a trailing context accepting number */ ! 151: #define YY_TRAILING_MASK 0x2000 ! 152: ! 153: /* mask to mark the accepting number of the "head" of a trailing context rule */ ! 154: #define YY_TRAILING_HEAD_MASK 0x4000 ! 155: ! 156: /* maximum number of rules, as outlined in the above note */ ! 157: #define MAX_RULE (YY_TRAILING_MASK - 1) ! 158: ! 159: ! 160: /* NIL must be 0. If not, its special meaning when making equivalence classes ! 161: * (it marks the representative of a given e.c.) will be unidentifiable ! 162: */ ! 163: #define NIL 0 ! 164: ! 165: #define JAM -1 /* to mark a missing DFA transition */ ! 166: #define NO_TRANSITION NIL ! 167: #define UNIQUE -1 /* marks a symbol as an e.c. representative */ ! 168: #define INFINITY -1 /* for x{5,} constructions */ ! 169: ! 170: #define INITIAL_MAX_CCLS 100 /* max number of unique character classes */ ! 171: #define MAX_CCLS_INCREMENT 100 ! 172: ! 173: /* size of table holding members of character classes */ ! 174: #define INITIAL_MAX_CCL_TBL_SIZE 500 ! 175: #define MAX_CCL_TBL_SIZE_INCREMENT 250 ! 176: ! 177: #define INITIAL_MAX_RULES 100 /* default maximum number of rules */ ! 178: #define MAX_RULES_INCREMENT 100 ! 179: ! 180: #define INITIAL_MNS 2000 /* default maximum number of nfa states */ ! 181: #define MNS_INCREMENT 1000 /* amount to bump above by if it's not enough */ ! 182: ! 183: #define INITIAL_MAX_DFAS 1000 /* default maximum number of dfa states */ ! 184: #define MAX_DFAS_INCREMENT 1000 ! 185: ! 186: #define JAMSTATE -32766 /* marks a reference to the state that always jams */ ! 187: ! 188: /* enough so that if it's subtracted from an NFA state number, the result ! 189: * is guaranteed to be negative ! 190: */ ! 191: #define MARKER_DIFFERENCE 32000 ! 192: #define MAXIMUM_MNS 31999 ! 193: ! 194: /* maximum number of nxt/chk pairs for non-templates */ ! 195: #define INITIAL_MAX_XPAIRS 2000 ! 196: #define MAX_XPAIRS_INCREMENT 2000 ! 197: ! 198: /* maximum number of nxt/chk pairs needed for templates */ ! 199: #define INITIAL_MAX_TEMPLATE_XPAIRS 2500 ! 200: #define MAX_TEMPLATE_XPAIRS_INCREMENT 2500 ! 201: ! 202: #define SYM_EPSILON (CSIZE + 1) /* to mark transitions on the symbol epsilon */ ! 203: ! 204: #define INITIAL_MAX_SCS 40 /* maximum number of start conditions */ ! 205: #define MAX_SCS_INCREMENT 40 /* amount to bump by if it's not enough */ ! 206: ! 207: #define ONE_STACK_SIZE 500 /* stack of states with only one out-transition */ ! 208: #define SAME_TRANS -1 /* transition is the same as "default" entry for state */ ! 209: ! 210: /* the following percentages are used to tune table compression: ! 211: ! 212: * the percentage the number of out-transitions a state must be of the ! 213: * number of equivalence classes in order to be considered for table ! 214: * compaction by using protos ! 215: */ ! 216: #define PROTO_SIZE_PERCENTAGE 15 ! 217: ! 218: /* the percentage the number of homogeneous out-transitions of a state ! 219: * must be of the number of total out-transitions of the state in order ! 220: * that the state's transition table is first compared with a potential ! 221: * template of the most common out-transition instead of with the first ! 222: * proto in the proto queue ! 223: */ ! 224: #define CHECK_COM_PERCENTAGE 50 ! 225: ! 226: /* the percentage the number of differences between a state's transition ! 227: * table and the proto it was first compared with must be of the total ! 228: * number of out-transitions of the state in order to keep the first ! 229: * proto as a good match and not search any further ! 230: */ ! 231: #define FIRST_MATCH_DIFF_PERCENTAGE 10 ! 232: ! 233: /* the percentage the number of differences between a state's transition ! 234: * table and the most similar proto must be of the state's total number ! 235: * of out-transitions to use the proto as an acceptable close match ! 236: */ ! 237: #define ACCEPTABLE_DIFF_PERCENTAGE 50 ! 238: ! 239: /* the percentage the number of homogeneous out-transitions of a state ! 240: * must be of the number of total out-transitions of the state in order ! 241: * to consider making a template from the state ! 242: */ ! 243: #define TEMPLATE_SAME_PERCENTAGE 60 ! 244: ! 245: /* the percentage the number of differences between a state's transition ! 246: * table and the most similar proto must be of the state's total number ! 247: * of out-transitions to create a new proto from the state ! 248: */ ! 249: #define NEW_PROTO_DIFF_PERCENTAGE 20 ! 250: ! 251: /* the percentage the total number of out-transitions of a state must be ! 252: * of the number of equivalence classes in order to consider trying to ! 253: * fit the transition table into "holes" inside the nxt/chk table. ! 254: */ ! 255: #define INTERIOR_FIT_PERCENTAGE 15 ! 256: ! 257: /* size of region set aside to cache the complete transition table of ! 258: * protos on the proto queue to enable quick comparisons ! 259: */ ! 260: #define PROT_SAVE_SIZE 2000 ! 261: ! 262: #define MSP 50 /* maximum number of saved protos (protos on the proto queue) */ ! 263: ! 264: /* maximum number of out-transitions a state can have that we'll rummage ! 265: * around through the interior of the internal fast table looking for a ! 266: * spot for it ! 267: */ ! 268: #define MAX_XTIONS_FULL_INTERIOR_FIT 4 ! 269: ! 270: /* maximum number of rules which will be reported as being associated ! 271: * with a DFA state ! 272: */ ! 273: #define MAX_ASSOC_RULES 100 ! 274: ! 275: /* number that, if used to subscript an array, has a good chance of producing ! 276: * an error; should be small enough to fit into a short ! 277: */ ! 278: #define BAD_SUBSCRIPT -32767 ! 279: ! 280: /* absolute value of largest number that can be stored in a short, with a ! 281: * bit of slop thrown in for general paranoia. ! 282: */ ! 283: #define MAX_SHORT 32766 ! 284: ! 285: ! 286: /* Declarations for global variables. */ ! 287: ! 288: /* variables for symbol tables: ! 289: * sctbl - start-condition symbol table ! 290: * ndtbl - name-definition symbol table ! 291: * ccltab - character class text symbol table ! 292: */ ! 293: ! 294: struct hash_entry ! 295: { ! 296: struct hash_entry *prev, *next; ! 297: char *name; ! 298: char *str_val; ! 299: int int_val; ! 300: } ; ! 301: ! 302: typedef struct hash_entry *hash_table[]; ! 303: ! 304: #define NAME_TABLE_HASH_SIZE 101 ! 305: #define START_COND_HASH_SIZE 101 ! 306: #define CCL_HASH_SIZE 101 ! 307: ! 308: extern struct hash_entry *ndtbl[NAME_TABLE_HASH_SIZE]; ! 309: extern struct hash_entry *sctbl[START_COND_HASH_SIZE]; ! 310: extern struct hash_entry *ccltab[CCL_HASH_SIZE]; ! 311: ! 312: ! 313: /* variables for flags: ! 314: * printstats - if true (-v), dump statistics ! 315: * syntaxerror - true if a syntax error has been found ! 316: * eofseen - true if we've seen an eof in the input file ! 317: * ddebug - if true (-d), make a "debug" scanner ! 318: * trace - if true (-T), trace processing ! 319: * spprdflt - if true (-s), suppress the default rule ! 320: * interactive - if true (-I), generate an interactive scanner ! 321: * caseins - if true (-i), generate a case-insensitive scanner ! 322: * useecs - if true (-Ce flag), use equivalence classes ! 323: * fulltbl - if true (-Cf flag), don't compress the DFA state table ! 324: * usemecs - if true (-Cm flag), use meta-equivalence classes ! 325: * fullspd - if true (-F flag), use Jacobson method of table representation ! 326: * gen_line_dirs - if true (i.e., no -L flag), generate #line directives ! 327: * performance_report - if true (i.e., -p flag), generate a report relating ! 328: * to scanner performance ! 329: * backtrack_report - if true (i.e., -b flag), generate "lex.backtrack" file ! 330: * listing backtracking states ! 331: * csize - size of character set for the scanner we're generating; ! 332: * 128 for 7-bit chars and 256 for 8-bit ! 333: * yymore_used - if true, yymore() is used in input rules ! 334: * reject - if true, generate backtracking tables for REJECT macro ! 335: * real_reject - if true, scanner really uses REJECT (as opposed to just ! 336: * having "reject" set for variable trailing context) ! 337: * continued_action - true if this rule's action is to "fall through" to ! 338: * the next rule's action (i.e., the '|' action) ! 339: * yymore_really_used - has a REALLY_xxx value indicating whether a ! 340: * %used or %notused was used with yymore() ! 341: * reject_really_used - same for REJECT ! 342: */ ! 343: ! 344: extern int printstats, syntaxerror, eofseen, ddebug, trace, spprdflt; ! 345: extern int interactive, caseins, useecs, fulltbl, usemecs; ! 346: extern int fullspd, gen_line_dirs, performance_report, backtrack_report, csize; ! 347: extern int yymore_used, reject, real_reject, continued_action; ! 348: ! 349: #define REALLY_NOT_DETERMINED 0 ! 350: #define REALLY_USED 1 ! 351: #define REALLY_NOT_USED 2 ! 352: extern int yymore_really_used, reject_really_used; ! 353: ! 354: ! 355: /* variables used in the flex input routines: ! 356: * datapos - characters on current output line ! 357: * dataline - number of contiguous lines of data in current data ! 358: * statement. Used to generate readable -f output ! 359: * linenum - current input line number ! 360: * skelfile - the skeleton file ! 361: * yyin - input file ! 362: * temp_action_file - temporary file to hold actions ! 363: * backtrack_file - file to summarize backtracking states to ! 364: * infilename - name of input file ! 365: * action_file_name - name of the temporary file ! 366: * input_files - array holding names of input files ! 367: * num_input_files - size of input_files array ! 368: * program_name - name with which program was invoked ! 369: */ ! 370: ! 371: extern int datapos, dataline, linenum; ! 372: extern FILE *skelfile, *yyin, *temp_action_file, *backtrack_file; ! 373: extern char *infilename; ! 374: extern char *action_file_name; ! 375: extern char **input_files; ! 376: extern int num_input_files; ! 377: extern char *program_name; ! 378: ! 379: ! 380: /* variables for stack of states having only one out-transition: ! 381: * onestate - state number ! 382: * onesym - transition symbol ! 383: * onenext - target state ! 384: * onedef - default base entry ! 385: * onesp - stack pointer ! 386: */ ! 387: ! 388: extern int onestate[ONE_STACK_SIZE], onesym[ONE_STACK_SIZE]; ! 389: extern int onenext[ONE_STACK_SIZE], onedef[ONE_STACK_SIZE], onesp; ! 390: ! 391: ! 392: /* variables for nfa machine data: ! 393: * current_mns - current maximum on number of NFA states ! 394: * num_rules - number of the last accepting state; also is number of ! 395: * rules created so far ! 396: * current_max_rules - current maximum number of rules ! 397: * lastnfa - last nfa state number created ! 398: * firstst - physically the first state of a fragment ! 399: * lastst - last physical state of fragment ! 400: * finalst - last logical state of fragment ! 401: * transchar - transition character ! 402: * trans1 - transition state ! 403: * trans2 - 2nd transition state for epsilons ! 404: * accptnum - accepting number ! 405: * assoc_rule - rule associated with this NFA state (or 0 if none) ! 406: * state_type - a STATE_xxx type identifying whether the state is part ! 407: * of a normal rule, the leading state in a trailing context ! 408: * rule (i.e., the state which marks the transition from ! 409: * recognizing the text-to-be-matched to the beginning of ! 410: * the trailing context), or a subsequent state in a trailing ! 411: * context rule ! 412: * rule_type - a RULE_xxx type identifying whether this a a ho-hum ! 413: * normal rule or one which has variable head & trailing ! 414: * context ! 415: * rule_linenum - line number associated with rule ! 416: */ ! 417: ! 418: extern int current_mns, num_rules, current_max_rules, lastnfa; ! 419: extern int *firstst, *lastst, *finalst, *transchar, *trans1, *trans2; ! 420: extern int *accptnum, *assoc_rule, *state_type, *rule_type, *rule_linenum; ! 421: ! 422: /* different types of states; values are useful as masks, as well, for ! 423: * routines like check_trailing_context() ! 424: */ ! 425: #define STATE_NORMAL 0x1 ! 426: #define STATE_TRAILING_CONTEXT 0x2 ! 427: ! 428: /* global holding current type of state we're making */ ! 429: ! 430: extern int current_state_type; ! 431: ! 432: /* different types of rules */ ! 433: #define RULE_NORMAL 0 ! 434: #define RULE_VARIABLE 1 ! 435: ! 436: /* true if the input rules include a rule with both variable-length head ! 437: * and trailing context, false otherwise ! 438: */ ! 439: extern int variable_trailing_context_rules; ! 440: ! 441: ! 442: /* variables for protos: ! 443: * numtemps - number of templates created ! 444: * numprots - number of protos created ! 445: * protprev - backlink to a more-recently used proto ! 446: * protnext - forward link to a less-recently used proto ! 447: * prottbl - base/def table entry for proto ! 448: * protcomst - common state of proto ! 449: * firstprot - number of the most recently used proto ! 450: * lastprot - number of the least recently used proto ! 451: * protsave contains the entire state array for protos ! 452: */ ! 453: ! 454: extern int numtemps, numprots, protprev[MSP], protnext[MSP], prottbl[MSP]; ! 455: extern int protcomst[MSP], firstprot, lastprot, protsave[PROT_SAVE_SIZE]; ! 456: ! 457: ! 458: /* variables for managing equivalence classes: ! 459: * numecs - number of equivalence classes ! 460: * nextecm - forward link of Equivalence Class members ! 461: * ecgroup - class number or backward link of EC members ! 462: * nummecs - number of meta-equivalence classes (used to compress ! 463: * templates) ! 464: * tecfwd - forward link of meta-equivalence classes members ! 465: * tecbck - backward link of MEC's ! 466: * xlation - maps character codes to their translations, or nil if no %t table ! 467: * num_xlations - number of different xlation values ! 468: */ ! 469: ! 470: /* reserve enough room in the equivalence class arrays so that we ! 471: * can use the CSIZE'th element to hold equivalence class information ! 472: * for the NUL character. Later we'll move this information into ! 473: * the 0th element. ! 474: */ ! 475: extern int numecs, nextecm[CSIZE + 1], ecgroup[CSIZE + 1], nummecs; ! 476: ! 477: /* meta-equivalence classes are indexed starting at 1, so it's possible ! 478: * that they will require positions from 1 .. CSIZE, i.e., CSIZE + 1 ! 479: * slots total (since the arrays are 0-based). nextecm[] and ecgroup[] ! 480: * don't require the extra position since they're indexed from 1 .. CSIZE - 1. ! 481: */ ! 482: extern int tecfwd[CSIZE + 1], tecbck[CSIZE + 1]; ! 483: ! 484: extern int *xlation; ! 485: extern int num_xlations; ! 486: ! 487: ! 488: /* variables for start conditions: ! 489: * lastsc - last start condition created ! 490: * current_max_scs - current limit on number of start conditions ! 491: * scset - set of rules active in start condition ! 492: * scbol - set of rules active only at the beginning of line in a s.c. ! 493: * scxclu - true if start condition is exclusive ! 494: * sceof - true if start condition has EOF rule ! 495: * scname - start condition name ! 496: * actvsc - stack of active start conditions for the current rule ! 497: */ ! 498: ! 499: extern int lastsc, current_max_scs, *scset, *scbol, *scxclu, *sceof, *actvsc; ! 500: extern char **scname; ! 501: ! 502: ! 503: /* variables for dfa machine data: ! 504: * current_max_dfa_size - current maximum number of NFA states in DFA ! 505: * current_max_xpairs - current maximum number of non-template xtion pairs ! 506: * current_max_template_xpairs - current maximum number of template pairs ! 507: * current_max_dfas - current maximum number DFA states ! 508: * lastdfa - last dfa state number created ! 509: * nxt - state to enter upon reading character ! 510: * chk - check value to see if "nxt" applies ! 511: * tnxt - internal nxt table for templates ! 512: * base - offset into "nxt" for given state ! 513: * def - where to go if "chk" disallows "nxt" entry ! 514: * nultrans - NUL transition for each state ! 515: * NUL_ec - equivalence class of the NUL character ! 516: * tblend - last "nxt/chk" table entry being used ! 517: * firstfree - first empty entry in "nxt/chk" table ! 518: * dss - nfa state set for each dfa ! 519: * dfasiz - size of nfa state set for each dfa ! 520: * dfaacc - accepting set for each dfa state (or accepting number, if ! 521: * -r is not given) ! 522: * accsiz - size of accepting set for each dfa state ! 523: * dhash - dfa state hash value ! 524: * numas - number of DFA accepting states created; note that this ! 525: * is not necessarily the same value as num_rules, which is the analogous ! 526: * value for the NFA ! 527: * numsnpairs - number of state/nextstate transition pairs ! 528: * jambase - position in base/def where the default jam table starts ! 529: * jamstate - state number corresponding to "jam" state ! 530: * end_of_buffer_state - end-of-buffer dfa state number ! 531: */ ! 532: ! 533: extern int current_max_dfa_size, current_max_xpairs; ! 534: extern int current_max_template_xpairs, current_max_dfas; ! 535: extern int lastdfa, lasttemp, *nxt, *chk, *tnxt; ! 536: extern int *base, *def, *nultrans, NUL_ec, tblend, firstfree, **dss, *dfasiz; ! 537: extern union dfaacc_union ! 538: { ! 539: int *dfaacc_set; ! 540: int dfaacc_state; ! 541: } *dfaacc; ! 542: extern int *accsiz, *dhash, numas; ! 543: extern int numsnpairs, jambase, jamstate; ! 544: extern int end_of_buffer_state; ! 545: ! 546: /* variables for ccl information: ! 547: * lastccl - ccl index of the last created ccl ! 548: * current_maxccls - current limit on the maximum number of unique ccl's ! 549: * cclmap - maps a ccl index to its set pointer ! 550: * ccllen - gives the length of a ccl ! 551: * cclng - true for a given ccl if the ccl is negated ! 552: * cclreuse - counts how many times a ccl is re-used ! 553: * current_max_ccl_tbl_size - current limit on number of characters needed ! 554: * to represent the unique ccl's ! 555: * ccltbl - holds the characters in each ccl - indexed by cclmap ! 556: */ ! 557: ! 558: extern int lastccl, current_maxccls, *cclmap, *ccllen, *cclng, cclreuse; ! 559: extern int current_max_ccl_tbl_size; ! 560: extern Char *ccltbl; ! 561: ! 562: ! 563: /* variables for miscellaneous information: ! 564: * starttime - real-time when we started ! 565: * endtime - real-time when we ended ! 566: * nmstr - last NAME scanned by the scanner ! 567: * sectnum - section number currently being parsed ! 568: * nummt - number of empty nxt/chk table entries ! 569: * hshcol - number of hash collisions detected by snstods ! 570: * dfaeql - number of times a newly created dfa was equal to an old one ! 571: * numeps - number of epsilon NFA states created ! 572: * eps2 - number of epsilon states which have 2 out-transitions ! 573: * num_reallocs - number of times it was necessary to realloc() a group ! 574: * of arrays ! 575: * tmpuses - number of DFA states that chain to templates ! 576: * totnst - total number of NFA states used to make DFA states ! 577: * peakpairs - peak number of transition pairs we had to store internally ! 578: * numuniq - number of unique transitions ! 579: * numdup - number of duplicate transitions ! 580: * hshsave - number of hash collisions saved by checking number of states ! 581: * num_backtracking - number of DFA states requiring back-tracking ! 582: * bol_needed - whether scanner needs beginning-of-line recognition ! 583: */ ! 584: ! 585: extern char *starttime, *endtime, nmstr[MAXLINE]; ! 586: extern int sectnum, nummt, hshcol, dfaeql, numeps, eps2, num_reallocs; ! 587: extern int tmpuses, totnst, peakpairs, numuniq, numdup, hshsave; ! 588: extern int num_backtracking, bol_needed; ! 589: ! 590: void *allocate_array(), *reallocate_array(); ! 591: ! 592: #define allocate_integer_array(size) \ ! 593: (int *) allocate_array( size, sizeof( int ) ) ! 594: ! 595: #define reallocate_integer_array(array,size) \ ! 596: (int *) reallocate_array( (void *) array, size, sizeof( int ) ) ! 597: ! 598: #define allocate_int_ptr_array(size) \ ! 599: (int **) allocate_array( size, sizeof( int * ) ) ! 600: ! 601: #define allocate_char_ptr_array(size) \ ! 602: (char **) allocate_array( size, sizeof( char * ) ) ! 603: ! 604: #define allocate_dfaacc_union(size) \ ! 605: (union dfaacc_union *) \ ! 606: allocate_array( size, sizeof( union dfaacc_union ) ) ! 607: ! 608: #define reallocate_int_ptr_array(array,size) \ ! 609: (int **) reallocate_array( (void *) array, size, sizeof( int * ) ) ! 610: ! 611: #define reallocate_char_ptr_array(array,size) \ ! 612: (char **) reallocate_array( (void *) array, size, sizeof( char * ) ) ! 613: ! 614: #define reallocate_dfaacc_union(array, size) \ ! 615: (union dfaacc_union *) \ ! 616: reallocate_array( (void *) array, size, sizeof( union dfaacc_union ) ) ! 617: ! 618: #define allocate_character_array(size) \ ! 619: (Char *) allocate_array( size, sizeof( Char ) ) ! 620: ! 621: #define reallocate_character_array(array,size) \ ! 622: (Char *) reallocate_array( (void *) array, size, sizeof( Char ) ) ! 623: ! 624: ! 625: /* used to communicate between scanner and parser. The type should really ! 626: * be YYSTYPE, but we can't easily get our hands on it. ! 627: */ ! 628: extern int yylval; ! 629: ! 630: ! 631: /* external functions that are cross-referenced among the flex source files */ ! 632: ! 633: ! 634: /* from file ccl.c */ ! 635: ! 636: extern void ccladd PROTO((int, int)); /* Add a single character to a ccl */ ! 637: extern int cclinit PROTO(()); /* make an empty ccl */ ! 638: extern void cclnegate PROTO((int)); /* negate a ccl */ ! 639: ! 640: /* list the members of a set of characters in CCL form */ ! 641: extern void list_character_set PROTO((FILE*, int[])); ! 642: ! 643: ! 644: /* from file dfa.c */ ! 645: ! 646: /* increase the maximum number of dfas */ ! 647: extern void increase_max_dfas PROTO(()); ! 648: ! 649: extern void ntod PROTO(()); /* convert a ndfa to a dfa */ ! 650: ! 651: ! 652: /* from file ecs.c */ ! 653: ! 654: /* convert character classes to set of equivalence classes */ ! 655: extern void ccl2ecl PROTO(()); ! 656: ! 657: /* associate equivalence class numbers with class members */ ! 658: extern int cre8ecs PROTO((int[], int[], int)); ! 659: ! 660: /* associate equivalence class numbers using %t table */ ! 661: extern int ecs_from_xlation PROTO((int[])); ! 662: ! 663: /* update equivalence classes based on character class transitions */ ! 664: extern void mkeccl PROTO((Char[], int, int[], int[], int, int)); ! 665: ! 666: /* create equivalence class for single character */ ! 667: extern void mkechar PROTO((int, int[], int[])); ! 668: ! 669: ! 670: /* from file gen.c */ ! 671: ! 672: extern void make_tables PROTO(()); /* generate transition tables */ ! 673: ! 674: ! 675: /* from file main.c */ ! 676: ! 677: extern void flexend PROTO((int)); ! 678: ! 679: ! 680: /* from file misc.c */ ! 681: ! 682: /* write out the actions from the temporary file to lex.yy.c */ ! 683: extern void action_out PROTO(()); ! 684: ! 685: /* true if a string is all lower case */ ! 686: extern int all_lower PROTO((register Char *)); ! 687: ! 688: /* true if a string is all upper case */ ! 689: extern int all_upper PROTO((register Char *)); ! 690: ! 691: /* bubble sort an integer array */ ! 692: extern void bubble PROTO((int [], int)); ! 693: ! 694: /* shell sort a character array */ ! 695: extern void cshell PROTO((Char [], int, int)); ! 696: ! 697: extern void dataend PROTO(()); /* finish up a block of data declarations */ ! 698: ! 699: /* report an error message and terminate */ ! 700: extern void flexerror PROTO((char[])); ! 701: ! 702: /* report a fatal error message and terminate */ ! 703: extern void flexfatal PROTO((char[])); ! 704: ! 705: /* report an error message formatted with one integer argument */ ! 706: extern void lerrif PROTO((char[], int)); ! 707: ! 708: /* report an error message formatted with one string argument */ ! 709: extern void lerrsf PROTO((char[], char[])); ! 710: ! 711: /* spit out a "# line" statement */ ! 712: extern void line_directive_out PROTO((FILE*)); ! 713: ! 714: /* generate a data statment for a two-dimensional array */ ! 715: extern void mk2data PROTO((int)); ! 716: ! 717: extern void mkdata PROTO((int)); /* generate a data statement */ ! 718: ! 719: /* return the integer represented by a string of digits */ ! 720: extern int myctoi PROTO((Char [])); ! 721: ! 722: /* write out one section of the skeleton file */ ! 723: extern void skelout PROTO(()); ! 724: ! 725: /* output a yy_trans_info structure */ ! 726: extern void transition_struct_out PROTO((int, int)); ! 727: ! 728: ! 729: /* from file nfa.c */ ! 730: ! 731: /* add an accepting state to a machine */ ! 732: extern void add_accept PROTO((int, int)); ! 733: ! 734: /* make a given number of copies of a singleton machine */ ! 735: extern int copysingl PROTO((int, int)); ! 736: ! 737: /* debugging routine to write out an nfa */ ! 738: extern void dumpnfa PROTO((int)); ! 739: ! 740: /* finish up the processing for a rule */ ! 741: extern void finish_rule PROTO((int, int, int, int)); ! 742: ! 743: /* connect two machines together */ ! 744: extern int link_machines PROTO((int, int)); ! 745: ! 746: /* mark each "beginning" state in a machine as being a "normal" (i.e., ! 747: * not trailing context associated) state ! 748: */ ! 749: extern void mark_beginning_as_normal PROTO((register int)); ! 750: ! 751: /* make a machine that branches to two machines */ ! 752: extern int mkbranch PROTO((int, int)); ! 753: ! 754: extern int mkclos PROTO((int)); /* convert a machine into a closure */ ! 755: extern int mkopt PROTO((int)); /* make a machine optional */ ! 756: ! 757: /* make a machine that matches either one of two machines */ ! 758: extern int mkor PROTO((int, int)); ! 759: ! 760: /* convert a machine into a positive closure */ ! 761: extern int mkposcl PROTO((int)); ! 762: ! 763: extern int mkrep PROTO((int, int, int)); /* make a replicated machine */ ! 764: ! 765: /* create a state with a transition on a given symbol */ ! 766: extern int mkstate PROTO((int)); ! 767: ! 768: extern void new_rule PROTO(()); /* initialize for a new rule */ ! 769: ! 770: ! 771: /* from file parse.y */ ! 772: ! 773: /* write out a message formatted with one string, pinpointing its location */ ! 774: extern void format_pinpoint_message PROTO((char[], char[])); ! 775: ! 776: /* write out a message, pinpointing its location */ ! 777: extern void pinpoint_message PROTO((char[])); ! 778: ! 779: extern void synerr PROTO((char [])); /* report a syntax error */ ! 780: extern int yyparse PROTO(()); /* the YACC parser */ ! 781: ! 782: ! 783: /* from file scan.l */ ! 784: ! 785: extern int flexscan PROTO(()); /* the Flex-generated scanner for flex */ ! 786: ! 787: /* open the given file (if NULL, stdin) for scanning */ ! 788: extern void set_input_file PROTO((char*)); ! 789: ! 790: extern int yywrap PROTO(()); /* wrapup a file in the lexical analyzer */ ! 791: ! 792: ! 793: /* from file sym.c */ ! 794: ! 795: /* save the text of a character class */ ! 796: extern void cclinstal PROTO ((Char [], int)); ! 797: ! 798: /* lookup the number associated with character class */ ! 799: extern int ccllookup PROTO((Char [])); ! 800: ! 801: extern void ndinstal PROTO((char[], Char[])); /* install a name definition */ ! 802: extern void scinstal PROTO((char[], int)); /* make a start condition */ ! 803: ! 804: /* lookup the number associated with a start condition */ ! 805: extern int sclookup PROTO((char[])); ! 806: ! 807: ! 808: /* from file tblcmp.c */ ! 809: ! 810: /* build table entries for dfa state */ ! 811: extern void bldtbl PROTO((int[], int, int, int, int)); ! 812: ! 813: extern void cmptmps PROTO(()); /* compress template table entries */ ! 814: extern void inittbl PROTO(()); /* initialize transition tables */ ! 815: extern void mkdeftbl PROTO(()); /* make the default, "jam" table entries */ ! 816: ! 817: /* create table entries for a state (or state fragment) which has ! 818: * only one out-transition */ ! 819: extern void mk1tbl PROTO((int, int, int, int)); ! 820: ! 821: /* place a state into full speed transition table */ ! 822: extern void place_state PROTO((int*, int, int)); ! 823: ! 824: /* save states with only one out-transition to be processed later */ ! 825: extern void stack1 PROTO((int, int, int, int)); ! 826: ! 827: ! 828: /* from file yylex.c */ ! 829: ! 830: extern int yylex PROTO(()); ! 831: ! 832: ! 833: /* The Unix kernel calls used here */ ! 834: ! 835: extern int read PROTO((int, char*, int)); ! 836: extern int unlink PROTO((char*)); ! 837: extern int write PROTO((int, char*, int));
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.