This repository has been archived on 2023-08-20. You can view files and clone it, but cannot push or open issues or pull requests.
yap-6.3/packages/sgml/sgml.c

456 lines
9.5 KiB
C
Raw Normal View History

/* $Id$
Part of SWI-Prolog
Author: Jan Wielemaker
E-mail: wielemak@science.uva.nl
WWW: http://www.swi-prolog.org
Copyright (C): 1985-2006, University of Amsterdam
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#define _ISOC99_SOURCE 1 /* fwprintf(), etc prototypes */
#include <stdio.h>
#include "dtd.h"
#include "util.h"
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <wctype.h>
#include <wchar.h>
#include <locale.h>
#define streq(s1, s2) (strcmp(s1, s2) == 0)
char *program;
int nerrors = 0;
int nwarnings = 0;
int style_messages = FALSE;
static void
usage(void)
{ fprintf(stderr,
"Usage: %s [-xml] [-s] [-nodefs] [file.dtd] [file]\n\n", program);
fprintf(stderr,
"\t-xml\tForce XML mode\n"
"\t-s\tSilent: only report errors and warnings\n"
"\t-style\tWarn about correct but dubious input\n"
"\t-nodefs\tDo not include defaulted attributes\n");
exit(EXIT_FAILURE);
}
static int
wputc(int c, FILE *f)
{ char buf[MB_CUR_MAX];
int i, len = wctomb(buf, c);
for(i=0; i<len; i++)
putc(buf[i], f);
return c;
}
static void
print_word(dtd_parser * p, char c, /* preceding character */
ichar const *s, /* where to start */
ichar const *e) /* where to end (at NUL if e is NULL) */
{ FILE *f = stdout;
ichar x;
wputc(c, f);
if (p->dtd->case_sensitive)
{ if (e != 0)
while (s != e)
wputc(*s++, f);
else
while ((x = *s++) != (ichar) 0)
wputc(x, f);
} else
{ if (e != 0)
while (s != e)
wputc(towupper((wint_t)*s++), f);
else
while ((x = *s++) != (ichar) 0)
wputc(towupper(x), f);
}
}
static void
wprint_escaped(FILE *f, const wchar_t *s, int len)
{ const wchar_t *e = &s[len];
while ( s < e )
{ wint_t x = *s++;
if (x >= ' ')
{ if (x == '\\') /* \ --> \\ */
wputc(x, f);
wputc(x, f);
} else if (x == '\t')
{ wputc(x, f); /* \t */
} else if (x == '\n')
{ fprintf(f, "\\n"); /* \n */
} else
{ fprintf(f, "\\%03o", x);
}
}
}
static void
print_cdata(char c, sgml_attribute *a)
{ wputc(c, stdout);
wprint_escaped(stdout, a->value.textW, a->value.number);
wputc('\n', stdout);
}
static int
print_close(dtd_parser * p, dtd_element * e)
{ print_word(p, ')', e->name->name, 0);
putchar('\n');
return TRUE;
}
typedef struct atdef
{ attrtype type; /* AT_* */
char const *name; /* name */
int islist; /* list-type */
} atdef;
static atdef attrs[] = {
{AT_CDATA, "CDATA", FALSE},
{AT_ENTITY, "ENTITY", FALSE},
{AT_ENTITIES, "ENTITY", TRUE},
{AT_ID, "ID", FALSE},
{AT_IDREF, "IDREF", FALSE},
{AT_IDREFS, "IDREF", TRUE},
{AT_NAME, "NAME", FALSE},
{AT_NAMES, "NAME", TRUE},
{AT_NMTOKEN, "NMTOKEN", FALSE},
{AT_NMTOKENS, "NMTOKEN", TRUE},
{AT_NUMBER, "NUMBER", FALSE},
{AT_NUMBERS, "NUMBER", TRUE},
{AT_NUTOKEN, "NUTOKEN", FALSE},
{AT_NUTOKENS, "NUTOKEN", TRUE},
{AT_NOTATION, "NOTATION", FALSE},
{AT_CDATA, (char *) 0, FALSE}
};
static atdef *
find_attrdef(attrtype type)
{ atdef *ad;
for (ad = attrs; ad->name != (char *) 0; ad++)
{ if (ad->type == type)
return ad;
}
assert(0);
return (atdef *) 0;
}
static ichar *
istrblank(ichar const *s)
{ for (; *s; s++)
{ if (iswspace(*s))
return (ichar *) s;
}
return (ichar *) 0;
}
static int
print_open(dtd_parser * p, dtd_element * e, int argc, sgml_attribute *argv)
{ int i;
for (i = 0; i < argc; i++)
{ print_word(p, 'A', argv[i].definition->name->name, 0);
switch (argv[i].definition->type)
{ case AT_CDATA:
printf(" CDATA");
print_cdata(' ', &argv[i]);
continue; /* so we don't get two line breaks */
case AT_NUMBER:
printf(" NUMBER ");
if (argv[i].value.textW)
print_word(p, ' ', argv[i].value.textW, 0);
else
printf("%ld", argv[i].value.number);
break;
case AT_NAMEOF:
printf(" NAME");
print_word(p, ' ', argv[i].value.textW, 0);
break;
default:
{ atdef *ad = find_attrdef(argv[i].definition->type);
ichar const *val = argv[i].value.textW;
printf(" %s", ad->name);
if (ad->islist)
{ ichar const *n;
while ((n = istrblank(val)) != 0)
{ if (n != val)
print_word(p, ' ', val, n);
val = n + 1;
}
}
print_word(p, ' ', val, 0);
}
break;
}
putchar('\n');
}
print_word(p, '(', e->name->name, 0);
putchar('\n');
return TRUE;
}
static int
print_data(dtd_parser * p, data_type type, int len, const wchar_t *data)
{ char c;
switch (type)
{ case EC_CDATA:
c = '-';
break;
case EC_NDATA:
c = 'N';
break;
case EC_SDATA:
c = 'S';
break;
default:
assert(0);
}
wputc(c, stdout);
wprint_escaped(stdout, data, len);
wputc('\n', stdout);
return TRUE;
}
static int
on_entity(dtd_parser *p, dtd_entity *e, int chr)
{ if (e == 0)
printf("&#%d;\n", chr);
else
wprintf(L"&%s;\n", e->name->name);
return TRUE;
}
static int
on_pi(dtd_parser *p, ichar const *pi)
{ wputc('?', stdout);
wprint_escaped(stdout, pi, wcslen(pi));
return TRUE;
}
static dtd_srcloc *
file_location(dtd_srcloc *l)
{ while (l->parent && l->type != IN_FILE)
l = l->parent;
return l;
}
static int
on_error(dtd_parser * p, dtd_error * error)
{ char const *severity;
char const *dialect;
dtd_srcloc *l = file_location(error->location);
switch (p->dtd->dialect)
{ case DL_SGML:
dialect = "sgml";
break;
case DL_XML:
dialect = "xml";
break;
case DL_XMLNS:
default: /* make compiler happy */
dialect = "xmlns";
break;
}
switch (error->severity)
{ case ERS_STYLE:
severity = "Style";
if ( !style_messages )
return TRUE;
break;
case ERS_WARNING:
severity = "Warning";
nwarnings++;
break;
case ERS_ERROR:
default: /* make compiler happy */
severity = "Error";
nerrors++;
break;
}
if ( l->name.file )
{ fwprintf(stderr, L"%s: (%s mode) %s: %ls:%d:%d %ls\n",
program, dialect, severity,
l->name.entity, l->line, l->linepos,
error->plain_message);
} else
{ fwprintf(stderr, L"%s: (%s mode) %s: %d:%d %ls\n",
program, dialect, severity,
error->plain_message);
}
return TRUE;
}
static void
set_functions(dtd_parser * p, int output)
{ if (output)
{ p->on_end_element = print_close;
p->on_begin_element = print_open;
p->on_data = print_data;
p->on_entity = on_entity;
p->on_pi = on_pi;
}
p->on_error = on_error;
}
static wchar_t *
mb2wc(const char *s)
{ int wl = mbstowcs(NULL, s, 0);
if ( wl > 0 )
{ wchar_t *ws = malloc((wl+1)*sizeof(wchar_t));
mbstowcs(ws, s, wl+1);
return ws;
}
perror("mbstowcs");
exit(1);
}
#define shift (argc--, argv++)
#define strcaseeq(x, y) istrcaseeq((ichar const *)(x), (ichar const *)(y))
static ichar const *no_dtd = (ichar const *) NULL;
int
main(int argc, char **argv)
{ dtd_parser *p = NULL;
char *s;
int xml = FALSE;
int output = TRUE;
int nodefs = FALSE; /* include defaulted attributes */
setlocale(LC_CTYPE, "");
s = strchr(argv[0], '/');
program = s == NULL ? argv[0] : s + 1;
if (streq(program, "xml"))
xml = TRUE;
shift;
while (argc > 0 && argv[0][0] == '-')
{ if (streq(argv[0], "-xml"))
{ xml = TRUE;
} else if (streq(argv[0], "-s"))
{ output = FALSE;
} else if (streq(argv[0], "-nodefs"))
{ nodefs = TRUE;
} else if (streq(argv[0], "-style"))
{ style_messages = TRUE;
} else
{ usage();
}
shift;
}
if (argc > 0)
{ char *slash = strchr(argv[0], '/');
char *dot = strchr(argv[0], '.');
char *ext = dot == 0 || (slash != 0 && slash > dot) ? "." : dot;
if (strcaseeq(ext, ".dtd"))
{ char doctype[256];
strncpy(doctype, argv[0], ext - argv[0]);
doctype[ext - argv[0]] = '\0';
p = new_dtd_parser(new_dtd(mb2wc(doctype)));
load_dtd_from_file(p, mb2wc(argv[0]));
shift;
} else if (strcaseeq(ext, ".html") || strcaseeq(ext, ".htm"))
{ p = new_dtd_parser(new_dtd((ichar const *) "html"));
load_dtd_from_file(p, L"html.dtd");
} else if (xml || strcaseeq(ext, ".xml"))
{ dtd *dtd = new_dtd(no_dtd);
set_dialect_dtd(dtd, DL_XML);
p = new_dtd_parser(dtd);
} else
{ p = new_dtd_parser(new_dtd(no_dtd));
}
} else
{ p = new_dtd_parser(new_dtd(no_dtd));
}
if (nodefs)
p->flags |= SGML_PARSER_NODEFS;
switch (argc)
{ case 1:
{ set_functions(p, output);
sgml_process_file(p, mb2wc(argv[0]), 0);
free_dtd_parser(p);
if (output && nerrors == 0)
printf("C\n");
return 0;
}
case 0:
{ set_functions(p, output);
set_file_dtd_parser(p, IN_FILE, L"stdin");
set_mode_dtd_parser(p, DM_DATA);
sgml_process_stream(p, stdin, 0);
free_dtd_parser(p);
if (output && nerrors == 0 && nwarnings == 0)
printf("C\n");
return 0;
}
default:
{ usage();
return EXIT_FAILURE;
}
}
}