home *** CD-ROM | disk | FTP | other *** search
/ The C Users' Group Library 1994 August / wc-cdrom-cusersgrouplibrary-1994-08.iso / vol_300 / 333_01 / awk.h < prev    next >
C/C++ Source or Header  |  1989-02-20  |  18KB  |  542 lines
  1.  
  2. /***************************************************************************/
  3. /*                                       */
  4. /*               awk.h -- Definitions for gawk.               */
  5. /*                                       */
  6. /*         Copyright (C) 1986 Free Software Foundation           */
  7. /*             Written by Paul Rubin, August 1986            */
  8. /*                                       */
  9. /***************************************************************************/
  10. /*                                       */
  11. /* GAWK is distributed in the hope that it will be useful, but WITHOUT ANY */
  12. /* WARRANTY.  No author or distributor accepts responsibility to anyone    */
  13. /* for the consequences of using it or for whether it serves any       */
  14. /* particular purpose or works at all, unless he says so in writing.       */
  15. /* Refer to the GAWK General Public License for full details.           */
  16. /*                                       */
  17. /* Everyone is granted permission to copy, modify and redistribute GAWK,   */
  18. /* but only under the conditions described in the GAWK General Public       */
  19. /* License.  A copy of this license is supposed to have been given to you  */
  20. /* along with GAWK so you can know your rights and responsibilities.  It   */
  21. /* should be in a file named COPYING.  Among other things, the copyright   */
  22. /* notice and this notice must be preserved on all copies.           */
  23. /*                                       */
  24. /* In other words, go ahead and share GAWK, but don't try to stop          */
  25. /* anyone else from sharing it farther.  Help stamp out software hoarding! */
  26. /*                                       */
  27. /***************************************************************************/
  28.  
  29. #ifndef AWK_H
  30. #define AWK_H
  31.  
  32.  
  33. #define AWKNUM              double
  34.  
  35. #include "regex.h"
  36.  
  37. #include <ctype.h>
  38. #define is_identchar(c)       (isalnum(c) || (c) == '_')
  39.  
  40. #define obstack_chunk_alloc    malloc
  41. #define obstack_chunk_free     free
  42. #include "obstack.h"
  43.  
  44. #define PROFILER           TRUE
  45.  
  46. #if PROFILER
  47. #define STATIC
  48. #else
  49. #define STATIC               static
  50. #endif
  51.  
  52. #define EOS               '\0'
  53. #define FPTR               void far *
  54.  
  55. #if defined(__POWERC)
  56. #define NEAR
  57. #define PASCAL
  58. #define CDECL
  59. #define VOID               int
  60. #else
  61. #define NEAR               near
  62. #define PASCAL               pascal
  63. #define CDECL               cdecl
  64. #define VOID               void
  65. #endif
  66.  
  67. #define TABSTOPS           8
  68.  
  69. #define MAXDIM(array)           (sizeof(array) / sizeof(array[0]))
  70.  
  71. #define MAX_SUBSCRIPT_LEN      80
  72.  
  73. #ifndef TRUE
  74. #define TRUE               1
  75. #define FALSE               0
  76. #endif
  77.  
  78. typedef int               BOOL;
  79.  
  80. /*  illegal node entry                                */
  81. #define NODE_ILLEGAL        0
  82.  
  83. /*  binary operators - lnode and rnode are the expressions to work on        */
  84. #define NODE_EXPONENTIAL    1
  85. #define NODE_TIMES        2
  86. #define NODE_QUOTIENT        3
  87. #define NODE_MOD        4
  88. #define NODE_PLUS        5
  89. #define NODE_MINUS        6
  90. #define NODE_COND_PAIR        7
  91. #define NODE_SUBSCRIPT        8
  92. #define NODE_CONCAT        9
  93.  
  94. /* unary operators - subnode is the expression to work on            */
  95. #define NODE_PREINCREMENT    10
  96. #define NODE_PREDECREMENT    11
  97. #define NODE_POSTINCREMENT    12
  98. #define NODE_POSTDECREMENT    13
  99. #define NODE_UNARY_MINUS    14
  100. #define NODE_FIELD_SPEC     15
  101.  
  102. /* assignment operators - lnode is the var to assign to rnode is the exp    */
  103. #define NODE_ASSIGN        16
  104. #define NODE_ASSIGN_EXPONENTIAL 17
  105. #define NODE_ASSIGN_TIMES    18
  106. #define NODE_ASSIGN_QUOTIENT    19
  107. #define NODE_ASSIGN_MOD     20
  108. #define NODE_ASSIGN_PLUS    21
  109. #define NODE_ASSIGN_MINUS    22
  110.  
  111. /*  boolean binary operators - lnode and rnode are expressions            */
  112. #define NODE_AND        23
  113. #define NODE_OR         24
  114.  
  115. /*  relational binary operators - lnode and rnode are exp to comapre        */
  116. #define NODE_EQUAL        25
  117. #define NODE_NOTEQUAL        26
  118. #define NODE_LESS        27
  119. #define NODE_GREATER        28
  120. #define NODE_LEQ        29
  121. #define NODE_GEQ        30
  122.  
  123. /*  relational unary operators - subnode is the expression to operate on    */
  124. #define NODE_NOT        31
  125.  
  126. /*  match operators - lnode is an exp, rnode is a regular expression        */
  127. #define NODE_MATCH        32
  128. #define NODE_NOMATCH        33
  129.  
  130. /*  data items                                    */
  131. #define NODE_STRING        34  /* stptr and stlen                */
  132. #define NODE_TEMP_STRING    35  /* stptr and stlen                */
  133. #define NODE_NUMBER        36  /* numbr                    */
  134.  
  135. /*  program structures                                */
  136. #define NODE_RULE_LIST        37  /* lnode is rule, rnode rest of list    */
  137. #define NODE_RULE_NODE        38  /* lnode is cond, rnode is statement    */
  138. #define NODE_STATEMENT_LIST    39  /* lnode is stmt, rnode is more list    */
  139. #define NODE_IF_BRANCHES    40  /* lnode is TRUE side, rnode is FALSE   */
  140. #define NODE_EXPRESSION_LIST    41  /* lnode is an exp, rnode is more list  */
  141.  
  142. /*  keywords                                    */
  143. #define NODE_K_BEGIN        42  /* nothing on either side            */
  144. #define NODE_K_END        43  /* nothing on either side            */
  145. #define NODE_K_IF        44  /* lnode is cond, rnode is if_branches  */
  146. #define NODE_K_WHILE        45  /* lnode is cond, rnode stuff to run    */
  147. #define NODE_K_FOR        46  /* lnode is for_struct, rnode run stuff */
  148. #define NODE_K_ARRAYFOR     47  /* lnode is for_struct, rnode run stuff */
  149. #define NODE_K_BREAK        48  /* nothing on either side            */
  150. #define NODE_K_CONTINUE     49  /* nothing on either side            */
  151. #define NODE_K_PRINT        50  /* lnode is exp_list, rnode is redirect */
  152. #define NODE_K_PRINTF        51  /* lnode is exp_list, rnode is redirect */
  153. #define NODE_K_NEXT        52  /* nothing on either side            */
  154. #define NODE_K_EXIT        53  /* subnode is return value, or NULL     */
  155. #define NODE_K_DELETE        54  /* lnode is symbol, rnode is subscript  */
  156. #define NODE_GETLINE        55  /* lnode is var, rnode is redirect        */
  157.  
  158. /*  I/O redirection for print statements                    */
  159. #define NODE_REDIRECT_INPUT    56  /* subnode is where to redirect        */
  160. #define NODE_REDIRECT_OUTPUT    57  /* subnode is where to redirect        */
  161. #define NODE_REDIRECT_APPEND    58  /* subnode is where to redirect        */
  162. #define NODE_REDIRECT_PIPE    59  /* subnode is where to redirect        */
  163.  
  164. /*  variables                                    */
  165. #define NODE_VAR        60  /* rnode is value, lnode array stuff    */
  166. #define NODE_VAR_ARRAY        61  /* array is ptr to elements, asize = #  */
  167.  
  168. /*  builtin functions - subnode is exp_list, proc is function to call        */
  169. #define NODE_BUILTIN        62
  170.  
  171. /*  line range pattern                                */
  172. #define NODE_LINE_RANGE     63
  173.  
  174. /*  conditional expression                            */
  175. #define NODE_CONDEXP        64  /* lnode is cond, rnode is cond_branches*/
  176. #define NODE_CONDEXP_BRANCHES    65  /* lnode is exp if TRUE, rnode if FALSE */
  177.  
  178. /*  regular expression                                */
  179. #define NODE_REGEXP        66
  180.  
  181. /*  membership conditional                            */
  182. #define NODE_MEMBER_COND    67
  183.  
  184.  
  185. typedef struct exp_node
  186. {
  187.     int                       type;
  188.     union
  189.     {
  190.     struct
  191.     {
  192.         struct exp_node              *lptr;
  193.         union
  194.         {
  195.         struct exp_node           *rptr;
  196.         struct exp_node        *(PASCAL *pptr)(struct exp_node *);
  197.         REPAT_BUFFER             *preg;
  198.         struct for_loop_header         *hd;
  199.         struct ahash            **av;
  200.         int                  r_ent; /* range entered (jfw) */
  201.         } r;
  202.     } nodep;
  203.     struct
  204.     {
  205.         struct exp_node            **ap;
  206.         int                   as;
  207.     } ar;
  208.     struct
  209.     {
  210.         char                 *sp;
  211.         int                   slen, sref;
  212.     } str;
  213.     AWKNUM                      fltnum;
  214.   } sub;
  215. } NODE;
  216.  
  217. #define lnode           sub.nodep.lptr
  218. #define rnode           sub.nodep.r.rptr
  219.  
  220. #define subnode        lnode
  221. #define proc           sub.nodep.r.pptr
  222.  
  223. #define reexp           lnode
  224. #define rereg           sub.nodep.r.preg
  225.  
  226. #define forsub           lnode
  227. #define forloop        sub.nodep.r.hd
  228.  
  229. #define array           sub.ar.ap
  230. #define arrsiz           sub.ar.as
  231.  
  232. #define stptr           sub.str.sp
  233. #define stlen           sub.str.slen
  234. #define stref           sub.str.sref
  235.  
  236. #define numbr           sub.fltnum
  237.  
  238. #define var_value       lnode
  239. #define var_array       sub.nodep.r.av
  240.  
  241. #define condpair       lnode
  242. #define triggered       sub.nodep.r.r_ent
  243.  
  244. #define HASHSIZE       101
  245. #define ASSOC_HASHSIZE       29
  246. #define STIR_BITS(n)       ((n) << 5 | (((n) >> 27) & 0x1f))
  247. #define HASHSTEP(old, c)   ((old << 1) + c)
  248. #define MAKE_POS(v)       (((v) < 0) ? -(v) : (v))
  249.  
  250. /* the following defines are used in calls to assoc_lookup() to advise the  */
  251. /* function of the type of action desired on the subscripted variable.        */
  252. #define ASSOC_CREATE       0    /* if var doesn't exist, create it          */
  253. #define ASSOC_TEST       1    /* test if var exists, don't create         */
  254. #define ASSOC_DELETE       2    /* if var exists delete it            */
  255.  
  256.  
  257. typedef struct hashnode        HASHNODE;
  258. struct hashnode
  259. {
  260.     HASHNODE *next;
  261.     char *name;
  262.     int length;
  263.     NODE *value;
  264. };
  265.  
  266.  
  267. typedef struct ahash            AHASH;
  268. struct ahash
  269. {
  270.     AHASH        *next;
  271.     NODE        *name,
  272.             *symbol,
  273.             *value;
  274. };
  275.  
  276.  
  277. typedef struct for_loop_header
  278. {
  279.     NODE        *init;
  280.     NODE        *cond;
  281.     NODE        *incr;
  282. } FOR_LOOP_HEADER;
  283.  
  284.  
  285. #define ADD_ONE_REFERENCE(s) ++(s)->stref
  286. #define FREE_ONE_REFERENCE(s) {\
  287.   if(s==Nnull_string) {\
  288.     fprintf(stderr,"Free_Nnull_string %d",(s)->stref);\
  289.   }\
  290.   if (--(s)->stref == 0) {\
  291.     free((char *)((s)->stptr));\
  292.     free((char *)s);\
  293.   }\
  294. }
  295.  
  296.     /* %%% VANDYS:
  297.      *  Can you say "do it with mirrors"?
  298.      *  Sure.  I knew you could.
  299.      *  There isn't exactly a 1:1 correspondence between the BSD
  300.      *   routines & the Sys-V ones, but it's close enough.
  301.      */
  302. #ifndef BSD
  303. #define index strchr
  304. #define bcopy(src, dest, count) memcpy(dest, src, count)
  305. #define bzero(ptr, count) memset(ptr, '\0', count)
  306. #define bcmp memcmp
  307. #endif /* BSD */
  308.  
  309. #if defined(__TURBOC__) || defined(__POWERC)
  310. #define NEARDATA
  311. #else
  312. #define NEARDATA        NEAR
  313. #endif
  314.  
  315. #ifdef DRIVER
  316. #define VARCLASS
  317. #define INIT(x)         = x
  318. #else
  319. #define VARCLASS        extern
  320. #define INIT(x)
  321. #endif
  322.  
  323. VARCLASS    NODE *     NEARDATA    expression_value    INIT(NULL);
  324.  
  325. VARCLASS    REPAT_BUFFER NEARDATA    wrk_repat;
  326. VARCLASS    char     NEARDATA    wrk_fastmap[FASTMAP_SIZE];
  327.  
  328.     /* This node is the cannonical null string, used everywhere */
  329. VARCLASS    NODE *     NEARDATA    Nnull_string    INIT(NULL);
  330.     /* A block of gAWK code to be run before running the program */
  331. VARCLASS    NODE *     NEARDATA    begin_block    INIT(NULL);
  332.     /* A block of gAWK code to be run after the last input file */
  333. VARCLASS    NODE *     NEARDATA    end_block        INIT(NULL);
  334.     /* These nodes store all the special variables gAWK uses */
  335. VARCLASS    NODE *     NEARDATA    FILENAME_node    INIT(NULL);
  336. VARCLASS    NODE *     NEARDATA    FS_node        INIT(NULL);
  337. VARCLASS    NODE *     NEARDATA    NF_node        INIT(NULL);
  338. VARCLASS    NODE *     NEARDATA    RS_node        INIT(NULL);
  339. VARCLASS    NODE *     NEARDATA    NR_node        INIT(NULL);
  340. VARCLASS    NODE *     NEARDATA    OFS_node        INIT(NULL);
  341. VARCLASS    NODE *     NEARDATA    ORS_node        INIT(NULL);
  342. VARCLASS    NODE *     NEARDATA    OFMT_node        INIT(NULL);
  343. VARCLASS    NODE *     NEARDATA    FNR_node        INIT(NULL);  /* BW */
  344. VARCLASS    NODE *     NEARDATA    RLENGTH_node    INIT(NULL);  /* BW */
  345. VARCLASS    NODE *     NEARDATA    RSTART_node    INIT(NULL);  /* BW */
  346. VARCLASS    NODE *     NEARDATA    ARGC_node        INIT(NULL);  /* BW */
  347. VARCLASS    NODE *     NEARDATA    ARGV_node        INIT(NULL);  /* BW */
  348. VARCLASS    NODE *     NEARDATA    SUBSEP_node    INIT(NULL);  /* BW */
  349.  
  350. VARCLASS    FILE *     NEARDATA    input_file     INIT(NULL);
  351. VARCLASS    char     NEARDATA    current_filename[64] INIT("");
  352.  
  353. VARCLASS    HASHNODE *     NEARDATA    variables[HASHSIZE];
  354.  
  355.     /* This dumb kludge is used by force_string to turn a floating point  */
  356.     /* number into a string                          */
  357. VARCLASS    NODE     NEARDATA    dumb[2];
  358.  
  359. VARCLASS    NODE **     NEARDATA    fields_arr     INIT(NULL);
  360. VARCLASS    NODE *     NEARDATA    fields_nodes    INIT(NULL);
  361. VARCLASS    int      NEARDATA    f_arr_siz        INIT(0);
  362. VARCLASS    char     NEARDATA    f_empty[2]     INIT("");
  363.  
  364.     /* Temporary nodes are stored here.  ob_dummy is a dummy object used   */
  365.     /* to keep the obstack library from free()ing up the entire stack.       */
  366. VARCLASS    OBSTACK     NEARDATA    temp_strings;
  367. VARCLASS    char *     NEARDATA    ob_dummy        INIT(NULL);
  368.  
  369.     /* The parse tree and field nodes are stored here.    Parse_end is a       */
  370.     /* dummy item used to free up unneeded fields without freeing the       */
  371.     /* program being run                           */
  372. VARCLASS    OBSTACK     NEARDATA    other_stack;
  373. VARCLASS    char *     NEARDATA    parse_end        INIT(NULL);
  374.  
  375.     /* The name the program was invoked under, for error messages       */
  376. VARCLASS    char *     NEARDATA    myname        INIT(NULL);
  377.  
  378.     /* We can't dereference a variable until after we've given it       */
  379.     /* its new value. This variable points to the value we have to free up */
  380. VARCLASS    NODE *     NEARDATA    deref        INIT(NULL);
  381.  
  382.     /* Switches used for debugging */
  383. VARCLASS    int      NEARDATA    debugging        INIT(0);
  384.  
  385. VARCLASS    char     NEARDATA    re_syntax_table[256];
  386.  
  387. #define WHOLELINE             fields_arr[0]
  388.  
  389.  
  390. #undef VARCLASS
  391. #undef INIT
  392.  
  393.  
  394. /*  AWK1.C  */
  395.  
  396.  
  397. void         PASCAL clear_wrk_repat(void);
  398. void            panic(char *str, ...);
  399. void         PASCAL er_panic(char *str);
  400. void         PASCAL usage(void);
  401. NODE *         PASCAL newnode(int ty);
  402. NODE *         PASCAL dupnode(NODE *n);
  403. NODE *         PASCAL node(NODE *left, int op, NODE *right);
  404. NODE *         PASCAL snode(NODE *subn, int op,
  405.                   NODE *(PASCAL *procp)(NODE *));
  406. NODE *         PASCAL mkrangenode(NODE *cpair);
  407. int         PASCAL count_arguments(NODE *exp_list);
  408. NODE *         PASCAL make_number(AWKNUM x);
  409. NODE *         PASCAL tmp_number(AWKNUM x);
  410. NODE *         PASCAL make_string(char *s, int len);
  411. NODE *         PASCAL tmp_string(char *s, int len);
  412. REPAT_BUFFER *     PASCAL make_regexp(char *s);
  413. FOR_LOOP_HEADER * PASCAL make_for_loop(NODE *init, NODE *cond, NODE *incr);
  414. NODE *         PASCAL variable(char *name);
  415. NODE *         PASCAL spc_var(char *name, NODE *value);
  416. NODE *         PASCAL install(HASHNODE **table, char *name, NODE *value);
  417. NODE *         PASCAL lookup(HASHNODE **table, char *name);
  418. int         PASCAL hashf(char *name, int len, int hashsize);
  419. NODE *         PASCAL append_right(NODE *list, NODE *new);
  420.  
  421. /*  AWK2.C  */
  422.  
  423. int         PASCAL interpret(NODE *tree);
  424. NODE *         PASCAL tree_eval(NODE *tree);
  425. NODE **      PASCAL get_lhs(NODE *ptr);
  426. void         PASCAL do_deref(void);
  427. void         PASCAL assign_number(NODE **ptr, AWKNUM value);
  428. void         PASCAL init_fields(void);
  429. void         PASCAL blank_fields(void);
  430. void         PASCAL set_field(int n, char *str, int len);
  431. NODE *         PASCAL field_string(char *s, int len);
  432. void         PASCAL fix_fields(void);
  433. int         PASCAL eval_condition(NODE *tree);
  434. int         PASCAL is_a_number(char *str);
  435. int         PASCAL cmp_nodes(NODE *t1, NODE *t2);
  436. void         PASCAL assoc_clear(NODE *symbol);
  437. NODE **      PASCAL assoc_lookup(NODE *symbol, NODE *subs, int operation);
  438. NODE *         PASCAL strforce(NODE *n);
  439. AWKNUM         PASCAL force_number(NODE *n);
  440. NODE *         PASCAL force_string(NODE *s);
  441.  
  442. /*  AWK3.C  */
  443.  
  444. void         PASCAL init_vars(void);
  445. char *         PASCAL get_ofmt(void);
  446. REPAT_BUFFER *     PASCAL get_fs(void);
  447. void         PASCAL set_fs(char *str);
  448. void         PASCAL set_rs(char *str);
  449. int         PASCAL get_rs(void);
  450. NODE *         PASCAL do_match(NODE *tree);
  451. NODE *         PASCAL do_sub(NODE *tree);
  452. NODE *         PASCAL do_gsub(NODE *tree);
  453. NODE *         PASCAL do_exp(NODE *tree);
  454. NODE *         PASCAL do_cos(NODE *tree);
  455. NODE *         PASCAL do_sin(NODE *tree);
  456. NODE *         PASCAL do_atan2(NODE *tree);
  457. NODE *         PASCAL do_getline(NODE *tree);
  458. NODE *         PASCAL do_close(NODE *tree);
  459. NODE *         PASCAL do_index(NODE *tree);
  460. NODE *         PASCAL do_upper(NODE *tree);
  461. NODE *         PASCAL do_lower(NODE *tree);
  462. NODE *         PASCAL do_reverse(NODE *tree);
  463. NODE *         PASCAL do_srand(NODE *tree);
  464. NODE *         PASCAL do_rand(NODE *tree);
  465. NODE *         PASCAL do_int(NODE *tree);
  466. NODE *         PASCAL do_length(NODE *tree);
  467. NODE *         PASCAL do_log(NODE *tree);
  468. NODE *         PASCAL do_printf(NODE *tree);
  469. NODE *         PASCAL do_split(NODE *tree);
  470. NODE *         PASCAL do_sprintf(NODE *tree);
  471. NODE *         PASCAL do_sqrt(NODE *tree);
  472. NODE *         PASCAL do_substr(NODE *tree);
  473. NODE *         PASCAL do_system(NODE *tree);
  474. void         PASCAL hack_print_node(NODE *tree);
  475. void         PASCAL get_one(NODE *tree, NODE **res);
  476. void         PASCAL get_two(NODE *tree, NODE **res1, NODE **res2);
  477. int         PASCAL get_three(NODE *tree, NODE **res1,
  478.                   NODE **res2, NODE **res3);
  479. int         PASCAL a_get_three(NODE *tree, NODE **res1,
  480.                     NODE **res2, NODE **res3);
  481. int         PASCAL inrec(FILE *fp);
  482. int         PASCAL read_a_record(FILE *fp, char **buf,
  483.                       int *buflen, int *cnt);
  484. void         PASCAL field_spec_changed(AWKNUM fld_no);
  485. void         PASCAL split_out_fields(int blank_em);
  486. FILE *         PASCAL deal_redirect(NODE *tree);
  487. void         PASCAL close_redirect_files(void);
  488. void         PASCAL print_simple(NODE *tree, FILE *fp);
  489.  
  490. /*  OBSTACK.C  */
  491.  
  492. void         PASCAL _obstack_begin(struct obstack *h, void *(*chunkfun)());
  493. void         PASCAL _obstack_newchunk(struct obstack *h,
  494.                       void *(*chunkfun)(), int length);
  495. void         PASCAL _obstack_free(struct obstack *h,
  496.                       void (*freechunkfun)(), char *obj);
  497. void         PASCAL obstack_begin(OBSTACK *h, int try_length);
  498. void         PASCAL obstack_grow(OBSTACK *h, char *where, int length);
  499. void         PASCAL obstack_grow0(OBSTACK *h, char *where, int length);
  500. void         PASCAL obstack_1grow(OBSTACK *h, int datum);
  501. void         PASCAL obstack_blank(OBSTACK *h, int length);
  502. void *         PASCAL obstack_finish(OBSTACK *h);
  503. void         PASCAL obstack_free(OBSTACK *h, char *obj);
  504.  
  505. #ifndef FAST
  506. /*  DEBUG.C  */
  507.  
  508. void         PASCAL ptree(NODE *n);
  509. void         PASCAL pt(void);
  510. void         PASCAL print_parse_tree(NODE *ptr);
  511. void         PASCAL dump_vars(void);
  512. void         PASCAL dump_fields(void);
  513. void            print_debug(char *str, ...);
  514. void         PASCAL print_a_node(NODE *ptr);
  515. void         PASCAL print_maybe_semi(NODE *ptr);
  516. NODE *         PASCAL do_prvars(NODE *);
  517. NODE *         PASCAL do_bp(NODE *);
  518. #endif /* FAST */
  519.  
  520. /*  REGEX1.C  */
  521.  
  522. int         PASCAL re_set_syntax(int syntax);
  523. char *         PASCAL re_compile_pattern(char *pattern, int size,
  524.                        REPAT_BUFFER *bufp);
  525. void         PASCAL re_compile_fastmap(REPAT_BUFFER *bufp);
  526. char *         PASCAL re_comp(char *s);
  527. int         PASCAL re_exec(char *s);
  528.  
  529. /*  REGEX2.C  */
  530.  
  531. int         PASCAL re_search(REPAT_BUFFER *pbufp, char *string, int size,
  532.                   int startpos, int range, REREGS *regs);
  533. int         PASCAL re_match(REPAT_BUFFER *pbufp, char *string, int size,
  534.                  int pos, REREGS *regs);
  535.  
  536. /*  AWKTAB.C  */
  537.  
  538. int         yyparse(void);
  539. void         yyerror(char *mesg, ...);
  540.  
  541. #endif        /* AWK_H */
  542.