/*								      CSParse.c**	PICS CONFIGURATION MANAGER FOR CLIENTS AND SERVERS****	(c) COPYRIGHT MIT 1995.**	Please first read the full copyright statement in the file COPYRIGHT.****	This module converts application/xpics streams (files or network) to PICS_ class data**** History:**	 4 Dec 95  EGP  start**	15 Feb 96  EGP  alpha 1**** BUGS: no code yet; doesn't actually do anything*//* Library include files */#include "wwwsys.h"#include "HTChunk.h"#include "HTString.h"#include "CSLUtils.h"#include "CSParse.h"PUBLIC int ParseDebug = 0;	/* For use with LablPars and RatPars */PUBLIC BOOL BVal_readVal(BVal_t * pBVal, const char * valueStr){    if (!strcasecomp(valueStr, "true") ||         !strcasecomp(valueStr, "yes"))        pBVal->state = BVal_YES;    else if (strcasecomp(valueStr, "false") &&              strcasecomp(valueStr, "no"))        return NO;;    pBVal->state |= BVal_INITIALIZED;    return YES;}PUBLIC BOOL BVal_initialized(const BVal_t * pBVal){    return (pBVal->state & BVal_INITIALIZED);}PUBLIC BOOL BVal_value(const BVal_t * pBVal){    return ((pBVal->state & BVal_YES) ? 1 : 0);}PUBLIC void BVal_set(BVal_t * pBVal, BOOL value){	if (value)		pBVal->state = BVal_YES;    pBVal->state |= BVal_INITIALIZED;    return;}PUBLIC void BVal_clear(BVal_t * pBVal){    if (pBVal)      pBVal->state = BVal_UNINITIALIZED;    return;}PUBLIC BOOL FVal_readVal(FVal_t * pFVal, const char * valueStr){    if (!strcasecomp(valueStr, "+INF")) {        pFVal->stat = FVal_POSITIVE_INF;        return YES;    }    if (!strcasecomp(valueStr, "-INF")) {        pFVal->stat = FVal_NEGATIVE_INF;        return YES;    }    pFVal->stat = FVal_VALUE;    sscanf(valueStr, "%f", &pFVal->value);    return YES;}PUBLIC BOOL FVal_initialized(const FVal_t * pFVal){    return (pFVal->stat != FVal_UNINITIALIZED);}PUBLIC float FVal_value(const FVal_t * pFVal){    return (pFVal->value);}/* C U T T I N G   E D G E   M A T H   T E C H N O L O G Y   H E R E */PUBLIC BOOL FVal_lessThan(const FVal_t * pSmall, const FVal_t * pBig){    if (pBig->stat == FVal_UNINITIALIZED || pSmall->stat == FVal_UNINITIALIZED)        return FALSE;    if (pBig->stat == FVal_POSITIVE_INF || pSmall->stat == FVal_NEGATIVE_INF) {        if (pSmall->stat == FVal_POSITIVE_INF)            return FALSE;        return TRUE;    }    if (pBig->stat == FVal_NEGATIVE_INF || pSmall->stat == FVal_POSITIVE_INF) {        return FALSE;    }    return pSmall->value < pBig->value;}PUBLIC FVal_t FVal_minus(const FVal_t * pBig, const FVal_t * pSmall){    FVal_t ret = FVal_NEW_UNINITIALIZED;    /* no notion of 2 time infinity so please keep your limits to a minimum */    if (pBig->stat == FVal_UNINITIALIZED || pSmall->stat == FVal_UNINITIALIZED)        return ret;    FVal_set(&ret, (float)0.0);    if (pBig->stat == FVal_POSITIVE_INF || pSmall->stat == FVal_NEGATIVE_INF) {        if (pSmall->stat != FVal_POSITIVE_INF)            FVal_setInfinite(&ret, 0);        return ret;    }    if (pBig->stat == FVal_NEGATIVE_INF || pSmall->stat == FVal_POSITIVE_INF) {        if (pSmall->stat != FVal_NEGATIVE_INF)            FVal_setInfinite(&ret, 0);        return ret;    }    ret.value = pBig->value - pSmall->value;    return (ret);}PUBLIC BOOL FVal_nearerZero(const FVal_t * pRef, const FVal_t * pCheck){    if (pRef->stat == FVal_UNINITIALIZED || pCheck->stat == FVal_UNINITIALIZED ||         pCheck->stat == FVal_POSITIVE_INF || pCheck->stat == FVal_NEGATIVE_INF)        return NO;    if (pRef->stat == FVal_POSITIVE_INF || pRef->stat == FVal_NEGATIVE_INF)        return YES;    if (pRef->value < 0.0) {        if (pCheck->value < 0.0)            return pCheck->value > pRef->value;        return pCheck->value < -pRef->value;    }    if (pCheck->value < 0.0)        return pCheck->value > -pRef->value;    return pCheck->value < pRef->value;}PUBLIC BOOL FVal_isZero(const FVal_t * pFVal){    if (pFVal->stat == FVal_VALUE && pFVal->value == 0.0)        return YES;    return NO;}PUBLIC void FVal_set(FVal_t * pFVal, float value){    pFVal->value = value;    pFVal->stat = FVal_VALUE;}PUBLIC void FVal_setInfinite(FVal_t * pFVal, BOOL negative){    pFVal->stat = negative ? FVal_NEGATIVE_INF : FVal_POSITIVE_INF;}PUBLIC int FVal_isInfinite(const FVal_t * pFVal){    return (pFVal->stat == FVal_POSITIVE_INF ? 1 : pFVal->stat == FVal_NEGATIVE_INF ? -1 : 0);}PUBLIC void FVal_clear(FVal_t * pFVal){    if (pFVal)      pFVal->stat = FVal_UNINITIALIZED;    return;}PUBLIC char * FVal_toStr(FVal_t * pFVal){    char * ptr;    if ((ptr = (char *)HT_MALLOC(40)) == NULL)	HT_OUTOFMEM("FVal buffer");    sprintf(ptr, "%.1f", FVal_value(pFVal));    return ptr;}PUBLIC BOOL SVal_readVal(SVal_t * pSVal, const char * valueStr){    pSVal->initialized = YES;    StrAllocCopy(pSVal->value, valueStr);    return YES;}PUBLIC BOOL SVal_initialized(const SVal_t * pSVal){    return (pSVal->initialized != NO);}PUBLIC char * SVal_value(const SVal_t * pSVal){    return (pSVal->value);}PUBLIC void SVal_clear(SVal_t * pSVal){    if (SVal_initialized(pSVal)) {      HT_FREE(pSVal->value);      pSVal->initialized = NO;      }    return;}#if 0    int year;    int month;    int day;    int hour;    int minute;    int timeZoneHours;    int timeZoneMinutes;#endifPUBLIC BOOL DVal_readVal(DVal_t * pDVal, const char * valueStr){    char space[] = "1994.11.05T08:15-0500";    char timeZoneSign;    char timeZoneMinutesMSB;    if (strlen(valueStr) != 0x15)        return NO;    memcpy(space, valueStr, 0x15);    timeZoneSign = space[16];    timeZoneMinutesMSB = space[19];    space[4] = space[7] = space[10] = space[13] = space[16] = space[19] = 0;    pDVal->year = atoi(space);    pDVal->month = atoi(space+5);    pDVal->day = atoi(space+8);    pDVal->hour = atoi(space+11);    pDVal->minute = atoi(space+14);    pDVal->timeZoneHours = atoi(space+17);    space[19] = timeZoneMinutesMSB;    pDVal->timeZoneMinutes = atoi(space+19);    if (timeZoneSign == '-') {        pDVal->timeZoneHours = -pDVal->timeZoneHours;        pDVal->timeZoneMinutes = -pDVal->timeZoneMinutes;    }    StrAllocCopy(pDVal->value, valueStr);    pDVal->initialized = YES;    return YES;}PUBLIC BOOL DVal_initialized(const DVal_t * pDVal){    return (pDVal->initialized != NO);}PUBLIC int DVal_compare(const DVal_t * a, const DVal_t * b){    if (a->year > b->year) return 1;    if (a->year < b->year) return -1;    if (a->month > b->month) return 1;    if (a->month < b->month) return -1;    if (a->day > b->day) return 1;    if (a->day < b->day) return -1;    if (a->hour+a->timeZoneHours > b->hour+b->timeZoneHours) return 1;    if (a->hour+a->timeZoneHours < b->hour+b->timeZoneHours) return -1;    if (a->minute+a->timeZoneMinutes > b->minute+b->timeZoneMinutes) return 1;    if (a->minute+a->timeZoneMinutes < b->minute+b->timeZoneMinutes) return -1;    return 0;}PUBLIC char * DVal_value(const DVal_t * pDVal){    return (pDVal->value);}PUBLIC void DVal_clear(DVal_t * pDVal){    if (DVal_initialized(pDVal)) {        HT_FREE(pDVal->value);	pDVal->initialized = NO;    }    return;}PUBLIC char * Range_toStr(Range_t * pRange){    HTChunk * pChunk;    char * ptr;    pChunk = HTChunk_new(20);    ptr = FVal_toStr(&pRange->min);    HTChunk_puts(pChunk, ptr);    HT_FREE(ptr);    if (FVal_initialized(&pRange->max)) {        ptr = FVal_toStr(&pRange->max);	HTChunk_puts(pChunk, ":");	HTChunk_puts(pChunk, ptr);	HT_FREE(ptr);    }    return HTChunk_toCString(pChunk);}/* Range_gap - find gap between 2 ranges. Either of these ranges may be a  * single value (in the min) * negative vector indicates that ref is greater than test */PUBLIC FVal_t Range_gap(Range_t * a, Range_t * b){    Range_t aN = *a;    Range_t bN = *b;    FVal_t ret = FVal_NEW_UNINITIALIZED;    if (!FVal_initialized(&a->min) || !FVal_initialized(&b->min))        return (ret);    /* set ret for successful 0 returns */    FVal_set(&ret, (float)0.0);    /* normalize our ranges */    if (FVal_lessThan(&aN.max, &aN.min)) {        aN.max = a->min;        aN.min = a->max;    }    if (FVal_lessThan(&bN.max, &bN.min)) {