/*
** Header is terminated by CRCR, LFLF, CRLFLF, CRLFCRLF
** Folding is either of CF LWS, LF LWS, CRLF LWS
*/
PRIVATE int HTMIME_put_block (HTStream * me, const char * b, int l)
{
const char * start = b;
const char * end = start;
const char * value = HTChunk_size(me->value) > 0 ? b : NULL;
int length = l;
int status;
while (!me->transparent) {
if (me->EOLstate == EOL_FCR) {
if (*b == CR) /* End of header */
me->EOLstate = EOL_END;
else if (*b == LF) /* CRLF */
me->EOLstate = EOL_FLF;
else if (isspace((int) *b)) /* Folding: CR SP */
me->EOLstate = EOL_FOLD;
else /* New line */
me->EOLstate = EOL_LINE;
} else if (me->EOLstate == EOL_FLF) {
if (*b == CR) /* LF CR or CR LF CR */
me->EOLstate = EOL_SCR;
else if (*b == LF) /* End of header */
me->EOLstate = EOL_END;
else if (isspace((int) *b)) /* Folding: LF SP or CR LF SP */
me->EOLstate = EOL_FOLD;
else /* New line */
me->EOLstate = EOL_LINE;
} else if (me->EOLstate == EOL_SCR) {
if (*b==CR || *b==LF) /* End of header */
me->EOLstate = EOL_END;
else if (isspace((int) *b)) /* Folding: LF CR SP or CR LF CR SP */
me->EOLstate = EOL_FOLD;
else /* New line */
me->EOLstate = EOL_LINE;
} else if (*b == CR)
me->EOLstate = EOL_FCR;
else if (*b == LF)
me->EOLstate = EOL_FLF; /* Line found */
else {
if (!me->haveToken) {
if (*b == ':' || isspace((int) *b)) {
HTChunk_putb(me->token, start, end-start);
HTChunk_putc(me->token, '\0');
me->haveToken = YES;
} else {
unsigned char ch = *(unsigned char *) b;
ch = TOLOWER(ch);
me->hash = (me->hash * 3 + ch) % MIME_HASH_SIZE;
}
} else if (value == NULL && *b != ':' && !isspace((int) *b))
value = b;
end++;
}
switch (me->EOLstate) {
case EOL_LINE:
case EOL_END:
{
int ret = HT_ERROR;
HTChunk_putb(me->value, value, end-value);
HTChunk_putc(me->value, '\0');
ret = _stream2dispatchParsers(me);
HTNet_addBytesRead(me->net, b-start);
start=b, end=b;
if (me->EOLstate == EOL_END) { /* EOL_END */
if (ret == HT_OK) {
b++, l--;
ret = pumpData(me);
HTNet_addBytesRead(me->net, 1);
if (me->mode & (HT_MIME_FOOTER | HT_MIME_CONT)) {
HTHost_setConsumed(HTNet_host(me->net), length - l);
return ret;
} else {
HTNet_setHeaderBytesRead(me->net, HTNet_bytesRead(me->net));
}
}
} else { /* EOL_LINE */
HTChunk_truncate(me->token,0);
HTChunk_truncate(me->value,0);
me->haveToken = NO;
me->hash = 0;
value = NULL;
}
me->EOLstate = EOL_BEGIN;
if (ret != HT_OK && ret != HT_LOADED) return ret;
break;
}
case EOL_FOLD:
me->EOLstate = EOL_BEGIN;
if (!me->haveToken) {
HTChunk_putb(me->token, start, end-start);
HTChunk_putc(me->token, '\0');
me->haveToken = YES;
} else if (value) {
HTChunk_putb(me->value, value, end-value);
HTChunk_putc(me->value, ' ');
}
start=b, end=b;
break;
default:
b++, l--;
if (!l) {
BOOL stop = NO;
if (!me->haveToken) {
/* If empty header then prepare to stop */
if (end-start)
HTChunk_putb(me->token, start, end-start);
else
stop = YES;
} else if (value)
HTChunk_putb(me->value, value, end-value);
HTHost_setConsumed(HTNet_host(me->net), length - l);
return stop ? pumpData(me) : HT_OK;
}
}
}
if (length != l) HTHost_setConsumed(HTNet_host(me->net), length - l);
/*
** Put the rest down the stream without touching the data but make sure
** that we get the correct content length of data. If we have a CL in
** the headers then this stream is responsible for the accountance.
*/
if (me->hasBody) {
HTNet * net = me->net;
/* Check if CL at all - thanks to [email protected] (John Wei) */
long cl = HTResponse_length(me->response);
if (cl >= 0) {
long bodyRead = HTNet_bytesRead(net) - HTNet_headerBytesRead(net);
/*
** If we have more than we need then just take what belongs to us.
*/
if (bodyRead + l >= cl) {
int consume = cl - bodyRead;
if ((status = (*me->target->isa->put_block)(me->target, b, consume)) < 0)
return status;
else {
HTAlertCallback * cbf = HTAlert_find(HT_PROG_DONE);
HTNet_addBytesRead(net, consume);
HTHost_setConsumed(HTNet_host(net), consume);
if (cbf) (*cbf)(me->request, HT_PROG_DONE, HT_MSG_NULL, NULL, NULL, NULL);
return HT_LOADED;
}
} else {
if ((status = (*me->target->isa->put_block)(me->target, b, l)) < 0)
return status;
HTNet_addBytesRead(net, l);
HTHost_setConsumed(HTNet_host(net), l);
return status;
}
}
return (*me->target->isa->put_block)(me->target, b, l);
} else {
HTAlertCallback * cbf = HTAlert_find(HT_PROG_DONE);
if (cbf) (*cbf)(me->request, HT_PROG_DONE, HT_MSG_NULL, NULL, NULL, NULL);
}
return HT_LOADED;
}
PRIVATE int SGML_write (HTStream * context, const char * b, int l)
{
const SGML_dtd *dtd = context->dtd;
HTChunk *string = context->string;
const char *text = b;
int count = 0;
while (l-- > 0)
{
char c = *b++;
switch(context->state)
{
got_element_open:
/*
** The label is jumped when the '>' of a the element
** start tag has been detected. This DOES NOT FALL TO
** THE CODE S_after_open, only processes the tag and
** sets the state (c should still contain the
** terminating character of the tag ('>'))
*/
if (context->current_tag && context->current_tag->name)
start_element(context);
context->state = S_after_open;
break;
case S_after_open:
/*
** State S_after_open is entered only for single
** character after the element opening tag to test
** against newline. Strip one trainling newline only
** after opening nonempty element. - SGML: Ugh!
*/
text = b;
count = 0;
if (c == '\n' && (context->contents != SGML_EMPTY))
{
context->state = S_text;
break;
}
--text;
goto S_text;
S_text:
context->state = S_text;
case S_text:
#ifdef ISO_2022_JP
if (c == '\033')
{
context->state = S_esc;
++count;
break;
}
#endif /* ISO_2022_JP */
if (c == '&')
{
if (count > 0)
PUTB(text, count);
count = 0;
HTChunk_clear(string);
context->state = S_ero;
}
else if (c == '<')
{
if (count > 0)
PUTB(text, count);
count = 0;
HTChunk_clear(string);
/* should scrap LITERAL, and use CDATA and
RCDATA -- msa */
context->state =
(context->contents == SGML_LITERAL) ?
S_literal : S_tag;
}
else if (c == '\n')
/* Newline - ignore if before end tag! */
context->state = S_nl;
else
++count;
break;
case S_nl:
if (c == '<')
{
if (count > 0)
PUTB(text, count);
count = 0;
HTChunk_clear(string);
context->state =
(context->contents == SGML_LITERAL) ?
S_literal : S_nl_tago;
}
else
{
++count;
goto S_text;
}
break;
case S_nl_tago: /* Had newline and tag opener */
if (c != '/')
PUTC('\n'); /* Only ignore newline before </ */
context->state = S_tag;
goto handle_S_tag;
#ifdef ISO_2022_JP
case S_esc:
if (c=='$')
context->state = S_dollar;
else if (c=='(')
context->state = S_paren;
else
context->state = S_text;
++count;
break;
case S_dollar:
if (c=='@' || c=='B')
context->state = S_nonascii_text;
else
context->state = S_text;
++count;
break;
case S_paren:
if (c=='B' || c=='J')
context->state = S_text;
else
context->state = S_text;
++count;
break;
case S_nonascii_text:
if (c == '\033')
context->state = S_esc;
++count;
break;
#endif /* ISO_2022_JP */
/* In literal mode, waits only for specific end tag!
** Only foir compatibility with old servers.
*/
case S_literal:
HTChunk_putc(string, c);
if ( TOUPPER(c) !=
((HTChunk_size(string) == 1) ? '/'
: context->current_tag->name[HTChunk_size(string)-2]))
{
/* If complete match, end literal */
if ((c == '>') &&
(!context->current_tag->name[HTChunk_size(string)-2]))
{
end_element
(context,context->current_tag);
/*
...setting SGML_MIXED below is a
bit of kludge, but a good guess that
currently works, anything other than
SGML_LITERAL would work... -- msa */
context->contents = SGML_MIXED;
}
else
{
/* If Mismatch: recover string. */
PUTC( '<');
PUTB(HTChunk_data(string), HTChunk_size(string));
}
context->state = S_text;
text = b;
count = 0;
}
break;
/*
** Character reference or Entity
*/
case S_ero:
if (c == '#')
{
/* &# is Char Ref Open */
context->state = S_cro;
break;
}
context->state = S_entity;
/** FALL THROUGH TO S_entity !! ***/
/*
** Handle Entities
*/
case S_entity:
if (isalnum((int) c))
HTChunk_putc(string, c);
else
{
HTChunk_terminate(string);
handle_entity(context);
text = b;
count = 0;
if (c != ';')
{
--text;
goto S_text;
}
context->state = S_text;
}
break;
/* Character reference
*/
case S_cro:
if (isalnum((int)c))
/* accumulate a character NUMBER */
HTChunk_putc(string, c);
else
{
int value;
HTChunk_terminate(string);
if (sscanf(HTChunk_data(string), "%d", &value)==1)
PUTC((char)value);
else
{
PUTB("&#", 2);
PUTB(HTChunk_data(string), HTChunk_size(string)-1);
}
text = b;
count = 0;
if (c != ';')
{
--text;
goto S_text;
}
context->state = S_text;
}
break;
case S_tag: /* new tag */
handle_S_tag:
if (isalnum((int)c))
HTChunk_putc(string, c);
else { /* End of tag name */
int i;
if (c == '/') {
if (HTChunk_size(string) > 0)
HTTRACE(SGML_TRACE, "`<%s/' found!\n" _ HTChunk_data(string));
context->state = S_end;
break;
} else if (c == '!') {
if (HTChunk_size(string) > 0)
HTTRACE(SGML_TRACE, " `<%s!' found!\n" _ HTChunk_data(string));
context->state = S_md;
break;
}
HTChunk_terminate(string);
context->current_tag = SGMLFindTag(dtd, HTChunk_data(string));
if (context->current_tag == NULL) {
HTTRACE(SGML_TRACE, "*** Unknown element %s\n" _ HTChunk_data(string));
(*context->actions->unparsed_begin_element)
(context->target, HTChunk_data(string), HTChunk_size(string));
} else {
for (i=0; i<context->current_tag->number_of_attributes; i++) {
context->present[i] = NO;
context->value[i] = -1;
}
}
context->token = 0;
HTChunk_clear(string);
context->current_attribute_number = INVALID;
goto S_tag_gap;
}
break;
S_tag_gap:
context->state = S_tag_gap;
case S_tag_gap: /* Expecting attribute or > */
if (isspace((int) c))
break; /* Gap between attributes */
if (c == '>')
goto got_element_open;
else
goto S_attr;
S_attr:
/*
** Start collecting the attribute name and collect
** it in S_attr.
*/
context->state = S_attr;
HTChunk_truncate(string, context->token);
case S_attr:
if (isspace((int) c) || c == '>' || c == '=')
goto got_attribute_name;
else
HTChunk_putc(string, c);
break;
got_attribute_name:
/*
** This label is entered when attribute name has been
** collected. Process it and enter S_attr_gap for
** potential value or start of the next attribute.
*/
HTChunk_terminate(string) ;
handle_attribute_name
(context, HTChunk_data(string) + context->token);
HTChunk_truncate(string, context->token);
context->state = S_attr_gap;
case S_attr_gap: /* Expecting attribute or = or > */
if (isspace((int) c))
break; /* Gap after attribute */
if (c == '>')
goto got_element_open;
else if (c == '=')
context->state = S_equals;
else
goto S_attr; /* Get next attribute */
break;
case S_equals: /* After attr = */
if (isspace((int) c))
break; /* Before attribute value */
if (c == '>')
{ /* End of tag */
HTTRACE(SGML_TRACE, "found = but no value\n");
goto got_element_open;
}
else if (c == '\'')
context->state = S_squoted;
else if (c == '"')
context->state = S_dquoted;
else
goto S_value;
break;
S_value:
context->state = S_value;
HTChunk_truncate(string, context->token);
case S_value:
if (isspace((int) c) || c == '>')
{
HTChunk_terminate(string);
handle_attribute_value(context);
context->token = HTChunk_size(string);
goto S_tag_gap;
}
else
HTChunk_putc(string, c);
break;
case S_squoted: /* Quoted attribute value */
if (c == '\'')
{
HTChunk_terminate(string);
handle_attribute_value(context);
context->token = HTChunk_size(string);
context->state = S_tag_gap;
}
else if (c && c != '\n' && c != '\r')
HTChunk_putc(string, c);
break;
case S_dquoted: /* Quoted attribute value */
if (c == '"')
{
HTChunk_terminate(string);
handle_attribute_value(context);
context->token = HTChunk_size(string);
context->state = S_tag_gap;
}
else if (c && c != '\n' && c != '\r')
HTChunk_putc(string, c);
break;
case S_end: /* </ */
if (isalnum((int) c))
HTChunk_putc(string, c);
else
{ /* End of end tag name */
HTTag *t;
char * first;
HTChunk_terminate(string);
if ((first=HTChunk_data(string))!=NULL && *first != '\0')
t = SGMLFindTag(dtd, HTChunk_data(string));
else
/* Empty end tag */
/* Original code popped here one
from the stack. If this feature
is required, I have to put the
stack back... -- msa */
t = NULL;
if (!t) {
HTTRACE(SGML_TRACE, "Unknown end tag </%s>\n" _ HTChunk_data(string));
(*context->actions->unparsed_end_element)
(context->target, HTChunk_data(string), HTChunk_size(string));
} else {
context->current_tag = NULL;
end_element(context, t);
}
HTChunk_clear(string);
context->current_attribute_number = INVALID;
if (c != '>')
{
if (!isspace((int) c))
HTTRACE(SGML_TRACE, "`</%s%c' found!\n" _ HTChunk_data(string) _ c);
context->state = S_junk_tag;
}
else
{
text = b;
count = 0;
context->state = S_text;
}
}
break;
case S_junk_tag:
if (c == '>')
{
text = b;
count = 0;
context->state = S_text;
}
break;
/*
** Scanning (actually skipping) declarations
*/
case S_md:
if (c == '-')
context->state = S_com_1;
else if (c == '"')
context->state = S_md_dqs;
else if (c == '\'')
context->state = S_md_sqs;
else if (c == '>')
{
text = b;
count = 0;
context->state = S_text;
}
break;
case S_md_dqs: /* Skip double quoted string */
if (c == '"')
context->state = S_md;
else if (c == '>')
{
text = b;
count = 0;
context->state = S_text;
}
break;
case S_md_sqs: /* Skip single quoted string */
if (c == '\'')
context->state = S_md;
else if (c == '>')
{
text = b;
count = 0;
context->state = S_text;
}
break;
case S_com_1: /* Starting a comment? */
context->state = (c == '-') ? S_com : S_md;
if (c == '>')
{
text = b;
count = 0;
context->state = S_text;
}
break;
case S_com: /* ..within comment */
if (c == '-')
context->state = S_com_2;
break;
case S_com_2: /* Ending a comment ? */
context->state = (c == '-') ? S_com_2a : S_com;
break;
case S_com_2a:
if (c == '>') {
text = b;
count = 0;
context->state = S_text;
} else if (c == '-') {
context->state = S_com_2a;
} else
context->state = S_com;
break;
}
}
if (count > 0)
PUTB(text, count);
return HT_OK;
}
PUBLIC BOOL HTBind_add (const char * suffix,
const char * representation,
const char * encoding,
const char * transfer,
const char * language,
double value)
{
HTBind * suff;
if (!suffix)
return NO;
if (!strcmp(suffix, "*"))
suff = &no_suffix;
else if (!strcmp(suffix, "*.*"))
suff = &unknown_suffix;
else {
HTList * suflist;
int hash;
const unsigned char * p;
/* Select list from hash table */
for (p=suffix, hash=0; *p; p++) {
hash = (hash * 3 + TOLOWER(*p)) % HT_L_HASH_SIZE;
}
if (!HTBindings) HTBind_init();
if (!HTBindings[hash]) HTBindings[hash] = HTList_new();
suflist = HTBindings[hash];
/* Look for existing binding */
{
HTList *cur = suflist;
while ((suff = (HTBind *) HTList_nextObject(cur)) != NULL) {
if (!strcmp(suff->suffix, suffix))
break;
}
}
/* If not found -- create a new node */
if (!suff) {
if ((suff = (HTBind *) HT_CALLOC(1, sizeof(HTBind))) == NULL)
HT_OUTOFMEM("HTBind_add");
HTList_addObject(suflist, (void *) suff);
StrAllocCopy(suff->suffix, suffix);
}
}
/* Set the appropriate values */
{
HTChunk * chunk = HTChunk_new(32);
char *ptr;
if (representation) {
HTChunk_puts(chunk, representation);
ptr = HTChunk_data(chunk);
for (; *ptr; ptr++)
*ptr = TOLOWER(*ptr);
suff->type = HTAtom_for(HTChunk_data(chunk));
HTChunk_truncate(chunk,0);
}
if (encoding) {
HTChunk_puts(chunk, encoding);
ptr = HTChunk_data(chunk);
for (; *ptr; ptr++)
*ptr = TOLOWER(*ptr);
suff->encoding = HTAtom_for(HTChunk_data(chunk));
HTChunk_truncate(chunk,0);
}
if (transfer) {
HTChunk_puts(chunk, transfer);
ptr = HTChunk_data(chunk);
for (; *ptr; ptr++)
*ptr = TOLOWER(*ptr);
suff->transfer = HTAtom_for(HTChunk_data(chunk));
HTChunk_truncate(chunk,0);
}
if (language) {
HTChunk_puts(chunk, language);
ptr = HTChunk_data(chunk);
for (; *ptr; ptr++)
*ptr = TOLOWER(*ptr);
suff->language = HTAtom_for(HTChunk_data(chunk));
HTChunk_truncate(chunk,0);
}
HTChunk_delete(chunk);
suff->quality = value;
}
return YES;
}
PRIVATE void HTML_start_element (HTStructured * me,
int element_number,
const BOOL * present,
const char ** value)
{
HTChildAnchor * address = NULL;
if (!me->started) {
HTextImp_build(me->text, HTEXT_BEGIN);
me->started = YES;
}
/* Look at what element was started */
switch (element_number) {
case HTML_A:
if (present[HTML_A_HREF] && value[HTML_A_HREF]) {
address = HTAnchor_findChildAndLink(
me->node_anchor, /* parent */
present[HTML_A_NAME] ? value[HTML_A_NAME] : NULL, /* Tag */
value[HTML_A_HREF], /* Addresss */
present[HTML_A_REL] && value[HTML_A_REL] ?
(HTLinkType) HTAtom_caseFor(value[HTML_A_REL]) : NULL);
if (present[HTML_A_TITLE] && value[HTML_A_TITLE]) {
HTLink * link = HTAnchor_mainLink((HTAnchor *) address);
HTParentAnchor * dest = HTAnchor_parent(HTLink_destination(link));
if (!HTAnchor_title(dest)) HTAnchor_setTitle(dest, value[HTML_A_TITLE]);
}
HTextImp_foundLink(me->text, element_number, HTML_A_HREF,
address, present, value);
HTTRACE(SGML_TRACE, "HTML Parser. Anchor `%s\'\n" _ value[HTML_A_HREF]);
}
break;
case HTML_AREA:
if (present[HTML_AREA_HREF] && value[HTML_AREA_HREF]) {
address = HTAnchor_findChildAndLink(me->node_anchor, NULL,
value[HTML_AREA_HREF], NULL);
HTextImp_foundLink(me->text, element_number, HTML_AREA_HREF,
address, present, value);
HTTRACE(SGML_TRACE, "HTML Parser. Image map area `%s\'\n" _ value[HTML_AREA_HREF]);
}
break;
case HTML_BASE:
if (present[HTML_BASE_HREF] && value[HTML_BASE_HREF]) {
HTAnchor_setBase(me->node_anchor, (char *) value[HTML_BASE_HREF]);
HTTRACE(SGML_TRACE, "HTML Parser. New base `%s\'\n" _ value[HTML_BASE_HREF]);
}
break;
case HTML_BODY:
if (present[HTML_BODY_BACKGROUND] && value[HTML_BODY_BACKGROUND]) {
address = HTAnchor_findChildAndLink(me->node_anchor, NULL,
value[HTML_BODY_BACKGROUND], NULL);
HTextImp_foundLink(me->text, element_number, HTML_BODY_BACKGROUND,
address, present, value);
HTTRACE(SGML_TRACE, "HTML Parser. Background `%s\'\n" _ value[HTML_BODY_BACKGROUND]);
}
break;
case HTML_FORM:
if (present[HTML_FORM_ACTION] && value[HTML_FORM_ACTION]) {
address = HTAnchor_findChildAndLink(me->node_anchor, NULL,
value[HTML_FORM_ACTION], NULL);
HTextImp_foundLink(me->text, element_number, HTML_FORM_ACTION,
address, present, value);
}
break;
case HTML_FRAME:
if (present[HTML_FRAME_SRC] && value[HTML_FRAME_SRC]) {
address = HTAnchor_findChildAndLink(me->node_anchor, NULL,
value[HTML_FRAME_SRC], NULL);
HTextImp_foundLink(me->text, element_number, HTML_FRAME_SRC,
address, present, value);
HTTRACE(SGML_TRACE, "HTML Parser. Frame `%s\'\n" _ value[HTML_FRAME_SRC]);
}
break;
case HTML_INPUT:
if (present[HTML_INPUT_SRC] && value[HTML_INPUT_SRC]) {
address = HTAnchor_findChildAndLink(me->node_anchor, NULL,
value[HTML_INPUT_SRC], NULL);
HTextImp_foundLink(me->text, element_number, HTML_INPUT_SRC,
address, present, value);
}
break;
case HTML_IMG:
if (present[HTML_IMG_SRC] && value[HTML_IMG_SRC]) {
address = HTAnchor_findChildAndLink(me->node_anchor, NULL,
value[HTML_IMG_SRC], NULL);
HTextImp_foundLink(me->text, element_number, HTML_IMG_SRC,
address, present, value);
}
break;
case HTML_ISINDEX:
HTAnchor_setIndex(me->node_anchor);
break;
case HTML_LINK:
if (present[HTML_LINK_HREF] && value[HTML_LINK_HREF]) {
HTParentAnchor * dest = NULL;
address = HTAnchor_findChildAndLink(
me->node_anchor, /* parent */
present[HTML_A_NAME] ? value[HTML_A_NAME] : NULL, /* Tag */
present[HTML_A_HREF] ? value[HTML_A_HREF] : NULL, /* Addresss */
NULL); /* Rels */
dest = HTAnchor_parent(HTAnchor_followMainLink((HTAnchor *) address));
/* If forward reference */
if ((present[HTML_LINK_REL] && value[HTML_LINK_REL])) {
char * strval = NULL;
char * ptr = NULL;
char * relation = NULL;
StrAllocCopy(strval, value[HTML_LINK_REL]);
ptr = strval;
while ((relation = HTNextLWSToken(&ptr)) != NULL) {
HTLink_add((HTAnchor *) me->node_anchor, (HTAnchor *) dest,
(HTLinkType) HTAtom_caseFor(relation),
METHOD_INVALID);
}
HT_FREE(strval);
}
/* If reverse reference */
if ((present[HTML_LINK_REV] && value[HTML_LINK_REV])) {
char * strval = NULL;
char * ptr = NULL;
char * relation = NULL;
StrAllocCopy(strval, value[HTML_LINK_REV]);
ptr = strval;
while ((relation = HTNextLWSToken(&ptr)) != NULL) {
HTLink_add((HTAnchor *) dest, (HTAnchor *) me->node_anchor,
(HTLinkType) HTAtom_caseFor(relation),
METHOD_INVALID);
}
HT_FREE(strval);
}
/* If we got any type information as well */
if (present[HTML_LINK_TYPE] && value[HTML_LINK_TYPE]) {
if (HTAnchor_format(dest) == WWW_UNKNOWN)
HTAnchor_setFormat(dest,
(HTFormat) HTAtom_caseFor(value[HTML_LINK_TYPE]));
}
/* Call out to the layout engine */
HTextImp_foundLink(me->text, element_number, HTML_LINK_HREF,
address, present, value);
}
break;
case HTML_META:
if (present[HTML_META_NAME] && value[HTML_META_NAME]) {
HTAnchor_addMeta (me->node_anchor,
value[HTML_META_NAME],
(present[HTML_META_CONTENT] && value[HTML_META_CONTENT]) ?
value[HTML_META_CONTENT] : "");
}
break;
case HTML_OBJECT:
if (present[HTML_OBJECT_CLASSID] && value[HTML_OBJECT_CLASSID]) {
address = HTAnchor_findChildAndLink(me->node_anchor, NULL,
value[HTML_OBJECT_CLASSID], NULL);
HTextImp_foundLink(me->text, element_number, HTML_OBJECT_CLASSID,
address, present, value);
}
if (present[HTML_OBJECT_CODEBASE] && value[HTML_OBJECT_CODEBASE]) {
address = HTAnchor_findChildAndLink(me->node_anchor, NULL,
value[HTML_OBJECT_CODEBASE], NULL);
HTextImp_foundLink(me->text, element_number, HTML_OBJECT_CODEBASE,
address, present, value);
}
if (present[HTML_OBJECT_DATA] && value[HTML_OBJECT_DATA]) {
address = HTAnchor_findChildAndLink(me->node_anchor, NULL,
value[HTML_OBJECT_DATA], NULL);
HTextImp_foundLink(me->text, element_number, HTML_OBJECT_DATA,
address, present, value);
}
if (present[HTML_OBJECT_ARCHIVE] && value[HTML_OBJECT_ARCHIVE]) {
address = HTAnchor_findChildAndLink(me->node_anchor, NULL,
value[HTML_OBJECT_ARCHIVE], NULL);
HTextImp_foundLink(me->text, element_number, HTML_OBJECT_ARCHIVE,
address, present, value);
}
if (present[HTML_OBJECT_USEMAP] && value[HTML_OBJECT_USEMAP]) {
address = HTAnchor_findChildAndLink(me->node_anchor, NULL,
value[HTML_OBJECT_USEMAP], NULL);
HTextImp_foundLink(me->text, element_number, HTML_OBJECT_USEMAP,
address, present, value);
}
break;
case HTML_PRE:
if (me->comment_end)
HTextImp_addText(me->text, me->comment_end, strlen(me->comment_end));
break;
case HTML_TITLE:
HTChunk_truncate(me->title,0);
break;
}
/* Update our parse stack */
if (SGML_findTagContents(me->dtd, element_number) != SGML_EMPTY) {
if (me->sp == me->stack) {
HTTRACE(SGML_TRACE, "HTML Parser. Maximum nesting of %d exceded!\n" _ MAX_NESTING);
me->overflow++;
return;
}
--(me->sp);
me->sp[0] = element_number;
}
/* Call out to the layout engine */
HTextImp_beginElement(me->text, element_number, present, value);
}
