/* Standard Generalized Markup Language Users' Group (SGMLUG)
SGML Parser Materials (ARCSGML 1.0)
(C) 1983-1988 Charles F. Goldfarb (assigned to IBM Corporation)
(C) 1988-1991 IBM Corporation
Licensed to the SGML Users' Group for distribution under the terms of
the following license: */
char license[] =
"SGMLUG hereby grants to any user: (1) an irrevocable royalty-free,\n\
worldwide, non-exclusive license to use, execute, reproduce, display,\n\
perform and distribute copies of, and to prepare derivative works\n\
based upon these materials; and (2) the right to authorize others to\n\
do any of the foregoing.\n";
#include "sgmlincl.h"
/* SGMLXTRN: Storage allocation and initialization for all public variables.
Exceptions: Constants lex????? and del????? are defined in
LEX?????.C modules; constants pcb????? are defined in PCB?????.c.
*/
int badresw = 0; /* 1=REF_ out of context; 0=valid. */
int charmode = 0; /* >0=in #CHARS; 0=not. */
int conactsw = 0; /* 1=return saved content action 0=get new one.*/
int conrefsw = 0; /* 1=content reference att specified; 0=no. */
int contersv = 0; /* Save contersw while processing pending REF. */
int contersw = 0; /* 1=element or #CHARS out of context; 0=valid. */
int datarc = 0; /* Return code for data: DAF_ or REF_. */
int delmscsw = 0; /* 1=DELMSC must be read on return to es==0. */
int didreq = 0; /* 1=required implied tag processed; 0=no. */
int dostag = 0; /* 1=retry newetd instead of parsing; 0=parse. */
int dtdsw = 0; /* DOCTYPE declaration found: 1=yes; 0=no. */
int entdatsw = 0; /* 2=CDATA entity; 4=SDATA; 8=NDATA; 0=none. */
int entpisw = 0; /* 4=PI entity occurred; 0=not. */
int eodsw = 0; /* 1=eod found in error; 0=not yet. */
int eofsw = 0; /* 1=eof found in body of document; 0=not yet. */
int es = -1; /* Index of current source in stack. */
int etagimct = 0; /* Implicitly ended elements left on stack. */
int etagimsw = 0; /* 1=end-tag implied by other end-tag; 0=not. */
int etagmin = MINNONE; /* Minim: NONE NULL NET DATA; implied by S/ETAG*/
int etictr = 0; /* Number of "NET enabled" tags on stack. */
int etisw = 0; /* 1=tag ended with eti; 0=did not. */
int indtdsw = 0; /* Are we in the DTD? 1=yes; 0=no. */
int mslevel = 0; /* Nesting level of marked sections. */
int msplevel = 0; /* Nested MS levels subject to special parse. */
int prologsw = 1; /* 1=in prolog; 0=not. */
int pss = 0; /* SGMLACT: scbsgml stack level. */
int sgmlsw = 0; /* SGML declaration found: 1=yes; 0=no. */
int stagmin = MINNONE; /* Minimization: NONE, NULL tag, implied by STAG*/
int tagctr = 0; /* Tag source chars read. */
int ts = -1; /* Index of current tag in stack. */
struct parse *propcb = &pcbpro; /* Current PCB for prolog parse. */
int aentctr = 0; /* Number of ENTITY tokens in this att list. */
int conact = 0; /* Return code from content parse. */
int conrefsv = 0; /* Save conrefsw when doing implied start-tag.*/
int dtdrefsw = 0; /* External DTD? 1=yes; 0=no. */
int etiswsv = 0; /* Save etisw when processing implied start-tag.*/
int grplvl = 0; /* Current level of nested grps in model. */
int idrctr = 0; /* Number of IDREF tokens in this att list. */
int mdessv = 0; /* ES level at start of markup declaration. */
int notadn = 0; /* Position of NOTATION attribute in list. */
int parmno = 0; /* Current markup declaration parameter number. */
int pexsw = 0; /* 1=tag valid solely because of plus exception.*/
int rcessv = 0; /* ES level at start of RCDATA content. */
int tagdelsw = 0; /* 1=tag ended with delimiter; 0=no delimiter. */
int tokencnt = 0; /* Number of tokens found in attribute value. */
struct entity *ecbdeflt = 0; /* #DEFAULT ecb (NULL if no default entity). */
struct etd *docetd = 0; /* The etd for the document as a whole. */
struct etd *etagreal = 0; /* Actual or dummy etd that implied this tag. */
struct etd *newetd = 0; /* The etd for a start- or end-tag recognized. */
struct etd *nextetd = 0; /* ETD that must come next (only one choice). */
struct etd *stagreal = 0; /* Actual or dummy etd that implied this tag. */
struct parse *conpcb = 0; /* Current PCB for content parse. */
UNCH *data = 0; /* Pointer to returned data in buffer. */
UNCH *mdname = 0; /* Name of current markup declaration. */
UNCH *ptcon = 0; /* Current pointer into tbuf. */
UNCH *ptpro = 0; /* Current pointer into tbuf. */
UNCH *rbufs = 0; /* DOS file read area: start position for read. */
UNCH *subdcl = 0; /* Subject of markup declaration (e.g., GI). */
int Tstart = 0; /* Save starting token for AND group testing. */
UNS conradn = 0; /* 1=CONREF attribute in list (0=no). */
UNS datalen = 0; /* Length of returned data in buffer. */
UNS entlen = 0; /* Length of TAG or EXTERNAL entity text. */
UNS idadn = 0; /* Number of ID attribute (0 if none). */
UNS noteadn = 0; /* Number of NOTATION attribute (0 if none). */
UNS reqadn = 0; /* Num of atts with REQUIRED default (0=none). */
int grplongs; /* Number of longs for GRPCNT bitvector. */
/* Variable arrays and structures.
*/
struct ad *al = 0; /* Current attribute list work area. */
struct dcncb *dcntab[1]; /* List of data content notation names. */
struct entity *etab[ENTHASH]; /* Entity hash table. */
struct etd *etdtab[ETDHASH]; /* Element type definition hash table. */
struct fpi fpidf; /* Fpi for #DEFAULT entity. */
struct id *itab[IDHASH]; /* Unique identifier hash table. */
struct etd **nmgrp = 0; /* Element name group */
PDCB *nnmgrp = 0; /* Notation name group */
struct restate *scbsgml = 0; /* SGMLACT: return action state stack. */
struct source *scbs = 0; /* Stack of open sources ("SCB stack"). */
struct srh *srhtab[1]; /* List of SHORTREF table headers. */
struct sgmlstat ds; /* Document statistics. */
struct switches sw; /* Parser control switches set by text proc. */
struct tag *tags = 0; /* Stack of open elements ("tag stack"). */
struct thdr *gbuf = 0; /* Buffer for creating group. */
struct thdr prcon[3]; /* 0-2: Model for *DOC content. */
struct thdr undechdr; /* 0:Default model hdr for undeclared content.*/
UNCH *dtype = 0; /* Document type name. */
UNCH *entbuf = 0; /* Buffer for entity reference name. */
UNCH fce[2]; /* String form of FCE char.
(fce[1] must be EOS).*/
/* Buffer for non-SGML character reference.*/
UNCH nonchbuf[2] = { DELNONCH };
UNCH *tbuf; /* Work area for tokenization. */
UNCH *lbuf = 0; /* In tbuf: Literal parse area.*/
UNCH *sysibuf = 0; /* Buffer for system identifiers. */
UNCH *pubibuf = 0; /* Buffer for public identifiers. */
UNCH *nmbuf = 0; /* Name buffer used by mdentity. */
struct mpos *savedpos;
/* Constants.
*/
struct map dctab[] = { /* Keywords for declared content parameter.*/
{ key[KRCDATA], MRCDATA+MPHRASE },
{ key[KCDATA], MCDATA+MPHRASE },
{ key[KANY], MANY+MCHARS+MGI },
{ key[KEMPTY], MNONE+MPHRASE },
{ NULL, 0 }
};
struct map deftab[] = { /* Default value keywords. */
{ key[KIMPLIED], DNULL },
{ key[KREQUIRED], DREQ },
{ key[KCURRENT], DCURR },
{ key[KCONREF], DCONR },
{ key[KFIXED], DFIXED},
{ NULL, 0}
};
struct map dvtab[] = { /* Declared value: keywords and type codes.*/
/* TYPE NUMBER */
/* grp ANMTGRP Case 1 0 Grp size */
/* grp member ANMTGRP Case 0 Position */
/* grp ANOTEGRP Case 1 1 Grp size */
{ key[KNOTATION], ANOTEGRP}, /* Case 1 Position */
{ key[KCDATA], ACHARS }, /* Case 2 Always 0 */
{ key[KENTITY], AENTITY }, /* Case 3 Normal 1 */
{ key[KID], AID }, /* Case 4 Normal 1 */
{ key[KIDREF], AIDREF }, /* Case 5 Normal 1 */
{ key[KNAME], ANAME }, /* Case 6 Normal 1 */
{ key[KNMTOKEN], ANMTOKE }, /* Case 7 Normal 1 */
{ key[KNUMBER], ANUMBER }, /* Case 8 Normal 1 */
{ key[KNUTOKEN], ANUTOKE }, /* Case 9 Normal 1 */
{ key[KENTITIES], AENTITYS}, /* Case A Normal 1 */
{ key[KIDREFS], AIDREFS }, /* Case B # tokens */
{ key[KNAMES], ANAMES }, /* Case C # tokens */
{ key[KNMTOKENS], ANMTOKES}, /* Case D # tokens */
{ key[KNUMBERS], ANUMBERS}, /* Case E # tokens */
{ key[KNUTOKENS], ANUTOKES}, /* Case F # tokens */
{ NULL, 0 } /* Case 0 ERROR */
};
struct map enttab[] = { /* Entity declaration second parameter. */
{ key[KCDATA], ESC },
{ key[KSDATA], ESX },
{ key[KMS], ESMS},
{ key[KPI], ESI },
{ key[KSTARTTAG], ESS },
{ key[KENDTAG], ESE },
{ key[KMD], ESMD},
{ NULL, 0 }
};
struct map exttab[] = { /* Keywords for external identifier. */
{ key[KSYSTEM], EDSYSTEM },
{ key[KPUBLIC], EDPUBLIC },
{ NULL, 0 }
};
struct map extettab[] = { /* Keywords for external entity type. */
{ key[KCDATA], ESNCDATA },
{ key[KNDATA], ESNNDATA },
{ key[KSDATA], ESNSDATA },
{ key[KSUBDOC], ESNSUB },
{ NULL, 0 }
};
struct map funtab[] = { /* Function character reference names. */
{ key[KRE], RECHAR },
{ key[KRS], RSCHAR },
{ key[KSPACE], SPCCHAR },
/* We should use an extra table for added functions. */
{ (UNCH *)"TAB", TABCHAR },
{ NULL, 0 }
};
struct map mstab[] = { /* Marked section keywords. */
{ key[KTEMP], MSTEMP },
{ key[KINCLUDE], MSTEMP }, /* Treat INCLUDE like TEMP; both are NOPs.*/
{ key[KRCDATA], MSRCDATA},
{ key[KCDATA], MSCDATA },
{ key[KIGNORE], MSIGNORE},
{ NULL, 0 }
};
struct map pubcltab[] = { /* Names for public text class. */
{ (UNCH *)"CAPACITY", FPICAP },
{ (UNCH *)"CHARSET", FPICHARS},
{ (UNCH *)"DOCUMENT", FPIDOC },
{ (UNCH *)"DTD", FPIDTD },
{ (UNCH *)"ELEMENTS", FPIELEM },
{ (UNCH *)"ENTITIES", FPIENT },
{ (UNCH *)"LPD", FPILPD },
{ (UNCH *)"NONSGML", FPINON },
{ (UNCH *)"NOTATION", FPINOT },
{ (UNCH *)"SHORTREF", FPISHORT},
{ (UNCH *)"SUBDOC", FPISUB },
{ (UNCH *)"SYNTAX", FPISYN },
{ (UNCH *)"TEXT", FPITEXT },
{ NULL, 0 }
};
UNCH indefent[] = "\12#DEFAULT"; /* Internal name: default entity name. */
UNCH indefetd[] = "\12*DOCTYPE"; /* Internal name: default document type. */
UNCH indocent[] = "\12*SGMLDOC"; /* Internal name: SGML document entity. */
UNCH indocetd[] = "\6*DOC"; /* Internal name: document level etd. */
UNCH indtdent[] = "\11*DTDENT"; /* Internal name: external DTD entity. */
struct etd dumetd[3];
struct entity *dumpecb;
UNCH sgmlkey[] = "SGML";