scalar.c

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

	case eBoolType:  return ISeTrue(p->uVal.bBool) ? 1.0 :0.0 ;
	default:	 return(0.0);
    }
    return(0.0);
}

static char *
ScalarToString(Scalar_t *p)
{
    char sBuf[BUFSIZ];
    char *pNullStr = "";
    int iLen;
    if(!p) {
	DebugHTML(__FILE__,__LINE__,0,"ToStr:NULLStr");
	return(pNullStr);
    }

    DebugHTML(__FILE__,__LINE__,5,"ToStr:%s.%d(%d),%s"
	    ,p->esType==eStringType    ?"S"
		:p->esType==eIntType   ?"I"
		:p->esType==eDoubleType?"D"
		:p->esType==eListType  ?"L"
		:p->esType==eBoolType  ?"B"
		:p->esType==eRawType   ?"R"
		:"?"
	    ,p->lSize
	    ,p->esType==eStringType?iStrLen(p->uVal.pString):-1
	    ,p->esType==eStringType && p->uVal.pString?p->uVal.pString:"*?*"
	    );
    switch(p->esType) {
	case eStringType:
			if(p->lSize==0) {
			    return(DupBuf(0));
			}
			/* if(p->uVal.pString && p->lSize>=0)
			/*    *(p->uVal.pString + p->lSize)=0; /* set NULL */
			/* */
			
			return(p->uVal.pString);
	case eIntType:	sprintf(sBuf,"%d",p->uVal.iInt);
			return(DupBuf(sBuf));
	case eDoubleType:
			sprintf(sBuf,"%f",p->uVal.dDouble);
			if(strchr(sBuf,'.')) {
			    /* Strip Trailing zeros, if decpt
			     */
			    iLen = iStrLen(sBuf);
			    while( sBuf[--iLen] == '0')
				sBuf[iLen]=0;
			    if(sBuf[iLen] == '.')
				sBuf[iLen]=0;
			}
			return(DupBuf(sBuf));
	case eListType: return(pNullStr);
	case eBoolType: return(ISeTrue(p->uVal.bBool)?"TRUE":"FALSE");
	default:
	    DebugHTML(__FILE__,__LINE__,0,"ToStr:Unknown Type %d",p->esType);
    }
    return(pNullStr);
}
static eBoolean_t
aToBool(char *p)
{
    if(is_casematch(p,"FALSE")) return(eFalse);
    if(is_casematch(p,"TRUE") )  return(eTrue);
    return(eTrue);
}

static eBoolean_t
CompareDouble(int iOp,double dLeft,double dRight)
{
    switch(iOp){
	case EQ:  return( (dLeft==dRight)   ?eTrue:eFalse);
	case NEQ: return( (!(dLeft==dRight))?eTrue:eFalse);
	case GT:  return( (dLeft>dRight)    ?eTrue:eFalse);
	case GE:  return( (dLeft>=dRight)   ?eTrue:eFalse);
	case LT:  return( (dLeft<dRight)    ?eTrue:eFalse);
	case LE:  return( (dLeft<=dRight)   ?eTrue:eFalse);
    }
    DebugHTML(__FILE__,__LINE__,0,"WARN:COMPARE DBL:Unknown OP:%d",iOp);
    return(eFalse);
}

static eBoolean_t
CompareString(int iOp,char *pLeft,char *pRight)
{
    DebugHTML(__FILE__,__LINE__,2,"COMPARE STR:%s %d %s",pLeft,iOp,pRight);
    switch(iOp){
	case EQ:  return(is_match(pLeft,pRight)   ?eTrue:eFalse);
	case NEQ: return(!(is_match(pLeft,pRight))?eTrue:eFalse);
	case GT:  return((iStrCmp(pLeft,pRight)>0)    ?eTrue:eFalse);
	case GE:  return((iStrCmp(pLeft,pRight)>=0)   ?eTrue:eFalse);
	case LT:  return((iStrCmp(pLeft,pRight)<0)    ?eTrue:eFalse);
	case LE:  return((iStrCmp(pLeft,pRight)<=0)   ?eTrue:eFalse);
    }
    DebugHTML(__FILE__,__LINE__,0,"WARN:COMPARE STR:Unknown OP:%d",iOp);
    MsgPush("WARN:COMPARE STR:Unknown OP:%d",iOp);
    return(eFalse);
}

static eBoolean_t
IsNumber(Scalar_t *p)
{
    if(!p){
	DebugHTML(__FILE__,__LINE__,0,"IsNumber:Scalar is NULL");
	MsgPush("IsNumber:Scalar is NULL");
	return(eFalse);
    }

    if(p->esType==eDoubleType || p->esType==eIntType)
	return(eTrue);
    return(eFalse);
}

Scalar_t *
ScalarUpper(Scalar_t *pList)
{
    Scalar_t *pTop;
    char sBuf[MAX_BUFSIZ];

    DebugHTML(__FILE__,__LINE__,3,"Called Upper(%x)",pList);
    if(!pList){
	DebugHTML(__FILE__,__LINE__,0,"ScalarUpper:Scalar is NULL(%x)",pList);
	MsgPush("ScalarUpper:Scalar is NULL");
	return(&gsNullScalar);
    }
    if(pList->esType != eListType) {
	DebugHTML(__FILE__,__LINE__,0,"WARN:UPPER:Invalid arg type passed to Function");
	return(&gsNullScalar);
    }
    sBuf[0]=0;
    while( (pTop = (Scalar_t *)DEQ(pList->uVal.pList)) ) {
	char *pTmp = ScalarToString(pTop);
	strcat(sBuf,pTmp);
    }
    ToUpper(sBuf);
    return(MkScalar(eStringType,sBuf,1+iStrLen(sBuf)));
}

Scalar_t *
ScalarLower(Scalar_t *pList)
{
    Scalar_t *pTop;
    char sBuf[MAX_BUFSIZ];

    if(!pList) {
	DebugHTML(__FILE__,__LINE__,0,"ScalarLower:Scalar is NULL(%x)",pList);
	MsgPush("ScalarLower:Scalar is NULL");
	return(&gsNullScalar);
    }
    if(pList->esType != eListType) {
	DebugHTML(__FILE__,__LINE__,0,"WARN:LOWER:Invalid arg type passed to Function");
	return(&gsNullScalar);
    }
    sBuf[0]=0;
    while( (pTop = (Scalar_t *)DEQ(pList->uVal.pList)) ) {
	char *pTmp = ScalarToString(pTop);
	strcat(sBuf,pTmp);
    }
    ToLower(sBuf);
    return(MkScalar(eStringType,sBuf,1+iStrLen(sBuf)));
}
Scalar_t *
ScalarSubstr(Scalar_t *pList)
{
    char *pTmp;
    int iSize,iOffset,iLength;
    Scalar_t *pString = 0
	    ,*pOffset = 0
	    ,*pLength = 0
	;
    if(!pList){
	DebugHTML(__FILE__,__LINE__,0,"ScalarSubstr:Scalar is NULL(%x)",pList);
	MsgPush("ScalarSubstr:Scalar is NULL");
	return(&gsNullScalar);
    }
    iSize = l_size(pList->uVal.pList);
    if(iSize==2){
	pString=(Scalar_t *)DEQ(pList->uVal.pList);
	pOffset=(Scalar_t *)DEQ(pList->uVal.pList);

	pTmp   = ScalarToString(pString);
	iOffset= (int)ScalarToDouble(pOffset);
	if(iOffset<iStrLen(pTmp)) {
	    pString->esType = eStringType;
	    pString->uVal.pString = (pTmp+iOffset);
	    pString->lSize = 1+iStrLen(pString->uVal.pString);
	    return(pString);
	}
    } else if (iSize==3) {
	pString=(Scalar_t *)DEQ(pList->uVal.pList);
	pOffset=(Scalar_t *)DEQ(pList->uVal.pList);
	pLength=(Scalar_t *)DEQ(pList->uVal.pList);

	pTmp   = ScalarToString(pString);
	iOffset= (int)ScalarToDouble(pOffset);
	iLength= (int)ScalarToDouble(pLength);

	/* Reusing iSize as length of first arg */
	iSize = iStrLen(pTmp);
	if(iOffset<iSize) {
	    pString->uVal.pString = (pTmp + iOffset);
	    if((iOffset+iLength) <iSize)
		*(pTmp + iOffset + iLength) = 0;
	    pString->esType = eStringType;
	    pString->lSize = 1+iStrLen(pString->uVal.pString);
	    return(pString);
	}
    } else {
	DebugHTML(__FILE__,__LINE__,0,"WARN:SUBSTR:Invalid args to Substr");
    }
    return(&gsNullScalar);
}

Scalar_t *
ScalarLength(Scalar_t *pList)
{
    Scalar_t *pTop;
    int iLen=0, lLen=0;
    char sLenBuf[MAX_INTEGER_DIGITS];

    if(!pList){
	DebugHTML(__FILE__,__LINE__,0,"ScalarLength:Scalar is NULL(%x)",pList);
	MsgPush("ScalarLength:Scalar is NULL");
	return(&gsNullScalar);
    }
    if(pList->esType != eListType) {
	DebugHTML(__FILE__,__LINE__,0
		 ,"WARN:LENGTH:Invalid arg type passed to Function"
		 );
	return(&gsNullScalar);
    }
    iLen=0, lLen=0;
    while( (pTop = (Scalar_t *)DEQ(pList->uVal.pList)) ) {
	/* char *pTmp = ScalarToString(pTop);
	/* iLen += iStrLen(pTmp);
	 */
	lLen += (pTop->lSize>0)?(pTop->lSize) -1:0;
	/* DebugHTML(__FILE__,__LINE__,0,"lSize=%d",lLen);
	 */
    }
    sprintf(sLenBuf,"%d",lLen);
    return(MkScalar(eDoubleType, sLenBuf,1+iStrLen(sLenBuf)));
}

Scalar_t *
ScalarNVL(Scalar_t *pList)
{
    Scalar_t *pTop;

    DebugHTML(__FILE__,__LINE__,3,"Called NVL");

    if(!pList){
	DebugHTML(__FILE__,__LINE__,0,"ScalarNVL:Scalar is NULL(%x)",pList);
	MsgPush("ScalarNVL:Scalar is NULL");
	return(&gsNullScalar);
    }
    pTop = (Scalar_t *)DEQ(pList->uVal.pList);
    if(IsNullCond(pTop)) {
	DebugHTML(__FILE__,__LINE__,2,"NVL:NULL Condition");
	return((Scalar_t *)DEQ(pList->uVal.pList));
    }
    DebugHTML(__FILE__,__LINE__,2,"NVL:NOT NULL Condition");
    return(pTop);
}

Scalar_t *
ScalarHost(Scalar_t *pList)
{
    Scalar_t *pTop;
    char sBuf[MAX_BUFSIZ];
    int c, iCharCount, iStatus;
    FILE *pF;

#ifdef WIN32
    MsgPush("SQLweb/NT: Doesn't Support HOST");
    return(&gsNullScalar);
#endif

#ifndef WIN32
    {
    DebugHTML(__FILE__,__LINE__,3,"Called Host");

    if(!pList){
	DebugHTML(__FILE__,__LINE__,0,"ScalarHost:Scalar is NULL(%x)",pList);
	MsgPush("ScalarHost:Scalar is NULL");
	return(&gsNullScalar);
    }
    sBuf[0]=0;
    while( (pTop = (Scalar_t *)DEQ(pList->uVal.pList)) ) {
	char *pTmp = ScalarToString(pTop);
	strcat(sBuf,pTmp);
    }

    DebugHTML(__FILE__,__LINE__,2,"Running: `%s`",sBuf);

    pF = popen(sBuf,"r");
    if(!pF){
	DebugHTML(__FILE__,__LINE__,0,"POpen Failed: (%s)",sBuf);
	MsgPush("Host:Can't popen(%s,\"r\")", sBuf);
	return(&gsNullScalar);
    }

    DebugHTML(__FILE__,__LINE__,3,"Open'd(%x)",pF);
    for( c=fgetc(pF), iCharCount=0
	;c != EOF && iCharCount<MAX_BUFSIZ
	;c=fgetc(pF), iCharCount++ )
    {
	sBuf[iCharCount] = c;
    }
    /*
    /* NULL the string...
     */
    if(iCharCount && sBuf[iCharCount-1]=='\n')
	 sBuf[iCharCount-1]=0;
    else sBuf[iCharCount] = 0;

    DebugHTML(__FILE__,__LINE__,3,"Read %d chars",iCharCount);
    iStatus = pclose(pF);
    DebugHTML(__FILE__,__LINE__,3,"popen:%d:%d",iStatus,c);
    return(MkScalar(eStringType, sBuf,1+iStrLen(sBuf)));
    }
#endif
}

Scalar_t *
ScalarSaveFile(Scalar_t *pList)
{
    Scalar_t *pScalarFileName
	    ,*pScalarData
	    ;
    char *pFileName;
    long lSize;
    int iListSize;
    FILE *pF;

    DebugHTML(__FILE__,__LINE__,3,"Called SaveFile");
    if(!pList){
	DebugHTML(__FILE__,__LINE__,0,"SaveFile:Scalar is NULL(%x)",pList);
	MsgPush("ScalarSaveFile:Scalar is NULL");
	return(&gsNullScalar);
    }

    /*
    /* Check number of parameters (the USAGE)
     */
    iListSize = l_size(pList->uVal.pList);
    if(iListSize != 2) {
	DebugHTML(__FILE__,__LINE__,0
		 ,"WARN:SAVEFILE:USAGE:SaveFile(filename,data)"
		 );
	MsgPush("ScalarSaveFile:Scalar is NULL");
	return(&gsNullScalar);
    }

    /*
    /* Get Filename 
     */
    pScalarFileName = (Scalar_t *)DEQ(pList->uVal.pList);
    pScalarData = (Scalar_t *)DEQ(pList->uVal.pList);

    pFileName = ScalarToString(pScalarFileName);
    pF=fopen(pFileName,"w");
    if(!pF){
	DebugHTML(__FILE__,__LINE__,0,"SaveFile:Open Failed:%d",errno);
	MsgPush("ScalarSaveFile:Open Failed");
	return(&gsNullScalar);
    }
    lSize = pScalarData->lSize;
    lSize = fwrite(pScalarData->uVal.pString,lSize,1,pF);
    fclose(pF);

    pScalarFileName->esType = eBoolType;
    pScalarFileName->uVal.bBool = lSize==1?eTrue:eFalse;
    pScalarFileName->lSize = 0;
    return(pScalarFileName);
}

Scalar_t *
ScalarToChar(Scalar_t *pList)
{
    char *pFmtStr
	 ,*pInpStr
	 ,sBuf[BUFSIZ]
	 ;
    int iSize;
    Scalar_t *pInput = 0
	    ,*pFormat = 0
	;
    if(!pList){
	DebugHTML(__FILE__,__LINE__,0,"ScalarToChar:Scalar is NULL(%x)",pList);
	MsgPush("ScalarToChar:Scalar is NULL");
	return(&gsNullScalar);
    }
    iSize = l_size(pList->uVal.pList);
    if(iSize!=2){
	DebugHTML(__FILE__,__LINE__,0,"WARN:TO_CHAR:usage error:to_char(input,fmt)");
	return(&gsNullScalar);
    }
    /* Get the Parameters
     */
    pInput =(Scalar_t *)DEQ(pList->uVal.pList);
    pFormat=(Scalar_t *)DEQ(pList->uVal.pList);

    /* Convert Each Parameter to a string
     */
    pInpStr= ScalarToString(pInput);
    pFmtStr= ScalarToString(pFormat);

    /*
    /* Convert input string using format mask
     */
    FormatString(pInpStr,pFmtStr,sBuf);
    return(MkScalar(eStringType, sBuf,1+iStrLen(sBuf)));
}

Scalar_t *
ScalarToNumber(Scalar_t *pList)
{
    int  iDotFlag = 0
	,iDigFlag = 0;
    Scalar_t *pScalar;
    char *pInStr;
    char sBuf[MAX_BUFSIZ], *psBuf=sBuf;

    /* fprintf(stderr,"ToNumber(!)\n");fflush(stderr);
     */
    if(!pList){
	DebugHTML(__FILE__,__LINE__,0,"ScalarToNumber:Scalar is NULL(%x)",pList);
	MsgPush("ScalarToNumber:Scalar is NULL");
	return(&gsNullScalar);
    }

    pScalar = DEQ(pList->uVal.pList);
    pInStr = ScalarToString(pScalar);

    for( ; *pInStr; pInStr++) {
	switch(*pInStr){
	    case '-' : 
		if(iDigFlag) break;
	    case '.' : 
		if(iDotFlag) break;
		iDotFlag=1;
	    case '0' :
	    case '1' :
	    case '2' :
	    case '3' :
	    case '4' :
	    case '5' :
	    case '6' :
	    case '7' :
	    case '8' :
	    case '9' :
		iDigFlag=1;
		*psBuf++ = *pInStr;
		break;
	} /* end of switch */
    } /* end of for */
    *psBuf = '\0';
    /* fprintf(stderr,"ToNumber(%s)\n",sBuf);fflush(stderr);
     */
    return(MkScalar(eStringType,sBuf,1+iStrLen(sBuf)));
}

Scalar_t *
ScalarLPad(Scalar_t *pList)
{
    int		 iSize
		,iPadSize
		;
    Scalar_t 	 *pSource
		,*pSize
		,*pChar
		;
    char	 *pStrSource
		,*pStrChar = " "
		,sBuf[MAX_BUFSIZ]
		;

    /* fprintf(stderr,"LPad(!)\n");fflush(stderr);
     */
    if(!pList){
	DebugHTML(__FILE__,__LINE__,0,"ScalarLPad:Scalar is NULL(%x)",pList);
	MsgPush("ScalarLPad:Scalar is NULL");
	return(&gsNullScalar);
    }

    iSize = l_size(pList->uVal.pList);
    if(iSize != 2 && iSize !=3) {
	DebugHTML(__FILE__,__LINE__,0,"WARN:LPAD:USAGE:LPad(input,size[,padchar])");
	return(&gsNullScalar);
    }
    pSource = DEQ(pList->uVal.pList);
    pSize   = DEQ(pList->uVal.pList);
    if(iSize == 3) {
	pChar = DEQ(pList->uVal.pList);
    }
    pStrSource = ScalarToString(pSource);
    iPadSize = (int)ScalarToDouble(pSize);
    pStrChar = ScalarToString(pChar);

    if(iPadSize >= MAX_BUFSIZ) {
	DebugHTML(__FILE__,__LINE__,0
		,"WARN:LPAD:overflow, truncated to %d",MAX_BUFSIZ);
	iPadSize = MAX_BUFSIZ -1;
    }

    memset(sBuf, *pStrChar, iPadSize);
    sBuf[iPadSize] = 0;

    strcpy(&sBuf[iPadSize-iStrLen(pStrSource)],pStrSource);