swoutput.c

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

    /* Don't forget to Flush!
     */
    FlushHTMLBuf();
    return(eTrue);
}

static eBoolean_t
GetPIFieldNameREF
    (PI *pPI
    ,char **pOutFieldName
    )
{
    DebugHTML(__FILE__,__LINE__,6,"GetPIFieldNameREF(%x,%s,?)",pPI,pPI->pTagName);
    if(is_casematch(pPI->pTagName,"INPUT")
       || is_casematch(pPI->pTagName,"TEXTAREA")
       || is_casematch(pPI->pTagName,"SELECT"))
    {
	if(ISeTrue(GetPIAValueREF(pPI,"NAME",pOutFieldName))) {
	    return(eTrue);
	}
    }
    else if(is_casematch(pPI->pTagName,"OPTION")){
	/* For options, since they are nested below SELECTs must
	/* use the PARENT's i.e. pPIContext' Attirb list to determine
	/* the NAME
	/* DebugHTML(__FILE__,__LINE__,5,"dump Core!(%x,%x)"
	/* 		,pPI
	/* 		,pPI->pPIContext);
	/* FlushHTMLBuf();
	 */
	PI *pPI2;
	for(pPI2=pPI->pPIContext;pPI2;pPI2=pPI2->pPIContext) {
	    if(ISeTrue(GetPIAValueREF(pPI2,"NAME",pOutFieldName))){
		return(eTrue);
	    }
	}
    }
    *pOutFieldName=0;
    return(eFalse);
}

/* static eBoolean_t
/* GetPIValue
/*     (PI *pPI
/*     ,char *pOutValue
/*     )
/* {
/*     /* Basically, look for a VALUE attribute
/*      */
/*     DebugHTML(__FILE__,__LINE__,5,"GetPIValue(%s)",pPI->pTagName);
/*     if(ISeTrue(GetPIAValue(pPI,"VALUE",pOutValue))){
/* 	/* Got IT! */
/* 	return(eTrue);
/*     }
/*     /* Only OPTIONS use the Contents as the backup value holder...
/*      */
/*     if(is_casematch(pPI->pTagName,"OPTION") && pPI->pPiContents){
/* 	DebugHTML(__FILE__,__LINE__,6,"GetPIValue(%s)",pPI->pPiContents);
/* 	strcpy(pOutValue,pPI->pPiContents);
/* 	return(eTrue);
/*     }
/*     
/*     /*
/*     /* Couln't find the value...
/*      */
/*     *pOutValue=0;
/*     return(eFalse);
/* }
/* */
static eBoolean_t
GetPIValueREF
    (PI *pPI
    ,char **pOutValue
    )
{
    /* Basically, look for a VALUE attribute
     */
    DebugHTML(__FILE__,__LINE__,5,"GetPIValueREF(%s)",pPI->pTagName);
    if(ISeTrue(GetPIAValueREF(pPI,"VALUE",pOutValue))){
	/* Got IT! */
	return(eTrue);
    }
    /* Only OPTIONS use the Contents as the backup value holder...
     */
    if(is_casematch(pPI->pTagName,"OPTION") && pPI->pPiContents){
	DebugHTML(__FILE__,__LINE__,6,"GetPIValueREF(%s)",pPI->pPiContents);
	(*pOutValue)=pPI->pPiContents;
	return(eTrue);
    }
    
    /*
    /* Couln't find the value...
     */
    (*pOutValue)=DupBuf(0);
    return(eFalse);
}

static eBoolean_t
GetPITagType
    (PI *pPI
    ,char **pOutType
    )
{
    if(ISeTrue(GetPIAValueREF(pPI,"TYPE",pOutType))) {
	/* Got it! */
	return(eTrue);
    }
    /* Default is TEXT
     */
    (*pOutType) = "TEXT";
    return(eTrue);
}

static eBoolean_t
SetPIValue
    (PI *pPI
    ,char *pValue
    )
{
    char *pType
	,*pValue2
	;

    DebugHTML(__FILE__,__LINE__,5,"SetPIValue(%s,%s)",pPI->pTagName,pValue);

    if(is_casematch(pPI->pTagName,"INPUT")) {
	RETeFalse(GetPITagType(pPI,&pType)
		 ,"GetPITagType failed"
		 );
	/* TYPE in(TEXT,PASSWORD)
	/* set VALUE Attribute to pValue
	 */
	if(    is_casematch(pType,"TEXT")
	    || is_casematch(pType,"PASSWORD")
	    || is_casematch(pType,"HIDDEN"))
	{
	    if(!pValue || !(*pValue)){
		/* Delete VALUE Attrib, since it's value is NULL
		/* If it works, it works!
		 */
		SYMBOL *p;
		p=l_delete(pPI->lPIA,l_find,iCmpSymbolpName,"VALUE");
		if(p){
		    FreePIA(p);
		}
	    } else {
		DebugHTML(__FILE__,__LINE__,5,"SettingV(%s,%s)",pType,pValue);
		return( SetPIAValue(pPI,"VALUE",pValue));
	    }
	}
	/* TYPE in(CHECKBOX,RADIO)
	/* Set CHECKED Attribute
	 */
	if(is_casematch(pType,"RADIO") || is_casematch(pType,"CHECKBOX")){
	    if(ISeFalse(GetPIValueREF(pPI,&pValue2))){
		pValue= "on"; /* Value is set to "on" when
			     /* there is no VALUE attrib */
	    }
	    /*
	    /* On a MATCH, SET/Create the CHECKED ATTRIBUTE
	     */
	    if(is_match(pValue2,pValue)){
		return( SetPIAValue(pPI,"CHECKED",""));
	    /*
	    /* No Match -- make sure the CHECKED ATTRIBUTE is Gone!
	     */
	    } else {
		SYMBOL *p;
		p=l_delete(pPI->lPIA,l_find,iCmpSymbolpName,"CHECKED");
		if(p) {
		    FreePIA(p);
		}
	    }
	    return(eTrue);
	}
    }
    if(is_casematch(pPI->pTagName,"TEXTAREA")){
	while(*pValue == '\n') ++pValue;
		/* Mosaic tends to stick leading '\n' is there
		 */
	FreeBuf(pPI->pPiContents);
	pPI->pPiContents = DupBuf(pValue);
	return(eTrue);
	/* strcpy(pOutValue,pPI->pPiContents);
	 */
    }
    /*
    /* OPTION TAG that has a VALUE
     */
    if(is_casematch(pPI->pTagName,"OPTION")
	&& ISeTrue(GetPIValueREF(pPI,&pValue2)))
    {
	/*
	/* IF Symbol VALUE Matches this OPTION
	/* Set the SELECTED ATTRIBUTE
	 */
	if( is_match(pValue2,pValue)) {
	    if(ISeFalse( SetPIAValue(pPI,"SELECTED",""))){
		MsgPush("SetPIAValue failed on OPTION");
		return(eFalse);
	    } else {
		DebugHTML(__FILE__,__LINE__,5,"Set OPTION:%s",pValue);
		return(eTrue);
	    }
	/*
	/* IF the VALUES Don't match make sure the 
	/* SELECTED ATTRIBUTE is DELETED
	 */
	} else {
	    SYMBOL *p;
	    /* If they don't match, erase the SELECTED attribute 
	     */
	    p=l_delete(pPI->lPIA,l_find,iCmpSymbolpName,"SELECTED");
	    if(p){
		FreePIA(p);
	    }
	}
    }
    return(eTrue);
}

/* eBoolean_t
/* GetPIAValue
/*     (PI *pPI
/*     ,char *pName
/*     ,char *pOutValue
/*     )
/* {
/*     SYMBOL *pSym;
/*     DebugHTML(__FILE__,__LINE__,5,"GetPIAValue(%x,%s,...)",pPI,pName);
/* 
/*     if(!pPI) {
/* 	*pOutValue=0;
/* 	return(eFalse);
/*     }
/* 
/*     pSym=l_find(pPI->lPIA,iCmpSymbolpName,pName);
/*     if(!pSym){
/* 	*pOutValue=0;
/* 	return(eFalse);
/*     }
/*     strcpy(pOutValue,pSym->pValue);
/*     return(eTrue);
/* }
 */
eBoolean_t
GetPIAValueREF
    (PI *pPI
    ,char *pName
    ,char **pOutValue
    )
{
    SYMBOL *pSym;
    DebugHTML(__FILE__,__LINE__,5,"GetPIAValueREF(%x,%s,...)",pPI,pName);

    if(!pPI) {
	(*pOutValue)=DupBuf(0);
	return(eFalse);
    }

    pSym=l_find(pPI->lPIA,iCmpSymbolpName,pName);
    if(!pSym){
	(*pOutValue)=DupBuf(0);
	return(eFalse);
    }
    (*pOutValue) = pSym->pValue;
    return(eTrue);
}

static eBoolean_t
SetPIAValue
    (PI *pPI
    ,char *pName
    ,char *pValue
    )
{
    SYMBOL *pSym;

    DebugHTML(__FILE__,__LINE__,6,"setPIAValue(%s,%s)",pName,pValue);

    pSym=l_find(pPI->lPIA,iCmpSymbolpName,pName);
    if(!pSym){
	pSym = NewPIA();
	if(!pSym){
	    MsgPush("NewPIA failed");
	    return(eFalse);
	}
	/* (void)memset((pSym),0,sizeof(SYMBOL));
	 */
	pSym->iType=0;	/* Not used, best init it, though */
	pSym->pName=DupBuf(pName);
	pSym->pValue=DupBuf(pValue);
	return( ENQ(pPI->lPIA,pSym) );
    }
    /* toss origional value
     */
    FreeBuf(pSym->pValue);
    pSym->pValue = DupBuf(pValue);
    return(eTrue);
}

static void
RawOutputHTML(char *p)
{
    FlushHTMLBuf();
    fprintf(stdout,"%s",p);
    fflush (stdout);
    return;
}

eBoolean_t
DumpPage(PAGE *pPage)
{
    eBoolean_t bRet;
    bRet=l_scan(pPage->lPI,(PFI)DumpPI);
    fprintf(stdout,"\n");
    return(bRet);
}
static eBoolean_t
DumpPI(PI *pPI)
{
    if(!pPI)
	return(eTrue);

    fprintf(stdout,"\n%*s%s (line=%d) (depth=%d) "
	   ,(pPI->iLevel)*2 ," "
	   ,pPI->pTagName
	   ,pPI->iLineNbr
	   ,pPI->iLevel
	   );
    (void)l_scan(pPI->lPIA,(PFI)DumpPIA);

    if(l_size(pPI->lPI)>0) {
	RETeFalse( l_scan(pPI->lPI,(PFI)DumpPI)
		 ,"Recursive call failed"
		 );

	fprintf(stdout,"\n%*s/%s"
		,(pPI->iLevel)*2 ," "
		,pPI->pTagName
		);
    }
    return(eTrue);
}
static eBoolean_t
DumpPIA(SYMBOL *pPIA)
{
    char sBuf[BUFSIZ];

    (void)memset(sBuf,0,BUFSIZ);
    if(pPIA->pValue)
	strncpy(sBuf,pPIA->pValue,10);
    fprintf(stdout,"(%s=%s)",pPIA->pName,sBuf);
    return(eTrue);
}