开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 浏览器 > 查看源码
SGML.c
资源名称：arena-beta-2b-src.tar.gz　[点击查看]
上传用户：zlh9724
上传日期：2007-01-04
资源大小：1991k
文件大小：20k
源码类别：

浏览器

开发平台：

Unix_Linux

SGML.c：源码内容
  1. /*  SGML.c
  2. ** GENERAL SGML PARSER CODE
  3. **
  4. ** (c) COPYRIGHT MIT 1995.
  5. ** Please first read the full copyright statement in the file COPYRIGH.
  6. **
  7. ** This module implements an HTStream object. To parse an
  8. ** SGML file, create this object which is a parser. The object
  9. ** is (currently) created by being passed a DTD structure,
  10. ** and a target HTStructured oject at which to throw the parsed stuff.
  11. **
  12. **  6 Feb 93   Binary seraches used. Intreface modified.
  13. **  8 Jul 94  FM Insulate free() from _free structure element.
  14. */
  16. /* Library include files */
  17. #include "tcp.h"
  18. #include "HTUtils.h"
  19. #include "HTString.h"
  20. #include "HTChunk.h"
  21. #include "SGML.h"
  23. #define INVALID (-1)
  25. /* The State (context) of the parser
  26. **
  27. ** This is passed with each call to make the parser reentrant
  28. **
  29. */
  34. /* Element Stack
  35. ** -------------
  36. ** This allows us to return down the stack reselcting styles.
  37. ** As we return, attribute values will be garbage in general.
  38. */
  39. typedef struct _HTElement HTElement;
  40. struct _HTElement {
  41. HTElement * next; /* Previously nested element or 0 */
  42. HTTag* tag; /* The tag at this level  */
  43. };
  46. typedef enum _sgml_state {
  47.     S_text, S_literal, S_tag, S_tag_gap, 
  48.     S_attr, S_attr_gap, S_equals, S_value, S_after_open,
  49.     S_nl, S_nl_tago,
  50.     S_ero, S_cro,
  51. #ifdef ISO_2022_JP
  52.     S_esc, S_dollar, S_paren, S_nonascii_text,
  53. #endif
  54.     S_squoted, S_dquoted, S_end, S_entity, S_junk_tag
  55. } sgml_state;
  58. /* Internal Context Data Structure
  59. ** -------------------------------
  60. */
  61. struct _HTStream {
  63.     CONST HTStreamClass * isa; /* inherited from HTStream */
  64.     
  65.     CONST SGML_dtd  *dtd;
  66.     HTStructuredClass *actions; /* target class  */
  67.     HTStructured *target; /* target object */
  69.     HTTag  *current_tag;
  70.     int  current_attribute_number;
  71.     HTChunk *string;
  72.     HTElement *element_stack;
  73.     sgml_state state;
  74. #ifdef CALLERDATA   
  75.     void * callerData;
  76. #endif
  77.     BOOL present[MAX_ATTRIBUTES]; /* Flags: attribute is present? */
  78.     char * value[MAX_ATTRIBUTES]; /* malloc'd strings or NULL if none */
  79. } ;
  82. #define PUTC(ch) ((*context->actions->put_character)(context->target, ch))
  85. /* Find Attribute Number
  86. ** ---------------------
  87. */
  89. PUBLIC int SGMLFindAttribute  (HTTag* tag, CONST char * s)
  90. {
  91.     attr* attributes = tag->attributes;
  93.     int high, low, i, diff; /* Binary search for attribute name */
  94.     for(low=0, high=tag->number_of_attributes;
  95.      high > low ;
  96. diff < 0 ? (low = i+1) : (high = i) )  {
  97. i = (low + (high-low)/2);
  98. diff = strcasecomp(attributes[i].name, s);
  99. if (diff==0) return i; /* success: found it */
  100.     } /* for */
  101.     
  102.     return -1;
  103. }
  106. /* Handle Attribute
  107. ** ----------------
  108. */
  109. /* PUBLIC CONST char * SGML_default = "";   ?? */
  111. PRIVATE void handle_attribute_name (HTStream * context, CONST char * s)
  112. {
  114.     HTTag * tag = context->current_tag;
  116.     int i = SGMLFindAttribute(tag, s);
  117.     if (i>=0) {
  118. context->current_attribute_number = i;
  119. context->present[i] = YES;
  120. if (context->value[i]) {
  121.     HT_FREE(context->value[i]);
  122.     context->value[i] = NULL;
  123. }
  124. return;
  125.     } /* if */
  127.     if (SGML_TRACE)
  128. TTYPrint(TDEST, "SGML: Unknown attribute %s for tag %sn",
  129.     s, context->current_tag->name);
  130.     context->current_attribute_number = INVALID; /* Invalid */
  131. }
  134. /* Handle attribute value
  135. ** ----------------------
  136. */
  137. PRIVATE void handle_attribute_value (HTStream * context, CONST char * s)
  138. {
  139.     if (context->current_attribute_number != INVALID) {
  140. StrAllocCopy(context->value[context->current_attribute_number], s);
  141.     } else {
  142.         if (SGML_TRACE) TTYPrint(TDEST, "SGML: Attribute value %s ignoredn", s);
  143.     }
  144.     context->current_attribute_number = INVALID; /* can't have two assignments! */
  145. }
  148. /* Handle entity
  149. ** -------------
  150. **
  151. ** On entry,
  152. ** s contains the entity name zero terminated
  153. ** Bugs:
  154. ** If the entity name is unknown, the terminator is treated as
  155. ** a printable non-special character in all cases, even if it is '<'
  156. */
  157. PRIVATE void handle_entity (HTStream * context, char term)
  158. {
  160.     CONST char ** entities = context->dtd->entity_names;
  161.     CONST char *s = context->string->data;
  162.     
  163.     int high, low, i, diff;
  164.     for(low=0, high = context->dtd->number_of_entities;
  165.      high > low ;
  166. diff < 0 ? (low = i+1) : (high = i))   {  /* Binary serach */
  167. i = (low + (high-low)/2);
  168. diff = strcmp(entities[i], s); /* Csse sensitive! */
  169. if (diff==0) { /* success: found it */
  170.     (*context->actions->put_entity)(context->target, i);
  171.     return;
  172. }
  173.     }
  174.     /* If entity string not found, display as text */
  175.     if (SGML_TRACE)
  176. TTYPrint(TDEST, "SGML: Unknown entity %sn", s); 
  177.     PUTC('&');
  178.     {
  179. CONST char *p;
  180. for (p=s; *p; p++) {
  181.     PUTC(*p);
  182. }
  183.     }
  184.     PUTC(term);
  185. }
  187. /*
  188. ** Helper function to check if the tag is on the stack
  189. */
  190. PRIVATE BOOL lookup_element_stack (HTElement* stack, HTTag *tag)
  191. {
  192.     HTElement* elem;
  193.     for (elem = stack; elem != NULL; elem = elem->next)
  194.     {
  195.         if (elem->tag == tag)  return YES;
  196.     }
  197.     return NO;
  198. }
  200. /* End element
  201. ** -----------
  202. */
  203. PRIVATE void end_element (HTStream * context, HTTag * old_tag)
  204. {
  205.     if (SGML_TRACE) TTYPrint(TDEST, "SGML: End   </%s>n", old_tag->name);
  206.     if (old_tag->contents == SGML_EMPTY) {
  207.         if (SGML_TRACE) TTYPrint(TDEST,"SGML: Illegal end tag </%s> found.n",
  208. old_tag->name);
  209. return;
  210.     }
  211.     while (context->element_stack)  {/* Loop is error path only */
  212. HTElement * N = context->element_stack;
  213. HTTag * t = N->tag;
  215. if (old_tag != t) { /* Mismatch: syntax error */
  216.     /*
  217.     ** Patch from Maciej Puzio, puzio@laser.mimuw.edu.pl
  218.     ** See explanation in ../User/Patch/lib_4.0_1.fix
  219.     */
  220.             if (context->element_stack->next   /* This is not the last level */
  221. && lookup_element_stack(context->element_stack, old_tag)) {
  222. if (SGML_TRACE) TTYPrint(TDEST,
  223.      "SGML: Found </%s> when expecting </%s>. </%s> assumed.n",
  224.     old_tag->name, t->name, t->name);
  225.     } else { /* last level */
  226. if (SGML_TRACE) TTYPrint(TDEST,
  227.             "SGML: Found </%s> when expecting </%s>. </%s> Ignored.n",
  228.     old_tag->name, t->name, old_tag->name);
  229.         return; /* Ignore */
  230.     }
  231. }
  233. context->element_stack = N->next; /* Remove from stack */
  234. HT_FREE(N);
  235. (*context->actions->end_element)(context->target,
  236.  t - context->dtd->tags);
  237. if (old_tag == t) return;  /* Correct sequence */
  239. /* Syntax error path only */
  241.     }
  242.     if (SGML_TRACE) TTYPrint(TDEST,
  243. "SGML: Extra end tag </%s> found and ignored.n", old_tag->name);
  244. }
  247. /* Start an element
  248. ** ----------------
  249. */
  250. PRIVATE void start_element (HTStream * context)
  251. {
  252.     HTTag * new_tag = context->current_tag;
  253.     
  254.     if (SGML_TRACE) TTYPrint(TDEST, "SGML: Start <%s>n", new_tag->name);
  255.     (*context->actions->start_element)(
  256.      context->target,
  257. new_tag - context->dtd->tags,
  258. context->present,
  259. (CONST char**) context->value);  /* coerce type for think c */
  260.     if (new_tag->contents != SGML_EMPTY) { /* i.e. tag not empty */
  261. HTElement * N;
  262. if ((N = (HTElement  *) HT_MALLOC(sizeof(HTElement))) == NULL)
  263.     HT_OUTOFMEM("start_element");
  264. N->next = context->element_stack;
  265. N->tag = new_tag;
  266. context->element_stack = N;
  267.     }
  268. }
  271. /* Find Tag in DTD tag list
  272. ** ------------------------
  273. **
  274. ** On entry,
  275. ** dtd points to dtd structire including valid tag list
  276. ** string points to name of tag in question
  277. **
  278. ** On exit,
  279. ** returns:
  280. ** NULL tag not found
  281. ** else address of tag structure in dtd
  282. */
  283. PUBLIC HTTag * SGMLFindTag (CONST SGML_dtd* dtd, CONST char * string)
  284. {
  285.     int high, low, i, diff;
  286.     for(low=0, high=dtd->number_of_tags;
  287.      high > low ;
  288. diff < 0 ? (low = i+1) : (high = i))   {  /* Binary serach */
  289. i = (low + (high-low)/2);
  290. diff = strcasecomp(dtd->tags[i].name, string); /* Case insensitive */
  291. if (diff==0) { /* success: found it */
  292.     return &dtd->tags[i];
  293. }
  294.     }
  295.     return NULL;
  296. }
  298. /*________________________________________________________________________
  299. ** Public Methods
  300. */
  303. /* Could check that we are back to bottom of stack! @@  */
  304. PUBLIC int SGML_flush  (HTStream * context)
  305. {
  306.     while (context->element_stack) {
  307. HTElement *ptr = context->element_stack;
  308. if (SGML_TRACE)
  309.     TTYPrint(TDEST, "SGML........ Non-matched tag found: <%s>n",
  310.     context->element_stack->tag->name);
  311. context->element_stack = ptr->next;
  312. HT_FREE(ptr);
  313.     }
  314.     return (*context->actions->flush)(context->target);
  315. }
  317. PUBLIC int SGML_free  (HTStream * context)
  318. {
  319.     int status;
  320.     int cnt;
  321.     while (context->element_stack) {    /* Make sure, that all tags are gone */
  322. HTElement *ptr = context->element_stack;
  324. if (SGML_TRACE)
  325.     TTYPrint(TDEST, "SGML........ Non-matched tag found: <%s>n",
  326.     context->element_stack->tag->name);
  327. context->element_stack = ptr->next;
  328. HT_FREE(ptr);
  329.     }
  330.     if ((status = (*context->actions->_free)(context->target)) != HT_OK)
  331. return status;
  332.     HTChunk_delete(context->string);
  333.     for(cnt=0; cnt<MAX_ATTRIBUTES; cnt++)        /* Leak fix Henrik 18/02-94 */
  334. if(context->value[cnt])
  335.     HT_FREE(context->value[cnt]);
  336.     HT_FREE(context);
  337.     return HT_OK;
  338. }
  340. PUBLIC int SGML_abort  (HTStream * context, HTList * e)
  341. {
  342.     int cnt;
  343.     while (context->element_stack) {    /* Make sure, that all tags are gone */
  344. HTElement *ptr = context->element_stack;
  345. if (SGML_TRACE)
  346.     TTYPrint(TDEST, "SGML........ Non-matched tag found: <%s>n",
  347.     context->element_stack->tag->name);
  348. context->element_stack = ptr->next;
  349. HT_FREE(ptr);
  350.     }
  351.     (*context->actions->abort)(context->target, e);
  352.     HTChunk_delete(context->string);
  353.     for(cnt=0; cnt<MAX_ATTRIBUTES; cnt++)       /* Leak fix Henrik 18/02-94 */
  354. if(context->value[cnt])
  355.     HT_FREE(context->value[cnt]);
  356.     HT_FREE(context);
  357.     return HT_ERROR;
  358. }
  361. /* Read and write user callback handle
  362. ** -----------------------------------
  363. **
  364. **   The callbacks from the SGML parser have an SGML context parameter.
  365. **   These calls allow the caller to associate his own context with a
  366. **   particular SGML context.
  367. */
  369. #ifdef CALLERDATA   
  370. PUBLIC void* SGML_callerData (HTStream * context)
  371. {
  372.     return context->callerData;
  373. }
  375. PUBLIC void SGML_setCallerData (HTStream * context, void* data)
  376. {
  377.     context->callerData = data;
  378. }
  379. #else
  380. #ifdef WWW_WIN_DLL
  381. PUBLIC void * SGML_callerData (HTStream * context) {return NULL;}
  382. PUBLIC void SGML_setCallerData (HTStream * context, void* data) {}
  383. #endif /* WWW_WIN_DLL */
  384. #endif /* CALLERDATA */
  386. PUBLIC int SGML_character (HTStream * context, char c)
  388. {
  389.     CONST SGML_dtd *dtd = context->dtd;
  390.     HTChunk *string =  context->string;
  392.     switch(context->state) {
  393.     
  394.     case S_after_open: /* Strip one trainling newline
  395.      only after opening nonempty element.  - SGML:Ugh! */
  396.         if (c=='n' && (context->current_tag->contents != SGML_EMPTY)) {
  397.     break;
  398. }
  399. context->state = S_text;
  400. goto normal_text;
  401. /* (***falls through***) */
  403.     case S_text:
  404. normal_text:
  406. #ifdef ISO_2022_JP
  407.   if (c=='33') {
  408.       context->state = S_esc;
  409.       PUTC(c);
  410.       break;
  411.   }
  412. #endif /* ISO_2022_JP */
  413. if (c=='&' && (!context->element_stack || (
  414.       context->element_stack->tag  &&
  415.       ( context->element_stack->tag->contents == SGML_MIXED
  416.    || context->element_stack->tag->contents ==
  417.         SGML_RCDATA)
  418. ))) {
  419.     string->size = 0;
  420.     context->state = S_ero;
  421.     
  422. } else if (c=='<') {
  423.     string->size = 0;
  424.     context->state = (context->element_stack &&
  425.      context->element_stack->tag  &&
  426.      context->element_stack->tag->contents == SGML_LITERAL) ?
  427.      S_literal : S_tag;
  428. } else if (c=='n') { /* Newline - ignore if before tag end! */
  429.     context->state = S_nl;
  430. } else PUTC(c);
  431. break;
  433.     case S_nl:
  434.         if (c=='<') {
  435.     string->size = 0;
  436.     context->state = (context->element_stack &&
  437. context->element_stack->tag  &&
  438. context->element_stack->tag->contents == SGML_LITERAL) ?
  439. S_literal : S_nl_tago;
  440. } else {
  441.     PUTC('n');
  442.     context->state = S_text;
  443.     goto normal_text;
  444. }
  445. break;
  447.     case S_nl_tago: /* Had newline and tag opener */
  448.         if (c != '/') {
  449.     PUTC('n'); /* Only ignore newline before </ */
  450. }
  451. context->state = S_tag;
  452. goto handle_S_tag;
  454. #ifdef ISO_2022_JP
  455.     case S_esc:
  456. if (c=='$') {
  457.     context->state = S_dollar;
  458. } else if (c=='(') {
  459.     context->state = S_paren;
  460. } else {
  461.     context->state = S_text;
  462. }
  463. PUTC(c);
  464. break;
  465.     case S_dollar:
  466. if (c=='@' || c=='B') {
  467.     context->state = S_nonascii_text;
  468. } else {
  469.     context->state = S_text;
  470. }
  471. PUTC(c);
  472. break;
  473.     case S_paren:
  474. if (c=='B' || c=='J') {
  475.     context->state = S_text;
  476. } else {
  477.     context->state = S_text;
  478. }
  479. PUTC(c);
  480. break;
  481.     case S_nonascii_text:
  482. if (c=='33') {
  483.     context->state = S_esc;
  484.     PUTC(c);
  485. } else {
  486.     PUTC(c);
  487. }
  488. break;
  489. #endif /* ISO_2022_JP */
  491. /* In literal mode, waits only for specific end tag!
  492. ** Only foir compatibility with old servers.
  493. */
  494.     case S_literal :
  495. HTChunk_putc(string, c);
  496. if ( TOUPPER(c) != ((string->size ==1) ? '/'
  497. : context->element_stack->tag->name[string->size-2])) {
  498.     int i;
  499.     
  500.     /* If complete match, end literal */
  501.     if ((c=='>') && (!context->element_stack->tag->name[string->size-2])) {
  502. end_element(context, context->element_stack->tag);
  503. string->size = 0;
  504. context->current_attribute_number = INVALID;
  505. context->state = S_text;
  506. break;
  507.     } /* If Mismatch: recover string. */
  508.     PUTC( '<');
  509.     for (i=0; i<string->size; i++) /* recover */
  510.        PUTC(
  511.               string->data[i]);
  512.     context->state = S_text;
  513. }
  515.         break;
  517. /* Character reference or Entity
  518. */
  519.    case S_ero:
  520.     if (c=='#') {
  521.     context->state = S_cro;  /*   &# is Char Ref Open */ 
  522.     break;
  523. }
  524. context->state = S_entity;    /* Fall through! */
  526. /* Handle Entities
  527. */
  528.     case S_entity:
  529. if (isalnum(c))
  530.     HTChunk_putc(string, c);
  531. else {
  532.     HTChunk_terminate(string);
  533.     handle_entity(context, c);
  534.     context->state = S_text;
  535. }
  536. break;
  538. /* Character reference
  539. */
  540.     case S_cro:
  541. if (isalnum(c))
  542.     HTChunk_putc(string, c); /* accumulate a character NUMBER */
  543. else {
  544.     int value;
  545.     HTChunk_terminate(string);
  546.     if (sscanf(string->data, "%d", &value)==1)
  547.         PUTC((char) value);
  548.     context->state = S_text;
  549. }
  550. break;
  552. /* Tag
  553. */     
  554.     case S_tag: /* new tag */
  555. handle_S_tag:
  557. if (isalnum(c))
  558.     HTChunk_putc(string, c);
  559. else { /* End of tag name */
  560.     HTTag * t;
  561.     if (c=='/') {
  562. if (SGML_TRACE) if (string->size!=0)
  563.     TTYPrint(TDEST,"SGML:  `<%s/' found!n", string->data);
  564. context->state = S_end;
  565. break;
  566.     }
  567.     HTChunk_terminate(string) ;
  569.     t = SGMLFindTag(dtd, string->data);
  570.     if (!t) {
  571. if(SGML_TRACE) TTYPrint(TDEST, "SGML: *** Unknown element %sn",
  572. string->data);
  573. context->state = (c=='>') ? S_text : S_junk_tag;
  574. break;
  575.     }
  576.     context->current_tag = t;
  577.     
  578.     /*  Clear out attributes
  579.     */
  580.     
  581.     {
  582.         int i;
  583.         for (i=0; i< context->current_tag->number_of_attributes; i++)
  584.          context->present[i] = NO;
  585.     }
  586.     string->size = 0;
  587.     context->current_attribute_number = INVALID;
  588.     
  589.     if (c=='>') {
  590. if (context->current_tag->name) start_element(context);
  591. context->state = S_after_open;
  592.     } else {
  593.         context->state = S_tag_gap;
  594.     }
  595. }
  596. break;
  599.     case S_tag_gap: /* Expecting attribute or > */
  600. if (WHITE(c)) break; /* Gap between attributes */
  601. if (c=='>') { /* End of tag */
  602.     if (context->current_tag->name) start_element(context);
  603.     context->state = S_after_open;
  604.     break;
  605. }
  606. HTChunk_putc(string, c);
  607. context->state = S_attr; /* Get attribute */
  608. break;
  610.     /* accumulating value */
  611.     case S_attr:
  612. if (WHITE(c) || (c=='>') || (c=='=')) { /* End of word */
  613.     HTChunk_terminate(string) ;
  614.     handle_attribute_name(context, string->data);
  615.     string->size = 0;
  616.     if (c=='>') { /* End of tag */
  617. if (context->current_tag->name) start_element(context);
  618. context->state = S_after_open;
  619. break;
  620.     }
  621.     context->state = (c=='=' ?  S_equals: S_attr_gap);
  622. } else {
  623.     HTChunk_putc(string, c);
  624. }
  625. break;
  627.     case S_attr_gap: /* Expecting attribute or = or > */
  628. if (WHITE(c)) break; /* Gap after attribute */
  629. if (c=='>') { /* End of tag */
  630.     if (context->current_tag->name) start_element(context);
  631.     context->state = S_after_open;
  632.     break;
  633. } else if (c=='=') {
  634.     context->state = S_equals;
  635.     break;
  636. }
  637. HTChunk_putc(string, c);
  638. context->state = S_attr; /* Get next attribute */
  639. break;
  641.     case S_equals: /* After attr = */ 
  642. if (WHITE(c)) break; /* Before attribute value */
  643. if (c=='>') { /* End of tag */
  644.     if (SGML_TRACE) TTYPrint(TDEST, "SGML: found = but no valuen");
  645.     if (context->current_tag->name) start_element(context);
  646.     context->state = S_after_open;
  647.     break;
  648.     
  649. } else if (c==''') {
  650.     context->state = S_squoted;
  651.     break;
  653. } else if (c=='"') {
  654.     context->state = S_dquoted;
  655.     break;
  656. }
  657. HTChunk_putc(string, c);
  658. context->state = S_value;
  659. break;
  661.     case S_value:
  662. if (WHITE(c) || (c=='>')) { /* End of word */
  663.     HTChunk_terminate(string) ;
  664.     handle_attribute_value(context, string->data);
  665.     string->size = 0;
  666.     if (c=='>') { /* End of tag */
  667. if (context->current_tag->name) start_element(context);
  668. context->state = S_after_open;
  669. break;
  670.     }
  671.     else context->state = S_tag_gap;
  672. } else {
  673.     HTChunk_putc(string, c);
  674. }
  675. break;
  677.     case S_squoted: /* Quoted attribute value */
  678. if (c==''') { /* End of attribute value */
  679.     HTChunk_terminate(string) ;
  680.     handle_attribute_value(context, string->data);
  681.     string->size = 0;
  682.     context->state = S_tag_gap;
  683. } else {
  684.     HTChunk_putc(string, c);
  685. }
  686. break;
  688.     case S_dquoted: /* Quoted attribute value */
  689. if (c=='"') { /* End of attribute value */
  690.     HTChunk_terminate(string) ;
  691.     handle_attribute_value(context, string->data);
  692.     string->size = 0;
  693.     context->state = S_tag_gap;
  694. } else {
  695.     HTChunk_putc(string, c);
  696. }
  697. break;
  699.     case S_end: /* </ */
  700. if (isalnum(c))
  701.     HTChunk_putc(string, c);
  702. else { /* End of end tag name */
  703.     HTTag * t;
  704.     HTChunk_terminate(string) ;
  705.     if (!*string->data) { /* Empty end tag */
  706.         t = context->element_stack->tag;
  707.     } else {
  708. t = SGMLFindTag(dtd, string->data);
  709.     }
  710.     if (!t) {
  711. if(SGML_TRACE) TTYPrint(TDEST,
  712.     "Unknown end tag </%s>n", string->data); 
  713.     } else {
  714.         context->current_tag = t;
  715. end_element( context, context->current_tag);
  716.     }
  718.     string->size = 0;
  719.     context->current_attribute_number = INVALID;
  720.     if (c!='>') {
  721. if (SGML_TRACE && !WHITE(c))
  722.     TTYPrint(TDEST,"SGML:  `</%s%c' found!n",
  723.      string->data, c);
  724. context->state = S_junk_tag;
  725.     } else {
  726.         context->state = S_text;
  727.     }
  728. }
  729. break;
  732.     case S_junk_tag:
  733. if (c=='>') {
  734.     context->state = S_text;
  735. }
  736.     } /* switch on context->state */
  737.     return HT_OK;
  738. }
  741. PUBLIC int SGML_string (HTStream * context, CONST char* s)
  742. {
  743.     while (*s)
  744.         SGML_character(context, *s++);
  745.     return HT_OK;
  746. }
  749. PUBLIC int SGML_write (HTStream * context, CONST char* b, int l)
  750. {
  751.     while (l-- > 0)
  752.         SGML_character(context, *b++);
  753.     return HT_OK;
  754. }
  756. /*_______________________________________________________________________
  757. */
  759. /* Structured Object Class
  760. ** -----------------------
  761. */
  762. PRIVATE CONST HTStreamClass SGMLParser = 
  763. {
  764.     "SGMLParser",
  765.     SGML_flush,
  766.     SGML_free,
  767.     SGML_abort,
  768.     SGML_character, 
  769.     SGML_string,
  770.     SGML_write,
  771. }; 
  773. /* Create SGML Engine
  774. ** ------------------
  775. **
  776. ** On entry,
  777. ** dtd represents the DTD, along with
  778. ** actions is the sink for the data as a set of routines.
  779. **
  780. */
  781. PUBLIC HTStream * SGML_new (CONST SGML_dtd * dtd, HTStructured * target)
  782. {
  783.     int i;
  784.     HTStream* context;
  785.     if ((context = (HTStream  *) HT_MALLOC(sizeof(*context))) == NULL)
  786.         HT_OUTOFMEM("SGML_begin");
  788.     context->isa = &SGMLParser;
  789.     context->string = HTChunk_new(128); /* Grow by this much */
  790.     context->dtd = dtd;
  791.     context->target = target;
  792.     context->actions = (HTStructuredClass*)(((HTStream*)target)->isa);
  793.      /* Ugh: no OO */
  794.     context->state = S_text;
  795.     context->element_stack = 0; /* empty */
  796. #ifdef CALLERDATA   
  797.     context->callerData = (void*) callerData;
  798. #endif    
  799.     for(i=0; i<MAX_ATTRIBUTES; i++) context->value[i] = 0;
  801.     return context;
  802. }