static void
reportError(XML_Parser parser, const XML_Char *filename)
{
enum XML_Error code = XML_GetErrorCode(parser);
const XML_Char *message = XML_ErrorString(code);
if (message)
ftprintf(stdout, T("%s:%" XML_FMT_INT_MOD "u:%" XML_FMT_INT_MOD "u: %s\n"),
filename,
XML_GetErrorLineNumber(parser),
XML_GetErrorColumnNumber(parser),
message);
else
ftprintf(stderr, T("%s: (unknown message %d)\n"), filename, code);
}
int
XML_ProcessFile(XML_Parser parser,
const XML_Char *filename,
unsigned flags)
{
int result;
if (!XML_SetBase(parser, filename)) {
ftprintf(stderr, T("%s: out of memory"), filename);
exit(1);
}
if (flags & XML_EXTERNAL_ENTITIES)
XML_SetExternalEntityRefHandler(parser,
(flags & XML_MAP_FILE)
? externalEntityRefFilemap
: externalEntityRefStream);
if (flags & XML_MAP_FILE) {
PROCESS_ARGS args;
args.retPtr = &result;
args.parser = parser;
if (!filemap(filename, processFile, &args))
result = 0;
}
else
result = processStream(filename, parser);
return result;
}
/**
* @brief alloc @p nelem elements of @p n bytes and set the memory to zero
*/
void *
xcalloc(size_t nelem, size_t n)
{
void *p;
p = calloc(nelem, n);
if (!p) {
ftprintf(stderr, _(T("Memory is too low\n")));
exit(EXIT_FAILURE);
}
return p;
}
/**
* @brief reallocate a pointer
*/
void *
xrealloc(void *ptr, size_t size)
{
void *p;
p = realloc(ptr, size);
if (!p) {
ftprintf(stderr, _(T("Memory is too low\n")));
exit(EXIT_FAILURE);
}
return p;
}
char *
tcstostr(const tchar *w)
{
#ifdef ESCM_UNICODE
char *str;
size_t n;
n = wcstombs(NULL, w, 0) + 1;
str = xmalloc(sizeof *str * n);
if (wcstombs(str, w, n) == (size_t) (-1))
ftprintf(stderr, _(T("wcstombs: conversion error.\n")));
return str;
#else
return xstrdup(w);
#endif
}
tchar *
strtotcs(const char *str)
{
#ifdef ESCM_UNICODE
wchar_t *w;
size_t n;
n = mbstowcs(NULL, str, 0) + 1;
w = xmalloc(sizeof *w * n);
if (mbstowcs(w, str, n) == (size_t) (-1))
ftprintf(stderr, _(T("mbstowcs: conversion error.\n")));
return w;
#else
return xstrdup(str);
#endif
}
static int
processStream(const XML_Char *filename, XML_Parser parser)
{
/* passing NULL for filename means read intput from stdin */
int fd = 0; /* 0 is the fileno for stdin */
if (filename != NULL) {
fd = topen(filename, O_BINARY|O_RDONLY);
if (fd < 0) {
tperror(filename);
return 0;
}
}
for (;;) {
int nread;
char *buf = (char *)XML_GetBuffer(parser, READ_SIZE);
if (!buf) {
if (filename != NULL)
close(fd);
ftprintf(stderr, T("%s: out of memory\n"),
filename != NULL ? filename : "xmlwf");
return 0;
}
nread = read(fd, buf, READ_SIZE);
if (nread < 0) {
tperror(filename != NULL ? filename : "STDIN");
if (filename != NULL)
close(fd);
return 0;
}
if (XML_ParseBuffer(parser, nread, nread == 0) == XML_STATUS_ERROR) {
reportError(parser, filename != NULL ? filename : "STDIN");
if (filename != NULL)
close(fd);
return 0;
}
if (nread == 0) {
if (filename != NULL)
close(fd);
break;;
}
}
return 1;
}
int
main(int argc, char **argv)
{
escm *e;
int i, j;
int casesens = 1;
int resume = 0;
char *p;
char *evalstr;
int ret;
if (!setlocale(LC_ALL, "") ||
!setlocale(LC_NUMERIC, "C")) /* corrects strtod interpretation */
ftprintf(stderr, T("can't set the locale.\n"));
evalstr = NULL;
srand(time(NULL));
for (i = 1; i < argc; i++) {
if (*argv[i] == '-') {
if (argv[i][1] == '-') {
if (0 == strcmp(argv[i], "--noload")) {
char *comma;
if (i+1 == argc) {
ftprintf(stderr,
_(T("missing arguments to --noload.\n")));
break;
}
p = argv[i+1], ret = 1;
while (ret) {
comma = strchr(p, ',');
if (!comma)
comma = p + strlen(p), ret = 0;
else
*comma = '\0';
for (j = 0; j < MAXTYPE; j++) {
if (0 == strcmp(p, desc[j].name)) {
desc[j].load = 0;
break;
}
}
if (j == MAXTYPE)
ftprintf(stderr, _(T("unknown argument to "))
_(T("--noload:%s.\n")), p);
p = comma + 1;
}
i++;
} else
ftprintf(stderr, _(T("unknown option %s.\n")), argv[i]);
} else {
for (p = argv[i] + 1; *p != '\0'; p++) {
switch (*p) {
case 'g': casesens = 1; break;
case 'G': casesens = 0; break;
case 'r': resume = 1; break;
case 'e': evalstr = argv[++i]; break;
case 'h':
usage(argv[0]);
return EXIT_SUCCESS;
default:
ftprintf(stderr, _(T("unknown option -%c.\n")), *p);
}
}
}
} else
break;
}
e = escm_new();
if (!e)
return EXIT_FAILURE;
for (j = 0; j < MAXTYPE; j++) {
if (desc[j].load)
desc[j].funinit(e);
}
e->casesensitive = casesens;
e->backtrace = 1;
escm_init(e);
ret = 1;
if (evalstr) {
tchar *tcs;
tcs = strtotcs(evalstr);
ret = escm_sparse(e, tcs);
free(tcs);
if (ret == 0)
goto end;
if (i >= argc) {
if (resume)
escm_shell(e);
else
goto end;
}
}
if (i < argc) {
while (i < argc) {
ret = escm_fparse(e, argv[i++]);
if (ret == 0)
break;
}
if (resume)
escm_shell(e);
} else
escm_shell(e);
end:
escm_free(e);
return (ret) ? EXIT_SUCCESS : EXIT_FAILURE;
}
int
filemap(const tchar *name,
void (*processor)(const void *, size_t, const tchar *, void *arg),
void *arg)
{
size_t nbytes;
int fd;
_EXPAT_read_count_t n;
struct stat sb;
void *p;
fd = topen(name, O_RDONLY|O_BINARY);
if (fd < 0) {
tperror(name);
return 0;
}
if (fstat(fd, &sb) < 0) {
tperror(name);
close(fd);
return 0;
}
if (!S_ISREG(sb.st_mode)) {
ftprintf(stderr, T("%s: not a regular file\n"), name);
close(fd);
return 0;
}
if (sb.st_size > XML_MAX_CHUNK_LEN) {
close(fd);
return 2; /* Cannot be passed to XML_Parse in one go */
}
nbytes = sb.st_size;
/* malloc will return NULL with nbytes == 0, handle files with size 0 */
if (nbytes == 0) {
static const char c = '\0';
processor(&c, 0, name, arg);
close(fd);
return 1;
}
p = malloc(nbytes);
if (!p) {
ftprintf(stderr, T("%s: out of memory\n"), name);
close(fd);
return 0;
}
n = _EXPAT_read(fd, p, (_EXPAT_read_req_t)nbytes);
if (n < 0) {
tperror(name);
free(p);
close(fd);
return 0;
}
if (n != (_EXPAT_read_count_t)nbytes) {
ftprintf(stderr, T("%s: read unexpected number of bytes\n"), name);
free(p);
close(fd);
return 0;
}
processor(p, nbytes, name, arg);
free(p);
close(fd);
return 1;
}
