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

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

Oracle数据库

开发平台：

Unix_Linux

swoutput.c：源码内容
  1. /* swoutput.c - Output routines for SQLweb
  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 <stdio.h>
  13. #include <stdlib.h>
  14. /* #include <sys/types.h>
  15.  */
  16. #include <ctype.h>
  17. #include <string.h>
  18. #include "sqlweb.h"
  19. #include "userexit.h"
  21. /*
  22. /* Internal Functions....
  23.  */
  24. static eBoolean_t LoadPageList(LIST *lPageGenNbrList);
  25. static eBoolean_t CookPage(PAGE *pPage);
  26. static eBoolean_t CookPIA(SYMBOL *pPIA);
  27. static eBoolean_t OutputPage(PAGE *pPage);
  28. static eBoolean_t OutputPI(PI *pPI);
  29. static eBoolean_t OutputPIA(SYMBOL *pPIA);
  30. static eBoolean_t GetPIFieldNameREF(PI *pPI,char **pOutFieldName);
  31. static eBoolean_t GetPIValue(PI *pPI, char *pOutValue);
  32. static eBoolean_t GetPIValueREF(PI *pPI, char **pOutValue);
  33. static eBoolean_t GetPITagType(PI *pPI, char **pOutType);
  34. static eBoolean_t SetPIValue(PI *pPI, char *pValue);
  35. static eBoolean_t SetPIAValue(PI *pPI,char *pName, char *pOutValue);
  36. static void RawOutputHTML(char *p);
  38. static eBoolean_t DumpPI(PI *pPI);
  39. static eBoolean_t DumpPIA(SYMBOL *pPIA);
  42. /*
  43. /* Global Variables used by all modules
  44. /* but owned by this one!
  45.  */
  46. eBoolean_t gbCookFlag;
  47. PAGE *gpPage;
  49. /*
  50. /* Global (local to this file) Variables...
  51.  */
  52. static LIST *galPI[MAX_TAG_LEVELS]
  53.     /* Array for storing the current PI List for
  54.     /*  each scope level
  55.      */
  56.     ;
  57. static PI   *gaPI[MAX_TAG_LEVELS]
  58.     ;
  59. eBoolean_t gbBufferOutput = eFalse;
  61. eBoolean_t
  62. swoutput(PAGE *pPage)
  63. {
  64.     DebugHTML(__FILE__,__LINE__,2,"swoutput(%x,%s)"
  65. ,pPage
  66. ,ISCOOKED ? "TRUE":"FALSE");
  67.     /*
  68.     /* Create the Global PAGE, if necessary,
  69.      */
  70.     /* Use the PAGE passed in
  71.      */
  72.     gpPage = pPage;
  74.     /*
  75.     /* Cook the raw page into something juicy...
  76.      */
  77.     if(ISCOOKED) {
  78. RETeFalse(CookPage(gpPage)
  79.  ,"Failed to expand SQLweb Page"
  80.  );
  81. if(ISeTrue(gbBufferOutput)) {
  82.     /* Time for desert....
  83.      */
  84.     if(giParseLevel==3) {
  85. DumpPage(gpPage);
  86. return(eTrue);
  87.     }
  88.     RETeFalse(OutputPage(gpPage),"OutputPage Failed");
  89. }
  90.     } else {
  91. RETeFalse(OutputPage(gpPage),"OutputPage Failed");
  92.     }
  93.     /* OutputHTML("n");
  94.      */
  95.     FlushHTMLBuf();
  96.     return(eTrue);
  97. }
  99. static eBoolean_t
  100. OutputPage(PAGE *pPage)
  101. {
  102.     DebugHTML(__FILE__,__LINE__,3,"OutputPage(%x)",pPage);
  103.     if(!pPage)
  104. return(eTrue);
  105.     PrintHTMLHeader("text/html");
  106.     return( l_scan(pPage->lPI,(PFI)OutputPI) );
  107. }
  109. static eBoolean_t
  110. OutputPI(PI *pPI)
  111. {
  112.     /* output tag
  113.      */
  114.     if(!pPI)
  115. return(eTrue);
  117.     DebugHTML(__FILE__,__LINE__,6,"OutputPI(%s)",pPI->pTagName);
  119.     if(isNotHidden(pPI)) {
  120. OutputHTML("<%s",pPI->pTagName);
  121. /*
  122. /* output TagAttributes
  123.  */
  124. RETeFalse(l_scan(pPI->lPIA,(PFI)OutputPIA)
  125.  ,"l_scan(PIA) OutputPIA Failed"
  126.  );
  127. /* output end-tag
  128.  */
  129. OutputHTML(">");
  130.     }
  131.     /* output (normal) contents
  132.      */
  133.     if(pPI && pPI->pPiContents && *(pPI->pPiContents)) {
  134.         RawOutputHTML(pPI->pPiContents);
  135.     }
  136.     /* output lPI
  137.      */
  138.     RETeFalse( l_scan(pPI->lPI,(PFI)OutputPI)
  139.      ,"Recursive call failed"
  140.      );
  141.     /*
  142.     /* Output Trailer
  143.      */
  144.     if(!isEmpty(pPI) && isNotHidden(pPI)) {
  145. OutputHTML("</%s>",pPI->pTagName);
  146.     }
  148.     FlushHTMLBuf();
  149.     return(eTrue);
  150. }
  152. static eBoolean_t
  153. CookPIA(SYMBOL *pPIA)
  154. {
  155.     char *pBuf ;
  156.     if(!pPIA)
  157. return(eTrue);
  159.     DebugHTML(__FILE__,__LINE__,5,"CookPIA(%s,%x)",pPIA->pName,pPIA->pValue);
  161.     /* Always expand the NAME= part of each attrib
  162.      */
  163.     RETeFalse2(ExpandString(pPIA->pName,&pBuf)
  164.       ,"ExpandString(%s) Failed"
  165.       ,pPIA->pName
  166.       );
  167.     FreeBuf(pPIA->pName);
  168.     pPIA->pName = pBuf;
  170.     /*
  171.     /* Only expand VALUE part when it's NOT EXPR= or SQL=
  172.     /*  ... because the parser will deal with the : variables
  173.      */
  174.     if( !(is_casematch(pBuf,"EXPR") || is_casematch(pBuf,"SQL"))) {
  175. RETeFalse2(ExpandString(pPIA->pValue,&pBuf)
  176.   ,"ExpandString(%s) Failed"
  177.   ,pPIA->pValue
  178.   );
  179. FreeBuf(pPIA->pValue);
  180. pPIA->pValue = pBuf;
  181.     } else {
  182.     /*
  183.     /* Only remove charcodes from SQL and EXPR attributes
  184.     /*  ... because the parser doesn't deal with the &gt; syntax
  185.      */
  186. RemoveCharCodes(pBuf);
  187.     }
  188.     return(eTrue);
  189. }
  191. static eBoolean_t
  192. OutputPIA(SYMBOL *pPIA)
  193. {
  194.     return ( iPrintHTMLSymbol(pPIA) );
  195. }
  197. static eBoolean_t
  198. CookPage(PAGE *pPage)
  199. {
  200.     if(!pPage)
  201. return(eTrue);
  202.     DebugHTML(__FILE__,__LINE__,3,"CookPage(%x)",pPage);
  203.     return( l_scan(pPage->lPI,(PFI)CookPI) );
  204. }
  206. eBoolean_t
  207. CookPI(PI *pPI)
  208. {
  209.     char *pFieldName
  210.      ,*pValue
  211. ;
  212.     TAG_HANDLE *pTagHandle;
  213.     eBoolean_t bExpr = eTrue;
  215.     if(pPI == NULL){
  216. MsgPush("Internal error: CookPI received NULL");
  217. return(eTrue);
  218. /* return(eFalse);
  219.  */
  220.     }
  221.     DebugHTML(__FILE__,__LINE__,5,"CookPI(%x):%s (line %d)"
  222.      ,pPI
  223.      ,pPI->pTagName
  224.      ,pPI->iLineNbr
  225.      );
  227.     for(pTagHandle= &gaTagHandlers[0]; pTagHandle->pTagName;pTagHandle++){
  228. if(is_casematch(pTagHandle->pTagName,pPI->pTagName)){
  229.     char *pBuf;
  230.     DebugHTML(__FILE__,__LINE__,2,"Handling:%s (line %d)"
  231.      ,pPI->pTagName
  232.      ,pPI->iLineNbr
  233.      );
  234.     /*
  235.     /* AUTOFAIL should be set for backward compatability...
  236.     /* May be set in the "INI" file or in "old" pages
  237.      */
  238.     if(ISeTrue(GetSymbolValueREF("SQLWEB_AUTOFAIL",&pBuf))
  239. && is_casematch("TRUE",pBuf))
  240.     {
  241. RETeFalse3((pTagHandle->fHandler)(pPI,&bExpr)
  242.   ,"Tag Handler Failed:%s (line %d)"
  243.   ,pPI->pTagName
  244.   ,pPI->iLineNbr
  245.   );
  246.     } else if(ISeFalse((pTagHandle->fHandler)(pPI,&bExpr))) {
  247. DebugHTML(__FILE__,__LINE__,0
  248. ,"ERROR: Tag Handler failed on %s (line %d)"
  249. ,pPI->pTagName
  250. ,pPI->iLineNbr
  251. );
  252. SELSym("SQLWEB_CODE","1");
  253. SELSym("SQLWEB_MESSAGE","Handler Failed");
  254. /* return(eFalse);
  255.  */
  256. return(eTrue);
  257.     }
  258.     SELSym("SQLWEB_CODE","0");
  259.     SELSym("SQLWEB_MESSAGE","Normal Successful Completion");
  261.     /* return(eTrue);
  262.      */
  263. }
  264.     }
  265.     if(ISeFalse(bExpr)){
  266. /*
  267.  */
  268. DebugHTML(__FILE__,__LINE__,3 ,"fHandler says FALSE:otta here!");
  269. /* ************************************************************
  270. /* ************************************************************
  271. /* BTW, don't reference pPI now, it has been FREE'd by fHandler
  272.  */
  274. /* if(ISeTrue(gbBufferOutput)) {
  275. /*     pPI->lPI = l_create("QUEUE"); /* Clobber list */
  276. /*     pPI->pPiContents = DupBuf(0); /* Clobber contents */
  277. /* } else {
  278. /*     FreePI(pPI);
  279. /* }
  280.  */
  281. return(eTrue);
  282.     }
  284.     /*
  285.     /* Expand Contents
  286.      */
  287.     RETeFalse2(ExpandContents(pPI)
  288.              ,"ExpandContents(%s) Failed"
  289.              ,pPI->pPiContents
  290.              );
  292.     /*
  293.     /* Expand Attributes....
  294.      */
  295.     RETeFalse(l_scan(pPI->lPIA,(PFI)CookPIA)
  296.      ,"l_scan(PIA) CookPIA Failed"
  297.      );
  298.     /*
  299.     /* Process (INPUT/TEXTAREA)/OPTION Tags
  300.      */
  301.     if((( is_casematch(pPI->pTagName,"INPUT")
  302. ||is_casematch(pPI->pTagName,"TEXTAREA"))
  303.    && (ISeTrue(GetPIFieldNameREF(pPI,&pFieldName)) && *pFieldName)
  304.    && ISeTrue(GetSymbolValueREF(pFieldName,&pValue)))
  305. ||(is_casematch(pPI->pTagName,"OPTION")
  306.    && (ISeTrue(GetPIFieldNameREF(pPI,&pFieldName)) && *pFieldName)
  307.    && ISeTrue(GetPIValueREF(pPI,&pValue))
  308.    && ISeTrue(IsSymbolValue(pFieldName,pValue))))
  309.     {
  310. if(ISeTrue(SetPIValue(pPI,pValue))) {
  311.     DebugHTML(__FILE__,__LINE__,5,"CookPI:SetPIValue(%s)OK",pFieldName);
  312. } else {
  313.     DebugHTML(__FILE__,__LINE__,1
  314.      ,"CookPI:W:SetPIValue(%s) Failed"
  315.      ,pFieldName
  316.      );
  317. }
  318.     }
  319.     if(ISeTrue(gbBufferOutput)){
  320. return(l_scan(pPI->lPI,(PFI)CookPI));
  321.     }
  323.     /********************************************
  324.     /* From here on we are only Non-Buffered Output ...
  325.      */
  327.     /*
  328.     /* Output <TAG and Attributes>
  329.      */
  330.     if(isNotHidden(pPI)) {
  331. OutputHTML("<%s",pPI->pTagName);
  332. RETeFalse(l_scan(pPI->lPIA,(PFI)OutputPIA)
  333.  ,"l_scan(PIA) OutputPIA Failed"
  334.  );
  335. OutputHTML(">");
  336.     }
  337.     /*
  338.     /* Output TAG Contents
  339.      */
  340.     if(pPI && pPI->pPiContents && *(pPI->pPiContents))
  341. RawOutputHTML(pPI->pPiContents);
  343.     /*
  344.     /* COOK and Output Subordinate TAGS, the children
  345.      */
  346.     RETeFalse(l_scan(pPI->lPI,(PFI)CookPI)
  347.      ,"l_scan(pPI->lPI,CookPI) Failed"
  348.      );
  350.     /*
  351.     /* Output the ENDING TAG </TAG>
  352.      */
  353.     if(!isEmpty(pPI) && isNotHidden(pPI)) {
  354. OutputHTML("</%s>",pPI->pTagName);
  355.     }
  356. /*
  357.  */
  358.     FreePI(pPI);
  360.     /* Don't forget to Flush!
  361.      */
  362.     FlushHTMLBuf();
  363.     return(eTrue);
  364. }
  366. static eBoolean_t
  367. GetPIFieldNameREF
  368.     (PI *pPI
  369.     ,char **pOutFieldName
  370.     )
  371. {
  372.     DebugHTML(__FILE__,__LINE__,6,"GetPIFieldNameREF(%x,%s,?)",pPI,pPI->pTagName);
  373.     if(is_casematch(pPI->pTagName,"INPUT")
  374.        || is_casematch(pPI->pTagName,"TEXTAREA")
  375.        || is_casematch(pPI->pTagName,"SELECT"))
  376.     {
  377. if(ISeTrue(GetPIAValueREF(pPI,"NAME",pOutFieldName))) {
  378.     return(eTrue);
  379. }
  380.     }
  381.     else if(is_casematch(pPI->pTagName,"OPTION")){
  382. /* For options, since they are nested below SELECTs must
  383. /* use the PARENT's i.e. pPIContext' Attirb list to determine
  384. /* the NAME
  385. /* DebugHTML(__FILE__,__LINE__,5,"dump Core!(%x,%x)"
  386. /*  ,pPI
  387. /*  ,pPI->pPIContext);
  388. /* FlushHTMLBuf();
  389.  */
  390. PI *pPI2;
  391. for(pPI2=pPI->pPIContext;pPI2;pPI2=pPI2->pPIContext) {
  392.     if(ISeTrue(GetPIAValueREF(pPI2,"NAME",pOutFieldName))){
  393. return(eTrue);
  394.     }
  395. }
  396.     }
  397.     *pOutFieldName=0;
  398.     return(eFalse);
  399. }
  401. /* static eBoolean_t
  402. /* GetPIValue
  403. /*     (PI *pPI
  404. /*     ,char *pOutValue
  405. /*     )
  406. /* {
  407. /*     /* Basically, look for a VALUE attribute
  408. /*      */
  409. /*     DebugHTML(__FILE__,__LINE__,5,"GetPIValue(%s)",pPI->pTagName);
  410. /*     if(ISeTrue(GetPIAValue(pPI,"VALUE",pOutValue))){
  411. /*  /* Got IT! */
  412. /*  return(eTrue);
  413. /*     }
  414. /*     /* Only OPTIONS use the Contents as the backup value holder...
  415. /*      */
  416. /*     if(is_casematch(pPI->pTagName,"OPTION") && pPI->pPiContents){
  417. /*  DebugHTML(__FILE__,__LINE__,6,"GetPIValue(%s)",pPI->pPiContents);
  418. /*  strcpy(pOutValue,pPI->pPiContents);
  419. /*  return(eTrue);
  420. /*     }
  421. /*     
  422. /*     /*
  423. /*     /* Couln't find the value...
  424. /*      */
  425. /*     *pOutValue=0;
  426. /*     return(eFalse);
  427. /* }
  428. /* */
  429. static eBoolean_t
  430. GetPIValueREF
  431.     (PI *pPI
  432.     ,char **pOutValue
  433.     )
  434. {
  435.     /* Basically, look for a VALUE attribute
  436.      */
  437.     DebugHTML(__FILE__,__LINE__,5,"GetPIValueREF(%s)",pPI->pTagName);
  438.     if(ISeTrue(GetPIAValueREF(pPI,"VALUE",pOutValue))){
  439. /* Got IT! */
  440. return(eTrue);
  441.     }
  442.     /* Only OPTIONS use the Contents as the backup value holder...
  443.      */
  444.     if(is_casematch(pPI->pTagName,"OPTION") && pPI->pPiContents){
  445. DebugHTML(__FILE__,__LINE__,6,"GetPIValueREF(%s)",pPI->pPiContents);
  446. (*pOutValue)=pPI->pPiContents;
  447. return(eTrue);
  448.     }
  449.     
  450.     /*
  451.     /* Couln't find the value...
  452.      */
  453.     (*pOutValue)=DupBuf(0);
  454.     return(eFalse);
  455. }
  457. static eBoolean_t
  458. GetPITagType
  459.     (PI *pPI
  460.     ,char **pOutType
  461.     )
  462. {
  463.     if(ISeTrue(GetPIAValueREF(pPI,"TYPE",pOutType))) {
  464. /* Got it! */
  465. return(eTrue);
  466.     }
  467.     /* Default is TEXT
  468.      */
  469.     (*pOutType) = "TEXT";
  470.     return(eTrue);
  471. }
  473. static eBoolean_t
  474. SetPIValue
  475.     (PI *pPI
  476.     ,char *pValue
  477.     )
  478. {
  479.     char *pType
  480. ,*pValue2
  481. ;
  483.     DebugHTML(__FILE__,__LINE__,5,"SetPIValue(%s,%s)",pPI->pTagName,pValue);
  485.     if(is_casematch(pPI->pTagName,"INPUT")) {
  486. RETeFalse(GetPITagType(pPI,&pType)
  487.  ,"GetPITagType failed"
  488.  );
  489. /* TYPE in(TEXT,PASSWORD)
  490. /* set VALUE Attribute to pValue
  491.  */
  492. if(    is_casematch(pType,"TEXT")
  493.     || is_casematch(pType,"PASSWORD")
  494.     || is_casematch(pType,"HIDDEN"))
  495. {
  496.     if(!pValue || !(*pValue)){
  497. /* Delete VALUE Attrib, since it's value is NULL
  498. /* If it works, it works!
  499.  */
  500. SYMBOL *p;
  501. p=l_delete(pPI->lPIA,l_find,iCmpSymbolpName,"VALUE");
  502. if(p){
  503.     FreePIA(p);
  504. }
  505.     } else {
  506. DebugHTML(__FILE__,__LINE__,5,"SettingV(%s,%s)",pType,pValue);
  507. return( SetPIAValue(pPI,"VALUE",pValue));
  508.     }
  509. }
  510. /* TYPE in(CHECKBOX,RADIO)
  511. /* Set CHECKED Attribute
  512.  */
  513. if(is_casematch(pType,"RADIO") || is_casematch(pType,"CHECKBOX")){
  514.     if(ISeFalse(GetPIValueREF(pPI,&pValue2))){
  515. pValue= "on"; /* Value is set to "on" when
  516.      /* there is no VALUE attrib */
  517.     }
  518.     /*
  519.     /* On a MATCH, SET/Create the CHECKED ATTRIBUTE
  520.      */
  521.     if(is_match(pValue2,pValue)){
  522. return( SetPIAValue(pPI,"CHECKED",""));
  523.     /*
  524.     /* No Match -- make sure the CHECKED ATTRIBUTE is Gone!
  525.      */
  526.     } else {
  527. SYMBOL *p;
  528. p=l_delete(pPI->lPIA,l_find,iCmpSymbolpName,"CHECKED");
  529. if(p) {
  530.     FreePIA(p);
  531. }
  532.     }
  533.     return(eTrue);
  534. }
  535.     }
  536.     if(is_casematch(pPI->pTagName,"TEXTAREA")){
  537. while(*pValue == 'n') ++pValue;
  538. /* Mosaic tends to stick leading 'n' is there
  539.  */
  540. FreeBuf(pPI->pPiContents);
  541. pPI->pPiContents = DupBuf(pValue);
  542. return(eTrue);
  543. /* strcpy(pOutValue,pPI->pPiContents);
  544.  */
  545.     }
  546.     /*
  547.     /* OPTION TAG that has a VALUE
  548.      */
  549.     if(is_casematch(pPI->pTagName,"OPTION")
  550. && ISeTrue(GetPIValueREF(pPI,&pValue2)))
  551.     {
  552. /*
  553. /* IF Symbol VALUE Matches this OPTION
  554. /* Set the SELECTED ATTRIBUTE
  555.  */
  556. if( is_match(pValue2,pValue)) {
  557.     if(ISeFalse( SetPIAValue(pPI,"SELECTED",""))){
  558. MsgPush("SetPIAValue failed on OPTION");
  559. return(eFalse);
  560.     } else {
  561. DebugHTML(__FILE__,__LINE__,5,"Set OPTION:%s",pValue);
  562. return(eTrue);
  563.     }
  564. /*
  565. /* IF the VALUES Don't match make sure the 
  566. /* SELECTED ATTRIBUTE is DELETED
  567.  */
  568. } else {
  569.     SYMBOL *p;
  570.     /* If they don't match, erase the SELECTED attribute 
  571.      */
  572.     p=l_delete(pPI->lPIA,l_find,iCmpSymbolpName,"SELECTED");
  573.     if(p){
  574. FreePIA(p);
  575.     }
  576. }
  577.     }
  578.     return(eTrue);
  579. }
  581. /* eBoolean_t
  582. /* GetPIAValue
  583. /*     (PI *pPI
  584. /*     ,char *pName
  585. /*     ,char *pOutValue
  586. /*     )
  587. /* {
  588. /*     SYMBOL *pSym;
  589. /*     DebugHTML(__FILE__,__LINE__,5,"GetPIAValue(%x,%s,...)",pPI,pName);
  590. /* 
  591. /*     if(!pPI) {
  592. /*  *pOutValue=0;
  593. /*  return(eFalse);
  594. /*     }
  595. /* 
  596. /*     pSym=l_find(pPI->lPIA,iCmpSymbolpName,pName);
  597. /*     if(!pSym){
  598. /*  *pOutValue=0;
  599. /*  return(eFalse);
  600. /*     }
  601. /*     strcpy(pOutValue,pSym->pValue);
  602. /*     return(eTrue);
  603. /* }
  604.  */
  605. eBoolean_t
  606. GetPIAValueREF
  607.     (PI *pPI
  608.     ,char *pName
  609.     ,char **pOutValue
  610.     )
  611. {
  612.     SYMBOL *pSym;
  613.     DebugHTML(__FILE__,__LINE__,5,"GetPIAValueREF(%x,%s,...)",pPI,pName);
  615.     if(!pPI) {
  616. (*pOutValue)=DupBuf(0);
  617. return(eFalse);
  618.     }
  620.     pSym=l_find(pPI->lPIA,iCmpSymbolpName,pName);
  621.     if(!pSym){
  622. (*pOutValue)=DupBuf(0);
  623. return(eFalse);
  624.     }
  625.     (*pOutValue) = pSym->pValue;
  626.     return(eTrue);
  627. }
  629. static eBoolean_t
  630. SetPIAValue
  631.     (PI *pPI
  632.     ,char *pName
  633.     ,char *pValue
  634.     )
  635. {
  636.     SYMBOL *pSym;
  638.     DebugHTML(__FILE__,__LINE__,6,"setPIAValue(%s,%s)",pName,pValue);
  640.     pSym=l_find(pPI->lPIA,iCmpSymbolpName,pName);
  641.     if(!pSym){
  642. pSym = NewPIA();
  643. if(!pSym){
  644.     MsgPush("NewPIA failed");
  645.     return(eFalse);
  646. }
  647. /* (void)memset((pSym),0,sizeof(SYMBOL));
  648.  */
  649. pSym->iType=0; /* Not used, best init it, though */
  650. pSym->pName=DupBuf(pName);
  651. pSym->pValue=DupBuf(pValue);
  652. return( ENQ(pPI->lPIA,pSym) );
  653.     }
  654.     /* toss origional value
  655.      */
  656.     FreeBuf(pSym->pValue);
  657.     pSym->pValue = DupBuf(pValue);
  658.     return(eTrue);
  659. }
  661. static void
  662. RawOutputHTML(char *p)
  663. {
  664.     FlushHTMLBuf();
  665.     fprintf(stdout,"%s",p);
  666.     fflush (stdout);
  667.     return;
  668. }
  670. eBoolean_t
  671. DumpPage(PAGE *pPage)
  672. {
  673.     eBoolean_t bRet;
  674.     bRet=l_scan(pPage->lPI,(PFI)DumpPI);
  675.     fprintf(stdout,"n");
  676.     return(bRet);
  677. }
  678. static eBoolean_t
  679. DumpPI(PI *pPI)
  680. {
  681.     if(!pPI)
  682. return(eTrue);
  684.     fprintf(stdout,"n%*s%s (line=%d) (depth=%d) "
  685.    ,(pPI->iLevel)*2 ," "
  686.    ,pPI->pTagName
  687.    ,pPI->iLineNbr
  688.    ,pPI->iLevel
  689.    );
  690.     (void)l_scan(pPI->lPIA,(PFI)DumpPIA);
  692.     if(l_size(pPI->lPI)>0) {
  693. RETeFalse( l_scan(pPI->lPI,(PFI)DumpPI)
  694.  ,"Recursive call failed"
  695.  );
  697. fprintf(stdout,"n%*s/%s"
  698. ,(pPI->iLevel)*2 ," "
  699. ,pPI->pTagName
  700. );
  701.     }
  702.     return(eTrue);
  703. }
  704. static eBoolean_t
  705. DumpPIA(SYMBOL *pPIA)
  706. {
  707.     char sBuf[BUFSIZ];
  709.     (void)memset(sBuf,0,BUFSIZ);
  710.     if(pPIA->pValue)
  711. strncpy(sBuf,pPIA->pValue,10);
  712.     fprintf(stdout,"(%s=%s)",pPIA->pName,sBuf);
  713.     return(eTrue);
  714. }