dylib_bnfrdr.h

Go to the documentation of this file.

#ifndef _DYLIB_BNFRDR_H
#define _DYLIB_BNFRDR_H

/*
  This file is part of the support library for the Dylp LP distribution.

        Copyright (C) 2005 -- 2007 Lou Hafer

        School of Computing Science
        Simon Fraser University
        Burnaby, B.C., V5A 1S6, Canada
        lou@cs.sfu.ca

  This code is licensed under the terms of the Eclipse Public License (EPL).
*/

#include "dylib_io.h"

/*
  sccs: @(#)bnfrdr.h    3.5     09/01/99
  svn/cvs: "$Id: dylib_bnfrdr.h 407 2010-12-31 20:48:48Z lou $" ;

  This file contains the structure definitions required to use the bnf reader
  package. The bnf reader depends heavily on the following two assumptions:

  * There is some pointer type into which any other pointer can be cast and
    recovered.
  
  * An int can be cast into a pointer and recovered. This is used to prevent
    the complexity of the bnf data structure from getting out of hand, but
    could be avoided at the expense of a substantial increase in its size and
    awkwardness of use.

  The basic scheme is something like this. At the bottom, we have a number of
  terminal constructs: immediates, literals, terminals, and labels of various
  flavours. Above these are the three non-terminal constructs: primitives,
  non-primitives, and generators. The non-terminals have bodies which are made
  up of references to other terminal or non-terminal constructs. Generator
  bodies have only one parse; primitive and non-primitive bodies can have a
  number of alternative parses. A picture is probably in order here:

  definition      body

  ----------      ----------      ----------      ----------
  |        | ---> |        | ---> |  ref   | ---> |  defn  |
  ----------      ----------      ----------      ----------
                  |  ....  |
                  ----------      ----------      ----------
                  |        | ---> |  ref   | ---> |  defn  |
                  ----------      ----------      ----------

  A definition contains a pointer to its body, which is an array of pointers to
  references. Each reference points to a definition. Essentially, a reference
  specifies how the second definition is to be used in the context of the body
  of the first definition.

  The bnf reader has the capability to create arbitrary links in the data
  structure it's building. Some terminology will make things easier:

                |  ....  |
                ----------      ----------
      socket -->| label -+----->|        |
                ----------      ----------
                |  ....  |      |  ....  |

  The value of a label is the address of something. To make a link, the
  value of the label has to be stored.  The place where it is stored is
  called a socket. The value of a socket is the address of the field where
  the value of the label is stored. When it defines a socket, the bnf reader
  associates a name with an address; similarly for a label. Both socket and
  label references cause a label to be stored in a socket; the difference
  between the two lies in which of the socket or label can be undefined when
  the reference is processed.

  When it's not important to distinguish between sockets and labels, the
  documentation uses label to include both.
  
  To write a bnf, you use the set of macros defined at the end of
  the file. For a detailed explanation of the sorts of things that can be
  specified with the bnf, the user should take a look at the supplementary
  documentation. The structures and code will make a lot more sense afterward.
*/



/*
  Definitions of enum types used as codes in the bnf structures which follow.
*/

/*
  bnftype_enum codes the type of the bnf definition.

  Value         Description
  -----         -----------
  bnfG          Generator definition
  bnfNP         Non-primitive definition
  bnfP          Primitive definition
  bnfT          Terminal definition
  bnfDS         Socket definition definition
  bnfDL         Label definition definition
  bnfRS         Socket reference definition 
  bnfRL         Label reference definition
  bnfI          Immediate value definition
  bnfL          Literal definition
*/

typedef enum {bnfG,bnfNP,bnfP,bnfT,bnfDS,
              bnfDL,bnfRS,bnfRL,bnfI,bnfL} bnftype_enum ;


/*
  bnfttype_enum codes the type of lexeme expected by a terminal.

  Value         Description
  -----         -----------
  bnfttNIL      the null lexeme
  bnfttN        number
  bnfttID       identifier
  bnfttD        delimiter
  bnfttF        fixed-length string
  bnfttQ        quoted string
*/

typedef enum {bnfttNIL,bnfttN,bnfttID,bnfttD,bnfttF,bnfttQ} bnfttype_enum ;


/*
  bnflblsrc_enum codes the way in which text strings used for label names
  are obtained.

  Value         Description
  -----         -----------
  bnfncBNF      A bnf is supplied which will produce a text string. If this
                code appears in the context of a name, the string will be the
                name of the label. If it appears in the context of a value,
                the string will be used as a label name and the value
                associated with the name will become the value of the label
                being defined.
  bnfncS        An index in the saved text array is supplied. The string
                retrieved is interpreted as for bnfncBNF.
  bnfncC        The value of curnde is used as the socket/label value. This
                code is not valid in the context of a name.
  bnfncN        The value of newnde is used as the socket/label value. This
                code is not valid in the context of a name.
*/

typedef enum {bnfncBNF,bnfncS,bnfncC,bnfncN} bnflblsrc_enum ;



/*
  Flag definitions used in bnf definitions.

  Flag          Description
  ----          -----------
  bnfadv        Indicates the redefinition of a previously defined label. The
                usual context for use is to redefine (advance) a label which
                is the link in a linked list.
  bnfsvnd       Save the text string developed by the nd part of a label
                definition definition or label reference definition.
  bnfsvnm       Save the text string developed by the nm part of a label
                definition definition or label reference definition. This
                flag is also used in literal definitions to indicate that text
                should be retrieved from the saved text array.
*/

#define bnfadv  1<<0
#define bnfsvnd 1<<1
#define bnfsvnm 1<<2


/*
  Flag definitions used in bnf references.

  Flag          Description
  ----          -----------
  bnflst        The definition referenced describes one element of a list of
                indefinite length.
  bnfstore      The value produced by the referenced bnf will be stored
                somehow, and the offset field should be valid.
  bnfatsgn      Store a pointer to the character string produced by the
                referenced bnf, rather than the string itself.
  bnfstbg       The bnf referenced as the separator between list elements is
                really the beginning of the next list element. (Hence we'll
                have to back up over it once we recognize it.)
  bnfflt        A float number is expected here.
  bnfdbl        A double number is expected here.
  bnfcs         Forces a case-sensitive comparison of the string read for a
                terminal with the value specified in the terminal definition.
  bnfmin        Requests a minimum-length comparison - as long as the string
                parsed for the terminal matches the value specified in the
                terminal definition up to the end of the parsed string, the
                comparison succeeds.
  bnfsv         Used in primitives to indicate that the string is to be stored
                in the savedtxt array. The offset should be a valid savedtxt
                index in this case.
  bnfexact      (bnfttF only) used to prevent the addition of the null
                terminator at the end of a character string when the string
                is stored directly in a field (must be specified to store a
                single char in a field of size sizeof(char))
  bnfdebug      Debugging should be activated for this reference and all
                bnf rules nested within it.
*/

#define bnflst          1<<0
#define bnfstore        1<<1
#define bnfatsgn        1<<2
#define bnfstbg         1<<3
#define bnfflt          1<<4
#define bnfcs           1<<5
#define bnfmin          1<<6
#define bnfsv           1<<7
#define bnfexact        1<<8
#define bnfdebug        1<<9
#define bnfdbl          1<<10



/*
  Bnfrdr regularly uses the first ([0]) entry of an array of addresses to hold
  the number of addresses in the array. In order to convert this back to an
  integer without triggering compiler warnings, the code uses this macro.
*/

# define addrToInt(zz_addr_zz) \
  ((int) (((char *)(zz_addr_zz)) - ((char *)(0))))

/*
  Data structures used for bnf definitions. There are three types of things
  here: individual structures for the various definition types, a common
  structure which consists only of the fields common to all of the individual
  structures, and a pointer union which is handy when walking around in a bnf.

  For C++ fans: really, what we're doing here is faking a base class and
  derived classes, with early 1980's technology.

  Just to keep the explanation in hand a bit, let's define components and
  alternatives. The body of a bnf definition consists of alternatives
  (alternative parses), each of which has a number of components. A component
  array is an array of pointers to bnf reference structures, each of which in
  turn references a bnf definition structure. An alternative array is an array
  of pointers to component arrays. I know this is ugly and involves a lot of
  dereferencing but it seems to be the only way to handle the variable lengths
  involved. 

  NOTE: To keep things from getting completely out of hand, the first entry
        in a component or alternative array specifies the number of pointers
        that follow. This is an abuse of type and casting. Bad when the world
        was 32-bit architectures. Worse now that it's a mix of 32- and 64-bit
        architectures. See the addrToInt macro above.
*/

/*
  The common portion.

  Field         Description
  -----         -----------
  type          Type code identifying what sort of definition this is.
  name          The name of the rule (derived from the C variable name;
                see the macros gdef, npdef, etc.)
*/

#define bnfdef_common bnftype_enum type ; \
                      const char *name ;

typedef struct { bnfdef_common } bnfdef_struct ;


/*
  Data structure for a generator definition. Generators cause the creation of a
  node in the data structure being built for the user. For simplicity, they may
  not have alternative parses, but since they can reference non-primitives no
  flexibility is lost.

  Field         Description
  -----         -----------
  bnfdef_common As above.
  size          Size (in bytes) of the node to be created.
  link          Offset (in bytes) from the base of the node created by the
                generator to the field used as a link field when this node is
                in a linked list.
  comps         Pointer to a component array.
*/

typedef struct { bnfdef_common
                 int size ;
                 int link ;
                 struct bnfref_struct_tag **comps ; } bnfGdef_struct ;


/*
  Data structure for a non-primitive definition. Non-primitives are simply a
  device for defining alternative parses. They don't directly create anything.

  Field         Description
  -----         -----------
  bnfdef_common As above.
  alts          Pointer to an alternative array.
*/

typedef struct {bnfdef_common
                struct bnfref_struct_tag ***alts ; } bnfNPdef_struct ;
                


/*
  Data structure for a primitive definition. The distinction between a
  primitive and a non-primitive is that a primitive constructs a string which
  is the concatenation of the strings returned by the bnf's referenced in the
  primitive's body. The data structure is identical to that for non-primitives.
*/

typedef bnfNPdef_struct bnfPdef_struct ;


/*
  Data structure for a terminal. Terminals are used to specify specific things
  to be obtained from the input stream. The various parameters required to
  describe a terminal should really be mushed into a union, but then the bnf
  data structure would have to be built dynamically, since unions can't be
  initialized.

  Field         Description
  -----         -----------
  bnfdef_common As above.
  ttype         Code identifying the type of terminal to be obtained.
  qschr         Starting character for a quoted string.
  qechr         Ending character for a quoted string.
  parm1         Overloaded field, interpreted as follows:
                numbers: specifies the radix
                fixed-length strings: specifies the string length
  val           Expected value of the string obtained from the input stream.
                (This test is applied before the string is converted to the
                 internal form appropriate for whatever is specified in ttype.)
*/

typedef struct { bnfdef_common
                 bnfttype_enum ttype ;
                 char qschr ;
                 char qechr ;
                 int parm1 ;
                 const char *val ; } bnfTdef_struct ;


/*
  Data structure for an immediate value. Immediates are used to jam a code into
  the data structure being built.

  Field         Description
  -----         -----------
  bnfdef_common As above.
  ival          Integer value.
*/

typedef struct {bnfdef_common
                int ival ; } bnfIdef_struct ;


/*
  Data structure for a literal. Literals are used to insert characters into the
  input stream. (Handy for generating label names, for instance.)

  Field         Description
  -----         -----------
  bnfdef_common As above.
  dflgs         Flags.
  txt           The string to be inserted. This field is also used to index
                into the saved text array by casting it to an int.
*/

typedef struct { bnfdef_common
                 flags dflgs ;
                 char *txt ; } bnfLdef_struct ;


/*
  Last but not least, the data structure used to define socket/label
  definitions and references. (Definitions, mind you - there is another
  structure to reference socket/label definitions and references.) A
  socket/label definition associates of a name (a text string) with a value
  (almost always an address).  A socket/label reference specifies a socket
  and a label. The label is inserted into the socket. Fields prefixed by nm
  are the name in a socket/label definition and the socket in a socket/label
  reference. Fields prefixed by nd are the value in a socket/label definition
  and the label in a socket/label reference.

  Field         Description
  -----         -----------
  bnfdef_common As above.
  dflgs         Flags.
  nmcd          Specifies how name/socket will be obtained.
  ndcd          Specifies how value/label will be obtained.
  savnm         Specifies location in saved text array where string associated
                with nm will be stored.
  nmsrc         Pointer to bnf which will produce string for nm, or cast into
                an int and used as a location in the saved text array.
  savnd         Specifies location in saved text array where string associated
                with nd will be stored.
  ndsrc         Pointer to bnf which will produce string for nd, or cast into
                an int and used as a location in the saved text array.
  offset        Correction (in bytes) to socket/label value (socket/label
                definitions) or socket (socket/label references).
  offset2       Correction (in bytes) to label (socket/label references).
*/

typedef struct { bnfdef_common
                 flags dflgs ;
                 bnflblsrc_enum nmcd ;
                 bnflblsrc_enum ndcd ;
                 int savnm ;
                 struct bnfref_struct_tag *nmsrc ;
                 int savnd ;
                 struct bnfref_struct_tag *ndsrc ;
                 int offset ;
                 int offset2 ; } bnfLBdef_struct ;


/*
  And finally, the handy union of pointers promised back at the start. We
  really should be using this in the bnf reference structure declarations,
  rather than (bnfdef_struct *), but since references and definitions are
  mutually recursive we get into ugliness. There's also the point that we
  want to be able to create bnfs at compile time and you can't initialize
  unions.
*/

typedef union { bnfdef_struct *com ;
                bnfGdef_struct *G ;
                bnfNPdef_struct *NP ;
                bnfPdef_struct *P ;
                bnfTdef_struct *T ;
                bnfIdef_struct *I ;
                bnfLdef_struct *L ;
                bnfLBdef_struct *LB ; } bnfdef_any ;



/*
  Now, on to the data structures used to reference bnf definitions. Recall if
  you will the introductory comments about component and alternative arrays and
  the general setup of the bnf data structure. We have the same three types of
  data structures here as for bnf definitions.
*/

/*
  The common portion. It includes a type code, a name, usage flags, and a
  pointer to the bnf definition.

  Field         Description
  -----         -----------
  type          Type code identifying what sort of definition this reference
                points to.
  name          The name of the reference (derived from the C variable name;
                see the macros qref, npref, pref, etc.)
  uflgs         Usage flags.
  defn          Pointer to a bnf definition structure.
*/

#define bnfref_common bnftype_enum type ; \
                      const char *name ; \
                      bnfdef_struct *defn ; \
                      flags uflgs ;

typedef struct bnfref_struct_tag { bnfref_common } bnfref_struct ;


/*
  References to labels of all flavours and to literals require only the
  common fields. The only reason we need the uflgs field is for the bnfdebug
  flag.
*/

typedef bnfref_struct bnfLBref_struct ;
typedef bnfref_struct bnfLref_struct ;


/*
  References to terminals and immediates require an offset for storage.

  Field         Description
  -----         -----------
  bnfref_common As above.
  offset        Offset (in bytes) into current node to the field where the
                value produced by the referenced bnf will be stored.
*/

struct bnfref_type2 { bnfref_common
                      int offset ; } ;

typedef struct bnfref_type2 bnfTref_struct ;
typedef struct bnfref_type2 bnfIref_struct ;


/*
  References to generators, non-primitives, and primitives can be in lists and
  require a separator specification in addition to the offset. Non-primitives
  do not make use of the offset field.

  Field         Description
  -----         -----------
  bnfref_common As above.
  offset        Offset (in bytes) into current node to the field where the
                value produced by the referenced bnf will be stored.
  sep           A reference to a bnf definition describing the separator
                between list elements in the input stream.
*/

struct bnfref_type3 { bnfref_common
                      int offset ;
                      bnfref_struct *sep ; } ;

typedef struct bnfref_type3 bnfGref_struct ;
typedef struct bnfref_type3 bnfNPref_struct ;
typedef struct bnfref_type3 bnfPref_struct ;


/*
  And the handy union pointer type. Same general comments as for the
  declaration of bnfdef_any.
*/

typedef union { bnfref_struct *com ;
                struct bnfref_type1 *t1 ;
                struct bnfref_type2 *t2 ;
                struct bnfref_type3 *t3 ;
                bnfGref_struct *G ;
                bnfNPref_struct *NP ;
                bnfPref_struct *P ;
                bnfTref_struct *T ;
                bnfIref_struct *I ;
                bnfLref_struct *L ;
                bnfLBref_struct *LB ; } bnfref_any ;



/*
  The macros that make defining the bnf data structures marginally
  less painful.
*/

/*
  Macros to help with constructing field offsets. NULLP is specially designed
  to produce a NULL value when used as &NULLP. This is required for some
  of the macros where one must fill the field with either the address of a
  bnfref_struct or the value NULL. By this device we avoid having to make
  the user aware of when and when not to use &.

  mkoff simply produces the offset of a given field in a structure type. But
  it's not quite that simple in the world of mixed 64- and 32-bit platforms.
  The cast to size_t leaves us with either a 64- or 32-bit int, depending
  on the size of addresses, but at least it's an int instead of a pointer,
  and that's sufficient to suppress warnings in other places when the result
  is converted to an int. And the result here should always be a small
  integer.
*/

#define NULLP (*((char *) 0))
#define mksav(qqoff) (*((char *) qqoff))
#define mkoff(qqtype,qqfield) ((size_t) (&((qqtype *) 0)->qqfield))

/*
  Macros for alternative and component lists. These just generate the headers;
  the actual lists have to be typed out, as:

  althd(arule_alts) = { altcnt(3),
                        mkaref(arule_alt1), mkaref(arule_alt2),
                        mkaref(arule_alt3) } ;

  comphd(arule_alt1) = { compcnt(2),
                         mkcref(brule_ref), mkcref(crule_ref) } ;

  where brule_ref and crule_ref are bnf references (most likely constructed
  using the gref, npref, etc. macros).
*/

#define althd(qqnme) bnfref_struct **qqnme[]
#define altcnt(qqcnt) (bnfref_struct **) (qqcnt)
#define mkaref(qqref) (bnfref_struct **) (qqref)

#define comphd(qqnme) bnfref_struct *qqnme[]
#define compcnt(qqcnt) (bnfref_struct *) (qqcnt)
#define mkcref(qqref) (bnfref_struct *) (&qqref)

/*
  Macros to initialise bnf definitions. Note the use of the ANSI C
  'stringisation' operator, '#', to get a text string for the name. For
  non-ANSI implementations, replacing #qqnme with "qqnme" usually works (but
  not all non-ANSI preprocessor implementations will see the macro parameter
  inside a string, and ANSI C explicitly disallows it).
*/

#define gdef(qqnme,qqsze,qqlnk,qqcomps) \
bnfGdef_struct qqnme = { bnfG, #qqnme, (int) (qqsze), (int) (qqlnk), \
                         (bnfref_struct **) qqcomps }

#define npdef(qqnme,qqalts) \
bnfNPdef_struct qqnme = { bnfNP, #qqnme, (bnfref_struct ***) qqalts }

#define pdef(qqnme,qqalts) \
bnfPdef_struct qqnme = { bnfP, #qqnme, (bnfref_struct ***) qqalts }

#define tdef(qqnme,qqttype,qqparm,qqval) \
bnfTdef_struct qqnme = { bnfT, #qqnme, qqttype, '\0', '\0', \
                         (int) (qqparm), (const char *) (qqval) }

#define tqdef(qqnme,qqschr,qqechr,qqval) \
bnfTdef_struct qqnme = { bnfT, #qqnme, bnfttQ, (char) qqschr, (char) qqechr,\
                         0, (char *) (qqval) }

#define dfdef(qqnme,qqdflgs,qqnmcd,qqnm,qqsavnm,qqndcd,qqnd,qqsavnd,qqoff) \
bnfLBdef_struct qqnme = { bnfDS, #qqnme, (flags) (qqdflgs), qqnmcd, qqndcd, \
                          (int) (qqsavnm), (bnfref_struct *) &qqnm, \
                          (int) (qqsavnd), (bnfref_struct *) &qqnd, \
                          (int) (qqoff), 0 }

#define dbdef(qqnme,qqdflgs,qqnmcd,qqnm,qqsavnm,qqndcd,qqnd,qqsavnd,qqoff) \
bnfLBdef_struct qqnme = { bnfDL, #qqnme, (flags) (qqdflgs), qqnmcd, qqndcd, \
                          (int) (qqsavnm), (bnfref_struct *) &qqnm, \
                          (int) (qqsavnd), (bnfref_struct *) &qqnd, \
                          (int) (qqoff), 0 }

#define rfdef(qqnme,qqdflgs,qqnmcd,qqnm,qqsavnm,qqoff,qqndcd,qqnd,qqsavnd,qqoff2) \
bnfLBdef_struct qqnme = { bnfRS, #qqnme, (flags) (qqdflgs), qqnmcd, qqndcd, \
                          (int) (qqsavnm), (bnfref_struct *) &qqnm, \
                          (int) (qqsavnd), (bnfref_struct *) &qqnd, \
                          (int) (qqoff), (int) (qqoff2) }

#define rbdef(qqnme,qqdflgs,qqnmcd,qqnm,qqsavnm,qqoff,qqndcd,qqnd,qqsavnd,qqoff2) \
bnfLBdef_struct qqnme = { bnfRL, #qqnme, (flags) (qqdflgs), qqnmcd, qqndcd, \
                          (int) (qqsavnm), (bnfref_struct *) &qqnm, \
                          (int) (qqsavnd), (bnfref_struct *) &qqnd, \
                          (int) (qqoff), (int) (qqoff2) }

#define idef(qqnme,qqval) \
bnfIdef_struct qqnme = { bnfI, #qqnme, (int) (qqval) }

#define ldef(qqnme,qqdflgs,qqtxt) \
bnfLdef_struct qqnme = { bnfL, #qqnme, (flags) (qqdflgs), (char *) (qqtxt) }



#define gref(qqnme,qqref,qquflgs,qqoff,qqsep) \
bnfGref_struct qqnme = { bnfG, #qqnme, (bnfdef_struct *) &qqref, \
                         (flags) (qquflgs), (int) (qqoff), \
                         (bnfref_struct *) &qqsep }

#define npref(qqnme,qqref,qquflgs,qqsep) \
bnfNPref_struct qqnme = { bnfNP, #qqnme, (bnfdef_struct *) &qqref, \
                         (flags) (qquflgs), (int) 0, (bnfref_struct *) &qqsep }

#define pref(qqnme,qqref,qquflgs,qqoff,qqsep) \
bnfPref_struct qqnme = { bnfP, #qqnme, (bnfdef_struct *) &qqref, \
                         (flags) (qquflgs), (int) (qqoff), \
                         (bnfref_struct *) &qqsep }

#define tref(qqnme,qqref,qquflgs,qqoff) \
bnfTref_struct qqnme = { bnfT, #qqnme, (bnfdef_struct *) &qqref, \
                         (flags) qquflgs, (int) qqoff }

#define dfref(qqnme,qqref) \
bnfLBref_struct qqnme = { bnfDS, #qqnme, (bnfdef_struct *) &qqref, (flags) 0 }

#define dbref(qqnme,qqref) \
bnfLBref_struct qqnme = { bnfDL, #qqnme, (bnfdef_struct *) &qqref, (flags) 0 }

#define rfref(qqnme,qqref) \
bnfLBref_struct qqnme = { bnfRS, #qqnme, (bnfdef_struct *) &qqref, (flags) 0 }

#define rbref(qqnme,qqref) \
bnfLBref_struct qqnme = { bnfRL, #qqnme, (bnfdef_struct *) &qqref, (flags) 0 }

#define iref(qqnme,qqref,qqoff) \
bnfIref_struct qqnme = { bnfI, #qqnme, (bnfdef_struct *) &qqref, \
                        (flags) 0, (int) qqoff }

#define lref(qqnme,qqref) \
bnfLref_struct qqnme = { bnfL, #qqnme, (bnfdef_struct *) &qqref, (flags) 0 }

#ifndef DYLP_NDEBUG

/*
  This set of definitions sets the bnfdebug flag, but doesn't add a separate
  uflgs parameter (we don't want to lead the user to think any of the others
  are valid).
*/

#define dfrefdbg(qqnme,qqref) \
bnfLBref_struct qqnme = { bnfDS, #qqnme, (bnfdef_struct *) &qqref, \
                          (flags) bnfdebug }

#define dbrefdbg(qqnme,qqref) \
bnfLBref_struct qqnme = { bnfDL, #qqnme, (bnfdef_struct *) &qqref, \
                          (flags) bnfdebug }

#define rfrefdbg(qqnme,qqref) \
bnfLBref_struct qqnme = { bnfRS, #qqnme, (bnfdef_struct *) &qqref, \
                          (flags) bnfdebug }

#define rbrefdbg(qqnme,qqref) \
bnfLBref_struct qqnme = { bnfRL, #qqnme, (bnfdef_struct *) &qqref, \
                          (flags) bnfdebug }

#define lrefdbg(qqnme,qqref) \
bnfLref_struct qqnme = { bnfL, #qqnme, (bnfdef_struct *) &qqref, \
                          (flags) bnfdebug }

#endif /* DYLP_NDEBUG */



/*
  Last, but not least, some declarations to allow the use of the bnf reader.
  rdrinit and rdrclear initialize and clear the reader; they should bracket
  related groups of calls. parse is the main parsing routine. The union type
  parse_any is the appropriate thing to hold the result.
*/

typedef union { void *g ;
                char *c ; } parse_any ;

extern void rdrinit(void),rdrclear(void) ;
extern bool parse(ioid chn, struct bnfref_type3 *bnfid, parse_any *result) ;

#ifndef DYLP_NDEBUG
/*
  The control routine for the bnf debugging trace output. See the comments
  in bnfrdr.c for the proper use of the parameters.
*/
  
extern void bnfdbgctl(ioid dbgchn, bool dbgecho, bool warnzlbl, bool numlvl,
                      bool tablvl) ;
#else
#define bnfdbgctl(dgbchn,dbgecho,warnzlbl,numlvl,tablvl)
#endif

/*
  Utility print routines from bnfrdrio.c.
*/

extern void prtbnfref(ioid chn, bool echo, bnfref_struct *ref),
            prtbnfdef(ioid chn, bool echo, bnfdef_struct *def) ;

#endif /* _DYLIB_BNFRDR_H */