: */
href = attributes_search(attributes, (Str)"HREF");
if (!str_is_empty(href)) {
Url local_url;
local_url = url_parse(href);
if (url_is_local(local_url, config)) {
/* Reference to document on this machine: */
Str describe;
Link link;
Links links;
Str name;
describe = attributes_search(attributes, (Str)"DESCRIBE");
name = attributes_search(attributes, (Str)"NAME");
link = link_create(remote, local_url, name, describe);
links = remote_links(remote);
links_append(links, link);
}
}
}
/*
* attributes_search(attributes, name)
* This routine will return the value associated with {name} in
* {attributes}. {name} must be upper-case. If {name} is not
* in {attributes}, {(Str)""} is returned.
*/
Str
attributes_search(
Attributes attributes,
Str name)
{
Attribute attribute;
ATTRIBUTES_LOOP(attribute, attributes) {
if (str_equal(attribute->upper_case_name, name)) {
return text_str_copy(attribute->value);
}
}
return (Str)"";
}
/*
* html_create()
* This routine will create and return an empty Html object.
*/
static Html
html_create(void)
{
Html html;
html = (Html)memory_allocate_zeroed(sizeof *html);
return html;
}
/*
* html_make_absolute(html, base_url)
* This routine will go through {html} converting all relative
* URL's into absolute URL's using {base_url} as the base.
*/
void
html_make_absolute(
Html html,
Url base_url)
{
Tag tag;
unsigned tag_index;
Tags tags;
unsigned size;
tags = html->tags;
size = tags_size(tags);
for (tag_index = 0; tag_index < size; tag_index++) {
Attribute attribute;
Attributes attributes;
tag = tags_fetch(tags, tag_index);
attributes = tag->attributes;
if (attributes != (Attributes)0) {
ATTRIBUTES_LOOP(attribute, attributes) {
Str upper_case_name;
upper_case_name = attribute->upper_case_name;
if (str_equal(upper_case_name, (Str)"HREF") ||
str_equal(upper_case_name, (Str)"SRC")) {
Url new_url;
unsigned new_url_size;
Str new_url_str;
Text new_url_text;
Url original_url;
Str original_url_str;
Text original_url_text;
original_url_text = attribute->value;
original_url_str = text_str_copy(original_url_text);
original_url = url_parse(original_url_str);
new_url = url_make_absolute(original_url, base_url);
new_url_str = url_str(new_url);
new_url_size = str_size(new_url_str);
new_url_text = text_create(new_url_str, new_url_size);
attribute->value = new_url_text;
}
}
}
}
}
/*
* html_parse(text)
* This routine will parse {text} into a bunch of Html objects
* and return them.
*/
Html
html_parse(
Text text)
{
unsigned index;
Html html;
Tags tags;
tags = tags_create();
html = html_create();
tags = tags_create();
html->tags = tags;
text = text_copy_shallow(text);
for (;;) {
Chr chr;
int offset;
Tag tag;
tag = tag_create();
tag->attributes = (Attributes)0;
tag->upper_case_name = (Str)"";
offset = text_chr_search(text, '<');
if (offset < 0) {
/* No more tags. Fill in the last {html} object and leave: */
tag->type = Tag_end_of_file;
tag->preceeding_text = text;
tags_append(tags, tag);
break;
}
tag->preceeding_text = text_lop_shallow(text, (unsigned)offset);
if (text_size(text) <= 1) {
goto messed_up;
}
index = 1;
while (chr_is_white_space(text_chr_fetch(text, index))) {
/*
* White-space after '<' is not permitted in "true"
* SGML. Most people who write HTML neither know nor care
* about correct SGML syntax. Hence, we will silently
* accept the white-space.
*/
index++;
}
chr = text_chr_fetch(text, index);
switch (chr) {
case '!':
{
/*
* The only SGML declarations allowed in HTML should be
* be comments.
*/
tag->type = Tag_comment;
tag->open_bracket = text_lop_shallow(text, index);
/* Sloppy! Should look for "--" */
break;
}
case '?':
/*
* While "true" SGML permits "" markup. No
* HTML should ever have it.
*/
goto messed_up;
case '/':
/* End-tag: */
/* Again, silently accept any bogus white space: */
tag->type = Tag_end;
index++;
tag->open_bracket = text_lop_white_space_shallow(text, index);
/* Get the tag name: */
tag->name = text_lop_name_shallow(text);
tag->upper_case_name = text_str_upper_case(tag->name);
index = 0;
break;
case '>':
/*
* Empty Start-tag:
*/
goto messed_up;
default:
{
if (!chr_is_name_start(chr)) {
/* Messed up tag: */
goto messed_up;
}
tag->type = Tag_start;
tag->open_bracket = text_lop_shallow(text, index);
/* Get the tag name: */
tag->name = text_lop_name_shallow(text);
tag->upper_case_name = text_str_upper_case(tag->name);
index = 0;
tag->attributes = attributes_parse(text);
}
}
/* Slurp up everything to the end-tag: */
while (chr_is_white_space(text_chr_fetch(text, index))) {
index++;
}
if (text_chr_fetch(text, index) == '>') {
index++;
tag->close_bracket = text_lop_shallow(text, index);
} else {
/* For now, slurp else everything up: */
offset = text_chr_search(text, '>');
if (offset >= 0) {
tag->close_bracket = text_lop_shallow(text, offset + 1);
} else {
goto messed_up;
}
}
assert(tag != (Tag)0);
tags_append(tags, tag);
}
return html;
messed_up:
return (Html)0;
}
/*
* html_read(url, errors)
* This routine will fetch and return the document named by {url}.
* Any errors are indicated by returning (Url)0.
*/
Html
html_read(
Url url,
Errors errors)
{
Html html;
Text text;
text = http_url_read(url, errors);
if (text == (Text)0) {
return (Html)0;
}
html = html_parse(text);
return html;
}
/*
* html_search(html, pattern, remote)
* This routine will find {pattern} in {html} and return an associated
* {Match} object; otherwise, (Match)0 is returned. {pattern} must
* be one or more words separated by single spaces. {remote} is
* saved in the resulting {Match} object.
*/
Match
html_search(
Html html,
Str pattern,
Remote remote)
{
/* The variable names are the same as the {Match} structure. */
Chr pattern_first;
unsigned pattern_size;
unsigned start_index;
unsigned size;
Tags tags;
pattern_size = str_size(pattern);
pattern_first = chr_to_upper(pattern[0]);
tags = html->tags;
size = tags_size(tags);
for (start_index = 0; start_index < size; start_index++) {
unsigned start_offset;
Tag start_tag;
Text start_text;
unsigned start_text_size;
start_tag = tags_fetch(tags, start_index);
if (tag_is_head(start_tag)) {
continue;
}
start_text = start_tag->preceeding_text;
start_text_size = text_size(start_text);
for (start_offset = 0;
start_offset < start_text_size; start_offset++) {
unsigned end_index;
int matched_white_space;
unsigned pattern_offset;
unsigned marker_index;
unsigned marker_offset;
Tag marker_tag;
if (chr_to_upper(text_chr_fetch(start_text, start_offset)) !=
pattern_first) {
continue;
}
marker_tag = (Tag)0;
/* First character matches! Try to match remaining ones:*/
pattern_offset = 0;
matched_white_space = 0;
for (end_index = start_index; end_index < size; end_index++) {
unsigned end_offset;
unsigned end_offset_start;
Tag end_tag;
Text end_text;
unsigned end_text_size;
end_tag = tags_fetch(tags, end_index);
end_text = end_tag->preceeding_text;
end_text_size = text_size(end_text);
end_offset_start =
(start_index == end_index) ? start_offset : 0;
for (end_offset = end_offset_start;
end_offset < end_text_size; end_offset++) {
Chr end_chr;
Chr pattern_chr;
end_chr =
chr_to_upper(text_chr_fetch(end_text, end_offset));
pattern_chr = chr_to_upper(pattern[pattern_offset]);
if (pattern_chr == marker_chr) {
pattern_offset += 1;
marker_index = end_index;
marker_tag = end_tag;
marker_offset = end_offset;
pattern_chr = chr_to_upper(pattern[pattern_offset]);
}
if (chr_is_white_space(end_chr)) {
if (matched_white_space) {
/* Already matched white space in pattern: */
continue;
}
end_chr = (Chr)' ';
}
if (end_chr != pattern_chr) {
goto no_match;
}
if (pattern_chr == (Chr)' ') {
matched_white_space = 1;
}
pattern_offset += 1;
if (pattern_offset == pattern_size) {
/* We have a complete match! */
Match match;
end_offset += 1;
if (marker_tag == (Tag)0){
marker_index = end_index;
marker_tag = end_tag;
marker_offset = end_offset;
}
match = (Match)memory_allocate(sizeof *match);
match->end_index = end_index;
match->end_tag = end_tag;
match->end_offset = end_offset;
match->html = html;
match->marker_index = marker_index;
match->marker_tag = marker_tag;
match->marker_offset = marker_offset;
match->pattern = pattern;
match->remote = remote;
match->start_index = start_index;
match->start_tag = start_tag;
match->start_offset = start_offset;
return match;
}
}
}
no_match:;
}
}
/* No match: */
return (Match)0;
}
/*
* html_tags(html)
* This routine will return the tags associated with {html}.
*/
Tags
html_tags(
Html html)
{
return html->tags;
}
/*
* html_write_public_annotation(html, out_file, url_name, name_value, pattern)
* This routine will write out the name...
*/
void
html_write_public_annotation(
Html html,
FILE *out_file,
Str url_name,
Str name_value)
{
unsigned index;
int insertion_point_found;
unsigned size;
Tag tag;
Tags tags;
/*
* The text of an annotation starts immediately after the tag.
*/
insertion_point_found = 0;
tags = html->tags;
size = tags_size(tags);
for (index = 0; index < size; index++) {
Str upper_case_name;
tag = tags_fetch(tags, index);
upper_case_name = tag->upper_case_name;
text_write(tag->preceeding_text, out_file);
tag_write(tag, out_file);
if (!insertion_point_found &&
(tag->type == Tag_start) &&
str_equal(upper_case_name, (Str)"PRE")) {
/* Found the insertion point: */
insertion_point_found = 1;
/* Delete any previous hypertext link: */
if (index + 5 < size) {
Tag tag1;
Tag tag2;
Tag tag3;
Tag tag4;
Tag tag5;
tag1 = tags_fetch(tags, index + 1);
tag2 = tags_fetch(tags, index + 2);
tag3 = tags_fetch(tags, index + 3);
tag4 = tags_fetch(tags, index + 4);
tag5 = tags_fetch(tags, index + 5);
if ((tag1->type == Tag_end) &&
str_equal(tag1->upper_case_name, (Str)"PRE") &&
(tag2->type == Tag_start) &&
str_equal(tag2->upper_case_name, (Str)"A") &&
str_equal(text_str_copy(tag2->preceeding_text),
(Str)"\nPublic annotation for\n") &&
(tag3->type == Tag_end) &&
str_equal(tag3->upper_case_name, (Str)"A") &&
(tag4->type == Tag_start) &&
str_equal(tag4->upper_case_name, (Str)"P")) {
/* Delete next 4 tags */
index += 4;
/* Delete new-line at beginning of {tag5}. */
(void)text_lop_shallow(tag5->preceeding_text, 1);
}
}
/* Output the new hypertext link: */
(void)fprintf(out_file,
"\n"
"Public annotation for\n"
/**/ "\n"
/**/ "%s.\n",
url_name, name_value, url_name);
}
}
}
/*
* html_write_remaining(html, out_file, with_markup)
* This routine will resume writing the tags {Html} starting with
* tag in {html} to {out_file}. If {with_markup} is 1, all SGML
* markup will be output; otherwise, all SGML markup will be omitted.
*/
void
html_write_remaining(
Html html,
FILE *out_file,
int with_markup)
{
unsigned index;
Tag tag;
Tags tags;
unsigned size;
tags = html->tags;
size = tags_size(tags);
index = html->index;
if (index < size) {
tag = tags_fetch(tags, html->index);
if (with_markup) {
tag_write(tag, out_file);
}
}
for (index += 1; index < size; index++) {
tag = tags_fetch(tags, index);
text_write(tag->preceeding_text, out_file);
if (with_markup) {
tag_write(tag, out_file);
}
}
}
/*
* html_write_to_body_end(html, out_file, matches, with_markup)
* This routine will write write the {Html} chain starting with {html}
* to {out_file} until either a