开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > Oracle数据库 > 查看源码
ldhtml.c
资源名称：sqlweb-2.2.0.tar.gz　[点击查看]
上传用户：aidanglao
上传日期：2007-01-07
资源大小：69k
文件大小：17k
源码类别：

Oracle数据库

开发平台：

Unix_Linux

ldhtml.c：源码内容
  1. /* ldhtml.c - loads and HTML file
  2. /*
  3. /* Copyright (c) 1995-1999 Applied Information Technologies, Inc.
  4. /* All Rights Reserved.
  5. /*  
  6. /* Distributed uder the GNU General Public License which was included in
  7. /* the file named "LICENSE" in the package that you recieved.
  8. /* If not, write to:
  9. /* The Free Software Foundation, Inc.,
  10. /* 675 Mass Ave, Cambridge, MA 02139, USA.
  11.  */
  12. #include <stdlib.h>
  13. #include <stdio.h>
  14. #include <ctype.h>
  15. #include <stdarg.h>
  16. #include <string.h>
  18. /*
  19. /* Local Includes 
  20.  */
  21. #include "sqlweb.h"
  23. /*
  24. /* TOKENS
  25.  */
  26. typedef enum {
  27.      OpenTag_t
  28.     ,OpenEndTag_t
  29.     ,OpenComment_t
  30.     ,EndTag_t
  31.     ,AttAssign_t
  32.     ,String_t
  33.     ,EndOfFile_t
  34. } eToken_t;
  36. /*
  37. /* STATES
  38.  */
  39. typedef enum {
  40.      Init_s
  41.     ,InBetween_s
  42.     ,InTag_s
  43.     ,InAtt_s
  44.     ,InAttAssign_s
  45.     ,InValue_s
  46.     ,InContents_s
  47.     ,InComment_s
  48.     ,InEndTag_s
  49.     ,InEndTag2_s
  50.     ,Err_s
  51.     ,EndOfFile_s
  52. } eParseState_t;
  54. /*
  55. /* Global Variables, basically, in a STATE MACHINE everything
  56. /* is global!
  57.  */
  58. static char gsStringBuf[MAX_BUFSIZ]; /* String from "TOKENIZER" */
  59. static char *gpStringBuf; /* Current Location in memory-
  60. /* mapped file */
  61. static eParseState_t gsParseState =Init_s; /* The STATE */
  62. static eToken_t gtToken; /* The TOKEN */
  63. static TAG *gpTAG; /* The TAG */
  64. static SYMBOL *gpSym; /* The Attribute */
  65. static PI *gpPI; /* The PageItem */
  66. static PAGE *gpPAGE; /* The PAGE */
  67. static LIST *galPI[MAX_TAG_LEVELS]; /* The PageItem List Array */
  68. static PI   *gaPI[MAX_TAG_LEVELS]; /* The PI Array (context) */
  69. static int giLevel /* The Level */
  70.   ,giErr = 0 /* Error counter */
  71.   ,giLineNbr = 1 /* Line Counter */
  72. ;
  73. static eBoolean_t
  74.    gbFatal = eFalse /* Fatal Errors */
  75. ;
  77. static TAG gNULLTag = 
  78.     {"NULL" /* pTagName */
  79.     ,"Y" /* pTagEmptyInd */
  80.     ,"" /* pTagDesc */
  81.     ,"A" /* pTagAfterInd(HIDDEN) */
  82.     ,"" /* pTagLinkDesc */
  83.     };
  85. #define EXACT_TOKENS 7
  86. #define EXACT_STATES 12
  87. /* #define MAX_PARSE_ERRORS 25
  88.  */
  90. /*
  91. /* State Transition Functions
  92.  */
  93. eParseState_t  f011(),f012(),f013(),f014(),f015(),f016()
  94. ,f021(),f022(),f023(),f024(),f025(),f026()
  95. ,f031(),f032(),f033(),f034(),f035(),f036()
  96. ,f041(),f042(),f043(),f044(),f045(),f046()
  97. ,f051(),f052(),f053(),f054(),f055(),f056()
  98. ,f061(),f062(),f063(),f064(),f065(),f066()
  99. ,f071(),f072(),f073(),f074(),f075(),f076()
  100. ,f081(),f082(),f083(),f084(),f085(),f086()
  101. ,f091(),f092(),f093(),f094(),f095(),f096()
  102. ,f101(),f102(),f103(),f104(),f105(),f106()
  103. ,f111(),f112(),f113(),f114(),f115(),f116()
  104. ,f_eof()/* end of file */
  105. ;
  107. /*
  108. /* The STATE MACHINE!
  109.  */
  110. typedef eParseState_t (*PFS_t)(); /* Pointer to Function returning STATE */
  111. PFS_t gaTransTab [ EXACT_STATES ] [ EXACT_TOKENS ]  = {
  112. /*    Open-  Open-   Open-           Att-
  113. /*    Tag    EndTag  Comment  EndTag Assign    STRING EOF
  114. /*    ===    ======  =======  ====== ======    ====== ===
  115. /* Init_s */ f011  ,f012   ,f013    ,f014  ,f015     ,f016  ,f_eof
  116. /* InBetween_s */,f021  ,f022   ,f023    ,f024  ,f025     ,f026  ,f_eof
  117. /* InTag_s */,f031  ,f032   ,f033    ,f034  ,f035     ,f036  ,f_eof
  118. /* InAtt_s */,f041  ,f042   ,f043    ,f044  ,f045     ,f046  ,f_eof
  119. /* InAttAssign_s*/,f051  ,f052   ,f053    ,f054  ,f055     ,f056  ,f_eof
  120. /* InValue_s */,f061  ,f062   ,f063    ,f064  ,f065     ,f066  ,f_eof
  121. /* InContents_s */,f071  ,f072   ,f073    ,f074  ,f075     ,f076  ,f_eof
  122. /* InComment_s */,f081  ,f082   ,f083    ,f084  ,f085     ,f086  ,f_eof
  123. /* InEndTag_s */,f091  ,f092   ,f093    ,f094  ,f095     ,f096  ,f_eof
  124. /* InEndTag2_s */,f101  ,f102   ,f103    ,f104  ,f105     ,f106  ,f_eof
  125. /* Err_s */,f111  ,f112   ,f113    ,f114  ,f115     ,f116  ,f_eof
  126. };
  128. static eBoolean_t ParseStream();
  129. static eToken_t GetNextToken();
  130. static eBoolean_t mk_PI(char *pTagName, char *pPiContents);
  131. static void ParseErr(const char *pFmt, ...);
  133. /*
  134. /* Routines for processing input characters
  135.  */
  136. static int EatSpaces(int c);
  137. static int GetC();
  138. static void unGetC(int c);
  140. /*
  141. /*  Here we go.....
  142.  */
  144. /* The main interface routine.  This function takes the SQLweb HTML
  145. /* file and builds the in-memory PAGE / PI Tree that is represented
  146. /* by it.
  147.  */
  148. eBoolean_t
  149. LoadHTML(char *pFilename
  150. ,PAGE **pout_Page)
  151. {
  152.     eBoolean_t bParseRet;
  153.     PI PI; /* temporary PI for loading File Text */
  154.     char sBuf[BUFSIZ]; /* for dumping ERRStack */
  156.     RETeFalse2(LoadTEXT(pFilename,"HTML",&PI)
  157.      ,"LoadHTML Failed on %s"
  158.      ,pFilename
  159.      );
  161.     (*pout_Page) = (PAGE*)malloc(sizeof(PAGE));
  162.     if(!(*pout_Page)){
  163. ParseErr("malloc failed in parser");
  164. return(eFalse);
  165.     }
  166.     (void)memset((*pout_Page),0,sizeof(PAGE));
  168.     (*pout_Page)->lPI = galPI[0] = l_create("QUEUE"); /* Level 0:Page List*/
  169.     (*pout_Page)->pFileText = gpStringBuf = PI.pPiContents;
  171.     bParseRet = ParseStream();
  174.     /* This method, pop's off ALL Parse Errors
  175.     /* and if we are NOT COOKING the page it
  176.     /* displays the errors as HTML Comments
  177.     /* are silently ignored.....
  178.      */
  179.     while( MsgPop(sBuf) ) {
  180. if(ISCOOKED) {
  181.     DebugHTML(__FILE__,__LINE__,0,"%s",sBuf);
  182. } else {
  183.     fprintf(stderr,"%sn",sBuf);
  184. }
  185.     }
  186.     return(bParseRet);
  187. }
  189. /*
  190. /* The file parser.  runs "The State Machine"
  191.  */
  192. static eBoolean_t
  193. ParseStream()
  194. {
  195.     giErr=0; /* Global Error Count */
  196.     gbFatal=eFalse; /* Fatal Error Flag */
  197.     giLevel=0; /* Global PageItem Level */
  198.     giLineNbr=1; /* Line Number */
  199.     gsParseState = Init_s;
  200.     do {
  201. gtToken = GetNextToken();
  202. gsParseState = (gaTransTab[gsParseState][gtToken])();
  203.     } while( gsParseState != EndOfFile_s);
  205.     return( ISeTrue(gbFatal) ? eFalse : eTrue );
  206. }
  208. /*
  209. /* The Tokenizer
  210.  */
  211. static eToken_t
  212. GetNextToken()
  213. {
  214.     int c;
  215.     char *pBuf=gsStringBuf;
  216.     eBoolean_t bQuote=eFalse;
  218.     /*
  219.     /* Get the first character
  220.      */
  221.     c=GetC();
  223.     /*
  224.     /* Initialize the global STRING BUFFER 
  225.      */
  226.     *pBuf=0;
  228.     if(c==EOF){
  229. return(EndOfFile_t);
  230.     }
  232.     if(gsParseState==InAttAssign_s && c=='=') {
  233. return( AttAssign_t );
  234.     }
  236.     if(c == '<'){
  237. c=GetC();
  239. if(c=='!') {
  240.     return(OpenComment_t);
  241. } if(c=='/') {
  242.     return(OpenEndTag_t);
  243. } 
  244. unGetC(c);
  245. return(OpenTag_t);
  246.     }
  247.     if(c == '>') {
  248. return(EndTag_t);
  249.     }
  251.     for( ;c!=EOF && (pBuf-gsStringBuf)<sizeof(gsStringBuf);c=GetC()){
  252. /*
  253. /* Deal with Quotes (excluding InContents_s and InComments_s)
  254.  */
  255. if(c == '"'
  256.     && (  gsParseState==InAtt_s
  257. ||gsParseState==InAttAssign_s
  258. ||gsParseState==InValue_s))
  259. {
  260.      bQuote = ISeTrue(bQuote) ? eFalse :eTrue;
  261.     /* Toggle Quote Flag
  262.      */
  263.      continue; /* And eat it! */
  264. }
  266. if(c == '\' && ISeTrue(bQuote)) {
  267.     int c2 = GetC();
  268.     if(c2=='"'){
  269. *pBuf++ = (char) c2;
  270. continue;
  271.     }
  272.     unGetC(c2);
  273. }
  275. /* Deal with < and > 'tings
  276.  */
  277. if((c == '<' || c == '>')
  278.     && ISeFalse(bQuote))
  279. {
  280.     unGetC(c);
  281.     *pBuf = 0;
  282.     return(String_t);
  283. }
  285. /*
  286. /* The Attribute Assignment
  287.  */
  288. if(c == '=' && ISeFalse(bQuote)
  289.     && (gsParseState==InAtt_s || gsParseState==InAttAssign_s))
  290. {
  291.     unGetC(c);
  292.     *pBuf = 0;
  293.     return(String_t);
  294. }
  296. /*
  297. /* White space separator within <> pairs...
  298.  */
  299. if(isspace(c) 
  300.     && ISeFalse(bQuote)
  301.     &&( gsParseState==InTag_s
  302.      || gsParseState==InAtt_s
  303.      || gsParseState==InAttAssign_s
  304.      || gsParseState==InValue_s))
  305. {
  306.     *pBuf=0;
  307.     c=EatSpaces(c);
  308.     unGetC(c);
  309.     if( pBuf==gsStringBuf )
  310. continue;
  311.     return(String_t);
  312. }
  314. /* Fillin the Buffer....
  315.  */
  316. *pBuf++ = (char) c;
  317.     }
  318.     if( pBuf==gsStringBuf )
  319. return(EndOfFile_t);
  321.     *pBuf=0;
  322.     unGetC(c);
  323.     return(String_t);
  324. }
  326. /*
  327. /* Eat Spaces between TAGS
  328.  */
  329. static int
  330. EatSpaces(int c)
  331. {
  332.     do{ c=GetC();
  333.       } while(isspace(c));
  334.     return(c);
  335. }
  337. eParseState_t f_eof(){ return(EndOfFile_s); }
  339. /*
  340. /* The Init_s State
  341.  */
  342. eParseState_t f011(){return(InTag_s);}
  343. eParseState_t f012(){return(Init_s);}
  344. eParseState_t f013(){return(InComment_s);}
  345. eParseState_t f014(){return(Init_s);}
  346. eParseState_t f015(){return(Init_s);}
  347. eParseState_t f016(){return(Init_s);}
  349. /*
  350. /* The InBetween State
  351.  */
  352. eParseState_t f021(){return(InTag_s);}
  353. eParseState_t f022(){return(InEndTag_s);}
  354. eParseState_t f023(){return(InComment_s);}
  355. eParseState_t f024(){ParseErr("Encountered unmatched 'gt'");return(Err_s); }
  356. eParseState_t f025(){ParseErr("Internal error got '=' inBTWN");return(Err_s);}
  357. eParseState_t f026()
  358. {
  359. /*
  360. /*    int iWLen = strspn(gsStringBuf," tnr");
  361. /*    if(iWLen=iStrLen(gsStringBuf))
  362. /* return(InBetween_s);
  363.  */
  365.     if(ISeFalse(mk_PI("NULL",gsStringBuf))) {
  366. ParseErr("FATAL Error:mk_PI(NULL,%%s) failed");
  367. gbFatal=eTrue;
  368. return(Err_s);
  369.     }
  370.     return(InBetween_s);
  371. }
  373. /*
  374. /* The InTag State
  375.  */
  376. eParseState_t f031(){ParseErr("Got 'lt' within a tag")   ;return(Err_s);}
  377. eParseState_t f032(){ParseErr("Got 'lt+/' within a tag") ;return(Err_s);}
  378. eParseState_t f033(){ParseErr("Got 'lt+!' within a tag") ;return(Err_s);}
  379. eParseState_t f034(){ParseErr("Got 'lt' before tag name");return(Err_s);}
  380. eParseState_t f035(){ParseErr("Got '=' before tag name") ;return(Err_s);}
  381. eParseState_t f036()
  382. {
  383.     if(ISeFalse(mk_PI(gsStringBuf,0))) {
  384. ParseErr("ERR:InTag:mk_PI(%s,null) failed",gsStringBuf);
  385. gbFatal=eTrue;
  386. return(Err_s);
  387.     }
  388.     return(InAtt_s);
  389. }
  391. /*
  392. /* The InAtt State
  393.  */
  394. eParseState_t f041(){ParseErr("Got 'lt' within tag, "%s"",gpTAG->pTagName);
  395.     return(Err_s); 
  396.     }
  397. eParseState_t f042(){ParseErr("Got 'lt+/' within tag, "%s"",gpTAG->pTagName);
  398.     return(Err_s); 
  399.     }
  400. eParseState_t f043(){ParseErr("Got 'lt+!' within tag, "%s"",gpTAG->pTagName);
  401.     return(Err_s); 
  402.     }
  403. /*eParseState_t f044(){if(!isEmpty((gpPI))) return(InContents_s);
  404. /*      else   return(InBetween_s);
  405. /*     }
  406.  */
  407. eParseState_t f044(){if(!isEmpty((gpPI))) {
  408. /* giLevel++;
  409. /* galPI[giLevel] = gpPI->lPI;
  410.  */
  411. return(InBetween_s);
  412.     }
  413.      else return(InContents_s);
  414.     }
  415. eParseState_t f045(){ParseErr("Got '=' within tag, "%s"",gpTAG->pTagName);
  416.     return(Err_s); 
  417.     }
  418. eParseState_t f046()
  419. {
  420.     gpSym = NewPIA();
  421.     if(!gpSym){
  422. ParseErr("NewPIA Failed in parser");
  423. gbFatal=eTrue;
  424. return(Err_s);
  425.     }
  426.     /* (void)memset(gpSym,0,sizeof(SYMBOL));
  427.      */
  428.     gpSym->iType = PIA_SYMBOL;
  429.     gpSym->pName = DupBuf(gsStringBuf);
  430.     gpSym->pValue= 0;
  432.     ENQ(gpPI->lPIA,gpSym);
  433.     return(InAttAssign_s);
  434. }
  436. /*
  437. /* The InAttAssign State
  438.  */
  439. eParseState_t f051(){ParseErr("Got 'lt' within tag, "%s"",gpTAG->pTagName);
  440.     return(Err_s); 
  441.     }
  442. eParseState_t f052(){ParseErr("Got 'lt+/' within tag, "%s"",gpTAG->pTagName);
  443.     return(Err_s); 
  444.     }
  445. eParseState_t f053(){ParseErr("Got 'lt+!' within tag, "%s"",gpTAG->pTagName);
  446.     return(Err_s); 
  447.     }
  448. /* eParseState_t f054(){if(!isEmpty((gpPI))) return(InContents_s);
  449. /*       else   return(InBetween_s);
  450. /*      }
  451.  */
  452. eParseState_t f054(){if(!isEmpty((gpPI))) {
  453. /* giLevel++;
  454. /* galPI[giLevel] = gpPI->lPI;
  455.  */
  456. return(InBetween_s);
  457.     }
  458.      else return(InContents_s);
  459.     }
  460. eParseState_t f055(){return(InValue_s);}
  461. eParseState_t f056()
  462. {
  463.     gpSym = NewPIA();
  464.     if(!gpSym){
  465. ParseErr("NewPIA Failed to parser");
  466. gbFatal=eTrue;
  467. return(Err_s);
  468.     }
  469.     (void)memset(gpSym,0,sizeof(SYMBOL));
  470.     gpSym->iType = PIA_SYMBOL;
  471.     gpSym->pName = DupBuf(gsStringBuf);
  472.     gpSym->pValue= 0;
  474.     ENQ(gpPI->lPIA,gpSym);
  475.     return(InAttAssign_s);
  476. }
  478. /*
  479. /* The InValue State
  480.  */
  481. eParseState_t f061(){ParseErr("Got 'lt' within tag, "%s"" ,gpTAG->pTagName);
  482.     return(Err_s);
  483.     }
  484. eParseState_t f062(){ParseErr("Got 'lt+/' within tag, "%s"" ,gpTAG->pTagName);
  485.     return(Err_s);
  486.     }
  487. eParseState_t f063(){ParseErr("Got 'lt+!' within tag, "%s"" ,gpTAG->pTagName);
  488.     return(Err_s);
  489.     }
  490. eParseState_t f064(){ParseErr("Got 'gt' within attribute assign of tag, "%s""
  491.     ,gpTAG->pTagName);
  492.     return(Err_s);
  493.     }
  494. eParseState_t f065(){ParseErr("Got '= =' within tag, "%s"" ,gpTAG->pTagName);
  495.     return(Err_s);
  496.     }
  497. eParseState_t f066(){
  498.     gpSym->pValue = DupBuf(gsStringBuf);
  499.     return(InAtt_s);
  500.     }
  502. /*
  503. /* The InContents State
  504.  */
  505. eParseState_t f071(){return(InTag_s); }
  506. eParseState_t f072(){return(InEndTag_s); }
  507. eParseState_t f073(){return(InComment_s); }
  508. eParseState_t f074(){ParseErr("Got 'gt' after tag, "%s"",gpTAG->pTagName);
  509.     return(Err_s);
  510.     }
  511. eParseState_t f075(){ParseErr("Got '=' after tag, "%s"",gpTAG->pTagName);
  512.     return(Err_s);
  513.     }
  514. eParseState_t f076(){
  515.     gpPI->pPiContents = DupBuf(gsStringBuf);
  516.     return(InBetween_s); 
  517.     }
  519. /*
  520. /* The InComment State
  521.  */
  522. eParseState_t f081(){return(InComment_s); }
  523. eParseState_t f082(){return(InComment_s); }
  524. eParseState_t f083(){return(InComment_s); }
  525. eParseState_t f084(){return(InBetween_s); }
  526. eParseState_t f085(){return(InComment_s); }
  527. eParseState_t f086(){
  528.     int iSize = iStrLen(gsStringBuf);
  530.     gsStringBuf[iSize+3]=0; /* NULL */
  531.     gsStringBuf[iSize+2]='>'; /* Closing of Tag '>' */
  532.     while( --iSize>=0 ) /* The Contents */
  533. gsStringBuf[iSize+2] = gsStringBuf[iSize];
  534.     gsStringBuf[1] = '!'; /* Comment identifier */
  535.     gsStringBuf[0] = '<'; /* Starting TAG symbol */
  537.     if(*gsStringBuf && ISeFalse(mk_PI("!",gsStringBuf))) {
  538. ParseErr("ERR:InComment:Failed to make COMMENT");
  539. gbFatal=eTrue;
  540. return(Err_s);
  541.     }
  542.     return(InComment_s);
  543. } /* was InEndTag2 */
  545. /*
  546. /* The InEndTag State, just got '</' now looking for TAG-NAME
  547.  */
  548. eParseState_t f091(){ParseErr("missing tag name in trailer");return(Err_s); }
  549. eParseState_t f092(){ParseErr("missing tag name in trailer");return(Err_s); }
  550. eParseState_t f093(){ParseErr("missing tag name in trailer");return(Err_s); }
  551. eParseState_t f094(){ParseErr("missing tag name in trailer");return(Err_s); }
  552. eParseState_t f095(){ParseErr("missing tag name in trailer");return(Err_s); }
  553. eParseState_t f096()
  554. {
  555.     int iLevel = giLevel;
  556.     TAG *pTAG;
  558.     /* Make sure Tag was non-empty...
  559.      */
  560.     if(ISeFalse(GetTAGByName(gsStringBuf,&pTAG))) {
  561.     /*
  562.     /* May want to use NULL, here???
  563.      */
  564. MsgPush("Unknown tag, "%s"", gsStringBuf);
  565. return(Err_s);
  566.     }
  567.     if(is_casematch(pTAG->pTagEmptyInd,"Y")) {
  568. /* Empty TAG with end tag, WARNING...
  569.  */
  570. MsgPush("WARN(%s):Empty Tag w/END-TAG ignored, "%s" near line %d"
  571. ,pTAG->pTagEmptyInd
  572. ,gsStringBuf
  573. ,giLineNbr
  574.         ,gaPI[(giLevel>0)?giLevel-1:0]->pTagName
  575.         ,(giLevel>0)?giLevel-1:0
  576. );
  577. return(InEndTag2_s);
  578.     }
  579.     
  580.     /*
  581.     /* OK, Tag was non-empty, let's find it on the stack
  582.      */
  583.     while(--giLevel>=0
  584. && !is_casematch(gaPI[giLevel]->pTagName,gsStringBuf))
  585.     {
  586. /*
  587. DebugHTML(__FILE__,__LINE__,1
  588. ,"WARN(%s): Possible missing END-TAG, "%s" near line %d"
  589.        ,gaPI[giLevel]->pTag->pTagEmptyInd
  590.        ,gaPI[giLevel]->pTagName
  591.        ,giLineNbr
  592.        );
  593.  */
  594. MsgPush("WARN(%s): Possible missing END-TAG, "%s" near line %d"
  595.        ,gaPI[giLevel]->pTag->pTagEmptyInd
  596.        ,gaPI[giLevel]->pTagName
  597.        ,giLineNbr
  598.        );
  599.     }
  600.     if(giLevel<0) {
  601. MsgPush("Failed to find matching TAG for END-TAG, "%s" at line %d"
  602.        ,gsStringBuf
  603.        ,giLineNbr
  604.        );
  605. /* giLevel = iLevel-1;
  606.  */
  607. giLevel = iLevel; /* Couldn't find it; don't pop */
  608. return(Err_s);
  609.     }
  610.     return(InEndTag2_s);
  611. }
  613. /*
  614. /* The InEndTag2 State (looking for '>')
  615.  */
  616. eParseState_t f101(){ParseErr("Failed to find 'gt'");return(Err_s);}
  617. eParseState_t f102(){ParseErr("Failed to find 'gt'");return(Err_s);}
  618. eParseState_t f103(){ParseErr("Failed to find 'gt'");return(Err_s);}
  619. eParseState_t f104(){return(InBetween_s);}
  620. eParseState_t f105(){ParseErr("Failed to find 'gt'");return(Err_s);}
  621. eParseState_t f106(){ParseErr("Failed to find 'gt'");return(Err_s);}
  623. /*
  624. /* The inErr State
  625.  */
  626. eParseState_t f111(){return(ISeTrue(gbFatal)?EndOfFile_s:InTag_s);}
  627. eParseState_t f112(){return(ISeTrue(gbFatal)?EndOfFile_s:InEndTag_s);}
  628. eParseState_t f113(){return(ISeTrue(gbFatal)?EndOfFile_s:InComment_s);}
  629. eParseState_t f114(){return(ISeTrue(gbFatal)?EndOfFile_s:InBetween_s);}
  630. eParseState_t f115(){return(ISeTrue(gbFatal)?EndOfFile_s:Err_s);}
  631. eParseState_t f116(){return(ISeTrue(gbFatal)?EndOfFile_s:InBetween_s);}
  633. static eBoolean_t
  634. mk_PI(char *pTagName
  635.      ,char *pPiContents
  636.      )
  637. {
  638.     DebugHTML(__FILE__,__LINE__,4
  639. ,"mk_PI(%s,%s) line=%d"
  640. ,pTagName
  641. ,pPiContents?pPiContents:"**Null**"
  642. ,giLineNbr
  643. );
  644.     (gpPI) = NewPI();
  645.     if(!gpPI) {
  646. ParseErr("NewPI Failed in parser");
  647. gbFatal=eTrue;
  648. return(Err_s);
  649.     }
  651.     (gpPI)->iLevel = giLevel;
  652.     (gpPI)->pTagName = DupBuf(pTagName);
  654.     (gpPI)->pPage = gpPAGE;
  655.     (gpPI)->pTag = gpTAG;
  656.     (gpPI)->lPI = l_create("QUEUE");
  657.     (gpPI)->lPIA= l_create("INORDER");
  658.     (gpPI)->iLineNbr = giLineNbr;
  661.     if(is_casematch(pTagName,"NULL")){
  662. gpTAG = &gNULLTag;
  663.     } else {
  664. if(ISeFalse(GetTAGByName(pTagName,&gpTAG))) {
  665. /*
  666. /* May want to use NULL, here???
  667.  */
  668.     ParseErr("Unknown tag, "%s"", gsStringBuf);
  669.     return(eFalse);
  670. }
  671.     }
  672.     (gpPI)->pTag = gpTAG;
  673.     ENQ(galPI[giLevel], gpPI); /* Put PI in correct PI List */
  675.     gaPI[giLevel] = gpPI; /* Store pPI in PI Array */
  676.     gpPI->pPIContext = giLevel>0 ? gaPI[giLevel-1]: 0;
  677. /* Build the CONTEXT pointer */
  679.     (gpPI)->pPiContents = DupBuf(pPiContents);
  681.     if(!isEmpty((gpPI))) {
  682. giLevel++;
  683. galPI[giLevel] = gpPI->lPI;
  684.     }
  685.     return(eTrue);
  686. }
  688. /*
  689. /* Report a Parse Error
  690.  */
  691. static void
  692. ParseErr
  693.     (
  694.     const char *pFmt
  695.     ,...
  696.     )
  697. {
  698.     va_list pParms;
  699.     char sBuf[BUFSIZ];
  701.     /*
  702.     /* Build PrintF style buffer
  703.      */
  704.     va_start(pParms,pFmt);
  705.     vsprintf(sBuf,pFmt,pParms);
  707.     /* Add Line Number information
  708.      */
  709.     MsgPush("ParseErr line: %.4d: %s",giLineNbr,sBuf);
  710. }
  712. static int
  713. GetC()
  714. {
  715.     int c;
  716.     c= (int) *gpStringBuf++;
  717.     if(c=='n') giLineNbr++;
  718.     if(c=='') return(EOF);
  719.     return(c);
  720. }
  722. static void
  723. unGetC(int c)
  724. {
  725.     *(--gpStringBuf) = (char)c;
  726. }