1 /* Standard Generalized Markup Language Users' Group (SGMLUG) 2 SGML Parser Materials (ARCSGML 1.0) 3 4 (C) 1983-1988 Charles F. Goldfarb (assigned to IBM Corporation) 5 (C) 1988-1991 IBM Corporation 6 7 Licensed to the SGML Users' Group for distribution under the terms of 8 the following license: */ 9 10 char license[] = 11 "SGMLUG hereby grants to any user: (1) an irrevocable royalty-free,\n\ 12 worldwide, non-exclusive license to use, execute, reproduce, display,\n\ 13 perform and distribute copies of, and to prepare derivative works\n\ 14 based upon these materials; and (2) the right to authorize others to\n\ 15 do any of the foregoing.\n"; 16 17 #include "sgmlincl.h" 18 19 /* SGMLXTRN: Storage allocation and initialization for all public variables. 20 Exceptions: Constants lex????? and del????? are defined in 21 LEX?????.C modules; constants pcb????? are defined in PCB?????.c. 22 */ 23 int badresw = 0; /* 1=REF_ out of context; 0=valid. */ 24 int charmode = 0; /* >0=in #CHARS; 0=not. */ 25 int conactsw = 0; /* 1=return saved content action 0=get new one.*/ 26 int conrefsw = 0; /* 1=content reference att specified; 0=no. */ 27 int contersv = 0; /* Save contersw while processing pending REF. */ 28 int contersw = 0; /* 1=element or #CHARS out of context; 0=valid. */ 29 int datarc = 0; /* Return code for data: DAF_ or REF_. */ 30 int delmscsw = 0; /* 1=DELMSC must be read on return to es==0. */ 31 int didreq = 0; /* 1=required implied tag processed; 0=no. */ 32 int dostag = 0; /* 1=retry newetd instead of parsing; 0=parse. */ 33 int dtdsw = 0; /* DOCTYPE declaration found: 1=yes; 0=no. */ 34 int entdatsw = 0; /* 2=CDATA entity; 4=SDATA; 8=NDATA; 0=none. */ 35 int entpisw = 0; /* 4=PI entity occurred; 0=not. */ 36 int eodsw = 0; /* 1=eod found in error; 0=not yet. */ 37 int eofsw = 0; /* 1=eof found in body of document; 0=not yet. */ 38 int es = -1; /* Index of current source in stack. */ 39 int etagimct = 0; /* Implicitly ended elements left on stack. */ 40 int etagimsw = 0; /* 1=end-tag implied by other end-tag; 0=not. */ 41 int etagmin = MINNONE; /* Minim: NONE NULL NET DATA; implied by S/ETAG*/ 42 int etictr = 0; /* Number of "NET enabled" tags on stack. */ 43 int etisw = 0; /* 1=tag ended with eti; 0=did not. */ 44 int indtdsw = 0; /* Are we in the DTD? 1=yes; 0=no. */ 45 int mslevel = 0; /* Nesting level of marked sections. */ 46 int msplevel = 0; /* Nested MS levels subject to special parse. */ 47 int prologsw = 1; /* 1=in prolog; 0=not. */ 48 int pss = 0; /* SGMLACT: scbsgml stack level. */ 49 int sgmlsw = 0; /* SGML declaration found: 1=yes; 0=no. */ 50 int stagmin = MINNONE; /* Minimization: NONE, NULL tag, implied by STAG*/ 51 int tagctr = 0; /* Tag source chars read. */ 52 int ts = -1; /* Index of current tag in stack. */ 53 struct parse *propcb = &pcbpro; /* Current PCB for prolog parse. */ 54 int aentctr = 0; /* Number of ENTITY tokens in this att list. */ 55 int conact = 0; /* Return code from content parse. */ 56 int conrefsv = 0; /* Save conrefsw when doing implied start-tag.*/ 57 int dtdrefsw = 0; /* External DTD? 1=yes; 0=no. */ 58 int etiswsv = 0; /* Save etisw when processing implied start-tag.*/ 59 int grplvl = 0; /* Current level of nested grps in model. */ 60 int idrctr = 0; /* Number of IDREF tokens in this att list. */ 61 int mdessv = 0; /* ES level at start of markup declaration. */ 62 int notadn = 0; /* Position of NOTATION attribute in list. */ 63 int parmno = 0; /* Current markup declaration parameter number. */ 64 int pexsw = 0; /* 1=tag valid solely because of plus exception.*/ 65 int rcessv = 0; /* ES level at start of RCDATA content. */ 66 int tagdelsw = 0; /* 1=tag ended with delimiter; 0=no delimiter. */ 67 int tokencnt = 0; /* Number of tokens found in attribute value. */ 68 struct entity *ecbdeflt = 0; /* #DEFAULT ecb (NULL if no default entity). */ 69 struct etd *docetd = 0; /* The etd for the document as a whole. */ 70 struct etd *etagreal = 0; /* Actual or dummy etd that implied this tag. */ 71 struct etd *newetd = 0; /* The etd for a start- or end-tag recognized. */ 72 struct etd *nextetd = 0; /* ETD that must come next (only one choice). */ 73 struct etd *stagreal = 0; /* Actual or dummy etd that implied this tag. */ 74 struct parse *conpcb = 0; /* Current PCB for content parse. */ 75 UNCH *data = 0; /* Pointer to returned data in buffer. */ 76 UNCH *mdname = 0; /* Name of current markup declaration. */ 77 UNCH *ptcon = 0; /* Current pointer into tbuf. */ 78 UNCH *ptpro = 0; /* Current pointer into tbuf. */ 79 UNCH *rbufs = 0; /* DOS file read area: start position for read. */ 80 UNCH *subdcl = 0; /* Subject of markup declaration (e.g., GI). */ 81 int Tstart = 0; /* Save starting token for AND group testing. */ 82 UNS conradn = 0; /* 1=CONREF attribute in list (0=no). */ 83 UNS datalen = 0; /* Length of returned data in buffer. */ 84 UNS entlen = 0; /* Length of TAG or EXTERNAL entity text. */ 85 UNS idadn = 0; /* Number of ID attribute (0 if none). */ 86 UNS noteadn = 0; /* Number of NOTATION attribute (0 if none). */ 87 UNS reqadn = 0; /* Num of atts with REQUIRED default (0=none). */ 88 int grplongs; /* Number of longs for GRPCNT bitvector. */ 89 90 /* Variable arrays and structures. 91 */ 92 struct ad *al = 0; /* Current attribute list work area. */ 93 struct dcncb *dcntab[1]; /* List of data content notation names. */ 94 struct entity *etab[ENTHASH]; /* Entity hash table. */ 95 struct etd *etdtab[ETDHASH]; /* Element type definition hash table. */ 96 struct fpi fpidf; /* Fpi for #DEFAULT entity. */ 97 struct id *itab[IDHASH]; /* Unique identifier hash table. */ 98 struct etd **nmgrp = 0; /* Element name group */ 99 PDCB *nnmgrp = 0; /* Notation name group */ 100 struct restate *scbsgml = 0; /* SGMLACT: return action state stack. */ 101 struct source *scbs = 0; /* Stack of open sources ("SCB stack"). */ 102 struct srh *srhtab[1]; /* List of SHORTREF table headers. */ 103 struct sgmlstat ds; /* Document statistics. */ 104 struct switches sw; /* Parser control switches set by text proc. */ 105 struct tag *tags = 0; /* Stack of open elements ("tag stack"). */ 106 struct thdr *gbuf = 0; /* Buffer for creating group. */ 107 struct thdr prcon[3]; /* 0-2: Model for *DOC content. */ 108 struct thdr undechdr; /* 0:Default model hdr for undeclared content.*/ 109 UNCH *dtype = 0; /* Document type name. */ 110 UNCH *entbuf = 0; /* Buffer for entity reference name. */ 111 UNCH fce[2]; /* String form of FCE char. 112 (fce[1] must be EOS).*/ 113 /* Buffer for non-SGML character reference.*/ 114 UNCH nonchbuf[2] = { DELNONCH }; 115 UNCH *tbuf; /* Work area for tokenization. */ 116 UNCH *lbuf = 0; /* In tbuf: Literal parse area.*/ 117 UNCH *sysibuf = 0; /* Buffer for system identifiers. */ 118 UNCH *pubibuf = 0; /* Buffer for public identifiers. */ 119 UNCH *nmbuf = 0; /* Name buffer used by mdentity. */ 120 struct mpos *savedpos; 121 122 /* Constants. 123 */ 124 struct map dctab[] = { /* Keywords for declared content parameter.*/ 125 { key[KRCDATA], MRCDATA+MPHRASE }, 126 { key[KCDATA], MCDATA+MPHRASE }, 127 { key[KANY], MANY+MCHARS+MGI }, 128 { key[KEMPTY], MNONE+MPHRASE }, 129 { NULL, 0 } 130 }; 131 struct map deftab[] = { /* Default value keywords. */ 132 { key[KIMPLIED], DNULL }, 133 { key[KREQUIRED], DREQ }, 134 { key[KCURRENT], DCURR }, 135 { key[KCONREF], DCONR }, 136 { key[KFIXED], DFIXED}, 137 { NULL, 0} 138 }; 139 struct map dvtab[] = { /* Declared value: keywords and type codes.*/ 140 /* TYPE NUMBER */ 141 /* grp ANMTGRP Case 1 0 Grp size */ 142 /* grp member ANMTGRP Case 0 Position */ 143 /* grp ANOTEGRP Case 1 1 Grp size */ 144 { key[KNOTATION], ANOTEGRP}, /* Case 1 Position */ 145 { key[KCDATA], ACHARS }, /* Case 2 Always 0 */ 146 { key[KENTITY], AENTITY }, /* Case 3 Normal 1 */ 147 { key[KID], AID }, /* Case 4 Normal 1 */ 148 { key[KIDREF], AIDREF }, /* Case 5 Normal 1 */ 149 { key[KNAME], ANAME }, /* Case 6 Normal 1 */ 150 { key[KNMTOKEN], ANMTOKE }, /* Case 7 Normal 1 */ 151 { key[KNUMBER], ANUMBER }, /* Case 8 Normal 1 */ 152 { key[KNUTOKEN], ANUTOKE }, /* Case 9 Normal 1 */ 153 { key[KENTITIES], AENTITYS}, /* Case A Normal 1 */ 154 { key[KIDREFS], AIDREFS }, /* Case B # tokens */ 155 { key[KNAMES], ANAMES }, /* Case C # tokens */ 156 { key[KNMTOKENS], ANMTOKES}, /* Case D # tokens */ 157 { key[KNUMBERS], ANUMBERS}, /* Case E # tokens */ 158 { key[KNUTOKENS], ANUTOKES}, /* Case F # tokens */ 159 { NULL, 0 } /* Case 0 ERROR */ 160 }; 161 struct map enttab[] = { /* Entity declaration second parameter. */ 162 { key[KCDATA], ESC }, 163 { key[KSDATA], ESX }, 164 { key[KMS], ESMS}, 165 { key[KPI], ESI }, 166 { key[KSTARTTAG], ESS }, 167 { key[KENDTAG], ESE }, 168 { key[KMD], ESMD}, 169 { NULL, 0 } 170 }; 171 struct map exttab[] = { /* Keywords for external identifier. */ 172 { key[KSYSTEM], EDSYSTEM }, 173 { key[KPUBLIC], EDPUBLIC }, 174 { NULL, 0 } 175 }; 176 struct map extettab[] = { /* Keywords for external entity type. */ 177 { key[KCDATA], ESNCDATA }, 178 { key[KNDATA], ESNNDATA }, 179 { key[KSDATA], ESNSDATA }, 180 { key[KSUBDOC], ESNSUB }, 181 { NULL, 0 } 182 }; 183 struct map funtab[] = { /* Function character reference names. */ 184 { key[KRE], RECHAR }, 185 { key[KRS], RSCHAR }, 186 { key[KSPACE], SPCCHAR }, 187 /* We should use an extra table for added functions. */ 188 { (UNCH *)"TAB", TABCHAR }, 189 { NULL, 0 } 190 }; 191 struct map mstab[] = { /* Marked section keywords. */ 192 { key[KTEMP], MSTEMP }, 193 { key[KINCLUDE], MSTEMP }, /* Treat INCLUDE like TEMP; both are NOPs.*/ 194 { key[KRCDATA], MSRCDATA}, 195 { key[KCDATA], MSCDATA }, 196 { key[KIGNORE], MSIGNORE}, 197 { NULL, 0 } 198 }; 199 struct map pubcltab[] = { /* Names for public text class. */ 200 { (UNCH *)"CAPACITY", FPICAP }, 201 { (UNCH *)"CHARSET", FPICHARS}, 202 { (UNCH *)"DOCUMENT", FPIDOC }, 203 { (UNCH *)"DTD", FPIDTD }, 204 { (UNCH *)"ELEMENTS", FPIELEM }, 205 { (UNCH *)"ENTITIES", FPIENT }, 206 { (UNCH *)"LPD", FPILPD }, 207 { (UNCH *)"NONSGML", FPINON }, 208 { (UNCH *)"NOTATION", FPINOT }, 209 { (UNCH *)"SHORTREF", FPISHORT}, 210 { (UNCH *)"SUBDOC", FPISUB }, 211 { (UNCH *)"SYNTAX", FPISYN }, 212 { (UNCH *)"TEXT", FPITEXT }, 213 { NULL, 0 } 214 }; 215 UNCH indefent[] = "\12#DEFAULT"; /* Internal name: default entity name. */ 216 UNCH indefetd[] = "\12*DOCTYPE"; /* Internal name: default document type. */ 217 UNCH indocent[] = "\12*SGMLDOC"; /* Internal name: SGML document entity. */ 218 UNCH indocetd[] = "\6*DOC"; /* Internal name: document level etd. */ 219 UNCH indtdent[] = "\11*DTDENT"; /* Internal name: external DTD entity. */ 220 221 struct etd dumetd[3]; 222 struct entity *dumpecb; 223 UNCH sgmlkey[] = "SGML"; 224