Jeffrey A Law
Jeff Law
parent
4f71d8e4e7
commit
2fa6b2d2ad
|
|
@ -1,3 +1,7 @@
|
|||
Fri Apr 2 16:09:02 1999 Jeffrey A Law (law@cygnus.com)
|
||||
|
||||
* fixinc/*: Delete obsolete files.
|
||||
|
||||
1999-02-04 Robert Lipe <robertlipe@usa.net>
|
||||
|
||||
* egcs_update: Test return values of 'cvs update'. Propogate
|
||||
|
|
|
|||
|
|
@ -1,81 +0,0 @@
|
|||
|
||||
## # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
|
||||
##
|
||||
## Makefile for constructing the "best" include fixer we can
|
||||
##
|
||||
## $Id: Makefile,v 1.4 1998/08/05 10:20:10 korbb Exp $
|
||||
##
|
||||
## # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
|
||||
|
||||
OBJ = fixincl.o server.o regex.o
|
||||
HDR = server.h regex.h
|
||||
## LIB = -lgen
|
||||
SH_TARGET = inclhack.sh fixincl.sh
|
||||
BIN_TARGET = fixincl
|
||||
AG_TEXT = $(SH_TARGET) fixincl.x \
|
||||
inclhack.def inclhack.tpl hackshell.tpl fixincl.tpl
|
||||
TARGETS = $(SH_TARGET) $(BIN_TARGET)
|
||||
|
||||
default : gen
|
||||
|
||||
all : $(TARGETS)
|
||||
sh : $(SH_TARGET)
|
||||
gen : $(SH_TARGET) fixincl.x
|
||||
|
||||
$(OBJ): $(HDR)
|
||||
|
||||
fixincl: $(OBJ)
|
||||
@echo $(CC) -o $@ $(OBJ) $(LIB) ; \
|
||||
if $(CC) -o $@ $(OBJ) $(LIB) ; then : ; else \
|
||||
rm -f $@ ; (echo "#! /bin/sh" ; echo exit 1 ) > $@ ; \
|
||||
chmod 777 $@ ; fi
|
||||
|
||||
regex.o: regex.c
|
||||
-$(CC) -g -DSTDC_HEADERS=1 -c regex.c
|
||||
|
||||
fixincl.o : fixincl.x fixincl.c
|
||||
-$(CC) $(CFLAGS) '-DTARGET_MACHINE="$(TARGET)"' -o $@ -c fixincl.c
|
||||
|
||||
server.o : server.c server.h
|
||||
-$(CC) $(CFLAGS) -o $@ -c server.c
|
||||
|
||||
fixincl.x: fixincl.tpl inclhack.def
|
||||
@if ( autogen --help > /dev/null 2>&1 ) ; then \
|
||||
echo autogen -T fixincl.tpl -b fixincl inclhack.def ; \
|
||||
autogen -T fixincl.tpl -b fixincl inclhack.def ; \
|
||||
else echo You need to install autogen ; touch $@ ; fi
|
||||
|
||||
inclhack.sh: inclhack.def inclhack.tpl hackshell.tpl
|
||||
@if ( autogen --help > /dev/null 2>&1 ) ; then \
|
||||
echo autogen inclhack.def ; \
|
||||
autogen inclhack.def ; \
|
||||
else echo You need to install autogen ; touch $@ ; fi
|
||||
|
||||
fixincl.sh: inclhack.def inclhack.tpl
|
||||
@if ( autogen --help > /dev/null 2>&1 ) ; then \
|
||||
echo autogen -DPROGRAM=1 -b fixincl inclhack.def ; \
|
||||
autogen -DPROGRAM=1 -b fixincl inclhack.def ; touch $@ ; \
|
||||
else echo You need to install autogen ; touch $@ ; fi ; \
|
||||
|
||||
clean:
|
||||
rm -f *.o $(TARGETS) fixincl.x
|
||||
|
||||
# Ensure all the targets are built. If the program "fixincl"
|
||||
# failed to compile, link or load, then we install the
|
||||
# "inclhack.sh" script. Otherwise, we install that program
|
||||
# plus the wrapper script, "fixincl.sh".
|
||||
#
|
||||
install: $(TARGETS)
|
||||
@rm -f $(DESTDIR)/fixinc.sh ; \
|
||||
if ( ./fixincl -v > /dev/null 2>&1 ) ; then \
|
||||
echo cp fixincl.sh $(DESTDIR)/fixinc.sh ; \
|
||||
cp fixincl.sh $(DESTDIR)/fixinc.sh ; \
|
||||
chmod 555 $(DESTDIR)/fixinc.sh ; \
|
||||
rm -f $(DESTDIR)/fixincl ; \
|
||||
echo cp fixincl $(DESTDIR) ; \
|
||||
cp fixincl $(DESTDIR) ; \
|
||||
chmod 555 $(DESTDIR)/fixincl ; \
|
||||
else \
|
||||
echo cp inclhack.sh $(DESTDIR)/fixinc.sh ; \
|
||||
cp inclhack.sh $(DESTDIR)/fixinc.sh ; \
|
||||
fi
|
||||
|
|
@ -1,810 +0,0 @@
|
|||
/*
|
||||
* $Id: fixincl.c,v 1.4 1998/08/05 10:20:11 korbb Exp $
|
||||
*
|
||||
* Install modified versions of certain ANSI-incompatible system header
|
||||
* files which are fixed to work correctly with ANSI C and placed in a
|
||||
* directory that GNU C will search.
|
||||
*
|
||||
* See README-fixinc for more information.
|
||||
*
|
||||
* fixincl is free software.
|
||||
*
|
||||
* You may redistribute it and/or modify it under the terms of the
|
||||
* GNU General Public License, as published by the Free Software
|
||||
* Foundation; either version 2, or (at your option) any later version.
|
||||
*
|
||||
* fixincl is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
||||
* See the GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with fixincl. See the file "COPYING". If not,
|
||||
* write to: The Free Software Foundation, Inc.,
|
||||
* 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
*/
|
||||
|
||||
#include <sys/param.h>
|
||||
#include <sys/stat.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/wait.h>
|
||||
#include <signal.h>
|
||||
#include <stdio.h>
|
||||
#include <unistd.h>
|
||||
#include <stdlib.h>
|
||||
#include <errno.h>
|
||||
#include <string.h>
|
||||
#include <fcntl.h>
|
||||
#include <ctype.h>
|
||||
|
||||
#include "regex.h"
|
||||
#include "server.h"
|
||||
|
||||
#define tSCC static const char
|
||||
#define tCC const char
|
||||
#define tSC static char
|
||||
|
||||
typedef int tSuccess;
|
||||
|
||||
#define FAILURE ((tSuccess)-1)
|
||||
#define SUCCESS ((tSuccess) 0)
|
||||
#define PROBLEM ((tSuccess) 1)
|
||||
|
||||
#define SUCCEEDED( p ) ((p) == SUCCESS)
|
||||
#define SUCCESSFUL( p ) SUCCEEDED( p )
|
||||
#define FAILED( p ) ((p) < SUCCESS)
|
||||
#define HADGLITCH( p ) ((p) > SUCCESS)
|
||||
|
||||
#define NUL '\0'
|
||||
|
||||
typedef enum
|
||||
{
|
||||
TT_TEST, TT_EGREP, TT_NEGREP
|
||||
}
|
||||
teTestType;
|
||||
|
||||
typedef struct test_desc tTestDesc;
|
||||
|
||||
struct test_desc
|
||||
{
|
||||
teTestType type;
|
||||
const char *pzTest;
|
||||
regex_t *pTestRegex;
|
||||
};
|
||||
|
||||
typedef struct patch_desc tPatchDesc;
|
||||
|
||||
#define FD_MACH_ONLY 0x0000
|
||||
#define FD_MACH_IFNOT 0x0001
|
||||
#define FD_SKIP_TEST 0x8000
|
||||
|
||||
typedef struct fix_desc tFixDesc;
|
||||
struct fix_desc
|
||||
{
|
||||
const char* pzFixName; /* Name of the fix */
|
||||
const char* pzFileList; /* List of files it applies to */
|
||||
const char** papzMachs; /* List of machine/os-es it applies to */
|
||||
regex_t* pListRegex;
|
||||
int testCt;
|
||||
int fdFlags;
|
||||
tTestDesc* pTestDesc;
|
||||
const char** papzPatchArgs;
|
||||
};
|
||||
|
||||
char *pzDestDir = (char *) NULL;
|
||||
char *pzSrcDir = (char *) NULL;
|
||||
char zMachine[] = TARGET_MACHINE;
|
||||
|
||||
pid_t chainHead = (pid_t) - 1;
|
||||
|
||||
const char zInclQuote[] = "^[ \t]*#[ \t]*include[ \t]*\"[^/]";
|
||||
regex_t inclQuoteRegex;
|
||||
|
||||
char zFileNameBuf[0x8000];
|
||||
|
||||
char *loadFile (const char *pzFile);
|
||||
void process (char *data, const char *dir, const char *file);
|
||||
void runCompiles (void);
|
||||
|
||||
#include "fixincl.x"
|
||||
|
||||
|
||||
int
|
||||
main (argc, argv)
|
||||
int argc;
|
||||
char **argv;
|
||||
{
|
||||
static const char zGnuLib[] =
|
||||
"This file is part of the GNU C Library";
|
||||
|
||||
#ifndef NO_BOGOSITY_LIMITS
|
||||
size_t loopCt;
|
||||
#endif
|
||||
|
||||
char *apzNames[128];
|
||||
size_t fileNameCt;
|
||||
|
||||
if (argc != 1)
|
||||
{
|
||||
if (argc != 2)
|
||||
{
|
||||
fputs ("fixincl ERROR: files specified on command line (not stdin)\n",
|
||||
stderr);
|
||||
exit (EXIT_FAILURE);
|
||||
}
|
||||
|
||||
if (strcmp (argv[1], "-v") == 0)
|
||||
{
|
||||
fputs ("$Id: fixincl.c,v 1.4 1998/08/05 10:20:11 korbb Exp $\n", stderr);
|
||||
exit (EXIT_SUCCESS);
|
||||
}
|
||||
|
||||
freopen (argv[1], "r", stdin);
|
||||
}
|
||||
|
||||
pzDestDir = getenv ("DESTDIR");
|
||||
if (pzDestDir == (char *) NULL)
|
||||
{
|
||||
fprintf (stderr, "fixincl ERROR: %s cannot find destination dir\n"
|
||||
"\t(`DESTDIR' must be an environment variable)\n", *argv);
|
||||
exit (EXIT_FAILURE);
|
||||
}
|
||||
|
||||
pzSrcDir = getenv ("SRCDIR");
|
||||
if (pzSrcDir == (char *) NULL)
|
||||
{
|
||||
fprintf (stderr, "fixincl ERROR: %s cannot find source dir\n"
|
||||
"\t(`SRCDIR' must be an environment variable)\n", *argv);
|
||||
exit (EXIT_FAILURE);
|
||||
}
|
||||
|
||||
runCompiles ();
|
||||
|
||||
#ifndef NO_BOGOSITY_LIMITS
|
||||
for (;;)
|
||||
{
|
||||
char *pzBuf;
|
||||
pid_t child;
|
||||
|
||||
/*
|
||||
* Only the parent process can read from stdin without
|
||||
* confusing the world. (How does the child tell the
|
||||
* parent to skip forward? Pipes and files behave differently.)
|
||||
*/
|
||||
for (fileNameCt = 0, pzBuf = zFileNameBuf;
|
||||
(fileNameCt < 128)
|
||||
&& (pzBuf
|
||||
< (zFileNameBuf + sizeof (zFileNameBuf) - MAXPATHLEN));
|
||||
)
|
||||
{
|
||||
|
||||
if (fgets (pzBuf, MAXPATHLEN, stdin) == (char *) NULL)
|
||||
break;
|
||||
while (isspace (*pzBuf))
|
||||
pzBuf++;
|
||||
apzNames[fileNameCt++] = pzBuf;
|
||||
pzBuf += strlen (pzBuf);
|
||||
while (isspace (pzBuf[-1]))
|
||||
pzBuf--;
|
||||
*pzBuf++ = '\0';
|
||||
}
|
||||
|
||||
if (fileNameCt == 0)
|
||||
return EXIT_SUCCESS;
|
||||
|
||||
child = fork ();
|
||||
if (child == NULLPROCESS)
|
||||
break;
|
||||
|
||||
if (child == NOPROCESS)
|
||||
{
|
||||
fprintf (stderr, "Error %d (%s) forking in main\n",
|
||||
errno, strerror (errno));
|
||||
exit (EXIT_FAILURE);
|
||||
}
|
||||
|
||||
waitpid (child, (int *) NULL, 0);
|
||||
}
|
||||
#else
|
||||
#error "NON-BOGUS LIMITS NOT SUPPORTED?!?!"
|
||||
#endif
|
||||
|
||||
/*
|
||||
* For every file specified in stdandard in
|
||||
* (except as throttled for bogus reasons)...
|
||||
*/
|
||||
for (loopCt = 0; loopCt < fileNameCt; loopCt++)
|
||||
{
|
||||
char *pzData;
|
||||
char *pzFile = apzNames[loopCt];
|
||||
|
||||
if (access (pzFile, R_OK) != 0)
|
||||
{
|
||||
int erno = errno;
|
||||
fprintf (stderr, "Cannot access %s from %s\n\terror %d (%s)\n",
|
||||
pzFile, getcwd ((char *) NULL, MAXPATHLEN),
|
||||
erno, strerror (erno));
|
||||
}
|
||||
else if (pzData = loadFile (pzFile),
|
||||
(pzData != (char *) NULL))
|
||||
{
|
||||
|
||||
if (strstr (pzData, zGnuLib) == (char *) NULL)
|
||||
process (pzData, pzDestDir, pzFile);
|
||||
|
||||
free ((void *) pzData);
|
||||
}
|
||||
}
|
||||
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
char *
|
||||
loadFile (pzFile)
|
||||
const char *pzFile;
|
||||
{
|
||||
char *pzDta;
|
||||
size_t fileSize;
|
||||
|
||||
{
|
||||
struct stat stbf;
|
||||
if (stat (pzFile, &stbf) != 0)
|
||||
{
|
||||
fprintf (stderr, "error %d (%s) stat-ing %s\n",
|
||||
errno, strerror (errno), pzFile);
|
||||
return (char *) NULL;
|
||||
}
|
||||
fileSize = stbf.st_size;
|
||||
}
|
||||
if (fileSize == 0)
|
||||
return (char *) NULL;
|
||||
|
||||
pzDta = (char *) malloc ((fileSize + 16) & ~0x00F);
|
||||
if (pzDta == (char *) NULL)
|
||||
{
|
||||
fprintf (stderr, "error: could not malloc %d bytes\n",
|
||||
fileSize);
|
||||
exit (EXIT_FAILURE);
|
||||
}
|
||||
|
||||
{
|
||||
FILE *fp = fopen (pzFile, "r");
|
||||
size_t sizeLeft = fileSize;
|
||||
char *readPtr = pzDta;
|
||||
|
||||
if (fp == (FILE *) NULL)
|
||||
{
|
||||
fprintf (stderr, "error %d (%s) opening %s\n", errno,
|
||||
strerror (errno), pzFile);
|
||||
free ((void *) pzDta);
|
||||
return (char *) NULL;
|
||||
}
|
||||
|
||||
do
|
||||
{
|
||||
size_t sizeRead = fread ((void *) readPtr, 1, sizeLeft, fp);
|
||||
|
||||
if (sizeRead == 0)
|
||||
{
|
||||
if (feof (fp))
|
||||
break;
|
||||
|
||||
if (ferror (fp))
|
||||
{
|
||||
fprintf (stderr, "error %d (%s) reading %s\n", errno,
|
||||
strerror (errno), pzFile);
|
||||
free ((void *) pzDta);
|
||||
fclose (fp);
|
||||
return (char *) NULL;
|
||||
}
|
||||
}
|
||||
|
||||
readPtr += sizeRead;
|
||||
sizeLeft -= sizeRead;
|
||||
}
|
||||
while (sizeLeft != 0);
|
||||
|
||||
*readPtr = '\0';
|
||||
fclose (fp);
|
||||
return pzDta;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
runCompiles ()
|
||||
{
|
||||
tSCC zBadComp[] = "fixincl ERROR: cannot compile %s regex for %s\n"
|
||||
"\texpr = `%s'\n" "\terror %s\n";
|
||||
tFixDesc *pFD = fixDescList;
|
||||
int fixCt = FIX_COUNT;
|
||||
tTestDesc *pTD;
|
||||
int tstCt;
|
||||
int reCt = REGEX_COUNT;
|
||||
const char *pzErr;
|
||||
regex_t *pRegex = (regex_t *) malloc (REGEX_COUNT * sizeof (regex_t));
|
||||
|
||||
if (pRegex == (regex_t *) NULL)
|
||||
{
|
||||
fprintf (stderr, "fixincl ERROR: cannot allocate %d bytes for regex\n",
|
||||
REGEX_COUNT * sizeof (regex_t));
|
||||
exit (EXIT_FAILURE);
|
||||
}
|
||||
|
||||
re_set_syntax (RE_SYNTAX_EGREP);
|
||||
pzErr = re_compile_pattern (zInclQuote, strlen (zInclQuote),
|
||||
&inclQuoteRegex);
|
||||
if (pzErr != (char *) NULL)
|
||||
{
|
||||
fprintf (stderr, zBadComp, "quoted include", "runCompiles",
|
||||
zInclQuote, pzErr);
|
||||
exit (EXIT_FAILURE);
|
||||
}
|
||||
|
||||
/*
|
||||
* FOR every fixup, ...
|
||||
*/
|
||||
do
|
||||
{
|
||||
pTD = pFD->pTestDesc;
|
||||
tstCt = pFD->testCt;
|
||||
|
||||
if (pFD->papzMachs != (const char**)NULL) {
|
||||
const char** papzMachs = pFD->papzMachs;
|
||||
char* pz = zFileNameBuf;
|
||||
char* pzSep = "";
|
||||
tCC* pzIfTrue;
|
||||
tCC* pzIfFalse;
|
||||
tSCC zSkip[] = "skip";
|
||||
tSCC zRun[] = "run";
|
||||
|
||||
sprintf( pz, "case %s in\n", zMachine );
|
||||
pz += strlen( pz );
|
||||
|
||||
if (pFD->fdFlags & FD_MACH_IFNOT) {
|
||||
pzIfTrue = zSkip;
|
||||
pzIfFalse = zRun;
|
||||
} else {
|
||||
pzIfTrue = zRun;
|
||||
pzIfFalse = zSkip;
|
||||
}
|
||||
|
||||
for (;;) {
|
||||
const char* pzMach = *(papzMachs++);
|
||||
if (pzMach == (const char*)NULL)
|
||||
break;
|
||||
sprintf( pz, "%s %s", pzSep, pzMach );
|
||||
pz += strlen( pz );
|
||||
pzSep = " | \\\n";
|
||||
}
|
||||
sprintf( pz, " )\n echo %s ;;\n * )\n echo %s ;;\nesac",
|
||||
pzIfTrue, pzIfFalse );
|
||||
pz = runShell( zFileNameBuf );
|
||||
if (*pz == 's') {
|
||||
pFD->fdFlags |= FD_SKIP_TEST;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* FOR every test for the fixup, ...
|
||||
*/
|
||||
while (--tstCt >= 0)
|
||||
{
|
||||
switch (pTD->type)
|
||||
{
|
||||
case TT_EGREP:
|
||||
case TT_NEGREP:
|
||||
if (--reCt < 0)
|
||||
{
|
||||
fputs ("out of RE's\n", stderr);
|
||||
exit (EXIT_FAILURE);
|
||||
}
|
||||
|
||||
pTD->pTestRegex = pRegex++;
|
||||
pzErr = re_compile_pattern (pTD->pzTest,
|
||||
strlen (pTD->pzTest),
|
||||
pTD->pTestRegex);
|
||||
if (pzErr != (char *) NULL)
|
||||
{
|
||||
fprintf (stderr, zBadComp, "select test", pFD->pzFixName,
|
||||
pTD->pzTest, pzErr);
|
||||
exit (EXIT_FAILURE);
|
||||
}
|
||||
}
|
||||
pTD++;
|
||||
}
|
||||
}
|
||||
while (pFD++, --fixCt > 0);
|
||||
}
|
||||
|
||||
|
||||
FILE *
|
||||
createFile (pzFile)
|
||||
const char *pzFile;
|
||||
{
|
||||
int fd;
|
||||
FILE *pf;
|
||||
char fname[MAXPATHLEN];
|
||||
|
||||
sprintf (fname, "%s/%s", pzDestDir, pzFile);
|
||||
unlink (fname);
|
||||
|
||||
fd = open (fname, O_WRONLY | O_CREAT);
|
||||
|
||||
if ((fd < 0) && (errno == ENOENT))
|
||||
{
|
||||
char *pzDir = strchr (fname + 1, '/');
|
||||
struct stat stbf;
|
||||
|
||||
while (pzDir != (char *) NULL)
|
||||
{
|
||||
*pzDir = NUL;
|
||||
if (stat (fname, &stbf) < 0)
|
||||
{
|
||||
mkdir (fname, S_IFDIR | S_IRWXU | S_IRGRP | S_IXGRP
|
||||
| S_IROTH | S_IXOTH);
|
||||
}
|
||||
|
||||
*pzDir = '/';
|
||||
pzDir = strchr (pzDir + 1, '/');
|
||||
}
|
||||
fd = open (fname, O_WRONLY | O_CREAT);
|
||||
}
|
||||
if (fd < 0)
|
||||
{
|
||||
fprintf (stderr, "Error %d (%s) creating %s\n",
|
||||
errno, strerror (errno), fname);
|
||||
exit (EXIT_FAILURE);
|
||||
}
|
||||
fprintf (stderr, "Fixed: %s\n", pzFile);
|
||||
pf = fdopen (fd, "w");
|
||||
|
||||
#ifdef LATER
|
||||
{
|
||||
static const char zHdr[] =
|
||||
"/*\n"
|
||||
" * DO NOT EDIT THIS FILE.\n"
|
||||
" *\n"
|
||||
" * It has been auto-edited by fixincludes from /usr/include/%s\n"
|
||||
" * This had to be done to correct non-standard usages in the\n"
|
||||
" * original, manufacturer supplied header file.\n"
|
||||
" */\n\n";
|
||||
|
||||
fprintf (pf, zHdr, pzFile);
|
||||
}
|
||||
#endif
|
||||
return pf;
|
||||
}
|
||||
|
||||
tSuccess
|
||||
testTest (pTest, pzFile)
|
||||
tTestDesc *pTest;
|
||||
char* pzFile;
|
||||
{
|
||||
char *pzRes;
|
||||
tSuccess res = FAILURE;
|
||||
|
||||
static char zCmdBuf[4096];
|
||||
tSCC zCmdFmt[] = "file=%s\nif ( test %s ) > /dev/null 2>&1\n"
|
||||
"then echo TRUE\n" "else echo FALSE\n" "fi";
|
||||
|
||||
sprintf (zCmdBuf, zCmdFmt, pzFile, pTest->pzTest);
|
||||
pzRes = runShell (zCmdBuf);
|
||||
if (*pzRes == 'T')
|
||||
res = SUCCESS;
|
||||
free ((void *) pzRes);
|
||||
return res;
|
||||
}
|
||||
|
||||
|
||||
tSuccess
|
||||
egrepTest (pzDta, pTest)
|
||||
char *pzDta;
|
||||
tTestDesc *pTest;
|
||||
{
|
||||
regmatch_t match;
|
||||
#ifndef NO_BOGOSITY
|
||||
if (pTest->pTestRegex == 0)
|
||||
fprintf (stderr, "fixincl ERROR RE not compiled: `%s'\n", pTest->pzTest);
|
||||
#endif
|
||||
if (regexec (pTest->pTestRegex, pzDta, 1, &match, 0) == 0)
|
||||
return SUCCESS;
|
||||
return FAILURE;
|
||||
}
|
||||
|
||||
|
||||
|
||||
void
|
||||
extractQuotedFiles (pzDta, pzFile, pMatch)
|
||||
char *pzDta;
|
||||
const char *pzFile;
|
||||
regmatch_t *pMatch;
|
||||
{
|
||||
char *pzDirEnd = strrchr (pzFile, '/');
|
||||
char *pzInclQuot = pzDta;
|
||||
|
||||
fprintf (stderr, "Quoted includes in %s\n", pzFile);
|
||||
|
||||
/*
|
||||
* Set "pzFile" to point to the containing subdirectory of the source
|
||||
* If there is none, then it is in our current direcory, ".".
|
||||
*/
|
||||
if (pzDirEnd == (char *) NULL)
|
||||
pzFile = ".";
|
||||
else
|
||||
*pzDirEnd = '\0';
|
||||
|
||||
for (;;)
|
||||
{
|
||||
pzInclQuot += pMatch->rm_so;
|
||||
|
||||
/*
|
||||
* Skip forward to the included file name
|
||||
*/
|
||||
while (isspace (*pzInclQuot))
|
||||
pzInclQuot++;
|
||||
while (isspace (*++pzInclQuot));
|
||||
pzInclQuot += sizeof ("include") - 1;
|
||||
while (*pzInclQuot++ != '"');
|
||||
|
||||
/*
|
||||
* Print the source directory and the subdirectory of the file
|
||||
* in question.
|
||||
*/
|
||||
printf ("%s %s/", pzSrcDir, pzFile);
|
||||
pzDirEnd = pzInclQuot;
|
||||
|
||||
/*
|
||||
* Append to the directory the relative path of the desired file
|
||||
*/
|
||||
while (*pzInclQuot != '"')
|
||||
putc (*pzInclQuot++, stdout);
|
||||
|
||||
/*
|
||||
* Now print the destination directory appended with the relative
|
||||
* path of the desired file
|
||||
*/
|
||||
printf (" %s/%s/", pzDestDir, pzFile);
|
||||
while (*pzDirEnd != '"')
|
||||
putc (*pzDirEnd++, stdout);
|
||||
|
||||
/*
|
||||
* End of entry
|
||||
*/
|
||||
putc ('\n', stdout);
|
||||
|
||||
/*
|
||||
* Find the next entry
|
||||
*/
|
||||
if (regexec (&inclQuoteRegex, pzInclQuot, 1, pMatch, 0) != 0)
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Process the potential fixes for a particular include file
|
||||
*/
|
||||
void
|
||||
process (pzDta, pzDir, pzFile)
|
||||
char *pzDta;
|
||||
const char *pzDir;
|
||||
const char *pzFile;
|
||||
{
|
||||
static char zEnvFile[1024] =
|
||||
{"file="};
|
||||
tFixDesc *pFD = fixDescList;
|
||||
int todoCt = FIX_COUNT;
|
||||
tFdPair fdp =
|
||||
{-1, -1};
|
||||
|
||||
/*
|
||||
* IF this is the first time through,
|
||||
* THEN put the 'file' environment variable into the environment.
|
||||
* This is used by some of the subject shell scripts and tests.
|
||||
*/
|
||||
if (zEnvFile[5] == NUL)
|
||||
putenv (zEnvFile);
|
||||
|
||||
/*
|
||||
* Ghastly as it is, this actually updates the value of the variable:
|
||||
*
|
||||
* putenv(3C) C Library Functions putenv(3C)
|
||||
*
|
||||
* DESCRIPTION
|
||||
* putenv() makes the value of the environment variable name
|
||||
* equal to value by altering an existing variable or creating
|
||||
* a new one. In either case, the string pointed to by string
|
||||
* becomes part of the environment, so altering the string will
|
||||
* change the environment. string points to a string of the
|
||||
* form ``name=value.'' The space used by string is no longer
|
||||
* used once a new string-defining name is passed to putenv().
|
||||
*/
|
||||
strcpy (zEnvFile + 5, pzFile);
|
||||
chainHead = NOPROCESS;
|
||||
|
||||
/*
|
||||
* For every fix in our fix list, ...
|
||||
*/
|
||||
for (; todoCt > 0; pFD++, todoCt--)
|
||||
{
|
||||
tTestDesc *pTD;
|
||||
int tstCt;
|
||||
tSuccess egrepRes;
|
||||
|
||||
if (pFD->fdFlags & FD_SKIP_TEST)
|
||||
continue;
|
||||
|
||||
/*
|
||||
* IF there is a file name restriction,
|
||||
* THEN ensure the current file name matches one in the pattern
|
||||
*/
|
||||
if (pFD->pzFileList != (char *) NULL)
|
||||
{
|
||||
const char *pzFil = pzFile;
|
||||
const char *pzScn = pFD->pzFileList;
|
||||
size_t nmLen;
|
||||
|
||||
while ((pzFil[0] == '.') && (pzFil[1] == '/'))
|
||||
pzFil += 2;
|
||||
nmLen = strlen (pzFil);
|
||||
|
||||
for (;;)
|
||||
{
|
||||
pzScn = strstr (pzScn + 1, pzFil);
|
||||
if (pzScn == (char *) NULL)
|
||||
goto nextFix;
|
||||
if ((pzScn[-1] == '|') && (pzScn[nmLen] == '|'))
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
egrepRes = PROBLEM;
|
||||
|
||||
/*
|
||||
* IF there are no tests
|
||||
* THEN we always run the fixup
|
||||
*/
|
||||
for (pTD = pFD->pTestDesc, tstCt = pFD->testCt;
|
||||
tstCt-- > 0;
|
||||
pTD++)
|
||||
{
|
||||
switch (pTD->type)
|
||||
{
|
||||
case TT_TEST:
|
||||
/*
|
||||
* IF *any* of the shell tests fail,
|
||||
* THEN do not process the fix.
|
||||
*/
|
||||
if (!SUCCESSFUL (testTest (pTD, pzFile)))
|
||||
goto nextFix;
|
||||
break;
|
||||
|
||||
case TT_EGREP:
|
||||
/*
|
||||
* IF we have not had a successful egrep test
|
||||
* *AND* this test does not pass,
|
||||
* THEN mark the egrep test as failing. It starts
|
||||
* out as a "PROBLEM", meaning that if we do not
|
||||
* encounter any egrep tests, then we will let it pass.
|
||||
*/
|
||||
if ((!SUCCESSFUL (egrepRes))
|
||||
&& (!SUCCESSFUL (egrepTest (pzDta, pTD))))
|
||||
|
||||
egrepRes = FAILURE;
|
||||
|
||||
break;
|
||||
|
||||
case TT_NEGREP:
|
||||
/*
|
||||
* IF *any* of the negative egrep tests fail,
|
||||
* THEN do not process the fix.
|
||||
*/
|
||||
if (SUCCESSFUL (egrepTest (pzDta, pTD)))
|
||||
goto nextFix;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* IF there were no egrep tests *OR* at least one passed, ...
|
||||
*/
|
||||
if (!FAILED (egrepRes))
|
||||
{
|
||||
fprintf (stderr, "Applying %-32s to %s\n",
|
||||
pFD->pzFixName, pzFile);
|
||||
|
||||
if (fdp.readFd == -1)
|
||||
{
|
||||
fdp.readFd = open (pzFile, O_RDONLY);
|
||||
if (fdp.readFd < 0)
|
||||
{
|
||||
fprintf (stderr, "Error %d (%s) opening %s\n", errno,
|
||||
strerror (errno), pzFile);
|
||||
exit (EXIT_FAILURE);
|
||||
}
|
||||
}
|
||||
|
||||
for (;;)
|
||||
{
|
||||
int newFd = chainOpen (fdp.readFd,
|
||||
(tpChar *) pFD->papzPatchArgs,
|
||||
(chainHead == -1)
|
||||
? &chainHead : (pid_t *) NULL);
|
||||
if (newFd != -1)
|
||||
{
|
||||
fdp.readFd = newFd;
|
||||
break;
|
||||
}
|
||||
|
||||
fprintf (stderr, "Error %d (%s) starting filter process "
|
||||
"for %s\n", errno, strerror (errno),
|
||||
pFD->pzFixName);
|
||||
|
||||
if (errno != EAGAIN)
|
||||
exit (EXIT_FAILURE);
|
||||
sleep (1);
|
||||
}
|
||||
}
|
||||
|
||||
nextFix:;
|
||||
}
|
||||
|
||||
/*
|
||||
* IF after all the tests we did not start any patch programs,
|
||||
* THEN quit now.
|
||||
*/
|
||||
if (fdp.readFd < 0)
|
||||
return;
|
||||
|
||||
{
|
||||
FILE *inFp = fdopen (fdp.readFd, "r");
|
||||
FILE *oFp = (FILE *) NULL;
|
||||
char *pzCmp = pzDta;
|
||||
|
||||
for (;;)
|
||||
{
|
||||
int ch;
|
||||
|
||||
ch = getc (inFp);
|
||||
if (ch == EOF)
|
||||
break;
|
||||
|
||||
if (oFp != (FILE *) NULL)
|
||||
putc (ch, oFp);
|
||||
|
||||
else if (ch != *pzCmp)
|
||||
{
|
||||
oFp = createFile (pzFile);
|
||||
if (pzCmp != pzDta)
|
||||
{
|
||||
char c = *pzCmp;
|
||||
*pzCmp = NUL;
|
||||
fputs (pzDta, oFp);
|
||||
*pzCmp = c;
|
||||
}
|
||||
putc (ch, oFp);
|
||||
|
||||
}
|
||||
else
|
||||
pzCmp++;
|
||||
}
|
||||
|
||||
if (oFp != (FILE *) NULL)
|
||||
{
|
||||
regmatch_t match;
|
||||
|
||||
fchmod (fileno (oFp), S_IRUSR | S_IRGRP | S_IROTH);
|
||||
fclose (oFp);
|
||||
if (regexec (&inclQuoteRegex, pzDta, 1, &match, 0) == 0)
|
||||
extractQuotedFiles (pzDta, pzFile, &match);
|
||||
}
|
||||
|
||||
fclose (inFp);
|
||||
}
|
||||
|
||||
close (fdp.readFd);
|
||||
}
|
||||
|
|
@ -1,364 +0,0 @@
|
|||
#!/bin/sh
|
||||
#
|
||||
# DO NOT EDIT THIS FILE (fixincl.sh)
|
||||
#
|
||||
# It has been autogen-ed Tuesday September 22, 1998 at 07:22:35 AM PDT
|
||||
# From the definitions inclhack.def
|
||||
# and the template file inclhack.tpl
|
||||
#
|
||||
# Install modified versions of certain ANSI-incompatible system header
|
||||
# files which are fixed to work correctly with ANSI C and placed in a
|
||||
# directory that GNU C will search.
|
||||
#
|
||||
# This script contains 104 fixup scripts.
|
||||
#
|
||||
# See README-fixinc for more information.
|
||||
#
|
||||
# fixincludes is free software.
|
||||
#
|
||||
# You may redistribute it and/or modify it under the terms of the
|
||||
# GNU General Public License, as published by the Free Software
|
||||
# Foundation; either version 2, or (at your option) any later version.
|
||||
#
|
||||
# fixincludes is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
||||
# See the GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with fixincludes. See the file "COPYING". If not,
|
||||
# write to: The Free Software Foundation, Inc.,
|
||||
# 59 Temple Place - Suite 330,
|
||||
# Boston, MA 02111-1307, USA.
|
||||
#
|
||||
# # # # # # # # # # # # # # # # # # # # #
|
||||
#
|
||||
# Directory containing the original header files.
|
||||
# (This was named INCLUDES, but that conflicts with a name in Makefile.in.)
|
||||
#
|
||||
INPUT=${2-${INPUT-/usr/include}}
|
||||
|
||||
( \cd ${INPUT} > /dev/null 2>&1 ) || {
|
||||
echo 'fixincludes: input dir `'$INPUT"' is an invalid directory"
|
||||
exit 1
|
||||
}
|
||||
|
||||
# # # # # # # # # # # # # # # # # # # # #
|
||||
#
|
||||
# Directory in which to store the results.
|
||||
# Fail if no arg to specify a directory for the output.
|
||||
if [ "x$1" = "x" ]
|
||||
then echo fixincludes: no output directory specified
|
||||
exit 1
|
||||
fi
|
||||
|
||||
LIB=${1}
|
||||
|
||||
# Make sure it exists.
|
||||
if [ ! -d $LIB ]; then
|
||||
mkdir $LIB || {
|
||||
echo fixincludes: output dir '`'$LIB"' cannot be created"
|
||||
exit 1
|
||||
}
|
||||
else
|
||||
( \cd $LIB && touch DONE && rm DONE ) || {
|
||||
echo fixincludes: output dir '`'$LIB"' is an invalid directory"
|
||||
exit 1
|
||||
}
|
||||
fi
|
||||
|
||||
# Define what target system we're fixing.
|
||||
#
|
||||
if test -r ./Makefile; then
|
||||
target_canonical="`sed -n -e 's,^target[ ]*=[ ]*\(.*\)$,\1,p' < Makefile`"
|
||||
fi
|
||||
|
||||
# If not from the Makefile, then try config.guess
|
||||
#
|
||||
if test -z "${target_canonical}" ; then
|
||||
if test -x ./config.guess ; then
|
||||
target_canonical="`config.guess`" ; fi
|
||||
test -z "${target_canonical}" && target_canonical=unknown
|
||||
fi
|
||||
export target_canonical
|
||||
|
||||
# # # # # # # # # # # # # # # # # # # # #
|
||||
#
|
||||
# Define PWDCMD as a command to use to get the working dir
|
||||
# in the form that we want.
|
||||
PWDCMD=pwd
|
||||
|
||||
case "`$PWDCMD`" in
|
||||
//*)
|
||||
# On an Apollo, discard everything before `/usr'.
|
||||
PWDCMD="eval pwd | sed -e 's,.*/usr/,/usr/,'"
|
||||
;;
|
||||
esac
|
||||
|
||||
# Original directory.
|
||||
ORIGDIR=`${PWDCMD}`
|
||||
FIXINCL=${ORIGDIR}/fixincl
|
||||
export FIXINCL
|
||||
|
||||
# Make LIB absolute only if needed to avoid problems with the amd.
|
||||
case $LIB in
|
||||
/*)
|
||||
;;
|
||||
*)
|
||||
cd $LIB; LIB=`${PWDCMD}`
|
||||
;;
|
||||
esac
|
||||
|
||||
echo Fixing headers into ${LIB} for ${target_canonical} target
|
||||
|
||||
# Determine whether this system has symbolic links.
|
||||
if ln -s X $LIB/ShouldNotExist 2>/dev/null; then
|
||||
rm -f $LIB/ShouldNotExist
|
||||
LINKS=true
|
||||
elif ln -s X /tmp/ShouldNotExist 2>/dev/null; then
|
||||
rm -f /tmp/ShouldNotExist
|
||||
LINKS=true
|
||||
else
|
||||
LINKS=false
|
||||
fi
|
||||
|
||||
# # # # # # # # # # # # # # # # # # # # #
|
||||
#
|
||||
echo Finding directories and links to directories
|
||||
cd ${INPUT}
|
||||
# Find all directories and all symlinks that point to directories.
|
||||
# Put the list in $files.
|
||||
# Each time we find a symlink, add it to newdirs
|
||||
# so that we do another find within the dir the link points to.
|
||||
# Note that $files may have duplicates in it;
|
||||
# later parts of this file are supposed to ignore them.
|
||||
dirs="."
|
||||
levels=2
|
||||
while [ -n "$dirs" ] && [ $levels -gt 0 ]
|
||||
do
|
||||
levels=`expr $levels - 1`
|
||||
newdirs=
|
||||
for d in $dirs
|
||||
do
|
||||
echo " Searching $INPUT/$d"
|
||||
|
||||
# Find all directories under $d, relative to $d, excluding $d itself.
|
||||
# (The /. is needed after $d in case $d is a symlink.)
|
||||
files="$files `find $d/. -type d -print | \
|
||||
sed -e '/\/\.$/d' -e 's@/./@/@g'`"
|
||||
# Find all links to directories.
|
||||
# Using `-exec test -d' in find fails on some systems,
|
||||
# and trying to run test via sh fails on others,
|
||||
# so this is the simplest alternative left.
|
||||
# First find all the links, then test each one.
|
||||
theselinks=
|
||||
$LINKS && \
|
||||
theselinks=`find $d/. -type l -print | sed -e 's@/./@/@g'`
|
||||
for d1 in $theselinks --dummy--
|
||||
do
|
||||
# If the link points to a directory,
|
||||
# add that dir to $newdirs
|
||||
if [ -d $d1 ]
|
||||
then
|
||||
files="$files $d1"
|
||||
if [ "`ls -ld $d1 | sed -n 's/.*-> //p'`" != "." ]
|
||||
then
|
||||
newdirs="$newdirs $d1"
|
||||
fi
|
||||
fi
|
||||
done
|
||||
done
|
||||
|
||||
dirs="$newdirs"
|
||||
done
|
||||
|
||||
# # # # # # # # # # # # # # # # # # # # #
|
||||
#
|
||||
dirs=
|
||||
echo "All directories (including links to directories):"
|
||||
echo $files
|
||||
|
||||
for file in $files; do
|
||||
rm -rf $LIB/$file
|
||||
if [ ! -d $LIB/$file ]
|
||||
then mkdir $LIB/$file
|
||||
fi
|
||||
done
|
||||
mkdir $LIB/root
|
||||
|
||||
# # # # # # # # # # # # # # # # # # # # #
|
||||
#
|
||||
# treetops gets an alternating list
|
||||
# of old directories to copy
|
||||
# and the new directories to copy to.
|
||||
treetops="${INPUT} ${LIB}"
|
||||
|
||||
if $LINKS; then
|
||||
echo 'Making symbolic directory links'
|
||||
for file in $files; do
|
||||
dest=`ls -ld $file | sed -n 's/.*-> //p'`
|
||||
if [ "$dest" ]; then
|
||||
cwd=`${PWDCMD}`
|
||||
# In case $dest is relative, get to $file's dir first.
|
||||
cd ${INPUT}
|
||||
cd `echo ./$file | sed -n 's&[^/]*$&&p'`
|
||||
# Check that the target directory exists.
|
||||
# Redirections changed to avoid bug in sh on Ultrix.
|
||||
(cd $dest) > /dev/null 2>&1
|
||||
if [ $? = 0 ]; then
|
||||
cd $dest
|
||||
# X gets the dir that the link actually leads to.
|
||||
x=`${PWDCMD}`
|
||||
# Canonicalize ${INPUT} now to minimize the time an
|
||||
# automounter has to change the result of ${PWDCMD}.
|
||||
cinput=`cd ${INPUT}; ${PWDCMD}`
|
||||
# If a link points to ., make a similar link to .
|
||||
if [ $x = ${cinput} ]; then
|
||||
echo $file '->' . ': Making link'
|
||||
rm -fr ${LIB}/$file > /dev/null 2>&1
|
||||
ln -s . ${LIB}/$file > /dev/null 2>&1
|
||||
# If link leads back into ${INPUT},
|
||||
# make a similar link here.
|
||||
elif expr $x : "${cinput}/.*" > /dev/null; then
|
||||
# Y gets the actual target dir name, relative to ${INPUT}.
|
||||
y=`echo $x | sed -n "s&${cinput}/&&p"`
|
||||
# DOTS is the relative path from ${LIB}/$file's dir back to ${LIB}.
|
||||
dots=`echo "$file" |
|
||||
sed -e 's@^./@@' -e 's@/./@/@g' -e 's@[^/][^/]*@..@g' -e 's@..$@@'`
|
||||
echo $file '->' $dots$y ': Making link'
|
||||
rm -fr ${LIB}/$file > /dev/null 2>&1
|
||||
ln -s $dots$y ${LIB}/$file > /dev/null 2>&1
|
||||
else
|
||||
# If the link is to a dir $target outside ${INPUT},
|
||||
# repoint the link at ${INPUT}/root$target
|
||||
# and process $target into ${INPUT}/root$target
|
||||
# treat this directory as if it actually contained the files.
|
||||
echo $file '->' root$x ': Making link'
|
||||
if [ -d $LIB/root$x ]
|
||||
then true
|
||||
else
|
||||
dirname=root$x/
|
||||
dirmade=.
|
||||
cd $LIB
|
||||
while [ x$dirname != x ]; do
|
||||
component=`echo $dirname | sed -e 's|/.*$||'`
|
||||
mkdir $component >/dev/null 2>&1
|
||||
cd $component
|
||||
dirmade=$dirmade/$component
|
||||
dirname=`echo $dirname | sed -e 's|[^/]*/||'`
|
||||
done
|
||||
fi
|
||||
# Duplicate directory structure created in ${LIB}/$file in new
|
||||
# root area.
|
||||
for file2 in $files; do
|
||||
case $file2 in
|
||||
$file/*)
|
||||
dupdir=${LIB}/root$x/`echo $file2 | sed -n "s|^${file}/||p"`
|
||||
echo "Duplicating ${file}'s ${dupdir}"
|
||||
if [ -d ${dupdir} ]
|
||||
then true
|
||||
else
|
||||
mkdir ${dupdir}
|
||||
fi
|
||||
;;
|
||||
*)
|
||||
;;
|
||||
esac
|
||||
done
|
||||
# Get the path from ${LIB} to $file, accounting for symlinks.
|
||||
parent=`echo "$file" | sed -e 's@/[^/]*$@@'`
|
||||
libabs=`cd ${LIB}; ${PWDCMD}`
|
||||
file2=`cd ${LIB}; cd $parent; ${PWDCMD} | sed -e "s@^${libabs}@@"`
|
||||
# DOTS is the relative path from ${LIB}/$file's dir back to ${LIB}.
|
||||
dots=`echo "$file2" | sed -e 's@/[^/]*@../@g'`
|
||||
rm -fr ${LIB}/$file > /dev/null 2>&1
|
||||
ln -s ${dots}root$x ${LIB}/$file > /dev/null 2>&1
|
||||
treetops="$treetops $x ${LIB}/root$x"
|
||||
fi
|
||||
fi
|
||||
cd $cwd
|
||||
fi
|
||||
done
|
||||
fi
|
||||
|
||||
# # # # # # # # # # # # # # # # # # # # #
|
||||
#
|
||||
required=
|
||||
set x $treetops
|
||||
shift
|
||||
while [ $# != 0 ]; do
|
||||
# $1 is an old directory to copy, and $2 is the new directory to copy to.
|
||||
#
|
||||
SRCDIR=`cd ${INPUT} ; cd $1 ; ${PWDCMD}`
|
||||
export SRCDIR
|
||||
shift
|
||||
|
||||
DESTDIR=`cd $1;${PWDCMD}`
|
||||
export DESTDIR
|
||||
shift
|
||||
|
||||
# The same dir can appear more than once in treetops.
|
||||
# There's no need to scan it more than once.
|
||||
#
|
||||
if [ -f ${DESTDIR}/DONE ]
|
||||
then continue ; fi
|
||||
|
||||
touch ${DESTDIR}/DONE
|
||||
echo Fixing directory ${SRCDIR} into ${DESTDIR}
|
||||
|
||||
# Check .h files which are symlinks as well as those which are files.
|
||||
# A link to a header file will not be processed by anything but this.
|
||||
#
|
||||
cd ${SRCDIR}
|
||||
|
||||
required="$required `if $LINKS; then
|
||||
find . -name '*.h' \( -type f -o -type l \) -print
|
||||
else
|
||||
find . -name '*.h' -type f -print
|
||||
fi | ${FIXINCL}`"
|
||||
done
|
||||
|
||||
## Make sure that any include files referenced using double quotes
|
||||
## exist in the fixed directory. This comes last since otherwise
|
||||
## we might end up deleting some of these files "because they don't
|
||||
## need any change."
|
||||
set x `echo $required`
|
||||
shift
|
||||
while [ $# != 0 ]; do
|
||||
newreq=
|
||||
while [ $# != 0 ]; do
|
||||
# $1 is the directory to copy from,
|
||||
# $2 is the unfixed file,
|
||||
# $3 is the fixed file name.
|
||||
#
|
||||
cd ${INPUT}
|
||||
cd $1
|
||||
if [ -r $2 ] && [ ! -r $3 ]; then
|
||||
cp $2 $3 >/dev/null 2>&1 || echo "Can't copy $2" >&2
|
||||
chmod +w $3 2>/dev/null
|
||||
chmod a+r $3 2>/dev/null
|
||||
echo Copied $2
|
||||
for include in `egrep '^[ ]*#[ ]*include[ ]*"[^/]' $3 |
|
||||
sed -e 's/^[ ]*#[ ]*include[ ]*"\([^"]*\)".*$/\1/'`
|
||||
do
|
||||
dir=`echo $2 | sed -e s'|/[^/]*$||'`
|
||||
dir2=`echo $3 | sed -e s'|/[^/]*$||'`
|
||||
newreq="$newreq $1 $dir/$include $dir2/$include"
|
||||
done
|
||||
fi
|
||||
shift; shift; shift
|
||||
done
|
||||
set x $newreq
|
||||
shift
|
||||
done
|
||||
|
||||
echo 'Cleaning up DONE files.'
|
||||
cd $LIB
|
||||
find . -name DONE -exec rm -f '{}' ';'
|
||||
|
||||
echo 'Removing unneeded directories:'
|
||||
cd $LIB
|
||||
files=`find . -type d -print | sort -r`
|
||||
for file in $files; do
|
||||
rmdir $LIB/$file > /dev/null 2>&1
|
||||
done
|
||||
|
|
@ -1,169 +0,0 @@
|
|||
[= autogen template -*- Mode: C -*-
|
||||
x =]
|
||||
/*
|
||||
[= _eval "# * " _DNE =]
|
||||
*
|
||||
* Install modified versions of certain ANSI-incompatible system header
|
||||
* files which are fixed to work correctly with ANSI C and placed in a
|
||||
* directory that GNU C will search.
|
||||
*
|
||||
* This script contains [=_eval fix _hilim 1 +=] fixup scripts.
|
||||
*
|
||||
* See README-fixinc for more information.
|
||||
*
|
||||
[=_eval inclhack "# * " _gpl=]
|
||||
*[=
|
||||
|
||||
|
||||
_FOR fix =]
|
||||
*
|
||||
* Description [=_eval _index 1 + "#%3d -" _printf=] [=hackname _Cap=] fix
|
||||
*/
|
||||
tSCC z[=hackname _cap=]Name[] =
|
||||
[=hackname _cap _str=];
|
||||
/*
|
||||
* File name selection pattern
|
||||
*/[=
|
||||
|
||||
_IF files _exist=]
|
||||
tSCC z[=hackname _cap=]List[] =[=
|
||||
_FOR files=]
|
||||
"|" [=files _str=][=
|
||||
/files=] "|";[=
|
||||
|
||||
_ELSE =]
|
||||
#define z[=hackname _cap=]List (char*)NULL[=
|
||||
_ENDIF "files _exist" =]
|
||||
/*
|
||||
* Machine/OS name selection pattern
|
||||
*/[=
|
||||
|
||||
_IF mach _exist=]
|
||||
tSCC* apz[=hackname _cap=]Machs[] = {[=
|
||||
_FOR mach =]
|
||||
[=mach _str=],[=
|
||||
/mach=]
|
||||
(const char*)NULL };[=
|
||||
|
||||
_ELSE =]
|
||||
#define apz[=hackname _cap=]Machs (const char**)NULL[=
|
||||
_ENDIF "files _exist" =][=
|
||||
|
||||
_IF exesel _exist=]
|
||||
|
||||
/*
|
||||
* content selection pattern
|
||||
*/[=
|
||||
_FOR exesel =]
|
||||
tSCC z[=hackname _cap=]Select[=_eval _index=][] =
|
||||
[=exesel _str=];[=
|
||||
/exesel =][=
|
||||
|
||||
_ELIF select _exist=]
|
||||
|
||||
/*
|
||||
* content selection pattern
|
||||
*/[=
|
||||
_FOR select =]
|
||||
tSCC z[=hackname _cap=]Select[=_eval _index=][] =
|
||||
[=select _str=];[=
|
||||
/select =][=
|
||||
_ENDIF =][=
|
||||
|
||||
_IF bypass _exist=]
|
||||
|
||||
/*
|
||||
* content bypass pattern
|
||||
*/[=
|
||||
_FOR bypass =]
|
||||
tSCC z[=hackname _cap=]Bypass[=_eval _index=][] =
|
||||
[=bypass _str=];[=
|
||||
/bypass =][=
|
||||
_ENDIF =][=
|
||||
|
||||
_IF test _exist=]
|
||||
|
||||
/*
|
||||
* content test pattern. A shell will deal with it later.
|
||||
*/[=
|
||||
_FOR test =]
|
||||
tSCC z[=hackname _cap=]Test[=_eval _index=][] =
|
||||
[=test _str=];[=
|
||||
/test =][=
|
||||
_ENDIF =][=
|
||||
|
||||
_IF exesel _exist select _exist bypass _exist test _exist | | |
|
||||
=]
|
||||
|
||||
#define [=hackname _up =]_TEST_CT [=
|
||||
_IF exesel _exist =][=
|
||||
_eval test _count bypass _count exesel _count + + =][=
|
||||
_ELSE =][=
|
||||
_eval test _count bypass _count select _count + + =][=
|
||||
_ENDIF =]
|
||||
tTestDesc a[=hackname _cap=]Tests[] = {[=
|
||||
|
||||
_IF test _exist =][=
|
||||
_FOR test=]
|
||||
{ TT_TEST, z[=hackname _cap=]Test[=_eval _index=], 0 /* unused */ },[=
|
||||
/test =][=
|
||||
_ENDIF =][=
|
||||
|
||||
_IF bypass _exist =][=
|
||||
_FOR bypass=]
|
||||
{ TT_NEGREP, z[=hackname _cap=]Bypass[=_eval _index=], (regex_t*)NULL },[=
|
||||
/bypass =][=
|
||||
_ENDIF =][=
|
||||
|
||||
_IF exesel _exist =][=
|
||||
_FOR exesel ,=]
|
||||
{ TT_EGREP, z[=hackname _cap=]Select[=_eval _index=], (regex_t*)NULL }[=
|
||||
/exesel =][=
|
||||
|
||||
_ELIF select _exist =][=
|
||||
_FOR select ,=]
|
||||
{ TT_EGREP, z[=hackname _cap=]Select[=_eval _index=], (regex_t*)NULL }[=
|
||||
/select =][=
|
||||
_ENDIF =] };[=
|
||||
_ELSE =]
|
||||
#define [=hackname _up=]_TEST_CT 0
|
||||
#define a[=hackname _cap=]Tests (tTestDesc*)NULL[=
|
||||
_ENDIF =]
|
||||
|
||||
/*
|
||||
* Fix Command Arguments for [=hackname _cap=]
|
||||
*/
|
||||
const char* apz[=hackname _cap=]Patch[] = {[=
|
||||
_IF sed _exist =] "sed"[=_FOR sed=],
|
||||
"-e" [=sed _str=][=/sed=][=
|
||||
_ELIF replacement _exist =] "sed",
|
||||
"s@[=select[]=]@[=replacement=]@"[=
|
||||
_ELIF shell _exist =] "sh", "-c",
|
||||
[=shell _str=][=
|
||||
_ELSE =][=_ERROR hackname _get "Error: %s has two fixup specifications"
|
||||
_printf =][=
|
||||
_ENDIF=],
|
||||
(char*)NULL };
|
||||
|
||||
/* * * * * * * * * * * * * * * * * * * * * * * * * *[=
|
||||
/fix=]
|
||||
*
|
||||
* List of all fixes
|
||||
*/
|
||||
#define REGEX_COUNT [=_eval fix.select _count
|
||||
fix.bypass _count + =]
|
||||
#define FIX_COUNT [=_eval fix _count =]
|
||||
tFixDesc fixDescList[ [=_eval fix _count =] ] = {[=
|
||||
|
||||
|
||||
_FOR fix ",\n" =]
|
||||
{ z[=hackname _cap=]Name, z[=hackname _cap=]List,
|
||||
apz[=hackname _cap=]Machs, (regex_t*)NULL,
|
||||
[=hackname _up=]_TEST_CT, [=
|
||||
_IF not_machine _exist =]FD_MACH_IFNOT[=
|
||||
_ELSE =]FD_MACH_ONLY[=
|
||||
_ENDIF =],
|
||||
a[=hackname _cap=]Tests, apz[=hackname _cap=]Patch }[=
|
||||
|
||||
/fix=]
|
||||
};
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -1,187 +0,0 @@
|
|||
[= autogen include
|
||||
=]
|
||||
[=
|
||||
# $Id: hackshell.tpl,v 1.1 1998/03/20 16:19:41 korbb Exp $
|
||||
#
|
||||
# This file contanes the shell template replacement for the
|
||||
# fixincl program. It is the repetitive guts of the fixincludes logic.
|
||||
#
|
||||
=]
|
||||
if $LINKS; then
|
||||
files=`find . -name '*.h' \( -type f -o -type l \) -print`
|
||||
else
|
||||
files=`find . -name '*.h' -type f -print`
|
||||
fi
|
||||
echo Checking header files
|
||||
for file in $files; do
|
||||
|
||||
if ( test ! -r $file -o \
|
||||
-n "`fgrep 'This file is part of the GNU C Library' $file`" )
|
||||
then continue ; fi
|
||||
|
||||
fixlist=""
|
||||
[=
|
||||
#
|
||||
# FOR every fix description,
|
||||
# DO: emit the shell text to apply the fix to the current file
|
||||
#
|
||||
# =][=
|
||||
|
||||
_FOR fix "\n\n" =]
|
||||
#
|
||||
# Fix [=_eval _index 1 + #%3d _printf=]: [=hackname _Cap=]
|
||||
#[=
|
||||
_IF files _exist=]
|
||||
case "$file" in [=_FOR files " | \\\n\t"=]./[=files=][=/files=] )[=
|
||||
_ENDIF=][=
|
||||
|
||||
_IF mach _exist=]
|
||||
case "$target_canonical" in [=
|
||||
_FOR mach " | \\\n\t" =][=
|
||||
mach =][=
|
||||
/mach =] )[=
|
||||
_IF mach_unmatched _exist =] : ;;
|
||||
* )[=
|
||||
_ENDIF =][=
|
||||
|
||||
_ENDIF=][=
|
||||
|
||||
# There are three conditional tests: select, bypass and test.
|
||||
They may appear as often as desired. They must all pass for
|
||||
the fix to be applied. "select" and "bypass" are egrep expressions
|
||||
that must each appear (or not appear) in the target file.
|
||||
"test" is an arbitrary test program expression that must yield
|
||||
true or false. It is enclosed in parenthesis to avoid
|
||||
precedence problems. The output looks like this:
|
||||
|
||||
if ( test -n "`egrep 'find-expr' $file`" -a
|
||||
-z "`egrep 'not-find' $file`" -a
|
||||
'(' <some-test-expression> ')'
|
||||
) > /dev/null 2>&1 ; then
|
||||
|
||||
# =][=
|
||||
|
||||
_IF select _exist =]
|
||||
if ( test [=
|
||||
_FOR select " -a \\\n "
|
||||
=]-n [=select _shrstr "#`egrep %s $file`"
|
||||
_printf _shstr =][=
|
||||
/select=][=
|
||||
|
||||
_IF bypass _exist =][=
|
||||
_FOR bypass=] -a \
|
||||
-z [=bypass _shrstr "#`egrep %s $file`"
|
||||
_printf _shstr =][=
|
||||
/bypass=][=
|
||||
_ENDIF=][=
|
||||
|
||||
_IF test _exist=][=
|
||||
_FOR test=] -a \
|
||||
'(' [=test=] ')'[=
|
||||
/test=][=
|
||||
_ENDIF=]
|
||||
) > /dev/null 2>&1 ; then[=
|
||||
|
||||
|
||||
_ELIF test _exist =]
|
||||
if ( test [=
|
||||
_FOR test " -a \\\n "
|
||||
=]'(' [=test=] ')'[=
|
||||
/test=][=
|
||||
|
||||
_IF bypass _exist=][=
|
||||
_FOR bypass=] -a \
|
||||
-z [=bypass _shrstr "#`egrep %s $file`"
|
||||
_printf _shstr=][=
|
||||
/bypass=][=
|
||||
_ENDIF=]
|
||||
) > /dev/null 2>&1 ; then[=
|
||||
|
||||
|
||||
_ELIF bypass _exist =]
|
||||
if ( test [=_FOR bypass " -a \\\n "
|
||||
=]-z [=bypass _shrstr "#`egrep %s $file`"
|
||||
_printf _shstr=][=/bypass=]
|
||||
) > /dev/null 2>&1 ; then[=
|
||||
|
||||
_ENDIF=]
|
||||
fixlist="${fixlist}
|
||||
[=hackname=]"
|
||||
if [ ! -r ${DESTDIR}/$file ]
|
||||
then infile=$file
|
||||
else infile=${DESTDIR}/$file ; fi [=
|
||||
|
||||
_IF sed _exist=][=
|
||||
_IF shell _exist =][=
|
||||
_ERROR hackname _get
|
||||
"fixincludes Error: %s fix has multiple fixups" _printf=][=
|
||||
_ENDIF=]
|
||||
|
||||
sed [=
|
||||
_FOR sed =]-e [=sed _shrstr=] \
|
||||
[=
|
||||
/sed=] < $infile > ${DESTDIR}/$file.[=
|
||||
|
||||
|
||||
_ELIF shell _exist =]
|
||||
( [=shell=] ) < $infile > ${DESTDIR}/$file.
|
||||
|
||||
# Shell scripts have the potential of removing the output
|
||||
# We interpret that to mean the file is not to be altered
|
||||
#
|
||||
if test ! -f ${DESTDIR}/$file.
|
||||
then continue ; fi [=
|
||||
|
||||
|
||||
_ELSE=][=
|
||||
_ERROR hackname _get "ERROR: %s has no fixup" _printf=][=
|
||||
|
||||
_ENDIF=]
|
||||
|
||||
mv -f ${DESTDIR}/$file. ${DESTDIR}/$file[=
|
||||
|
||||
# Close off any opened "if" or "case" statements in reverse order
|
||||
|
||||
# =][=
|
||||
|
||||
_IF select _exist test _exist | bypass _exist | =]
|
||||
fi # end of selection 'if'[=
|
||||
_ENDIF =][=
|
||||
|
||||
_IF mach _exist=]
|
||||
;; # case end for machine type test
|
||||
esac[=
|
||||
_ENDIF =][=
|
||||
|
||||
_IF files _exist=]
|
||||
;; # case end for file name test
|
||||
esac[=
|
||||
_ENDIF =][=
|
||||
|
||||
/fix =][=
|
||||
#
|
||||
# DONE with every fix for the current file
|
||||
#
|
||||
#=]
|
||||
# IF the output has been removed OR it is unchanged,
|
||||
# THEN ensure the output is gone
|
||||
# ELSE look for local directory include syntax
|
||||
#
|
||||
if ( test ! -f ${DESTDIR}/$file || \
|
||||
cmp $file ${DESTDIR}/$file ) > /dev/null 2>&1
|
||||
then
|
||||
rm -f ${DESTDIR}/$file
|
||||
else
|
||||
echo "Fixed $file:${fixlist}"
|
||||
|
||||
# Find any include directives that use "file".
|
||||
#
|
||||
for include in `
|
||||
egrep '^[ ]*#[ ]*include[ ]*"[^/]' ${DESTDIR}/$file |
|
||||
sed -e 's/^[ ]*#[ ]*include[ ]*"\([^"]*\)".*$/\1/'`
|
||||
do
|
||||
dir=`echo $file | sed -e s'|/[^/]*$||'`
|
||||
required="$required ${SRCDIR} $dir/$include ${DESTDIR}/$dir/$include"
|
||||
done
|
||||
fi
|
||||
done # for file in $files
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
|
|
@ -1,366 +0,0 @@
|
|||
[= autogen template -*- Mode: shell-script -*-
|
||||
sh
|
||||
#
|
||||
# $Id: inclhack.tpl,v 1.2 1998/09/22 07:21:14 korbb Exp $
|
||||
#
|
||||
=]
|
||||
#!/bin/sh
|
||||
#
|
||||
[= _EVAL "## " _DNE =]
|
||||
#
|
||||
# Install modified versions of certain ANSI-incompatible system header
|
||||
# files which are fixed to work correctly with ANSI C and placed in a
|
||||
# directory that GNU C will search.
|
||||
#
|
||||
# This script contains [=_eval fix _count =] fixup scripts.
|
||||
#
|
||||
# See README-fixinc for more information.
|
||||
#
|
||||
[=_eval fixincludes "## " _gpl=]
|
||||
#
|
||||
# # # # # # # # # # # # # # # # # # # # #
|
||||
#
|
||||
# Directory containing the original header files.
|
||||
# (This was named INCLUDES, but that conflicts with a name in Makefile.in.)
|
||||
#
|
||||
INPUT=${2-${INPUT-/usr/include}}
|
||||
|
||||
( \cd ${INPUT} > /dev/null 2>&1 ) || {
|
||||
echo 'fixincludes: input dir `'$INPUT"' is an invalid directory"
|
||||
exit 1
|
||||
}
|
||||
|
||||
# # # # # # # # # # # # # # # # # # # # #
|
||||
#
|
||||
# Directory in which to store the results.
|
||||
# Fail if no arg to specify a directory for the output.
|
||||
if [ "x$1" = "x" ]
|
||||
then echo fixincludes: no output directory specified
|
||||
exit 1
|
||||
fi
|
||||
|
||||
LIB=${1}
|
||||
|
||||
# Make sure it exists.
|
||||
if [ ! -d $LIB ]; then
|
||||
mkdir $LIB || {
|
||||
echo fixincludes: output dir '`'$LIB"' cannot be created"
|
||||
exit 1
|
||||
}
|
||||
else
|
||||
( \cd $LIB && touch DONE && rm DONE ) || {
|
||||
echo fixincludes: output dir '`'$LIB"' is an invalid directory"
|
||||
exit 1
|
||||
}
|
||||
fi
|
||||
|
||||
# Define what target system we're fixing.
|
||||
#
|
||||
if test -r ./Makefile; then
|
||||
target_canonical="`sed -n -e 's,^target[ ]*=[ ]*\(.*\)$,\1,p' < Makefile`"
|
||||
fi
|
||||
|
||||
# If not from the Makefile, then try config.guess
|
||||
#
|
||||
if test -z "${target_canonical}" ; then
|
||||
if test -x ./config.guess ; then
|
||||
target_canonical="`config.guess`" ; fi
|
||||
test -z "${target_canonical}" && target_canonical=unknown
|
||||
fi
|
||||
export target_canonical
|
||||
|
||||
# # # # # # # # # # # # # # # # # # # # #
|
||||
#
|
||||
# Define PWDCMD as a command to use to get the working dir
|
||||
# in the form that we want.
|
||||
PWDCMD=pwd
|
||||
|
||||
case "`$PWDCMD`" in
|
||||
//*)
|
||||
# On an Apollo, discard everything before `/usr'.
|
||||
PWDCMD="eval pwd | sed -e 's,.*/usr/,/usr/,'"
|
||||
;;
|
||||
esac
|
||||
|
||||
# Original directory.
|
||||
ORIGDIR=`${PWDCMD}`[=
|
||||
_IF PROGRAM _env =]
|
||||
FIXINCL=${ORIGDIR}/fixincl
|
||||
export FIXINCL[=
|
||||
_ENDIF=]
|
||||
|
||||
# Make LIB absolute only if needed to avoid problems with the amd.
|
||||
case $LIB in
|
||||
/*)
|
||||
;;
|
||||
*)
|
||||
cd $LIB; LIB=`${PWDCMD}`
|
||||
;;
|
||||
esac
|
||||
|
||||
echo Fixing headers into ${LIB} for ${target_canonical} target
|
||||
|
||||
# Determine whether this system has symbolic links.
|
||||
if ln -s X $LIB/ShouldNotExist 2>/dev/null; then
|
||||
rm -f $LIB/ShouldNotExist
|
||||
LINKS=true
|
||||
elif ln -s X /tmp/ShouldNotExist 2>/dev/null; then
|
||||
rm -f /tmp/ShouldNotExist
|
||||
LINKS=true
|
||||
else
|
||||
LINKS=false
|
||||
fi
|
||||
|
||||
# # # # # # # # # # # # # # # # # # # # #
|
||||
#
|
||||
echo Finding directories and links to directories
|
||||
cd ${INPUT}
|
||||
# Find all directories and all symlinks that point to directories.
|
||||
# Put the list in $files.
|
||||
# Each time we find a symlink, add it to newdirs
|
||||
# so that we do another find within the dir the link points to.
|
||||
# Note that $files may have duplicates in it;
|
||||
# later parts of this file are supposed to ignore them.
|
||||
dirs="."
|
||||
levels=2
|
||||
while [ -n "$dirs" ] && [ $levels -gt 0 ]
|
||||
do
|
||||
levels=`expr $levels - 1`
|
||||
newdirs=
|
||||
for d in $dirs
|
||||
do
|
||||
echo " Searching $INPUT/$d"
|
||||
|
||||
# Find all directories under $d, relative to $d, excluding $d itself.
|
||||
# (The /. is needed after $d in case $d is a symlink.)
|
||||
files="$files `find $d/. -type d -print | \
|
||||
sed -e '/\/\.$/d' -e 's@/./@/@g'`"
|
||||
# Find all links to directories.
|
||||
# Using `-exec test -d' in find fails on some systems,
|
||||
# and trying to run test via sh fails on others,
|
||||
# so this is the simplest alternative left.
|
||||
# First find all the links, then test each one.
|
||||
theselinks=
|
||||
$LINKS && \
|
||||
theselinks=`find $d/. -type l -print | sed -e 's@/./@/@g'`
|
||||
for d1 in $theselinks --dummy--
|
||||
do
|
||||
# If the link points to a directory,
|
||||
# add that dir to $newdirs
|
||||
if [ -d $d1 ]
|
||||
then
|
||||
files="$files $d1"
|
||||
if [ "`ls -ld $d1 | sed -n 's/.*-> //p'`" != "." ]
|
||||
then
|
||||
newdirs="$newdirs $d1"
|
||||
fi
|
||||
fi
|
||||
done
|
||||
done
|
||||
|
||||
dirs="$newdirs"
|
||||
done
|
||||
|
||||
# # # # # # # # # # # # # # # # # # # # #
|
||||
#
|
||||
dirs=
|
||||
echo "All directories (including links to directories):"
|
||||
echo $files
|
||||
|
||||
for file in $files; do
|
||||
rm -rf $LIB/$file
|
||||
if [ ! -d $LIB/$file ]
|
||||
then mkdir $LIB/$file
|
||||
fi
|
||||
done
|
||||
mkdir $LIB/root
|
||||
|
||||
# # # # # # # # # # # # # # # # # # # # #
|
||||
#
|
||||
# treetops gets an alternating list
|
||||
# of old directories to copy
|
||||
# and the new directories to copy to.
|
||||
treetops="${INPUT} ${LIB}"
|
||||
|
||||
if $LINKS; then
|
||||
echo 'Making symbolic directory links'
|
||||
for file in $files; do
|
||||
dest=`ls -ld $file | sed -n 's/.*-> //p'`
|
||||
if [ "$dest" ]; then
|
||||
cwd=`${PWDCMD}`
|
||||
# In case $dest is relative, get to $file's dir first.
|
||||
cd ${INPUT}
|
||||
cd `echo ./$file | sed -n 's&[^/]*$&&p'`
|
||||
# Check that the target directory exists.
|
||||
# Redirections changed to avoid bug in sh on Ultrix.
|
||||
(cd $dest) > /dev/null 2>&1
|
||||
if [ $? = 0 ]; then
|
||||
cd $dest
|
||||
# X gets the dir that the link actually leads to.
|
||||
x=`${PWDCMD}`
|
||||
# Canonicalize ${INPUT} now to minimize the time an
|
||||
# automounter has to change the result of ${PWDCMD}.
|
||||
cinput=`cd ${INPUT}; ${PWDCMD}`
|
||||
# If a link points to ., make a similar link to .
|
||||
if [ $x = ${cinput} ]; then
|
||||
echo $file '->' . ': Making link'
|
||||
rm -fr ${LIB}/$file > /dev/null 2>&1
|
||||
ln -s . ${LIB}/$file > /dev/null 2>&1
|
||||
# If link leads back into ${INPUT},
|
||||
# make a similar link here.
|
||||
elif expr $x : "${cinput}/.*" > /dev/null; then
|
||||
# Y gets the actual target dir name, relative to ${INPUT}.
|
||||
y=`echo $x | sed -n "s&${cinput}/&&p"`
|
||||
# DOTS is the relative path from ${LIB}/$file's dir back to ${LIB}.
|
||||
dots=`echo "$file" |
|
||||
sed -e 's@^./@@' -e 's@/./@/@g' -e 's@[^/][^/]*@..@g' -e 's@..$@@'`
|
||||
echo $file '->' $dots$y ': Making link'
|
||||
rm -fr ${LIB}/$file > /dev/null 2>&1
|
||||
ln -s $dots$y ${LIB}/$file > /dev/null 2>&1
|
||||
else
|
||||
# If the link is to a dir $target outside ${INPUT},
|
||||
# repoint the link at ${INPUT}/root$target
|
||||
# and process $target into ${INPUT}/root$target
|
||||
# treat this directory as if it actually contained the files.
|
||||
echo $file '->' root$x ': Making link'
|
||||
if [ -d $LIB/root$x ]
|
||||
then true
|
||||
else
|
||||
dirname=root$x/
|
||||
dirmade=.
|
||||
cd $LIB
|
||||
while [ x$dirname != x ]; do
|
||||
component=`echo $dirname | sed -e 's|/.*$||'`
|
||||
mkdir $component >/dev/null 2>&1
|
||||
cd $component
|
||||
dirmade=$dirmade/$component
|
||||
dirname=`echo $dirname | sed -e 's|[^/]*/||'`
|
||||
done
|
||||
fi
|
||||
# Duplicate directory structure created in ${LIB}/$file in new
|
||||
# root area.
|
||||
for file2 in $files; do
|
||||
case $file2 in
|
||||
$file/*)
|
||||
dupdir=${LIB}/root$x/`echo $file2 | sed -n "s|^${file}/||p"`
|
||||
echo "Duplicating ${file}'s ${dupdir}"
|
||||
if [ -d ${dupdir} ]
|
||||
then true
|
||||
else
|
||||
mkdir ${dupdir}
|
||||
fi
|
||||
;;
|
||||
*)
|
||||
;;
|
||||
esac
|
||||
done
|
||||
# Get the path from ${LIB} to $file, accounting for symlinks.
|
||||
parent=`echo "$file" | sed -e 's@/[^/]*$@@'`
|
||||
libabs=`cd ${LIB}; ${PWDCMD}`
|
||||
file2=`cd ${LIB}; cd $parent; ${PWDCMD} | sed -e "s@^${libabs}@@"`
|
||||
# DOTS is the relative path from ${LIB}/$file's dir back to ${LIB}.
|
||||
dots=`echo "$file2" | sed -e 's@/[^/]*@../@g'`
|
||||
rm -fr ${LIB}/$file > /dev/null 2>&1
|
||||
ln -s ${dots}root$x ${LIB}/$file > /dev/null 2>&1
|
||||
treetops="$treetops $x ${LIB}/root$x"
|
||||
fi
|
||||
fi
|
||||
cd $cwd
|
||||
fi
|
||||
done
|
||||
fi
|
||||
|
||||
# # # # # # # # # # # # # # # # # # # # #
|
||||
#
|
||||
required=
|
||||
set x $treetops
|
||||
shift
|
||||
while [ $# != 0 ]; do
|
||||
# $1 is an old directory to copy, and $2 is the new directory to copy to.
|
||||
#
|
||||
SRCDIR=`cd ${INPUT} ; cd $1 ; ${PWDCMD}`
|
||||
export SRCDIR
|
||||
shift
|
||||
|
||||
DESTDIR=`cd $1;${PWDCMD}`
|
||||
export DESTDIR
|
||||
shift
|
||||
|
||||
# The same dir can appear more than once in treetops.
|
||||
# There's no need to scan it more than once.
|
||||
#
|
||||
if [ -f ${DESTDIR}/DONE ]
|
||||
then continue ; fi
|
||||
|
||||
touch ${DESTDIR}/DONE
|
||||
echo Fixing directory ${SRCDIR} into ${DESTDIR}
|
||||
|
||||
# Check .h files which are symlinks as well as those which are files.
|
||||
# A link to a header file will not be processed by anything but this.
|
||||
#
|
||||
cd ${SRCDIR}
|
||||
[=_IF PROGRAM _env ! =][=
|
||||
|
||||
_include hackshell =][=
|
||||
|
||||
_ELSE
|
||||
|
||||
=]
|
||||
required="$required `if $LINKS; then
|
||||
find . -name '*.h' \( -type f -o -type l \) -print
|
||||
else
|
||||
find . -name '*.h' -type f -print
|
||||
fi | ${FIXINCL}`"[=
|
||||
|
||||
|
||||
_ENDIF =]
|
||||
done
|
||||
|
||||
## Make sure that any include files referenced using double quotes
|
||||
## exist in the fixed directory. This comes last since otherwise
|
||||
## we might end up deleting some of these files "because they don't
|
||||
## need any change."
|
||||
set x `echo $required`
|
||||
shift
|
||||
while [ $# != 0 ]; do
|
||||
newreq=
|
||||
while [ $# != 0 ]; do
|
||||
# $1 is the directory to copy from,
|
||||
# $2 is the unfixed file,
|
||||
# $3 is the fixed file name.
|
||||
#
|
||||
cd ${INPUT}
|
||||
cd $1
|
||||
if [ -r $2 ] && [ ! -r $3 ]; then
|
||||
cp $2 $3 >/dev/null 2>&1 || echo "Can't copy $2" >&2
|
||||
chmod +w $3 2>/dev/null
|
||||
chmod a+r $3 2>/dev/null
|
||||
echo Copied $2
|
||||
for include in `egrep '^[ ]*#[ ]*include[ ]*"[^/]' $3 |
|
||||
sed -e 's/^[ ]*#[ ]*include[ ]*"\([^"]*\)".*$/\1/'`
|
||||
do
|
||||
dir=`echo $2 | sed -e s'|/[^/]*$||'`
|
||||
dir2=`echo $3 | sed -e s'|/[^/]*$||'`
|
||||
newreq="$newreq $1 $dir/$include $dir2/$include"
|
||||
done
|
||||
fi
|
||||
shift; shift; shift
|
||||
done
|
||||
set x $newreq
|
||||
shift
|
||||
done
|
||||
|
||||
echo 'Cleaning up DONE files.'
|
||||
cd $LIB
|
||||
find . -name DONE -exec rm -f '{}' ';'
|
||||
|
||||
echo 'Removing unneeded directories:'
|
||||
cd $LIB
|
||||
files=`find . -type d -print | sort -r`
|
||||
for file in $files; do
|
||||
rmdir $LIB/$file > /dev/null 2>&1
|
||||
done[=
|
||||
|
||||
# Make the output file executable
|
||||
# =][=
|
||||
_eval _outfile "chmod +x %s" _printf _shell=]
|
||||
|
|
@ -1,119 +0,0 @@
|
|||
#! /bin/sh
|
||||
|
||||
machine=$1
|
||||
dest=$2
|
||||
|
||||
if test -z "$dest"
|
||||
then
|
||||
echo "No destination directory specified"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
echo constructing $dest for $machine
|
||||
|
||||
case $machine in
|
||||
alpha*-dec-vms* | \
|
||||
arm-semi-aout | \
|
||||
armel-semi-aout | \
|
||||
arm-semi-aof | \
|
||||
armel-semi-aof | \
|
||||
c1-convex-* | \
|
||||
c2-convex-* | \
|
||||
c32-convex-* | \
|
||||
c34-convex-* | \
|
||||
c38-convex-* | \
|
||||
hppa1.[01]-*-osf* | \
|
||||
hppa1.[01]-*-bsd* | \
|
||||
hppa*-*-lites* | \
|
||||
i[34567]86-moss-msdos* | \
|
||||
i[34567]86-*-moss* | \
|
||||
i[34567]86-*-sysv5* | \
|
||||
i[34567]86-*-osf1* | \
|
||||
i[34567]86-*-pe | \
|
||||
i[34567]86-*-cygwin32 | \
|
||||
i[34567]86-*-mingw32* | \
|
||||
mips-sgi-irix5cross64 | \
|
||||
mips-dec-bsd* | \
|
||||
powerpc-*-eabi* | \
|
||||
powerpc-*-rtems* | \
|
||||
powerpcle-*-eabi* | \
|
||||
powerpcle-*-winnt* | \
|
||||
powerpcle-*-pe | \
|
||||
powerpcle-*-cygwin32 | \
|
||||
*-*-linux-* | \
|
||||
*-*-gnu* )
|
||||
fixincludes=`basename $dest`
|
||||
;;
|
||||
|
||||
i[34567]86-dg-dgux* | \
|
||||
m88k-dg-dgux*)
|
||||
fixincludes=fixinc.dgux
|
||||
;;
|
||||
|
||||
mips-sgi-irix[56]* )
|
||||
fixincludes=fixinc.irix
|
||||
;;
|
||||
|
||||
i[34567]86-sequent-ptx1* | \
|
||||
i[34567]86-sequent-ptx2* | \
|
||||
i[34567]86-sequent-ptx4* | \
|
||||
i[34567]86-sequent-sysv3* | \
|
||||
i[34567]86-sequent-sysv4*)
|
||||
fixincludes=fixinc.ptx
|
||||
;;
|
||||
|
||||
i[34567]86-*-sco3.2v[45]*)
|
||||
fixincludes=fixinc.sco
|
||||
;;
|
||||
|
||||
i[34567]86-*-solaris2.[0-4]* | \
|
||||
*-*-solaris2.[0-4]* | \
|
||||
*-*-sysv4*)
|
||||
fixincludes=fixinc.svr4
|
||||
;;
|
||||
|
||||
alpha*-*-winnt* | \
|
||||
i[34567]86-*-winnt3*)
|
||||
fixincludes=fixinc.winnt
|
||||
;;
|
||||
|
||||
alpha*-*-netbsd* | \
|
||||
arm-*-netbsd* | \
|
||||
i[34567]86-*-freebsdelf* | \
|
||||
i[34567]86-*-freebsd* | \
|
||||
i[34567]86-*-netbsd* | \
|
||||
i[34567]86-*-solaris2* | \
|
||||
m68k-*-netbsd* | \
|
||||
mips-dec-netbsd* | \
|
||||
ns32k-pc532-netbsd* | \
|
||||
*-*-solaris2* | \
|
||||
sparc-*-netbsd* | \
|
||||
vax-*-netbsd*)
|
||||
fixincludes=fixinc.wrap
|
||||
;;
|
||||
|
||||
*)
|
||||
fixincludes=`basename $dest`
|
||||
;;
|
||||
esac
|
||||
|
||||
if test -z "$fixincludes"
|
||||
then
|
||||
cat > $dest <<- _EOF_
|
||||
#! /bin/sh
|
||||
exit 0
|
||||
_EOF_
|
||||
exit 0
|
||||
fi
|
||||
|
||||
if test -f "$fixincludes"
|
||||
then
|
||||
echo copying $fixincludes to $dest
|
||||
cp $fixincludes $dest
|
||||
exit 0
|
||||
fi
|
||||
|
||||
echo $MAKE install DESTDIR=`dirname $dest` TARGET=$machine
|
||||
$MAKE install DESTDIR=`dirname $dest` TARGET=$machine
|
||||
|
||||
exit 1
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -1,504 +0,0 @@
|
|||
/* Definitions for data structures and routines for the regular
|
||||
expression library, version 0.12.
|
||||
|
||||
Copyright (C) 1985, 1989, 1990, 1991, 1992, 1993 Free Software Foundation, Inc.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation; either version 2, or (at your option)
|
||||
any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, 59 Temple Place - Suite 330,
|
||||
Boston, MA 02111-1307, USA. */
|
||||
|
||||
/* $Id: regex.h,v 1.2 1999/01/11 13:25:48 law Exp $ */
|
||||
|
||||
#ifndef __REGEXP_LIBRARY_H__
|
||||
#define __REGEXP_LIBRARY_H__
|
||||
|
||||
/* POSIX says that <sys/types.h> must be included (by the caller) before
|
||||
<regex.h>. */
|
||||
|
||||
#ifdef VMS
|
||||
/* VMS doesn't have `size_t' in <sys/types.h>, even though POSIX says it
|
||||
should be there. */
|
||||
#include <stddef.h>
|
||||
#endif
|
||||
|
||||
|
||||
/* The following bits are used to determine the regexp syntax we
|
||||
recognize. The set/not-set meanings are chosen so that Emacs syntax
|
||||
remains the value 0. The bits are given in alphabetical order, and
|
||||
the definitions shifted by one from the previous bit; thus, when we
|
||||
add or remove a bit, only one other definition need change. */
|
||||
typedef unsigned reg_syntax_t;
|
||||
|
||||
/* If this bit is not set, then \ inside a bracket expression is literal.
|
||||
If set, then such a \ quotes the following character. */
|
||||
#define RE_BACKSLASH_ESCAPE_IN_LISTS (1)
|
||||
|
||||
/* If this bit is not set, then + and ? are operators, and \+ and \? are
|
||||
literals.
|
||||
If set, then \+ and \? are operators and + and ? are literals. */
|
||||
#define RE_BK_PLUS_QM (RE_BACKSLASH_ESCAPE_IN_LISTS << 1)
|
||||
|
||||
/* If this bit is set, then character classes are supported. They are:
|
||||
[:alpha:], [:upper:], [:lower:], [:digit:], [:alnum:], [:xdigit:],
|
||||
[:space:], [:print:], [:punct:], [:graph:], and [:cntrl:].
|
||||
If not set, then character classes are not supported. */
|
||||
#define RE_CHAR_CLASSES (RE_BK_PLUS_QM << 1)
|
||||
|
||||
/* If this bit is set, then ^ and $ are always anchors (outside bracket
|
||||
expressions, of course).
|
||||
If this bit is not set, then it depends:
|
||||
^ is an anchor if it is at the beginning of a regular
|
||||
expression or after an open-group or an alternation operator;
|
||||
$ is an anchor if it is at the end of a regular expression, or
|
||||
before a close-group or an alternation operator.
|
||||
|
||||
This bit could be (re)combined with RE_CONTEXT_INDEP_OPS, because
|
||||
POSIX draft 11.2 says that * etc. in leading positions is undefined.
|
||||
We already implemented a previous draft which made those constructs
|
||||
invalid, though, so we haven't changed the code back. */
|
||||
#define RE_CONTEXT_INDEP_ANCHORS (RE_CHAR_CLASSES << 1)
|
||||
|
||||
/* If this bit is set, then special characters are always special
|
||||
regardless of where they are in the pattern.
|
||||
If this bit is not set, then special characters are special only in
|
||||
some contexts; otherwise they are ordinary. Specifically,
|
||||
* + ? and intervals are only special when not after the beginning,
|
||||
open-group, or alternation operator. */
|
||||
#define RE_CONTEXT_INDEP_OPS (RE_CONTEXT_INDEP_ANCHORS << 1)
|
||||
|
||||
/* If this bit is set, then *, +, ?, and { cannot be first in an re or
|
||||
immediately after an alternation or begin-group operator. */
|
||||
#define RE_CONTEXT_INVALID_OPS (RE_CONTEXT_INDEP_OPS << 1)
|
||||
|
||||
/* If this bit is set, then . matches newline.
|
||||
If not set, then it doesn't. */
|
||||
#define RE_DOT_NEWLINE (RE_CONTEXT_INVALID_OPS << 1)
|
||||
|
||||
/* If this bit is set, then . doesn't match NUL.
|
||||
If not set, then it does. */
|
||||
#define RE_DOT_NOT_NULL (RE_DOT_NEWLINE << 1)
|
||||
|
||||
/* If this bit is set, nonmatching lists [^...] do not match newline.
|
||||
If not set, they do. */
|
||||
#define RE_HAT_LISTS_NOT_NEWLINE (RE_DOT_NOT_NULL << 1)
|
||||
|
||||
/* If this bit is set, either \{...\} or {...} defines an
|
||||
interval, depending on RE_NO_BK_BRACES.
|
||||
If not set, \{, \}, {, and } are literals. */
|
||||
#define RE_INTERVALS (RE_HAT_LISTS_NOT_NEWLINE << 1)
|
||||
|
||||
/* If this bit is set, +, ? and | aren't recognized as operators.
|
||||
If not set, they are. */
|
||||
#define RE_LIMITED_OPS (RE_INTERVALS << 1)
|
||||
|
||||
/* If this bit is set, newline is an alternation operator.
|
||||
If not set, newline is literal. */
|
||||
#define RE_NEWLINE_ALT (RE_LIMITED_OPS << 1)
|
||||
|
||||
/* If this bit is set, then `{...}' defines an interval, and \{ and \}
|
||||
are literals.
|
||||
If not set, then `\{...\}' defines an interval. */
|
||||
#define RE_NO_BK_BRACES (RE_NEWLINE_ALT << 1)
|
||||
|
||||
/* If this bit is set, (...) defines a group, and \( and \) are literals.
|
||||
If not set, \(...\) defines a group, and ( and ) are literals. */
|
||||
#define RE_NO_BK_PARENS (RE_NO_BK_BRACES << 1)
|
||||
|
||||
/* If this bit is set, then \<digit> matches <digit>.
|
||||
If not set, then \<digit> is a back-reference. */
|
||||
#define RE_NO_BK_REFS (RE_NO_BK_PARENS << 1)
|
||||
|
||||
/* If this bit is set, then | is an alternation operator, and \| is literal.
|
||||
If not set, then \| is an alternation operator, and | is literal. */
|
||||
#define RE_NO_BK_VBAR (RE_NO_BK_REFS << 1)
|
||||
|
||||
/* If this bit is set, then an ending range point collating higher
|
||||
than the starting range point, as in [z-a], is invalid.
|
||||
If not set, then when ending range point collates higher than the
|
||||
starting range point, the range is ignored. */
|
||||
#define RE_NO_EMPTY_RANGES (RE_NO_BK_VBAR << 1)
|
||||
|
||||
/* If this bit is set, then an unmatched ) is ordinary.
|
||||
If not set, then an unmatched ) is invalid. */
|
||||
#define RE_UNMATCHED_RIGHT_PAREN_ORD (RE_NO_EMPTY_RANGES << 1)
|
||||
|
||||
/* This global variable defines the particular regexp syntax to use (for
|
||||
some interfaces). When a regexp is compiled, the syntax used is
|
||||
stored in the pattern buffer, so changing this does not affect
|
||||
already-compiled regexps. */
|
||||
extern reg_syntax_t re_syntax_options;
|
||||
|
||||
/* Define combinations of the above bits for the standard possibilities.
|
||||
(The [[[ comments delimit what gets put into the Texinfo file, so
|
||||
don't delete them!) */
|
||||
/* [[[begin syntaxes]]] */
|
||||
#define RE_SYNTAX_EMACS 0
|
||||
|
||||
#define RE_SYNTAX_AWK \
|
||||
(RE_BACKSLASH_ESCAPE_IN_LISTS | RE_DOT_NOT_NULL \
|
||||
| RE_NO_BK_PARENS | RE_NO_BK_REFS \
|
||||
| RE_NO_BK_VBAR | RE_NO_EMPTY_RANGES \
|
||||
| RE_UNMATCHED_RIGHT_PAREN_ORD)
|
||||
|
||||
#define RE_SYNTAX_POSIX_AWK \
|
||||
(RE_SYNTAX_POSIX_EXTENDED | RE_BACKSLASH_ESCAPE_IN_LISTS)
|
||||
|
||||
#define RE_SYNTAX_GREP \
|
||||
(RE_BK_PLUS_QM | RE_CHAR_CLASSES \
|
||||
| RE_HAT_LISTS_NOT_NEWLINE | RE_INTERVALS \
|
||||
| RE_NEWLINE_ALT)
|
||||
|
||||
#define RE_SYNTAX_EGREP \
|
||||
(RE_CHAR_CLASSES | RE_CONTEXT_INDEP_ANCHORS \
|
||||
| RE_CONTEXT_INDEP_OPS | RE_HAT_LISTS_NOT_NEWLINE \
|
||||
| RE_NEWLINE_ALT | RE_NO_BK_PARENS \
|
||||
| RE_NO_BK_VBAR)
|
||||
|
||||
#define RE_SYNTAX_POSIX_EGREP \
|
||||
(RE_SYNTAX_EGREP | RE_INTERVALS | RE_NO_BK_BRACES)
|
||||
|
||||
/* P1003.2/D11.2, section 4.20.7.1, lines 5078ff. */
|
||||
#define RE_SYNTAX_ED RE_SYNTAX_POSIX_BASIC
|
||||
|
||||
#define RE_SYNTAX_SED RE_SYNTAX_POSIX_BASIC
|
||||
|
||||
/* Syntax bits common to both basic and extended POSIX regex syntax. */
|
||||
#define _RE_SYNTAX_POSIX_COMMON \
|
||||
(RE_CHAR_CLASSES | RE_DOT_NEWLINE | RE_DOT_NOT_NULL \
|
||||
| RE_INTERVALS | RE_NO_EMPTY_RANGES)
|
||||
|
||||
#define RE_SYNTAX_POSIX_BASIC \
|
||||
(_RE_SYNTAX_POSIX_COMMON | RE_BK_PLUS_QM)
|
||||
|
||||
/* Differs from ..._POSIX_BASIC only in that RE_BK_PLUS_QM becomes
|
||||
RE_LIMITED_OPS, i.e., \? \+ \| are not recognized. Actually, this
|
||||
isn't minimal, since other operators, such as \`, aren't disabled. */
|
||||
#define RE_SYNTAX_POSIX_MINIMAL_BASIC \
|
||||
(_RE_SYNTAX_POSIX_COMMON | RE_LIMITED_OPS)
|
||||
|
||||
#define RE_SYNTAX_POSIX_EXTENDED \
|
||||
(_RE_SYNTAX_POSIX_COMMON | RE_CONTEXT_INDEP_ANCHORS \
|
||||
| RE_CONTEXT_INDEP_OPS | RE_NO_BK_BRACES \
|
||||
| RE_NO_BK_PARENS | RE_NO_BK_VBAR \
|
||||
| RE_UNMATCHED_RIGHT_PAREN_ORD)
|
||||
|
||||
/* Differs from ..._POSIX_EXTENDED in that RE_CONTEXT_INVALID_OPS
|
||||
replaces RE_CONTEXT_INDEP_OPS and RE_NO_BK_REFS is added. */
|
||||
#define RE_SYNTAX_POSIX_MINIMAL_EXTENDED \
|
||||
(_RE_SYNTAX_POSIX_COMMON | RE_CONTEXT_INDEP_ANCHORS \
|
||||
| RE_CONTEXT_INVALID_OPS | RE_NO_BK_BRACES \
|
||||
| RE_NO_BK_PARENS | RE_NO_BK_REFS \
|
||||
| RE_NO_BK_VBAR | RE_UNMATCHED_RIGHT_PAREN_ORD)
|
||||
/* [[[end syntaxes]]] */
|
||||
|
||||
/* Maximum number of duplicates an interval can allow. Some systems
|
||||
(erroneously) define this in other header files, but we want our
|
||||
value, so remove any previous define. */
|
||||
#ifdef RE_DUP_MAX
|
||||
#undef RE_DUP_MAX
|
||||
#endif
|
||||
#define RE_DUP_MAX ((1 << 15) - 1)
|
||||
|
||||
|
||||
/* POSIX `cflags' bits (i.e., information for `regcomp'). */
|
||||
|
||||
/* If this bit is set, then use extended regular expression syntax.
|
||||
If not set, then use basic regular expression syntax. */
|
||||
#define REG_EXTENDED 1
|
||||
|
||||
/* If this bit is set, then ignore case when matching.
|
||||
If not set, then case is significant. */
|
||||
#define REG_ICASE (REG_EXTENDED << 1)
|
||||
|
||||
/* If this bit is set, then anchors do not match at newline
|
||||
characters in the string.
|
||||
If not set, then anchors do match at newlines. */
|
||||
#define REG_NEWLINE (REG_ICASE << 1)
|
||||
|
||||
/* If this bit is set, then report only success or fail in regexec.
|
||||
If not set, then returns differ between not matching and errors. */
|
||||
#define REG_NOSUB (REG_NEWLINE << 1)
|
||||
|
||||
|
||||
/* POSIX `eflags' bits (i.e., information for regexec). */
|
||||
|
||||
/* If this bit is set, then the beginning-of-line operator doesn't match
|
||||
the beginning of the string (presumably because it's not the
|
||||
beginning of a line).
|
||||
If not set, then the beginning-of-line operator does match the
|
||||
beginning of the string. */
|
||||
#define REG_NOTBOL 1
|
||||
|
||||
/* Like REG_NOTBOL, except for the end-of-line. */
|
||||
#define REG_NOTEOL (1 << 1)
|
||||
|
||||
|
||||
/* POSIX doesn't require that we do anything for the 0 case,
|
||||
but why not be nice. */
|
||||
|
||||
#define REG_ERR_TABLE \
|
||||
_RERR_( NOERROR, "Success" ) \
|
||||
_RERR_( NOMATCH, "No match" ) \
|
||||
/* \
|
||||
* POSIX regcomp return error codes. \
|
||||
* (In the order listed in the standard.) \
|
||||
*/ \
|
||||
_RERR_( BADPAT, "Invalid regular expression" ) \
|
||||
_RERR_( ECOLLATE, "Invalid collation character" ) \
|
||||
_RERR_( ECTYPE, "Invalid character class name" ) \
|
||||
_RERR_( EESCAPE, "Trailing backslash" ) \
|
||||
_RERR_( ESUBREG, "Invalid back reference" ) \
|
||||
_RERR_( EBRACK, "Unmatched [ or [^" ) \
|
||||
_RERR_( EPAREN, "Unmatched ( or \\(" ) \
|
||||
_RERR_( EBRACE, "Unmatched \\{" ) \
|
||||
_RERR_( BADBR, "Invalid content of \\{\\}" ) \
|
||||
_RERR_( ERANGE, "Invalid range end" ) \
|
||||
_RERR_( ESPACE, "Memory exhausted" ) \
|
||||
_RERR_( BADRPT, "Invalid preceding regular expression" ) \
|
||||
_RERR_( ECHAR, "Invalid multibyte character" ) \
|
||||
_RERR_( EBOL, "^ anchor and not BOL" ) \
|
||||
_RERR_( EEOL, "$ anchor and not EOL" ) \
|
||||
\
|
||||
/* \
|
||||
* Error codes we've added. \
|
||||
*/ \
|
||||
_RERR_( EEND, "Premature end of regular expression" ) \
|
||||
_RERR_( ESIZE, "Regular expression too big" ) \
|
||||
_RERR_( ERPAREN, "Unmatched ) or \\)" )
|
||||
|
||||
#define _RERR_(n,t) REG_ ## n,
|
||||
|
||||
typedef enum { REG_ERR_TABLE REG_ERR_COUNT } reg_errcode_t;
|
||||
|
||||
#undef _RERR_
|
||||
|
||||
/* This data structure represents a compiled pattern. Before calling
|
||||
the pattern compiler, the fields `buffer', `allocated', `fastmap',
|
||||
`translate', and `no_sub' can be set. After the pattern has been
|
||||
compiled, the `re_nsub' field is available. All other fields are
|
||||
private to the regex routines. */
|
||||
|
||||
struct re_pattern_buffer
|
||||
{
|
||||
/* [[[begin pattern_buffer]]] */
|
||||
/* Space that holds the compiled pattern. It is declared as
|
||||
`unsigned char *' because its elements are
|
||||
sometimes used as array indexes. */
|
||||
unsigned char *buffer;
|
||||
|
||||
/* Number of bytes to which `buffer' points. */
|
||||
unsigned long allocated;
|
||||
|
||||
/* Number of bytes actually used in `buffer'. */
|
||||
unsigned long used;
|
||||
|
||||
/* Syntax setting with which the pattern was compiled. */
|
||||
reg_syntax_t syntax;
|
||||
|
||||
/* Pointer to a fastmap, if any, otherwise zero. re_search uses
|
||||
the fastmap, if there is one, to skip over impossible
|
||||
starting points for matches. */
|
||||
char *fastmap;
|
||||
|
||||
/* Either a translate table to apply to all characters before
|
||||
comparing them, or zero for no translation. The translation
|
||||
is applied to a pattern when it is compiled and to a string
|
||||
when it is matched. */
|
||||
char *translate;
|
||||
|
||||
/* Number of subexpressions found by the compiler. */
|
||||
size_t re_nsub;
|
||||
|
||||
/* Zero if this pattern cannot match the empty string, one else.
|
||||
Well, in truth it's used only in `re_search_2', to see
|
||||
whether or not we should use the fastmap, so we don't set
|
||||
this absolutely perfectly; see `re_compile_fastmap' (the
|
||||
`duplicate' case). */
|
||||
unsigned can_be_null : 1;
|
||||
|
||||
/* If REGS_UNALLOCATED, allocate space in the `regs' structure
|
||||
for `max (RE_NREGS, re_nsub + 1)' groups.
|
||||
If REGS_REALLOCATE, reallocate space if necessary.
|
||||
If REGS_FIXED, use what's there. */
|
||||
#define REGS_UNALLOCATED 0
|
||||
#define REGS_REALLOCATE 1
|
||||
#define REGS_FIXED 2
|
||||
unsigned regs_allocated : 2;
|
||||
|
||||
/* Set to zero when `regex_compile' compiles a pattern; set to one
|
||||
by `re_compile_fastmap' if it updates the fastmap. */
|
||||
unsigned fastmap_accurate : 1;
|
||||
|
||||
/* If set, `re_match_2' does not return information about
|
||||
subexpressions. */
|
||||
unsigned no_sub : 1;
|
||||
|
||||
/* If set, a beginning-of-line anchor doesn't match at the
|
||||
beginning of the string. */
|
||||
unsigned not_bol : 1;
|
||||
|
||||
/* Similarly for an end-of-line anchor. */
|
||||
unsigned not_eol : 1;
|
||||
|
||||
/* If true, an anchor at a newline matches. */
|
||||
unsigned newline_anchor : 1;
|
||||
|
||||
/* [[[end pattern_buffer]]] */
|
||||
};
|
||||
|
||||
typedef struct re_pattern_buffer regex_t;
|
||||
|
||||
|
||||
/* search.c (search_buffer) in Emacs needs this one opcode value. It is
|
||||
defined both in `regex.c' and here. */
|
||||
#define RE_EXACTN_VALUE 1
|
||||
|
||||
/* Type for byte offsets within the string. POSIX mandates this. */
|
||||
typedef int regoff_t;
|
||||
|
||||
|
||||
/* This is the structure we store register match data in. See
|
||||
regex.texinfo for a full description of what registers match. */
|
||||
struct re_registers
|
||||
{
|
||||
unsigned num_regs;
|
||||
regoff_t *start;
|
||||
regoff_t *end;
|
||||
};
|
||||
|
||||
|
||||
/* If `regs_allocated' is REGS_UNALLOCATED in the pattern buffer,
|
||||
`re_match_2' returns information about at least this many registers
|
||||
the first time a `regs' structure is passed. */
|
||||
#ifndef RE_NREGS
|
||||
#define RE_NREGS 30
|
||||
#endif
|
||||
|
||||
|
||||
/* POSIX specification for registers. Aside from the different names than
|
||||
`re_registers', POSIX uses an array of structures, instead of a
|
||||
structure of arrays. */
|
||||
typedef struct
|
||||
{
|
||||
regoff_t rm_so; /* Byte offset from string's start to substring's start. */
|
||||
regoff_t rm_eo; /* Byte offset from string's start to substring's end. */
|
||||
} regmatch_t;
|
||||
|
||||
/* Declarations for routines. */
|
||||
|
||||
/* To avoid duplicating every routine declaration -- once with a
|
||||
prototype (if we are ANSI), and once without (if we aren't) -- we
|
||||
use the following macro to declare argument types. This
|
||||
unfortunately clutters up the declarations a bit, but I think it's
|
||||
worth it. */
|
||||
|
||||
#if __STDC__
|
||||
|
||||
#define _RE_ARGS(args) args
|
||||
|
||||
#else /* not __STDC__ */
|
||||
|
||||
#define _RE_ARGS(args) ()
|
||||
|
||||
#endif /* not __STDC__ */
|
||||
|
||||
/* Sets the current default syntax to SYNTAX, and return the old syntax.
|
||||
You can also simply assign to the `re_syntax_options' variable. */
|
||||
extern reg_syntax_t re_set_syntax _RE_ARGS ((reg_syntax_t syntax));
|
||||
|
||||
/* Compile the regular expression PATTERN, with length LENGTH
|
||||
and syntax given by the global `re_syntax_options', into the buffer
|
||||
BUFFER. Return NULL if successful, and an error string if not. */
|
||||
extern const char *re_compile_pattern
|
||||
_RE_ARGS ((const char *pattern, int length,
|
||||
struct re_pattern_buffer *buffer));
|
||||
|
||||
|
||||
/* Compile a fastmap for the compiled pattern in BUFFER; used to
|
||||
accelerate searches. Return 0 if successful and -2 if was an
|
||||
internal error. */
|
||||
extern int re_compile_fastmap _RE_ARGS ((struct re_pattern_buffer *buffer));
|
||||
|
||||
|
||||
/* Search in the string STRING (with length LENGTH) for the pattern
|
||||
compiled into BUFFER. Start searching at position START, for RANGE
|
||||
characters. Return the starting position of the match, -1 for no
|
||||
match, or -2 for an internal error. Also return register
|
||||
information in REGS (if REGS and BUFFER->no_sub are nonzero). */
|
||||
extern int re_search
|
||||
_RE_ARGS ((struct re_pattern_buffer *buffer, const char *string,
|
||||
int length, int start, int range, struct re_registers *regs));
|
||||
|
||||
|
||||
/* Like `re_search', but search in the concatenation of STRING1 and
|
||||
STRING2. Also, stop searching at index START + STOP. */
|
||||
extern int re_search_2
|
||||
_RE_ARGS ((struct re_pattern_buffer *buffer, const char *string1,
|
||||
int length1, const char *string2, int length2,
|
||||
int start, int range, struct re_registers *regs, int stop));
|
||||
|
||||
|
||||
/* Like `re_search', but return how many characters in STRING the regexp
|
||||
in BUFFER matched, starting at position START. */
|
||||
extern int re_match
|
||||
_RE_ARGS ((struct re_pattern_buffer *buffer, const char *string,
|
||||
int length, int start, struct re_registers *regs));
|
||||
|
||||
|
||||
/* Relates to `re_match' as `re_search_2' relates to `re_search'. */
|
||||
extern int re_match_2
|
||||
_RE_ARGS ((struct re_pattern_buffer *buffer, const char *string1,
|
||||
int length1, const char *string2, int length2,
|
||||
int start, struct re_registers *regs, int stop));
|
||||
|
||||
|
||||
/* Set REGS to hold NUM_REGS registers, storing them in STARTS and
|
||||
ENDS. Subsequent matches using BUFFER and REGS will use this memory
|
||||
for recording register information. STARTS and ENDS must be
|
||||
allocated with malloc, and must each be at least `NUM_REGS * sizeof
|
||||
(regoff_t)' bytes long.
|
||||
|
||||
If NUM_REGS == 0, then subsequent matches should allocate their own
|
||||
register data.
|
||||
|
||||
Unless this function is called, the first search or match using
|
||||
PATTERN_BUFFER will allocate its own register data, without
|
||||
freeing the old data. */
|
||||
extern void re_set_registers
|
||||
_RE_ARGS ((struct re_pattern_buffer *buffer, struct re_registers *regs,
|
||||
unsigned num_regs, regoff_t *starts, regoff_t *ends));
|
||||
|
||||
/* 4.2 bsd compatibility. */
|
||||
extern char *re_comp _RE_ARGS ((const char *));
|
||||
extern int re_exec _RE_ARGS ((const char *));
|
||||
|
||||
/* POSIX compatibility. */
|
||||
extern int regcomp _RE_ARGS ((regex_t *preg, const char *pattern, int cflags));
|
||||
extern int regexec
|
||||
_RE_ARGS ((const regex_t *preg, const char *string, size_t nmatch,
|
||||
regmatch_t pmatch[], int eflags));
|
||||
extern size_t regerror
|
||||
_RE_ARGS ((int errcode, const regex_t *preg, char *errbuf,
|
||||
size_t errbuf_size));
|
||||
extern void regfree _RE_ARGS ((regex_t *preg));
|
||||
|
||||
#endif /* not __REGEXP_LIBRARY_H__ */
|
||||
|
||||
/*
|
||||
Local variables:
|
||||
make-backup-files: t
|
||||
version-control: t
|
||||
trim-versions-without-asking: nil
|
||||
End:
|
||||
*/
|
||||
|
|
@ -1,464 +0,0 @@
|
|||
|
||||
/*
|
||||
* $Id: server.c,v 1.2 1998/05/28 09:21:29 korbb Exp $
|
||||
*
|
||||
* Server Handling copyright 1992-1998 Bruce Korb
|
||||
*
|
||||
* Server Handling is free software.
|
||||
* You may redistribute it and/or modify it under the terms of the
|
||||
* GNU General Public License, as published by the Free Software
|
||||
* Foundation; either version 2, or (at your option) any later version.
|
||||
*
|
||||
* Server Handling is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with Server Handling. See the file "COPYING". If not,
|
||||
* write to: The Free Software Foundation, Inc.,
|
||||
* 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
*
|
||||
* As a special exception, Bruce Korb gives permission for additional
|
||||
* uses of the text contained in his release of ServerHandler.
|
||||
*
|
||||
* The exception is that, if you link the ServerHandler library with other
|
||||
* files to produce an executable, this does not by itself cause the
|
||||
* resulting executable to be covered by the GNU General Public License.
|
||||
* Your use of that executable is in no way restricted on account of
|
||||
* linking the ServerHandler library code into it.
|
||||
*
|
||||
* This exception does not however invalidate any other reasons why
|
||||
* the executable file might be covered by the GNU General Public License.
|
||||
*
|
||||
* This exception applies only to the code released by Bruce Korb under
|
||||
* the name ServerHandler. If you copy code from other sources under the
|
||||
* General Public License into a copy of ServerHandler, as the General Public
|
||||
* License permits, the exception does not apply to the code that you add
|
||||
* in this way. To avoid misleading anyone as to the status of such
|
||||
* modified files, you must delete this exception notice from them.
|
||||
*
|
||||
* If you write modifications of your own for ServerHandler, it is your
|
||||
* choice whether to permit this exception to apply to your modifications.
|
||||
* If you do not wish that, delete this exception notice.
|
||||
*/
|
||||
|
||||
#include <fcntl.h>
|
||||
#include <errno.h>
|
||||
#include <signal.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <ctype.h>
|
||||
#include <sys/param.h>
|
||||
|
||||
#include "server.h"
|
||||
|
||||
#ifdef DEBUG
|
||||
#define STATIC
|
||||
#else
|
||||
#define STATIC static
|
||||
#endif
|
||||
#ifndef tSCC
|
||||
#define tSCC static const char
|
||||
#endif
|
||||
#ifndef NUL
|
||||
#define NUL '\0'
|
||||
#endif
|
||||
|
||||
STATIC bool readPipeTimeout;
|
||||
|
||||
STATIC tpChar defArgs[] =
|
||||
{(char *) NULL, "-p", (char *) NULL};
|
||||
STATIC tpfPair serverPair =
|
||||
{(FILE *) NULL, (FILE *) NULL};
|
||||
STATIC pid_t serverId = NULLPROCESS;
|
||||
/*
|
||||
* Arbitrary text that should not be found in the shell output.
|
||||
* It must be a single line and appear verbatim at the start of
|
||||
* the terminating output line.
|
||||
*/
|
||||
tSCC zDone[] = "ShElL-OuTpUt-HaS-bEeN-cOmPlEtEd";
|
||||
STATIC tpChar pCurDir = (char *) NULL;
|
||||
|
||||
/*
|
||||
* chainOpen
|
||||
*
|
||||
* Given an FD for an inferior process to use as stdin,
|
||||
* start that process and return a NEW FD that that process
|
||||
* will use for its stdout. Requires the argument vector
|
||||
* for the new process and, optionally, a pointer to a place
|
||||
* to store the child's process id.
|
||||
*/
|
||||
int
|
||||
chainOpen (stdinFd, ppArgs, pChild)
|
||||
int stdinFd;
|
||||
tpChar *ppArgs;
|
||||
pid_t *pChild;
|
||||
{
|
||||
tFdPair stdoutPair =
|
||||
{-1, -1};
|
||||
pid_t chId;
|
||||
char *pzCmd;
|
||||
|
||||
/*
|
||||
* Create a pipe it will be the child process' stdout,
|
||||
* and the parent will read from it.
|
||||
*/
|
||||
if ((pipe ((int *) &stdoutPair) < 0))
|
||||
{
|
||||
if (pChild != (pid_t *) NULL)
|
||||
*pChild = NOPROCESS;
|
||||
return -1;
|
||||
}
|
||||
|
||||
/*
|
||||
* If we did not get an arg list, use the default
|
||||
*/
|
||||
if (ppArgs == (tpChar *) NULL)
|
||||
ppArgs = defArgs;
|
||||
|
||||
/*
|
||||
* If the arg list does not have a program,
|
||||
* assume the "SHELL" from the environment, or, failing
|
||||
* that, then sh. Set argv[0] to whatever we decided on.
|
||||
*/
|
||||
if (pzCmd = *ppArgs,
|
||||
(pzCmd == (char *) NULL) || (*pzCmd == '\0'))
|
||||
{
|
||||
|
||||
pzCmd = getenv ("SHELL");
|
||||
if (pzCmd == (char *) NULL)
|
||||
pzCmd = "sh";
|
||||
}
|
||||
#ifdef DEBUG_PRINT
|
||||
printf ("START: %s\n", pzCmd);
|
||||
{
|
||||
int idx = 0;
|
||||
while (ppArgs[++idx] != (char *) NULL)
|
||||
printf (" ARG %2d: %s\n", idx, ppArgs[idx]);
|
||||
}
|
||||
#endif
|
||||
/*
|
||||
* Call fork() and see which process we become
|
||||
*/
|
||||
chId = fork ();
|
||||
switch (chId)
|
||||
{
|
||||
case NOPROCESS: /* parent - error in call */
|
||||
close (stdoutPair.readFd);
|
||||
close (stdoutPair.writeFd);
|
||||
if (pChild != (pid_t *) NULL)
|
||||
*pChild = NOPROCESS;
|
||||
return -1;
|
||||
|
||||
default: /* parent - return opposite FD's */
|
||||
if (pChild != (pid_t *) NULL)
|
||||
*pChild = chId;
|
||||
#ifdef DEBUG_PRINT
|
||||
printf ("for pid %d: stdin from %d, stdout to %d\n"
|
||||
"for parent: read from %d\n",
|
||||
chId, stdinFd, stdoutPair.writeFd, stdoutPair.readFd);
|
||||
#endif
|
||||
close (stdinFd);
|
||||
close (stdoutPair.writeFd);
|
||||
return stdoutPair.readFd;
|
||||
|
||||
case NULLPROCESS: /* child - continue processing */
|
||||
break;
|
||||
}
|
||||
|
||||
/*
|
||||
* Close the pipe end handed back to the parent process
|
||||
*/
|
||||
close (stdoutPair.readFd);
|
||||
|
||||
/*
|
||||
* Close our current stdin and stdout
|
||||
*/
|
||||
close (STDIN_FILENO);
|
||||
close (STDOUT_FILENO);
|
||||
|
||||
/*
|
||||
* Make the fd passed in the stdin, and the write end of
|
||||
* the new pipe become the stdout.
|
||||
*/
|
||||
fcntl (stdoutPair.writeFd, F_DUPFD, STDOUT_FILENO);
|
||||
fcntl (stdinFd, F_DUPFD, STDIN_FILENO);
|
||||
|
||||
if (*ppArgs == (char *) NULL)
|
||||
*ppArgs = pzCmd;
|
||||
|
||||
execvp (pzCmd, ppArgs);
|
||||
fprintf (stderr, "Error %d: Could not execvp( '%s', ... ): %s\n",
|
||||
errno, pzCmd, strerror (errno));
|
||||
exit (EXIT_PANIC);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* p2open
|
||||
*
|
||||
* Given a pointer to an argument vector, start a process and
|
||||
* place its stdin and stdout file descriptors into an fd pair
|
||||
* structure. The "writeFd" connects to the inferior process
|
||||
* stdin, and the "readFd" connects to its stdout. The calling
|
||||
* process should write to "writeFd" and read from "readFd".
|
||||
* The return value is the process id of the created process.
|
||||
*/
|
||||
pid_t
|
||||
p2open (pPair, ppArgs)
|
||||
tFdPair *pPair;
|
||||
tpChar *ppArgs;
|
||||
{
|
||||
pid_t chId;
|
||||
|
||||
/*
|
||||
* Create a bi-directional pipe. Writes on 0 arrive on 1
|
||||
* and vice versa, so the parent and child processes will
|
||||
* read and write to opposite FD's.
|
||||
*/
|
||||
if (pipe ((int *) pPair) < 0)
|
||||
return NOPROCESS;
|
||||
|
||||
pPair->readFd = chainOpen (pPair->readFd, ppArgs, &chId);
|
||||
if (chId == NOPROCESS)
|
||||
close (pPair->writeFd);
|
||||
|
||||
return chId;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* p2fopen
|
||||
*
|
||||
* Identical to "p2open()", except that the "fd"'s are "fdopen(3)"-ed
|
||||
* into file pointers instead.
|
||||
*/
|
||||
pid_t
|
||||
p2fopen (pfPair, ppArgs)
|
||||
tpfPair *pfPair;
|
||||
tpChar *ppArgs;
|
||||
{
|
||||
tFdPair fdPair;
|
||||
pid_t chId = p2open (&fdPair, ppArgs);
|
||||
|
||||
if (chId == NOPROCESS)
|
||||
return chId;
|
||||
|
||||
pfPair->pfRead = fdopen (fdPair.readFd, "r");
|
||||
pfPair->pfWrite = fdopen (fdPair.writeFd, "w");
|
||||
return chId;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* loadData
|
||||
*
|
||||
* Read data from a file pointer (a pipe to a process in this context)
|
||||
* until we either get EOF or we get a marker line back.
|
||||
* The read data are stored in a malloc-ed string that is truncated
|
||||
* to size at the end. Input is assumed to be an ASCII string.
|
||||
*/
|
||||
STATIC char *
|
||||
loadData (fp)
|
||||
FILE *fp;
|
||||
{
|
||||
char *pzText;
|
||||
size_t textSize;
|
||||
char *pzScan;
|
||||
char zLine[1024];
|
||||
|
||||
textSize = sizeof (zLine) * 2;
|
||||
pzScan = \
|
||||
pzText = malloc (textSize);
|
||||
|
||||
if (pzText == (char *) NULL)
|
||||
return pzText;
|
||||
|
||||
for (;;)
|
||||
{
|
||||
size_t usedCt;
|
||||
|
||||
alarm (10);
|
||||
readPipeTimeout = BOOL_FALSE;
|
||||
if (fgets (zLine, sizeof (zLine), fp) == (char *) NULL)
|
||||
break;
|
||||
|
||||
if (strncmp (zLine, zDone, sizeof (zDone) - 1) == 0)
|
||||
break;
|
||||
|
||||
strcpy (pzScan, zLine);
|
||||
pzScan += strlen (zLine);
|
||||
usedCt = (size_t) (pzScan - pzText);
|
||||
|
||||
if (textSize - usedCt < sizeof (zLine))
|
||||
{
|
||||
|
||||
size_t off = (size_t) (pzScan - pzText);
|
||||
void *p;
|
||||
textSize += 4096;
|
||||
p = realloc ((void *) pzText, textSize);
|
||||
if (p == (void *) NULL)
|
||||
{
|
||||
fprintf (stderr, "Failed to get 0x%08X bytes\n", textSize);
|
||||
free ((void *) pzText);
|
||||
return (char *) NULL;
|
||||
}
|
||||
|
||||
pzText = (char *) p;
|
||||
pzScan = pzText + off;
|
||||
}
|
||||
}
|
||||
|
||||
alarm (0);
|
||||
if (readPipeTimeout)
|
||||
{
|
||||
free ((void *) pzText);
|
||||
return (char *) NULL;
|
||||
}
|
||||
|
||||
while ((pzScan > pzText) && isspace (pzScan[-1]))
|
||||
pzScan--;
|
||||
*pzScan = NUL;
|
||||
return realloc ((void *) pzText, strlen (pzText) + 1);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* SHELL SERVER PROCESS CODE
|
||||
*/
|
||||
|
||||
#ifdef DONT_HAVE_SIGSEND
|
||||
typedef enum
|
||||
{
|
||||
P_ALL, P_PID, P_GID, P_UID, P_PGID, P_SID, P_CID
|
||||
}
|
||||
idtype_t;
|
||||
typedef long id_t;
|
||||
|
||||
STATIC int
|
||||
sigsend (idtype, id, sig)
|
||||
idtype_t idtype;
|
||||
id_t id;
|
||||
int sig;
|
||||
{
|
||||
switch (idtype)
|
||||
{
|
||||
case P_PID:
|
||||
kill ((pid_t) id, sig);
|
||||
break;
|
||||
|
||||
case P_ALL:
|
||||
case P_GID:
|
||||
case P_UID:
|
||||
case P_PGID:
|
||||
case P_SID:
|
||||
case P_CID:
|
||||
errno = EINVAL;
|
||||
return -1;
|
||||
/*NOTREACHED */
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
#endif /* HAVE_SIGSEND */
|
||||
|
||||
|
||||
STATIC void
|
||||
closeServer ()
|
||||
{
|
||||
kill( (pid_t) serverId, SIGKILL);
|
||||
serverId = NULLPROCESS;
|
||||
fclose (serverPair.pfRead);
|
||||
fclose (serverPair.pfWrite);
|
||||
serverPair.pfRead = serverPair.pfWrite = (FILE *) NULL;
|
||||
}
|
||||
|
||||
|
||||
struct sigaction savePipeAction;
|
||||
struct sigaction saveAlrmAction;
|
||||
struct sigaction currentAction;
|
||||
|
||||
STATIC void
|
||||
sigHandler (signo)
|
||||
int signo;
|
||||
{
|
||||
closeServer ();
|
||||
readPipeTimeout = BOOL_TRUE;
|
||||
}
|
||||
|
||||
|
||||
STATIC void
|
||||
serverSetup ()
|
||||
{
|
||||
#ifndef SA_SIGINFO
|
||||
# define SA_SIGINFO 0
|
||||
#else
|
||||
currentAction.sa_sigaction =
|
||||
#endif
|
||||
currentAction.sa_handler = sigHandler;
|
||||
currentAction.sa_flags = SA_SIGINFO;
|
||||
sigemptyset( ¤tAction.sa_mask );
|
||||
|
||||
sigaction( SIGPIPE, ¤tAction, &savePipeAction );
|
||||
sigaction( SIGALRM, ¤tAction, &saveAlrmAction );
|
||||
atexit( &closeServer );
|
||||
|
||||
fputs ("trap : INT\n", serverPair.pfWrite);
|
||||
fflush (serverPair.pfWrite);
|
||||
pCurDir = getcwd ((char *) NULL, MAXPATHLEN + 1);
|
||||
}
|
||||
|
||||
|
||||
char *
|
||||
runShell (pzCmd)
|
||||
const char *pzCmd;
|
||||
{
|
||||
tSCC zNil[] = "";
|
||||
|
||||
/*
|
||||
* IF the shell server process is not running yet,
|
||||
* THEN try to start it.
|
||||
*/
|
||||
if (serverId == NULLPROCESS)
|
||||
{
|
||||
serverId = p2fopen (&serverPair, defArgs);
|
||||
if (serverId > 0)
|
||||
serverSetup ();
|
||||
}
|
||||
|
||||
/*
|
||||
* IF it is still not running,
|
||||
* THEN return the nil string.
|
||||
*/
|
||||
if (serverId <= 0)
|
||||
return (char *) zNil;
|
||||
|
||||
/*
|
||||
* Make sure the process will pay attention to us,
|
||||
* send the supplied command, and then
|
||||
* have it output a special marker that we can find.
|
||||
*/
|
||||
fprintf (serverPair.pfWrite, "\\cd %s\n%s\n\necho\necho %s\n",
|
||||
pCurDir, pzCmd, zDone);
|
||||
fflush (serverPair.pfWrite);
|
||||
if (serverId == NULLPROCESS)
|
||||
return (char *) NULL;
|
||||
|
||||
/*
|
||||
* Now try to read back all the data. If we fail due to either
|
||||
* a sigpipe or sigalrm (timeout), we will return the nil string.
|
||||
*/
|
||||
{
|
||||
char *pz = loadData (serverPair.pfRead);
|
||||
if (pz == (char *) NULL)
|
||||
{
|
||||
fprintf (stderr, "CLOSING SHELL SERVER - command failure:\n\t%s\n",
|
||||
pzCmd);
|
||||
closeServer ();
|
||||
pz = (char *) zNil;
|
||||
}
|
||||
return pz;
|
||||
}
|
||||
}
|
||||
|
|
@ -1,94 +0,0 @@
|
|||
|
||||
/*
|
||||
* $Id: server.h,v 1.1 1998/03/20 16:19:41 korbb Exp $
|
||||
*
|
||||
* Server Handling copyright 1992-1998 Bruce Korb
|
||||
*
|
||||
* Server Handling is free software.
|
||||
* You may redistribute it and/or modify it under the terms of the
|
||||
* GNU General Public License, as published by the Free Software
|
||||
* Foundation; either version 2, or (at your option) any later version.
|
||||
*
|
||||
* Server Handling is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with Server Handling. See the file "COPYING". If not,
|
||||
* write to: The Free Software Foundation, Inc.,
|
||||
* 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
*
|
||||
* As a special exception, Bruce Korb gives permission for additional
|
||||
* uses of the text contained in his release of ServerHandler.
|
||||
*
|
||||
* The exception is that, if you link the ServerHandler library with other
|
||||
* files to produce an executable, this does not by itself cause the
|
||||
* resulting executable to be covered by the GNU General Public License.
|
||||
* Your use of that executable is in no way restricted on account of
|
||||
* linking the ServerHandler library code into it.
|
||||
*
|
||||
* This exception does not however invalidate any other reasons why
|
||||
* the executable file might be covered by the GNU General Public License.
|
||||
*
|
||||
* This exception applies only to the code released by Bruce Korb under
|
||||
* the name ServerHandler. If you copy code from other sources under the
|
||||
* General Public License into a copy of ServerHandler, as the General Public
|
||||
* License permits, the exception does not apply to the code that you add
|
||||
* in this way. To avoid misleading anyone as to the status of such
|
||||
* modified files, you must delete this exception notice from them.
|
||||
*
|
||||
* If you write modifications of your own for ServerHandler, it is your
|
||||
* choice whether to permit this exception to apply to your modifications.
|
||||
* If you do not wish that, delete this exception notice.
|
||||
*/
|
||||
|
||||
#ifndef FIXINC_SERVER_H
|
||||
#define FIXINC_SERVER_H
|
||||
|
||||
#include <stdio.h>
|
||||
#include <unistd.h>
|
||||
|
||||
/*
|
||||
* Dual pipe opening of a child process
|
||||
*/
|
||||
|
||||
typedef struct
|
||||
{
|
||||
int readFd;
|
||||
int writeFd;
|
||||
}
|
||||
tFdPair;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
FILE *pfRead; /* parent read fp */
|
||||
FILE *pfWrite; /* parent write fp */
|
||||
}
|
||||
tpfPair;
|
||||
|
||||
typedef char *tpChar;
|
||||
|
||||
#define NOPROCESS ((pid_t)-1)
|
||||
#define NULLPROCESS ((pid_t)0)
|
||||
|
||||
#define EXIT_PANIC 99
|
||||
|
||||
typedef enum
|
||||
{
|
||||
BOOL_FALSE, BOOL_TRUE
|
||||
}
|
||||
bool;
|
||||
|
||||
#define _P_(p) ()
|
||||
|
||||
char *runShell _P_ ((const char *pzCmd));
|
||||
pid_t p2fopen _P_ ((tpfPair * pfPair, tpChar * ppArgs));
|
||||
pid_t p2open _P_ ((tFdPair * pPair, tpChar * ppArgs));
|
||||
int
|
||||
chainOpen _P_ ((int stdinFd,
|
||||
tpChar * ppArgs,
|
||||
pid_t * pChild));
|
||||
|
||||
#endif /* FIXINC_SERVER_H */
|
||||
Loading…
Reference in New Issue