AuroraMiddleware/bullet3
1
0
Fork 0
mirror of https://github.com/bulletphysics/bullet3 synced 2024-12-15 14:10:11 +00:00
Code Issues Releases Wiki Activity
62bdd2bde2
bullet3/Extras/LibXML/xmlcatalog.c

618 lines
15 KiB
C
Raw Blame History

/*
* xmlcatalog.c : a small utility program to handle XML catalogs
*
* See Copyright for the status of this software.
*
* daniel@veillard.com
*/
#include "libxml.h"
#include <string.h>
#include <stdio.h>
#include <stdarg.h>
#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif
#ifdef HAVE_LIBREADLINE
#include <readline/readline.h>
#ifdef HAVE_LIBHISTORY
#include <readline/history.h>
#endif
#endif
#include <libxml/xmlmemory.h>
#include <libxml/uri.h>
#include <libxml/catalog.h>
#include <libxml/parser.h>
#include <libxml/globals.h>
#if defined(LIBXML_CATALOG_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
static int shell = 0;
static int sgml = 0;
static int noout = 0;
static int create = 0;
static int add = 0;
static int del = 0;
static int convert = 0;
static int no_super_update = 0;
static int verbose = 0;
static char *filename = NULL;
#ifndef XML_SGML_DEFAULT_CATALOG
#define XML_SGML_DEFAULT_CATALOG "/etc/sgml/catalog"
#endif
/************************************************************************
* *
* Shell Interface *
* *
************************************************************************/
/**
* xmlShellReadline:
* @prompt: the prompt value
*
* Read a string
*
* Returns a pointer to it or NULL on EOF the caller is expected to
* free the returned string.
*/
static char *
xmlShellReadline(const char *prompt) {
#ifdef HAVE_LIBREADLINE
char *line_read;
/* Get a line from the user. */
line_read = readline (prompt);
/* If the line has any text in it, save it on the history. */
if (line_read && *line_read)
add_history (line_read);
return (line_read);
#else
char line_read[501];
char *ret;
int len;
if (prompt != NULL)
fprintf(stdout, "%s", prompt);
if (!fgets(line_read, 500, stdin))
return(NULL);
line_read[500] = 0;
len = strlen(line_read);
ret = (char *) malloc(len + 1);
if (ret != NULL) {
memcpy (ret, line_read, len + 1);
}
return(ret);
#endif
}
static void usershell(void) {
char *cmdline = NULL, *cur;
int nbargs;
char command[100];
char arg[400];
char *argv[20];
int i, ret;
xmlChar *ans;
while (1) {
cmdline = xmlShellReadline("> ");
if (cmdline == NULL)
return;
/*
* Parse the command itself
*/
cur = cmdline;
nbargs = 0;
while ((*cur == ' ') || (*cur == '\t')) cur++;
i = 0;
while ((*cur != ' ') && (*cur != '\t') &&
(*cur != '\n') && (*cur != '\r')) {
if (*cur == 0)
break;
command[i++] = *cur++;
}
command[i] = 0;
if (i == 0) {
free(cmdline);
continue;
}
nbargs++;
/*
* Parse the argument string
*/
memset(arg, 0, sizeof(arg));
while ((*cur == ' ') || (*cur == '\t')) cur++;
i = 0;
while ((*cur != '\n') && (*cur != '\r') && (*cur != 0)) {
if (*cur == 0)
break;
arg[i++] = *cur++;
}
arg[i] = 0;
if (i != 0)
nbargs++;
/*
* Parse the arguments
*/
i = 0;
nbargs = 0;
cur = arg;
memset(argv, 0, sizeof(argv));
while (*cur != 0) {
while ((*cur == ' ') || (*cur == '\t')) cur++;
if (*cur == '\'') {
cur++;
argv[i] = cur;
while ((*cur != 0) && (*cur != '\'')) cur++;
if (*cur == '\'') {
*cur = 0;
nbargs++;
i++;
cur++;
}
} else if (*cur == '"') {
cur++;
argv[i] = cur;
while ((*cur != 0) && (*cur != '"')) cur++;
if (*cur == '"') {
*cur = 0;
nbargs++;
i++;
cur++;
}
} else {
argv[i] = cur;
while ((*cur != 0) && (*cur != ' ') && (*cur != '\t'))
cur++;
*cur = 0;
nbargs++;
i++;
cur++;
}
}
/*
* start interpreting the command
*/
if (!strcmp(command, "exit"))
break;
if (!strcmp(command, "quit"))
break;
if (!strcmp(command, "bye"))
break;
if (!strcmp(command, "public")) {
if (nbargs != 1) {
printf("public requires 1 arguments\n");
} else {
ans = xmlCatalogResolvePublic((const xmlChar *) argv[0]);
if (ans == NULL) {
printf("No entry for PUBLIC %s\n", argv[0]);
} else {
printf("%s\n", (char *) ans);
xmlFree(ans);
}
}
} else if (!strcmp(command, "system")) {
if (nbargs != 1) {
printf("system requires 1 arguments\n");
} else {
ans = xmlCatalogResolveSystem((const xmlChar *) argv[0]);
if (ans == NULL) {
printf("No entry for SYSTEM %s\n", argv[0]);
} else {
printf("%s\n", (char *) ans);
xmlFree(ans);
}
}
} else if (!strcmp(command, "add")) {
if (sgml) {
if ((nbargs != 3) && (nbargs != 2)) {
printf("add requires 2 or 3 arguments\n");
} else {
if (argv[2] == NULL)
ret = xmlCatalogAdd(BAD_CAST argv[0], NULL,
BAD_CAST argv[1]);
else
ret = xmlCatalogAdd(BAD_CAST argv[0], BAD_CAST argv[1],
BAD_CAST argv[2]);
if (ret != 0)
printf("add command failed\n");
}
} else {
if ((nbargs != 3) && (nbargs != 2)) {
printf("add requires 2 or 3 arguments\n");
} else {
if (argv[2] == NULL)
ret = xmlCatalogAdd(BAD_CAST argv[0], NULL,
BAD_CAST argv[1]);
else
ret = xmlCatalogAdd(BAD_CAST argv[0], BAD_CAST argv[1],
BAD_CAST argv[2]);
if (ret != 0)
printf("add command failed\n");
}
}
} else if (!strcmp(command, "del")) {
if (nbargs != 1) {
printf("del requires 1\n");
} else {
ret = xmlCatalogRemove(BAD_CAST argv[0]);
if (ret <= 0)
printf("del command failed\n");
}
} else if (!strcmp(command, "resolve")) {
if (nbargs != 2) {
printf("resolve requires 2 arguments\n");
} else {
ans = xmlCatalogResolve(BAD_CAST argv[0],
BAD_CAST argv[1]);
if (ans == NULL) {
printf("Resolver failed to find an answer\n");
} else {
printf("%s\n", (char *) ans);
xmlFree(ans);
}
}
} else if (!strcmp(command, "dump")) {
if (nbargs != 0) {
printf("dump has no arguments\n");
} else {
xmlCatalogDump(stdout);
}
} else if (!strcmp(command, "debug")) {
if (nbargs != 0) {
printf("debug has no arguments\n");
} else {
verbose++;
xmlCatalogSetDebug(verbose);
}
} else if (!strcmp(command, "quiet")) {
if (nbargs != 0) {
printf("quiet has no arguments\n");
} else {
if (verbose > 0)
verbose--;
xmlCatalogSetDebug(verbose);
}
} else {
if (strcmp(command, "help")) {
printf("Unrecognized command %s\n", command);
}
printf("Commands available:\n");
printf("\tpublic PublicID: make a PUBLIC identifier lookup\n");
printf("\tsystem SystemID: make a SYSTEM identifier lookup\n");
printf("\tresolve PublicID SystemID: do a full resolver lookup\n");
printf("\tadd 'type' 'orig' 'replace' : add an entry\n");
printf("\tdel 'values' : remove values\n");
printf("\tdump: print the current catalog state\n");
printf("\tdebug: increase the verbosity level\n");
printf("\tquiet: decrease the verbosity level\n");
printf("\texit: quit the shell\n");
}
free(cmdline); /* not xmlFree here ! */
}
}
/************************************************************************
* *
* Main *
* *
************************************************************************/
static void usage(const char *name) {
/* split into 2 printf's to avoid overly long string (gcc warning) */
printf("\
Usage : %s [options] catalogfile entities...\n\
\tParse the catalog file and query it for the entities\n\
\t--sgml : handle SGML Super catalogs for --add and --del\n\
\t--shell : run a shell allowing interactive queries\n\
\t--create : create a new catalog\n\
\t--add 'type' 'orig' 'replace' : add an XML entry\n\
\t--add 'entry' : add an SGML entry\n", name);
printf("\
\t--del 'values' : remove values\n\
\t--noout: avoid dumping the result on stdout\n\
\t used with --add or --del, it saves the catalog changes\n\
\t and with --sgml it automatically updates the super catalog\n\
\t--no-super-update: do not update the SGML super catalog\n\
\t-v --verbose : provide debug informations\n");
}
int main(int argc, char **argv) {
int i;
int ret;
int exit_value = 0;
if (argc <= 1) {
usage(argv[0]);
return(1);
}
LIBXML_TEST_VERSION
for (i = 1; i < argc ; i++) {
if (!strcmp(argv[i], "-"))
break;
if (argv[i][0] != '-')
break;
if ((!strcmp(argv[i], "-verbose")) ||
(!strcmp(argv[i], "-v")) ||
(!strcmp(argv[i], "--verbose"))) {
verbose++;
xmlCatalogSetDebug(verbose);
} else if ((!strcmp(argv[i], "-noout")) ||
(!strcmp(argv[i], "--noout"))) {
noout = 1;
} else if ((!strcmp(argv[i], "-shell")) ||
(!strcmp(argv[i], "--shell"))) {
shell++;
noout = 1;
} else if ((!strcmp(argv[i], "-sgml")) ||
(!strcmp(argv[i], "--sgml"))) {
sgml++;
} else if ((!strcmp(argv[i], "-create")) ||
(!strcmp(argv[i], "--create"))) {
create++;
} else if ((!strcmp(argv[i], "-convert")) ||
(!strcmp(argv[i], "--convert"))) {
convert++;
} else if ((!strcmp(argv[i], "-no-super-update")) ||
(!strcmp(argv[i], "--no-super-update"))) {
no_super_update++;
} else if ((!strcmp(argv[i], "-add")) ||
(!strcmp(argv[i], "--add"))) {
if (sgml)
i += 2;
else
i += 3;
add++;
} else if ((!strcmp(argv[i], "-del")) ||
(!strcmp(argv[i], "--del"))) {
i += 1;
del++;
} else {
fprintf(stderr, "Unknown option %s\n", argv[i]);
usage(argv[0]);
return(1);
}
}
for (i = 1; i < argc; i++) {
if ((!strcmp(argv[i], "-add")) ||
(!strcmp(argv[i], "--add"))) {
if (sgml)
i += 2;
else
i += 3;
continue;
} else if ((!strcmp(argv[i], "-del")) ||
(!strcmp(argv[i], "--del"))) {
i += 1;
/* No catalog entry specified */
if (i == argc || (sgml && i + 1 == argc)) {
fprintf(stderr, "No catalog entry specified to remove from\n");
usage (argv[0]);
return(1);
}
continue;
} else if (argv[i][0] == '-')
continue;
filename = argv[i];
ret = xmlLoadCatalog(argv[i]);
if ((ret < 0) && (create)) {
xmlCatalogAdd(BAD_CAST "catalog", BAD_CAST argv[i], NULL);
}
break;
}
if (convert)
ret = xmlCatalogConvert();
if ((add) || (del)) {
for (i = 1; i < argc ; i++) {
if (!strcmp(argv[i], "-"))
break;
if (argv[i][0] != '-')
continue;
if (strcmp(argv[i], "-add") && strcmp(argv[i], "--add") &&
strcmp(argv[i], "-del") && strcmp(argv[i], "--del"))
continue;
if (sgml) {
/*
* Maintenance of SGML catalogs.
*/
xmlCatalogPtr catal = NULL;
xmlCatalogPtr super = NULL;
catal = xmlLoadSGMLSuperCatalog(argv[i + 1]);
if ((!strcmp(argv[i], "-add")) ||
(!strcmp(argv[i], "--add"))) {
if (catal == NULL)
catal = xmlNewCatalog(1);
xmlACatalogAdd(catal, BAD_CAST "CATALOG",
BAD_CAST argv[i + 2], NULL);
if (!no_super_update) {
super = xmlLoadSGMLSuperCatalog(XML_SGML_DEFAULT_CATALOG);
if (super == NULL)
super = xmlNewCatalog(1);
xmlACatalogAdd(super, BAD_CAST "CATALOG",
BAD_CAST argv[i + 1], NULL);
}
} else {
if (catal != NULL)
ret = xmlACatalogRemove(catal, BAD_CAST argv[i + 2]);
else
ret = -1;
if (ret < 0) {
fprintf(stderr, "Failed to remove entry from %s\n",
argv[i + 1]);
exit_value = 1;
}
if ((!no_super_update) && (noout) && (catal != NULL) &&
(xmlCatalogIsEmpty(catal))) {
super = xmlLoadSGMLSuperCatalog(
XML_SGML_DEFAULT_CATALOG);
if (super != NULL) {
ret = xmlACatalogRemove(super,
BAD_CAST argv[i + 1]);
if (ret < 0) {
fprintf(stderr,
"Failed to remove entry from %s\n",
XML_SGML_DEFAULT_CATALOG);
exit_value = 1;
}
}
}
}
if (noout) {
FILE *out;
if (xmlCatalogIsEmpty(catal)) {
remove(argv[i + 1]);
} else {
out = fopen(argv[i + 1], "w");
if (out == NULL) {
fprintf(stderr, "could not open %s for saving\n",
argv[i + 1]);
exit_value = 2;
noout = 0;
} else {
xmlACatalogDump(catal, out);
fclose(out);
}
}
if (!no_super_update && super != NULL) {
if (xmlCatalogIsEmpty(super)) {
remove(XML_SGML_DEFAULT_CATALOG);
} else {
out = fopen(XML_SGML_DEFAULT_CATALOG, "w");
if (out == NULL) {
fprintf(stderr,
"could not open %s for saving\n",
XML_SGML_DEFAULT_CATALOG);
exit_value = 2;
noout = 0;
} else {
xmlACatalogDump(super, out);
fclose(out);
}
}
}
} else {
xmlACatalogDump(catal, stdout);
}
i += 2;
} else {
if ((!strcmp(argv[i], "-add")) ||
(!strcmp(argv[i], "--add"))) {
if ((argv[i + 3] == NULL) || (argv[i + 3][0] == 0))
ret = xmlCatalogAdd(BAD_CAST argv[i + 1], NULL,
BAD_CAST argv[i + 2]);
else
ret = xmlCatalogAdd(BAD_CAST argv[i + 1],
BAD_CAST argv[i + 2],
BAD_CAST argv[i + 3]);
if (ret != 0) {
printf("add command failed\n");
exit_value = 3;
}
i += 3;
} else if ((!strcmp(argv[i], "-del")) ||
(!strcmp(argv[i], "--del"))) {
ret = xmlCatalogRemove(BAD_CAST argv[i + 1]);
if (ret < 0) {
fprintf(stderr, "Failed to remove entry %s\n",
argv[i + 1]);
exit_value = 1;
}
i += 1;
}
}
}
} else if (shell) {
usershell();
} else {
for (i++; i < argc; i++) {
xmlURIPtr uri;
xmlChar *ans;
uri = xmlParseURI(argv[i]);
if (uri == NULL) {
ans = xmlCatalogResolvePublic((const xmlChar *) argv[i]);
if (ans == NULL) {
printf("No entry for PUBLIC %s\n", argv[i]);
exit_value = 4;
} else {
printf("%s\n", (char *) ans);
xmlFree(ans);
}
} else {
xmlFreeURI(uri);
ans = xmlCatalogResolveSystem((const xmlChar *) argv[i]);
if (ans == NULL) {
printf("No entry for SYSTEM %s\n", argv[i]);
ans = xmlCatalogResolveURI ((const xmlChar *) argv[i]);
if (ans == NULL) {
printf ("No entry for URI %s\n", argv[i]);
exit_value = 4;
} else {
printf("%s\n", (char *) ans);
xmlFree (ans);
}
} else {
printf("%s\n", (char *) ans);
xmlFree(ans);
}
}
}
}
if ((!sgml) && ((add) || (del) || (create) || (convert))) {
if (noout && filename && *filename) {
FILE *out;
out = fopen(filename, "w");
if (out == NULL) {
fprintf(stderr, "could not open %s for saving\n", filename);
exit_value = 2;
noout = 0;
} else {
xmlCatalogDump(out);
}
} else {
xmlCatalogDump(stdout);
}
}
/*
* Cleanup and check for memory leaks
*/
xmlCleanupParser();
xmlMemoryDump();
return(exit_value);
}
#else
int main(int argc ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED) {
fprintf(stderr, "libxml was not compiled with catalog and output support\n");
return(1);
}
#endif
Reference in New Issue View Git Blame Copy Permalink