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

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

Oracle数据库

开发平台：

Unix_Linux

scalar.c：源码内容
  1. /* scalar.c - suupporting functions for parser
  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.  */
  13. #include <string.h>
  14. #include <errno.h>
  15. #include "scalar.h"
  16. #include "sqlweb.h"
  17. #include "ifparse.h"
  18. #include "ifwords.h"
  20. /* 
  21. /* The Global Variables for the IfParser
  22.  */
  23. static LIST *glAllScalarElements; /* All Allocated Stuff, for cleanup */
  24. static Scalar_t gsNullScalar /* = {-1,0,0,0} */ ;
  26. /*
  27. /* External Functions
  28.  */
  29. extern double atof();
  30. extern char *strcat();
  31. extern atoi();
  33. /*
  34. /* Private Functions
  35.  */
  36. static eBoolean_t aToBool(char *p);
  37. /* static void PushScalar(Scalar_t *p);
  38.  */
  39. static double ScalarToDouble(Scalar_t *p);
  40. static char *ScalarToString(Scalar_t *p);
  41. static eBoolean_t CompareDouble(int iOp,double dLeft, double dRight);
  42. static eBoolean_t CompareString(int iOp,char *pLeft, char *pRight);
  43. static eBoolean_t IsNumber(Scalar_t *p);
  44. static void ToUpper(char *pBuf);
  45. static void ToLower(char *pBuf);
  46. static void FormatString(char *pInpStr,char *pFmtStr,char *pOutBuf);
  47. static long GetReplaceSize(char *pBuf, char *pSrch, char *pRepl );
  48. static char * Replace( char *pBuf, char *pSrch, char *pRepl );
  50. /********************************************************
  51. /* Boolean Functions
  52.  */
  53. eBoolean_t 
  54. BetweenCond(Scalar_t *p, Scalar_t *pLo, Scalar_t *pHi)
  55. {
  56.     double d, dLo, dHi;
  57.     if(!p || !pLo || !pHi) {
  58. DebugHTML(__FILE__,__LINE__,0
  59. ,"WARN:BETWEEN:Scalar is NULL(%x between %x and %x)"
  60. ,p
  61. ,pLo
  62. ,pHi
  63. );
  64. MsgPush("WARN:BETWEEN:Scalar is NULL");
  65. return(eFalse);
  66.     }
  68.     d   = ScalarToDouble(p);
  69.     dLo = ScalarToDouble(pLo);
  70.     dHi = ScalarToDouble(pHi);
  72.     return( (d>=dLo && d<=dHi)?eTrue :eFalse);
  73. }
  75. eBoolean_t 
  76. LikeCond(Scalar_t *p1, Scalar_t *p2)
  77. {
  78.     char *pStr1, *pStr2;
  79.     if(!p1 || !p2) {
  80. DebugHTML(__FILE__,__LINE__,0
  81. ,"WARN:LIKE:Scalar is NULL(%x like %x)"
  82. ,pStr1
  83. ,pStr2
  84. );
  85. MsgPush("WARN:LIKE:Scalar is NULL");
  86. return(eFalse);
  87.     }
  89.     pStr1 = ScalarToString(p1);
  90.     pStr2 = ScalarToString(p2);
  92.     DebugHTML(__FILE__,__LINE__,0,"WARN:LIKE only supports EQ.");
  93.     DebugHTML(__FILE__,__LINE__,4,"Strcmp(%s,%s)",pStr1,pStr2);
  94.     /* return( (strcmp(pStr1,pStr2)==0)?eTrue :eFalse );
  95.      */
  96.     return( bStrMatch(pStr1,pStr2) );
  97. }
  99. eBoolean_t 
  100. IsNullCond(Scalar_t *p)
  101. {
  102.     char *pStr;
  104.     if(!p){
  105. DebugHTML(__FILE__,__LINE__,2,"WARN:IS NULL:Scalar is NULL");
  106. return(eTrue);
  107.     }
  108.     pStr = ScalarToString(p);
  110.     /*
  111.     /* Compare STRINGS
  112.      */
  113.     return(pStr ? (iStrLen(pStr)==0)?eTrue :eFalse 
  114.         : eTrue
  115.   );
  116. }
  118. eBoolean_t 
  119. InCond(Scalar_t *pVal, Scalar_t *pList)
  120. {
  121.     Scalar_t *pTop;
  122.     if(!pVal || !pList) {
  123. DebugHTML(__FILE__,__LINE__,0
  124. ,"WARN:IN:Scalar is NULL(%x in(%x))"
  125. ,pVal
  126. ,pList
  127. );
  128. MsgPush("WARN:IN:Scalar is NULL");
  129. return(eFalse);
  130.     }
  131.     for(pTop=DEQ(pList->uVal.pList);pTop;pTop=DEQ(pList->uVal.pList)){
  132. if(ISeTrue(CompareCond(MkScalarToken(EQ),pVal,pTop))){
  133.     return(eTrue);
  134. }
  135.     }
  136.     return(eFalse);
  137. }
  139. eBoolean_t 
  140. CompareCond(Scalar_t *pOp,Scalar_t *pLeft,Scalar_t *pRight)
  141. {
  142.     double dLeft, dRight;
  143.     char  *pStrLeft,*pStrRight;
  145.     if(!pOp || !pLeft || !pRight) {
  146. DebugHTML(__FILE__,__LINE__,0
  147. ,"WARN:COMPARE:Scalar is NULL(op=%x, %x op %x)"
  148. ,pOp
  149. ,pLeft
  150. ,pRight
  151. );
  152. MsgPush("WARN:COMPARE:Scalar is NULL");
  153. return(eFalse);
  154.     }
  156.     /*
  157.     /* If either operand is a number, they are all numbers 
  158.      */
  159.     if(ISeTrue(IsNumber(pLeft)) || ISeTrue(IsNumber(pRight)))
  160.     {
  161. /* Comparing Numbers */
  162. dLeft = ScalarToDouble(pLeft);
  163. dRight= ScalarToDouble(pRight);
  164. return(CompareDouble(pOp->uVal.iInt,dLeft,dRight));
  165.     }
  166.     /*
  167.     /* Otherwise treat them as strings
  168.      */
  169.     pStrLeft =ScalarToString(pLeft);
  170.     pStrRight=ScalarToString(pRight);
  171.     return(CompareString(pOp->uVal.iInt,pStrLeft,pStrRight));
  172. }
  174. /********************************************************
  175. /* The Scalar Functions
  176.  */
  177. Scalar_t *
  178. AddScalar(Scalar_t *p1, Scalar_t *p2)
  179. {
  180.     double d1, d2;
  182.     if(!p1 || !p2) {
  183. DebugHTML(__FILE__,__LINE__,0
  184. ,"WARN:ADD:Scalar is NULL(%x + %x)"
  185. ,p1
  186. ,p2
  187. );
  188. return(&gsNullScalar);
  189.     }
  190.     /*
  191.     /* If either is a number convert to number...
  192.      */
  193.     if( ISeTrue(IsNumber(p1)) || ISeTrue(IsNumber(p2))) {
  194. d1 = ScalarToDouble(p1);
  195. d2 = ScalarToDouble(p2);
  197. p1->esType = eDoubleType;
  198. p1->uVal.dDouble = d1+d2;
  199. p1->lSize = 0L;
  200. return(p1);
  201.     }
  202.     return(CatScalar(p1,p2));
  203. }
  205. Scalar_t *
  206. CatScalar(Scalar_t *p1, Scalar_t *p2)
  207. {
  208.     char *pB1,*pB2,*pRet;
  209.     long lSize;
  211.     if(!p1 || !p2) {
  212. DebugHTML(__FILE__,__LINE__,0
  213. ,"WARN:CAT:Scalar is NULL(%x + %x)"
  214. ,p1
  215. ,p2
  216. );
  217. return(&gsNullScalar);
  218.     }
  220.     pB1=ScalarToString(p1);
  221.     pB2=ScalarToString(p2);
  222.     lSize = iStrLen(pB1)+iStrLen(pB2)+1; /* need room for null */
  224.     pRet = (char*)malloc(lSize);
  225.     if(!pRet) {
  226. DebugHTML(__FILE__,__LINE__,0
  227. ,"WARN:CAT:Malloc failed(%x,%x)"
  228. ,p1
  229. ,p2
  230. );
  231. return(&gsNullScalar);
  232.     }
  233.     (void)memset(pRet,0,lSize);
  235.     strcpy(pRet,pB1);
  236.     strcat(pRet,pB2);
  237.     p1->esType = eStringType;
  238.     p1->uVal.pString = pRet;
  239.     p1->lSize = lSize;
  240.     return(p1);
  241. }
  243. Scalar_t *
  244. SubScalar(Scalar_t *p1, Scalar_t *p2)
  245. {
  246.     double d1, d2;
  247.     if(!p1 || !p2) {
  248. DebugHTML(__FILE__,__LINE__,0
  249. ,"WARN:SUB:Scalar is NULL(%x - %x)"
  250. ,p1
  251. ,p2
  252. );
  253. return(&gsNullScalar);
  254.     }
  255. /*
  256. /*   Convert to number and subtract...
  257.  */
  258.     d1 = ScalarToDouble(p1);
  259.     d2 = ScalarToDouble(p2);
  261.     p1->esType = eDoubleType;
  262.     p1->uVal.dDouble = d1-d2;
  263.     p1->lSize = 0;
  264.     return(p1);
  265. }
  266. Scalar_t *
  267. MultScalar(Scalar_t *p1, Scalar_t *p2)
  268. {
  269.     double d1, d2;
  270.     if(!p1 || !p2) {
  271. DebugHTML(__FILE__,__LINE__,0
  272. ,"WARN:MULTIPLY:Scalar is NULL(%x * %x)"
  273. ,p1
  274. ,p2
  275. );
  276. return(&gsNullScalar);
  277.     }
  278.     /* Convert to number and do it!
  279.      */
  280.     d1 = ScalarToDouble(p1);
  281.     d2 = ScalarToDouble(p2);
  283.     p1->esType = eDoubleType;
  284.     p1->uVal.dDouble = d1*d2;
  285.     p1->lSize = 0;
  286.     return(p1);
  287. }
  288. Scalar_t *
  289. DivScalar(Scalar_t *p1, Scalar_t *p2)
  290. {
  291.     double d1, d2;
  292.     if(!p1 || !p2) {
  293. DebugHTML(__FILE__,__LINE__,0
  294. ,"WARN:DIV:Scalar is NULL(%x / %x)"
  295. ,p1
  296. ,p2
  297. );
  298. return(&gsNullScalar);
  299.     }
  300.     d1 = ScalarToDouble(p1);
  301.     d2 = ScalarToDouble(p2);
  302.     if( (int)d2==0) {
  303. DebugHTML(__FILE__,__LINE__,0,"WARN:Div by Zero");
  304. return(&gsNullScalar);
  305.     }
  307.     p1->esType = eDoubleType;
  308.     p1->uVal.dDouble = d1/d2;
  309.     p1->lSize = 0;
  310.     return(p1);
  311. }
  312. Scalar_t *
  313. ModScalar(Scalar_t *p1, Scalar_t *p2)
  314. {
  315.     double d1, d2;
  316.     if(!p1 || !p2) {
  317. DebugHTML(__FILE__,__LINE__,0
  318. ,"WARN:MOD:Scalar is NULL(%x / %x)"
  319. ,p1
  320. ,p2
  321. );
  322. return(&gsNullScalar);
  323.     }
  324.     d1 = ScalarToDouble(p1);
  325.     d2 = ScalarToDouble(p2);
  326.     if( (int)d2==0) {
  327. DebugHTML(__FILE__,__LINE__,0,"WARN:Div by Zero");
  328. return(&gsNullScalar);
  329.     }
  331.     p1->esType = eDoubleType;
  332.     p1->uVal.dDouble = (int)d1 %(int)d2;
  333.     p1->lSize = 0;
  334.     return(p1);
  335. }
  337. Scalar_t *
  338. USubScalar(Scalar_t *p1)
  339. {
  340.     double d1;
  341.     if(!p1) {
  342. DebugHTML(__FILE__,__LINE__,0,"WARN:USUB:Scalar is NULL(%x)",p1);
  343. return(&gsNullScalar);
  344.     }
  345.     d1 = ScalarToDouble(p1);
  347.     p1->esType = eDoubleType;
  348.     p1->uVal.dDouble = -d1;
  349.     p1->lSize = 0;
  350.     return(p1);
  351. }
  353. Scalar_t *
  354. CallFunction
  355. (Scalar_t *pName
  356. ,Scalar_t *pList
  357. )
  358. {
  359.     Reserved_t *pResWord;
  360.     if(!pName || !pList) {
  361. DebugHTML(__FILE__,__LINE__,0
  362. ,"WARN:CALL:Scalar is NULL(%x(%x))"
  363. ,pName
  364. ,pList
  365. );
  366. return(&gsNullScalar);
  367.     }
  369.     for(pResWord=gaReservedWordTable; pResWord->pName; pResWord++){
  370. if(is_casematch(pResWord->pName,pName->uVal.pString)) {
  371.     /* Got one!
  372.      */
  373.     return( (pResWord->pScalarFunc)(pList) );
  374. }
  375.     }
  376.     DebugHTML(__FILE__,__LINE__,0,"WARN:CALL:Unknown Function or Type.");
  377.     return( &gsNullScalar );
  378. }
  379. Scalar_t *
  380. AddScalarToList(Scalar_t *pList,Scalar_t *p1)
  381. {
  382.     if(!p1) {
  383. DebugHTML(__FILE__,__LINE__,0,"WARN:ADD LIST:Scalar is NULL(%x)",p1);
  384. return(&gsNullScalar);
  385.     }
  386.     if(!pList){
  387. pList=MkScalar(eListType,p1,p1->lSize);
  388. return(pList);
  389.     }
  390.     ENQ(pList->uVal.pList,p1);
  391.     return(pList);
  392. }
  394. /********************************************************
  395. /* Called by yylex and elsewhere to create a scalar when found
  396.  */
  397. Scalar_t *
  398. MkScalarToken(int iToken)
  399. {
  400.     Scalar_t *p;
  401.     p = (Scalar_t *)malloc(sizeof(Scalar_t));
  402.     if(!p){
  403. /* out of memory */
  404. return(0);
  405.     }
  406.     (void)memset(p,0,sizeof(Scalar_t));
  407.     p->esType = eIntType;
  408.     p->uVal.iInt = iToken;
  409.     p->lSize = 0;
  410.     /* PushScalar(p);
  411.      */
  412.     return(p);
  413. }
  415. Scalar_t *
  416. MkScalar(eScalar_t esType, void *pValue, long lSize)
  417. {
  418.     Scalar_t *p;
  419.     p = (Scalar_t *)malloc(sizeof(Scalar_t));
  420.     if(!p){
  421. /* out of memory */
  422. return(0);
  423.     }
  424.     (void)memset(p,0,sizeof(Scalar_t));
  425.     p->esType = esType;
  426.     p->lSize  = lSize;
  427.     switch(esType) {
  428. case eStringType:p->uVal.pString= DupMem(pValue,lSize); break;
  429. case eIntType:  p->uVal.iInt   = atoi(pValue);    break;/* Integers */
  430. case eDoubleType:p->uVal.dDouble= atof(pValue);    break;/* Real */
  431. case eListType:  p->uVal.pList  = l_create("QUEUE");
  432.  ENQ(p->uVal.pList,pValue);
  433.  break; /* Lists */
  434. case eBoolType:  p->uVal.bBool  = aToBool(pValue); break;/* Bool */
  435. case eRawType:   p->uVal.pRaw   = DupMem(pValue,lSize); break;
  436.     }
  437.     /* PushScalar(p);
  438.      */
  439.     return(p);
  440. }
  442. extern Scalar_t *
  443. ToScalar(eBoolean_t bBool)
  444. {
  445.     Scalar_t *p;
  446.     p = (Scalar_t *)malloc(sizeof(Scalar_t));
  447.     if(!p){
  448. /* out of memory */
  449. return(0);
  450.     }
  451.     (void)memset(p,0,sizeof(Scalar_t));
  452.     p->esType = eBoolType;
  453.     p->uVal.bBool  = bBool;
  455.     /* PushScalar(p);
  456.      */
  457.     return(p);
  458. }
  460. extern eBoolean_t
  461. IsScalar(Scalar_t *pScalar)
  462. {
  463.     switch(pScalar->esType) {
  464. case eStringType:
  465.     if(is_casematch(pScalar->uVal.pString,"TRUE")) return(eTrue);
  466.     else return(eFalse);
  467. case eIntType:
  468.     if(pScalar->uVal.iInt) return(eTrue);
  469.     else return(eFalse);
  470. case eDoubleType:
  471.     if(pScalar->uVal.dDouble) return(eTrue);
  472.     else return(eFalse);
  473. /* case eListType:  pScalar->uVal.pList  = l_create("QUEUE");
  474. /*  ENQ(pScalar->uVal.pList,pValue);
  475. /*  break; /* Lists */
  476. /* */
  477. case eBoolType:  return(pScalar->uVal.bBool);
  478. default: return(eFalse);
  479.     }
  480.     return(eFalse);
  481. }
  483. extern eBoolean_t
  484. OutputScalar(Scalar_t *pScalar)
  485. {
  486.     OutputHTML("%s",ScalarToString(pScalar));
  487.     return(eTrue);
  488. }
  489. /*
  490. /* Internal Private Functions
  491. /* static void
  492. /* PushScalar(Scalar_t *p)
  493. /* {
  494. /*     if(!glAllScalarElements){
  495. /*  glAllScalarElements=l_create("QUEUE");
  496. /*     }
  497. /*     ENQ(glAllScalarElements,p);
  498. /*     return;
  499. /* }
  500.  */
  502. static double
  503. ScalarToDouble(Scalar_t *p)
  504. {
  505.     if(!p) return(0.0);
  507.     switch(p->esType) {
  508. case eStringType:return(atof(p->uVal.pString));
  509. case eIntType:  return((double)p->uVal.iInt);
  510. case eDoubleType:return(p->uVal.dDouble);
  511. case eListType:  return(0.0);
  512. case eBoolType:  return ISeTrue(p->uVal.bBool) ? 1.0 :0.0 ;
  513. default:  return(0.0);
  514.     }
  515.     return(0.0);
  516. }
  518. static char *
  519. ScalarToString(Scalar_t *p)
  520. {
  521.     char sBuf[BUFSIZ];
  522.     char *pNullStr = "";
  523.     int iLen;
  524.     if(!p) {
  525. DebugHTML(__FILE__,__LINE__,0,"ToStr:NULLStr");
  526. return(pNullStr);
  527.     }
  529.     DebugHTML(__FILE__,__LINE__,5,"ToStr:%s.%d(%d),%s"
  530.     ,p->esType==eStringType    ?"S"
  531. :p->esType==eIntType   ?"I"
  532. :p->esType==eDoubleType?"D"
  533. :p->esType==eListType  ?"L"
  534. :p->esType==eBoolType  ?"B"
  535. :p->esType==eRawType   ?"R"
  536. :"?"
  537.     ,p->lSize
  538.     ,p->esType==eStringType?iStrLen(p->uVal.pString):-1
  539.     ,p->esType==eStringType && p->uVal.pString?p->uVal.pString:"*?*"
  540.     );
  541.     switch(p->esType) {
  542. case eStringType:
  543. if(p->lSize==0) {
  544.     return(DupBuf(0));
  545. }
  546. /* if(p->uVal.pString && p->lSize>=0)
  547. /*    *(p->uVal.pString + p->lSize)=0; /* set NULL */
  548. /* */
  550. return(p->uVal.pString);
  551. case eIntType: sprintf(sBuf,"%d",p->uVal.iInt);
  552. return(DupBuf(sBuf));
  553. case eDoubleType:
  554. sprintf(sBuf,"%f",p->uVal.dDouble);
  555. if(strchr(sBuf,'.')) {
  556.     /* Strip Trailing zeros, if decpt
  557.      */
  558.     iLen = iStrLen(sBuf);
  559.     while( sBuf[--iLen] == '0')
  560. sBuf[iLen]=0;
  561.     if(sBuf[iLen] == '.')
  562. sBuf[iLen]=0;
  563. }
  564. return(DupBuf(sBuf));
  565. case eListType: return(pNullStr);
  566. case eBoolType: return(ISeTrue(p->uVal.bBool)?"TRUE":"FALSE");
  567. default:
  568.     DebugHTML(__FILE__,__LINE__,0,"ToStr:Unknown Type %d",p->esType);
  569.     }
  570.     return(pNullStr);
  571. }
  572. static eBoolean_t
  573. aToBool(char *p)
  574. {
  575.     if(is_casematch(p,"FALSE")) return(eFalse);
  576.     if(is_casematch(p,"TRUE") )  return(eTrue);
  577.     return(eTrue);
  578. }
  580. static eBoolean_t
  581. CompareDouble(int iOp,double dLeft,double dRight)
  582. {
  583.     switch(iOp){
  584. case EQ:  return( (dLeft==dRight)   ?eTrue:eFalse);
  585. case NEQ: return( (!(dLeft==dRight))?eTrue:eFalse);
  586. case GT:  return( (dLeft>dRight)    ?eTrue:eFalse);
  587. case GE:  return( (dLeft>=dRight)   ?eTrue:eFalse);
  588. case LT:  return( (dLeft<dRight)    ?eTrue:eFalse);
  589. case LE:  return( (dLeft<=dRight)   ?eTrue:eFalse);
  590.     }
  591.     DebugHTML(__FILE__,__LINE__,0,"WARN:COMPARE DBL:Unknown OP:%d",iOp);
  592.     return(eFalse);
  593. }
  595. static eBoolean_t
  596. CompareString(int iOp,char *pLeft,char *pRight)
  597. {
  598.     DebugHTML(__FILE__,__LINE__,2,"COMPARE STR:%s %d %s",pLeft,iOp,pRight);
  599.     switch(iOp){
  600. case EQ:  return(is_match(pLeft,pRight)   ?eTrue:eFalse);
  601. case NEQ: return(!(is_match(pLeft,pRight))?eTrue:eFalse);
  602. case GT:  return((iStrCmp(pLeft,pRight)>0)    ?eTrue:eFalse);
  603. case GE:  return((iStrCmp(pLeft,pRight)>=0)   ?eTrue:eFalse);
  604. case LT:  return((iStrCmp(pLeft,pRight)<0)    ?eTrue:eFalse);
  605. case LE:  return((iStrCmp(pLeft,pRight)<=0)   ?eTrue:eFalse);
  606.     }
  607.     DebugHTML(__FILE__,__LINE__,0,"WARN:COMPARE STR:Unknown OP:%d",iOp);
  608.     MsgPush("WARN:COMPARE STR:Unknown OP:%d",iOp);
  609.     return(eFalse);
  610. }
  612. static eBoolean_t
  613. IsNumber(Scalar_t *p)
  614. {
  615.     if(!p){
  616. DebugHTML(__FILE__,__LINE__,0,"IsNumber:Scalar is NULL");
  617. MsgPush("IsNumber:Scalar is NULL");
  618. return(eFalse);
  619.     }
  621.     if(p->esType==eDoubleType || p->esType==eIntType)
  622. return(eTrue);
  623.     return(eFalse);
  624. }
  626. Scalar_t *
  627. ScalarUpper(Scalar_t *pList)
  628. {
  629.     Scalar_t *pTop;
  630.     char sBuf[MAX_BUFSIZ];
  632.     DebugHTML(__FILE__,__LINE__,3,"Called Upper(%x)",pList);
  633.     if(!pList){
  634. DebugHTML(__FILE__,__LINE__,0,"ScalarUpper:Scalar is NULL(%x)",pList);
  635. MsgPush("ScalarUpper:Scalar is NULL");
  636. return(&gsNullScalar);
  637.     }
  638.     if(pList->esType != eListType) {
  639. DebugHTML(__FILE__,__LINE__,0,"WARN:UPPER:Invalid arg type passed to Function");
  640. return(&gsNullScalar);
  641.     }
  642.     sBuf[0]=0;
  643.     while( (pTop = (Scalar_t *)DEQ(pList->uVal.pList)) ) {
  644. char *pTmp = ScalarToString(pTop);
  645. strcat(sBuf,pTmp);
  646.     }
  647.     ToUpper(sBuf);
  648.     return(MkScalar(eStringType,sBuf,1+iStrLen(sBuf)));
  649. }
  651. Scalar_t *
  652. ScalarLower(Scalar_t *pList)
  653. {
  654.     Scalar_t *pTop;
  655.     char sBuf[MAX_BUFSIZ];
  657.     if(!pList) {
  658. DebugHTML(__FILE__,__LINE__,0,"ScalarLower:Scalar is NULL(%x)",pList);
  659. MsgPush("ScalarLower:Scalar is NULL");
  660. return(&gsNullScalar);
  661.     }
  662.     if(pList->esType != eListType) {
  663. DebugHTML(__FILE__,__LINE__,0,"WARN:LOWER:Invalid arg type passed to Function");
  664. return(&gsNullScalar);
  665.     }
  666.     sBuf[0]=0;
  667.     while( (pTop = (Scalar_t *)DEQ(pList->uVal.pList)) ) {
  668. char *pTmp = ScalarToString(pTop);
  669. strcat(sBuf,pTmp);
  670.     }
  671.     ToLower(sBuf);
  672.     return(MkScalar(eStringType,sBuf,1+iStrLen(sBuf)));
  673. }
  674. Scalar_t *
  675. ScalarSubstr(Scalar_t *pList)
  676. {
  677.     char *pTmp;
  678.     int iSize,iOffset,iLength;
  679.     Scalar_t *pString = 0
  680.     ,*pOffset = 0
  681.     ,*pLength = 0
  682. ;
  683.     if(!pList){
  684. DebugHTML(__FILE__,__LINE__,0,"ScalarSubstr:Scalar is NULL(%x)",pList);
  685. MsgPush("ScalarSubstr:Scalar is NULL");
  686. return(&gsNullScalar);
  687.     }
  688.     iSize = l_size(pList->uVal.pList);
  689.     if(iSize==2){
  690. pString=(Scalar_t *)DEQ(pList->uVal.pList);
  691. pOffset=(Scalar_t *)DEQ(pList->uVal.pList);
  693. pTmp   = ScalarToString(pString);
  694. iOffset= (int)ScalarToDouble(pOffset);
  695. if(iOffset<iStrLen(pTmp)) {
  696.     pString->esType = eStringType;
  697.     pString->uVal.pString = (pTmp+iOffset);
  698.     pString->lSize = 1+iStrLen(pString->uVal.pString);
  699.     return(pString);
  700. }
  701.     } else if (iSize==3) {
  702. pString=(Scalar_t *)DEQ(pList->uVal.pList);
  703. pOffset=(Scalar_t *)DEQ(pList->uVal.pList);
  704. pLength=(Scalar_t *)DEQ(pList->uVal.pList);
  706. pTmp   = ScalarToString(pString);
  707. iOffset= (int)ScalarToDouble(pOffset);
  708. iLength= (int)ScalarToDouble(pLength);
  710. /* Reusing iSize as length of first arg */
  711. iSize = iStrLen(pTmp);
  712. if(iOffset<iSize) {
  713.     pString->uVal.pString = (pTmp + iOffset);
  714.     if((iOffset+iLength) <iSize)
  715. *(pTmp + iOffset + iLength) = 0;
  716.     pString->esType = eStringType;
  717.     pString->lSize = 1+iStrLen(pString->uVal.pString);
  718.     return(pString);
  719. }
  720.     } else {
  721. DebugHTML(__FILE__,__LINE__,0,"WARN:SUBSTR:Invalid args to Substr");
  722.     }
  723.     return(&gsNullScalar);
  724. }
  726. Scalar_t *
  727. ScalarLength(Scalar_t *pList)
  728. {
  729.     Scalar_t *pTop;
  730.     int iLen=0, lLen=0;
  731.     char sLenBuf[MAX_INTEGER_DIGITS];
  733.     if(!pList){
  734. DebugHTML(__FILE__,__LINE__,0,"ScalarLength:Scalar is NULL(%x)",pList);
  735. MsgPush("ScalarLength:Scalar is NULL");
  736. return(&gsNullScalar);
  737.     }
  738.     if(pList->esType != eListType) {
  739. DebugHTML(__FILE__,__LINE__,0
  740.  ,"WARN:LENGTH:Invalid arg type passed to Function"
  741.  );
  742. return(&gsNullScalar);
  743.     }
  744.     iLen=0, lLen=0;
  745.     while( (pTop = (Scalar_t *)DEQ(pList->uVal.pList)) ) {
  746. /* char *pTmp = ScalarToString(pTop);
  747. /* iLen += iStrLen(pTmp);
  748.  */
  749. lLen += (pTop->lSize>0)?(pTop->lSize) -1:0;
  750. /* DebugHTML(__FILE__,__LINE__,0,"lSize=%d",lLen);
  751.  */
  752.     }
  753.     sprintf(sLenBuf,"%d",lLen);
  754.     return(MkScalar(eDoubleType, sLenBuf,1+iStrLen(sLenBuf)));
  755. }
  757. Scalar_t *
  758. ScalarNVL(Scalar_t *pList)
  759. {
  760.     Scalar_t *pTop;
  762.     DebugHTML(__FILE__,__LINE__,3,"Called NVL");
  764.     if(!pList){
  765. DebugHTML(__FILE__,__LINE__,0,"ScalarNVL:Scalar is NULL(%x)",pList);
  766. MsgPush("ScalarNVL:Scalar is NULL");
  767. return(&gsNullScalar);
  768.     }
  769.     pTop = (Scalar_t *)DEQ(pList->uVal.pList);
  770.     if(IsNullCond(pTop)) {
  771. DebugHTML(__FILE__,__LINE__,2,"NVL:NULL Condition");
  772. return((Scalar_t *)DEQ(pList->uVal.pList));
  773.     }
  774.     DebugHTML(__FILE__,__LINE__,2,"NVL:NOT NULL Condition");
  775.     return(pTop);
  776. }
  778. Scalar_t *
  779. ScalarHost(Scalar_t *pList)
  780. {
  781.     Scalar_t *pTop;
  782.     char sBuf[MAX_BUFSIZ];
  783.     int c, iCharCount, iStatus;
  784.     FILE *pF;
  786. #ifdef WIN32
  787.     MsgPush("SQLweb/NT: Doesn't Support HOST");
  788.     return(&gsNullScalar);
  789. #endif
  791. #ifndef WIN32
  792.     {
  793.     DebugHTML(__FILE__,__LINE__,3,"Called Host");
  795.     if(!pList){
  796. DebugHTML(__FILE__,__LINE__,0,"ScalarHost:Scalar is NULL(%x)",pList);
  797. MsgPush("ScalarHost:Scalar is NULL");
  798. return(&gsNullScalar);
  799.     }
  800.     sBuf[0]=0;
  801.     while( (pTop = (Scalar_t *)DEQ(pList->uVal.pList)) ) {
  802. char *pTmp = ScalarToString(pTop);
  803. strcat(sBuf,pTmp);
  804.     }
  806.     DebugHTML(__FILE__,__LINE__,2,"Running: `%s`",sBuf);
  808.     pF = popen(sBuf,"r");
  809.     if(!pF){
  810. DebugHTML(__FILE__,__LINE__,0,"POpen Failed: (%s)",sBuf);
  811. MsgPush("Host:Can't popen(%s,"r")", sBuf);
  812. return(&gsNullScalar);
  813.     }
  815.     DebugHTML(__FILE__,__LINE__,3,"Open'd(%x)",pF);
  816.     for( c=fgetc(pF), iCharCount=0
  817. ;c != EOF && iCharCount<MAX_BUFSIZ
  818. ;c=fgetc(pF), iCharCount++ )
  819.     {
  820. sBuf[iCharCount] = c;
  821.     }
  822.     /*
  823.     /* NULL the string...
  824.      */
  825.     if(iCharCount && sBuf[iCharCount-1]=='n')
  826.  sBuf[iCharCount-1]=0;
  827.     else sBuf[iCharCount] = 0;
  829.     DebugHTML(__FILE__,__LINE__,3,"Read %d chars",iCharCount);
  830.     iStatus = pclose(pF);
  831.     DebugHTML(__FILE__,__LINE__,3,"popen:%d:%d",iStatus,c);
  832.     return(MkScalar(eStringType, sBuf,1+iStrLen(sBuf)));
  833.     }
  834. #endif
  835. }
  837. Scalar_t *
  838. ScalarSaveFile(Scalar_t *pList)
  839. {
  840.     Scalar_t *pScalarFileName
  841.     ,*pScalarData
  842.     ;
  843.     char *pFileName;
  844.     long lSize;
  845.     int iListSize;
  846.     FILE *pF;
  848.     DebugHTML(__FILE__,__LINE__,3,"Called SaveFile");
  849.     if(!pList){
  850. DebugHTML(__FILE__,__LINE__,0,"SaveFile:Scalar is NULL(%x)",pList);
  851. MsgPush("ScalarSaveFile:Scalar is NULL");
  852. return(&gsNullScalar);
  853.     }
  855.     /*
  856.     /* Check number of parameters (the USAGE)
  857.      */
  858.     iListSize = l_size(pList->uVal.pList);
  859.     if(iListSize != 2) {
  860. DebugHTML(__FILE__,__LINE__,0
  861.  ,"WARN:SAVEFILE:USAGE:SaveFile(filename,data)"
  862.  );
  863. MsgPush("ScalarSaveFile:Scalar is NULL");
  864. return(&gsNullScalar);
  865.     }
  867.     /*
  868.     /* Get Filename 
  869.      */
  870.     pScalarFileName = (Scalar_t *)DEQ(pList->uVal.pList);
  871.     pScalarData = (Scalar_t *)DEQ(pList->uVal.pList);
  873.     pFileName = ScalarToString(pScalarFileName);
  874.     pF=fopen(pFileName,"w");
  875.     if(!pF){
  876. DebugHTML(__FILE__,__LINE__,0,"SaveFile:Open Failed:%d",errno);
  877. MsgPush("ScalarSaveFile:Open Failed");
  878. return(&gsNullScalar);
  879.     }
  880.     lSize = pScalarData->lSize;
  881.     lSize = fwrite(pScalarData->uVal.pString,lSize,1,pF);
  882.     fclose(pF);
  884.     pScalarFileName->esType = eBoolType;
  885.     pScalarFileName->uVal.bBool = lSize==1?eTrue:eFalse;
  886.     pScalarFileName->lSize = 0;
  887.     return(pScalarFileName);
  888. }
  890. Scalar_t *
  891. ScalarToChar(Scalar_t *pList)
  892. {
  893.     char *pFmtStr
  894.  ,*pInpStr
  895.  ,sBuf[BUFSIZ]
  896.  ;
  897.     int iSize;
  898.     Scalar_t *pInput = 0
  899.     ,*pFormat = 0
  900. ;
  901.     if(!pList){
  902. DebugHTML(__FILE__,__LINE__,0,"ScalarToChar:Scalar is NULL(%x)",pList);
  903. MsgPush("ScalarToChar:Scalar is NULL");
  904. return(&gsNullScalar);
  905.     }
  906.     iSize = l_size(pList->uVal.pList);
  907.     if(iSize!=2){
  908. DebugHTML(__FILE__,__LINE__,0,"WARN:TO_CHAR:usage error:to_char(input,fmt)");
  909. return(&gsNullScalar);
  910.     }
  911.     /* Get the Parameters
  912.      */
  913.     pInput =(Scalar_t *)DEQ(pList->uVal.pList);
  914.     pFormat=(Scalar_t *)DEQ(pList->uVal.pList);
  916.     /* Convert Each Parameter to a string
  917.      */
  918.     pInpStr= ScalarToString(pInput);
  919.     pFmtStr= ScalarToString(pFormat);
  921.     /*
  922.     /* Convert input string using format mask
  923.      */
  924.     FormatString(pInpStr,pFmtStr,sBuf);
  925.     return(MkScalar(eStringType, sBuf,1+iStrLen(sBuf)));
  926. }
  928. Scalar_t *
  929. ScalarToNumber(Scalar_t *pList)
  930. {
  931.     int  iDotFlag = 0
  932. ,iDigFlag = 0;
  933.     Scalar_t *pScalar;
  934.     char *pInStr;
  935.     char sBuf[MAX_BUFSIZ], *psBuf=sBuf;
  937.     /* fprintf(stderr,"ToNumber(!)n");fflush(stderr);
  938.      */
  939.     if(!pList){
  940. DebugHTML(__FILE__,__LINE__,0,"ScalarToNumber:Scalar is NULL(%x)",pList);
  941. MsgPush("ScalarToNumber:Scalar is NULL");
  942. return(&gsNullScalar);
  943.     }
  945.     pScalar = DEQ(pList->uVal.pList);
  946.     pInStr = ScalarToString(pScalar);
  948.     for( ; *pInStr; pInStr++) {
  949. switch(*pInStr){
  950.     case '-' : 
  951. if(iDigFlag) break;
  952.     case '.' : 
  953. if(iDotFlag) break;
  954. iDotFlag=1;
  955.     case '0' :
  956.     case '1' :
  957.     case '2' :
  958.     case '3' :
  959.     case '4' :
  960.     case '5' :
  961.     case '6' :
  962.     case '7' :
  963.     case '8' :
  964.     case '9' :
  965. iDigFlag=1;
  966. *psBuf++ = *pInStr;
  967. break;
  968. } /* end of switch */
  969.     } /* end of for */
  970.     *psBuf = '';
  971.     /* fprintf(stderr,"ToNumber(%s)n",sBuf);fflush(stderr);
  972.      */
  973.     return(MkScalar(eStringType,sBuf,1+iStrLen(sBuf)));
  974. }
  976. Scalar_t *
  977. ScalarLPad(Scalar_t *pList)
  978. {
  979.     int  iSize
  980. ,iPadSize
  981. ;
  982.     Scalar_t   *pSource
  983. ,*pSize
  984. ,*pChar
  985. ;
  986.     char  *pStrSource
  987. ,*pStrChar = " "
  988. ,sBuf[MAX_BUFSIZ]
  989. ;
  991.     /* fprintf(stderr,"LPad(!)n");fflush(stderr);
  992.      */
  993.     if(!pList){
  994. DebugHTML(__FILE__,__LINE__,0,"ScalarLPad:Scalar is NULL(%x)",pList);
  995. MsgPush("ScalarLPad:Scalar is NULL");
  996. return(&gsNullScalar);
  997.     }
  999.     iSize = l_size(pList->uVal.pList);
  1000.     if(iSize != 2 && iSize !=3) {
  1001. DebugHTML(__FILE__,__LINE__,0,"WARN:LPAD:USAGE:LPad(input,size[,padchar])");
  1002. return(&gsNullScalar);
  1003.     }
  1004.     pSource = DEQ(pList->uVal.pList);
  1005.     pSize   = DEQ(pList->uVal.pList);
  1006.     if(iSize == 3) {
  1007. pChar = DEQ(pList->uVal.pList);
  1008.     }
  1009.     pStrSource = ScalarToString(pSource);
  1010.     iPadSize = (int)ScalarToDouble(pSize);
  1011.     pStrChar = ScalarToString(pChar);
  1013.     if(iPadSize >= MAX_BUFSIZ) {
  1014. DebugHTML(__FILE__,__LINE__,0
  1015. ,"WARN:LPAD:overflow, truncated to %d",MAX_BUFSIZ);
  1016. iPadSize = MAX_BUFSIZ -1;
  1017.     }
  1019.     memset(sBuf, *pStrChar, iPadSize);
  1020.     sBuf[iPadSize] = 0;
  1022.     strcpy(&sBuf[iPadSize-iStrLen(pStrSource)],pStrSource);
  1023.     return(MkScalar(eStringType,sBuf,1+iStrLen(sBuf)));
  1024. }
  1026. Scalar_t *
  1027. ScalarRPad(Scalar_t *pList)
  1028. {
  1029.     int  iSize
  1030. ,iPadSize
  1031. ;
  1032.     Scalar_t   *pSource
  1033. ,*pSize
  1034. ,*pChar
  1035. ;
  1036.     char  *pStrSource
  1037. ,*pStrChar = " "
  1038. ,sBuf[MAX_BUFSIZ]
  1039. ;
  1041.     /* fprintf(stderr,"RPad(!)n");fflush(stderr);
  1042.      */
  1043.     if(!pList){
  1044. DebugHTML(__FILE__,__LINE__,0,"ScalarRPad:Scalar is NULL(%x)",pList);
  1045. MsgPush("ScalarRPad:Scalar is NULL");
  1046. return(&gsNullScalar);
  1047.     }
  1049.     iSize = l_size(pList->uVal.pList);
  1050.     if(iSize != 2 && iSize !=3) {
  1051. DebugHTML(__FILE__,__LINE__,0,"WARN:RPAD:USAGE:RPad(input,size[,padchar])");
  1052. return(&gsNullScalar);
  1053.     }
  1054.     pSource = DEQ(pList->uVal.pList);
  1055.     pSize   = DEQ(pList->uVal.pList);
  1056.     if(iSize == 3) {
  1057. pChar = DEQ(pList->uVal.pList);
  1058.     }
  1059.     pStrSource = ScalarToString(pSource);
  1060.     iPadSize = (int)ScalarToDouble(pSize);
  1061.     pStrChar = ScalarToString(pChar);
  1063.     if(iPadSize >= MAX_BUFSIZ) {
  1064. DebugHTML(__FILE__,__LINE__,0
  1065. ,"WARN:RPAD:overflow, truncated to %d",MAX_BUFSIZ);
  1066. iPadSize = MAX_BUFSIZ -1;
  1067.     }
  1069.     memset(sBuf, *pStrChar, iPadSize);
  1070.     sBuf[iPadSize] = 0;
  1072.     strncpy(sBuf,pStrSource,iStrLen(pStrSource));
  1073.     return(MkScalar(eStringType, sBuf,1+iStrLen(sBuf)));
  1074. }
  1076. Scalar_t *
  1077. ScalarLTrim(Scalar_t *pList)
  1078. {
  1079.     int  iSize
  1080. ;
  1081.     Scalar_t   *pSource
  1082. ,*pChar
  1083. ;
  1084.     char  *pStrSource
  1085. ,*pStrChar = " "
  1086. ,sBuf[MAX_BUFSIZ]
  1087. ;
  1089.     if(!pList){
  1090. DebugHTML(__FILE__,__LINE__,0,"ScalarTrim:Scalar is NULL(%x)",pList);
  1091. MsgPush("ScalarLTrim:Scalar is NULL");
  1092. return(&gsNullScalar);
  1093.     }
  1095.     iSize = l_size(pList->uVal.pList);
  1096.     if(iSize != 1 && iSize !=2) {
  1097. DebugHTML(__FILE__,__LINE__,0,"WARN:LTRIM:USAGE:LTrim(input[,trimchar])");
  1098. return(&gsNullScalar);
  1099.     }
  1100.     /*
  1101.     /* Get String version of Variable
  1102.      */
  1103.     pSource = DEQ(pList->uVal.pList);
  1104.     pStrSource = ScalarToString(pSource);
  1106.     /*
  1107.     /* Now Get The "Trimoff Char"
  1108.      */
  1109.     if(iSize == 2) {
  1110. pChar = DEQ(pList->uVal.pList);
  1111. pStrChar = ScalarToString(pChar);
  1112.     }
  1114.     while(*pStrSource == *pStrChar)
  1115. pStrSource++;
  1117.     if(*pStrSource)
  1118.  strcpy(sBuf,pStrSource);
  1119.     else sBuf[0] = 0;
  1121.     return(MkScalar(eStringType, sBuf,1+iStrLen(sBuf)));
  1122. }
  1124. Scalar_t *
  1125. ScalarRTrim(Scalar_t *pList)
  1126. {
  1127.     int  iSize
  1128. ;
  1129.     Scalar_t   *pSource
  1130. ,*pChar
  1131. ;
  1132.     char  *pStrSource
  1133. ,*pStrChar = " "
  1134. ;
  1136.     if(!pList){
  1137. DebugHTML(__FILE__,__LINE__,0,"ScalarRTrim:Scalar is NULL(%x)",pList);
  1138. MsgPush("ScalarRTrim:Scalar is NULL");
  1139. return(&gsNullScalar);
  1140.     }
  1142.     iSize = l_size(pList->uVal.pList);
  1143.     if(iSize != 1 && iSize !=2) {
  1144. DebugHTML(__FILE__,__LINE__,0,"WARN:RTRIM:USAGE:RTrim(input[,padchar])");
  1145. return(&gsNullScalar);
  1146.     }
  1147.     pSource = DEQ(pList->uVal.pList);
  1148.     pStrSource = ScalarToString(pSource);
  1150.     if(iSize == 2) {
  1151. pChar = DEQ(pList->uVal.pList);
  1152. pStrChar = ScalarToString(pChar);
  1153.     }
  1155.     iSize = iStrLen(pStrSource);
  1156.     while( *(pStrSource+ (--iSize)) == *pStrChar)
  1157. ; /* nothing */
  1158.     *(pStrSource + iSize +1) = 0;
  1159.     return(MkScalar(eStringType, pStrSource,1+iStrLen(pStrSource)));
  1160. }
  1162. static void
  1163. ToUpper(char *pBuf)
  1164. {
  1165.     int c;
  1166.     for(c= *pBuf;c;c = *++pBuf)
  1167. *pBuf=(char)toupper(c);
  1168.     return;
  1169. }
  1171. static void
  1172. ToLower(char *pBuf)
  1173. {
  1174.     int c;
  1175.     for(c = *pBuf;c; c= *++pBuf)
  1176. *pBuf = (char)tolower(c);
  1177.     return;
  1178. }
  1180. static void
  1181. FormatString(char *pInpStr,char *pFmtStr,char *pOutBuf)
  1182. {
  1183.     char *pInDecPt
  1184. ,*pFmtDecPt
  1185. ;
  1186.     int  iInDecSize
  1187. ,iFmtPrecision
  1188. ,iNewDecSize
  1189. ,iNewBufSize
  1190. ,iCommaFlag
  1191. ,i
  1192. ;
  1194.     DebugHTML(__FILE__,__LINE__,3,"FormatString(%s,%s,buf)",pInpStr,pFmtStr);
  1196.     pInDecPt = (char *)strchr(pInpStr,'.');
  1197.     pFmtDecPt= (char *)strchr(pFmtStr,'.');
  1199.     iInDecSize   = (pInDecPt) ? pInDecPt - pInpStr : iStrLen(pInpStr);
  1200.     iFmtPrecision= (pFmtDecPt)? iStrLen(pFmtDecPt+1) : 0;
  1202.     iCommaFlag =  (strchr(pFmtStr,',')) ? 1 : 0;
  1203.     iNewDecSize= (iCommaFlag)
  1204. ? (iInDecSize + ((iInDecSize-1)/3)) /* Fmt str has commas */
  1205. : iInDecSize     /* Fmt str NO commas  */
  1206. ;
  1207.     iNewBufSize= iNewDecSize + ((iFmtPrecision>0)?1:0) + iFmtPrecision;
  1209. /*    fprintf(stderr,"NSiz=%d (%d + %d + %d) (fmtprec=%s)n"
  1210. /*      , iNewBufSize
  1211. /*      , iNewDecSize
  1212. /*      , ((iFmtPrecision>0)?1:0) 
  1213. /*      , iFmtPrecision
  1214. /*      , pFmtDecPt+1
  1215. /*      );
  1216. /*    fflush(stderr);
  1217.  */
  1219.     for(i=0;i<iNewBufSize;i++) {
  1220. /* Place Decimal point when not included in pInpStr
  1221.  */
  1222. if(i==iNewDecSize && !pInDecPt) {
  1223.     *pOutBuf++ = '.';
  1224. }
  1225. /* if a comma goes here
  1226.  */
  1227. else if(iCommaFlag /* format string has comma */
  1228.     && i>0 /* no leading comma */
  1229.     && iNewDecSize-i>0 /* no comma after decpt */
  1230.     && ((iNewDecSize-i)%4)==0) /* comma position */
  1231. {
  1232.     *pOutBuf++ = ','; /* Insert Comma */
  1233. }else {
  1234.     *pOutBuf++ = (*pInpStr) ?*pInpStr++ : '0';
  1235. }
  1236.     }
  1237.     *pOutBuf = 0;
  1238.     return;
  1239. }
  1241. extern eBoolean_t
  1242. AssignCond(Scalar_t *pScalarName
  1243.   ,Scalar_t *pScalarValue
  1244.   )
  1245. {
  1246.     char *pValue
  1247. ,*pName
  1248. ;
  1249.     if(!pScalarName) {
  1250. DebugHTML(__FILE__,__LINE__,0 ,"WARN:ASSIGN:No Symbol Name");
  1251. MsgPush("WARN:ASSIGN:No Symbol Name");
  1252. return(eFalse);
  1253.     }
  1254.     pName=pScalarName->pName? pScalarName->pName: ScalarToString(pScalarName);
  1255.     DebugHTML(__FILE__,__LINE__,2,"AssignCond(%s)",pName); 
  1256.     if(!pScalarValue) {
  1257. DebugHTML(__FILE__,__LINE__,0
  1258.  ,"WARN:ASSIGN:No Symbol Value for %s"
  1259.  ,pName
  1260.  );
  1261. /* return(eFalse);
  1262.  */
  1263. pValue = "";
  1264.     } else {
  1265. pValue = ScalarToString(pScalarValue); /* Determine Value */
  1266.     }
  1267.     SELSym(pName,pValue);
  1268.     DebugHTML(__FILE__,__LINE__,2,"AssignCond:Completed");
  1269.     return(eTrue);
  1270. }
  1272. extern Scalar_t *
  1273. ScalarGetSym(Scalar_t *pScalar
  1274.     ,char *pRule
  1275. )
  1276. {
  1277.     char *pBuf, *pName;
  1278.     Scalar_t *pNewScalar;
  1279.     long lSize;
  1281.     if(!pScalar){
  1282. DebugHTML(__FILE__,__LINE__,0,"ScalarGetSym:%s:Scalar is NULL",pRule);
  1283. MsgPush("ScalarGetSym:%s:Scalar is NULL",pRule);
  1284. return(pScalar);
  1285.     }
  1286.     pName =  pScalar->pName? pScalar->pName: ScalarToString(pScalar);
  1287.     if(!pName || iStrLen(pName)==0) {
  1288. DebugHTML(__FILE__,__LINE__,0,"ScalarGetSym:No Name");
  1289. return(pScalar);
  1290.     }
  1292.     (void)GetRawSymbolValueREF(pName,&pBuf,&lSize);
  1294.     DebugHTML(__FILE__,__LINE__,2,"ScalarGetSym(%s,%s):%s:%d"
  1295.     ,pName
  1296.     ,pBuf?pBuf:""
  1297.     ,pRule
  1298.     ,lSize
  1299.     );
  1300.     pNewScalar = MkScalar(eStringType,pBuf,lSize);
  1301.     pNewScalar->pName = DupBuf(pName);
  1302.     return(pNewScalar);
  1303. }
  1305. Scalar_t *
  1306. ScalarGetSymARR(Scalar_t *pScalar,Scalar_t *pArrayOffset)
  1307. {
  1308.     char *pBuf, *pName;
  1309.     int iOffset;
  1310.     Scalar_t *pNewScalar;
  1312.     if(!pScalar || !pArrayOffset){
  1313. DebugHTML(__FILE__,__LINE__,0,"ScalarARRGetSym(%x,%x):Scalar is NULL"
  1314. ,pScalar
  1315. ,pArrayOffset
  1316. );
  1317. MsgPush("ScalarARRGetSym:Scalar is NULL");
  1318. return(pScalar);
  1319.     }
  1320.     pName =  pScalar->pName? pScalar->pName: ScalarToString(pScalar);
  1321.     if(!pName || iStrLen(pName)==0) {
  1322. DebugHTML(__FILE__,__LINE__,0,"ScalarGetSym:No Name");
  1323. return(pScalar);
  1324.     }
  1325.     iOffset = (int)ScalarToDouble(pArrayOffset);
  1326.     DebugHTML(__FILE__,__LINE__,2,"ScalarGetSym(%s,%d):%s",pName,iOffset); 
  1327.     (void)GetARRSymbolValueREF(pName,iOffset,&pBuf);
  1329.     pNewScalar = MkScalar(eStringType,pBuf,1+iStrLen(pBuf));
  1330.     pNewScalar->pName = DupBuf(pName);
  1331.     return(pNewScalar);
  1332. }
  1334. Scalar_t *
  1335. ScalarGetCookieValue(Scalar_t *pList)
  1336. {
  1337.     int iListSize;
  1338.     long lSize;
  1339.     char *pName, *pBuf;
  1340.     Scalar_t *pCookieName;
  1342.     DebugHTML(__FILE__,__LINE__,3,"Called GetCookieValue()");
  1343.     if(!pList){
  1344. DebugHTML(__FILE__,__LINE__,0,"GetCookieValue:Scalar is NULL(0)");
  1345. MsgPush("GetCookieValue:Scalar is NULL");
  1346. return(&gsNullScalar);
  1347.     }
  1349.     /* Check number of parameters (the USAGE)
  1350.      */
  1351.     iListSize = l_size(pList->uVal.pList);
  1352.     if(iListSize != 1) {
  1353. DebugHTML(__FILE__,__LINE__,0
  1354.  ,"WARN:GetCookieValue:USAGE:GetCookieValue(CookieName)"
  1355.  );
  1356. return(&gsNullScalar);
  1357.     }
  1359.     /*
  1360.     /* Get CookieName 
  1361.      */
  1362.     pCookieName=(Scalar_t *)DEQ(pList->uVal.pList);
  1363.     pName=ScalarToString(pCookieName);
  1365.     lSize=0L;
  1366.     (void)GetCookieValueREF(pName,&pBuf,&lSize);
  1367.     if(lSize>0){
  1368. return( MkScalar(eStringType,pBuf,1+iStrLen(pBuf)) );
  1369.     }
  1370.     DebugHTML(__FILE__,__LINE__,1 ,"WARN:GetCookie(%s):No HTTP_COOKIE",pName);
  1371.     return(&gsNullScalar);
  1372. }
  1374. Scalar_t *
  1375. ScalarReplace(Scalar_t *pList)
  1376. {
  1377.     char *pStr, *pSrch, *pRepl, *pResult;
  1378.     int iSize;
  1379.     Scalar_t *pString = 0
  1380.     ,*pSearch = 0
  1381.     ,*pReplace = 0
  1382. ;
  1383.     DebugHTML(__FILE__,__LINE__,3,"ScalarReplace()");
  1384.     if(!pList){
  1385. DebugHTML(__FILE__,__LINE__,0,"ScalarReplace:Scalar is NULL(%x)",pList);
  1386. MsgPush("ScalarReplace:Scalar is NULL");
  1387. return(&gsNullScalar);
  1388.     }
  1389.     iSize = l_size(pList->uVal.pList);
  1390.     if(iSize==2){
  1391. pString=(Scalar_t *)DEQ(pList->uVal.pList);
  1392. pSearch=(Scalar_t *)DEQ(pList->uVal.pList);
  1394. pStr   = ScalarToString(pString);
  1395. pSrch  = ScalarToString(pSearch);
  1396.         DebugHTML(__FILE__,__LINE__,2,"ScalarReplace(%s,%s)",pStr,pSrch);
  1397. pResult= Replace( pStr, pSrch, "" );
  1399. pString->esType = eStringType;
  1400. pString->uVal.pString = pResult;
  1401. pString->lSize = iStrLen(pResult);
  1402. return(pString);
  1404.     } else if (iSize==3) {
  1405. pString =(Scalar_t *)DEQ(pList->uVal.pList);
  1406. pSearch =(Scalar_t *)DEQ(pList->uVal.pList);
  1407. pReplace=(Scalar_t *)DEQ(pList->uVal.pList);
  1409. pStr   = ScalarToString(pString);
  1410. pSrch  = ScalarToString(pSearch);
  1411. pRepl  = ScalarToString(pReplace);
  1412.         DebugHTML(__FILE__,__LINE__,2,"ScalarReplace(%s,%s,%s)"
  1413.  ,pStr
  1414.  ,pSrch
  1415.  ,pRepl
  1416.  );
  1417. pResult= Replace( pStr, pSrch, pRepl );
  1419. pString->esType = eStringType;
  1420. pString->uVal.pString = pResult;
  1421. pString->lSize = iStrLen(pResult);
  1422. return(pString);
  1424.     } else {
  1425. DebugHTML(__FILE__,__LINE__,0,"WARN:SUBSTR:Invalid args to Replace");
  1426.     }
  1427.     return(&gsNullScalar);
  1428. }
  1430. static char *
  1431. Replace( char *pBuf, char *pSrch, char *pRepl )
  1432. {
  1433.     char *p, *pE, *po, *pOut;
  1434.     long lOutSize;
  1436.     lOutSize=GetReplaceSize(pBuf,pSrch,pRepl);
  1437. /* Calc size of resultant string */
  1438.     po=pOut=(char*)malloc(lOutSize+1);
  1439. /* Get storage */
  1440.     (void)memset(pOut,0,lOutSize);
  1441. /* just in case ... cleanup space */
  1443.     for(pE=pBuf,p=strstr(pBuf,pSrch); p; p=strstr(pE,pSrch)) {
  1444. while(pE<p)
  1445.     *po++ = *pE++; /* copy characters not being replaced */
  1446. strcpy(po,pRepl); /* copy replace string */
  1447. pE = p + strlen(pSrch); /* move pointer on input string ahead */
  1448. po = po + strlen(pRepl);/* move pointer on output string ahead */
  1449.     }
  1450.     while(*pE) /* process remaining part of string */
  1451. *po++ = *pE++; /* copy characters */
  1452.     *po=0; /* don't forget the all important NULL */
  1453.     return( pOut ); /* OK, otta here! */
  1454. }
  1456. static long
  1457. GetReplaceSize(char *pBuf, char *pSrch, char *pRepl )
  1458. {
  1459.     char *p, *pE;
  1460.     long lStrCount = 0;
  1462.     for( p=strstr(pBuf,pSrch); p; p=strstr(pE,pSrch)) {
  1463. pE = p + strlen(pSrch);
  1464. pE++;
  1465. lStrCount++; /* Count occurances of "pSrch" */
  1466.     }
  1467.     return (strlen(pBuf)+(lStrCount*(strlen(pRepl)-strlen(pSrch))) );
  1468. /* Calc Size of replaced string */
  1469. }
  1471. Scalar_t *
  1472. ScalarAscii(Scalar_t *pList)
  1473. {
  1474.     char *pStr;
  1475.     Scalar_t *pInt;
  1476.     int iSize, iChar;
  1477.     DebugHTML(__FILE__,__LINE__,3,"ScalarAscii()");
  1478.     if(!pList){
  1479. DebugHTML(__FILE__,__LINE__,0,"ScalarAscii:Scalar is NULL(%x)",pList);
  1480. MsgPush("ScalarAscii:Scalar is NULL");
  1481. return(&gsNullScalar);
  1482.     }
  1483.     iSize = l_size(pList->uVal.pList);
  1484.     if(iSize!=1){
  1485. DebugHTML(__FILE__,__LINE__,0,"WARN:Invalid args to Ascii");
  1486. return(&gsNullScalar);
  1487.     }
  1488.     pInt=(Scalar_t *)DEQ(pList->uVal.pList);
  1489.     pStr=ScalarToString(pInt);
  1491.     DebugHTML(__FILE__,__LINE__,2,"ScalarAscii(%s)",pStr);
  1492.     iChar = (int) *pStr;
  1494.     pInt->esType = eIntType;
  1495.     pInt->uVal.iInt = iChar;
  1496.     pInt->lSize = 1;
  1497.     return(pInt);
  1498. }
  1500. Scalar_t *
  1501. ScalarCHR(Scalar_t *pList)
  1502. {
  1503.     char *pStr, sChar[2];
  1505.     Scalar_t *pString;
  1506.     int iSize, iChar;
  1507.     DebugHTML(__FILE__,__LINE__,3,"ScalarCHR()");
  1508.     if(!pList){
  1509. DebugHTML(__FILE__,__LINE__,0,"ScalarCHR:Scalar is NULL(%x)",pList);
  1510. MsgPush("ScalarCHR:Scalar is NULL");
  1511. return(&gsNullScalar);
  1512.     }
  1513.     iSize = l_size(pList->uVal.pList);
  1514.     if(iSize!=1){
  1515. DebugHTML(__FILE__,__LINE__,0,"WARN:Invalid args to CHR");
  1516. return(&gsNullScalar);
  1517.     }
  1518.     pString=(Scalar_t *)DEQ(pList->uVal.pList);
  1520.     iChar = (int) ScalarToDouble(pString);
  1521.     DebugHTML(__FILE__,__LINE__,2,"ScalarCHR(%d)",iChar);
  1523.     sChar[0] = (char)iChar;
  1524.     sChar[1] = (char)0;
  1526.     DebugHTML(__FILE__,__LINE__,2,"ScalarCHR(%s,%c)",sChar,iChar);
  1528.     pString->esType = eStringType;
  1529.     pString->uVal.pString = DupBuf(sChar);
  1530.     pString->lSize =iStrLen(sChar);
  1531.     return(pString);
  1532. }