mirror of
https://github.com/antoinevignau/source.git
synced 2024-08-10 23:29:08 +00:00
1 line
4.6 KiB
C++
1 line
4.6 KiB
C++
|
/***********************************************************************\
Filename: spath.c
\***********************************************************************/
#include <language.h>
#include "corelex.h"
#include "cache.h"
#include "clam.h"
#include "lex.h"
#include "spath.h"
#include "environ.h"
/* These routines are used to manipulate the Searchpath. */
SPENTRY *Srchend = Srchpath; /* end of the SP array */
SPENTRY Srchpath[SRCHMAXSIZE]; /* The wordlists to search */
/* Add a new entry to the Searchpath. Return TRUE if added.
The order in which routines like clamopen() and lexopen() are called
forces the order in which the wordlists are searched, since pathadd()
simply puts their structures sequentially into the Searchpath.
Multiple environments are allowed in the Searchpath, but calling programs
are restricted to one environment at a time. */
static int
pathadd(flags, idcode, type, errcode, access)
int flags; /* Searchpath control flags */
int idcode; /* Searchpath entry identifier */
int type; /* associated wordlist type (IW_LEX, etc.) */
int errcode; /* Error code for placing in Scerror. */
char *access; /* Wordlist ptr */
{
SPENTRY *addptr; /* pointer into the searchpath */
/* Special case: if opened with no flags then do not add the
wordlist to the searchpath. */
if (flags == 0)
return (TRUE);
/* make sure there is room in the Searchpath array and that a proper
environment has been set. */
if (Srchend == &Srchpath[SRCHMAXSIZE])
{
Scerror = errcode | ERR_PATH;
return (FALSE);
}
/* put the new entry in the next available slot */
addptr = Srchend;
addptr->sp_type = type;
addptr->sp_flags = flags & SP_MASK;
addptr->sp_idcode = idcode;
addptr->sp_access = access;
++Srchend;
return (TRUE);
}
/* Remove the wordlist entry at 'access' from the Searchpath. Move all the
other entries up.
The entries in the searchpath are located by using their 'sp_access'
fields. This field typically points to a structure that is used while
accessing the wordlist, and must be unique to each word list. */
static void pathdel(access)
char *access; /* the entry to delete */
{
SPENTRY *delptr; /* pointer into the searchpath */
/* Locate the structure pointer in the Searchpath, then move the
entries which are past it up one entry. */
delptr = Srchend;
while (--delptr >= Srchpath) {
if (delptr->sp_access == access) {
--Srchend;
scmove(delptr, delptr + 1,
sizeof(SPENTRY) * (Srchend - delptr));
return;
}
}
/* The structure was not found, so do nothing. */
}
/* Pairs of routines for each type of word list, one open routine and one
close routine. The open routines verify that the word list can be added
to the Searchpath, allocate the word list, and return a pointer to the
allocaed word list. The close routines free the word list and remove it
from the Searchpath. */
CLAM *clamopen(idcode, flags, fname, ftype, atype)
int idcode; /* Identifier for this word list */
int flags; /* Searchpath flags */
char *fname; /* File name */
int ftype; /* If CL_INIT, new file type */
long atype; /* If CL_INIT, new file auxtype */
{
extern CLAM *clamalloc();
CLAM *cp;
if (!(cp = clamalloc(fname, flags, ftype, atype)))
return(NULL);
if (!pathadd(flags, idcode, IW_CLAM >> 8, ERR_CLAM, cp))
return (NULL);
return(cp);
}
void clamclose(cp)
CLAM *cp;
{
extern void clamfree();
clamfree(cp);
pathdel((char *) cp);
}
clxopen(idcode, flags)
int idcode; /* Identifier for this word list */
int flags; /* Searchpath flags */
{
extern clxalloc();
return(pathadd(flags, idcode, IW_CORELEX >
|