scalar.c

一个简单的数据库管理工具

/* scalar.c - suupporting functions for parser
/*
/* Copyright (c) 1995-1999 Applied Information Technologies, Inc.
/* All Rights Reserved.
/*  
/* Distributed uder the GNU General Public License which was included in
/* the file named "LICENSE" in the package that you recieved.
/* If not, write to:
/* The Free Software Foundation, Inc.,
/* 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include <string.h>
#include <errno.h>
#include "scalar.h"
#include "sqlweb.h"
#include "ifparse.h"
#include "ifwords.h"

/* 
/* The Global Variables for the IfParser
 */
static LIST *glAllScalarElements;	/* All Allocated Stuff, for cleanup */
static Scalar_t gsNullScalar /* = {-1,0,0,0} */ ;

/*
/* External Functions
 */
extern double atof();
extern char *strcat();
extern atoi();

/*
/* Private Functions
 */
static eBoolean_t aToBool(char *p);
/* static void PushScalar(Scalar_t *p);
 */
static double ScalarToDouble(Scalar_t *p);
static char *ScalarToString(Scalar_t *p);
static eBoolean_t CompareDouble(int iOp,double dLeft, double dRight);
static eBoolean_t CompareString(int iOp,char *pLeft, char *pRight);
static eBoolean_t IsNumber(Scalar_t *p);
static void ToUpper(char *pBuf);
static void ToLower(char *pBuf);
static void FormatString(char *pInpStr,char *pFmtStr,char *pOutBuf);
static long GetReplaceSize(char *pBuf, char *pSrch, char *pRepl );
static char * Replace( char *pBuf, char *pSrch, char *pRepl );

/********************************************************
/* Boolean Functions
 */
eBoolean_t 
BetweenCond(Scalar_t *p, Scalar_t *pLo, Scalar_t *pHi)
{
    double d, dLo, dHi;
    if(!p || !pLo || !pHi) {
	DebugHTML(__FILE__,__LINE__,0
		,"WARN:BETWEEN:Scalar is NULL(%x between %x and %x)"
		,p
		,pLo
		,pHi
		);
	MsgPush("WARN:BETWEEN:Scalar is NULL");
	return(eFalse);
    }

    d   = ScalarToDouble(p);
    dLo = ScalarToDouble(pLo);
    dHi = ScalarToDouble(pHi);

    return( (d>=dLo && d<=dHi)?eTrue :eFalse);
}

eBoolean_t 
LikeCond(Scalar_t *p1, Scalar_t *p2)
{
    char *pStr1, *pStr2;
    if(!p1 || !p2) {
	DebugHTML(__FILE__,__LINE__,0
		,"WARN:LIKE:Scalar is NULL(%x like %x)"
		,pStr1
		,pStr2
		);
	MsgPush("WARN:LIKE:Scalar is NULL");
	return(eFalse);
    }

    pStr1 = ScalarToString(p1);
    pStr2 = ScalarToString(p2);

    DebugHTML(__FILE__,__LINE__,0,"WARN:LIKE only supports EQ.");
    DebugHTML(__FILE__,__LINE__,4,"Strcmp(%s,%s)",pStr1,pStr2);
    /* return( (strcmp(pStr1,pStr2)==0)?eTrue :eFalse );
     */
    return( bStrMatch(pStr1,pStr2) );
}

eBoolean_t 
IsNullCond(Scalar_t *p)
{
    char *pStr;

    if(!p){
	DebugHTML(__FILE__,__LINE__,2,"WARN:IS NULL:Scalar is NULL");
	return(eTrue);
    }
    pStr = ScalarToString(p);

    /*
    /* Compare STRINGS
     */
    return(pStr ? (iStrLen(pStr)==0)?eTrue :eFalse 
	        : eTrue
	  );
}

eBoolean_t 
InCond(Scalar_t *pVal, Scalar_t *pList)
{
    Scalar_t *pTop;
    if(!pVal || !pList) {
	DebugHTML(__FILE__,__LINE__,0
		,"WARN:IN:Scalar is NULL(%x in(%x))"
		,pVal
		,pList
		);
	MsgPush("WARN:IN:Scalar is NULL");
	return(eFalse);
    }
    for(pTop=DEQ(pList->uVal.pList);pTop;pTop=DEQ(pList->uVal.pList)){
	if(ISeTrue(CompareCond(MkScalarToken(EQ),pVal,pTop))){
	    return(eTrue);
	}
    }
    return(eFalse);
}

eBoolean_t 
CompareCond(Scalar_t *pOp,Scalar_t *pLeft,Scalar_t *pRight)
{
    double dLeft, dRight;
    char  *pStrLeft,*pStrRight;

    if(!pOp || !pLeft || !pRight) {
	DebugHTML(__FILE__,__LINE__,0
		,"WARN:COMPARE:Scalar is NULL(op=%x, %x op %x)"
		,pOp
		,pLeft
		,pRight
		);
	MsgPush("WARN:COMPARE:Scalar is NULL");
	return(eFalse);
    }

    /*
    /* If either operand is a number, they are all numbers 
     */
    if(ISeTrue(IsNumber(pLeft)) || ISeTrue(IsNumber(pRight)))
    {
	/* Comparing Numbers */
	dLeft = ScalarToDouble(pLeft);
	dRight= ScalarToDouble(pRight);
	return(CompareDouble(pOp->uVal.iInt,dLeft,dRight));
    }
    /*
    /* Otherwise treat them as strings
     */
    pStrLeft =ScalarToString(pLeft);
    pStrRight=ScalarToString(pRight);
    return(CompareString(pOp->uVal.iInt,pStrLeft,pStrRight));
}

/********************************************************
/* The Scalar Functions
 */
Scalar_t *
AddScalar(Scalar_t *p1, Scalar_t *p2)
{
    double d1, d2;

    if(!p1 || !p2) {
	DebugHTML(__FILE__,__LINE__,0
		,"WARN:ADD:Scalar is NULL(%x + %x)"
		,p1
		,p2
		);
	return(&gsNullScalar);
    }
    /*
    /* If either is a number convert to number...
     */
    if( ISeTrue(IsNumber(p1)) || ISeTrue(IsNumber(p2))) {
	d1 = ScalarToDouble(p1);
	d2 = ScalarToDouble(p2);

	p1->esType = eDoubleType;
	p1->uVal.dDouble = d1+d2;
	p1->lSize = 0L;
	return(p1);
    }
    return(CatScalar(p1,p2));
}

Scalar_t *
CatScalar(Scalar_t *p1, Scalar_t *p2)
{
    char *pB1,*pB2,*pRet;
    long lSize;

    if(!p1 || !p2) {
	DebugHTML(__FILE__,__LINE__,0
		,"WARN:CAT:Scalar is NULL(%x + %x)"
		,p1
		,p2
		);
	return(&gsNullScalar);
    }

    pB1=ScalarToString(p1);
    pB2=ScalarToString(p2);
    lSize = iStrLen(pB1)+iStrLen(pB2)+1; /* need room for null */

    pRet = (char*)malloc(lSize);
    if(!pRet) {
	DebugHTML(__FILE__,__LINE__,0
		,"WARN:CAT:Malloc failed(%x,%x)"
		,p1
		,p2
		);
	return(&gsNullScalar);
    }
    (void)memset(pRet,0,lSize);

    strcpy(pRet,pB1);
    strcat(pRet,pB2);
    p1->esType = eStringType;
    p1->uVal.pString = pRet;
    p1->lSize = lSize;
    return(p1);
}

Scalar_t *
SubScalar(Scalar_t *p1, Scalar_t *p2)
{
    double d1, d2;
    if(!p1 || !p2) {
	DebugHTML(__FILE__,__LINE__,0
		,"WARN:SUB:Scalar is NULL(%x - %x)"
		,p1
		,p2
		);
	return(&gsNullScalar);
    }
/*
/*   Convert to number and subtract...
 */
    d1 = ScalarToDouble(p1);
    d2 = ScalarToDouble(p2);

    p1->esType = eDoubleType;
    p1->uVal.dDouble = d1-d2;
    p1->lSize = 0;
    return(p1);
}
Scalar_t *
MultScalar(Scalar_t *p1, Scalar_t *p2)
{
    double d1, d2;
    if(!p1 || !p2) {
	DebugHTML(__FILE__,__LINE__,0
		,"WARN:MULTIPLY:Scalar is NULL(%x * %x)"
		,p1
		,p2
		);
	return(&gsNullScalar);
    }
    /* Convert to number and do it!
     */
    d1 = ScalarToDouble(p1);
    d2 = ScalarToDouble(p2);

    p1->esType = eDoubleType;
    p1->uVal.dDouble = d1*d2;
    p1->lSize = 0;
    return(p1);
}
Scalar_t *
DivScalar(Scalar_t *p1, Scalar_t *p2)
{
    double d1, d2;
    if(!p1 || !p2) {
	DebugHTML(__FILE__,__LINE__,0
		,"WARN:DIV:Scalar is NULL(%x / %x)"
		,p1
		,p2
		);
	return(&gsNullScalar);
    }
    d1 = ScalarToDouble(p1);
    d2 = ScalarToDouble(p2);
    if( (int)d2==0) {
	DebugHTML(__FILE__,__LINE__,0,"WARN:Div by Zero");
	return(&gsNullScalar);
    }

    p1->esType = eDoubleType;
    p1->uVal.dDouble = d1/d2;
    p1->lSize = 0;
    return(p1);
}
Scalar_t *
ModScalar(Scalar_t *p1, Scalar_t *p2)
{
    double d1, d2;
    if(!p1 || !p2) {
	DebugHTML(__FILE__,__LINE__,0
		,"WARN:MOD:Scalar is NULL(%x / %x)"
		,p1
		,p2
		);
	return(&gsNullScalar);
    }
    d1 = ScalarToDouble(p1);
    d2 = ScalarToDouble(p2);
    if( (int)d2==0) {
	DebugHTML(__FILE__,__LINE__,0,"WARN:Div by Zero");
	return(&gsNullScalar);
    }

    p1->esType = eDoubleType;
    p1->uVal.dDouble = (int)d1 %(int)d2;
    p1->lSize = 0;
    return(p1);
}

Scalar_t *
USubScalar(Scalar_t *p1)
{
    double d1;
    if(!p1) {
	DebugHTML(__FILE__,__LINE__,0,"WARN:USUB:Scalar is NULL(%x)",p1);
	return(&gsNullScalar);
    }
    d1 = ScalarToDouble(p1);

    p1->esType = eDoubleType;
    p1->uVal.dDouble = -d1;
    p1->lSize = 0;
    return(p1);
}

Scalar_t *
CallFunction
	(Scalar_t *pName
	,Scalar_t *pList
	)
{
    Reserved_t *pResWord;
    if(!pName || !pList) {
	DebugHTML(__FILE__,__LINE__,0
		,"WARN:CALL:Scalar is NULL(%x(%x))"
		,pName
		,pList
		);
	return(&gsNullScalar);
    }

    for(pResWord=gaReservedWordTable; pResWord->pName; pResWord++){
	if(is_casematch(pResWord->pName,pName->uVal.pString)) {
	    /* Got one!
	     */
	    return( (pResWord->pScalarFunc)(pList) );
	}
    }
    DebugHTML(__FILE__,__LINE__,0,"WARN:CALL:Unknown Function or Type.");
    return( &gsNullScalar );
}
Scalar_t *
AddScalarToList(Scalar_t *pList,Scalar_t *p1)
{
    if(!p1) {
	DebugHTML(__FILE__,__LINE__,0,"WARN:ADD LIST:Scalar is NULL(%x)",p1);
	return(&gsNullScalar);
    }
    if(!pList){
	pList=MkScalar(eListType,p1,p1->lSize);
	return(pList);
    }
    ENQ(pList->uVal.pList,p1);
    return(pList);
}

/********************************************************
/* Called by yylex and elsewhere to create a scalar when found
 */
Scalar_t *
MkScalarToken(int iToken)
{
    Scalar_t *p;
    p = (Scalar_t *)malloc(sizeof(Scalar_t));
    if(!p){
	/* out of memory */
	return(0);
    }
    (void)memset(p,0,sizeof(Scalar_t));
    p->esType = eIntType;
    p->uVal.iInt = iToken;
    p->lSize = 0;
    /* PushScalar(p);
     */
    return(p);
}

Scalar_t *
MkScalar(eScalar_t esType, void *pValue, long lSize)
{
    Scalar_t *p;
    p = (Scalar_t *)malloc(sizeof(Scalar_t));
    if(!p){
	/* out of memory */
	return(0);
    }
    (void)memset(p,0,sizeof(Scalar_t));
    p->esType = esType;
    p->lSize  = lSize;
    switch(esType) {
	case eStringType:p->uVal.pString= DupMem(pValue,lSize); break;
	case eIntType:	 p->uVal.iInt   = atoi(pValue);    break;/* Integers */
	case eDoubleType:p->uVal.dDouble= atof(pValue);    break;/* Real */
	case eListType:	 p->uVal.pList  = l_create("QUEUE");
			 ENQ(p->uVal.pList,pValue);
			 break;					/* Lists */
	case eBoolType:  p->uVal.bBool  = aToBool(pValue); break;/* Bool */
	case eRawType:   p->uVal.pRaw   = DupMem(pValue,lSize); break;
    }
    /* PushScalar(p);
     */
    return(p);
}

extern Scalar_t *
ToScalar(eBoolean_t bBool)
{
    Scalar_t *p;
    p = (Scalar_t *)malloc(sizeof(Scalar_t));
    if(!p){
	/* out of memory */
	return(0);
    }
    (void)memset(p,0,sizeof(Scalar_t));
    p->esType = eBoolType;
    p->uVal.bBool  = bBool;

    /* PushScalar(p);
     */
    return(p);
}

extern eBoolean_t
IsScalar(Scalar_t *pScalar)
{
    switch(pScalar->esType) {
	case eStringType:
	    if(is_casematch(pScalar->uVal.pString,"TRUE")) return(eTrue);
	    else return(eFalse);
	case eIntType:
	    if(pScalar->uVal.iInt) return(eTrue);
	    else return(eFalse);
	case eDoubleType:
	    if(pScalar->uVal.dDouble) return(eTrue);
	    else return(eFalse);
/*	case eListType:	 pScalar->uVal.pList  = l_create("QUEUE");
/*			 ENQ(pScalar->uVal.pList,pValue);
/*			 break;					/* Lists */
/* */
	case eBoolType:  return(pScalar->uVal.bBool);
	default: return(eFalse);
    }
    return(eFalse);
}

extern eBoolean_t
OutputScalar(Scalar_t *pScalar)
{
    OutputHTML("%s",ScalarToString(pScalar));
    return(eTrue);
}
/*
/* Internal Private Functions
/* static void
/* PushScalar(Scalar_t *p)
/* {
/*     if(!glAllScalarElements){
/* 	glAllScalarElements=l_create("QUEUE");
/*     }
/*     ENQ(glAllScalarElements,p);
/*     return;
/* }
 */

static double
ScalarToDouble(Scalar_t *p)
{
    if(!p) return(0.0);

    switch(p->esType) {
	case eStringType:return(atof(p->uVal.pString));
	case eIntType:	 return((double)p->uVal.iInt);
	case eDoubleType:return(p->uVal.dDouble);
	case eListType:	 return(0.0);