dbtoman: remove duplicate source code and merge into dtdocbook.
This commit is contained in:
Liang Chang
@@ -1,9 +0,0 @@
|
||||
XCOMM $XConsortium: Imakefile /main/2 1996/07/23 20:03:15 rws $
|
||||
|
||||
#define IHaveSubdirs
|
||||
#define PassCDebugFlags
|
||||
|
||||
SUBDIRS = dbtoman
|
||||
|
||||
MakeSubdirs($(SUBDIRS))
|
||||
DependSubdirs($(SUBDIRS))
|
||||
@@ -1,3 +0,0 @@
|
||||
MAINTAINERCLEANFILES = Makefile.in
|
||||
|
||||
SUBDIRS = dbtoman
|
||||
@@ -1,3 +0,0 @@
|
||||
MAINTAINERCLEANFILES = Makefile.in
|
||||
|
||||
SUBDIRS = instant
|
||||
@@ -1,128 +0,0 @@
|
||||
#!/bin/ksh
|
||||
# $XConsortium: dbtoman /main/6 1996/09/15 18:58:15 rws $
|
||||
#############################################################################
|
||||
#
|
||||
# dbtoman
|
||||
#
|
||||
#############################################################################
|
||||
#
|
||||
# Copyright (c) 1996 X Consortium
|
||||
# Copyright (c) 1996 Dalrymple Consulting
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
# of this software and associated documentation files (the "Software"), to deal
|
||||
# in the Software without restriction, including without limitation the rights
|
||||
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
# copies of the Software, and to permit persons to whom the Software is
|
||||
# furnished to do so, subject to the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included in
|
||||
# all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
# X CONSORTIUM OR DALRYMPLE CONSULTING BE LIABLE FOR ANY CLAIM, DAMAGES OR
|
||||
# OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
# ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
||||
# OTHER DEALINGS IN THE SOFTWARE.
|
||||
#
|
||||
# Except as contained in this notice, the names of the X Consortium and
|
||||
# Dalrymple Consulting shall not be used in advertising or otherwise to
|
||||
# promote the sale, use or other dealings in this Software without prior
|
||||
# written authorization.
|
||||
#
|
||||
|
||||
trap "rm -f /tmp/dtm.$$.psinc /tmp/dtm.$$.out1 /tmp/dtm.$$.out2" 0 1 2 3 4 5 6 7 8 10 12 15
|
||||
|
||||
CDETOP=${CDETOP:-/proj/cde}
|
||||
SGML=$CDETOP/programs/dtdocbook/doc2sdl/SGML
|
||||
TPT_LIB=$CDETOP/doc/util/dbtoman/transpec
|
||||
export TPT_LIB
|
||||
|
||||
PARSER=$CDETOP/programs/nsgmls/nsgmls
|
||||
PARSER_OPTS="-g -oline -wno-idref"
|
||||
SGML_CATALOG_FILES="$SGML/catalog"
|
||||
export SGML_CATALOG_FILES
|
||||
|
||||
INSTANT=$CDETOP/doc/util/dbtoman/instant/instant
|
||||
INSTANT_OPT=-d
|
||||
|
||||
DECL=$CDETOP/programs/dtdocbook/doc2sdl/docbook.sgml
|
||||
|
||||
NROFF=
|
||||
|
||||
if [ $# -gt 0 ] && [ $1 = "-c" ]
|
||||
then
|
||||
NROFF="| tbl | nroff -man"
|
||||
shift
|
||||
fi
|
||||
if [ $# -eq 3 ]
|
||||
then DCLFILE=$1
|
||||
REFFILE=$2
|
||||
MANFILE=$3
|
||||
else echo "usage: dbtoman [-c] dcl-file ref-src-file man-dst-file"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
cat > /tmp/dtm.$$.psinc <<\!
|
||||
'\" t
|
||||
!
|
||||
|
||||
grep '<\!-- $''XConsortium: ' $REFFILE | \
|
||||
sed -e 's/<\!-- $''XConsortium:/...\\"/g' -e 's/ -->//g' >> /tmp/dtm.$$.psinc
|
||||
|
||||
cat >> /tmp/dtm.$$.psinc <<\!
|
||||
.de P!
|
||||
.fl
|
||||
\!!1 setgray
|
||||
.fl
|
||||
\\&.\"
|
||||
.fl
|
||||
\!!0 setgray
|
||||
.fl \" force out current output buffer
|
||||
\!!save /psv exch def currentpoint translate 0 0 moveto
|
||||
\!!/showpage{}def
|
||||
.fl \" prolog
|
||||
.sy sed -e 's/^/!/' \\$1\" bring in postscript file
|
||||
\!!psv restore
|
||||
.
|
||||
.de pF
|
||||
.ie \\*(f1 .ds f1 \\n(.f
|
||||
.el .ie \\*(f2 .ds f2 \\n(.f
|
||||
.el .ie \\*(f3 .ds f3 \\n(.f
|
||||
.el .ie \\*(f4 .ds f4 \\n(.f
|
||||
.el .tm ? font overflow
|
||||
.ft \\$1
|
||||
..
|
||||
.de fP
|
||||
.ie !\\*(f4 \{\
|
||||
. ft \\*(f4
|
||||
. ds f4\"
|
||||
' br \}
|
||||
.el .ie !\\*(f3 \{\
|
||||
. ft \\*(f3
|
||||
. ds f3\"
|
||||
' br \}
|
||||
.el .ie !\\*(f2 \{\
|
||||
. ft \\*(f2
|
||||
. ds f2\"
|
||||
' br \}
|
||||
.el .ie !\\*(f1 \{\
|
||||
. ft \\*(f1
|
||||
. ds f1\"
|
||||
' br \}
|
||||
.el .tm ? font underflow
|
||||
..
|
||||
.ds f1\"
|
||||
.ds f2\"
|
||||
.ds f3\"
|
||||
.ds f4\"
|
||||
!
|
||||
|
||||
cat $DECL $DCLFILE $REFFILE | \
|
||||
sed -e 's/<\!\[[ ]*\%CDE\.C\.CDE;[ ]*\[<[rR]ef[eE]ntry [iI]d="[^"]*">\]\]>/<refentry>/g' | \
|
||||
$PARSER $PARSER_OPTS | \
|
||||
$INSTANT $INSTANT_OPT -croff.cmap -sroff.sdata -tdocbook-to-man.ts > \
|
||||
/tmp/dtm.$$.out1 && eval cat /tmp/dtm.$$.psinc /tmp/dtm.$$.out1 $NROFF > \
|
||||
/tmp/dtm.$$.out2 && cp /tmp/dtm.$$.out2 $MANFILE
|
||||
@@ -1,11 +0,0 @@
|
||||
XCOMM $XConsortium: Imakefile /main/1 1996/07/23 19:42:01 rws $
|
||||
|
||||
INCLUDES = -I$(CDESRC)/dtdocbook/lib/tptregexp
|
||||
LOCAL_LIBRARIES = -L$(CDESRC)/dtdocbook/lib/tptregexp -ltptregexp
|
||||
|
||||
SRCS = main.c util.c info.c translate.c traninit.c tranvar.c tables.c \
|
||||
browse.c
|
||||
OBJS = main.o util.o info.o translate.o traninit.o tranvar.o tables.o \
|
||||
browse.o
|
||||
|
||||
ComplexProgramTarget(instant)
|
||||
@@ -1,10 +0,0 @@
|
||||
MAINTAINERCLEANFILES = Makefile.in
|
||||
|
||||
noinst_PROGRAMS = instant
|
||||
|
||||
instant_CFLAGS = -I$(top_builddir)/programs/dtdocbook/lib/tptregexp
|
||||
|
||||
instant_LDADD = $(top_builddir)/programs/dtdocbook/lib/tptregexp/libtptregexp.a
|
||||
|
||||
instant_SOURCES = main.c util.c info.c translate.c traninit.c tranvar.c \
|
||||
tables.c browse.c
|
||||
@@ -1,490 +0,0 @@
|
||||
/*
|
||||
* CDE - Common Desktop Environment
|
||||
*
|
||||
* Copyright (c) 1993-2012, The Open Group. All rights reserved.
|
||||
*
|
||||
* These libraries and programs are free software; you can
|
||||
* redistribute them and/or modify them under the terms of the GNU
|
||||
* Lesser General Public License as published by the Free Software
|
||||
* Foundation; either version 2 of the License, or (at your option)
|
||||
* any later version.
|
||||
*
|
||||
* These libraries and programs are distributed in the hope that
|
||||
* they 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 these libraries and programs; if not, write
|
||||
* to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
|
||||
* Floor, Boston, MA 02110-1301 USA
|
||||
*/
|
||||
/* $XConsortium: browse.c /main/1 1996/07/23 19:42:19 rws $ */
|
||||
/*
|
||||
* Copyright 1993 Open Software Foundation, Inc., Cambridge, Massachusetts.
|
||||
* All rights reserved.
|
||||
*/
|
||||
/*
|
||||
* Copyright (c) 1994
|
||||
* Open Software Foundation, Inc.
|
||||
*
|
||||
* Permission is hereby granted to use, copy, modify and freely distribute
|
||||
* the software in this file and its documentation for any purpose without
|
||||
* fee, provided that the above copyright notice appears in all copies and
|
||||
* that both the copyright notice and this permission notice appear in
|
||||
* supporting documentation. Further, provided that the name of Open
|
||||
* Software Foundation, Inc. ("OSF") not be used in advertising or
|
||||
* publicity pertaining to distribution of the software without prior
|
||||
* written permission from OSF. OSF makes no representations about the
|
||||
* suitability of this software for any purpose. It is provided "as is"
|
||||
* without express or implied warranty.
|
||||
*/
|
||||
/*
|
||||
* Copyright (c) 1996 X Consortium
|
||||
* Copyright (c) 1995, 1996 Dalrymple Consulting
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to deal
|
||||
* in the Software without restriction, including without limitation the rights
|
||||
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
* copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* X CONSORTIUM OR DALRYMPLE CONSULTING BE LIABLE FOR ANY CLAIM, DAMAGES OR
|
||||
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
||||
* OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* Except as contained in this notice, the names of the X Consortium and
|
||||
* Dalrymple Consulting shall not be used in advertising or otherwise to
|
||||
* promote the sale, use or other dealings in this Software without prior
|
||||
* written authorization.
|
||||
*/
|
||||
|
||||
/* ________________________________________________________________________
|
||||
*
|
||||
* Module for interactive browsing.
|
||||
*
|
||||
* Entry points for this module:
|
||||
* Browse() interactive browser
|
||||
* ________________________________________________________________________
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <ctype.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "general.h"
|
||||
|
||||
static void PrElemPlusID(Element_t *);
|
||||
static void ls_node(Element_t *, int, char **);
|
||||
static void do_query(Element_t *, char *, char *);
|
||||
static void do_find(Element_t *, char **);
|
||||
|
||||
/* ______________________________________________________________________ */
|
||||
|
||||
static char *br_help_msg[] = {
|
||||
" ls List info about current element in tree",
|
||||
" (context, children, attributes, etc.)",
|
||||
" cd N ... Change to Nth elememt child, where N is shown by 'ls'.",
|
||||
" N may also be '/' (top) or '..' (up).",
|
||||
" cd id I Change to elememt whose ID is I",
|
||||
" data N Show data of Nth data node",
|
||||
" where Show current position in the tree",
|
||||
" id I Show path to element with id I",
|
||||
" (using '?' for I will lists all IDs and their paths)",
|
||||
" find S Find elements matching spec S. Recognized syntaxes:",
|
||||
" find attr <name> <value>",
|
||||
" find cont <string>",
|
||||
" find parent <gi-name>",
|
||||
" find child <gi-name>",
|
||||
" find gi <gi-name>",
|
||||
" q rel gi Query: report if elem 'gi' has relation to current elem",
|
||||
" ('rel' is one of 'child parent ancestor descendant",
|
||||
" sibling sibling+ sibling+1 sibling- sibling-1 cousin')",
|
||||
"",
|
||||
" tran file [outfile]",
|
||||
" With trans spec in 'file' translate into 'outfile' (stdout)",
|
||||
" sdata file Read SDATA map file (for translations).",
|
||||
" cmap file Read character map file (for translations).",
|
||||
" stat Print statistics (how often elements occur, etc.)",
|
||||
" sum Print elem usage summary (# of children, depth, etc.)",
|
||||
" tree Print document hierarchy as a tree",
|
||||
" cont Print context of each element",
|
||||
NULL
|
||||
};
|
||||
|
||||
/* ______________________________________________________________________ */
|
||||
|
||||
void
|
||||
Browse(void)
|
||||
{
|
||||
char buf[256], *cmd, **av, **sv, *cmapfile, *sdatafile;
|
||||
char *Prompt;
|
||||
Element_t *ce; /* current element */
|
||||
Element_t *e;
|
||||
int i, n, ac;
|
||||
|
||||
if (slave) Prompt = "=>\n";
|
||||
else Prompt = "=> ";
|
||||
|
||||
ce = DocTree;
|
||||
while (fputs(Prompt, stdout)) {
|
||||
if (!fgets(buf, 256, stdin)) break;
|
||||
stripNL(buf);
|
||||
if (buf[0] == EOS) {
|
||||
fputs(Prompt, stdout);
|
||||
continue;
|
||||
}
|
||||
ac = 20;
|
||||
av = Split(buf, &ac, S_ALVEC);
|
||||
if (ac > 0) cmd = av[0];
|
||||
if (!cmd || !(*cmd)) continue;
|
||||
|
||||
if (!strcmp(cmd, "ls")) ls_node(ce, ac, av);
|
||||
|
||||
else if (!strcmp(cmd, "cd")) {
|
||||
if (av[1]) {
|
||||
if (ac == 3 && !strcmp(av[1], "id")) {
|
||||
if ((e = FindElemByID(av[2]))) ce = e;
|
||||
else printf("Element with ID '%s' not found.\n", av[2]);
|
||||
continue;
|
||||
}
|
||||
for (i=1; i<ac; i++) {
|
||||
if (!strcmp(av[i], "..")) {
|
||||
if (ce->parent) ce = ce->parent;
|
||||
continue;
|
||||
}
|
||||
if (!strcmp(av[i], "/")) {
|
||||
if (ce->parent) ce = DocTree;
|
||||
continue;
|
||||
}
|
||||
if (!isdigit(*av[i])) {
|
||||
printf("Expecting digit, '..', or '/', got '%s'.\n",
|
||||
av[i]);
|
||||
break;
|
||||
}
|
||||
n = atoi(av[i]);
|
||||
if (n < ce->necont) ce = ce->econt[n];
|
||||
else {
|
||||
printf("Must be in range 0 - %d.\n", ce->necont);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
else if (!strcmp(cmd, "data")) {
|
||||
if (av[1] && isdigit(*av[1])) {
|
||||
n = atoi(av[1]);
|
||||
if (n < ce->ndcont) {
|
||||
printf("%s", ce->dcont[n]);
|
||||
fputs("\n", stdout);
|
||||
}
|
||||
else if (ce->ndcont == 0)
|
||||
printf("No data at this node.\n");
|
||||
else printf("Must be in range 0 - %d.\n", ce->ndcont);
|
||||
}
|
||||
}
|
||||
|
||||
/* show where we are in the tree */
|
||||
else if (!strcmp(cmd, "where")) PrintLocation(ce, stdout);
|
||||
|
||||
/* show where we are in the tree */
|
||||
else if (!strcmp(cmd, "pwd")) PrElemPlusID(ce);
|
||||
|
||||
/* perform query with yes/no answer */
|
||||
else if (!strcmp(cmd, "q") && av[1] && av[2])
|
||||
do_query(ce, av[1], av[2]);
|
||||
|
||||
/* perform query printing paths to matching elements */
|
||||
else if (!strcmp(cmd, "find") && av[1] && av[2])
|
||||
do_find(ce, av);
|
||||
|
||||
/* list locations where specified ID(s) occur */
|
||||
else if (!strcmp(cmd, "id")) {
|
||||
if (ac <= 1) continue;
|
||||
if (*av[1] == '?') PrintIDList();
|
||||
else {
|
||||
/* short: "id i1 i2 ...", long: "id -l i1 i2 ..." */
|
||||
if (!strcmp(av[1], "-l")) n = 2;
|
||||
else n = 1;
|
||||
for (i=n; i<ac; i++) {
|
||||
if ((e = FindElemByID(av[i]))) {
|
||||
if (n == 2) { /* long (multiline) format */
|
||||
if (n != i) putchar('\n');
|
||||
PrintLocation(e, stdout);
|
||||
}
|
||||
else PrElemPlusID(e);
|
||||
}
|
||||
else printf("Element with ID '%s' not found.\n", av[i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* show and set variables */
|
||||
else if (!strcmp(cmd, "show") && av[1]) {
|
||||
printf("%s\n", FindMappingVal(Variables, av[1]));
|
||||
}
|
||||
else if (!strcmp(cmd, "set") && av[1] && av[2]) {
|
||||
SetMappingNV(Variables, av[1], av[2]);
|
||||
}
|
||||
|
||||
/* print summary of tag usage */
|
||||
else if (!strcmp(cmd, "sum")) {
|
||||
if (ac > 1) PrintElemSummary(ce);
|
||||
else PrintElemSummary(DocTree);
|
||||
}
|
||||
/* print element tree */
|
||||
else if (!strcmp(cmd, "tree")) {
|
||||
if (ac > 1) PrintElemTree(ce);
|
||||
else PrintElemTree(DocTree);
|
||||
}
|
||||
/* print statistics */
|
||||
else if (!strcmp(cmd, "stat")) {
|
||||
if (ac > 1) PrintStats(ce);
|
||||
else PrintStats(DocTree);
|
||||
}
|
||||
/* print context of each element of tree */
|
||||
else if (!strcmp(cmd, "cont")) {
|
||||
if (ac > 1) PrintContext(ce);
|
||||
else PrintContext(DocTree);
|
||||
}
|
||||
/* print translation, given transpec */
|
||||
else if (!strcmp(cmd, "tran")) {
|
||||
FILE *fp;
|
||||
if (ac > 2){
|
||||
if (!(fp = fopen(av[2], "w"))) {
|
||||
perror("Can not open output file");
|
||||
continue;
|
||||
}
|
||||
}
|
||||
else fp = stdout;
|
||||
DoTranslate(ce, av[1], fp);
|
||||
if (ac > 2) fclose(fp);
|
||||
}
|
||||
else if (!strcmp(cmd, "sdata")){
|
||||
sdatafile = strdup(av[1]);
|
||||
ReadSDATA(sdatafile);
|
||||
}
|
||||
else if (!strcmp(cmd, "cmap")){
|
||||
cmapfile = strdup(av[1]);
|
||||
ReadCharMap(cmapfile);
|
||||
}
|
||||
|
||||
else if (!strcmp(cmd, "help") || *cmd == '?') {
|
||||
sv = br_help_msg;
|
||||
while (*sv) puts(*sv++);
|
||||
}
|
||||
|
||||
/* quit (control-D also works) */
|
||||
else if (!strcmp(cmd, "quit")) break;
|
||||
|
||||
else
|
||||
fprintf(stderr, "Unknown command '%s' - ignored.\n", cmd);
|
||||
}
|
||||
putc(NL, stdout);
|
||||
}
|
||||
|
||||
/* ______________________________________________________________________ */
|
||||
/* Do the "ls" command.
|
||||
* Arguments:
|
||||
* Pointer to element under consideration.
|
||||
* Arg count from command line (this command, not the shell command).
|
||||
* Arg vector.
|
||||
*/
|
||||
|
||||
static void
|
||||
ls_node(
|
||||
Element_t *e,
|
||||
int ac,
|
||||
char **av
|
||||
)
|
||||
{
|
||||
int i;
|
||||
char buf[LINESIZE];
|
||||
|
||||
if (ac > 1 && !strcmp(av[1], "-n")) {
|
||||
for(i=0; i<e->ncont; i++) {
|
||||
if (IsContElem(e,i)) printf("%s\n", ContElem(e,i)->gi);
|
||||
else if (IsContData(e,i)) printf("#data %s\n", ContData(e,i));
|
||||
else if (IsContPI(e,i)) printf("#pi %s\n", ContData(e,i));
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
printf("Element: %s\tLineNumber: %d\n", e->gi, e->lineno);
|
||||
if (e->parent)
|
||||
printf("Context: %s\n", FindContext(e, 20, buf));
|
||||
|
||||
if (e->natts) {
|
||||
printf("%d attributes:\n", e->natts);
|
||||
for (i=0; i<e->natts; i++)
|
||||
printf("\t%2d: %s = '%s'\n", i, e->atts[i].name, e->atts[i].sval);
|
||||
}
|
||||
if (e->entity) {
|
||||
printf("Entity & notation information:\n");
|
||||
if (e->entity->ename)
|
||||
printf("Entity name: %s\n", e->entity->ename);
|
||||
if (e->entity->nname)
|
||||
printf("Notation name: %s\n", e->entity->nname);
|
||||
if (e->entity->sysid)
|
||||
printf("Sys id: %s\n", e->entity->sysid);
|
||||
if (e->entity->pubid)
|
||||
printf("Pub id: %s\n", e->entity->pubid);
|
||||
if (e->entity->fname)
|
||||
printf("Filename: %s\n", e->entity->fname);
|
||||
}
|
||||
|
||||
if (e->my_eorder >= 0)
|
||||
printf("My order among my siblings: %d\n", e->my_eorder);
|
||||
|
||||
if (e->necont) {
|
||||
printf("%d child element nodes:\n", e->necont);
|
||||
for(i=0; i<e->necont; i++) printf("\t%2d: %s\n", i, e->econt[i]->gi);
|
||||
}
|
||||
|
||||
if (e->ndcont) {
|
||||
printf("%d child data nodes:\n", e->ndcont);
|
||||
for(i=0; i<e->ndcont; i++) {
|
||||
if (strlen(e->dcont[i]) < 40)
|
||||
printf("\t%2d: %s\n", i, e->dcont[i]);
|
||||
else
|
||||
printf("\t%2d: %-40.40s...\n", i, e->dcont[i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* ______________________________________________________________________ */
|
||||
/* Perform query. Syntax: find relationship gi. Tells whether gi has
|
||||
* given relationship to current element. Result (message) sent to stdout.
|
||||
* Args:
|
||||
* Pointer to element under consideration.
|
||||
* Pointer to name of relationship. (see FindRelByName() for names)
|
||||
* Pointer to GI to look for.
|
||||
*/
|
||||
|
||||
static void
|
||||
do_query(
|
||||
Element_t *e,
|
||||
char *rel,
|
||||
char *gi
|
||||
)
|
||||
{
|
||||
char *cp;
|
||||
Relation_t r;
|
||||
Element_t *ep;
|
||||
|
||||
for (cp=gi; *cp; cp++) if (islower(*cp)) *cp = toupper(*cp);
|
||||
|
||||
if ((r = FindRelByName(rel)) == REL_Unknown) {
|
||||
return;
|
||||
}
|
||||
ep = QRelation(e, gi, r);
|
||||
printf("%s, '%s' is%s %s of '%s'.\n", (ep ? "Yes" : "No"), gi,
|
||||
(ep ? "" : " not"), rel, e->gi);
|
||||
}
|
||||
|
||||
/* ______________________________________________________________________ */
|
||||
/* Print path to the element and its ID (if it has one) on a single line.
|
||||
* Arguments:
|
||||
* Pointer to element under consideration.
|
||||
*/
|
||||
static void
|
||||
PrElemPlusID(
|
||||
Element_t *e
|
||||
)
|
||||
{
|
||||
char buf[LINESIZE];
|
||||
|
||||
if (e->id) printf("%s -- ID=%s\n", FindElementPath(e, buf), e->id);
|
||||
else printf("%s\n", FindElementPath(e, buf));
|
||||
}
|
||||
|
||||
/* ______________________________________________________________________ */
|
||||
/* Print path to the element and its ID (if it has one) on a single line.
|
||||
* Arguments:
|
||||
* Pointer to element under consideration.
|
||||
*/
|
||||
|
||||
static void
|
||||
match_gi(
|
||||
Element_t *e,
|
||||
char **av
|
||||
)
|
||||
{
|
||||
if (!strcmp(av[1], e->gi)) PrElemPlusID(e);
|
||||
}
|
||||
|
||||
/* Shorthand for defining simple finctions, which are just interfaces to
|
||||
* calling QRelation(). DescendTree() only passes ptr to element. */
|
||||
#define MATCH(Fun,Rel) \
|
||||
static void Fun(Element_t *e, char **av) \
|
||||
{ if (QRelation(e, av[1], Rel)) PrElemPlusID(e); }
|
||||
|
||||
MATCH(match_parent, REL_Parent)
|
||||
MATCH(match_child, REL_Child)
|
||||
MATCH(match_anc, REL_Ancestor)
|
||||
MATCH(match_desc, REL_Descendant)
|
||||
MATCH(match_sib, REL_Sibling)
|
||||
|
||||
static void
|
||||
match_attr(
|
||||
Element_t *e,
|
||||
char **av
|
||||
)
|
||||
{
|
||||
char *atval;
|
||||
|
||||
if ((atval = FindAttValByName(e, av[1])) && !strcmp(av[2], atval))
|
||||
PrElemPlusID(e);
|
||||
}
|
||||
|
||||
static void
|
||||
match_cont(
|
||||
Element_t *e,
|
||||
char **av
|
||||
)
|
||||
{
|
||||
int i;
|
||||
for (i=0; i<e->ncont; i++) {
|
||||
if (IsContData(e,i) && strstr(ContData(e,i), av[1])) {
|
||||
PrElemPlusID(e);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Find an element, given the criteria on its command line.
|
||||
* Arguments:
|
||||
* Pointer to element under consideration.
|
||||
*/
|
||||
static void
|
||||
do_find(
|
||||
Element_t *e,
|
||||
char **av
|
||||
)
|
||||
{
|
||||
av++;
|
||||
if (!strcmp(av[0], ".")) av++;
|
||||
else e = DocTree;
|
||||
if (!strcmp(av[0], "gi")) DescendTree(e, match_gi, 0, 0, av);
|
||||
else if (!strcmp(av[0], "attr")) DescendTree(e, match_attr, 0, 0, av);
|
||||
else if (!strcmp(av[0], "parent")) DescendTree(e, match_parent, 0, 0, av);
|
||||
else if (!strcmp(av[0], "child")) DescendTree(e, match_child, 0, 0, av);
|
||||
else if (!strcmp(av[0], "cont")) DescendTree(e, match_cont, 0, 0, av);
|
||||
else if (!strcmp(av[0], "sib")) DescendTree(e, match_sib, 0, 0, av);
|
||||
else if (!strcmp(av[0], "desc")) DescendTree(e, match_desc, 0, 0, av);
|
||||
else if (!strcmp(av[0], "anc")) DescendTree(e, match_anc, 0, 0, av);
|
||||
else fprintf(stderr, "Unknown find command: %s.\n", av[0]);
|
||||
}
|
||||
|
||||
/* ______________________________________________________________________ */
|
||||
@@ -1,333 +0,0 @@
|
||||
/*
|
||||
* CDE - Common Desktop Environment
|
||||
*
|
||||
* Copyright (c) 1993-2012, The Open Group. All rights reserved.
|
||||
*
|
||||
* These libraries and programs are free software; you can
|
||||
* redistribute them and/or modify them under the terms of the GNU
|
||||
* Lesser General Public License as published by the Free Software
|
||||
* Foundation; either version 2 of the License, or (at your option)
|
||||
* any later version.
|
||||
*
|
||||
* These libraries and programs are distributed in the hope that
|
||||
* they 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 these libraries and programs; if not, write
|
||||
* to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
|
||||
* Floor, Boston, MA 02110-1301 USA
|
||||
*/
|
||||
/* $XConsortium: general.h /main/1 1996/07/23 19:42:38 rws $ */
|
||||
/*
|
||||
* Copyright 1993 Open Software Foundation, Inc., Cambridge, Massachusetts.
|
||||
* All rights reserved.
|
||||
*/
|
||||
/*
|
||||
* Copyright (c) 1994
|
||||
* Open Software Foundation, Inc.
|
||||
*
|
||||
* Permission is hereby granted to use, copy, modify and freely distribute
|
||||
* the software in this file and its documentation for any purpose without
|
||||
* fee, provided that the above copyright notice appears in all copies and
|
||||
* that both the copyright notice and this permission notice appear in
|
||||
* supporting documentation. Further, provided that the name of Open
|
||||
* Software Foundation, Inc. ("OSF") not be used in advertising or
|
||||
* publicity pertaining to distribution of the software without prior
|
||||
* written permission from OSF. OSF makes no representations about the
|
||||
* suitability of this software for any purpose. It is provided "as is"
|
||||
* without express or implied warranty.
|
||||
*/
|
||||
/*
|
||||
* Copyright (c) 1996 X Consortium
|
||||
* Copyright (c) 1995, 1996 Dalrymple Consulting
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to deal
|
||||
* in the Software without restriction, including without limitation the rights
|
||||
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
* copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* X CONSORTIUM OR DALRYMPLE CONSULTING BE LIABLE FOR ANY CLAIM, DAMAGES OR
|
||||
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
||||
* OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* Except as contained in this notice, the names of the X Consortium and
|
||||
* Dalrymple Consulting shall not be used in advertising or otherwise to
|
||||
* promote the sale, use or other dealings in this Software without prior
|
||||
* written authorization.
|
||||
*/
|
||||
/* ________________________________________________________________________
|
||||
*
|
||||
* Common definitions for "instant" program.
|
||||
* ________________________________________________________________________
|
||||
*/
|
||||
|
||||
/* string/numeric/character definitions */
|
||||
|
||||
#define EOS '\0'
|
||||
#define NL '\n'
|
||||
#define TAB '\t'
|
||||
#define CR '\r'
|
||||
#define ANCHOR '^'
|
||||
|
||||
/* bigmask/flags for the Split() function */
|
||||
#define S_STRDUP 0x01
|
||||
#define S_ALVEC 0x02
|
||||
|
||||
/* Command codes (1st char of esis lines) from sgmls. See its manpage. */
|
||||
#define CMD_DATA '-'
|
||||
#define CMD_OPEN '('
|
||||
#define CMD_CLOSE ')'
|
||||
#define CMD_ATT 'A'
|
||||
#define CMD_D_ATT 'D'
|
||||
#define CMD_NOTATION 'N'
|
||||
#define CMD_EXT_ENT 'E'
|
||||
#define CMD_INT_ENT 'I'
|
||||
#define CMD_SYSID 's'
|
||||
#define CMD_PUBID 'p'
|
||||
#define CMD_FILENAME 'f'
|
||||
#define CMD_LINE 'L'
|
||||
#define CMD_PI '?'
|
||||
#define CMD_SUBDOC 'S'
|
||||
#define CMD_SUBDOC_S '{'
|
||||
#define CMD_SUBDOC_E '}'
|
||||
#define CMD_EXT_REF '&'
|
||||
#define CMD_APPINFO '#'
|
||||
#define CMD_CONFORM 'C'
|
||||
|
||||
/* Some sizes */
|
||||
#define MAX_DEPTH 40
|
||||
#define LINESIZE 60000
|
||||
|
||||
/* Name of library env variable, and default value. */
|
||||
#ifndef TPT_LIB
|
||||
#define TPT_LIB "TPT_LIB"
|
||||
#endif
|
||||
#ifndef DEF_TPT_LIB
|
||||
#define DEF_TPT_LIB "/project/tools/libdata/tpt"
|
||||
#endif
|
||||
|
||||
/* Relationships - for querying */
|
||||
typedef enum {
|
||||
REL_None, REL_Parent, REL_Child, REL_Ancestor, REL_Descendant,
|
||||
REL_Sibling, REL_Preceding, REL_ImmPreceding, REL_Following,
|
||||
REL_ImmFollowing, REL_Cousin, REL_Unknown
|
||||
} Relation_t;
|
||||
|
||||
/* Initial map sizes (IMS) */
|
||||
#define IMS_relations 3
|
||||
#define IMS_setvar 3
|
||||
#define IMS_incvar 3
|
||||
#define IMS_sdata 50
|
||||
#define IMS_sdatacache 30
|
||||
#define IMS_variables 20
|
||||
#define IMS_attnames 50
|
||||
#define IMS_elemnames 50
|
||||
|
||||
/* ----- typedef and other misc definitions ----- */
|
||||
|
||||
#ifndef TRUE
|
||||
#define TRUE (1 == 1)
|
||||
#endif
|
||||
|
||||
#ifndef FALSE
|
||||
#define FALSE (1 == 0)
|
||||
#endif
|
||||
|
||||
typedef short bool;
|
||||
|
||||
|
||||
/* ----- structure definitions ----- */
|
||||
|
||||
/* We use this for variables, attributes, etc., so the caller only needs an
|
||||
* opaque handle to the thing below, not worrying about array management. */
|
||||
typedef struct {
|
||||
char *name; /* name of the thing */
|
||||
char *sval; /* string value */
|
||||
} Mapping_t;
|
||||
|
||||
typedef struct {
|
||||
int n_alloc; /* number of elements allocated */
|
||||
int n_used; /* number of elements used */
|
||||
int slot_incr; /* increment for allocating slots */
|
||||
int flags; /* info about this set of mappings */
|
||||
Mapping_t *maps; /* array of mappings */
|
||||
} Map_t;
|
||||
|
||||
/* ______________________________________________________________________ */
|
||||
|
||||
/* Information about an entity reference. Not all fields will be used
|
||||
* at once. */
|
||||
typedef struct _ent {
|
||||
char *type; /* entity type */
|
||||
char *ename; /* entity name */
|
||||
char *nname; /* notation name */
|
||||
char *sysid; /* sys id */
|
||||
char *pubid; /* pub id */
|
||||
char *fname; /* filename */
|
||||
struct _ent *next; /* next in linked list */
|
||||
} Entity_t;
|
||||
|
||||
/* Content (child nodes) of an element (node in the tree) -- both data
|
||||
* and other elements. */
|
||||
typedef struct {
|
||||
char type; /* element, data, or pi? */
|
||||
union {
|
||||
struct _elem *elem; /* direct children of this elem */
|
||||
char *data; /* character data of this elem */
|
||||
} ch;
|
||||
} Content_t;
|
||||
|
||||
/* An element (node in the tree) */
|
||||
typedef struct _elem {
|
||||
char *gi; /* element GI */
|
||||
Content_t *cont; /* content - element & data children */
|
||||
int ncont; /* # of content/children */
|
||||
struct _elem **econt; /* element children */
|
||||
int necont; /* # of element children */
|
||||
char **dcont; /* character data children */
|
||||
int ndcont; /* # of data children */
|
||||
Mapping_t *atts; /* array of attributes */
|
||||
int natts; /* # of attributes */
|
||||
Entity_t *entity; /* ext entity & notation info */
|
||||
char *id; /* for linking */
|
||||
int index; /* an internal bookkeeping mechanism */
|
||||
int depth; /* how deep in tree */
|
||||
int lineno; /* line number */
|
||||
char *infile; /* input filename */
|
||||
int my_eorder; /* order of this elem of its parent */
|
||||
struct _elem *parent; /* this elem's direct parent */
|
||||
struct _elem *next; /* kept in linked list */
|
||||
void *trans; /* pointer to translation spec */
|
||||
/* I'm not crazy about this, but it works */
|
||||
int gen_trans[2]; /* refs to generated trans specs */
|
||||
int processed; /* was this node processed? */
|
||||
} Element_t;
|
||||
|
||||
/* For mapping of element IDs to elements themselves. */
|
||||
typedef struct id_s {
|
||||
char *id; /* ID of the element */
|
||||
Element_t *elem; /* pointer to it */
|
||||
struct id_s *next;
|
||||
} ID_t;
|
||||
|
||||
/* ----- global variable declarations ----- */
|
||||
|
||||
#ifdef STORAGE
|
||||
# define def
|
||||
#else
|
||||
# define def extern
|
||||
#endif
|
||||
|
||||
def Element_t *DocTree; /* root of document tree */
|
||||
def char **UsedElem; /* a unique list of used elem names */
|
||||
def int nUsedElem; /* number of used elem names */
|
||||
def char **UsedAtt; /* a unique list of used attrib names */
|
||||
def int nUsedAtt; /* number of used attrib names */
|
||||
def ID_t *IDList; /* list of IDs used in the doc */
|
||||
def Map_t *Variables; /* general, global variables */
|
||||
def Map_t *SDATAmap; /* SDATA mappings */
|
||||
def Map_t *PImap; /* Processing Instruction mappings */
|
||||
def Entity_t *Entities; /* list of entities */
|
||||
|
||||
def FILE *outfp; /* where output is written */
|
||||
def char *tpt_lib; /* TPT library directory */
|
||||
def int verbose; /* flag - verbose output? */
|
||||
def int warnings; /* flag - show warnings? */
|
||||
def int interactive; /* flag - interactive browsing? */
|
||||
def int slave; /* are we slave to another process? */
|
||||
def int fold_case; /* flag - fold case of GIs? */
|
||||
|
||||
/* ----- some macros for convenience and ease of code reading ----- */
|
||||
|
||||
#define stripNL(s) { char *_cp; if ((_cp=strchr(s, NL))) *_cp = EOS; }
|
||||
|
||||
/* Similar to calloc(), malloc(), and realloc(), but check for success.
|
||||
* Args to all:
|
||||
* (1) number of 'elements' to allocate
|
||||
* (2) variable to point at allocated space
|
||||
* (3) type of 'element'
|
||||
* Eg: Calloc(5, e, Element_t) replaces
|
||||
* if (!(e = (Element_t *)calloc(5, sizeof(Element_t))) {
|
||||
* ... handle error ... ;
|
||||
* }
|
||||
*/
|
||||
#define Calloc(N,V,T) \
|
||||
{ if (!((V) = (T *)calloc((size_t)N, sizeof(T)))) { \
|
||||
perror("Calloc failed -- out of memory. Bailing out."); exit(1); \
|
||||
}; memset((void *) (V), 0, (size_t) sizeof(T)); }
|
||||
#define Malloc(N,V,T) \
|
||||
{ if (!((V) = (T *)malloc((size_t)N*sizeof(T)))) { \
|
||||
perror("Malloc failed -- out of memory. Bailing out."); exit(1); \
|
||||
}; memset((void *) (V), 0, (size_t) sizeof(T)); }
|
||||
#define Realloc(N,V,T) \
|
||||
{ if (!((V) = (T *)realloc(V,(size_t)N*sizeof(T)))) { \
|
||||
perror("Realloc failed -- out of memory. Bailing out."); exit(1); \
|
||||
} }
|
||||
|
||||
/* similar to strcmp(), but check first chars first, for efficiency */
|
||||
#define StrEq(s1,s2) (s1[0] == s2[0] && !strcmp(s1,s2))
|
||||
|
||||
/* similar to isspace(), but check for blank or tab - without overhead
|
||||
* of procedure call */
|
||||
#define IsWhite(c) (c == ' ' || c == TAB)
|
||||
|
||||
#define ContType(e,i) (e->cont[i].type)
|
||||
#define ContData(e,i) (e->cont[i].ch.data)
|
||||
#define ContElem(e,i) (e->cont[i].ch.elem)
|
||||
#define IsContData(e,i) (e->cont[i].type == CMD_DATA)
|
||||
#define IsContElem(e,i) (e->cont[i].type == CMD_OPEN)
|
||||
#define IsContPI(e,i) (e->cont[i].type == CMD_PI)
|
||||
|
||||
/* ----- function prototypes ----- */
|
||||
|
||||
/* things defined in util.c */
|
||||
Element_t *QRelation(Element_t *, char *, Relation_t);
|
||||
Relation_t FindRelByName(char *);
|
||||
char *FindAttValByName(Element_t *, char *);
|
||||
char *FindContext(Element_t *, int, char *);
|
||||
char *AddElemName(char *);
|
||||
char *AddAttName(char *);
|
||||
void OutputString(char *, FILE *, int);
|
||||
FILE *OpenFile(char *);
|
||||
char *FindElementPath(Element_t *, char *);
|
||||
char *NearestOlderElem(Element_t *, char *);
|
||||
void PrintLocation(Element_t *, FILE *);
|
||||
char **Split(char *, int *, int);
|
||||
void DescendTree(Element_t *, void(*)(), void(*)(), void(*)(), void *);
|
||||
Map_t *NewMap(int);
|
||||
Mapping_t *FindMapping(Map_t *, char *);
|
||||
char *FindMappingVal(Map_t *, char *);
|
||||
void SetMapping(Map_t *, char *);
|
||||
void SetMappingNV(Map_t *, char *, char *);
|
||||
void AddID(Element_t *, char *);
|
||||
Element_t *FindElemByID(char *);
|
||||
|
||||
/* things defined in translate.c */
|
||||
void DoTranslate(Element_t*, char *, FILE *);
|
||||
|
||||
/* things defined in traninit.c */
|
||||
void ReadTransSpec(char *);
|
||||
void ReadSDATA(char *);
|
||||
void ReadCharMap(char *);
|
||||
|
||||
/* things defined in tranvar.c */
|
||||
char *Get_A_C_value(char *);
|
||||
|
||||
/* things defined in info.c */
|
||||
void PrintContext(Element_t *e);
|
||||
void PrintElemSummary(Element_t *);
|
||||
void PrintElemTree(Element_t *);
|
||||
void PrintStats(Element_t *);
|
||||
void PrintIDList();
|
||||
@@ -1,318 +0,0 @@
|
||||
/*
|
||||
* CDE - Common Desktop Environment
|
||||
*
|
||||
* Copyright (c) 1993-2012, The Open Group. All rights reserved.
|
||||
*
|
||||
* These libraries and programs are free software; you can
|
||||
* redistribute them and/or modify them under the terms of the GNU
|
||||
* Lesser General Public License as published by the Free Software
|
||||
* Foundation; either version 2 of the License, or (at your option)
|
||||
* any later version.
|
||||
*
|
||||
* These libraries and programs are distributed in the hope that
|
||||
* they 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 these libraries and programs; if not, write
|
||||
* to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
|
||||
* Floor, Boston, MA 02110-1301 USA
|
||||
*/
|
||||
/* $XConsortium: info.c /main/1 1996/07/23 19:42:57 rws $ */
|
||||
/*
|
||||
* Copyright 1993 Open Software Foundation, Inc., Cambridge, Massachusetts.
|
||||
* All rights reserved.
|
||||
*/
|
||||
/*
|
||||
* Copyright (c) 1994
|
||||
* Open Software Foundation, Inc.
|
||||
*
|
||||
* Permission is hereby granted to use, copy, modify and freely distribute
|
||||
* the software in this file and its documentation for any purpose without
|
||||
* fee, provided that the above copyright notice appears in all copies and
|
||||
* that both the copyright notice and this permission notice appear in
|
||||
* supporting documentation. Further, provided that the name of Open
|
||||
* Software Foundation, Inc. ("OSF") not be used in advertising or
|
||||
* publicity pertaining to distribution of the software without prior
|
||||
* written permission from OSF. OSF makes no representations about the
|
||||
* suitability of this software for any purpose. It is provided "as is"
|
||||
* without express or implied warranty.
|
||||
*/
|
||||
/*
|
||||
* Copyright (c) 1996 X Consortium
|
||||
* Copyright (c) 1995, 1996 Dalrymple Consulting
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to deal
|
||||
* in the Software without restriction, including without limitation the rights
|
||||
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
* copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* X CONSORTIUM OR DALRYMPLE CONSULTING BE LIABLE FOR ANY CLAIM, DAMAGES OR
|
||||
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
||||
* OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* Except as contained in this notice, the names of the X Consortium and
|
||||
* Dalrymple Consulting shall not be used in advertising or otherwise to
|
||||
* promote the sale, use or other dealings in this Software without prior
|
||||
* written authorization.
|
||||
*/
|
||||
/* ________________________________________________________________________
|
||||
*
|
||||
* Functions for printing information about an instance in the 'instant'
|
||||
* program. Most of these are fairly short and simple.
|
||||
*
|
||||
* Entry points for this module:
|
||||
* PrintElemSummary(elem) print summary info of each element
|
||||
* PrintContext(elem) print context of each element
|
||||
* PrintElemTree(elem) print tree of document
|
||||
* PrintStats(elem) print statistics about doc tree
|
||||
* PrintIDList(elem) print list of IDs and element context
|
||||
* Most Print*() functions start at subtree pointed to by 'elem'.
|
||||
* ________________________________________________________________________
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <ctype.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "general.h"
|
||||
|
||||
/* ______________________________________________________________________ */
|
||||
/* Print a summary of each tag use in the instance. Things like depth in
|
||||
* the tree, number of children, parent, attributes.
|
||||
*/
|
||||
|
||||
/* Do the actual printing. Print the info about the node. If null,
|
||||
* print a header for the columns.
|
||||
* Arguments:
|
||||
* Pointer to element structure of the node to print.
|
||||
*/
|
||||
static void
|
||||
print_summ(
|
||||
Element_t *e
|
||||
)
|
||||
{
|
||||
int i, n, dsize;
|
||||
char *hfmt="%-18.18s %4s %5s %4s %4s %s\n";
|
||||
char *fmt ="%-18.18s %4d %5d %4d %4d %s\n";
|
||||
|
||||
if (e == NULL) {
|
||||
fprintf(outfp, hfmt, "Element", "Att", "Data", "Chd", "Dep", "Parent");
|
||||
return;
|
||||
}
|
||||
for (i=0,n=0; i<e->ncont; i++) if (IsContElem(e,i)) n++;
|
||||
for (i=0,dsize=0; i<e->ncont; i++)
|
||||
if (IsContElem(e,i)) dsize += strlen(e->cont[i].ch.data);
|
||||
fprintf(outfp, fmt, e->gi, e->natts, dsize, n, e->depth,
|
||||
e->parent ? e->parent->gi : "-");
|
||||
|
||||
for (i=0; i<e->natts; i++) {
|
||||
fprintf(outfp, "%45d: %s = %s\n", i, e->atts[i].name,
|
||||
e->atts[i].sval ? e->atts[i].sval : "empty");
|
||||
}
|
||||
}
|
||||
|
||||
/* Descend the tree, calling processing routine.
|
||||
* Arguments:
|
||||
* Pointer to element structure at top of tree to traverse.
|
||||
*/
|
||||
void
|
||||
PrintElemSummary(
|
||||
Element_t *e
|
||||
)
|
||||
{
|
||||
print_summ(0);
|
||||
DescendTree(e, print_summ, 0, 0, 0);
|
||||
}
|
||||
|
||||
/* ______________________________________________________________________ */
|
||||
/* Print the context of each tag in the instance (i.e. the tag with its
|
||||
* ancestors).
|
||||
*/
|
||||
|
||||
/* Do the actual printing. Print the context of the node.
|
||||
* Arguments:
|
||||
* Pointer to element structure of the node to print.
|
||||
*/
|
||||
static void
|
||||
print_context(
|
||||
Element_t *e
|
||||
)
|
||||
{
|
||||
char buf[LINESIZE];
|
||||
|
||||
fprintf(outfp, "%-22s %s\n", e->gi, FindContext(e, 10, buf));
|
||||
}
|
||||
|
||||
/* Descend the tree, calling processing routine.
|
||||
* Arguments:
|
||||
* Pointer to element structure at top of tree to traverse.
|
||||
*/
|
||||
void
|
||||
PrintContext(
|
||||
Element_t *e
|
||||
)
|
||||
{
|
||||
fprintf(outfp, "%-22s %s\n", "Element", "Context");
|
||||
fprintf(outfp, "%-22s %s\n", "---------------", "-----------");
|
||||
DescendTree(e, print_context, 0, 0, 0);
|
||||
|
||||
putc(NL, outfp);
|
||||
}
|
||||
|
||||
/* ______________________________________________________________________ */
|
||||
/* Print tree of the instance. GI's are printed indented by their depth
|
||||
* in the tree.
|
||||
*/
|
||||
|
||||
/* Do the actual printing. Print the element name, indented the right amount.
|
||||
* Arguments:
|
||||
* Pointer to element structure of the node to print.
|
||||
*/
|
||||
static void
|
||||
print_indent(
|
||||
Element_t *e
|
||||
)
|
||||
{
|
||||
int i, ne, nd;
|
||||
for(i=0; i<e->depth; i++) fputs(". ", outfp);
|
||||
for(i=0,ne=0; i<e->ncont; i++) if (IsContElem(e,i)) ne++;
|
||||
for(i=0,nd=0; i<e->ncont; i++) if IsContData(e,i) nd++;
|
||||
fprintf(outfp, "%s (%d,%d)\n", e->gi, ne, nd);
|
||||
}
|
||||
|
||||
/* Descend the tree, calling processing routine.
|
||||
* Arguments:
|
||||
* Pointer to element structure at top of tree to traverse.
|
||||
*/
|
||||
void
|
||||
PrintElemTree(
|
||||
Element_t *e
|
||||
)
|
||||
{
|
||||
DescendTree(e, print_indent, 0, 0, 0);
|
||||
putc(NL, outfp);
|
||||
}
|
||||
|
||||
/* ______________________________________________________________________ */
|
||||
/* Print some statistics about the instance.
|
||||
*/
|
||||
|
||||
/* Accumulate the totals for the statistics.
|
||||
* Arguments:
|
||||
* Pointer to element structure of the node to print.
|
||||
* Pointer to the total number of elements.
|
||||
* Pointer to the total amount of content data.
|
||||
* Pointer to the maximum depth of tree.
|
||||
*/
|
||||
static void
|
||||
acc_tots(
|
||||
Element_t *e,
|
||||
int *tot_el,
|
||||
int *tot_data,
|
||||
int *max_depth
|
||||
)
|
||||
{
|
||||
int i;
|
||||
for(i=0; i<e->necont; i++)
|
||||
acc_tots(e->econt[i], tot_el, tot_data, max_depth);
|
||||
for (i=0; i<e->necont; i++) (*tot_el)++;
|
||||
for (i=0; i<e->ndcont; i++) (*tot_data) += strlen(e->dcont[i]);
|
||||
if (e->depth > (*max_depth)) *max_depth = e->depth;
|
||||
}
|
||||
|
||||
/* Descend the tree (recursively), collecting the statistics.
|
||||
* Arguments:
|
||||
* Pointer to element structure of the node to print.
|
||||
* Pointer to the total number of elements.
|
||||
* Pointer to the total amount of content data.
|
||||
* Pointer to the maximum depth of tree.
|
||||
*/
|
||||
static void
|
||||
elem_usage(
|
||||
Element_t *e,
|
||||
char *name,
|
||||
int *n_used,
|
||||
int *nchars
|
||||
)
|
||||
{
|
||||
int i;
|
||||
if (!strcmp(name, e->gi)) {
|
||||
(*n_used)++;
|
||||
for (i=0; i<e->ncont; i++)
|
||||
if (IsContData(e,i)) (*nchars) += strlen(ContData(e,i));
|
||||
}
|
||||
for(i=0; i<e->necont; i++)
|
||||
elem_usage(e->econt[i], name, n_used, nchars);
|
||||
}
|
||||
|
||||
/* Descend the tree, calling processing routine.
|
||||
* Arguments:
|
||||
* Pointer to element structure at top of tree to traverse.
|
||||
*/
|
||||
void
|
||||
PrintStats(
|
||||
Element_t *top
|
||||
)
|
||||
{
|
||||
int i, n;
|
||||
int dif_el=0, tot_el=0, tot_data=0, nchars, max_depth=0;
|
||||
float pct;
|
||||
|
||||
fprintf(outfp, "%-22s %s %s\n", "Element name", "Occurrences", "Character Content");
|
||||
fprintf(outfp, "%-22s %s %s\n", "---------------", "-----------", "-----------------");
|
||||
|
||||
acc_tots(top, &tot_el, &tot_data, &max_depth);
|
||||
|
||||
for (i=0; i<nUsedElem; i++) {
|
||||
n = 0;
|
||||
nchars = 0;
|
||||
elem_usage(top, UsedElem[i], &n, &nchars);
|
||||
if (n > 0) {
|
||||
pct = 100.0 * (float)n / (float)tot_el;
|
||||
fprintf(outfp, "%-22s %4d %4.1f%% %6d %4d\n", UsedElem[i],
|
||||
n, pct, nchars, (nchars/n));
|
||||
dif_el++;
|
||||
}
|
||||
}
|
||||
|
||||
fprintf(outfp, "\nTotal of %d elements used, %d different ones.\n",
|
||||
tot_el, dif_el);
|
||||
fprintf(outfp, "Total character data: %d.\n", tot_data);
|
||||
fprintf(outfp, "Maximum element depth: %d.\n", max_depth);
|
||||
putc(NL, outfp);
|
||||
}
|
||||
|
||||
/* ______________________________________________________________________ */
|
||||
/* Print list of: ID, GI, input file, line number, separated by colons.
|
||||
* This is better for other programs to manipulate (like for keeping a
|
||||
* database of IDs in documents) than humans to read.
|
||||
*/
|
||||
|
||||
void
|
||||
PrintIDList(void)
|
||||
{
|
||||
ID_t *id;
|
||||
Element_t *ep;
|
||||
|
||||
for (id=IDList; id; id=id->next) {
|
||||
ep = id->elem;
|
||||
fprintf(outfp, "%s:%s:%s:%d\n", id->id, ep->gi,
|
||||
ep->infile?ep->infile:"-", ep->lineno);
|
||||
}
|
||||
}
|
||||
|
||||
/* ______________________________________________________________________ */
|
||||
|
||||
@@ -1,720 +0,0 @@
|
||||
/*
|
||||
* CDE - Common Desktop Environment
|
||||
*
|
||||
* Copyright (c) 1993-2012, The Open Group. All rights reserved.
|
||||
*
|
||||
* These libraries and programs are free software; you can
|
||||
* redistribute them and/or modify them under the terms of the GNU
|
||||
* Lesser General Public License as published by the Free Software
|
||||
* Foundation; either version 2 of the License, or (at your option)
|
||||
* any later version.
|
||||
*
|
||||
* These libraries and programs are distributed in the hope that
|
||||
* they 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 these libraries and programs; if not, write
|
||||
* to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
|
||||
* Floor, Boston, MA 02110-1301 USA
|
||||
*/
|
||||
/* $TOG: main.c /main/6 1997/12/23 12:08:23 bill $ */
|
||||
/*
|
||||
* Copyright 1993 Open Software Foundation, Inc., Cambridge, Massachusetts.
|
||||
* All rights reserved.
|
||||
*/
|
||||
/*
|
||||
* Copyright (c) 1994
|
||||
* Open Software Foundation, Inc.
|
||||
*
|
||||
* Permission is hereby granted to use, copy, modify and freely distribute
|
||||
* the software in this file and its documentation for any purpose without
|
||||
* fee, provided that the above copyright notice appears in all copies and
|
||||
* that both the copyright notice and this permission notice appear in
|
||||
* supporting documentation. Further, provided that the name of Open
|
||||
* Software Foundation, Inc. ("OSF") not be used in advertising or
|
||||
* publicity pertaining to distribution of the software without prior
|
||||
* written permission from OSF. OSF makes no representations about the
|
||||
* suitability of this software for any purpose. It is provided "as is"
|
||||
* without express or implied warranty.
|
||||
*/
|
||||
/*
|
||||
* Copyright (c) 1996 X Consortium
|
||||
* Copyright (c) 1995, 1996 Dalrymple Consulting
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to deal
|
||||
* in the Software without restriction, including without limitation the rights
|
||||
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
* copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* X CONSORTIUM OR DALRYMPLE CONSULTING BE LIABLE FOR ANY CLAIM, DAMAGES OR
|
||||
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
||||
* OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* Except as contained in this notice, the names of the X Consortium and
|
||||
* Dalrymple Consulting shall not be used in advertising or otherwise to
|
||||
* promote the sale, use or other dealings in this Software without prior
|
||||
* written authorization.
|
||||
*/
|
||||
/* ________________________________________________________________________
|
||||
*
|
||||
* Program to read an SGML document instance, creating any of several things:
|
||||
*
|
||||
* "translated" output for formatting applications (given a trans. spec)
|
||||
* validation report (given a appropriate trans spec)
|
||||
* tree of the document's structure
|
||||
* statistics about the element usage
|
||||
* summary of the elements used
|
||||
* context of each element used
|
||||
* IDs of each element
|
||||
*
|
||||
* A C structure is created for each element, which includes:
|
||||
* name, attributes, parent, children, content
|
||||
* The tree is descended, and the desired actions performed.
|
||||
*
|
||||
* Takes input from James Clark's "sgmls" program (v. 1.1).
|
||||
* ________________________________________________________________________
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <ctype.h>
|
||||
#include <string.h>
|
||||
#include <memory.h>
|
||||
#include <errno.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/stat.h>
|
||||
#include <sys/file.h>
|
||||
#include <time.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#define STORAGE
|
||||
#include "general.h"
|
||||
|
||||
static int do_context, do_tree, do_summ, do_stats, do_validate, do_idlist;
|
||||
static int do_DATAhack = 0;
|
||||
static char *this_prog;
|
||||
static char *in_file, *out_file;
|
||||
static char *tranfile, *cmapfile, *sdatafile;
|
||||
static char *start_id;
|
||||
static char *last_file;
|
||||
static int last_lineno;
|
||||
|
||||
extern int BOFTTextThresh;
|
||||
|
||||
/* forward references */
|
||||
static void HandleArgs(int, char *[]);
|
||||
static void Initialize1();
|
||||
static void Initialize2();
|
||||
static void ReadInstance(char *);
|
||||
static void DoHelpMessage();
|
||||
extern void Browse();
|
||||
|
||||
/* ______________________________________________________________________ */
|
||||
/* Program entry point. Look at args, read instance, dispatch to the
|
||||
* correct routines to do the work, and finish.
|
||||
*/
|
||||
|
||||
int
|
||||
main(
|
||||
int ac,
|
||||
char *av[]
|
||||
)
|
||||
{
|
||||
Initialize1(av[0]);
|
||||
HandleArgs(ac, av);
|
||||
Initialize2();
|
||||
|
||||
ReadInstance(in_file);
|
||||
|
||||
if (interactive) {
|
||||
Browse(); /* this will handle interactive commands */
|
||||
}
|
||||
else {
|
||||
/* Perform tasks based on command line flags... */
|
||||
if (tranfile) {
|
||||
Element_t *e;
|
||||
/* If user wants to start at a particular ID, point to that
|
||||
* element. Else, point to the top of the tree. */
|
||||
if (start_id) {
|
||||
if (!(e=FindElemByID(start_id))) {
|
||||
fprintf(stderr, "Error: Can not find element with ID %s\n",
|
||||
start_id);
|
||||
exit(1);
|
||||
}
|
||||
}
|
||||
else e = DocTree;
|
||||
if (sdatafile) ReadSDATA(sdatafile);
|
||||
if (cmapfile) ReadCharMap(cmapfile);
|
||||
/* If we're doing validation, make output file pointer null.
|
||||
* This means that we generate no output, except error messages. */
|
||||
if (do_validate) outfp = NULL;
|
||||
DoTranslate(e, tranfile, outfp);
|
||||
}
|
||||
if (do_summ) PrintElemSummary(DocTree);
|
||||
if (do_tree) PrintElemTree(DocTree);
|
||||
if (do_stats) PrintStats(DocTree);
|
||||
if (do_context) PrintContext(DocTree);
|
||||
if (do_idlist) PrintIDList();
|
||||
}
|
||||
if (out_file && outfp) fclose(outfp);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* ______________________________________________________________________ */
|
||||
/* Initialization stuff done before dealing with args.
|
||||
* Arguments:
|
||||
* Name of program (string).
|
||||
*/
|
||||
|
||||
static void
|
||||
Initialize1(
|
||||
char *myname
|
||||
)
|
||||
{
|
||||
time_t tnow;
|
||||
struct tm *nowtm;
|
||||
char *cp, buf[100];
|
||||
|
||||
/* where we try to find data/library files */
|
||||
if (!(tpt_lib=getenv(TPT_LIB))) tpt_lib = DEF_TPT_LIB;
|
||||
|
||||
/* set some global variables */
|
||||
warnings = 1;
|
||||
fold_case = 1;
|
||||
this_prog = myname;
|
||||
|
||||
/* setup global variable mapping */
|
||||
Variables = NewMap(IMS_variables);
|
||||
|
||||
/* set some pre-defined variables */
|
||||
SetMappingNV(Variables, "user", (cp=getenv("USER")) ? cp : "UnknownUser" );
|
||||
time(&tnow);
|
||||
nowtm = localtime(&tnow);
|
||||
strftime(buf, 100, "%a %d %b %Y, %R", nowtm);
|
||||
SetMappingNV(Variables, "date", buf);
|
||||
SetMappingNV(Variables, "host", "unknown-host");
|
||||
SetMappingNV(Variables, "transpec", tranfile ? tranfile : "??");
|
||||
}
|
||||
|
||||
/* Initialization stuff done after dealing with args. */
|
||||
|
||||
static void
|
||||
Initialize2(void)
|
||||
{
|
||||
SetMappingNV(Variables, "transpec", tranfile ? tranfile : "??");
|
||||
|
||||
/* If user wants to send output to a file, open the file, and set
|
||||
* the file pointer. Else we send output to standard out. */
|
||||
if (out_file) {
|
||||
if (!(outfp = fopen(out_file, "w"))) {
|
||||
fprintf(stderr, "Could not open output '%s' file for writing.\n%s",
|
||||
out_file, strerror(errno));
|
||||
exit(1);
|
||||
}
|
||||
}
|
||||
else outfp = stdout;
|
||||
}
|
||||
|
||||
/* ______________________________________________________________________ */
|
||||
/* Set a variable. If it is one of the "known" variables, set the
|
||||
* variable in the C code (this program).
|
||||
* Arguments:
|
||||
* Variable name/value string - separated by an '=' (eg, "myname=Sally").
|
||||
*/
|
||||
static void
|
||||
CmdLineSetVariable(
|
||||
char *var
|
||||
)
|
||||
{
|
||||
char *cp, buf[100], **tok;
|
||||
int n;
|
||||
|
||||
/* Turn '=' into a space, to isolate the name. Then set variable. */
|
||||
strcpy(buf, var);
|
||||
if ((cp=strchr(buf, '='))) {
|
||||
/* we have "var=value" */
|
||||
*cp = ' ';
|
||||
n = 2;
|
||||
tok = Split(buf, &n, 0);
|
||||
/* see if variable name matches one of our internal ones */
|
||||
if (!strcmp(tok[0], "verbose")) verbose = atoi(tok[1]);
|
||||
else if (!strcmp(tok[0], "warnings")) warnings = atoi(tok[1]);
|
||||
else if (!strcmp(tok[0], "foldcase")) fold_case = atoi(tok[1]);
|
||||
else SetMappingNV(Variables, tok[0], tok[1]);
|
||||
}
|
||||
else {
|
||||
fprintf(stderr, "Expected an '=' in variable assignment: %s. Ignored\n",
|
||||
var);
|
||||
}
|
||||
}
|
||||
|
||||
/* ______________________________________________________________________ */
|
||||
/* Bounce through arguments, setting variables and flags.
|
||||
* Arguments:
|
||||
* Argc and Argv, as passed to main().
|
||||
*/
|
||||
static void
|
||||
HandleArgs(
|
||||
int ac,
|
||||
char *av[]
|
||||
)
|
||||
{
|
||||
int c, errflag=0;
|
||||
extern char *optarg;
|
||||
extern int optind;
|
||||
|
||||
while ((c=getopt(ac, av, "df:t:vc:s:o:huSxIl:bHVWi:D:Z")) != EOF) {
|
||||
switch (c) {
|
||||
case 't': tranfile = optarg; break;
|
||||
case 'v': do_validate = 1; break;
|
||||
case 's': sdatafile = optarg; break;
|
||||
case 'c': cmapfile = optarg; break;
|
||||
case 'h': do_tree = 1; break;
|
||||
case 'u': do_summ = 1; break;
|
||||
case 'S': do_stats = 1; break;
|
||||
case 'x': do_context = 1; break;
|
||||
case 'I': do_idlist = 1; break;
|
||||
case 'l': tpt_lib = optarg; break;
|
||||
case 'i': start_id = optarg; break;
|
||||
case 'o': out_file = optarg; break;
|
||||
case 'd': do_DATAhack = 1; break;
|
||||
case 'f': BOFTTextThresh = atoi(optarg); break;
|
||||
case 'b': interactive = 1; break;
|
||||
case 'W': warnings = 0; break;
|
||||
case 'V': verbose = 1; break;
|
||||
case 'Z': slave = 1; break;
|
||||
case 'H': DoHelpMessage(); exit(0); break;
|
||||
case 'D': CmdLineSetVariable(optarg); break;
|
||||
case '?': errflag = 1; break;
|
||||
}
|
||||
if (errflag) {
|
||||
fprintf(stderr, "Try '%s -H' for help.\n", this_prog);
|
||||
exit(1);
|
||||
}
|
||||
}
|
||||
|
||||
/* input (ESIS) file name */
|
||||
if (optind < ac) in_file = av[optind];
|
||||
|
||||
/* If doing interactive/browsing, we can't take ESIS from stdin. */
|
||||
if (interactive && !in_file) {
|
||||
fprintf(stderr,
|
||||
"You must specify ESIS file on cmd line for browser mode.\n");
|
||||
exit(1);
|
||||
}
|
||||
}
|
||||
|
||||
/* ______________________________________________________________________ */
|
||||
/* Simply print out a help/usage message.
|
||||
*/
|
||||
|
||||
static char *help_msg[] = {
|
||||
"",
|
||||
" -t file Print translated output using translation spec in <file>",
|
||||
" -s file <file> contains a list of SDATA entity mappings",
|
||||
" -c file <file> contains a list of character mappings",
|
||||
" -v Validate using translation spec specified with -t",
|
||||
" -i id Consider only subtree starting at element with ID <id>",
|
||||
" -b Interactive browser",
|
||||
" -S Print statistics (how often elements occur, etc.)",
|
||||
" -u Print element usage summary (# of children, depth, etc.)",
|
||||
" -x Print context of each element",
|
||||
" -h Print document hierarchy as a tree",
|
||||
" -o file Write output to <file>. Default is standard output.",
|
||||
" -l dir Set library directory to <dir>. (or env. variable TPT_LIB)",
|
||||
" -I List all IDs used in the instance",
|
||||
" -W Do not print warning messages",
|
||||
" -H Print this help message",
|
||||
" -Dvar=val Set variable 'var' to value 'val'",
|
||||
" file Take input from named file. If not specified, assume stdin.",
|
||||
" File should be output from the 'sgmls' program (ESIS).",
|
||||
NULL
|
||||
};
|
||||
|
||||
static void
|
||||
DoHelpMessage(void)
|
||||
{
|
||||
char **s = help_msg;
|
||||
printf("usage: %s [option ...] [file]", this_prog);
|
||||
while (*s) puts(*s++);
|
||||
printf("\n");
|
||||
}
|
||||
|
||||
/* ______________________________________________________________________ */
|
||||
/* Remember an external entity for future reference.
|
||||
* Arguments:
|
||||
* Pointer to entity structure to remember.
|
||||
*/
|
||||
|
||||
static void
|
||||
AddEntity(
|
||||
Entity_t *ent
|
||||
)
|
||||
{
|
||||
static Entity_t *last_ent;
|
||||
|
||||
if (!Entities) {
|
||||
Malloc(1, Entities, Entity_t);
|
||||
last_ent = Entities;
|
||||
}
|
||||
else {
|
||||
Malloc(1, last_ent->next, Entity_t);
|
||||
last_ent = last_ent->next;
|
||||
}
|
||||
*last_ent = *ent;
|
||||
|
||||
}
|
||||
|
||||
/* Find an entity, given its entity name.
|
||||
* Arguments:
|
||||
* Name of entity to retrieve.
|
||||
*/
|
||||
static Entity_t *
|
||||
FindEntity(
|
||||
char *ename
|
||||
)
|
||||
{
|
||||
Entity_t *n;
|
||||
for (n=Entities; n; n=n->next)
|
||||
if (StrEq(ename, n->ename)) return n;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Accumulate lines up to the open tag. Attributes, line number,
|
||||
* entity info, notation info, etc., all come before the open tag.
|
||||
*/
|
||||
static Element_t *
|
||||
AccumElemInfo(
|
||||
FILE *fp
|
||||
)
|
||||
{
|
||||
char buf[LINESIZE+1];
|
||||
int c;
|
||||
int i, na;
|
||||
char *cp, *atval;
|
||||
Mapping_t a[100];
|
||||
Element_t *e;
|
||||
Entity_t ent, *ent2;
|
||||
char **tok;
|
||||
static int Index=0;
|
||||
static Element_t *last_e;
|
||||
|
||||
|
||||
Calloc(1, e, Element_t);
|
||||
memset(&ent, 0, sizeof ent); /* clean space for entity info */
|
||||
|
||||
/* Also, keep a linked list of elements, so we can easily scan through */
|
||||
if (last_e) last_e->next = e;
|
||||
last_e = e;
|
||||
|
||||
e->index = Index++; /* just a unique number for identification */
|
||||
|
||||
/* in case these are not set for this element in the ESIS */
|
||||
e->lineno = last_lineno;
|
||||
e->infile = last_file;
|
||||
|
||||
na = 0;
|
||||
while (1) {
|
||||
if ((c = getc(fp)) == EOF) break;
|
||||
fgets(buf, LINESIZE, fp);
|
||||
stripNL(buf);
|
||||
switch (c) {
|
||||
case EOF: /* End of input */
|
||||
fprintf(stderr, "Error: Unexpectedly reached end of ESIS.\n");
|
||||
exit(1);
|
||||
break;
|
||||
|
||||
case CMD_OPEN: /* (gi */
|
||||
e->gi = AddElemName(buf);
|
||||
if (na > 0) {
|
||||
Malloc(na, e->atts, Mapping_t);
|
||||
memcpy(e->atts, a, na*sizeof(Mapping_t));
|
||||
e->natts = na;
|
||||
na = 0;
|
||||
}
|
||||
/* Check if this elem has a notation attr. If yes, and there
|
||||
is no notation specified, recall the previous one. (feature
|
||||
of sgmls - it does not repeat notation stuff if we the same
|
||||
is used twice in a row) */
|
||||
if (((atval=FindAttValByName(e, "NAME")) ||
|
||||
(atval=FindAttValByName(e, "ENTITYREF")) ||
|
||||
(atval=FindAttValByName(e, "EXTERNAL"))) && /* HACK */
|
||||
(ent2=FindEntity(atval))) {
|
||||
e->entity = ent2;
|
||||
}
|
||||
|
||||
return e;
|
||||
break;
|
||||
|
||||
case CMD_ATT: /* Aname val */
|
||||
i = 3;
|
||||
tok = Split(buf, &i, 0);
|
||||
if (!strcmp(tok[1], "IMPLIED")) break; /* skip IMPLIED atts. */
|
||||
if (!strcmp(tok[1], "CDATA") || !strcmp(tok[1], "TOKEN") ||
|
||||
!strcmp(tok[1], "ENTITY") ||!strcmp(tok[1], "NOTATION"))
|
||||
{
|
||||
a[na].name = AddAttName(tok[0]);
|
||||
a[na].sval = AddAttName(tok[2]);
|
||||
na++;
|
||||
}
|
||||
else {
|
||||
fprintf(stderr, "Error: Bad attr line (%d): A%s %s...\n",
|
||||
e->lineno, tok[0], tok[1]);
|
||||
}
|
||||
break;
|
||||
|
||||
case CMD_LINE: /* Llineno */
|
||||
/* These lines come in 2 forms: "L123" and "L123 file.sgml".
|
||||
* Filename is given only at 1st occurrence. Remember it.
|
||||
*/
|
||||
if ((cp = strchr(buf, ' '))) {
|
||||
cp++;
|
||||
last_file = strdup(cp);
|
||||
}
|
||||
last_lineno = e->lineno = atoi(buf);
|
||||
e->infile = last_file;
|
||||
break;
|
||||
|
||||
case CMD_DATA: /* -data */
|
||||
fprintf(stderr, "Error: Data in AccumElemInfo, line %d:\n%c%s\n",
|
||||
e->lineno, c,buf);
|
||||
/*return e;*/
|
||||
exit(1);
|
||||
break;
|
||||
|
||||
case CMD_D_ATT: /* Dename name val */
|
||||
|
||||
case CMD_NOTATION: /* Nnname */
|
||||
case CMD_PI: /* ?pi */
|
||||
/* This should be reworked soon, as it
|
||||
forces all PI's before the first GI
|
||||
to be ignored. -CSS */
|
||||
break;
|
||||
|
||||
case CMD_EXT_ENT: /* Eename typ nname */
|
||||
i = 3;
|
||||
tok = Split(buf, &i, 0);
|
||||
ent.ename = strdup(tok[0]);
|
||||
ent.type = strdup(tok[1]);
|
||||
ent.nname = strdup(tok[2]);
|
||||
AddEntity(&ent);
|
||||
break;
|
||||
case CMD_INT_ENT: /* Iename typ text */
|
||||
fprintf(stderr, "Error: Got CMD_INT_ENT in AccumElemInfo: %s\n", buf);
|
||||
break;
|
||||
case CMD_SYSID: /* ssysid */
|
||||
ent.sysid = strdup(buf);
|
||||
break;
|
||||
case CMD_PUBID: /* ppubid */
|
||||
ent.pubid = strdup(buf);
|
||||
break;
|
||||
case CMD_FILENAME: /* ffilename */
|
||||
ent.fname = strdup(buf);
|
||||
break;
|
||||
|
||||
case CMD_CLOSE: /* )gi */
|
||||
case CMD_SUBDOC: /* Sename */
|
||||
case CMD_SUBDOC_S: /* {ename */
|
||||
case CMD_SUBDOC_E: /* }ename */
|
||||
case CMD_EXT_REF: /* &name */
|
||||
case CMD_APPINFO: /* #text */
|
||||
case CMD_CONFORM: /* C */
|
||||
default:
|
||||
fprintf(stderr, "Error: Unexpected input in AccumElemInfo, %d:\n%c%s\n",
|
||||
e->lineno, c,buf);
|
||||
exit(1);
|
||||
break;
|
||||
}
|
||||
}
|
||||
fprintf(stderr, "Error: End of AccumElemInfo - should not be here: %s\n",
|
||||
e->gi);
|
||||
/* return e;*/
|
||||
exit(1);
|
||||
}
|
||||
|
||||
/* Read ESIS lines.
|
||||
* Limitation? Max 50000 children per node. (done for efficiency --
|
||||
* should do some malloc and bookkeeping games later).
|
||||
*/
|
||||
|
||||
static Element_t *
|
||||
ReadESIS(
|
||||
FILE *fp,
|
||||
int depth
|
||||
)
|
||||
{
|
||||
char *buf;
|
||||
int i, c, ncont;
|
||||
int curnum = 10; /* current # of elements allocated */
|
||||
Element_t *e;
|
||||
Content_t *cont;
|
||||
|
||||
Malloc( curnum, cont, Content_t );
|
||||
Malloc( LINESIZE+1, buf, char );
|
||||
|
||||
/* Read input stream - the output of "sgmls", called "ESIS". */
|
||||
e = AccumElemInfo(fp);
|
||||
e->depth = depth;
|
||||
|
||||
ncont = 0;
|
||||
while (1) {
|
||||
if (ncont >= curnum) { /* may need more */
|
||||
curnum += curnum;
|
||||
Realloc(curnum, cont, Content_t);
|
||||
}
|
||||
|
||||
if ((c = getc(fp)) == EOF) break;
|
||||
switch (c) {
|
||||
case EOF: /* End of input */
|
||||
break;
|
||||
|
||||
case CMD_DATA: /* -data */
|
||||
fgets(buf, LINESIZE, fp);
|
||||
stripNL(buf);
|
||||
if (do_DATAhack && (buf[0] == '\\') && (buf[1] == 'n') ) {
|
||||
buf[0] = -1; /* simulate "^" command */
|
||||
memmove(&buf[1], &buf[2], strlen(buf)-1);
|
||||
}
|
||||
cont[ncont].ch.data = strdup(buf);
|
||||
cont[ncont].type = CMD_DATA;
|
||||
ncont++;
|
||||
break;
|
||||
|
||||
case CMD_PI: /* ?pi */
|
||||
fgets(buf, LINESIZE, fp);
|
||||
stripNL(buf);
|
||||
cont[ncont].type = CMD_PI;
|
||||
cont[ncont].ch.data = strdup(buf);
|
||||
ncont++;
|
||||
break;
|
||||
|
||||
case CMD_CLOSE: /* )gi */
|
||||
fgets(buf, LINESIZE, fp);
|
||||
stripNL(buf);
|
||||
if (ncont) {
|
||||
e->ncont = ncont;
|
||||
Malloc(ncont, e->cont, Content_t);
|
||||
for (i=0; i<ncont; i++) e->cont[i] = cont[i];
|
||||
}
|
||||
free(cont);
|
||||
free(buf);
|
||||
return e;
|
||||
break;
|
||||
|
||||
case CMD_OPEN: /* (gi */
|
||||
/*fprintf(stderr, "+++++ OPEN +++\n");*/
|
||||
/* break;*/
|
||||
|
||||
case CMD_ATT: /* Aname val */
|
||||
case CMD_D_ATT: /* Dename name val */
|
||||
case CMD_NOTATION: /* Nnname */
|
||||
case CMD_EXT_ENT: /* Eename typ nname */
|
||||
case CMD_INT_ENT: /* Iename typ text */
|
||||
case CMD_SYSID: /* ssysid */
|
||||
case CMD_PUBID: /* ppubid */
|
||||
case CMD_FILENAME: /* ffilename */
|
||||
ungetc(c, fp);
|
||||
cont[ncont].ch.elem = ReadESIS(fp, depth+1);
|
||||
cont[ncont].type = CMD_OPEN;
|
||||
cont[ncont].ch.elem->parent = e;
|
||||
ncont++;
|
||||
break;
|
||||
|
||||
case CMD_LINE: /* Llineno */
|
||||
fgets(buf, LINESIZE, fp);
|
||||
break; /* ignore these here */
|
||||
|
||||
case CMD_SUBDOC: /* Sename */
|
||||
case CMD_SUBDOC_S: /* {ename */
|
||||
case CMD_SUBDOC_E: /* }ename */
|
||||
case CMD_EXT_REF: /* &name */
|
||||
case CMD_APPINFO: /* #text */
|
||||
case CMD_CONFORM: /* C */
|
||||
default:
|
||||
fgets(buf, LINESIZE, fp);
|
||||
fprintf(stderr, "Error: Unexpected input at %d: '%c%s'\n",
|
||||
e->lineno, c, buf);
|
||||
exit(1);
|
||||
break;
|
||||
}
|
||||
}
|
||||
fprintf(stderr, "Error: End of ReadESIS - should not be here: %s\n", e->gi);
|
||||
free(cont);
|
||||
free(buf);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* ______________________________________________________________________ */
|
||||
/* Read input stream, creating a tree in memory of the elements and data.
|
||||
* Arguments:
|
||||
* Filename where instance's ESIS is.
|
||||
*/
|
||||
static void
|
||||
ReadInstance(
|
||||
char *filename
|
||||
)
|
||||
{
|
||||
int i, n;
|
||||
FILE *fp;
|
||||
Element_t *e;
|
||||
char *idatt;
|
||||
|
||||
if (filename) { /* if we specified input file. else stdin */
|
||||
if ((fp=fopen(filename, "r")) == NULL) {
|
||||
perror(filename);
|
||||
exit(1);
|
||||
}
|
||||
}
|
||||
else fp = stdin;
|
||||
last_file = filename;
|
||||
DocTree = ReadESIS(fp, 0);
|
||||
if (filename) fclose(fp);
|
||||
|
||||
/* Traverse tree, filling in econt and figuring out which child
|
||||
* (ie. what birth order) each element is. */
|
||||
DocTree->my_eorder = -1;
|
||||
for (e=DocTree; e; e=e->next) {
|
||||
|
||||
/* count element children */
|
||||
for (i=0,n=0; i<e->ncont; i++) if (IsContElem(e,i)) n++;
|
||||
if (n > 0) Calloc(n, e->econt, Element_t *);
|
||||
for (i=0; i<e->ncont; i++)
|
||||
if (IsContElem(e,i)) e->econt[e->necont++] = ContElem(e,i);
|
||||
|
||||
/* count data children */
|
||||
for (i=0,n=0; i<e->ncont; i++) if (IsContData(e,i)) n++;
|
||||
if (n > 0) Calloc(n, e->dcont, char *);
|
||||
for (i=0; i<e->ncont; i++)
|
||||
if (IsContData(e,i)) e->dcont[e->ndcont++] = ContData(e,i);
|
||||
|
||||
/* where in child order order */
|
||||
for (i=0; i<e->necont; i++)
|
||||
e->econt[i]->my_eorder = i;
|
||||
|
||||
/* Does this element have an ID? */
|
||||
for (i=0; i<e->natts; i++) {
|
||||
if ((idatt=FindAttValByName(e, "ID"))) {
|
||||
AddID(e, idatt);
|
||||
/* remember ID value for quick reference */
|
||||
e->id = idatt;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
/* ______________________________________________________________________ */
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,467 +0,0 @@
|
||||
/*
|
||||
* CDE - Common Desktop Environment
|
||||
*
|
||||
* Copyright (c) 1993-2012, The Open Group. All rights reserved.
|
||||
*
|
||||
* These libraries and programs are free software; you can
|
||||
* redistribute them and/or modify them under the terms of the GNU
|
||||
* Lesser General Public License as published by the Free Software
|
||||
* Foundation; either version 2 of the License, or (at your option)
|
||||
* any later version.
|
||||
*
|
||||
* These libraries and programs are distributed in the hope that
|
||||
* they 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 these libraries and programs; if not, write
|
||||
* to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
|
||||
* Floor, Boston, MA 02110-1301 USA
|
||||
*/
|
||||
/* $XConsortium: traninit.c /main/1 1996/07/23 19:43:52 rws $ */
|
||||
/*
|
||||
* Copyright 1993 Open Software Foundation, Inc., Cambridge, Massachusetts.
|
||||
* All rights reserved.
|
||||
*/
|
||||
/*
|
||||
* Copyright (c) 1994
|
||||
* Open Software Foundation, Inc.
|
||||
*
|
||||
* Permission is hereby granted to use, copy, modify and freely distribute
|
||||
* the software in this file and its documentation for any purpose without
|
||||
* fee, provided that the above copyright notice appears in all copies and
|
||||
* that both the copyright notice and this permission notice appear in
|
||||
* supporting documentation. Further, provided that the name of Open
|
||||
* Software Foundation, Inc. ("OSF") not be used in advertising or
|
||||
* publicity pertaining to distribution of the software without prior
|
||||
* written permission from OSF. OSF makes no representations about the
|
||||
* suitability of this software for any purpose. It is provided "as is"
|
||||
* without express or implied warranty.
|
||||
*/
|
||||
/*
|
||||
* Copyright (c) 1996 X Consortium
|
||||
* Copyright (c) 1995, 1996 Dalrymple Consulting
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to deal
|
||||
* in the Software without restriction, including without limitation the rights
|
||||
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
* copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* X CONSORTIUM OR DALRYMPLE CONSULTING BE LIABLE FOR ANY CLAIM, DAMAGES OR
|
||||
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
||||
* OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* Except as contained in this notice, the names of the X Consortium and
|
||||
* Dalrymple Consulting shall not be used in advertising or otherwise to
|
||||
* promote the sale, use or other dealings in this Software without prior
|
||||
* written authorization.
|
||||
*/
|
||||
/* ________________________________________________________________________
|
||||
*
|
||||
* Program to manipulate SGML instances.
|
||||
*
|
||||
* This module contains the initialization routines for translation module.
|
||||
* They mostly deal with reading data files (translation specs, SDATA
|
||||
* mappings, character mappings).
|
||||
*
|
||||
* Entry points:
|
||||
* ReadTransSpec(transfile) read/store translation spec from file
|
||||
* ReadSDATA(sdatafile) read/store SDATA mappings from file
|
||||
* ReadMapping(mapfile) read/store char mappings from file
|
||||
* ________________________________________________________________________
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <ctype.h>
|
||||
#include <string.h>
|
||||
#include <memory.h>
|
||||
#include <sys/types.h>
|
||||
#include <errno.h>
|
||||
|
||||
#include <tptregexp.h>
|
||||
#include "general.h"
|
||||
#include "translate.h"
|
||||
|
||||
#ifndef TRUE
|
||||
#define TRUE (1 == 1)
|
||||
#endif
|
||||
|
||||
/* forward references */
|
||||
void RememberTransSpec(Trans_t *, int);
|
||||
void ExpandVariables(char *in, char *out, Element_t *e);
|
||||
|
||||
/* ______________________________________________________________________ */
|
||||
/* Read the translation specs from the input file, storing in memory.
|
||||
* Arguments:
|
||||
* Name of translation spec file.
|
||||
*/
|
||||
|
||||
void
|
||||
ReadTransSpec(
|
||||
char *transfile
|
||||
)
|
||||
{
|
||||
FILE *fp;
|
||||
char buf[LINESIZE], *cp, *fn, *cp2;
|
||||
int lineno=0, c, i;
|
||||
Trans_t T;
|
||||
|
||||
if ((fp=OpenFile(transfile)) == NULL) {
|
||||
fprintf(stderr, "Can not open translation spec file '%s'.\n%s\n",
|
||||
transfile, strerror(errno));
|
||||
return;
|
||||
}
|
||||
|
||||
memset(&T, 0, sizeof T); /* initialize/clear structure */
|
||||
while (fgets(buf, LINESIZE, fp)) /* read line from .ts file */
|
||||
{
|
||||
lineno++;
|
||||
/* skip comment and blank lines */
|
||||
if (buf[0] == '#' || buf[0] == NL) continue;
|
||||
|
||||
/* '-' indicates end of a spec. When we hit one, remember what we've
|
||||
* accumulated so far, and null-out the accumulating structure. */
|
||||
if (buf[0] == '-') {
|
||||
T.lineno = lineno;
|
||||
RememberTransSpec(&T, lineno);
|
||||
memset(&T, 0, sizeof T);
|
||||
continue;
|
||||
}
|
||||
|
||||
stripNL(buf);
|
||||
|
||||
/* See if next line is continued from this one -- ie. it starts with
|
||||
* whitespace. If so, append to current line. (This is similar to
|
||||
* how e-mail headers work...) */
|
||||
while (1) {
|
||||
c = getc(fp); /* 1st char of next line */
|
||||
if (IsWhite(c)) { /* space or tab? */
|
||||
/* keep getting characters until it's a non-whitespace */
|
||||
c = getc(fp);
|
||||
while (IsWhite(c)) c = getc(fp);
|
||||
ungetc(c, fp); /* put back non-whitespace */
|
||||
i = strlen(buf);
|
||||
buf[i++] = ' ';
|
||||
fn = buf + i; /* point to end of string in buffer */
|
||||
fgets(fn, LINESIZE-i, fp); /* read and append to buf */
|
||||
lineno++;
|
||||
stripNL(buf);
|
||||
}
|
||||
else {
|
||||
ungetc(c, fp); /* put back non-whitespace */
|
||||
break;
|
||||
}
|
||||
}
|
||||
/* Isolate field value */
|
||||
if ((cp=strchr(buf, ':'))) {
|
||||
cp++; /* point past colon */
|
||||
while (*cp && IsWhite(*cp)) cp++; /* point to content */
|
||||
}
|
||||
else {
|
||||
fprintf(stderr,
|
||||
"Trans spec error, missing colon (skipping line):\n %s\n", fn);
|
||||
continue;
|
||||
}
|
||||
fn = buf; /* fn is name of the field, cp the value. */
|
||||
|
||||
/* Check field names in order that they're likely to occur. */
|
||||
if (!strncmp("GI:", fn, 3)) {
|
||||
/* if we are folding the case of GIs, make all upper (unless
|
||||
it's an internal pseudo-GI name, which starts with '_') */
|
||||
if (fold_case && cp[0] != '_' && cp[0] != '#') {
|
||||
for (cp2=cp; *cp2; cp2++)
|
||||
if (islower(*cp2)) *cp2 = toupper(*cp2);
|
||||
}
|
||||
T.gi = AddElemName(cp);
|
||||
}
|
||||
else if (!strncmp("StartText:", fn, 10)) T.starttext = strdup(cp);
|
||||
else if (!strncmp("EndText:", fn, 8)) T.endtext = strdup(cp);
|
||||
else if (!strncmp("Relation:", fn, 9)) {
|
||||
if (!T.relations) T.relations = NewMap(IMS_relations);
|
||||
SetMapping(T.relations, cp);
|
||||
}
|
||||
else if (!strncmp("Replace:", fn, 8)) T.replace = strdup(cp);
|
||||
else if (!strncmp("AttValue:", fn, 9)) {
|
||||
if (!T.nattpairs) {
|
||||
Malloc(1, T.attpair, AttPair_t);
|
||||
}
|
||||
else
|
||||
Realloc((T.nattpairs+1), T.attpair, AttPair_t);
|
||||
/* we'll split name/value pairs later */
|
||||
T.attpair[T.nattpairs].name = strdup(cp);
|
||||
T.nattpairs++;
|
||||
}
|
||||
/* If there's only one item in context, it's the parent. Treat
|
||||
* it specially, since it's easier to just check parent gi.
|
||||
*/
|
||||
else if (!strncmp("Context:", fn, 8)) T.context = strdup(cp);
|
||||
else if (!strncmp("Message:", fn, 8)) T.message = strdup(cp);
|
||||
else if (!strncmp("SpecID:", fn, 7)) T.my_id = atoi(cp);
|
||||
else if (!strncmp("Action:", fn, 7)) T.use_id = atoi(cp);
|
||||
else if (!strncmp("Content:", fn, 8)) T.content = strdup(cp);
|
||||
else if (!strncmp("PAttSet:", fn, 8)) T.pattrset = strdup(cp);
|
||||
else if (!strncmp("Verbatim:", fn, 9)) T.verbatim = TRUE;
|
||||
else if (!strncmp("Ignore:", fn, 7)) {
|
||||
if (!strcmp(cp, "all")) T.ignore = IGN_ALL;
|
||||
else if (!strcmp(cp, "data")) T.ignore = IGN_DATA;
|
||||
else if (!strcmp(cp, "children")) T.ignore = IGN_CHILDREN;
|
||||
else
|
||||
fprintf(stderr, "Bad 'Ignore:' arg in transpec (line %d): %s\n",
|
||||
lineno, cp);
|
||||
}
|
||||
else if (!strncmp("VarValue:", fn, 9)) {
|
||||
char **tok;
|
||||
i = 2;
|
||||
tok = Split(cp, &i, S_STRDUP);
|
||||
T.var_name = tok[0];
|
||||
T.var_value = tok[1];
|
||||
}
|
||||
else if (!strncmp("VarREValue:", fn, 11)) {
|
||||
char **tok;
|
||||
i = 2;
|
||||
tok = Split(cp, &i, S_STRDUP);
|
||||
T.var_RE_name = tok[0];
|
||||
ExpandVariables(tok[1], buf, 0);
|
||||
if (!(T.var_RE_value=tpt_regcomp(buf))) {
|
||||
fprintf(stderr, "Regex error in VarREValue Content: %s\n",
|
||||
tok[1]);
|
||||
}
|
||||
}
|
||||
else if (!strncmp("Set:", fn, 4)) {
|
||||
if (!T.set_var) T.set_var = NewMap(IMS_setvar);
|
||||
SetMapping(T.set_var, cp);
|
||||
}
|
||||
else if (!strncmp("Increment:", fn, 10)) {
|
||||
if (!T.incr_var) T.incr_var = NewMap(IMS_incvar);
|
||||
SetMapping(T.incr_var, cp);
|
||||
}
|
||||
else if (!strncmp("NthChild:", fn, 9)) T.nth_child = atoi(cp);
|
||||
else if (!strncmp("Var:", fn, 4)) SetMapping(Variables, cp);
|
||||
else if (!strncmp("Quit:", fn, 5)) T.quit = strdup(cp);
|
||||
else
|
||||
fprintf(stderr, "Unknown translation spec (skipping it): %s\n", fn);
|
||||
}
|
||||
fclose(fp);
|
||||
}
|
||||
|
||||
/* ______________________________________________________________________ */
|
||||
/* Store translation spec 't' in memory.
|
||||
* Arguments:
|
||||
* Pointer to translation spec to remember.
|
||||
* Line number where translation spec ends.
|
||||
*/
|
||||
void
|
||||
RememberTransSpec(
|
||||
Trans_t *t,
|
||||
int lineno
|
||||
)
|
||||
{
|
||||
char *cp;
|
||||
int i, do_regex;
|
||||
static Trans_t *last_t;
|
||||
char buf[1000];
|
||||
|
||||
/* If context testing, check some details and set things up for later. */
|
||||
if (t->context) {
|
||||
/* See if the context specified is a regular expression.
|
||||
* If so, compile the reg expr. It is assumed to be a regex if
|
||||
* it contains a character other than what's allowed for GIs in the
|
||||
* OSF sgml declaration (alphas, nums, '-', and '.').
|
||||
*/
|
||||
for (do_regex=0,cp=t->context; *cp; cp++) {
|
||||
if (!isalnum(*cp) && *cp != '-' && *cp != '.' && *cp != ' ') {
|
||||
do_regex = 1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (do_regex) {
|
||||
t->depth = MAX_DEPTH;
|
||||
if (!(t->context_re=tpt_regcomp(t->context))) {
|
||||
fprintf(stderr, "Regex error in Context: %s\n", t->context);
|
||||
}
|
||||
}
|
||||
else {
|
||||
/* If there's only one item in context, it's the parent. Treat
|
||||
* it specially, since it's faster to just check parent gi.
|
||||
*/
|
||||
cp = t->context;
|
||||
if (!strchr(cp, ' ')) {
|
||||
t->parent = t->context;
|
||||
t->context = NULL;
|
||||
}
|
||||
else {
|
||||
/* Figure out depth of context string */
|
||||
t->depth = 0;
|
||||
while (*cp) {
|
||||
if (*cp) t->depth++;
|
||||
while (*cp && !IsWhite(*cp)) cp++; /* find end of gi */
|
||||
while (*cp && IsWhite(*cp)) cp++; /* skip space */
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Compile regular expressions for each attribute */
|
||||
for (i=0; i<t->nattpairs; i++) {
|
||||
/* Initially, name points to "name value". Split them... */
|
||||
cp = t->attpair[i].name;
|
||||
while (*cp && !IsWhite(*cp)) cp++; /* point past end of name */
|
||||
if (*cp) { /* value found */
|
||||
*cp++ = EOS; /* terminate name */
|
||||
while (*cp && IsWhite(*cp)) cp++; /* point to value */
|
||||
ExpandVariables(cp, buf, 0); /* expand any variables */
|
||||
t->attpair[i].val = strdup(buf);
|
||||
}
|
||||
else { /* value not found */
|
||||
t->attpair[i].val = ".";
|
||||
}
|
||||
if (!(t->attpair[i].rex=tpt_regcomp(t->attpair[i].val))) {
|
||||
fprintf(stderr, "Regex error in AttValue: %s %s\n",
|
||||
t->attpair[i].name, t->attpair[i].val);
|
||||
}
|
||||
}
|
||||
|
||||
/* Compile regular expression for content */
|
||||
t->content_re = 0;
|
||||
if (t->content) {
|
||||
ExpandVariables(t->content, buf, 0);
|
||||
if (!(t->content_re=tpt_regcomp(buf)))
|
||||
fprintf(stderr, "Regex error in Content: %s\n",
|
||||
t->content);
|
||||
}
|
||||
|
||||
/* If multiple GIs, break up into a vector, then remember it. We either
|
||||
* sture the individual, or the list - not both. */
|
||||
if (t->gi && strchr(t->gi, ' ')) {
|
||||
t->gilist = Split(t->gi, 0, S_ALVEC);
|
||||
t->gi = NULL;
|
||||
}
|
||||
|
||||
/* Now, store structure in linked list. */
|
||||
if (!TrSpecs) {
|
||||
Malloc(1, TrSpecs, Trans_t);
|
||||
last_t = TrSpecs;
|
||||
}
|
||||
else {
|
||||
Malloc(1, last_t->next, Trans_t);
|
||||
last_t = last_t->next;
|
||||
}
|
||||
*last_t = *t;
|
||||
}
|
||||
|
||||
|
||||
/* ______________________________________________________________________ */
|
||||
/* Read mapping file, filling in structure slots (just name-value pairs).
|
||||
* Arguments:
|
||||
* Name of character mapping file.
|
||||
*/
|
||||
|
||||
void
|
||||
ReadCharMap(
|
||||
char *filename
|
||||
)
|
||||
{
|
||||
FILE *fp;
|
||||
char buf[LINESIZE], *name, *val;
|
||||
int lineno=0;
|
||||
int n_alloc=0; /* number of slots allocated so far */
|
||||
|
||||
if ((fp=OpenFile(filename)) == NULL) {
|
||||
fprintf(stderr, "Can not open character mapping file '%s'.\n%s\n",
|
||||
filename, strerror(errno));
|
||||
return;
|
||||
}
|
||||
|
||||
/* We allocate slots in blocks of N, so we don't have to call
|
||||
* malloc so many times. */
|
||||
n_alloc = 32;
|
||||
Calloc(n_alloc, CharMap, Mapping_t);
|
||||
|
||||
nCharMap = 0;
|
||||
while (fgets(buf, LINESIZE, fp))
|
||||
{
|
||||
lineno++;
|
||||
/* skip comment and blank lines */
|
||||
if (buf[0] == '#' || buf[0] == NL) continue;
|
||||
stripNL(buf);
|
||||
|
||||
/* Need more slots for mapping structures? */
|
||||
if (nCharMap >= n_alloc) {
|
||||
n_alloc += 32;
|
||||
Realloc(n_alloc, CharMap, Mapping_t);
|
||||
}
|
||||
name = val = buf;
|
||||
while (*val && !IsWhite(*val)) val++; /* point past end of name */
|
||||
if (*val) {
|
||||
*val++ = EOS; /* terminate name */
|
||||
while (*val && IsWhite(*val)) val++; /* point to value */
|
||||
}
|
||||
if (name) {
|
||||
CharMap[nCharMap].name = strdup(name);
|
||||
if (val) CharMap[nCharMap].sval = strdup(val);
|
||||
if (CharMap[nCharMap].name[0] == '\\') CharMap[nCharMap].name++;
|
||||
nCharMap++;
|
||||
}
|
||||
}
|
||||
fclose(fp);
|
||||
}
|
||||
|
||||
/* ______________________________________________________________________ */
|
||||
/* Read SDATA mapping file, remembering the mappings in memory.
|
||||
* Input file format is 2 columns, name and value, separated by one or
|
||||
* more tabs (not spaces).
|
||||
* This can be called multuple times, reading several files.
|
||||
* Arguments:
|
||||
* Name of SDATA entity mapping file.
|
||||
*/
|
||||
|
||||
void
|
||||
ReadSDATA(
|
||||
char *filename
|
||||
)
|
||||
{
|
||||
FILE *fp;
|
||||
char buf[LINESIZE], *name, *val;
|
||||
int lineno=0;
|
||||
|
||||
if ((fp=OpenFile(filename)) == NULL) {
|
||||
fprintf(stderr, "Can not open SDATA file '%s': %s", filename,
|
||||
strerror(errno));
|
||||
return;
|
||||
}
|
||||
|
||||
if (!SDATAmap) SDATAmap = NewMap(IMS_sdata);
|
||||
|
||||
while (fgets(buf, LINESIZE, fp))
|
||||
{
|
||||
lineno++;
|
||||
/* skip comment and blank lines */
|
||||
if (buf[0] == '#' || buf[0] == NL) continue;
|
||||
stripNL(buf);
|
||||
|
||||
name = val = buf;
|
||||
while (*val && *val != TAB) val++; /* point past end of name */
|
||||
if (*val) {
|
||||
*val++ = EOS; /* terminate name */
|
||||
while (*val && *val == TAB) val++; /* point to value */
|
||||
}
|
||||
|
||||
SetMappingNV(SDATAmap, name, val);
|
||||
}
|
||||
fclose(fp);
|
||||
}
|
||||
|
||||
/* ______________________________________________________________________ */
|
||||
@@ -1,960 +0,0 @@
|
||||
/*
|
||||
* CDE - Common Desktop Environment
|
||||
*
|
||||
* Copyright (c) 1993-2012, The Open Group. All rights reserved.
|
||||
*
|
||||
* These libraries and programs are free software; you can
|
||||
* redistribute them and/or modify them under the terms of the GNU
|
||||
* Lesser General Public License as published by the Free Software
|
||||
* Foundation; either version 2 of the License, or (at your option)
|
||||
* any later version.
|
||||
*
|
||||
* These libraries and programs are distributed in the hope that
|
||||
* they 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 these libraries and programs; if not, write
|
||||
* to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
|
||||
* Floor, Boston, MA 02110-1301 USA
|
||||
*/
|
||||
/* $XConsortium: translate.c /main/2 1996/12/07 13:15:42 rws $ */
|
||||
/*
|
||||
* Copyright 1993 Open Software Foundation, Inc., Cambridge, Massachusetts.
|
||||
* All rights reserved.
|
||||
*/
|
||||
/*
|
||||
* Copyright (c) 1994
|
||||
* Open Software Foundation, Inc.
|
||||
*
|
||||
* Permission is hereby granted to use, copy, modify and freely distribute
|
||||
* the software in this file and its documentation for any purpose without
|
||||
* fee, provided that the above copyright notice appears in all copies and
|
||||
* that both the copyright notice and this permission notice appear in
|
||||
* supporting documentation. Further, provided that the name of Open
|
||||
* Software Foundation, Inc. ("OSF") not be used in advertising or
|
||||
* publicity pertaining to distribution of the software without prior
|
||||
* written permission from OSF. OSF makes no representations about the
|
||||
* suitability of this software for any purpose. It is provided "as is"
|
||||
* without express or implied warranty.
|
||||
*/
|
||||
/*
|
||||
* Copyright (c) 1996 X Consortium
|
||||
* Copyright (c) 1995, 1996 Dalrymple Consulting
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to deal
|
||||
* in the Software without restriction, including without limitation the rights
|
||||
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
* copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* X CONSORTIUM OR DALRYMPLE CONSULTING BE LIABLE FOR ANY CLAIM, DAMAGES OR
|
||||
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
||||
* OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* Except as contained in this notice, the names of the X Consortium and
|
||||
* Dalrymple Consulting shall not be used in advertising or otherwise to
|
||||
* promote the sale, use or other dealings in this Software without prior
|
||||
* written authorization.
|
||||
*/
|
||||
/* ________________________________________________________________________
|
||||
*
|
||||
* Program to manipulate SGML instances.
|
||||
*
|
||||
* This module is for "translating" an instance to another form, usually
|
||||
* suitable for a formatting application.
|
||||
*
|
||||
* Entry points for this module:
|
||||
* DoTranslate(elem, transfile, mapfile, fp)
|
||||
* ________________________________________________________________________
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <ctype.h>
|
||||
#include <string.h>
|
||||
#include <memory.h>
|
||||
#include <sys/types.h>
|
||||
#include <errno.h>
|
||||
|
||||
#include <tptregexp.h>
|
||||
#include "general.h"
|
||||
#define STORAGE
|
||||
#include "translate.h"
|
||||
|
||||
static Trans_t NullTrans; /* an empty one */
|
||||
|
||||
/* forward references */
|
||||
void ProcesOutputSpec(char *, Element_t *, FILE *, int);
|
||||
static void WasProcessed(Element_t *);
|
||||
|
||||
/* ______________________________________________________________________ */
|
||||
/* Translate the subtree starting at 'e'. Use 'transfile' for translation
|
||||
* specs. Output goes to 'fp'. This is the entry point for translating
|
||||
* an instance.
|
||||
* Assumes you've read SDATA and CharMap files (optionally).
|
||||
* Arguments:
|
||||
* Pointer to element under consideration.
|
||||
* Pointer to name of translation spec file.
|
||||
* FILE pointer to where to write output.
|
||||
*/
|
||||
|
||||
void
|
||||
DoTranslate(
|
||||
Element_t *e,
|
||||
char *transfile,
|
||||
FILE *fp
|
||||
)
|
||||
{
|
||||
Trans_t *t, *tn;
|
||||
|
||||
if (!transfile) {
|
||||
fprintf(stderr,
|
||||
"Translation spec file not specified. Skipping translation.\n");
|
||||
return;
|
||||
}
|
||||
ReadTransSpec(transfile);
|
||||
|
||||
/* Find transpec for each node. */
|
||||
DescendTree(e, PrepTranspecs, 0, 0, 0);
|
||||
|
||||
/* Stuff to do at start of processing */
|
||||
if ((t = FindTransByName("_Start"))) {
|
||||
if (t->starttext) ProcesOutputSpec(t->starttext, 0, fp, 1);
|
||||
if (t->replace) ProcesOutputSpec(t->replace, 0, fp, 1);
|
||||
if (t->message) ProcesOutputSpec(t->message, 0, stderr, 0);
|
||||
if (t->endtext) ProcesOutputSpec(t->endtext, 0, fp, 1);
|
||||
}
|
||||
|
||||
/* Translate topmost/first element. This is recursive. */
|
||||
TransElement(e, fp, NULL);
|
||||
|
||||
/* Stuff to do at end of processing */
|
||||
if ((t = FindTransByName("_End"))) {
|
||||
if (t->starttext) ProcesOutputSpec(t->starttext, 0, fp, 1);
|
||||
if (t->replace) ProcesOutputSpec(t->replace, 0, fp, 1);
|
||||
if (t->message) ProcesOutputSpec(t->message, 0, stderr, 0);
|
||||
if (t->endtext) ProcesOutputSpec(t->endtext, 0, fp, 1);
|
||||
}
|
||||
|
||||
/* Warn about unprocessed elements in this doc tree, if verbose mode. */
|
||||
if (verbose)
|
||||
DescendTree(e, WasProcessed, 0, 0, 0);
|
||||
|
||||
/* Clean up. This is not yet complete, which is no big deal (since the
|
||||
* program is normally done at this point anyway. */
|
||||
for (t=TrSpecs; t; ) {
|
||||
tn = t->next;
|
||||
/* free the contents of t here ... */
|
||||
(void)free((void* )t);
|
||||
t = tn;
|
||||
}
|
||||
TrSpecs = 0;
|
||||
}
|
||||
|
||||
/* ______________________________________________________________________ */
|
||||
/* Print warning about unprocessed elements in this doc tree (if they
|
||||
* were not explicitely ignored).
|
||||
* Arguments:
|
||||
* Pointer to element under consideration.
|
||||
*/
|
||||
static void
|
||||
WasProcessed(
|
||||
Element_t *e
|
||||
)
|
||||
{
|
||||
Trans_t *t;
|
||||
t = e->trans;
|
||||
if (!e->processed && (t && !t->ignore)) {
|
||||
fprintf(stderr, "Warning: element '%s' was not processed:\n", e->gi);
|
||||
PrintLocation(e, stderr);
|
||||
}
|
||||
}
|
||||
|
||||
/* ______________________________________________________________________ */
|
||||
/* For each element find transpec.
|
||||
* Arguments:
|
||||
* Pointer to element under consideration.
|
||||
*/
|
||||
void
|
||||
PrepTranspecs(
|
||||
Element_t *e
|
||||
)
|
||||
{
|
||||
Trans_t *t;
|
||||
t = FindTrans(e, 0);
|
||||
e->trans = t;
|
||||
}
|
||||
|
||||
/* ______________________________________________________________________ */
|
||||
/* Copy a buffer/string into another, expanding regular variables and immediate
|
||||
* variables. (Special variables are done later.)
|
||||
* Arguments:
|
||||
* Pointer to string to expand.
|
||||
* Pointer to expanded string. (return)
|
||||
* Pointer to element under consideration.
|
||||
*/
|
||||
void
|
||||
ExpandVariables(
|
||||
char *in,
|
||||
char *out,
|
||||
Element_t *e
|
||||
)
|
||||
{
|
||||
int i, j, k;
|
||||
char *ip, *vp, *op;
|
||||
char *def_val, *s, *atval, *modifier;
|
||||
char vbuf[500];
|
||||
int lev;
|
||||
|
||||
ip = in;
|
||||
op = out;
|
||||
while (*ip) {
|
||||
/* start of regular variable? */
|
||||
if (*ip == '$' && *(ip+1) == L_CURLY && *(ip+2) != '_') {
|
||||
ip++;
|
||||
ip++; /* point at variable name */
|
||||
vp = vbuf;
|
||||
/* Look for matching (closing) curly. (watch for nesting)
|
||||
* We store the variable content in a tmp buffer, so we don't
|
||||
* clobber the input buffer.
|
||||
*/
|
||||
lev = 0;
|
||||
while (*ip) {
|
||||
if (*ip == L_CURLY) lev++;
|
||||
if (*ip == R_CURLY) {
|
||||
if (lev == 0) {
|
||||
ip++;
|
||||
break;
|
||||
}
|
||||
else lev--;
|
||||
}
|
||||
*vp++ = *ip++; /* copy to variable buffer */
|
||||
}
|
||||
*vp = EOS;
|
||||
/* vbuf now contains the variable name (stuff between curlys). */
|
||||
if (lev != 0) {
|
||||
fprintf(stderr, "Botched variable use: %s\n", in);
|
||||
/* copy rest of string if we can't recover ?? */
|
||||
return;
|
||||
}
|
||||
/* Now, expand variable. */
|
||||
vp = vbuf;
|
||||
|
||||
/* Check for immediate variables -- like _special variables but
|
||||
* interpreted right now. These start with a "+" */
|
||||
|
||||
if ( *vp == '+' ) {
|
||||
|
||||
if ( ! strcmp(vp, "+content") ) {
|
||||
for ( i=0; i<e->ncont; i++ ) {
|
||||
if ( IsContData(e, i) ) {
|
||||
j = strlen(ContData(e,i));
|
||||
memcpy(op, ContData(e,i), j);
|
||||
op += j;
|
||||
} else {
|
||||
fprintf(stderr, "warning: ${+current} skipped element content\n");
|
||||
}
|
||||
}
|
||||
|
||||
} else
|
||||
|
||||
if ( ! strcmp(vp, "+caps") ) {
|
||||
for ( i=k=0; i<e->ncont; i++ ) {
|
||||
if ( IsContData(e, i) ) {
|
||||
for ( j=0; ContData(e, i)[j]; j++ )
|
||||
op[k++] = toupper(ContData(e, i)[j]);
|
||||
} else {
|
||||
fprintf(stderr, "warning: ${+caps} skipped element content\n");
|
||||
}
|
||||
}
|
||||
op[k] = 0;
|
||||
|
||||
} else {
|
||||
fprintf(stderr, "unknown immediate variable: %s\n", vp);
|
||||
}
|
||||
|
||||
} else {
|
||||
|
||||
/* See if this variable has a default [ format: ${varname def} ] */
|
||||
|
||||
def_val = vp;
|
||||
while (*def_val && *def_val != ' ') def_val++;
|
||||
if (*def_val) *def_val++ = EOS;
|
||||
else def_val = 0;
|
||||
/* def_val now points to default, if it exists, null if not. */
|
||||
|
||||
modifier = vp;
|
||||
while (*modifier && *modifier != ':') modifier++;
|
||||
if (*modifier) *modifier++ = EOS;
|
||||
else modifier = 0;
|
||||
/* modifier now points to modifier if it exists, null if not. */
|
||||
|
||||
s = 0;
|
||||
/* if attribute of current elem with this name found, use value */
|
||||
if (e && (atval = FindAttValByName(e, vp)))
|
||||
s = atval;
|
||||
else /* else try for (global) variable with this name */
|
||||
s = FindMappingVal(Variables, vp);
|
||||
|
||||
/* If we found a value, copy it to the output buffer. */
|
||||
|
||||
if (s) {
|
||||
if ( modifier && *modifier == 'l' ) {
|
||||
while (*s) {
|
||||
*op = tolower(*s);
|
||||
op++, *s++;
|
||||
}
|
||||
} else
|
||||
while (*s) *op++ = *s++;
|
||||
} else
|
||||
if (def_val) {
|
||||
while (*def_val) *op++ = *def_val++;
|
||||
}
|
||||
}
|
||||
continue;
|
||||
}
|
||||
*op++ = *ip++;
|
||||
}
|
||||
*op = EOS; /* terminate string */
|
||||
}
|
||||
|
||||
/* ______________________________________________________________________ */
|
||||
/* Process an "output" translation spec - one of StartText, EndText,
|
||||
* Replace, Message. (These are the ones that produce output.)
|
||||
* Steps done:
|
||||
* Expand attributes and regular variables in input string.
|
||||
* Pass thru string, accumulating chars to be sent to output stream.
|
||||
* If we find the start of a special variable, output what we've
|
||||
* accumulated, then find the special variable's "bounds" (ie, the
|
||||
* stuff between the curly brackets), and expand that by passing to
|
||||
* ExpandSpecialVar(). Continue until done the input string.
|
||||
* Arguments:
|
||||
* Input buffer (string) to be expanded and output.
|
||||
* Pointer to element under consideration.
|
||||
* FILE pointer to where to write output.
|
||||
* Flag saying whether to track the character position we're on
|
||||
* (passed to OutputString).
|
||||
*/
|
||||
void
|
||||
ProcesOutputSpec(
|
||||
char *ib,
|
||||
Element_t *e,
|
||||
FILE *fp,
|
||||
int track_pos
|
||||
)
|
||||
{
|
||||
char obuf[LINESIZE];
|
||||
char vbuf[LINESIZE];
|
||||
char *dest, vname[LINESIZE], *cp;
|
||||
int esc;
|
||||
|
||||
obuf[0] = EOS; /* start with empty output buffer */
|
||||
|
||||
ExpandVariables(ib, vbuf, e); /* expand regular variables */
|
||||
ib = vbuf;
|
||||
dest = obuf;
|
||||
|
||||
esc = 0;
|
||||
while (*ib) {
|
||||
/* Is esc-$ next? If so, just copy the '$'. */
|
||||
if (*ib == '\\' && ib[1] == '$') {
|
||||
ib++; /* skip esc */
|
||||
*dest++ = *ib++; /* copy $ */
|
||||
continue;
|
||||
}
|
||||
|
||||
/* If not a $, it's a regular char. Just copy it and go to next. */
|
||||
if (*ib != '$') { /* look for att/variable marker */
|
||||
*dest++ = *ib++; /* it's not. just copy character */
|
||||
continue;
|
||||
}
|
||||
|
||||
/* We have a $. What we have must be a "special variable" since
|
||||
* regular variables have already been expanded, or just a lone $. */
|
||||
|
||||
if (ib[1] != L_CURLY) { /* just a stray dollar sign (no variable) */
|
||||
*dest++ = *ib++;
|
||||
continue;
|
||||
}
|
||||
|
||||
ib++; /* point past $ */
|
||||
|
||||
/* Output what we have in buffer so far. */
|
||||
*dest = EOS; /* terminate string */
|
||||
if (obuf[0]) OutputString(obuf, fp, track_pos);
|
||||
dest = obuf; /* ready for new stuff in buffer */
|
||||
|
||||
if (!strchr(ib, R_CURLY)) {
|
||||
fprintf(stderr, "Mismatched braces in TranSpec: %s\n", ib);
|
||||
/* how do we recover from this? */
|
||||
}
|
||||
ib++;
|
||||
cp = vname;
|
||||
while (*ib && *ib != R_CURLY) *cp++ = *ib++;
|
||||
*cp = EOS; /* terminate att/var name */
|
||||
ib++; /* point past closing curly */
|
||||
/* we now have special variable name (stuff in curly {}'s) in vname */
|
||||
ExpandSpecialVar(&vname[1], e, fp, track_pos);
|
||||
}
|
||||
*dest = EOS; /* terminate string in output buffer */
|
||||
|
||||
if (obuf[0]) OutputString(obuf, fp, track_pos);
|
||||
}
|
||||
|
||||
/* ______________________________________________________________________ */
|
||||
/* Find the translation spec for the given tag.
|
||||
* Returns pointer to first spec that matches (name, depth, etc., of tag).
|
||||
* Arguments:
|
||||
* e -- Pointer to element under consideration.
|
||||
* specID -- name of specid that we're looking for
|
||||
* Return:
|
||||
* Pointer to translation spec that matches given element's context.
|
||||
*/
|
||||
|
||||
Trans_t *
|
||||
FindTrans(
|
||||
Element_t *e,
|
||||
int specID
|
||||
)
|
||||
{
|
||||
char context[LINESIZE], buf[LINESIZE], *cp, **vec, *atval;
|
||||
int i, a, match;
|
||||
Trans_t *t, *tt;
|
||||
|
||||
/* loop through all transpecs */
|
||||
for (t=TrSpecs; t; t=t->next)
|
||||
{
|
||||
/* Only one of gi or gilist will be set. */
|
||||
/* Check if elem name matches */
|
||||
if (t->gi && !StrEq(t->gi, e->gi) && !specID) continue;
|
||||
|
||||
/* test if we're looking for a specific specID and then if
|
||||
* this is it.. */
|
||||
if (specID)
|
||||
if (!t->my_id || (specID != t->my_id))
|
||||
continue;
|
||||
|
||||
/* Match one in the list of GIs? */
|
||||
if (t->gilist) {
|
||||
for (match=0,vec=t->gilist; *vec; vec++) {
|
||||
if (StrEq(*vec, e->gi)) {
|
||||
match = 1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!match) continue;
|
||||
}
|
||||
|
||||
/* Check context */
|
||||
|
||||
/* Special case of context */
|
||||
if (t->parent)
|
||||
if (!QRelation(e, t->parent, REL_Parent)) continue;
|
||||
|
||||
if (t->context) { /* no context specified -> a match */
|
||||
FindContext(e, t->depth, context);
|
||||
|
||||
/* If reg expr set, do regex compare; else just string compare. */
|
||||
if (t->context_re) {
|
||||
if (! tpt_regexec(t->context_re, context)) continue;
|
||||
}
|
||||
else {
|
||||
/* Is depth of spec deeper than element's depth? */
|
||||
if (t->depth > e->depth) continue;
|
||||
|
||||
/* See if context of element matches "context" of transpec */
|
||||
match = ( (t->context[0] == context[0]) &&
|
||||
!strcmp(t->context, context) );
|
||||
if (!match) continue;
|
||||
}
|
||||
}
|
||||
|
||||
/* Check attributes. Loop through list, comparing each. */
|
||||
if (t->nattpairs) { /* no att specified -> a match */
|
||||
for (match=1,a=0; a<t->nattpairs; a++) {
|
||||
if (!(atval = FindAttValByName(e, t->attpair[a].name))) {
|
||||
match = 0;
|
||||
break;
|
||||
}
|
||||
if (!tpt_regexec(t->attpair[a].rex, atval)) match = 0;
|
||||
}
|
||||
if (!match) continue;
|
||||
}
|
||||
|
||||
/* Check relationships: child, parent, ancestor, sib, ... */
|
||||
if (t->relations) {
|
||||
Mapping_t *r;
|
||||
match = 1;
|
||||
for (r=t->relations->maps,i=0; i<t->relations->n_used; i++) {
|
||||
if (!CheckRelation(e, r[i].name, r[i].sval, 0, 0, RA_Current)) {
|
||||
match = 0;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!match) continue;
|
||||
}
|
||||
|
||||
/* check this element's parent's attribute */
|
||||
if (t->pattrset && e->parent) {
|
||||
char *p, **tok;
|
||||
|
||||
i = 2;
|
||||
match = 1;
|
||||
tok = Split(t->pattrset, &i, S_STRDUP);
|
||||
if ( i == 2 ) {
|
||||
p = FindAttValByName(e->parent, tok[0]);
|
||||
ExpandVariables(tok[1], buf, 0);
|
||||
if ( !p || strcmp(p, buf) )
|
||||
match = 0;
|
||||
} else {
|
||||
if (!FindAttValByName(e->parent, t->pattrset))
|
||||
match = 0;
|
||||
}
|
||||
free(tok[0]);
|
||||
if (!match) continue;
|
||||
}
|
||||
|
||||
/* check this element's "birth order" */
|
||||
if (t->nth_child) {
|
||||
/* First one is called "1" by the user. Internally called "0". */
|
||||
i = t->nth_child;
|
||||
if (i > 0) { /* positive # -- count from beginning */
|
||||
if (e->my_eorder != (i-1)) continue;
|
||||
}
|
||||
else { /* negative # -- count from end */
|
||||
i = e->parent->necont - i;
|
||||
if (e->my_eorder != i) continue;
|
||||
}
|
||||
}
|
||||
|
||||
/* check that variables match */
|
||||
if (t->var_name) {
|
||||
cp = FindMappingVal(Variables, t->var_name);
|
||||
if (!cp || strcmp(cp, t->var_value)) continue;
|
||||
}
|
||||
|
||||
/* check for variable regular expression match */
|
||||
if ( t->var_RE_name ) {
|
||||
cp = FindMappingVal(Variables, t->var_RE_name);
|
||||
if (!cp || !tpt_regexec(t->var_RE_value, cp)) continue;
|
||||
}
|
||||
|
||||
/* check content */
|
||||
if (t->content) { /* no att specified -> a match */
|
||||
for (match=0,i=0; i<e->ndcont; i++) {
|
||||
if (tpt_regexec(t->content_re, e->dcont[i])) {
|
||||
match = 1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!match) continue;
|
||||
}
|
||||
|
||||
/* -------- at this point we've passed all criteria -------- */
|
||||
|
||||
/* See if we should be using another transpec's actions. */
|
||||
if (t->use_id) {
|
||||
if (t->use_id < 0) return &NullTrans; /* missing? */
|
||||
/* see if we have a pointer to that transpec */
|
||||
if (t->use_trans) return t->use_trans;
|
||||
for (tt=TrSpecs; tt; tt=tt->next) {
|
||||
if (t->use_id == tt->my_id) {
|
||||
/* remember pointer for next time */
|
||||
t->use_trans = tt;
|
||||
return t->use_trans;
|
||||
}
|
||||
}
|
||||
t->use_id = -1; /* flag it as missing */
|
||||
fprintf(stderr, "Warning: transpec ID (%d) not found for %s.\n",
|
||||
t->use_id, e->gi);
|
||||
return &NullTrans;
|
||||
}
|
||||
|
||||
return t;
|
||||
}
|
||||
|
||||
/* At this point, we have not found a matching spec. See if there
|
||||
* is a wildcard, and if so, use it. (Wildcard GI is named "*".) */
|
||||
if ((t = FindTransByName("*"))) return t;
|
||||
|
||||
if (warnings && !specID)
|
||||
fprintf(stderr, "Warning: transpec not found for %s\n", e->gi);
|
||||
|
||||
/* default spec - pass character data and descend node */
|
||||
return &NullTrans;
|
||||
}
|
||||
|
||||
/* ______________________________________________________________________ */
|
||||
/* Find translation spec by (GI) name. Returns the first one that matches.
|
||||
* Arguments:
|
||||
* Pointer to name of transpec (the "gi" field of the Trans structure).
|
||||
* Return:
|
||||
* Pointer to translation spec that matches name.
|
||||
*/
|
||||
|
||||
Trans_t *
|
||||
FindTransByName(
|
||||
char *s
|
||||
)
|
||||
{
|
||||
Trans_t *t;
|
||||
|
||||
for (t=TrSpecs; t; t=t->next) {
|
||||
/* check if tag name matches (first check 1st char, for efficiency) */
|
||||
if (t->gi) {
|
||||
if (*(t->gi) != *s) continue; /* check 1st character */
|
||||
if (!strcmp(t->gi, s)) return t;
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* Find translation spec by its ID (SpecID).
|
||||
* Arguments:
|
||||
* Spec ID (an int).
|
||||
* Return:
|
||||
* Pointer to translation spec that matches name.
|
||||
*/
|
||||
Trans_t *
|
||||
FindTranByID(int n)
|
||||
{
|
||||
Trans_t *t;
|
||||
|
||||
for (t=TrSpecs; t; t=t->next)
|
||||
if (n == t->my_id) return t;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* ______________________________________________________________________ */
|
||||
/* Process a "chunk" of content data of an element.
|
||||
* Arguments:
|
||||
* Pointer to data content to process
|
||||
* FILE pointer to where to write output.
|
||||
*/
|
||||
|
||||
void
|
||||
DoData(
|
||||
char *data,
|
||||
FILE *fp,
|
||||
int verbatim
|
||||
)
|
||||
{
|
||||
char *cp, buf[LINESIZE], *dp, *sub, prev;
|
||||
int i, mapped;
|
||||
|
||||
/* Worry about embedded newlines? */
|
||||
|
||||
if (!fp) return;
|
||||
|
||||
/* CLEANUP: this should really all be done in OutputString(). (I think) */
|
||||
|
||||
if (nCharMap) {
|
||||
/* for each character, see if it's mapped to something else */
|
||||
for (prev=0,cp=data,dp=buf; *cp; cp++) {
|
||||
if (prev == '\\') {
|
||||
*dp++ = *cp;
|
||||
prev = *cp;
|
||||
continue;
|
||||
}
|
||||
for (mapped=0,i=0; !verbatim && (i<nCharMap); i++) {
|
||||
if (*cp != CharMap[i].name[0]) continue;
|
||||
sub = CharMap[i].sval;
|
||||
while (*sub) *dp++ = *sub++;
|
||||
mapped = 1;
|
||||
break;
|
||||
}
|
||||
if ( *cp == -1 ) *cp = '^';
|
||||
if (!mapped) *dp++ = *cp;
|
||||
prev = *cp;
|
||||
}
|
||||
*dp = EOS;
|
||||
dp = buf;
|
||||
}
|
||||
else dp = data;
|
||||
OutputString(dp, fp, 1);
|
||||
}
|
||||
|
||||
/* ______________________________________________________________________ */
|
||||
/* Handle a processing instruction. This is done similarly to elements,
|
||||
* where we find a transpec, then do what it says. Differences: PI names
|
||||
* start with '_' in the spec file (if a GI does not start with '_', it
|
||||
* may be forced to upper case, sgmls keeps PIs as mixed case); the args
|
||||
* to the PI are treated as the data of an element. Note that a PI wildcard
|
||||
* is "_*"
|
||||
* Arguments:
|
||||
* Pointer to the PI.
|
||||
* FILE pointer to where to write output.
|
||||
*/
|
||||
|
||||
void
|
||||
DoPI(
|
||||
char *pi,
|
||||
FILE *fp
|
||||
)
|
||||
{
|
||||
char buf[250], **tok;
|
||||
int n;
|
||||
Trans_t *t;
|
||||
|
||||
buf[0] = '_';
|
||||
strcpy(&buf[1], pi);
|
||||
n = 2;
|
||||
tok = Split(buf, &n, 0);
|
||||
if ((t = FindTransByName(tok[0])) ||
|
||||
(t = FindTransByName("_*"))) {
|
||||
if (t->replace) ProcesOutputSpec(t->replace, 0, fp, 1);
|
||||
else {
|
||||
if (t->starttext) ProcesOutputSpec(t->starttext, 0, fp, 1);
|
||||
if (t->ignore != IGN_DATA) /* skip data nodes? */
|
||||
if (n > 1) OutputString(tok[1], fp, 1);
|
||||
if (t->endtext) ProcesOutputSpec(t->endtext, 0, fp, 1);
|
||||
}
|
||||
if (t->message) ProcesOutputSpec(t->message, 0, stderr, 0);
|
||||
}
|
||||
else {
|
||||
/* If not found, just print the PI in square brackets, along
|
||||
* with a warning message. */
|
||||
fprintf(fp, "[%s]", pi);
|
||||
if (warnings) fprintf(stderr, "Warning: Unrecognized PI: [%s]\n", pi);
|
||||
}
|
||||
}
|
||||
|
||||
/* ______________________________________________________________________ */
|
||||
/* Set and increment variables, as appropriate, if the transpec says to.
|
||||
* Arguments:
|
||||
* Pointer to translation spec for current element.
|
||||
*/
|
||||
|
||||
static void
|
||||
set_and_increment(
|
||||
Trans_t *t,
|
||||
Element_t *e
|
||||
)
|
||||
{
|
||||
Mapping_t *m;
|
||||
int i, inc, n;
|
||||
char *cp, buf[50];
|
||||
char ebuf[500];
|
||||
|
||||
/* set/reset variables */
|
||||
if (t->set_var) {
|
||||
for (m=t->set_var->maps,i=0; i<t->set_var->n_used; i++) {
|
||||
ExpandVariables(m[i].sval, ebuf, e); /* do some expansion */
|
||||
SetMappingNV(Variables, m[i].name, ebuf);
|
||||
}
|
||||
}
|
||||
|
||||
/* increment counters */
|
||||
if (t->incr_var) {
|
||||
for (m=t->incr_var->maps,i=0; i<t->incr_var->n_used; i++) {
|
||||
cp = FindMappingVal(Variables, m[i].name);
|
||||
/* if not set at all, set to 1 */
|
||||
if (!cp) SetMappingNV(Variables, m[i].name, "1");
|
||||
else {
|
||||
if (isdigit(*cp) || (*cp == '-' && isdigit(cp[1]))) {
|
||||
n = atoi(cp);
|
||||
if (m[i].sval && isdigit(*m[i].sval)) inc = atoi(m[i].sval);
|
||||
else inc = 1;
|
||||
sprintf(buf, "%d", (n + inc));
|
||||
SetMappingNV(Variables, m[i].name, buf);
|
||||
} else
|
||||
if (!*(cp+1) && isalpha(*cp)) {
|
||||
buf[0] = *cp + 1;
|
||||
buf[1] = 0;
|
||||
SetMappingNV(Variables, m[i].name, buf);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* ______________________________________________________________________ */
|
||||
/* Translate one element.
|
||||
* Arguments:
|
||||
* Pointer to element under consideration.
|
||||
* FILE pointer to where to write output.
|
||||
* Pointer to translation spec for current element, or null.
|
||||
*/
|
||||
void
|
||||
TransElement(
|
||||
Element_t *e,
|
||||
FILE *fp,
|
||||
Trans_t *t
|
||||
)
|
||||
{
|
||||
int i;
|
||||
|
||||
if (!t) t = ((e && e->trans) ? e->trans : &NullTrans);
|
||||
|
||||
/* see if we should quit. */
|
||||
if (t->quit) {
|
||||
fprintf(stderr, "Quitting at location:\n");
|
||||
PrintLocation(e, fp);
|
||||
fprintf(stderr, "%s\n", t->quit);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
/* See if we want to replace subtree (do text, don't descend subtree) */
|
||||
if (t->replace) {
|
||||
ProcesOutputSpec(t->replace, e, fp, 1);
|
||||
if (t->message) ProcesOutputSpec(t->message, e, stderr, 0);
|
||||
set_and_increment(t, e); /* adjust variables, if appropriate */
|
||||
return;
|
||||
}
|
||||
|
||||
if (t->starttext) ProcesOutputSpec(t->starttext, e, fp, 1);
|
||||
if (t->message) ProcesOutputSpec(t->message, e, stderr, 0);
|
||||
|
||||
/* Process data for this node and descend child elements/nodes. */
|
||||
if (t->ignore != IGN_ALL) {
|
||||
/* Is there a "generated" node at the front of this one? */
|
||||
if (e->gen_trans[0]) {
|
||||
Trans_t *tp;
|
||||
if ((tp = FindTranByID(e->gen_trans[0]))) {
|
||||
if (tp->starttext) ProcesOutputSpec(tp->starttext, e, fp, 1);
|
||||
if (tp->message) ProcesOutputSpec(tp->message, e, stderr, 0);
|
||||
if (tp->endtext) ProcesOutputSpec(tp->endtext, e, fp, 1);
|
||||
}
|
||||
}
|
||||
/* Loop thruthe "nodes", whether data, child element, or PI. */
|
||||
for (i=0; i<e->ncont; i++) {
|
||||
if (IsContElem(e,i)) {
|
||||
if (t->ignore != IGN_CHILDREN) /* skip child nodes? */
|
||||
TransElement(ContElem(e,i), fp, NULL);
|
||||
}
|
||||
else if (IsContData(e,i)) {
|
||||
if (t->ignore != IGN_DATA) /* skip data nodes? */
|
||||
DoData(ContData(e,i), fp, t->verbatim);
|
||||
}
|
||||
else if (IsContPI(e,i))
|
||||
DoPI(e->cont[i].ch.data, fp);
|
||||
}
|
||||
/* Is there a "generated" node at the end of this one? */
|
||||
if (e->gen_trans[1]) {
|
||||
Trans_t *tp;
|
||||
if ((tp = FindTranByID(e->gen_trans[1]))) {
|
||||
if (tp->starttext) ProcesOutputSpec(tp->starttext, e, fp, 1);
|
||||
if (tp->message) ProcesOutputSpec(tp->message, e, stderr, 0);
|
||||
if (tp->endtext) ProcesOutputSpec(tp->endtext, e, fp, 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
set_and_increment(t, e); /* adjust variables, if appropriate */
|
||||
|
||||
if (t->endtext) ProcesOutputSpec(t->endtext, e, fp, 1);
|
||||
|
||||
e->processed = 1;
|
||||
}
|
||||
|
||||
/* ______________________________________________________________________ */
|
||||
/* Check if element matches specified relationship, and, if it does, perform
|
||||
* action on either current element or matching element (depends on flag).
|
||||
* Arguments:
|
||||
* Pointer to element under consideration.
|
||||
* Pointer to relationship name.
|
||||
* Pointer to related element name (GI).
|
||||
* Pointer to action to take (string - turned into an int).
|
||||
* FILE pointer to where to write output.
|
||||
* Flag saying whether to do action on related element (RA_Related)
|
||||
* or on current element (RA_Current).
|
||||
* Return:
|
||||
* Bool, saying whether (1) or not (0) relationship matches.
|
||||
*/
|
||||
|
||||
int
|
||||
CheckRelation(
|
||||
Element_t *e,
|
||||
char *relname, /* relationship name */
|
||||
char *related, /* related element */
|
||||
char *actname, /* action to take */
|
||||
FILE *fp,
|
||||
RelAction_t flag
|
||||
)
|
||||
{
|
||||
Element_t *ep;
|
||||
Relation_t r;
|
||||
|
||||
if ((r = FindRelByName(relname)) == REL_Unknown) return 0;
|
||||
if (!(ep=QRelation(e, related, r))) return 0;
|
||||
|
||||
if (!actname) return 1; /* no action - return what we found */
|
||||
|
||||
switch (flag) {
|
||||
case RA_Related: TranTByAction(ep, actname, fp); break;
|
||||
case RA_Current: TranTByAction(e, actname, fp); break;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* ______________________________________________________________________ */
|
||||
/* Perform action given by a SpecID on the given element.
|
||||
* Arguments:
|
||||
* Pointer to element under consideration.
|
||||
* SpecID of action to perform.
|
||||
* FILE pointer to where to write output.
|
||||
*
|
||||
*/
|
||||
void
|
||||
TranByAction(
|
||||
Element_t *e,
|
||||
int n,
|
||||
FILE *fp
|
||||
)
|
||||
{
|
||||
Trans_t *t;
|
||||
|
||||
t = FindTranByID(n);
|
||||
if (!t) {
|
||||
fprintf(stderr, "Could not find named action for %d.\n", n);
|
||||
return;
|
||||
}
|
||||
TransElement(e, fp, t);
|
||||
}
|
||||
|
||||
/* ______________________________________________________________________ */
|
||||
/* Perhaps perform action given by a SpecID on the given element.
|
||||
* Arguments:
|
||||
* Pointer to element under consideration.
|
||||
* SpecID of action to perform. Unlike TranByAction, this is the argument
|
||||
* as it occurred in the transpec (ASCII) and may end with the letter
|
||||
* "t" which means that the transpec mustpass criteria selection.
|
||||
* FILE pointer to where to write output.
|
||||
*/
|
||||
void
|
||||
TranTByAction(
|
||||
Element_t *e,
|
||||
char *strn,
|
||||
FILE *fp
|
||||
)
|
||||
{
|
||||
int n;
|
||||
Trans_t *t;
|
||||
|
||||
n = atoi(strn);
|
||||
if ( strn[strlen(strn)-1] != 't' ) {
|
||||
t = FindTranByID(n);
|
||||
if (!t) {
|
||||
fprintf(stderr, "Could not find named action for %d.\n", n);
|
||||
return;
|
||||
}
|
||||
} else {
|
||||
t = FindTrans(e, n);
|
||||
if ( !t || !t->my_id )
|
||||
return;
|
||||
}
|
||||
TransElement(e, fp, t);
|
||||
}
|
||||
|
||||
/* ______________________________________________________________________ */
|
||||
@@ -1,169 +0,0 @@
|
||||
/*
|
||||
* CDE - Common Desktop Environment
|
||||
*
|
||||
* Copyright (c) 1993-2012, The Open Group. All rights reserved.
|
||||
*
|
||||
* These libraries and programs are free software; you can
|
||||
* redistribute them and/or modify them under the terms of the GNU
|
||||
* Lesser General Public License as published by the Free Software
|
||||
* Foundation; either version 2 of the License, or (at your option)
|
||||
* any later version.
|
||||
*
|
||||
* These libraries and programs are distributed in the hope that
|
||||
* they 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 these libraries and programs; if not, write
|
||||
* to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
|
||||
* Floor, Boston, MA 02110-1301 USA
|
||||
*/
|
||||
/* $XConsortium: translate.h /main/1 1996/07/23 19:44:35 rws $ */
|
||||
/*
|
||||
* Copyright 1993 Open Software Foundation, Inc., Cambridge, Massachusetts.
|
||||
* All rights reserved.
|
||||
*/
|
||||
/*
|
||||
* Copyright (c) 1994
|
||||
* Open Software Foundation, Inc.
|
||||
*
|
||||
* Permission is hereby granted to use, copy, modify and freely distribute
|
||||
* the software in this file and its documentation for any purpose without
|
||||
* fee, provided that the above copyright notice appears in all copies and
|
||||
* that both the copyright notice and this permission notice appear in
|
||||
* supporting documentation. Further, provided that the name of Open
|
||||
* Software Foundation, Inc. ("OSF") not be used in advertising or
|
||||
* publicity pertaining to distribution of the software without prior
|
||||
* written permission from OSF. OSF makes no representations about the
|
||||
* suitability of this software for any purpose. It is provided "as is"
|
||||
* without express or implied warranty.
|
||||
*/
|
||||
/*
|
||||
* Copyright (c) 1996 X Consortium
|
||||
* Copyright (c) 1995, 1996 Dalrymple Consulting
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to deal
|
||||
* in the Software without restriction, including without limitation the rights
|
||||
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
* copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* X CONSORTIUM OR DALRYMPLE CONSULTING BE LIABLE FOR ANY CLAIM, DAMAGES OR
|
||||
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
||||
* OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* Except as contained in this notice, the names of the X Consortium and
|
||||
* Dalrymple Consulting shall not be used in advertising or otherwise to
|
||||
* promote the sale, use or other dealings in this Software without prior
|
||||
* written authorization.
|
||||
*/
|
||||
/* ________________________________________________________________________
|
||||
*
|
||||
* Program to manipulate SGML instances.
|
||||
*
|
||||
* These are data definitions for the "translating" portion of the program.
|
||||
*
|
||||
* ________________________________________________________________________
|
||||
*/
|
||||
|
||||
#define L_CURLY '{'
|
||||
#define R_CURLY '}'
|
||||
|
||||
/* things to ignore when processing an element */
|
||||
#define IGN_NONE 0
|
||||
#define IGN_ALL 1
|
||||
#define IGN_DATA 2
|
||||
#define IGN_CHILDREN 3
|
||||
|
||||
/* for CheckRelation() */
|
||||
typedef enum { RA_Current, RA_Related } RelAction_t;
|
||||
|
||||
typedef struct {
|
||||
char *name; /* attribute name string */
|
||||
char *val; /* attribute value string */
|
||||
regexp *rex; /* attribute value reg expr (compiled) */
|
||||
} AttPair_t;
|
||||
|
||||
typedef struct _Trans {
|
||||
/* criteria */
|
||||
char *gi; /* element name of tag under consideration */
|
||||
char **gilist; /* list of element names (multiple gi's) */
|
||||
char *context; /* context in tree - looking depth levels up */
|
||||
regexp *context_re; /* tree hierarchy looking depth levels up */
|
||||
int depth; /* number of levels to look up the tree */
|
||||
AttPair_t *attpair; /* attr name-value pairs */
|
||||
int nattpairs; /* number of name-value pairs */
|
||||
char *parent; /* GI has this element as parent */
|
||||
int nth_child; /* GI is Nth child of this of parent element */
|
||||
char *content; /* element has this string in content */
|
||||
regexp *content_re; /* content reg expr (compiled) */
|
||||
char *pattrset; /* is this attr set (any value) in parent? */
|
||||
char *var_name; /* variable name */
|
||||
char *var_value; /* variable value */
|
||||
char *var_RE_name; /* variable name (for VarREValue) */
|
||||
regexp *var_RE_value; /* variable value (compiled, for VarREValue) */
|
||||
Map_t *relations; /* various relations to check */
|
||||
|
||||
/* actions */
|
||||
char *starttext; /* string to output at the start tag */
|
||||
char *endtext; /* string to output at the end tag */
|
||||
char *replace; /* string to replace this subtree with */
|
||||
char *message; /* message for stderr, if element encountered */
|
||||
int ignore; /* flag - ignore content or data of element? */
|
||||
int verbatim; /* flag - pass content verbatim or do cmap? */
|
||||
char *var_reset;
|
||||
char *increment; /* increment these variables */
|
||||
Map_t *set_var; /* set these variables */
|
||||
Map_t *incr_var; /* increment these variables */
|
||||
char *quit; /* print message and exit */
|
||||
|
||||
/* pointers and bookkeeping */
|
||||
int my_id; /* unique (hopefully) ID of this transpec */
|
||||
int use_id; /* use transpec whose ID is this */
|
||||
struct _Trans *use_trans; /* pointer to other transpec */
|
||||
struct _Trans *next; /* linked list */
|
||||
int lineno; /* line number of end of transpec */
|
||||
} Trans_t;
|
||||
|
||||
#ifdef def
|
||||
#undef def
|
||||
#endif
|
||||
#ifdef STORAGE
|
||||
# define def
|
||||
#else
|
||||
# define def extern
|
||||
#endif
|
||||
|
||||
def Trans_t *TrSpecs;
|
||||
def Mapping_t *CharMap;
|
||||
def int nCharMap;
|
||||
|
||||
/* prototypes for things defined in translate.c */
|
||||
int CheckRelation(Element_t *, char *, char *, char *, FILE*, RelAction_t);
|
||||
Trans_t *FindTrans(Element_t *, int);
|
||||
Trans_t *FindTransByName(char *);
|
||||
Trans_t *FindTransByID(int);
|
||||
void PrepTranspecs(Element_t *);
|
||||
void ProcessOneSpec(char *, Element_t *, FILE *, int);
|
||||
void TransElement(Element_t *, FILE *, Trans_t *);
|
||||
void TranByAction(Element_t *, int, FILE *);
|
||||
void TranTByAction(Element_t *, char *, FILE *);
|
||||
|
||||
/* prototypes for things defined in tranvar.c */
|
||||
void ExpandSpecialVar(char *, Element_t *, FILE *, int);
|
||||
|
||||
/* prototypes for things defined in tables.c */
|
||||
void OSFtable(Element_t *, FILE *, char **, int);
|
||||
|
||||
/* ______________________________________________________________________ */
|
||||
|
||||
@@ -1,779 +0,0 @@
|
||||
/*
|
||||
* CDE - Common Desktop Environment
|
||||
*
|
||||
* Copyright (c) 1993-2012, The Open Group. All rights reserved.
|
||||
*
|
||||
* These libraries and programs are free software; you can
|
||||
* redistribute them and/or modify them under the terms of the GNU
|
||||
* Lesser General Public License as published by the Free Software
|
||||
* Foundation; either version 2 of the License, or (at your option)
|
||||
* any later version.
|
||||
*
|
||||
* These libraries and programs are distributed in the hope that
|
||||
* they 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 these libraries and programs; if not, write
|
||||
* to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
|
||||
* Floor, Boston, MA 02110-1301 USA
|
||||
*/
|
||||
/* $XConsortium: tranvar.c /main/2 1996/12/07 13:15:57 rws $ */
|
||||
/*
|
||||
* Copyright 1993 Open Software Foundation, Inc., Cambridge, Massachusetts.
|
||||
* All rights reserved.
|
||||
*/
|
||||
/*
|
||||
* Copyright (c) 1994
|
||||
* Open Software Foundation, Inc.
|
||||
*
|
||||
* Permission is hereby granted to use, copy, modify and freely distribute
|
||||
* the software in this file and its documentation for any purpose without
|
||||
* fee, provided that the above copyright notice appears in all copies and
|
||||
* that both the copyright notice and this permission notice appear in
|
||||
* supporting documentation. Further, provided that the name of Open
|
||||
* Software Foundation, Inc. ("OSF") not be used in advertising or
|
||||
* publicity pertaining to distribution of the software without prior
|
||||
* written permission from OSF. OSF makes no representations about the
|
||||
* suitability of this software for any purpose. It is provided "as is"
|
||||
* without express or implied warranty.
|
||||
*/
|
||||
/*
|
||||
* Copyright (c) 1996 X Consortium
|
||||
* Copyright (c) 1995, 1996 Dalrymple Consulting
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to deal
|
||||
* in the Software without restriction, including without limitation the rights
|
||||
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
* copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* X CONSORTIUM OR DALRYMPLE CONSULTING BE LIABLE FOR ANY CLAIM, DAMAGES OR
|
||||
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
||||
* OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* Except as contained in this notice, the names of the X Consortium and
|
||||
* Dalrymple Consulting shall not be used in advertising or otherwise to
|
||||
* promote the sale, use or other dealings in this Software without prior
|
||||
* written authorization.
|
||||
*/
|
||||
/* ________________________________________________________________________
|
||||
*
|
||||
* instant - a program to manipulate SGML instances.
|
||||
*
|
||||
* This module is for handling "special variables". These act a lot like
|
||||
* procedure calls
|
||||
* ________________________________________________________________________
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <ctype.h>
|
||||
#include <string.h>
|
||||
#include <memory.h>
|
||||
#include <sys/types.h>
|
||||
#include <errno.h>
|
||||
|
||||
#include <tptregexp.h>
|
||||
#include "general.h"
|
||||
#include "translate.h"
|
||||
|
||||
static char **idrefs; /* list of IDREF att names to follow */
|
||||
static char *def_idrefs[] = { "LINKEND", "LINKENDS", "IDREF", 0 };
|
||||
static char *each_A = 0; /* last seen _eachatt */
|
||||
static char *each_C = 0; /* last seen _eachcon */
|
||||
|
||||
/* forward references */
|
||||
void ChaseIDRefs(Element_t *, char *, char *, FILE *);
|
||||
void Find(Element_t *, int, char **, FILE *);
|
||||
void GetIDREFnames();
|
||||
void ExpandVariables(char *in, char *out, Element_t *e);
|
||||
void CALStable(Element_t *e, FILE *fp, char **av, int ac);
|
||||
|
||||
|
||||
/* ______________________________________________________________________ */
|
||||
/* Handle "special" variable - read file, run command, do action, etc.
|
||||
* Arguments:
|
||||
* Name of special variable to expand.
|
||||
* Pointer to element under consideration.
|
||||
* FILE pointer to where to write output.
|
||||
* Flag saying whether to track the character position we're on
|
||||
* (passed to OutputString).
|
||||
*/
|
||||
|
||||
void
|
||||
ExpandSpecialVar(
|
||||
char *name,
|
||||
Element_t *e,
|
||||
FILE *fp,
|
||||
int track_pos
|
||||
)
|
||||
{
|
||||
FILE *infile;
|
||||
char buf[LINESIZE], *cp, *cp2, *atval;
|
||||
char **tok;
|
||||
int ntok, n, i, actioni;
|
||||
char *action, *action1;
|
||||
Element_t *ep;
|
||||
Trans_t *t, *tt;
|
||||
|
||||
/* Run a command.
|
||||
* Format: _! command args ... */
|
||||
if (*name == '!') {
|
||||
name++;
|
||||
if ((infile = popen(name, "r"))) {
|
||||
while (fgets(buf, LINESIZE, infile)) fputs(buf, fp);
|
||||
pclose(infile);
|
||||
fflush(fp);
|
||||
}
|
||||
else {
|
||||
fprintf(stderr, "Could not start program '%s': %s",
|
||||
name, strerror(errno));
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
/* See if caller wants one of the tokens from _eachatt or _eachcon.
|
||||
* If so, output it and return. (Yes, I admit that this is a hack.)
|
||||
*/
|
||||
if (*name == 'A' && name[1] == EOS && each_A) {
|
||||
OutputString(each_A, fp, track_pos);
|
||||
return;
|
||||
}
|
||||
if (*name == 'C' && name[1] == EOS && each_C) {
|
||||
OutputString(each_C, fp, track_pos);
|
||||
return;
|
||||
}
|
||||
|
||||
ntok = 0;
|
||||
tok = Split(name, &ntok, 0);
|
||||
|
||||
/* Include another file.
|
||||
* Format: _include filename */
|
||||
if (StrEq(tok[0], "include")) {
|
||||
name = tok[1];
|
||||
if (ntok > 1 ) {
|
||||
if ((infile=OpenFile(name)) == NULL) {
|
||||
sprintf(buf, "Can not open included file '%s'", name);
|
||||
perror(buf);
|
||||
return;
|
||||
}
|
||||
while (fgets(buf, LINESIZE, infile)) fputs(buf, fp);
|
||||
fclose(infile);
|
||||
}
|
||||
else fprintf(stderr, "No file name specified for include\n");
|
||||
return;
|
||||
}
|
||||
|
||||
/* Print location (nearest title, line no, path).
|
||||
* Format: _location */
|
||||
else if (StrEq(tok[0], "location")) {
|
||||
PrintLocation(e, fp);
|
||||
}
|
||||
|
||||
/* Print path to this element.
|
||||
* Format: _path */
|
||||
else if (StrEq(tok[0], "path")) {
|
||||
(void)FindElementPath(e, buf);
|
||||
OutputString(buf, fp, track_pos);
|
||||
}
|
||||
|
||||
/* Print name of this element (gi).
|
||||
* Format: _gi [M|L|U] */
|
||||
else if (StrEq(tok[0], "gi")) {
|
||||
strcpy(buf, e->gi);
|
||||
if (ntok >= 2) {
|
||||
if (*tok[1] == 'L' || *tok[1] == 'l' ||
|
||||
*tok[1] == 'M' || *tok[1] == 'm') {
|
||||
for (cp=buf; *cp; cp++)
|
||||
if (isupper(*cp)) *cp = tolower(*cp);
|
||||
}
|
||||
if (*tok[1] == 'M' || *tok[1] == 'm')
|
||||
if (islower(buf[0])) buf[0] = toupper(buf[0]);
|
||||
}
|
||||
OutputString(buf, fp, track_pos);
|
||||
}
|
||||
|
||||
/* Print filename of this element's associated external entity.
|
||||
* Format: _filename */
|
||||
else if (StrEq(tok[0], "filename")) {
|
||||
if (!e->entity) {
|
||||
fprintf(stderr, "Expected ext entity (internal error? bug?):\n");
|
||||
PrintLocation(e, stderr);
|
||||
return;
|
||||
}
|
||||
if (!e->entity->fname) {
|
||||
fprintf(stderr, "Expected filename (internal error? bug?):\n");
|
||||
PrintLocation(e, stderr);
|
||||
return;
|
||||
}
|
||||
OutputString(e->entity->fname, fp, track_pos);
|
||||
}
|
||||
|
||||
/* Value of parent's attribute, by attr name.
|
||||
* Format: _pattr attname */
|
||||
else if (StrEq(tok[0], "pattr")) {
|
||||
ep = e->parent;
|
||||
if (!ep) {
|
||||
fprintf(stderr, "Element does not have a parent:\n");
|
||||
PrintLocation(ep, stderr);
|
||||
return;
|
||||
}
|
||||
if ((atval = FindAttValByName(ep, tok[1]))) {
|
||||
OutputString(atval, fp, track_pos);
|
||||
}
|
||||
}
|
||||
|
||||
/* Use an action, given transpec's SID.
|
||||
* Format: _action action */
|
||||
else if (StrEq(tok[0], "action")) {
|
||||
TranTByAction(e, tok[1], fp);
|
||||
}
|
||||
|
||||
/* Number of child elements of this element.
|
||||
* Format: _nchild */
|
||||
else if (StrEq(tok[0], "nchild")) {
|
||||
if (ntok > 1) {
|
||||
for (n=0,i=0; i<e->necont; i++)
|
||||
if (StrEq(e->econt[i]->gi, tok[1])) n++;
|
||||
}
|
||||
else n = e->necont;
|
||||
sprintf(buf, "%d", n);
|
||||
OutputString(buf, fp, track_pos);
|
||||
}
|
||||
|
||||
/* number of 1st child's child elements (grandchildren from first child).
|
||||
* Format: _n1gchild */
|
||||
else if (StrEq(tok[0], "n1gchild")) {
|
||||
if (e->necont) {
|
||||
sprintf(buf, "%d", e->econt[0]->necont);
|
||||
OutputString(buf, fp, track_pos);
|
||||
}
|
||||
}
|
||||
|
||||
/* Chase this element's pointers until we hit the named GI.
|
||||
* Do the action if it matches.
|
||||
* Format: _chasetogi gi action */
|
||||
else if (StrEq(tok[0], "chasetogi")) {
|
||||
if (ntok < 3) {
|
||||
fprintf(stderr, "Error: Not enough args for _chasetogi.\n");
|
||||
return;
|
||||
}
|
||||
actioni = atoi(tok[2]);
|
||||
if (actioni) ChaseIDRefs(e, tok[1], tok[2], fp);
|
||||
}
|
||||
|
||||
/* Follow link to element pointed to, then do action.
|
||||
* Format: _followlink [attname] action. */
|
||||
else if (StrEq(tok[0], "followlink")) {
|
||||
char **s;
|
||||
if (ntok > 2) {
|
||||
if ((atval = FindAttValByName(e, tok[1]))) {
|
||||
if ((ep = FindElemByID(atval))) {
|
||||
TranTByAction(ep, tok[2], fp);
|
||||
return;
|
||||
}
|
||||
}
|
||||
else fprintf(stderr, "Error: Did not find attr: %s.\n", tok[1]);
|
||||
return;
|
||||
}
|
||||
GetIDREFnames();
|
||||
for (s=idrefs; *s; s++) {
|
||||
/* is this IDREF attr set? */
|
||||
if ((atval = FindAttValByName(e, *s))) {
|
||||
ntok = 0;
|
||||
tok = Split(atval, &ntok, S_STRDUP);
|
||||
/* we'll follow the first one... */
|
||||
if ((ep = FindElemByID(tok[0]))) {
|
||||
TranTByAction(ep, tok[1], fp);
|
||||
return;
|
||||
}
|
||||
else fprintf(stderr, "Error: Can not find elem for ID: %s.\n",
|
||||
tok[0]);
|
||||
}
|
||||
}
|
||||
fprintf(stderr, "Error: Element does not have IDREF attribute set:\n");
|
||||
PrintLocation(e, stderr);
|
||||
return;
|
||||
}
|
||||
|
||||
/* Starting at this element, decend tree (in-order), finding GI.
|
||||
* Do the action if it matches.
|
||||
* Format: _find args ... */
|
||||
else if (StrEq(tok[0], "find")) {
|
||||
Find(e, ntok, tok, fp);
|
||||
}
|
||||
|
||||
/* Starting at this element's parent, decend tree (in-order), finding GI.
|
||||
* Do the action if it matches.
|
||||
* Format: _pfind args ... */
|
||||
else if (StrEq(tok[0], "pfind")) {
|
||||
Find(e->parent ? e->parent : e, ntok, tok, fp);
|
||||
}
|
||||
|
||||
/* Content is supposed to be a list of IDREFs. Follow each, doing action.
|
||||
* If 2 actions are specified, use 1st for the 1st ID, 2nd for the rest.
|
||||
* Format: _namelist action [action2] */
|
||||
else if (StrEq(tok[0], "namelist")) {
|
||||
int id;
|
||||
action1 = tok[1];
|
||||
if (ntok > 2) action = tok[2];
|
||||
else action = action1;
|
||||
for (i=0; i<e->ndcont; i++) {
|
||||
n = 0;
|
||||
tok = Split(e->dcont[i], &n, S_STRDUP);
|
||||
for (id=0; id<n; id++) {
|
||||
if (fold_case)
|
||||
for (cp=tok[id]; *cp; cp++)
|
||||
if (islower(*cp)) *cp = toupper(*cp);
|
||||
if ((e = FindElemByID(tok[id]))) {
|
||||
if (id) TranTByAction(e, action, fp);
|
||||
else TranTByAction(e, action1, fp); /* first one */
|
||||
}
|
||||
else fprintf(stderr, "Error: Can not find ID: %s.\n", tok[id]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* For each word in the element's content, do action.
|
||||
* Format: _eachcon action [action] */
|
||||
else if (StrEq(tok[0], "eachcon")) {
|
||||
int id;
|
||||
action1 = tok[1];
|
||||
if (ntok > 3) action = tok[2];
|
||||
else action = action1;
|
||||
for (i=0; i<e->ndcont; i++) {
|
||||
n = 0;
|
||||
tok = Split(e->dcont[i], &n, S_STRDUP|S_ALVEC);
|
||||
for (id=0; id<n; id++) {
|
||||
each_C = tok[id];
|
||||
TranTByAction(e, action, fp);
|
||||
}
|
||||
free(*tok);
|
||||
}
|
||||
}
|
||||
/* For each word in the given attribute's value, do action.
|
||||
* Format: _eachatt attname action [action] */
|
||||
else if (StrEq(tok[0], "eachatt")) {
|
||||
int id;
|
||||
action1 = tok[2];
|
||||
if (ntok > 3) action = tok[3];
|
||||
else action = action1;
|
||||
if ((atval = FindAttValByName(e, tok[1]))) {
|
||||
n = 0;
|
||||
tok = Split(atval, &n, S_STRDUP|S_ALVEC);
|
||||
for (id=0; id<n; id++) {
|
||||
each_A = tok[id];
|
||||
if (id) TranTByAction(e, action, fp);
|
||||
else TranTByAction(e, action1, fp); /* first one */
|
||||
}
|
||||
free(*tok);
|
||||
}
|
||||
}
|
||||
|
||||
/* Do action on this element if element has [relationship] with gi.
|
||||
* Format: _relation relationship gi action [action] */
|
||||
else if (StrEq(tok[0], "relation")) {
|
||||
if (ntok >= 4) {
|
||||
if (!CheckRelation(e, tok[1], tok[2], tok[3], fp, RA_Current)) {
|
||||
/* action not done, see if alt action specified */
|
||||
if (ntok >= 5)
|
||||
TranTByAction(e, tok[4], fp);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Do action on followed element if element has [relationship] with gi.
|
||||
* Format: _followrel relationship gi action */
|
||||
else if (StrEq(tok[0], "followrel")) {
|
||||
if (ntok >= 4)
|
||||
(void)CheckRelation(e, tok[1], tok[2], tok[3], fp, RA_Related);
|
||||
}
|
||||
|
||||
/* Find element with matching ID and do action. If action not specified,
|
||||
* choose the right one appropriate for its context.
|
||||
* Format: _id id [action] */
|
||||
else if (StrEq(tok[0], "id")) {
|
||||
if ((ep = FindElemByID(tok[1]))) {
|
||||
if (ntok > 2) TranTByAction(ep, tok[2], fp);
|
||||
else {
|
||||
t = FindTrans(ep, 0);
|
||||
TransElement(ep, fp, t);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Set variable to value.
|
||||
* Format: _set name value */
|
||||
else if (StrEq(tok[0], "set")) {
|
||||
SetMappingNV(Variables, tok[1], tok[2]);
|
||||
}
|
||||
|
||||
/* Do action if variable is set, optionally to value.
|
||||
* If not set, do nothing.
|
||||
* Format: _isset varname [value] action
|
||||
* Format: _issete varname [value] action -- expands value */
|
||||
else if (StrEq(tok[0], "isset") || StrEq(tok[0], "issete")) {
|
||||
if ((cp = FindMappingVal(Variables, tok[1]))) {
|
||||
if (ntok == 3) TranTByAction(e, tok[2], fp);
|
||||
else
|
||||
if (ntok > 3) {
|
||||
if ( StrEq(tok[0], "issete") ) {
|
||||
ExpandVariables(tok[2], buf, e);
|
||||
cp2 = buf;
|
||||
} else
|
||||
cp2 = tok[2];
|
||||
if ( !strcmp(cp, cp2))
|
||||
TranTByAction(e, tok[3], fp);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Insert a node into the tree at start/end, pointing to action to perform.
|
||||
* Format: _insertnode S|E action */
|
||||
else if (StrEq(tok[0], "insertnode")) {
|
||||
actioni = atoi(tok[2]);
|
||||
if (*tok[1] == 'S') e->gen_trans[0] = actioni;
|
||||
else if (*tok[1] == 'E') e->gen_trans[1] = actioni;
|
||||
}
|
||||
|
||||
/* Do an CALS DTD table spec for TeX or troff. Looks through attributes
|
||||
* and determines what to output. "check" means to check consistency,
|
||||
* and print error messages.
|
||||
* This is (hopefully) the only hard-coded part of instant.
|
||||
*
|
||||
* This was originally written for the OSF DTDs and recoded by FLD for
|
||||
* CALS tables (since no one will ever use the OSF tables). Although
|
||||
* TeX was addressed first, it seems that a fresh approach was required,
|
||||
* and so, tbl is the first to be really *fixed*. Once tbl is stable,
|
||||
* and there is a need for TeX again, that part will be recoded.
|
||||
*
|
||||
* *Obsolete* form (viz, for TeX):
|
||||
* Format: _calstable [clear|check|tex]
|
||||
* [cellstart|cellend|rowstart|rowend|top|bottom]
|
||||
*
|
||||
* New, good form:
|
||||
*
|
||||
* Format: _calstable [tbl]
|
||||
* [tablestart|tableend|tablegroup|tablefoot|rowstart|
|
||||
* rowend|entrystart|entryend]
|
||||
*/
|
||||
|
||||
else if (StrEq(tok[0], "calstable")) {
|
||||
CALStable(e, fp, tok, ntok);
|
||||
}
|
||||
|
||||
/* Do action if element's attr is set, optionally to value.
|
||||
* If not set, do nothing.
|
||||
* Format: _attval att [value] action */
|
||||
else if (StrEq(tok[0], "attval")) {
|
||||
if ((atval = FindAttValByName(e, tok[1]))) {
|
||||
if (ntok == 3) TranTByAction(e, tok[2], fp);
|
||||
else if (ntok > 3 && !strcmp(atval, tok[2]))
|
||||
TranTByAction(e, tok[3], fp);
|
||||
}
|
||||
}
|
||||
/* Same thing, but look at parent */
|
||||
else if (StrEq(tok[0], "pattval")) {
|
||||
if ((atval = FindAttValByName(e->parent, tok[1]))) {
|
||||
if (ntok == 3) {
|
||||
TranTByAction(e, tok[2], fp);
|
||||
}
|
||||
if (ntok > 3 && !strcmp(atval, tok[2]))
|
||||
TranTByAction(e, tok[3], fp);
|
||||
}
|
||||
}
|
||||
|
||||
/* Print each attribute and value for the current element, hopefully
|
||||
* in a legal sgml form: <elem-name att1="value1" att2="value2:> .
|
||||
* Format: _allatts */
|
||||
else if (StrEq(tok[0], "allatts")) {
|
||||
for (i=0; i<e->natts; i++) {
|
||||
if (i != 0) putc(' ', fp);
|
||||
fputs(e->atts[i].name, fp);
|
||||
fputs("=\"", fp);
|
||||
fputs(e->atts[i].sval, fp);
|
||||
putc('"', fp);
|
||||
}
|
||||
}
|
||||
|
||||
/* Print the element's input filename, and optionally, the line number.
|
||||
* Format: _infile [line] */
|
||||
else if (StrEq(tok[0], "infile")) {
|
||||
if (e->infile) {
|
||||
if (ntok > 1 && !strcmp(tok[1], "root")) {
|
||||
strcpy(buf, e->infile);
|
||||
if ((cp = strrchr(buf, '.'))) *cp = EOS;
|
||||
fputs(buf, fp);
|
||||
}
|
||||
else {
|
||||
fputs(e->infile, fp);
|
||||
if (ntok > 1 && !strcmp(tok[1], "line"))
|
||||
fprintf(fp, " %d", e->lineno);
|
||||
}
|
||||
return;
|
||||
}
|
||||
else fputs("input-file??", fp);
|
||||
}
|
||||
|
||||
/* Get value of an environement variable */
|
||||
else if (StrEq(tok[0], "env")) {
|
||||
if (ntok > 1 && (cp = getenv(tok[1]))) {
|
||||
OutputString(cp, fp, track_pos);
|
||||
}
|
||||
}
|
||||
|
||||
/* Something unknown */
|
||||
else {
|
||||
fprintf(stderr, "Unknown special variable: %s\n", tok[0]);
|
||||
tt = e->trans;
|
||||
if (tt && tt->lineno)
|
||||
fprintf(stderr, "Used in transpec, line %d\n", tt->lineno);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
/* ______________________________________________________________________ */
|
||||
/* return the value for the special variables _A (last processed _eachatt)
|
||||
* and _C (last processed _eachcon)
|
||||
*/
|
||||
|
||||
char *
|
||||
Get_A_C_value(char * name)
|
||||
{
|
||||
if ( !strcmp(name, "each_A") ) {
|
||||
if ( each_A ) {
|
||||
return each_A;
|
||||
} else {
|
||||
fprintf(stderr, "Requested value for unset _A variable\n");
|
||||
}
|
||||
} else
|
||||
if ( !strcmp(name, "each_C") ) {
|
||||
if ( each_C ) {
|
||||
return each_C;
|
||||
} else {
|
||||
fprintf(stderr, "Requested value for unset _C variable\n");
|
||||
}
|
||||
} else {
|
||||
fprintf(stderr, "Requested value for unknown special variable '%s'\n",
|
||||
name);
|
||||
}
|
||||
return "";
|
||||
}
|
||||
|
||||
/* ______________________________________________________________________ */
|
||||
/* Chase IDs until we find an element whose GI matches. We also check
|
||||
* child element names, not just the names of elements directly pointed
|
||||
* at (by IDREF attributes).
|
||||
*/
|
||||
|
||||
void
|
||||
GetIDREFnames(void)
|
||||
{
|
||||
char *cp;
|
||||
|
||||
if (!idrefs) {
|
||||
/* did user or transpec set the variable */
|
||||
if ((cp = FindMappingVal(Variables, "link_atts")))
|
||||
idrefs = Split(cp, 0, S_STRDUP|S_ALVEC);
|
||||
else
|
||||
idrefs = def_idrefs;
|
||||
}
|
||||
}
|
||||
|
||||
/* ______________________________________________________________________ */
|
||||
/* Chase ID references - follow IDREF(s) attributes until we find
|
||||
* a GI named 'gi', then perform given action on that GI.
|
||||
* Arguments:
|
||||
* Pointer to element under consideration.
|
||||
* Name of GI we're looking for.
|
||||
* Spec ID of action to take.
|
||||
* FILE pointer to where to write output.
|
||||
*/
|
||||
void
|
||||
ChaseIDRefs(
|
||||
Element_t *e,
|
||||
char *gi,
|
||||
char * action,
|
||||
FILE *fp
|
||||
)
|
||||
{
|
||||
int ntok, i, ei;
|
||||
char **tok, **s, *atval;
|
||||
|
||||
/* First, see if we got what we came for with this element */
|
||||
if (StrEq(e->gi, gi)) {
|
||||
TranTByAction(e, action, fp);
|
||||
return;
|
||||
}
|
||||
GetIDREFnames();
|
||||
|
||||
/* loop for each attribute of type IDREF(s) */
|
||||
for (s=idrefs; *s; s++) {
|
||||
/* is this IDREF attr set? */
|
||||
if ((atval = FindAttValByName(e, *s))) {
|
||||
ntok = 0;
|
||||
tok = Split(atval, &ntok, 0);
|
||||
for (i=0; i<ntok; i++) {
|
||||
/* get element pointed to */
|
||||
if ((e = FindElemByID(tok[i]))) {
|
||||
/* OK, we found a matching GI name */
|
||||
if (StrEq(e->gi, gi)) {
|
||||
/* process using named action */
|
||||
TranTByAction(e, action, fp);
|
||||
return;
|
||||
}
|
||||
else {
|
||||
/* this elem itself did not match, try its children */
|
||||
for (ei=0; ei<e->necont; ei++) {
|
||||
if (StrEq(e->econt[ei]->gi, gi)) {
|
||||
TranTByAction(e->econt[ei], action, fp);
|
||||
return;
|
||||
}
|
||||
}
|
||||
/* try this elem's IDREF attributes */
|
||||
ChaseIDRefs(e, gi, action, fp);
|
||||
return;
|
||||
}
|
||||
}
|
||||
else {
|
||||
/* should not happen, since parser checks ID/IDREFs */
|
||||
fprintf(stderr, "Error: Could not find ID %s\n", atval);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
/* if the pointers didn't lead to the GI, give error */
|
||||
if (!s)
|
||||
fprintf(stderr, "Error: Could not find '%s'\n", gi);
|
||||
}
|
||||
|
||||
/* ______________________________________________________________________ */
|
||||
|
||||
/* state to pass to recursive routines - so we don't have to use
|
||||
* global variables. */
|
||||
typedef struct {
|
||||
char *gi;
|
||||
char *gi2;
|
||||
char action[10];
|
||||
Element_t *elem;
|
||||
FILE *fp;
|
||||
} Descent_t;
|
||||
|
||||
static void
|
||||
tr_find_gi(
|
||||
Element_t *e,
|
||||
Descent_t *ds
|
||||
)
|
||||
{
|
||||
if (StrEq(ds->gi, e->gi))
|
||||
if (ds->action[0]) TranTByAction(e, ds->action, ds->fp);
|
||||
}
|
||||
|
||||
static void
|
||||
tr_find_gipar(
|
||||
Element_t *e,
|
||||
Descent_t *ds
|
||||
)
|
||||
{
|
||||
if (StrEq(ds->gi, e->gi) && e->parent &&
|
||||
StrEq(ds->gi2, e->parent->gi))
|
||||
if (ds->action[0]) TranTByAction(e, ds->action, ds->fp);
|
||||
}
|
||||
|
||||
static void
|
||||
tr_find_attr(
|
||||
Element_t *e,
|
||||
Descent_t *ds
|
||||
)
|
||||
{
|
||||
char *atval;
|
||||
if ((atval = FindAttValByName(e, ds->gi)) && StrEq(ds->gi2, atval))
|
||||
TranTByAction(e, ds->action, ds->fp);
|
||||
}
|
||||
|
||||
static void
|
||||
tr_find_parent(
|
||||
Element_t *e,
|
||||
Descent_t *ds
|
||||
)
|
||||
{
|
||||
if (QRelation(e, ds->gi, REL_Parent)) {
|
||||
if (ds->action[0]) TranTByAction(e, ds->action, ds->fp);
|
||||
}
|
||||
}
|
||||
|
||||
/* ______________________________________________________________________ */
|
||||
/* Descend tree, finding elements that match criteria, then perform
|
||||
* given action.
|
||||
* Arguments:
|
||||
* Pointer to element under consideration.
|
||||
* Number of tokens in special variable.
|
||||
* Vector of tokens in special variable (eg, "find" "gi" "TITLE")
|
||||
* FILE pointer to where to write output.
|
||||
*/
|
||||
void
|
||||
Find(
|
||||
Element_t *e,
|
||||
int ac,
|
||||
char **av,
|
||||
FILE *fp
|
||||
)
|
||||
{
|
||||
Descent_t DS; /* state passed to recursive routine */
|
||||
|
||||
memset(&DS, 0, sizeof(Descent_t));
|
||||
DS.elem = e;
|
||||
DS.fp = fp;
|
||||
|
||||
/* see if we should start at the top of instance tree */
|
||||
if (StrEq(av[1], "top")) {
|
||||
av++;
|
||||
ac--;
|
||||
e = DocTree;
|
||||
}
|
||||
if (ac < 4) {
|
||||
fprintf(stderr, "Bad '_find' specification - missing args.\n");
|
||||
return;
|
||||
}
|
||||
/* Find elem whose GI is av[2] */
|
||||
if (StrEq(av[1], "gi")) {
|
||||
DS.gi = av[2];
|
||||
strcpy(DS.action, av[3]);
|
||||
DescendTree(e, tr_find_gi, 0, 0, &DS);
|
||||
}
|
||||
/* Find elem whose GI is av[2] and whose parent GI is av[3] */
|
||||
else if (StrEq(av[1], "gi-parent")) {
|
||||
DS.gi = av[2];
|
||||
DS.gi2 = av[3];
|
||||
strcpy(DS.action, av[4]);
|
||||
DescendTree(e, tr_find_gipar, 0, 0, &DS);
|
||||
}
|
||||
/* Find elem whose parent GI is av[2] */
|
||||
else if (StrEq(av[0], "parent")) {
|
||||
DS.gi = av[2];
|
||||
strcpy(DS.action, av[3]);
|
||||
DescendTree(e, tr_find_parent, 0, 0, &DS);
|
||||
}
|
||||
/* Find elem whose attribute av[2] has value av[3] */
|
||||
else if (StrEq(av[0], "attr")) {
|
||||
DS.gi = av[2];
|
||||
DS.gi2 = av[3];
|
||||
snprintf(DS.action, sizeof(DS.action), "%s", av[4]);
|
||||
DescendTree(e, tr_find_attr, 0, 0, &DS);
|
||||
}
|
||||
}
|
||||
|
||||
/* ______________________________________________________________________ */
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@@ -1,50 +0,0 @@
|
||||
# $XConsortium: roff.cmap /main/1 1996/07/23 19:48:00 rws $
|
||||
#
|
||||
# Copyright (c) 1994
|
||||
# Open Software Foundation, Inc.
|
||||
#
|
||||
# Permission is hereby granted to use, copy, modify and freely distribute
|
||||
# the software in this file and its documentation for any purpose without
|
||||
# fee, provided that the above copyright notice appears in all copies and
|
||||
# that both the copyright notice and this permission notice appear in
|
||||
# supporting documentation. Further, provided that the name of Open
|
||||
# Software Foundation, Inc. ("OSF") not be used in advertising or
|
||||
# publicity pertaining to distribution of the software without prior
|
||||
# written permission from OSF. OSF makes no representations about the
|
||||
# suitability of this software for any purpose. It is provided "as is"
|
||||
# without express or implied warranty.
|
||||
#
|
||||
# Copyright (c) 1996 X Consortium
|
||||
# Copyright (c) 1996 Dalrymple Consulting
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
# of this software and associated documentation files (the "Software"), to deal
|
||||
# in the Software without restriction, including without limitation the rights
|
||||
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
# copies of the Software, and to permit persons to whom the Software is
|
||||
# furnished to do so, subject to the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included in
|
||||
# all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
# X CONSORTIUM OR DALRYMPLE CONSULTING BE LIABLE FOR ANY CLAIM, DAMAGES OR
|
||||
# OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
# ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
||||
# OTHER DEALINGS IN THE SOFTWARE.
|
||||
#
|
||||
# Except as contained in this notice, the names of the X Consortium and
|
||||
# Dalrymple Consulting shall not be used in advertising or otherwise to
|
||||
# promote the sale, use or other dealings in this Software without prior
|
||||
# written authorization.
|
||||
#
|
||||
#
|
||||
# Character strings to map for troff/nroff.
|
||||
#
|
||||
# From To
|
||||
#\\ \\e
|
||||
^ \^
|
||||
. \\&.
|
||||
' \\&'
|
||||
@@ -1,589 +0,0 @@
|
||||
# $XConsortium: roff.sdata /main/2 1996/08/31 13:58:01 rws $
|
||||
# Copyright (c) 1994
|
||||
# Open Software Foundation, Inc.
|
||||
#
|
||||
# Permission is hereby granted to use, copy, modify and freely distribute
|
||||
# the software in this file and its documentation for any purpose without
|
||||
# fee, provided that the above copyright notice appears in all copies and
|
||||
# that both the copyright notice and this permission notice appear in
|
||||
# supporting documentation. Further, provided that the name of Open
|
||||
# Software Foundation, Inc. ("OSF") not be used in advertising or
|
||||
# publicity pertaining to distribution of the software without prior
|
||||
# written permission from OSF. OSF makes no representations about the
|
||||
# suitability of this software for any purpose. It is provided "as is"
|
||||
# without express or implied warranty.
|
||||
#
|
||||
# Copyright (c) 1996 X Consortium
|
||||
# Copyright (c) 1996 Dalrymple Consulting
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
# of this software and associated documentation files (the "Software"), to deal
|
||||
# in the Software without restriction, including without limitation the rights
|
||||
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
# copies of the Software, and to permit persons to whom the Software is
|
||||
# furnished to do so, subject to the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included in
|
||||
# all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
# X CONSORTIUM OR DALRYMPLE CONSULTING BE LIABLE FOR ANY CLAIM, DAMAGES OR
|
||||
# OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
# ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
||||
# OTHER DEALINGS IN THE SOFTWARE.
|
||||
#
|
||||
# Except as contained in this notice, the names of the X Consortium and
|
||||
# Dalrymple Consulting shall not be used in advertising or otherwise to
|
||||
# promote the sale, use or other dealings in this Software without prior
|
||||
# written authorization.
|
||||
#
|
||||
#
|
||||
# SDATA entity mappings to TeX instructions.
|
||||
# sgmls outputs sdata references in the form: \\|[mdash ]\\|
|
||||
#
|
||||
# J.Bowe, 1993
|
||||
#
|
||||
# Numeric and Special Graphic ________________________________
|
||||
#
|
||||
[half ] \\(12
|
||||
[frac12] \\(12
|
||||
[frac14] \\(14
|
||||
[frac34] \\(34
|
||||
[frac18] 1/8
|
||||
[frac38] 3/8
|
||||
[frac58] 5/8
|
||||
[frac78] 7/8
|
||||
[sup1 ] \\u1\\l
|
||||
[sup2 ] \\u2\\l
|
||||
[sup3 ] \\u3\\l
|
||||
[plus ] \\(pl
|
||||
[plusmn] \\(+-
|
||||
[lt ] <
|
||||
[equals] =
|
||||
[gt ] >
|
||||
[divide] \\(di
|
||||
[times ] \\(ti
|
||||
# [curren] =general currency sign
|
||||
[pound ] #
|
||||
[dollar] $
|
||||
[cent ] \\(ct
|
||||
[yen ] yen
|
||||
[num ] #
|
||||
[percnt] %
|
||||
[amp ] &
|
||||
[ast ] *
|
||||
[commat] @
|
||||
[lsqb ] [
|
||||
[bsol ] \\e
|
||||
[rsqb ] ]
|
||||
[lcub ] { /lbrace O: =left curly bracket
|
||||
# [horbar] horizontal bar
|
||||
[horbar] _
|
||||
[verbar] \\(or
|
||||
[rcub ] }
|
||||
[micro ] \\(*m
|
||||
[ohm ] \\(*W
|
||||
[deg ] \\(de
|
||||
# [ordm ] =ordinal indicator, masculine
|
||||
# [ordf ] =ordinal indicator, feminine
|
||||
[sect ] \\(sc
|
||||
# [para ] =pilcrow (paragraph sign)
|
||||
# [middot] /centerdot B: =middle dot
|
||||
[larr ] \\(<-
|
||||
[rarr ] \\(->
|
||||
[uarr ] \\(ua
|
||||
[darr ] \\(da
|
||||
[copy ] \\(co
|
||||
[reg ] \\(rg
|
||||
#[trade ] trademark
|
||||
[trade ] \\(tm
|
||||
# [brvbar] =broken (vertical) bar
|
||||
[brvbar] |
|
||||
[not ] \\(no
|
||||
# [sung ] =music note (sung text sign)
|
||||
[excl ] !
|
||||
# [iexcl ] =inverted exclamation mark
|
||||
[quot ] "
|
||||
[apos ] \\&'
|
||||
[lpar ] (
|
||||
[rpar ] )
|
||||
[comma ] ,
|
||||
[lowbar] _
|
||||
[hyphen] -
|
||||
[period] .
|
||||
[sol ] /
|
||||
[colon ] :
|
||||
[semi ] ;
|
||||
[quest ] ?
|
||||
# [iquest] =inverted question mark
|
||||
# [laquo ] =angle quotation mark, left
|
||||
[laquo ] <<
|
||||
# [raquo ] =angle quotation mark, right
|
||||
[raquo ] >>
|
||||
[lsquo ] `
|
||||
[rsquo ] \\&'
|
||||
[ldquo ] "
|
||||
[rdquo ] "
|
||||
[nbsp ] \\
|
||||
[shy ] \\%
|
||||
#
|
||||
# Publishing ________________________________
|
||||
#
|
||||
# trailing space here
|
||||
[emsp ] \\ \\
|
||||
[ensp ] \\
|
||||
[emsp3 ] \\
|
||||
[emsp4 ] \\
|
||||
[numsp ] \\0
|
||||
[puncsp] \\|
|
||||
[thinsp] \\!
|
||||
[hairsp] \\\^
|
||||
[mdash ] \\(em
|
||||
[ndash ] -
|
||||
[dash ] -
|
||||
[blank ] \\
|
||||
[hellip] \\&...
|
||||
[nldr ] \\&..
|
||||
[frac13] 1/3
|
||||
[frac23] 2/3
|
||||
[frac15] 1/5
|
||||
[frac25] 2/5
|
||||
[frac35] 3/5
|
||||
[frac45] 4/5
|
||||
[frac16] 1/6
|
||||
[frac56] 5/6
|
||||
# [incare] =in-care-of symbol
|
||||
# [block ] =full block
|
||||
# [uhblk ] =upper half block
|
||||
# [lhblk ] =lower half block
|
||||
# [blk14 ] =25% shaded block
|
||||
# [blk12 ] =50% shaded block
|
||||
# [blk34 ] =75% shaded block
|
||||
# [marker] =histogram marker
|
||||
[cir ] \\(ci
|
||||
[squ ] \\(sq
|
||||
# [rect ] =rectangle, open
|
||||
# [utri ] /triangle =up triangle, open
|
||||
# [dtri ] /triangledown =down triangle, open
|
||||
[star ] \\(** =star, open
|
||||
[bull ] \\(bu
|
||||
# [squf ] /blacksquare =sq bullet, filled
|
||||
# [utrif ] /blacktriangle =up tri, filled
|
||||
# [dtrif ] /blacktriangledown =dn tri, filled
|
||||
# [ltrif ] /blacktriangleleft R: =l tri, filled
|
||||
# [rtrif ] /blacktriangleright R: =r tri, filled
|
||||
# [clubs ] /clubsuit =club suit symbol
|
||||
# [diams ] /diamondsuit =diamond suit symbol
|
||||
# [hearts] /heartsuit =heart suit symbol
|
||||
# [spades] /spadesuit =spades suit symbol
|
||||
# [malt ] /maltese =maltese cross
|
||||
[dagger] \\(dg
|
||||
[Dagger] \\(dd
|
||||
# [check ] /checkmark =tick, check mark
|
||||
# [ballot] =ballot cross
|
||||
# [sharp ] /sharp =musical sharp
|
||||
# [flat ] /flat =musical flat
|
||||
# [male ] =male symbol
|
||||
# [female] =female symbol
|
||||
# [phone ] =telephone symbol
|
||||
# [telrec] =telephone recorder symbol
|
||||
# [copysr] =sound recording copyright sign
|
||||
[caret ] \^
|
||||
[lsquor] `
|
||||
[ldquor] ``
|
||||
[fflig ] \\(ff
|
||||
[filig ] \\(fi
|
||||
# [fjlig ] small fj ligature
|
||||
[ffilig] \\(Fi
|
||||
[ffllig] \\(Fl
|
||||
[fllig ] \\(fl
|
||||
# [mldr ] em leader
|
||||
[rdquor] \\&''
|
||||
[rsquor] \\&'
|
||||
# [vellip] vertical ellipsis
|
||||
# [hybull] rectangle, filled (hyphen bullet)
|
||||
# [loz ] /lozenge - lozenge or total mark
|
||||
# [lozf ] /blacklozenge - lozenge, filled
|
||||
# [ltri ] /triangleleft B: l triangle, open
|
||||
# [rtri ] /triangleright B: r triangle, open
|
||||
# [starf ] /bigstar - star, filled
|
||||
# [natur ] /natural - music natural
|
||||
# [rx ] pharmaceutical prescription (Rx)
|
||||
# [sext ] sextile (6-pointed star)
|
||||
# [target] register mark or target
|
||||
# [dlcrop] downward left crop mark
|
||||
# [drcrop] downward right crop mark
|
||||
# [ulcrop] upward left crop mark
|
||||
# [urcrop] upward right crop mark
|
||||
#
|
||||
# Added Latin 1 ________________________________
|
||||
#
|
||||
[aacute] \\(a'
|
||||
[Aacute] \\(A'
|
||||
[acirc ] \\(a^
|
||||
[Acirc ] \\(A^
|
||||
[agrave] \\(a`
|
||||
[Agrave] \\(A`
|
||||
# [aring ] =small a, ring
|
||||
# [Aring ] =capital A, ring
|
||||
# [atilde] =small a, tilde
|
||||
# [Atilde] =capital A, tilde
|
||||
[auml ] \\(a:
|
||||
# [Auml ] =capital A, dieresis or umlaut mark
|
||||
[aelig ] \\(ae
|
||||
[AElig ] \\(AE
|
||||
# [ccedil] =small c, cedilla
|
||||
# [Ccedil] =capital C, cedilla
|
||||
# [eth ] =small eth, Icelandic
|
||||
# [ETH ] =capital Eth, Icelandic
|
||||
[eacute] \\(e'
|
||||
[Eacute] \\(E'
|
||||
# [ecirc ] =small e, circumflex accent
|
||||
# [Ecirc ] =capital E, circumflex accent
|
||||
[egrave] \\(e`
|
||||
[Egrave] \\(E`
|
||||
# [euml ] =small e, dieresis or umlaut mark
|
||||
# [Euml ] =capital E, dieresis or umlaut mark
|
||||
[iacute] \\(i'
|
||||
[Iacute] \\(I'
|
||||
# [icirc ] =small i, circumflex accent
|
||||
# [Icirc ] =capital I, circumflex accent
|
||||
[igrave] \\(i`
|
||||
[Igrave] \\(I`
|
||||
# [iuml ] =small i, dieresis or umlaut mark
|
||||
# [Iuml ] =capital I, dieresis or umlaut mark
|
||||
[ntilde] \\(n~
|
||||
[Ntilde] \\(N~
|
||||
[oacute] \\(o'
|
||||
[Oacute] \\(O'
|
||||
# [ocirc ] =small o, circumflex accent
|
||||
# [Ocirc ] =capital O, circumflex accent
|
||||
[ograve] \\(o`
|
||||
[Ograve] \\(O`
|
||||
[oslash] \\(o/
|
||||
[Oslash] \\(O/
|
||||
# [otilde] =small o, tilde
|
||||
# [Otilde] =capital O, tilde
|
||||
# [ouml ] =small o, dieresis or umlaut mark
|
||||
# [Ouml ] =capital O, dieresis or umlaut mark
|
||||
[szlig ] \\(ss
|
||||
[thorn ] \\(th
|
||||
# [THORN ] =capital THORN, Icelandic
|
||||
[uacute] \\(u'
|
||||
[Uacute] \\(U'
|
||||
# [ucirc ] =small u, circumflex accent
|
||||
# [Ucirc ] =capital U, circumflex accent
|
||||
[ugrave] \\(u`
|
||||
[Ugrave] \\(U`
|
||||
# [uuml ] =small u, dieresis or umlaut mark
|
||||
# [Uuml ] =capital U, dieresis or umlaut mark
|
||||
# [yacute] =small y, acute accent
|
||||
# [Yacute] =capital Y, acute accent
|
||||
# [yuml ] =small y, dieresis or umlaut mark
|
||||
#
|
||||
# Added Latin 2 ________________________________
|
||||
#
|
||||
# [abreve] =small a, breve
|
||||
# [Abreve] =capital A, breve
|
||||
# [amacr ] =small a, macron
|
||||
# [Amacr ] =capital A, macron
|
||||
[aogon ] \\(ao
|
||||
# [Aogon ] =capital A, ogonek
|
||||
# [cacute] =small c, acute accent
|
||||
# [Cacute] =capital C, acute accent
|
||||
# [ccaron] =small c, caron
|
||||
# [Ccaron] =capital C, caron
|
||||
# [ccirc ] =small c, circumflex accent
|
||||
# [Ccirc ] =capital C, circumflex accent
|
||||
# [cdot ] =small c, dot above
|
||||
# [Cdot ] =capital C, dot above
|
||||
# [dcaron] =small d, caron
|
||||
# [Dcaron] =capital D, caron
|
||||
# [dstrok] =small d, stroke
|
||||
# [Dstrok] =capital D, stroke
|
||||
# [ecaron] =small e, caron
|
||||
# [Ecaron] =capital E, caron
|
||||
# [edot ] =small e, dot above
|
||||
# [Edot ] =capital E, dot above
|
||||
# [emacr ] =small e, macron
|
||||
# [Emacr ] =capital E, macron
|
||||
# [eogon ] =small e, ogonek
|
||||
# [Eogon ] =capital E, ogonek
|
||||
# [gacute] =small g, acute accent
|
||||
# [gbreve] =small g, breve
|
||||
# [Gbreve] =capital G, breve
|
||||
# [Gcedil] =capital G, cedilla
|
||||
# [gcirc ] =small g, circumflex accent
|
||||
# [Gcirc ] =capital G, circumflex accent
|
||||
# [gdot ] =small g, dot above
|
||||
# [Gdot ] =capital G, dot above
|
||||
# [hcirc ] =small h, circumflex accent
|
||||
# [Hcirc ] =capital H, circumflex accent
|
||||
# [hstrok] =small h, stroke
|
||||
# [Hstrok] =capital H, stroke
|
||||
# [Idot ] =capital I, dot above
|
||||
# [Imacr ] =capital I, macron
|
||||
# [imacr ] =small i, macron
|
||||
# [ijlig ] =small ij ligature
|
||||
# [IJlig ] =capital IJ ligature
|
||||
# [inodot] =small i without dot
|
||||
# [iogon ] =small i, ogonek
|
||||
# [Iogon ] =capital I, ogonek
|
||||
# [itilde] =small i, tilde
|
||||
# [Itilde] =capital I, tilde
|
||||
# [jcirc ] =small j, circumflex accent
|
||||
# [Jcirc ] =capital J, circumflex accent
|
||||
# [kcedil] =small k, cedilla
|
||||
# [Kcedil] =capital K, cedilla
|
||||
# [kgreen] =small k, Greenlandic
|
||||
# [lacute] =small l, acute accent
|
||||
# [Lacute] =capital L, acute accent
|
||||
# [lcaron] =small l, caron
|
||||
# [Lcaron] =capital L, caron
|
||||
# [lcedil] =small l, cedilla
|
||||
# [Lcedil] =capital L, cedilla
|
||||
# [lmidot] =small l, middle dot
|
||||
# [Lmidot] =capital L, middle dot
|
||||
# [lstrok] =small l, stroke
|
||||
# [Lstrok] =capital L, stroke
|
||||
# [nacute] =small n, acute accent
|
||||
# [Nacute] =capital N, acute accent
|
||||
# [eng ] =small eng, Lapp
|
||||
# [ENG ] =capital ENG, Lapp
|
||||
# [napos ] =small n, apostrophe
|
||||
# [ncaron] =small n, caron
|
||||
# [Ncaron] =capital N, caron
|
||||
# [ncedil] =small n, cedilla
|
||||
# [Ncedil] =capital N, cedilla
|
||||
# [odblac] =small o, double acute accent
|
||||
# [Odblac] =capital O, double acute accent
|
||||
# [Omacr ] =capital O, macron
|
||||
# [omacr ] =small o, macron
|
||||
# [oelig ] =small oe ligature
|
||||
# [OElig ] =capital OE ligature
|
||||
# [racute] =small r, acute accent
|
||||
# [Racute] =capital R, acute accent
|
||||
# [rcaron] =small r, caron
|
||||
# [Rcaron] =capital R, caron
|
||||
# [rcedil] =small r, cedilla
|
||||
# [Rcedil] =capital R, cedilla
|
||||
# [sacute] =small s, acute accent
|
||||
# [Sacute] =capital S, acute accent
|
||||
# [scaron] =small s, caron
|
||||
# [Scaron] =capital S, caron
|
||||
# [scedil] =small s, cedilla
|
||||
# [Scedil] =capital S, cedilla
|
||||
# [scirc ] =small s, circumflex accent
|
||||
# [Scirc ] =capital S, circumflex accent
|
||||
# [tcaron] =small t, caron
|
||||
# [Tcaron] =capital T, caron
|
||||
# [tcedil] =small t, cedilla
|
||||
# [Tcedil] =capital T, cedilla
|
||||
# [tstrok] =small t, stroke
|
||||
# [Tstrok] =capital T, stroke
|
||||
# [ubreve] =small u, breve
|
||||
# [Ubreve] =capital U, breve
|
||||
# [udblac] =small u, double acute accent
|
||||
# [Udblac] =capital U, double acute accent
|
||||
# [umacr ] =small u, macron
|
||||
# [Umacr ] =capital U, macron
|
||||
# [uogon ] =small u, ogonek
|
||||
# [Uogon ] =capital U, ogonek
|
||||
# [uring ] =small u, ring
|
||||
# [Uring ] =capital U, ring
|
||||
# [utilde] =small u, tilde
|
||||
# [Utilde] =capital U, tilde
|
||||
# [wcirc ] =small w, circumflex accent
|
||||
# [Wcirc ] =capital W, circumflex accent
|
||||
# [ycirc ] =small y, circumflex accent
|
||||
# [Ycirc ] =capital Y, circumflex accent
|
||||
# [Yuml ] =capital Y, dieresis or umlaut mark
|
||||
# [zacute] =small z, acute accent
|
||||
# [Zacute] =capital Z, acute accent
|
||||
# [zcaron] =small z, caron
|
||||
# [Zcaron] =capital Z, caron
|
||||
# [zdot ] =small z, dot above
|
||||
# [Zdot ] =capital Z, dot above
|
||||
#
|
||||
# Greek Letters ________________________________
|
||||
#
|
||||
[agr ] \\(*a
|
||||
[Agr ] \\(*A
|
||||
[bgr ] \\(*b
|
||||
[Bgr ] \\(*B
|
||||
[ggr ] \\(*g
|
||||
[Ggr ] \\(*G
|
||||
[dgr ] \\(*d
|
||||
[Dgr ] \\(*D
|
||||
[egr ] \\(*e
|
||||
[Egr ] \\(*E
|
||||
[zgr ] \\(*z
|
||||
[Zgr ] \\(*Z
|
||||
[eegr ] \\(*y
|
||||
[EEgr ] \\(*Y
|
||||
[thgr ] \\(*h
|
||||
[THgr ] \\(*H
|
||||
[igr ] \\(*i
|
||||
[Igr ] \\(*I
|
||||
[kgr ] \\(*k
|
||||
[Kgr ] \\(*K
|
||||
[lgr ] \\(*l
|
||||
[Lgr ] \\(*L
|
||||
[mgr ] \\(*m
|
||||
[Mgr ] \\(*M
|
||||
[ngr ] \\(*n
|
||||
[Ngr ] \\(*N
|
||||
[xgr ] \\(*c
|
||||
[Xgr ] \\(*C
|
||||
[ogr ] \\(*o
|
||||
[Ogr ] \\(*O
|
||||
[pgr ] \\(*p
|
||||
[Pgr ] \\(*P
|
||||
[rgr ] \\(*r
|
||||
[Rgr ] \\(*R
|
||||
[sgr ] \\(*s
|
||||
[Sgr ] \\(*S
|
||||
[sfgr ] \\(ts
|
||||
[tgr ] \\(*t
|
||||
[Tgr ] \\(*T
|
||||
[ugr ] \\(*u
|
||||
[Ugr ] \\(*U
|
||||
[phgr ] \\(*f
|
||||
[PHgr ] \\(*F
|
||||
[khgr ] \\(*x
|
||||
[KHgr ] \\(*X
|
||||
[psgr ] \\(*q
|
||||
[PSgr ] \\(*Q
|
||||
[ohgr ] \\(*w
|
||||
[OHgr ] \\(*W
|
||||
#
|
||||
# Greek Symbols ________________________________
|
||||
#
|
||||
[alpha ] \\(*a
|
||||
[beta ] \\(*b
|
||||
[gamma ] \\(*g
|
||||
[Gamma ] \\(*G
|
||||
# [gammad] /digamma
|
||||
[delta ] \\(*d
|
||||
[Delta ] \\(*D
|
||||
[epsi ] \\(*e
|
||||
# [epsiv ] /varepsilon
|
||||
[epsis ] \\(*e
|
||||
[zeta ] \\(*z
|
||||
[eta ] \\(*y
|
||||
[thetas] \\(*h
|
||||
[Theta ] \\(*H
|
||||
# [thetav] /vartheta - curly or open theta
|
||||
[iota ] \\(*i
|
||||
[kappa ] \\(*k
|
||||
# [kappav] /varkappa
|
||||
[lambda] \\(*l
|
||||
[Lambda] \\(*L
|
||||
[mu ] \\(*m
|
||||
[nu ] \\(*n
|
||||
[xi ] \\(*c
|
||||
[Xi ] \\(*C
|
||||
[pi ] \\(*p
|
||||
# [piv ] /varpi
|
||||
[Pi ] \\(*P
|
||||
[rho ] \\(*r
|
||||
# [rhov ] /varrho
|
||||
[sigma ] \\(*s
|
||||
[Sigma ] \\(*S
|
||||
# [sigmav] /varsigma
|
||||
[tau ] \\(*t
|
||||
[upsi ] \\(*u
|
||||
[Upsi ] \\(*U
|
||||
[phis ] \\(*f
|
||||
[Phi ] \\(*F
|
||||
# [phiv ] /varphi - curly or open phi
|
||||
[chi ] \\(*x
|
||||
[psi ] \\(*q
|
||||
[Psi ] \\(*X
|
||||
[omega ] \\(*w
|
||||
[Omega ] \\(*W
|
||||
#
|
||||
# General Technical ________________________________
|
||||
#
|
||||
# [aleph ] /aleph =aleph, Hebrew
|
||||
# [and ] /wedge /land B: =logical and
|
||||
# [ang90 ] =right (90 degree) angle
|
||||
# [angsph] /sphericalangle =angle-spherical
|
||||
[ap ] \\(ap
|
||||
# [becaus] /because R: =because
|
||||
# [bottom] /bot B: =perpendicular
|
||||
# [cap ] /cap B: =intersection
|
||||
# [cong ] /cong R: =congruent with
|
||||
# [conint] /oint L: =contour integral operator
|
||||
# [cup ] /cup B: =union or logical sum
|
||||
[equiv ] \\(==
|
||||
# [exist ] /exists =at least one exists
|
||||
# [forall] /forall =for all
|
||||
# [fnof ] =function of (italic small f)
|
||||
[ge ] \\(>=
|
||||
# [iff ] /iff =if and only if
|
||||
[infin ] \\(if
|
||||
# [int ] /int L: =integral operator
|
||||
[isin ] \\(sb
|
||||
# [lang ] /langle O: =left angle bracket
|
||||
# [lArr ] /Leftarrow A: =is implied by
|
||||
[le ] \\(<=
|
||||
[minus ] -
|
||||
# [mnplus] /mp B: =minus-or-plus sign
|
||||
# [nabla ] /nabla =del, Hamilton operator
|
||||
[ne ] \\(!=
|
||||
# [ni ] /ni /owns R: =contains
|
||||
# [or ] /vee /lor B: =logical or
|
||||
# [par ] /parallel R: =parallel
|
||||
# [part ] /partial =partial differential
|
||||
# [permil] =per thousand
|
||||
# [perp ] /perp R: =perpendicular
|
||||
# [prime ] /prime =prime or minute
|
||||
# [Prime ] =double prime or second
|
||||
[prop ] \\(pt
|
||||
# [radic ] /surd =radical
|
||||
# [rang ] /rangle C: =right angle bracket
|
||||
# [rArr ] /Rightarrow A: =implies
|
||||
# [sim ] /sim R: =similar
|
||||
# [sime ] /simeq R: =similar, equals
|
||||
[square] \\(sq
|
||||
[sub ] \\(sb
|
||||
[sube ] \\(ib
|
||||
[sup ] \\(sp
|
||||
[supe ] \\(ip
|
||||
# [there4] /therefore R: =therefore
|
||||
# [Verbar] /Vert =dbl vertical bar
|
||||
# [angst ] Angstrom =capital A, ring
|
||||
# [bernou] Bernoulli function (script capital B)
|
||||
# [compfn] B: composite function (small circle)
|
||||
# [Dot ] =dieresis or umlaut mark
|
||||
# [DotDot] four dots above
|
||||
# [hamilt] Hamiltonian (script capital H)
|
||||
# [lagran] Lagrangian (script capital L)
|
||||
# [lowast] low asterisk
|
||||
# [notin ] N: negated set membership
|
||||
# [order ] order of (script small o)
|
||||
# [phmmat] physics M-matrix (script capital M)
|
||||
# [tdot ] three dots above
|
||||
# [tprime] triple prime
|
||||
# [wedgeq] R: corresponds to (wedge, equals)
|
||||
#
|
||||
# Diacritical Marks ________________________________
|
||||
#
|
||||
[acute ] \\&'
|
||||
[breve ] \\(be
|
||||
[caron ] \\(hc
|
||||
[cedil ] \\(cd
|
||||
# [circ ] =circumflex accent
|
||||
# [dblac ] =double acute accent
|
||||
# [die ] =dieresis
|
||||
[dot ] \\(dt
|
||||
[grave ] `
|
||||
[macr ] \\(ma
|
||||
[ogon ] \\(og
|
||||
[ring ] \\(ri
|
||||
[tilde ] ~
|
||||
[uml ] \\(..
|
||||
#
|
||||
Reference in New Issue
Block a user