home *** CD-ROM | disk | FTP | other *** search
/ Tools / WinSN5.0Ver.iso / NETSCAP.50 / WIN1998.ZIP / ns / lib / libpics / csparse.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-04-08  |  23.9 KB  |  700 lines
  1.  
  2. /*  W3 Copyright statement 
  3. Copyright 1995 by: Massachusetts Institute of Technology (MIT), INRIA</H2>
  4.  
  5. This W3C software is being provided by the copyright holders under the
  6. following license. By obtaining, using and/or copying this software,
  7. you agree that you have read, understood, and will comply with the
  8. following terms and conditions: 
  9.  
  10. Permission to use, copy, modify, and distribute this software and its
  11. documentation for any purpose and without fee or royalty is hereby
  12. granted, provided that the full text of this NOTICE appears on
  13. <EM>ALL</EM> copies of the software and documentation or portions
  14. thereof, including modifications, that you make. 
  15.  
  16. <B>THIS SOFTWARE IS PROVIDED "AS IS," AND COPYRIGHT HOLDERS MAKE NO
  17. REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED.  BY WAY OF EXAMPLE,
  18. BUT NOT LIMITATION, COPYRIGHT HOLDERS MAKE NO REPRESENTATIONS OR
  19. WARRANTIES OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR
  20. THAT THE USE OF THE SOFTWARE OR DOCUMENTATION WILL NOT INFRINGE ANY
  21. THIRD PARTY PATENTS, COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS.
  22. COPYRIGHT HOLDERS WILL BEAR NO LIABILITY FOR ANY USE OF THIS SOFTWARE
  23. OR DOCUMENTATION.
  24.  
  25. The name and trademarks of copyright holders may NOT be used
  26. in advertising or publicity pertaining to the software without
  27. specific, written prior permission.  Title to copyright in this
  28. software and any associated documentation will at all times remain
  29. with copyright holders. 
  30. */
  31. /*                                      CSParse.c
  32. **    PICS CONFIGURATION MANAGER FOR CLIENTS AND SERVERS
  33. **
  34. **    (c) COPYRIGHT MIT 1995.
  35. **    Please first read the full copyright statement in the file COPYRIGHT.
  36. **
  37. **    This module converts application/xpics streams (files or network) to PICS_ class data
  38. **
  39. ** History:
  40. **     4 Dec 95  EGP  start
  41. **    15 Feb 96  EGP  alpha 1
  42. **
  43. ** BUGS: no code yet; doesn't actually do anything
  44. */
  45.  
  46. /* Library include files */
  47. /* --- BEGIN added by mharmsen@netscape.com on 7/9/97 --- */
  48. #include "xp.h"
  49. /* --- END added by mharmsen@netscape.com on 7/9/97 --- */
  50. /* #include "sysdep.h" jhines 7/9/97 */
  51. #include "htchunk.h"
  52. #include "htstring.h"
  53. #include "cslutils.h"
  54. #include "csparse.h"
  55.  
  56. PUBLIC int ParseDebug = 0;    /* For use with LablPars and RatPars */
  57.  
  58. PUBLIC BOOL BVal_readVal(BVal_t * pBVal, const char * valueStr)
  59. {
  60.     /* --- BEGIN converted by mharmsen@netscape.com on 7/9/97 --- */
  61.     if (!XP_STRCASECMP(valueStr, "true") || 
  62.         !XP_STRCASECMP(valueStr, "yes"))
  63.         pBVal->state = BVal_YES;
  64.     else if (XP_STRCASECMP(valueStr, "false") && 
  65.              XP_STRCASECMP(valueStr, "no"))
  66.         return NO;;
  67.     /* --- END converted by mharmsen@netscape.com on 7/9/97 --- */
  68.     pBVal->state |= BVal_INITIALIZED;
  69.     return YES;
  70. }
  71.  
  72. PUBLIC BOOL BVal_initialized(const BVal_t * pBVal)
  73. {
  74.     return (pBVal->state & BVal_INITIALIZED);
  75. }
  76.  
  77. PUBLIC BOOL BVal_value(const BVal_t * pBVal)
  78. {
  79.     return ((pBVal->state & BVal_YES) ? 1 : 0);
  80. }
  81.  
  82. PUBLIC void BVal_set(BVal_t * pBVal, BOOL value)
  83. {
  84.     if (value)
  85.         pBVal->state = BVal_YES;
  86.     pBVal->state |= BVal_INITIALIZED;
  87.     return;
  88. }
  89.  
  90. PUBLIC void BVal_clear(BVal_t * pBVal)
  91. {
  92.     if (pBVal)
  93.       pBVal->state = BVal_UNINITIALIZED;
  94.     return;
  95. }
  96.  
  97. PUBLIC BOOL FVal_readVal(FVal_t * pFVal, const char * valueStr)
  98. {
  99.     /* --- BEGIN converted by mharmsen@netscape.com on 7/9/97 --- */
  100.     if (!XP_STRCASECMP(valueStr, "+INF")) {
  101.         pFVal->stat = FVal_POSITIVE_INF;
  102.         return YES;
  103.     }
  104.     if (!XP_STRCASECMP(valueStr, "-INF")) {
  105.         pFVal->stat = FVal_NEGATIVE_INF;
  106.         return YES;
  107.     }
  108.     /* --- END converted by mharmsen@netscape.com on 7/9/97 --- */
  109.     pFVal->stat = FVal_VALUE;
  110.     sscanf(valueStr, "%f", &pFVal->value);
  111.     return YES;
  112. }
  113.  
  114. PUBLIC BOOL FVal_initialized(const FVal_t * pFVal)
  115. {
  116.     return (pFVal->stat != FVal_UNINITIALIZED);
  117. }
  118.  
  119. PUBLIC float FVal_value(const FVal_t * pFVal)
  120. {
  121.     return (pFVal->value);
  122. }
  123.  
  124. /* 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 */
  125. PRIVATE BOOL FVal_lessThan(const FVal_t * pSmall, const FVal_t * pBig)
  126. {
  127.     if (pBig->stat == FVal_UNINITIALIZED || pSmall->stat == FVal_UNINITIALIZED)
  128.         return FALSE;
  129.     if (pBig->stat == FVal_POSITIVE_INF || pSmall->stat == FVal_NEGATIVE_INF) {
  130.         if (pSmall->stat == FVal_POSITIVE_INF)
  131.             return FALSE;
  132.         return TRUE;
  133.     }
  134.     if (pBig->stat == FVal_NEGATIVE_INF || pSmall->stat == FVal_POSITIVE_INF) {
  135.         return FALSE;
  136.     }
  137.     return pSmall->value < pBig->value;
  138. }
  139.  
  140. PUBLIC FVal_t FVal_minus(const FVal_t * pBig, const FVal_t * pSmall)
  141. {
  142.     FVal_t ret = FVal_NEW_UNINITIALIZED;
  143.     /* no notion of 2 time infinity so please keep your limits to a minimum */
  144.     if (pBig->stat == FVal_UNINITIALIZED || pSmall->stat == FVal_UNINITIALIZED)
  145.         return ret;
  146.     FVal_set(&ret, (float)0.0);
  147.     if (pBig->stat == FVal_POSITIVE_INF || pSmall->stat == FVal_NEGATIVE_INF) {
  148.         if (pSmall->stat != FVal_POSITIVE_INF)
  149.             FVal_setInfinite(&ret, 0);
  150.         return ret;
  151.     }
  152.     if (pBig->stat == FVal_NEGATIVE_INF || pSmall->stat == FVal_POSITIVE_INF) {
  153.         if (pSmall->stat != FVal_NEGATIVE_INF)
  154.             FVal_setInfinite(&ret, 0);
  155.         return ret;
  156.     }
  157.     ret.value = pBig->value - pSmall->value;
  158.     return (ret);
  159. }
  160.  
  161. PUBLIC BOOL FVal_nearerZero(const FVal_t * pRef, const FVal_t * pCheck)
  162. {
  163.     if (pRef->stat == FVal_UNINITIALIZED || pCheck->stat == FVal_UNINITIALIZED || 
  164.         pCheck->stat == FVal_POSITIVE_INF || pCheck->stat == FVal_NEGATIVE_INF)
  165.         return NO;
  166.     if (pRef->stat == FVal_POSITIVE_INF || pRef->stat == FVal_NEGATIVE_INF)
  167.         return YES;
  168.     if (pRef->value < 0.0) {
  169.         if (pCheck->value < 0.0)
  170.             return pCheck->value > pRef->value;
  171.         return pCheck->value < -pRef->value;
  172.     }
  173.     if (pCheck->value < 0.0)
  174.         return pCheck->value > -pRef->value;
  175.     return pCheck->value < pRef->value;
  176. }
  177.  
  178. PUBLIC BOOL FVal_isZero(const FVal_t * pFVal)
  179. {
  180.     if (pFVal->stat == FVal_VALUE && pFVal->value == 0.0)
  181.         return YES;
  182.     return NO;
  183. }
  184.  
  185. PUBLIC void FVal_set(FVal_t * pFVal, float value)
  186. {
  187.     pFVal->value = value;
  188.     pFVal->stat = FVal_VALUE;
  189. }
  190.  
  191. PUBLIC void FVal_setInfinite(FVal_t * pFVal, BOOL negative)
  192. {
  193.     pFVal->stat = negative ? FVal_NEGATIVE_INF : FVal_POSITIVE_INF;
  194. }
  195.  
  196. PUBLIC int FVal_isInfinite(const FVal_t * pFVal)
  197. {
  198.     return (pFVal->stat == FVal_POSITIVE_INF ? 1 : pFVal->stat == FVal_NEGATIVE_INF ? -1 : 0);
  199. }
  200.  
  201. PUBLIC void FVal_clear(FVal_t * pFVal)
  202. {
  203.     if (pFVal)
  204.       pFVal->stat = FVal_UNINITIALIZED;
  205.     return;
  206. }
  207.  
  208. PUBLIC char * FVal_toStr(FVal_t * pFVal)
  209. {
  210.     char * ptr;
  211.     if ((ptr = (char *)HT_MALLOC(40)) == NULL)
  212.     HT_OUTOFMEM("FVal buffer");
  213.     sprintf(ptr, "%.1f", FVal_value(pFVal));
  214.     return ptr;
  215. }
  216.  
  217. PUBLIC BOOL SVal_readVal(SVal_t * pSVal, const char * valueStr)
  218. {
  219.     pSVal->initialized = YES;
  220.     StrAllocCopy(pSVal->value, valueStr);
  221.     return YES;
  222. }
  223.  
  224. PUBLIC BOOL SVal_initialized(const SVal_t * pSVal)
  225. {
  226.     return (pSVal->initialized != NO);
  227. }
  228.  
  229. PUBLIC char * SVal_value(const SVal_t * pSVal)
  230. {
  231.     return (pSVal->value);
  232. }
  233.  
  234. PUBLIC void SVal_clear(SVal_t * pSVal)
  235. {
  236.     if (SVal_initialized(pSVal)) {
  237.       HT_FREE(pSVal->value);
  238.       pSVal->initialized = NO;
  239.       }
  240.     return;
  241. }
  242.  
  243. #if 0
  244.     int year;
  245.     int month;
  246.     int day;
  247.     int hour;
  248.     int minute;
  249.     int timeZoneHours;
  250.     int timeZoneMinutes;
  251. #endif
  252. PUBLIC BOOL DVal_readVal(DVal_t * pDVal, const char * valueStr)
  253. {
  254.     char space[] = "1994.11.05T08:15-0500";
  255.     char timeZoneSign;
  256.     char timeZoneMinutesMSB;
  257.     /* --- BEGIN converted by mharmsen@netscape.com on 7/9/97 --- */
  258.     if (XP_STRLEN(valueStr) != 0x15)
  259.         return NO;
  260.     XP_MEMCPY(space, valueStr, 0x15);
  261.     timeZoneSign = space[16];
  262.     timeZoneMinutesMSB = space[19];
  263.     space[4] = space[7] = space[10] = space[13] = space[16] = space[19] = 0;
  264.     pDVal->year = XP_ATOI(space);
  265.     pDVal->month = XP_ATOI(space+5);
  266.     pDVal->day = XP_ATOI(space+8);
  267.     pDVal->hour = XP_ATOI(space+11);
  268.     pDVal->minute = XP_ATOI(space+14);
  269.     pDVal->timeZoneHours = XP_ATOI(space+17);
  270.     space[19] = timeZoneMinutesMSB;
  271.     pDVal->timeZoneMinutes = XP_ATOI(space+19);
  272.     /* --- END converted by mharmsen@netscape.com on 7/9/97 --- */
  273.     if (timeZoneSign == '-') {
  274.         pDVal->timeZoneHours = -pDVal->timeZoneHours;
  275.         pDVal->timeZoneMinutes = -pDVal->timeZoneMinutes;
  276.     }
  277.     StrAllocCopy(pDVal->value, valueStr);
  278.     pDVal->initialized = YES;
  279.     return YES;
  280. }
  281.  
  282. PUBLIC BOOL DVal_initialized(const DVal_t * pDVal)
  283. {
  284.     return (pDVal->initialized != NO);
  285. }
  286.  
  287. PUBLIC int DVal_compare(const DVal_t * a, const DVal_t * b)
  288. {
  289.     if (a->year > b->year) return 1;
  290.     if (a->year < b->year) return -1;
  291.     if (a->month > b->month) return 1;
  292.     if (a->month < b->month) return -1;
  293.     if (a->day > b->day) return 1;
  294.     if (a->day < b->day) return -1;
  295.     if (a->hour+a->timeZoneHours > b->hour+b->timeZoneHours) return 1;
  296.     if (a->hour+a->timeZoneHours < b->hour+b->timeZoneHours) return -1;
  297.     if (a->minute+a->timeZoneMinutes > b->minute+b->timeZoneMinutes) return 1;
  298.     if (a->minute+a->timeZoneMinutes < b->minute+b->timeZoneMinutes) return -1;
  299.     return 0;
  300. }
  301.  
  302. PUBLIC char * DVal_value(const DVal_t * pDVal)
  303. {
  304.     return (pDVal->value);
  305. }
  306.  
  307. PUBLIC void DVal_clear(DVal_t * pDVal)
  308. {
  309.     if (DVal_initialized(pDVal)) {
  310.         HT_FREE(pDVal->value);
  311.     pDVal->initialized = NO;
  312.     }
  313.     return;
  314. }
  315.  
  316. PUBLIC char * Range_toStr(Range_t * pRange)
  317. {
  318.     HTChunk * pChunk;
  319.     char * ptr;
  320.     pChunk = HTChunk_new(20);
  321.     ptr = FVal_toStr(&pRange->min);
  322.     HTChunk_puts(pChunk, ptr);
  323.     HT_FREE(ptr);
  324.     if (FVal_initialized(&pRange->max)) {
  325.         ptr = FVal_toStr(&pRange->max);
  326.     HTChunk_puts(pChunk, ":");
  327.     HTChunk_puts(pChunk, ptr);
  328.     HT_FREE(ptr);
  329.     }
  330.     return HTChunk_toCString(pChunk);
  331. }
  332.  
  333. /* Range_gap - find gap between 2 ranges. Either of these ranges may be a 
  334.  * single value (in the min)
  335.  * negative vector indicates that ref is greater than test
  336.  */
  337. PUBLIC FVal_t Range_gap(Range_t * a, Range_t * b)
  338. {
  339.     Range_t aN = *a;
  340.     Range_t bN = *b;
  341.     FVal_t ret = FVal_NEW_UNINITIALIZED;
  342.     if (!FVal_initialized(&a->min) || !FVal_initialized(&b->min))
  343.         return (ret);
  344.  
  345.     /* set ret for successful 0 returns */
  346.     FVal_set(&ret, (float)0.0);
  347.  
  348.     /* normalize our ranges */
  349.     if (FVal_lessThan(&aN.max, &aN.min)) {
  350.         aN.max = a->min;
  351.         aN.min = a->max;
  352.     }
  353.     if (FVal_lessThan(&bN.max, &bN.min)) {
  354.         bN.max = b->min;
  355.         bN.min = b->max;
  356.     }
  357.  
  358.     /* check partial ranges (just a min, no max) */
  359.     if (!FVal_initialized(&aN.max)) {
  360.         if (!FVal_initialized(&bN.max))
  361.             return FVal_minus(&aN.min, &bN.min);
  362.         if (FVal_lessThan(&aN.min, &bN.min))
  363.             return FVal_minus(&bN.min, &aN.min);
  364.         if (FVal_lessThan(&bN.max, &aN.min))
  365.             return FVal_minus(&bN.max, &aN.min);
  366.         return ret;
  367.     }
  368.     /* we have four values to compare */
  369.     {
  370.         FVal_t minDif = FVal_minus(&bN.min, &aN.min);
  371.         FVal_t maxDif = FVal_minus(&bN.max, &aN.max);
  372.         Range_t common;
  373.         common.min = FVal_lessThan(&bN.min, &aN.min) ? aN.min : bN.min;
  374.         common.max = FVal_lessThan(&bN.max, &aN.max) ? bN.max : aN.max;
  375.         if (!FVal_lessThan(&common.max, &common.min))
  376.             return ret;
  377.         /* failure - indicate how far we are off */
  378.         return FVal_nearerZero(&minDif, &maxDif) ? minDif : maxDif;
  379.     }
  380. }
  381.  
  382. /* ------------------------------------------------------------------------- */
  383.  
  384. /* C O N S T R U C T O R S */
  385. PUBLIC CSParse_t * CSParse_new(void)
  386. {
  387.     CSParse_t * me;
  388.     if ((me = (CSParse_t *) HT_CALLOC(1, sizeof(CSParse_t))) == NULL)
  389.         HT_OUTOFMEM("CSParse");
  390.     me->nowIn = NowIn_NEEDOPEN;
  391.     me->token = HTChunk_new(0x10);
  392.     if ((me->pParseContext = (ParseContext_t *) HT_CALLOC(1, sizeof(ParseContext_t))) == NULL)
  393.         HT_OUTOFMEM("ParseContext_t");
  394.     return me;
  395. }
  396.  
  397. PUBLIC void CSParse_delete(CSParse_t * me)
  398. {
  399.     HT_FREE(me->pParseContext);
  400.     HTChunk_delete(me->token);
  401.     HT_FREE(me);
  402. }
  403.  
  404. /* L A B E L   P A R S E R S */
  405. PRIVATE StateRet_t callErrorHandler(CSParse_t * pCSParse, 
  406.                     const char * errorLocation,
  407.                     char demark, StateRet_t errorCode)
  408. {
  409.     char * token = HTChunk_data(pCSParse->token);
  410.     /* --- BEGIN removed compiler warning by mharmsen@netscape.com on 7/9/97 --- */
  411.     pCSParse->pParseContext->pTokenError = (char *)errorLocation;
  412.     /* --- END removed compiler warning by mharmsen@netscape.com on 7/9/97 --- */
  413.     return (*pCSParse->pParseContext->pParseErrorHandler)(pCSParse, token, 
  414.                           demark, StateRet_ERROR_BAD_CHAR);
  415. }
  416.  
  417. /* CSParse_parseChunk - elemental parse engine for all pics nowIns. This passes 
  418.  * tokenized data into the handler functions in the CSParse_t.handlersOf. These 
  419.  * handlers are responsibel for placing the data in the appropriate target.
  420.  * The text is broken into nowIns and passed a SubParser based on the current 
  421.  * nowIn which is one of:
  422.  *  NowIn_NEEDOPEN - get paren and go to NowIn_ENGINE, text is an error
  423.  *  NowIn_ENGINE - in a containing structure, text goes to engineOf_
  424.  *  NowIn_NEEDCLOSE - get paren and go to NowIn_ENGINE, text is an error
  425.  *  NowIn_END - expect no more text or parens
  426.  *  NowIn_ERROR - 
  427.  */
  428. PUBLIC CSDoMore_t CSParse_parseChunk (CSParse_t * pCSParse, const char * ptr, int len, void * pVoid)
  429. {
  430.     int i;
  431.     if (!len || !ptr)
  432.         return CSDoMore_error;
  433.     for (i = 0; i < len; i++) {
  434.         pCSParse->offset++;
  435.         if (pCSParse->quoteState) {
  436.             if (pCSParse->quoteState == ptr[i]) {
  437.                 pCSParse->quoteState = 0;
  438.                 pCSParse->demark = ' ';
  439.             }
  440.             else
  441.                 HTChunk_putb(pCSParse->token, ptr+i, 1);
  442.             continue;
  443.         }
  444.         if (ptr[i] == SQUOTE || ptr[i] == DQUOTE) {
  445.             if (pCSParse->demark) {
  446.                 while ((pCSParse->nowIn = (*pCSParse->pParseContext->engineOf)(pCSParse, ' ', pVoid)) == NowIn_CHAIN)
  447.                     ; /* */
  448.                 HTChunk_clear(pCSParse->token);
  449.                 pCSParse->demark = 0;
  450.             } else if (HTChunk_size(pCSParse->token) && 
  451. /*                  && warn(pCSParse, message_UNEXPECTED_CHARACTER, ptr[i])) */
  452.                callErrorHandler(pCSParse, ptr+i, ptr[i], 
  453.                     StateRet_ERROR_BAD_CHAR) !=StateRet_OK)
  454.             pCSParse->nowIn = NowIn_ERROR;
  455.             pCSParse->quoteState = ptr[i];
  456.             pCSParse->pParseContext->observedQuotes = YES;
  457.             continue;
  458.         }
  459.         switch (pCSParse->nowIn) {
  460.             case NowIn_NEEDOPEN:
  461.                 if (ptr[i] == LPAREN) {
  462.                     pCSParse->nowIn = NowIn_ENGINE;
  463.                     continue;
  464.                 }
  465.                 if (XP_IS_SPACE(ptr[i]))
  466.                     continue;
  467. /*                if (warn(pCSParse, message_UNEXPECTED_CHARACTER, ptr[i])) pCSParse->nowIn = NowIn_ERROR; */
  468.             if (callErrorHandler(pCSParse, ptr+i, ptr[i], 
  469.                      StateRet_ERROR_BAD_CHAR) !=StateRet_OK)
  470.             pCSParse->nowIn = NowIn_ERROR;
  471.                 continue;
  472.             case NowIn_ENGINE:
  473.                 if (XP_IS_SPACE(ptr[i])) {
  474.                     if (HTChunk_size(pCSParse->token))
  475.                         pCSParse->demark = ' ';
  476.                     continue;
  477.                 }
  478.                 if (ptr[i] == LPAREN || ptr[i] == RPAREN || pCSParse->demark) {
  479.             /* parens override space demarkation */
  480.             if (ptr[i] == LPAREN) pCSParse->demark = LPAREN;
  481.             if (ptr[i] == RPAREN) pCSParse->demark = RPAREN;
  482.             /* call the engine as long as it wants re-entrance */
  483.                     while ((pCSParse->nowIn = (*pCSParse->pParseContext->engineOf)(pCSParse, pCSParse->demark, pVoid)) == NowIn_CHAIN)
  484.                         ; /* */
  485.                     HTChunk_clear(pCSParse->token);
  486.                     pCSParse->demark = 0;
  487.                     if (ptr[i] == LPAREN || ptr[i] == RPAREN)
  488.                         continue;
  489.                     /* continue with next token */
  490.                 }
  491.                 HTChunk_putb(pCSParse->token, ptr+i, 1);
  492.                 continue;
  493.             case NowIn_NEEDCLOSE:
  494.                 if (ptr[i] == RPAREN) {
  495.                     pCSParse->nowIn = NowIn_ENGINE;
  496.                     continue;
  497.                 }
  498.                 if (XP_IS_SPACE(ptr[i]))
  499.                     continue;
  500.         if (callErrorHandler(pCSParse, ptr+i, ptr[i], 
  501.                      StateRet_ERROR_BAD_CHAR) !=StateRet_OK)
  502.             pCSParse->nowIn = NowIn_ERROR;
  503. /*                if (warn(pCSParse, message_UNEXPECTED_CHARACTER, ptr[i])) pCSParse->nowIn = NowIn_ERROR; */
  504.                 continue;
  505.             case NowIn_END:
  506. #if 0 /* enable this to tell the parser to check the remainder of 
  507.          the stream after the parsed object thinks it is done */
  508.                 if (XP_IS_SPACE(ptr[i]))
  509.                     continue;
  510. /*                if (warn(pCSParse, message_UNEXPECTED_CHARACTER, ptr[i])) pCSParse->nowIn = NowIn_ERROR; */
  511.         if (callErrorHandler(pCSParse, ptr+i, ptr[i], 
  512.                      StateRet_ERROR_BAD_CHAR) !=StateRet_OK)
  513.             pCSParse->nowIn = NowIn_ERROR;
  514.                 continue;
  515. #else
  516.                 return CSDoMore_done;
  517. #endif
  518.             case NowIn_MATCHCLOSE:
  519.                 if (ptr[i] == RPAREN) {
  520.                     if (!pCSParse->depth)
  521.                         pCSParse->nowIn = NowIn_ENGINE;
  522.                     else
  523.                         pCSParse->depth--;
  524.                 }
  525.                 if (ptr[i] == LPAREN)
  526.                     pCSParse->depth++;
  527.                 continue;
  528.             case NowIn_ERROR:
  529.                 return CSDoMore_error;
  530.                 break;
  531.             default:
  532. /*                if (warn(pCSParse, message_INTERNAL_ERROR, "bad nowIn")) pCSParse->nowIn = NowIn_ERROR; */
  533.         HTTrace("PICS: Internal error in parser - bad nowIn:%d.\n", 
  534.             pCSParse->nowIn);
  535.         return CSDoMore_error;
  536.         }
  537.     }
  538.     /* check completion */
  539.     return pCSParse->nowIn == NowIn_END ? CSDoMore_done : CSDoMore_more;
  540. }
  541.  
  542. PUBLIC BOOL Punct_badDemark(Punct_t validPunctuation, char demark)
  543. {
  544.     switch (demark) {
  545.         case ' ': return (!(validPunctuation & Punct_WHITE));
  546.         case LPAREN: return (!(validPunctuation & Punct_LPAREN));
  547.         case RPAREN: return (!(validPunctuation & Punct_RPAREN));
  548.     }
  549.     return YES;
  550. }
  551.  
  552. #if 0
  553. PRIVATE void Input_dump(char * token, char demark)
  554. {
  555.     char space[256];
  556.     sprintf(space, " %s |%c|\n", token, demark);
  557.     HTTrace(space);
  558. }
  559. #endif
  560. PRIVATE char * CSParse_subState2str(SubState_t subState)
  561. {
  562.     static char space[33];
  563.     space[0] = 0;
  564.     /* --- BEGIN converted by mharmsen@netscape.com on 7/9/97 --- */
  565.     if (subState == SubState_N)
  566.         XP_STRCPY(space, "N");
  567.     else if (subState == SubState_X)
  568.         XP_STRCPY(space, "X");
  569.     else {
  570.         int i;
  571.     SubState_t comp;
  572.     char ch[] = "A";
  573.     for (i = 1, comp = SubState_A; i < (sizeof(SubState_t)*8 - 1); i++, (*ch)++, comp<<=1)
  574.         if (comp & subState)
  575.             XP_STRCAT(space, ch);
  576.     }
  577.     /* --- END converted by mharmsen@netscape.com on 7/9/97 --- */
  578.     return space;
  579. }
  580.  
  581. PRIVATE int ParseTrace(const char * fmt, ...)
  582. {
  583.     va_list pArgs;
  584.  
  585.     va_start(pArgs, fmt);
  586.  
  587.     if (!ParseDebug)
  588.         return 0;
  589.     return (vfprintf(stderr, fmt, pArgs));
  590. }
  591.  
  592. PUBLIC NowIn_t CSParse_targetParser(CSParse_t * pCSParse, char demark, void * pVoid)
  593. {
  594. /*    ParseContext_t * pParseContext = pCSParse->pParseContext; */
  595.     TargetObject_t * pTargetObject = pCSParse->pTargetObject;
  596.     BOOL failedOnPunct = NO;
  597.     char * token = 0;
  598.     StateRet_t ret = StateRet_OK;
  599.     int i;
  600. static NowIn_t lastRet = NowIn_END;
  601.  
  602.     /* changed by montulli@netscape.com 11/29/97 
  603.      * if (HTChunk_size(pCSParse->token)) {
  604.      *   HTChunk_terminate(pCSParse->token);
  605.      *   token = HTChunk_data(pCSParse->token);
  606.      * }
  607.      */
  608.     if(HTChunk_data(pCSParse->token))
  609.     {
  610.         HTChunk_terminate(pCSParse->token);
  611.         token = HTChunk_data(pCSParse->token);
  612.     }
  613.  
  614.     /*Input_dump(token, demark);*/
  615.     for (i = 0; i < pTargetObject->stateTokenCount; i++) {
  616.         StateToken_t * pStateToken = pTargetObject->stateTokens + i;
  617.         pCSParse->pStateToken = pStateToken;
  618.  
  619.         if (!(pCSParse->currentSubState & pStateToken->validSubStates))
  620.             continue;
  621.         if (pStateToken->pCheck) {  /* use check function */
  622.             StateRet_t checkRes;
  623.             checkRes = (*pStateToken->pCheck)(pCSParse, pStateToken, token, demark);
  624.             switch (checkRes) {
  625.                 case StateRet_WARN_BAD_PUNCT:
  626.                     failedOnPunct = YES;
  627.                 case StateRet_WARN_NO_MATCH:
  628.                     continue;
  629.                 case StateRet_ERROR_BAD_CHAR:
  630.             (*pCSParse->pParseContext->pParseErrorHandler)(pCSParse, token, demark, StateRet_ERROR_BAD_CHAR);
  631.             /*                    if (pTargetObject->pDestroy)
  632.                 (*pTargetObject->pDestroy)(pCSParse); */
  633.                     return NowIn_ERROR;
  634.             default:
  635.             break;
  636.             }
  637.         } else {                    /* or match by name[s] */
  638.             if (!(pStateToken->command & Command_MATCHANY)) {
  639.             if (token && pStateToken->name1) {
  640.                     /* --- BEGIN converted by mharmsen@netscape.com on 7/9/97 --- */
  641.                 if (XP_STRCASECMP(token, pStateToken->name1) && (!pStateToken->name2 || XP_STRCASECMP(token, pStateToken->name2)))
  642.                        continue;
  643.                     /* --- END converted by mharmsen@netscape.com on 7/9/97 --- */
  644.             } else {
  645.             if (token != pStateToken->name1)
  646.                     continue;
  647.             }
  648.         }
  649.             if (Punct_badDemark(pStateToken->validPunctuation, demark)) {
  650.                 failedOnPunct = YES;
  651.                 continue;
  652.             }
  653.         }
  654. /* open or close and do the appropriate callbacks */
  655.     if (lastRet != NowIn_CHAIN)
  656.         ParseTrace("%30s %c ", token ? token : "", demark);
  657.         ParseTrace("%10s - %s:%10s => ", pCSParse->pTargetObject->note, CSParse_subState2str(pCSParse->currentSubState), pStateToken->note);
  658.     if (pStateToken->command & Command_NOTOKEN) {
  659.         HTChunk_clear(pCSParse->token);
  660.         token = 0;
  661.     }
  662.     if (pStateToken->command & Command_OPEN && pTargetObject->pOpen)
  663.         if ((*pTargetObject->pOpen)(pCSParse, token, demark) == StateRet_ERROR)
  664.             return NowIn_ERROR;
  665.     
  666.     if (pStateToken->command & (Command_OPEN|Command_CLOSE) && pCSParse->pParseContext->pTargetChangeCallback) {
  667.         ParseTrace("%3d", pStateToken->command & Command_CLOSE ? -(int)pTargetObject->targetChange : pTargetObject->targetChange);
  668.         if ((*pCSParse->pParseContext->pTargetChangeCallback)(pCSParse, pTargetObject, pTargetObject->targetChange, 
  669.         (BOOL)(pStateToken->command & Command_CLOSE), pVoid) == StateRet_ERROR)
  670.         return NowIn_ERROR;
  671.     } else
  672.         ParseTrace("   ");
  673.         if (pStateToken->command & Command_CLOSE && pTargetObject->pClose)
  674.             ret = (*pTargetObject->pClose)(pCSParse, token, demark);
  675.  
  676.         if (pStateToken->pPrep && ret != NowIn_ERROR)
  677.             ret = (*pStateToken->pPrep)(pCSParse, token, demark);
  678.         if (pStateToken->pNextTargetObject)
  679.             pCSParse->pTargetObject = pStateToken->pNextTargetObject;
  680.         if (pStateToken->nextSubState != SubState_X)
  681.             pCSParse->currentSubState = pStateToken->nextSubState;
  682. /*
  683. CSLabel_dump(pCSLabel);
  684. HTTrace(pCSParse->pTargetObject->note);
  685. */
  686.         ParseTrace("%10s - %s", pCSParse->pTargetObject->note, CSParse_subState2str(pCSParse->currentSubState));
  687.         if (pStateToken->command & Command_CHAIN) {
  688.         ParseTrace(" -O-O-");
  689.             return lastRet = NowIn_CHAIN;
  690.     }
  691.     ParseTrace("\n");
  692.         return lastRet = ret == StateRet_ERROR_BAD_CHAR ? NowIn_ERROR : ret == StateRet_DONE ? NowIn_END : NowIn_ENGINE;
  693.     }
  694.     (*pCSParse->pParseContext->pParseErrorHandler)(pCSParse, token, demark, failedOnPunct ? StateRet_WARN_BAD_PUNCT : StateRet_WARN_NO_MATCH);
  695.     if (pTargetObject->pDestroy)
  696.         (*pTargetObject->pDestroy)(pCSParse);
  697.     return NowIn_ERROR;
  698. }
  699.  
  700.