util.c revision 7c478bd95313f5f23a4c958a745db2134aa03244
/*
* Copyright 1993 Open Software Foundation, Inc., Cambridge, Massachusetts.
* All rights reserved.
*/
/*
#pragma ident "%Z%%M% %I% %E% SMI"
* 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
* 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.
*/
/* ________________________________________________________________________
*
* General utility functions for 'instant' program. These are used
* throughout the rest of the program.
*
* Entry points for this module:
* Split(s, &n, flags) split string into n tokens
* NewMap(slot_incr) create a new mapping structure
* FindMapping(map, name) find mapping by name; return mapping
* FindMappingVal(map, name) find mapping by name; return value
* SetMapping(map, s) set mapping based on string
* OpenFile(filename) open file, looking in inst path
* FindElementPath(elem, s) find path to element
* PrintLocation(ele, fp) print location of element in tree
* NearestOlderElem(elem, name) find prev elem up tree with name
* OutputString(s, fp, track_pos) output string
* AddElemName(name) add elem to list of known elements
* AddAttName(name) add att name to list of known atts
* FindAttByName(elem, name) find an elem's att by name
* FindContext(elem, lev, context) find context of elem
* QRelation(elem, name, rel_flag) find relation elem has to named elem
* DescendTree(elem, enter_f, leave_f, data_f, dp) descend doc tree,
* ________________________________________________________________________
*/
#ifndef lint
static char *RCSid =
#endif
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
#include <memory.h>
/* CSS don't have it and I don't see where it's used
#include <values.h>
*/
#include "general.h"
/* forward references */
static char *LookupSDATA(char *);
/* ______________________________________________________________________ */
/* "Split" a string into tokens. Given a string that has space-separated
* tokens. Like what the shell does with *argv[]. The array can be is
* static or allocated. Space can be allocated for string, or allocated.
* Arguments:
* Pointer to string to pick apart.
* Pointer to max number of tokens to find; actual number found is
* returned. If 0 or null pointer, use a 'sane' maximum number (hard-
* code). If more tokens than the number specified, make last token be
* a single string composed of the rest of the tokens (includes spaces).
* Flag. Bit 0 says whether to make a copy of input string (since we'll
* clobber parts of it). To free the string, use the pointer to
* the first token returned by the function (or *ret_value).
* Bit 1 says whether to allocate the vector itself. If not, use
* (and return) a static vector.
* Return:
* Pointer to the provided string (for convenience of caller).
*/
char **
char *s, /* input string */
int *ntok, /* # of tokens desired (input)/found (return) */
int flag /* dup string? allocate a vector? */
)
{
int n_alloc;
char **tokens;
static char *local_tokens[100];
/* Figure max number of tokens (maxnt) to find. 0 means find them all. */
maxnt = 100;
else {
*ntok = 0;
}
if (!s) return 0; /* no string */
/* Point to 1st token (there may be initial space) */
while (*s && IsWhite(*s)) s++; /* skip initial space, if any */
if (*s == EOS) return 0; /* none found? */
/* See if caller wants us to copy the input string. */
/* See if caller wants us to allocate the returned vector. */
n_alloc = 20;
/* if caller did not specify max tokens to find, set to more than
* there will possibly ever be */
}
else tokens = local_tokens;
i = 0; /* index into vector */
tokens[0] = s; /* s already points to 1st token */
while (i<maxnt) {
quote = (*s == '\007');
if ( quote ) s++; /* skip quote */
tokens[i] = s; /* point vector member at start of token */
i++;
/* If we allocated vector, see if we need more space. */
n_alloc += 20;
}
if (i >= maxnt) break; /* is this the last one? */
if ( *s && quote ) {
*s = EOS;
s++;
}
if (*s == EOS) break; /* at end of input string? */
if (*s) *s++ = EOS; /* terminate token string */
while (*s && IsWhite(*s)) s++; /* skip space - to next token */
}
tokens[i] = 0; /* null-terminate vector */
return tokens;
}
/* ______________________________________________________________________ */
/* Mapping routines. These are used for name-value pairs, like attributes,
* variables, and counters. A "Map" is an opaque data structure used
* internally by these routines. The caller gets one when creating a new
* map, then hands it to other routines that need it. A "Mapping" is a
* Here's some sample usage:
*
* Map *V;
* V = NewMap(20);
* printf("Home: %s\n", FindMappingVal(V, "home");
*/
* Arg:
* Number of initial slots to allocate space for. This is also the
* "chunk size" - how much to allocate when we use up the given space.
* Return:
* Pointer to the (opaque) map structure. (User passes this to other
* mapping routines.)
*/
Map_t *
int slot_increment
)
{
Map_t *M;
macros, but that will have to wait until time permits -CSS */
M->slot_incr = slot_increment;
return M;
}
/* Given pointer to a Map and a name, find the mapping.
* Arguments:
* Pointer to map structure (as returned by NewMap().
* Variable name.
* Return:
* Pointer to the matching mapping structure, or null if not found.
*/
Map_t *M,
char *name
)
{
int i;
Mapping_t *m;
return NULL;
}
/* Given pointer to a Map and a name, return string value of the mapping.
* Arguments:
* Pointer to map structure (as returned by NewMap().
* Variable name.
* Return:
* Pointer to the value (string), or null if not found.
*/
char *
Map_t *M,
char *name
)
{
Mapping_t *m;
return Get_A_C_value(name);
}
/*
if (!M || M->n_used == 0) return NULL;
if ((m = FindMapping(M, name))) return m->sval;
return NULL;
*/
if (!M || M->n_used == 0) {
return NULL;
}
if ((m = FindMapping(M, name))) {
return m->sval;
}
return NULL;
}
* there is some amount of space after the name. The correct mapping is done.
* Arguments:
* Pointer to map structure (as returned by NewMap().
* Pointer to variable name (string).
* Pointer to variable value (string).
*/
void
Map_t *M,
char *name,
char *value
)
{
int i;
Mapping_t *m;
/* First, look to see if it's a "well-known" variable. */
/* OK, we have a string mapping */
if (m) { /* exists - just replace value */
}
else {
if (name) { /* just in case */
/* Need more slots for mapping structures? Allocate in clumps. */
if (M->n_used == 0) {
}
}
M->n_used++;
}
}
if (value)
{
/* See if the value is a command to run. If so, run the command
* and replace the value with the output.
*/
s = value;
if (*s == '!') {
s++; /* point to command */
i = 0;
if (i >= LINESIZE) {
"Prog execution of variable '%s' too long.\n",
m->name);
break;
}
}
}
else {
}
}
}
}
/* Separate name and value from input string, then pass to SetMappingNV.
* Arguments:
* Pointer to map structure (as returned by NewMap().
* Pointer to variable name and value (string), in form "name value".
*/
void
Map_t *M,
char *s
)
{
if (!M) {
return;
}
if (*val) {
}
}
/* ______________________________________________________________________ */
/* Opens a file for reading. If not found in current directory, try
* lib directories (from TPT_LIB env variable, or -l option).
* Arguments:
* Filename (string).
* Return:
* FILE pointer to open file, or null if it not found or can't open.
*/
FILE *
char *filename
)
{
int i;
static char **libdirs;
static int nlibdirs = -1;
if (nlibdirs < 0) {
char *cp, *s;
if (tpt_lib) {
nlibdirs = 0;
}
else nlibdirs = 0;
}
for (i=0; i<nlibdirs; i++) {
}
return NULL;
}
/* ______________________________________________________________________ */
/* This will find the path to an tag. The format is the:
* tag1(n1):tag2(n2):tag3
* where the tags are going down the tree and the numbers indicate which
* child (the first is numbered 1) the next tag is.
* Returns pointer to the string just written to (so you can use this
* function as a printf arg).
* Arguments:
* Pointer to element under consideration.
* String to write path into (provided by caller).
* Return:
* Pointer to the provided string (for convenience of caller).
*/
char *
Element_t *e,
char *s
)
{
char *cp;
/* Move up the tree, noting "birth order" of each element encountered */
/* Move down the tree, printing the element names to the string. */
}
return s;
}
/* ______________________________________________________________________ */
/* Print some location info about a tag. Helps user locate error.
* Messages are indented 2 spaces (convention for multi-line messages).
* Arguments:
* Pointer to element under consideration.
* FILE pointer of where to print.
*/
void
Element_t *e,
)
{
if (!e || !fp) return;
if ((s=NearestOlderElem(e, "TITLE")))
if (e->lineno) {
if (e->infile)
else
}
if (e->id)
}
/* ______________________________________________________________________ */
/* Finds the data part of the nearest "older" tag (up the tree, and
* preceding) whose tag name matches the argument, or "TITLE", if null.
* Returns a pointer to the first chunk of character data.
* Arguments:
* Pointer to element under consideration.
* Name (GI) of element we'll return data from.
* Return:
* Pointer to that element's data content.
*/
char *
Element_t *e,
char *name
)
{
int i;
if (!e) return 0;
for (i=0; i<=e->my_eorder; i++) { /* check preceding sibs */
}
return NULL;
}
/* ______________________________________________________________________ */
/* Expands escaped strings in the input buffer (things like tabs, newlines,
* octal characters - using C style escapes) and outputs buffer to specified
* beginning of a line. The cursor position is kept track of (optionally)
* so that this can be done.
* Arguments:
* Pointer to element under consideration.
* FILE pointer of where to print.
* Flag saying whether or not to keep track of our position in the output
* stream. (We want to when writing to a file, but not for stderr.)
*/
void
char *s,
int track_pos
)
{
int i;
static int char_pos; /* remembers our character position */
if (!fp) return;
if (!s) s = ""; /* no string - go to start of line */
for ( ; *s; s++) {
if (*s == '\\') {
s++;
switch (*s) {
default: c = *s; break;
case 's': c = ' '; break;
case 't': c = TAB; break;
case '0': case '1': case '2': case '3':
case '4': case '5': case '6': case '7':
/* for octal numbers (C style) of the form \012 */
c = *s - '0';
for (i=1, s++; ((*s >= '0') && (*s <= '7')
&& (i <= 2) ); s++, i++)
c = (c << 3) + (*s - '0');
s--;
break;
case '|': /* SDATA */
s++; /* point past \| */
sdata = s;
cp = s;
if (!*cp) break;
cp++;
s = cp; /* s now points to | */
else {
/* not found - output sdata thing in brackets */
}
c = 0;
break;
}
}
else { /* not escaped - just pass the character */
c = *s;
/* If caller wants us to track position, see if it's an anchor
* (ie, align at a newline). */
if (track_pos) {
if (c == ANCHOR) {
/* If we're already at the start of a line, don't do
* another newline. */
else c = 0;
}
else char_pos++;
}
}
}
}
/* ______________________________________________________________________ */
/* Figure out value of SDATA entity.
* We rememeber lookup hits in a "cache" (a shorter list), and look in
* cache before general list. Typically there will be LOTS of entries
* in the general list and only a handful in the hit list. Often, if an
* entity is used once, it'll be used again.
* Arguments:
* Pointer to SDATA entity token in ESIS.
* Return:
* Mapped value of the SDATA entity.
*/
static char *
char *s
)
{
char *v;
/* If we have a hit list, check it. */
if (Hits) {
if ((v = FindMappingVal(Hits, s))) return v;
}
v = FindMappingVal(SDATAmap, s);
/* If mapping found, remember it, then return it. */
if ((v = FindMappingVal(SDATAmap, s))) {
SetMappingNV(Hits, s, v);
return v;
}
return NULL;
}
/* ______________________________________________________________________ */
/* Add tag 'name' of length 'len' to list of tag names (if not there).
* This is a list of null-terminated strings so that we don't have to
* keep using the name length.
* Arguments:
* Pointer to element name (GI) to remember.
* Return:
* Pointer to the SAVED element name (GI).
*/
char *
char *name
)
{
int i;
static int n_alloc=0; /* number of slots allocated so far */
/* See if it's already in the list. */
for (i=0; i<nUsedElem; i++)
return UsedElem[i];
/* Allocate slots in blocks of N, so we don't have to call malloc
* so many times. */
if (n_alloc == 0) {
}
n_alloc += IMS_elemnames;
}
}
/* ______________________________________________________________________ */
/* Add attrib name to list of attrib names (if not there).
* This is a list of null-terminated strings so that we don't have to
* keep using the name length.
* Arguments:
* Pointer to attr name to remember.
* Return:
* Pointer to the SAVED attr name.
*/
char *
char *name
)
{
int i;
static int n_alloc=0; /* number of slots allocated so far */
/* See if it's already in the list. */
for (i=0; i<nUsedAtt; i++)
return UsedAtt[i];
/* Allocate slots in blocks of N, so we don't have to call malloc
* so many times. */
if (n_alloc == 0) {
}
n_alloc += IMS_attnames;
}
}
/* ______________________________________________________________________ */
/* Find an element's attribute value given element pointer and attr name.
* Typical use:
* a=FindAttByName("TYPE", t);
* do something with a->val;
* Arguments:
* Pointer to element under consideration.
* Pointer to attribute name.
* Return:
* Pointer to the value of the attribute.
*/
/*
Mapping_t *
FindAttByName(
Element_t *e,
char *name
)
{
int i;
if (!e) return NULL;
for (i=0; i<e->natts; i++)
if (e->atts[i].name[0] == name[0] && !strcmp(e->atts[i].name, name))
return &(e->atts[i]);
return NULL;
}
*/
char *
Element_t *e,
char *name
)
{
int i;
if (!e) return NULL;
for (i=0; i<e->natts; i++)
return NULL;
}
/* ______________________________________________________________________ */
/* Find context of a tag, 'levels' levels up the tree.
* Space for string is passed by caller.
* Arguments:
* Pointer to element under consideration.
* Number of levels to look up tree.
* String to write path into (provided by caller).
* Return:
* Pointer to the provided string (for convenience of caller).
*/
char *
Element_t *e,
int levels,
char *con
)
{
char *s;
int i;
if (!e) return NULL;
s = con;
*s = EOS;
if (i != 0) *s++ = ' ';
s += strlen(s);
}
return con;
}
/* ______________________________________________________________________ */
* (structure pointer) and named element.
* Returns pointer to matching tag if found, null otherwise.
* Arguments:
* Pointer to element under consideration.
* Pointer to name of elem whose relationsip we are trying to determine.
* Relationship we are testing.
* Return:
* Pointer to the provided string (for convenience of caller).
*/
Element_t *e,
char *s,
)
{
int i;
if (!e) return 0;
/* we'll call e the "given element" */
switch (rel)
{
case REL_Parent:
break;
case REL_Child:
for (i=0; i<e->necont; i++)
break;
case REL_Ancestor:
break;
case REL_Descendant:
if (e->necont == 0) return 0;
/* check immediate children first */
for (i=0; i<e->necont; i++)
/* then children's children (recursively) */
for (i=0; i<e->necont; i++)
return ep;
break;
case REL_Sibling:
if (!e->parent) return 0;
break;
case REL_Preceding:
for (i=0; i<e->my_eorder; i++)
break;
case REL_ImmPreceding:
break;
case REL_Following:
return 0; /* last? */
break;
case REL_ImmFollowing:
return 0; /* last? */
break;
case REL_Cousin:
if (!e->parent) return 0;
/* Now, see if element's parent has that thing as a child. */
break;
case REL_None:
case REL_Unknown:
break;
}
return NULL;
}
/* Given a relationship name (string), determine enum symbol for it.
* Arguments:
* Pointer to relationship name.
* Return:
* Relation_t enum.
*/
char *relname
)
{
"child, parent, ancestor, descendant,",
"sibling, sibling+, sibling+1, sibling-, sibling-1");
return REL_None;
}
return REL_Unknown;
}
/* ______________________________________________________________________ */
/* This will descend the element tree in-order. (enter_f)() is called
* upon entering the node. Then all children (data and child elements)
* are operated on, calling either DescendTree() with a pointer to
* the child element or (data_f)() for each non-element child node.
* Before leaving the node (ascending), (leave_f)() is called. enter_f
* and leave_f are passed a pointer to this node and data_f is passed
* type information). dp is an opaque pointer to any data the caller
* wants to pass.
* Arguments:
* Pointer to element under consideration.
* Pointer to procedure to call when entering element.
* Pointer to procedure to call when leaving element.
* Pointer to procedure to call for each "chunk" of content data.
* Void data pointer, passed to the avobe 3 procedures.
*/
void
Element_t *e,
void (*enter_f)(),
void (*leave_f)(),
void (*data_f)(),
void *dp
)
{
int i;
for (i=0; i<e->ncont; i++) {
else
}
}
/* ______________________________________________________________________ */
/* Add element, 'e', whose ID is 'idval', to a list of IDs.
* This makes it easier to find an element by ID later.
* Arguments:
* Pointer to element under consideration.
* Element's ID attribute value (a string).
*/
void
Element_t *e,
char *idval
)
{
if (!IDList) {
}
else {
}
}
/* ______________________________________________________________________ */
/* Return pointer to element who's ID is given.
* Arguments:
* Element's ID attribute value (a string).
* Return:
* Pointer to element whose ID matches.
*/
char *idval
)
{
return 0;
}
/* ______________________________________________________________________ */
#ifndef linux
char *
{
char buf[100];
}
#endif