snailed
/
void-packages
2
0
Fork 0
Code Issues 1 Pull Requests 2 Actions Activity

Added rcorder-2009.01 template, taken from NetBSD HEAD. 

--HG--
extra : convert_revision : 84eaf0c93bae0a069eb7a8e242d6c0e4b97af019
This commit is contained in:
Juan RP 2009-03-05 19:39:23 +01:00
parent 4c2e44acc3
commit 7f403680eb
10 changed files with 2013 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
templates/rcorder/files/Makefile Normal file
View File

@ -0,0 +1,5 @@
BIN= rcorder
OBJS= fgetln.o fparseln.o ealloc.o hash.o rcorder.o
TOPDIR= ../../..
include $(TOPDIR)/prog.mk

20
templates/rcorder/files/defs.h Normal file
View File

@ -0,0 +1,20 @@
#ifndef _DEFS_H_
#define _DEFS_H_
#include <stdio.h>
#include <stdlib.h>
#define FPARSELN_UNESCESC 0x01
#define FPARSELN_UNESCCONT 0x02
#define FPARSELN_UNESCCOMM 0x04
#define FPARSELN_UNESCREST 0x08
#define FPARSELN_UNESCALL 0x0f
char *fgetln(FILE *, size_t *);
char *fparseln(FILE *, size_t *, size_t *, const char [3], int);
void *emalloc(size_t);
char *estrdup(const char *);
void *erealloc(void *, size_t);
void *ecalloc(size_t, size_t);
#endif /* ! _DEFS_H_ */

144
templates/rcorder/files/ealloc.c Normal file
View File

@ -0,0 +1,144 @@
/* $NetBSD: ealloc.c,v 1.2 2004/08/27 03:06:07 jlam Exp $ */
/*
* Copyright (c) 1988, 1989, 1990, 1993
* The Regents of the University of California. All rights reserved.
*
* This code is derived from software contributed to Berkeley by
* Adam de Boor.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
/*
* Copyright (c) 1989 by Berkeley Softworks
* All rights reserved.
*
* This code is derived from software contributed to Berkeley by
* Adam de Boor.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Berkeley and its contributors.
* 4. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <err.h>
#include "defs.h"
static void enomem(void);
/*
* enomem --
* die when out of memory.
*/
static void
enomem(void)
{
errx(2, "Cannot allocate memory.");
}
/*
* emalloc --
* malloc, but die on error.
*/
void *
emalloc(size_t len)
{
void *p;
if ((p = malloc(len)) == NULL)
enomem();
return(p);
}
/*
* estrdup --
* strdup, but die on error.
*/
char *
estrdup(const char *str)
{
char *p;
if ((p = strdup(str)) == NULL)
enomem();
return(p);
}
/*
* erealloc --
* realloc, but die on error.
*/
void *
erealloc(void *ptr, size_t size)
{
if ((ptr = realloc(ptr, size)) == NULL)
enomem();
return(ptr);
}
/*
* ecalloc --
* calloc, but die on error.
*/
void *
ecalloc(size_t nmemb, size_t size)
{
void *ptr;
if ((ptr = calloc(nmemb, size)) == NULL)
enomem();
return(ptr);
}

80
templates/rcorder/files/fgetln.c Normal file
View File

@ -0,0 +1,80 @@
/* $NetBSD: fgetln.c,v 1.5 2008/04/29 05:46:08 martin Exp $ */
/*-
* Copyright (c) 1998 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Christos Zoulas.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include "defs.h"
/*
* XXX: This implementation doesn't quite conform to the specification
* in the man page, in that it only manages one buffer at all, not one
* per stdio stream. Since the previous implementation did the same,
* this won't break anything new.
*/
char *
fgetln(FILE *fp, size_t *len)
{
static char *buf = NULL;
static size_t bufsiz = 0;
static size_t buflen = 0;
int c;
if (buf == NULL) {
bufsiz = BUFSIZ;
if ((buf = malloc(bufsiz)) == NULL)
return NULL;
}
buflen = 0;
while ((c = fgetc(fp)) != EOF) {
if (buflen >= bufsiz) {
size_t nbufsiz = bufsiz + BUFSIZ;
char *nbuf = realloc(buf, nbufsiz);
if (nbuf == NULL) {
int oerrno = errno;
free(buf);
errno = oerrno;
buf = NULL;
return NULL;
}
buf = nbuf;
bufsiz = nbufsiz;
}
buf[buflen++] = c;
if (c == '\n')
break;
}
*len = buflen;
return buflen == 0 ? NULL : buf;
}

178
templates/rcorder/files/fparseln.c Normal file
View File

@ -0,0 +1,178 @@
/* $NetBSD: fparseln.c,v 1.3 2004/08/23 03:32:12 jlam Exp $ */
/*
* Copyright (c) 1997 Christos Zoulas. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by Christos Zoulas.
* 4. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <assert.h>
#include <errno.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "defs.h"
static int isescaped(const char *, const char *, int);
/* isescaped():
* Return true if the character in *p that belongs to a string
* that starts in *sp, is escaped by the escape character esc.
*/
static int
isescaped(const char *sp, const char *p, int esc)
{
const char *cp;
size_t ne;
/* No escape character */
if (esc == '\0')
return 1;
/* Count the number of escape characters that precede ours */
for (ne = 0, cp = p; --cp >= sp && *cp == esc; ne++)
continue;
/* Return true if odd number of escape characters */
return (ne & 1) != 0;
}
/* fparseln():
* Read a line from a file parsing continuations ending in \
* and eliminating trailing newlines, or comments starting with
* the comment char.
*/
char *
fparseln(FILE *fp, size_t *size, size_t *lineno, const char str[3], int flags)
{
static const char dstr[3] = { '\\', '\\', '#' };
size_t s, len;
char *buf;
char *ptr, *cp;
int cnt;
char esc, con, nl, com;
len = 0;
buf = NULL;
cnt = 1;
if (str == NULL)
str = dstr;
esc = str[0];
con = str[1];
com = str[2];
/*
* XXX: it would be cool to be able to specify the newline character,
* but unfortunately, fgetln does not let us
*/
nl = '\n';
while (cnt) {
cnt = 0;
if (lineno)
(*lineno)++;
if ((ptr = fgetln(fp, &s)) == NULL)
break;
if (s && com) { /* Check and eliminate comments */
for (cp = ptr; cp < ptr + s; cp++)
if (*cp == com && !isescaped(ptr, cp, esc)) {
s = cp - ptr;
cnt = s == 0 && buf == NULL;
break;
}
}
if (s && nl) { /* Check and eliminate newlines */
cp = &ptr[s - 1];
if (*cp == nl)
s--; /* forget newline */
}
if (s && con) { /* Check and eliminate continuations */
cp = &ptr[s - 1];
if (*cp == con && !isescaped(ptr, cp, esc)) {
s--; /* forget escape */
cnt = 1;
}
}
if (s == 0 && buf != NULL)
continue;
if ((cp = realloc(buf, len + s + 1)) == NULL) {
free(buf);
return NULL;
}
buf = cp;
(void) memcpy(buf + len, ptr, s);
len += s;
buf[len] = '\0';
}
if ((flags & FPARSELN_UNESCALL) != 0 && esc && buf != NULL &&
strchr(buf, esc) != NULL) {
ptr = cp = buf;
while (cp[0] != '\0') {
int skipesc;
while (cp[0] != '\0' && cp[0] != esc)
*ptr++ = *cp++;
if (cp[0] == '\0' || cp[1] == '\0')
break;
skipesc = 0;
if (cp[1] == com)
skipesc += (flags & FPARSELN_UNESCCOMM);
if (cp[1] == con)
skipesc += (flags & FPARSELN_UNESCCONT);
if (cp[1] == esc)
skipesc += (flags & FPARSELN_UNESCESC);
if (cp[1] != com && cp[1] != con && cp[1] != esc)
skipesc = (flags & FPARSELN_UNESCREST);
if (skipesc)
cp++;
else
*ptr++ = *cp++;
*ptr++ = *cp++;
}
*ptr = '\0';
len = strlen(buf);
}
if (size)
*size = len;
return buf;
}

455
templates/rcorder/files/hash.c Normal file
View File

@ -0,0 +1,455 @@
/* $NetBSD: hash.c,v 1.5 2007/03/03 00:09:30 simonb Exp $ */
/*
* Copyright (c) 1988, 1989, 1990 The Regents of the University of California.
* All rights reserved.
*
* This code is derived from software contributed to Berkeley by
* Adam de Boor.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
/*
* Copyright (c) 1988, 1989 by Adam de Boor
* Copyright (c) 1989 by Berkeley Softworks
* All rights reserved.
*
* This code is derived from software contributed to Berkeley by
* Adam de Boor.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Berkeley and its contributors.
* 4. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#include <sys/types.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <err.h>
#include "defs.h"
/* hash.c --
*
* This module contains routines to manipulate a hash table.
* See hash.h for a definition of the structure of the hash
* table. Hash tables grow automatically as the amount of
* information increases.
*/
#include "hash.h"
/*
* Forward references to local procedures that are used before they're
* defined:
*/
static void RebuildTable(Hash_Table *);
/*
* The following defines the ratio of # entries to # buckets
* at which we rebuild the table to make it larger.
*/
#define rebuildLimit 8
/*
*---------------------------------------------------------
*
* Hash_InitTable --
*
* This routine just sets up the hash table.
*
* Input:
* t Structure to use to hold table.
* numBuckets How many buckets to create for starters. This number
* is rounded up to a power of two. If <= 0, a reasonable
* default is chosen. The table will grow in size later
* as needed.
*
* Results:
* None.
*
* Side Effects:
* Memory is allocated for the initial bucket area.
*
*---------------------------------------------------------
*/
void
Hash_InitTable(Hash_Table *t, int numBuckets)
{
int i;
struct Hash_Entry **hp;
/*
* Round up the size to a power of two.
*/
if (numBuckets <= 0)
i = 16;
else {
for (i = 2; i < numBuckets; i <<= 1)
continue;
}
t->numEntries = 0;
t->size = i;
t->mask = i - 1;
t->bucketPtr = hp = (struct Hash_Entry **)emalloc(sizeof(*hp) * i);
while (--i >= 0)
*hp++ = NULL;
}
/*
*---------------------------------------------------------
*
* Hash_DeleteTable --
*
* This routine removes everything from a hash table
* and frees up the memory space it occupied (except for
* the space in the Hash_Table structure).
*
* Results:
* None.
*
* Side Effects:
* Lots of memory is freed up.
*
*---------------------------------------------------------
*/
void
Hash_DeleteTable(Hash_Table *t)
{
struct Hash_Entry **hp, *h, *nexth;
int i;
nexth = NULL;
for (hp = t->bucketPtr, i = t->size; --i >= 0;) {
for (h = *hp++; h != NULL; h = nexth) {
nexth = h->next;
free(h);
}
}
free(t->bucketPtr);
/*
* Set up the hash table to cause memory faults on any future access
* attempts until re-initialization.
*/
t->bucketPtr = NULL;
}
/*
*---------------------------------------------------------
*
* Hash_FindEntry --
*
* Searches a hash table for an entry corresponding to key.
*
* Input:
* t Hash table to search.
* key A hash key.
*
* Results:
* The return value is a pointer to the entry for key,
* if key was present in the table. If key was not
* present, NULL is returned.
*
* Side Effects:
* None.
*
*---------------------------------------------------------
*/
Hash_Entry *
Hash_FindEntry(Hash_Table *t, char *key)
{
Hash_Entry *e;
unsigned h;
char *p;
for (h = 0, p = key; *p;)
h = (h << 5) - h + *p++;
p = key;
for (e = t->bucketPtr[h & t->mask]; e != NULL; e = e->next)
if (e->namehash == h && strcmp(e->name, p) == 0)
return (e);
return (NULL);
}
/*
*---------------------------------------------------------
*
* Hash_CreateEntry --
*
* Searches a hash table for an entry corresponding to
* key. If no entry is found, then one is created.
*
* Input:
* t Hash table to search.
* key A hash key.
* newPtr Filled in with 1 if new entry created, 0 otherwise.
*
* Results:
* The return value is a pointer to the entry. If *newPtr
* isn't NULL, then *newPtr is filled in with TRUE if a
* new entry was created, and FALSE if an entry already existed
* with the given key.
*
* Side Effects:
* Memory may be allocated, and the hash buckets may be modified.
*---------------------------------------------------------
*/
Hash_Entry *
Hash_CreateEntry(Hash_Table *t, char *key, int *newPtr)
{
Hash_Entry *e;
unsigned h;
char *p;
int keylen;
struct Hash_Entry **hp;
/*
* Hash the key. As a side effect, save the length (strlen) of the
* key in case we need to create the entry.
*/
for (h = 0, p = key; *p;)
h = (h << 5) - h + *p++;
keylen = p - key;
p = key;
for (e = t->bucketPtr[h & t->mask]; e != NULL; e = e->next) {
if (e->namehash == h && strcmp(e->name, p) == 0) {
if (newPtr != NULL)
*newPtr = 0;
return (e);
}
}
/*
* The desired entry isn't there. Before allocating a new entry,
* expand the table if necessary (and this changes the resulting
* bucket chain).
*/
if (t->numEntries >= rebuildLimit * t->size)
RebuildTable(t);
e = (Hash_Entry *) emalloc(sizeof(*e) + keylen);
hp = &t->bucketPtr[h & t->mask];
e->next = *hp;
*hp = e;
e->clientData = NULL;
e->namehash = h;
(void) strcpy(e->name, p);
t->numEntries++;
if (newPtr != NULL)
*newPtr = 1;
return (e);
}
/*
*---------------------------------------------------------
*
* Hash_DeleteEntry --
*
* Delete the given hash table entry and free memory associated with
* it.
*
* Results:
* None.
*
* Side Effects:
* Hash chain that entry lives in is modified and memory is freed.
*
*---------------------------------------------------------
*/
void
Hash_DeleteEntry(Hash_Table *t, Hash_Entry *e)
{
Hash_Entry **hp, *p;
if (e == NULL)
return;
for (hp = &t->bucketPtr[e->namehash & t->mask];
(p = *hp) != NULL; hp = &p->next) {
if (p == e) {
*hp = p->next;
free(p);
t->numEntries--;
return;
}
}
(void)write(2, "bad call to Hash_DeleteEntry\n", 29);
abort();
}
/*
*---------------------------------------------------------
*
* Hash_EnumFirst --
* This procedure sets things up for a complete search
* of all entries recorded in the hash table.
*
* Input:
* t Table to be searched.
* searchPtr Area in which to keep state about search.
*
* Results:
* The return value is the address of the first entry in
* the hash table, or NULL if the table is empty.
*
* Side Effects:
* The information in searchPtr is initialized so that successive
* calls to Hash_Next will return successive HashEntry's
* from the table.
*
*---------------------------------------------------------
*/
Hash_Entry *
Hash_EnumFirst(Hash_Table *t, Hash_Search *searchPtr)
{
searchPtr->tablePtr = t;
searchPtr->nextIndex = 0;
searchPtr->hashEntryPtr = NULL;
return Hash_EnumNext(searchPtr);
}
/*
*---------------------------------------------------------
*
* Hash_EnumNext --
* This procedure returns successive entries in the hash table.
*
* Results:
* The return value is a pointer to the next HashEntry
* in the table, or NULL when the end of the table is
* reached.
*
* Side Effects:
* The information in searchPtr is modified to advance to the
* next entry.
*
*---------------------------------------------------------
*/
Hash_Entry *
Hash_EnumNext(Hash_Search *searchPtr)
{
Hash_Entry *e;
Hash_Table *t = searchPtr->tablePtr;
/*
* The hashEntryPtr field points to the most recently returned
* entry, or is nil if we are starting up. If not nil, we have
* to start at the next one in the chain.
*/
e = searchPtr->hashEntryPtr;
if (e != NULL)
e = e->next;
/*
* If the chain ran out, or if we are starting up, we need to
* find the next nonempty chain.
*/
while (e == NULL) {
if (searchPtr->nextIndex >= t->size)
return (NULL);
e = t->bucketPtr[searchPtr->nextIndex++];
}
searchPtr->hashEntryPtr = e;
return (e);
}
/*
*---------------------------------------------------------
*
* RebuildTable --
* This local routine makes a new hash table that
* is larger than the old one.
*
* Results:
* None.
*
* Side Effects:
* The entire hash table is moved, so any bucket numbers
* from the old table are invalid.
*
*---------------------------------------------------------
*/
static void
RebuildTable(Hash_Table *t)
{
Hash_Entry *e, *next, **hp, **xp;
int i, mask;
Hash_Entry **oldhp;
int oldsize;
next = NULL;
oldhp = t->bucketPtr;
oldsize = i = t->size;
i <<= 1;
t->size = i;
t->mask = mask = i - 1;
t->bucketPtr = hp = (struct Hash_Entry **) emalloc(sizeof(*hp) * i);
while (--i >= 0)
*hp++ = NULL;
for (hp = oldhp, i = oldsize; --i >= 0;) {
for (e = *hp++; e != NULL; e = next) {
next = e->next;
xp = &t->bucketPtr[e->namehash & mask];
e->next = *xp;
*xp = e;
}
}
free(oldhp);
}

161
templates/rcorder/files/hash.h Normal file
View File

@ -0,0 +1,161 @@
/* $NetBSD: hash.h,v 1.3 2003/08/07 10:04:37 agc Exp $ */
/*
* Copyright (c) 1988, 1989, 1990 The Regents of the University of California.
* All rights reserved.
*
* This code is derived from software contributed to Berkeley by
* Adam de Boor.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* from: @(#)hash.h 8.1 (Berkeley) 6/6/93
*/
/*
* Copyright (c) 1988, 1989 by Adam de Boor
* Copyright (c) 1989 by Berkeley Softworks
* All rights reserved.
*
* This code is derived from software contributed to Berkeley by
* Adam de Boor.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Berkeley and its contributors.
* 4. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* from: @(#)hash.h 8.1 (Berkeley) 6/6/93
*/
/* hash.h --
*
* This file contains definitions used by the hash module,
* which maintains hash tables.
*/
#ifndef _HASH
#define _HASH
/*
* The following defines one entry in the hash table.
*/
typedef struct Hash_Entry {
struct Hash_Entry *next; /* Used to link together all the
* entries associated with the same
* bucket. */
void *clientData; /* Arbitrary piece of data associated
* with key. */
unsigned namehash; /* hash value of key */
char name[1]; /* key string */
} Hash_Entry;
typedef struct Hash_Table {
struct Hash_Entry **bucketPtr;
/* Pointers to Hash_Entry, one
* for each bucket in the table. */
int size; /* Actual size of array. */
int numEntries; /* Number of entries in the table. */
int mask; /* Used to select bits for hashing. */
} Hash_Table;
/*
* The following structure is used by the searching routines
* to record where we are in the search.
*/
typedef struct Hash_Search {
Hash_Table *tablePtr; /* Table being searched. */
int nextIndex; /* Next bucket to check (after
* current). */
Hash_Entry *hashEntryPtr; /* Next entry to check in current
* bucket. */
} Hash_Search;
/*
* Macros.
*/
/*
* void *Hash_GetValue(h)
* Hash_Entry *h;
*/
#define Hash_GetValue(h) ((h)->clientData)
/*
* Hash_SetValue(h, val);
* Hash_Entry *h;
* char *val;
*/
#define Hash_SetValue(h, val) ((h)->clientData = (void *) (val))
/*
* Hash_GetKey(h);
* Hash_Entry *h;
*/
#define Hash_GetKey(h) ((h)->name)
/*
* Hash_Size(n) returns the number of words in an object of n bytes
*/
#define Hash_Size(n) (((n) + sizeof (int) - 1) / sizeof (int))
void Hash_InitTable(Hash_Table *, int);
void Hash_DeleteTable(Hash_Table *);
Hash_Entry *Hash_FindEntry(Hash_Table *, char *);
Hash_Entry *Hash_CreateEntry(Hash_Table *, char *, int *);
void Hash_DeleteEntry(Hash_Table *, Hash_Entry *);
Hash_Entry *Hash_EnumFirst(Hash_Table *, Hash_Search *);
Hash_Entry *Hash_EnumNext(Hash_Search *);
#endif /* _HASH */

171
templates/rcorder/files/rcorder.8 Normal file
View File

@ -0,0 +1,171 @@
.\" $NetBSD: rcorder.8,v 1.8 2005/06/23 12:01:48 peter Exp $
.\"
.\" Copyright (c) 1998
.\" Perry E. Metzger. All rights reserved.
.\"
.\" Redistribution and use in source and binary forms, with or without
.\" modification, are permitted provided that the following conditions
.\" are met:
.\" 1. Redistributions of source code must retain the above copyright
.\" notice, this list of conditions and the following disclaimer.
.\" 2. Redistributions in binary form must reproduce the above copyright
.\" notice, this list of conditions and the following disclaimer in the
.\" documentation and/or other materials provided with the distribution.
.\" 3. All advertising materials mentioning features or use of this software
.\" must display the following acknowledgment:
.\" This product includes software developed for the NetBSD Project
.\" by Perry E. Metzger.
.\" 4. The name of the author may not be used to endorse or promote products
.\" derived from this software without specific prior written permission.
.\"
.\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
.\" IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
.\" OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
.\" IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
.\" INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
.\" NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
.\" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
.\" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
.\" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
.\" THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
.\"
.\"
.Dd April 23, 2003
.Dt RCORDER 8
.Os
.Sh NAME
.Nm rcorder
.Nd print a dependency ordering of interdependent files
.Sh SYNOPSIS
.Nm
.Op Fl k Ar keep
.Op Fl s Ar skip
.Ar
.Sh DESCRIPTION
.Nm
is designed to print out a dependency ordering of a set of
interdependent files.
Typically it is used to find an execution sequence for a set of
shell scripts in which certain files must be executed before others.
.Pp
Each file passed to
.Nm
should be annotated with special lines (which look like comments to the
shell) which indicate the dependencies the files have upon certain
points in the sequence, known as
.Dq conditions ,
and which indicate, for each file, which
.Dq conditions
may be expected to be filled by that file.
.Pp
Within each file, a block containing a series of
.Dq REQUIRE ,
.Dq PROVIDE ,
.Dq BEFORE
and
.Dq KEYWORD
lines should appear.
The format of the lines is rigid.
Each line must begin with a single
.Dq # ,
followed by a single space, followed by
.Dq PROVIDE: ,
.Dq REQUIRE: ,
.Dq BEFORE: ,
or
.Dq KEYWORD: .
No deviation is permitted.
Each dependency line is then followed by a series of conditions,
separated by whitespace.
Multiple
.Dq PROVIDE ,
.Dq REQUIRE ,
.Dq BEFORE
and
.Dq KEYWORD
lines may appear, but all such lines must appear in a sequence without
any intervening lines, as once a line that does not follow the format
is reached, parsing stops.
.Pp
The options are as follows:
.Bl -tag -width Ds
.It Fl k
Add the specified keyword to the
.Dq keep list .
If any
.Fl k
option is given, only those files containing the matching keyword are listed.
.It Fl s
Add the specified keyword to the
.Dq skip list .
If any
.Fl s
option is given, files containing the matching keyword are not listed.
.El
.Pp
An example block follows:
.Bd -literal -offset indent
# REQUIRE: networking syslog
# REQUIRE: usr
# PROVIDE: dns nscd
.Ed
.Pp
This block states that the file in which it appears depends upon the
.Dq networking ,
.Dq syslog ,
and
.Dq usr
conditions, and provides the
.Dq dns
and
.Dq nscd
conditions.
.Pp
A file may contain zero
.Dq PROVIDE
lines, in which case it provides no conditions, and may contain zero
.Dq REQUIRE
lines, in which case it has no dependencies.
A file containing no
.Dq PROVIDE ,
.Dq REQUIRE ,
or
.Dq BEFORE
lines may be output at an arbitrary position in the dependency
ordering.
.Pp
There must be at least one file with no dependencies in the set of
arguments passed to
.Nm
in order for it to find a starting place in the dependency ordering.
.Sh DIAGNOSTICS
.Nm
may print one of the following error messages and exit with a non-zero
status if it encounters an error while processing the file list.
.Bl -diag
.It "Requirement %s has no providers, aborting."
No file has a
.Dq PROVIDE
line corresponding to a condition present in a
.Dq REQUIRE
line in another file.
.It "Circular dependency on provision %s, aborting."
A set of files has a circular dependency which was detected while
processing the stated condition.
.It "Circular dependency on file %s, aborting."
A set of files has a circular dependency which was detected while
processing the stated file.
.El
.Sh SEE ALSO
.Xr rc 8
.Sh HISTORY
The
.Nm
program first appeared in
.Nx 1.5 .
.Sh AUTHORS
.An -nosplit
Written by
.An Perry E. Metzger Aq perry@piermont.com
and
.An Matthew R. Green Aq mrg@eterna.com.au .

770
templates/rcorder/files/rcorder.c Normal file
View File

@ -0,0 +1,770 @@
/* $NetBSD: rcorder.c,v 1.16 2008/08/03 07:49:46 lukem Exp $ */
/*
* Copyright (c) 1998, 1999 Matthew R. Green
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/*
* Copyright (c) 1998
* Perry E. Metzger. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed for the NetBSD Project
* by Perry E. Metzger.
* 4. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <sys/types.h>
#include <sys/stat.h>
#include <err.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "defs.h"
#include "hash.h"
#ifdef DEBUG
int debug = 0;
# define DPRINTF(args) if (debug) { fflush(stdout); fprintf args; }
#else
# define DPRINTF(args)
#endif
#define REQUIRE_STR "# REQUIRE:"
#define REQUIRE_LEN (sizeof(REQUIRE_STR) - 1)
#define REQUIRES_STR "# REQUIRES:"
#define REQUIRES_LEN (sizeof(REQUIRES_STR) - 1)
#define PROVIDE_STR "# PROVIDE:"
#define PROVIDE_LEN (sizeof(PROVIDE_STR) - 1)
#define PROVIDES_STR "# PROVIDES:"
#define PROVIDES_LEN (sizeof(PROVIDES_STR) - 1)
#define BEFORE_STR "# BEFORE:"
#define BEFORE_LEN (sizeof(BEFORE_STR) - 1)
#define KEYWORD_STR "# KEYWORD:"
#define KEYWORD_LEN (sizeof(KEYWORD_STR) - 1)
#define KEYWORDS_STR "# KEYWORDS:"
#define KEYWORDS_LEN (sizeof(KEYWORDS_STR) - 1)
int exit_code;
int file_count;
char **file_list;
enum {
RESET = 0,
SET = 1,
};
Hash_Table provide_hash_s, *provide_hash;
typedef struct provnode provnode;
typedef struct filenode filenode;
typedef struct f_provnode f_provnode;
typedef struct f_reqnode f_reqnode;
typedef struct strnodelist strnodelist;
struct provnode {
int head;
int in_progress;
filenode *fnode;
provnode *next, *last;
};
struct f_provnode {
provnode *pnode;
f_provnode *next;
};
struct f_reqnode {
Hash_Entry *entry;
f_reqnode *next;
};
struct strnodelist {
filenode *node;
strnodelist *next;
char s[1];
};
struct filenode {
char *filename;
int in_progress;
filenode *next, *last;
f_reqnode *req_list;
f_provnode *prov_list;
strnodelist *keyword_list;
};
filenode fn_head_s, *fn_head;
strnodelist *bl_list;
strnodelist *keep_list;
strnodelist *skip_list;
void do_file(filenode *fnode);
void strnode_add(strnodelist **, char *, filenode *);
int skip_ok(filenode *fnode);
int keep_ok(filenode *fnode);
void satisfy_req(f_reqnode *rnode, char *);
void crunch_file(char *);
void parse_line(filenode *, char *, void (*)(filenode *, char *));
filenode *filenode_new(char *);
void add_require(filenode *, char *);
void add_provide(filenode *, char *);
void add_before(filenode *, char *);
void add_keyword(filenode *, char *);
void insert_before(void);
Hash_Entry *make_fake_provision(filenode *);
void crunch_all_files(void);
void initialize(void);
void generate_ordering(void);
int main(int, char *[]);
int
main(int argc, char *argv[])
{
int ch;
while ((ch = getopt(argc, argv, "dk:s:")) != -1)
switch (ch) {
case 'd':
#ifdef DEBUG
debug = 1;
#else
warnx("debugging not compiled in, -d ignored");
#endif
break;
case 'k':
strnode_add(&keep_list, optarg, 0);
break;
case 's':
strnode_add(&skip_list, optarg, 0);
break;
default:
/* XXX should crunch it? */
break;
}
argc -= optind;
argv += optind;
file_count = argc;
file_list = argv;
DPRINTF((stderr, "parse_args\n"));
initialize();
DPRINTF((stderr, "initialize\n"));
crunch_all_files();
DPRINTF((stderr, "crunch_all_files\n"));
generate_ordering();
DPRINTF((stderr, "generate_ordering\n"));
exit(exit_code);
}
/*
* initialise various variables.
*/
void
initialize(void)
{
fn_head = &fn_head_s;
provide_hash = &provide_hash_s;
Hash_InitTable(provide_hash, file_count);
}
/* generic function to insert a new strnodelist element */
void
strnode_add(strnodelist **listp, char *s, filenode *fnode)
{
strnodelist *ent;
ent = emalloc(sizeof *ent + strlen(s));
ent->node = fnode;
strcpy(ent->s, s);
ent->next = *listp;
*listp = ent;
}
/*
* below are the functions that deal with creating the lists
* from the filename's given and the dependancies and provisions
* in each of these files. no ordering or checking is done here.
*/
/*
* we have a new filename, create a new filenode structure.
* fill in the bits, and put it in the filenode linked list
*/
filenode *
filenode_new(char *filename)
{
filenode *temp;
temp = emalloc(sizeof(*temp));
memset(temp, 0, sizeof(*temp));
temp->filename = estrdup(filename);
temp->req_list = NULL;
temp->prov_list = NULL;
temp->keyword_list = NULL;
temp->in_progress = RESET;
/*
* link the filenode into the list of filenodes.
* note that the double linking means we can delete a
* filenode without searching for where it belongs.
*/
temp->next = fn_head->next;
if (temp->next != NULL)
temp->next->last = temp;
temp->last = fn_head;
fn_head->next = temp;
return (temp);
}
/*
* add a requirement to a filenode.
*/
void
add_require(filenode *fnode, char *s)
{
Hash_Entry *entry;
f_reqnode *rnode;
int new;
entry = Hash_CreateEntry(provide_hash, s, &new);
if (new)
Hash_SetValue(entry, NULL);
rnode = emalloc(sizeof(*rnode));
rnode->entry = entry;
rnode->next = fnode->req_list;
fnode->req_list = rnode;
}
/*
* add a provision to a filenode. if this provision doesn't
* have a head node, create one here.
*/
void
add_provide(filenode *fnode, char *s)
{
Hash_Entry *entry;
f_provnode *f_pnode;
provnode *pnode, *head;
int new;
entry = Hash_CreateEntry(provide_hash, s, &new);
head = Hash_GetValue(entry);
/* create a head node if necessary. */
if (head == NULL) {
head = emalloc(sizeof(*head));
head->head = SET;
head->in_progress = RESET;
head->fnode = NULL;
head->last = head->next = NULL;
Hash_SetValue(entry, head);
}
#if 0
/*
* Don't warn about this. We want to be able to support
* scripts that do two complex things:
*
* - Two independent scripts which both provide the
* same thing. Both scripts must be executed in
* any order to meet the barrier. An example:
*
* Script 1:
*
* PROVIDE: mail
* REQUIRE: LOGIN
*
* Script 2:
*
* PROVIDE: mail
* REQUIRE: LOGIN
*
* - Two interdependent scripts which both provide the
* same thing. Both scripts must be executed in
* graph order to meet the barrier. An example:
*
* Script 1:
*
* PROVIDE: nameservice dnscache
* REQUIRE: SERVERS
*
* Script 2:
*
* PROVIDE: nameservice nscd
* REQUIRE: dnscache
*/
else if (new == 0) {
warnx("file `%s' provides `%s'.", fnode->filename, s);
warnx("\tpreviously seen in `%s'.",
head->next->fnode->filename);
}
#endif
pnode = emalloc(sizeof(*pnode));
pnode->head = RESET;
pnode->in_progress = RESET;
pnode->fnode = fnode;
pnode->next = head->next;
pnode->last = head;
head->next = pnode;
if (pnode->next != NULL)
pnode->next->last = pnode;
f_pnode = emalloc(sizeof(*f_pnode));
f_pnode->pnode = pnode;
f_pnode->next = fnode->prov_list;
fnode->prov_list = f_pnode;
}
/*
* put the BEFORE: lines to a list and handle them later.
*/
void
add_before(filenode *fnode, char *s)
{
strnode_add(&bl_list, s, fnode);
}
/*
* add a key to a filenode.
*/
void
add_keyword(filenode *fnode, char *s)
{
strnode_add(&fnode->keyword_list, s, fnode);
}
/*
* loop over the rest of a line, giving each word to
* add_func() to do the real work.
*/
void
parse_line(filenode *node, char *buffer, void (*add_func)(filenode *, char *))
{
char *s;
while ((s = strsep(&buffer, " \t\n")) != NULL)
if (*s != '\0')
(*add_func)(node, s);
}
/*
* given a file name, create a filenode for it, read in lines looking
* for provision and requirement lines, building the graphs as needed.
*/
void
crunch_file(char *filename)
{
FILE *fp;
char *buf;
int require_flag, provide_flag, before_flag, keyword_flag;
enum { BEFORE_PARSING, PARSING, PARSING_DONE } state;
filenode *node;
char delims[3] = { '\\', '\\', '\0' };
struct stat st;
if ((fp = fopen(filename, "r")) == NULL) {
warn("could not open %s", filename);
return;
}
if (fstat(fileno(fp), &st) == -1) {
warn("could not stat %s", filename);
fclose(fp);
return;
}
if (!S_ISREG(st.st_mode)) {
#if 0
warnx("%s is not a file", filename);
#endif
fclose(fp);
return;
}
node = filenode_new(filename);
/*
* we don't care about length, line number, don't want # for comments,
* and have no flags.
*/
for (state = BEFORE_PARSING; state != PARSING_DONE &&
(buf = fparseln(fp, NULL, NULL, delims, 0)) != NULL; free(buf)) {
require_flag = provide_flag = before_flag = keyword_flag = 0;
if (strncmp(REQUIRE_STR, buf, REQUIRE_LEN) == 0)
require_flag = REQUIRE_LEN;
else if (strncmp(REQUIRES_STR, buf, REQUIRES_LEN) == 0)
require_flag = REQUIRES_LEN;
else if (strncmp(PROVIDE_STR, buf, PROVIDE_LEN) == 0)
provide_flag = PROVIDE_LEN;
else if (strncmp(PROVIDES_STR, buf, PROVIDES_LEN) == 0)
provide_flag = PROVIDES_LEN;
else if (strncmp(BEFORE_STR, buf, BEFORE_LEN) == 0)
before_flag = BEFORE_LEN;
else if (strncmp(KEYWORD_STR, buf, KEYWORD_LEN) == 0)
keyword_flag = KEYWORD_LEN;
else if (strncmp(KEYWORDS_STR, buf, KEYWORDS_LEN) == 0)
keyword_flag = KEYWORDS_LEN;
else {
if (state == PARSING)
state = PARSING_DONE;
continue;
}
state = PARSING;
if (require_flag)
parse_line(node, buf + require_flag, add_require);
else if (provide_flag)
parse_line(node, buf + provide_flag, add_provide);
else if (before_flag)
parse_line(node, buf + before_flag, add_before);
else if (keyword_flag)
parse_line(node, buf + keyword_flag, add_keyword);
}
fclose(fp);
}
Hash_Entry *
make_fake_provision(filenode *node)
{
Hash_Entry *entry;
f_provnode *f_pnode;
provnode *head, *pnode;
static int i = 0;
int new;
char buffer[30];
do {
snprintf(buffer, sizeof buffer, "fake_prov_%08d", i++);
entry = Hash_CreateEntry(provide_hash, buffer, &new);
} while (new == 0);
head = emalloc(sizeof(*head));
head->head = SET;
head->in_progress = RESET;
head->fnode = NULL;
head->last = head->next = NULL;
Hash_SetValue(entry, head);
pnode = emalloc(sizeof(*pnode));
pnode->head = RESET;
pnode->in_progress = RESET;
pnode->fnode = node;
pnode->next = head->next;
pnode->last = head;
head->next = pnode;
if (pnode->next != NULL)
pnode->next->last = pnode;
f_pnode = emalloc(sizeof(*f_pnode));
f_pnode->pnode = pnode;
f_pnode->next = node->prov_list;
node->prov_list = f_pnode;
return (entry);
}
/*
* go through the BEFORE list, inserting requirements into the graph(s)
* as required. in the before list, for each entry B, we have a file F
* and a string S. we create a "fake" provision (P) that F provides.
* for each entry in the provision list for S, add a requirement to
* that provisions filenode for P.
*/
void
insert_before(void)
{
Hash_Entry *entry, *fake_prov_entry;
provnode *pnode;
f_reqnode *rnode;
strnodelist *bl;
int new;
while (bl_list != NULL) {
bl = bl_list->next;
fake_prov_entry = make_fake_provision(bl_list->node);
entry = Hash_CreateEntry(provide_hash, bl_list->s, &new);
if (new == 1)
warnx("file `%s' is before unknown provision `%s'",
bl_list->node->filename, bl_list->s);
for (pnode = Hash_GetValue(entry); pnode; pnode = pnode->next) {
if (pnode->head)
continue;
rnode = emalloc(sizeof(*rnode));
rnode->entry = fake_prov_entry;
rnode->next = pnode->fnode->req_list;
pnode->fnode->req_list = rnode;
}
free(bl_list);
bl_list = bl;
}
}
/*
* loop over all the files calling crunch_file() on them to do the
* real work. after we have built all the nodes, insert the BEFORE:
* lines into graph(s).
*/
void
crunch_all_files(void)
{
int i;
for (i = 0; i < file_count; i++)
crunch_file(file_list[i]);
insert_before();
}
/*
* below are the functions that traverse the graphs we have built
* finding out the desired ordering, printing each file in turn.
* if missing requirements, or cyclic graphs are detected, a
* warning will be issued, and we will continue on..
*/
/*
* given a requirement node (in a filename) we attempt to satisfy it.
* we do some sanity checking first, to ensure that we have providers,
* aren't already satisfied and aren't already being satisfied (ie,
* cyclic). if we pass all this, we loop over the provision list
* calling do_file() (enter recursion) for each filenode in this
* provision.
*/
void
satisfy_req(f_reqnode *rnode, char *filename)
{
Hash_Entry *entry;
provnode *head;
entry = rnode->entry;
head = Hash_GetValue(entry);
if (head == NULL) {
warnx("requirement `%s' in file `%s' has no providers.",
Hash_GetKey(entry), filename);
exit_code = 1;
return;
}
/* return if the requirement is already satisfied. */
if (head->next == NULL)
return;
/*
* if list is marked as in progress,
* print that there is a circular dependency on it and abort
*/
if (head->in_progress == SET) {
warnx("Circular dependency on provision `%s' in file `%s'.",
Hash_GetKey(entry), filename);
exit_code = 1;
return;
}
head->in_progress = SET;
/*
* while provision_list is not empty
* do_file(first_member_of(provision_list));
*/
while (head->next != NULL)
do_file(head->next->fnode);
}
int
skip_ok(filenode *fnode)
{
strnodelist *s;
strnodelist *k;
for (s = skip_list; s; s = s->next)
for (k = fnode->keyword_list; k; k = k->next)
if (strcmp(k->s, s->s) == 0)
return (0);
return (1);
}
int
keep_ok(filenode *fnode)
{
strnodelist *s;
strnodelist *k;
for (s = keep_list; s; s = s->next)
for (k = fnode->keyword_list; k; k = k->next)
if (strcmp(k->s, s->s) == 0)
return (1);
/* an empty keep_list means every one */
return (!keep_list);
}
/*
* given a filenode, we ensure we are not a cyclic graph. if this
* is ok, we loop over the filenodes requirements, calling satisfy_req()
* for each of them.. once we have done this, remove this filenode
* from each provision table, as we are now done.
*
* NOTE: do_file() is called recursively from several places and cannot
* safely free() anything related to items that may be recursed on.
* Circular dependancies will cause problems if we do.
*/
void
do_file(filenode *fnode)
{
f_reqnode *r, *r_tmp;
f_provnode *p, *p_tmp;
provnode *pnode;
int was_set;
DPRINTF((stderr, "do_file on %s.\n", fnode->filename));
/*
* if fnode is marked as in progress,
* print that fnode; is circularly depended upon and abort.
*/
if (fnode->in_progress == SET) {
warnx("Circular dependency on file `%s'.",
fnode->filename);
was_set = exit_code = 1;
} else
was_set = 0;
/* mark fnode */
fnode->in_progress = SET;
/*
* for each requirement of fnode -> r
* satisfy_req(r, filename)
*/
r = fnode->req_list;
while (r != NULL) {
r_tmp = r;
satisfy_req(r, fnode->filename);
r = r->next;
#if 0
free(r_tmp);
#endif
}
fnode->req_list = NULL;
/*
* for each provision of fnode -> p
* remove fnode from provision list for p in hash table
*/
p = fnode->prov_list;
while (p != NULL) {
p_tmp = p;
pnode = p->pnode;
if (pnode->next != NULL) {
pnode->next->last = pnode->last;
}
if (pnode->last != NULL) {
pnode->last->next = pnode->next;
}
free(pnode);
p = p->next;
free(p_tmp);
}
fnode->prov_list = NULL;
/* do_it(fnode) */
DPRINTF((stderr, "next do: "));
/* if we were already in progress, don't print again */
if (was_set == 0 && skip_ok(fnode) && keep_ok(fnode))
printf("%s\n", fnode->filename);
if (fnode->next != NULL) {
fnode->next->last = fnode->last;
}
if (fnode->last != NULL) {
fnode->last->next = fnode->next;
}
DPRINTF((stderr, "nuking %s\n", fnode->filename));
#if 0
free(fnode->filename);
free(fnode);
#endif
}
void
generate_ordering(void)
{
/*
* while there remain undone files{f},
* pick an arbitrary f, and do_file(f)
* Note that the first file in the file list is perfectly
* arbitrary, and easy to find, so we use that.
*/
/*
* N.B.: the file nodes "self delete" after they execute, so
* after each iteration of the loop, the head will be pointing
* to something totally different. The loop ends up being
* executed only once for every strongly connected set of
* nodes.
*/
while (fn_head->next != NULL) {
DPRINTF((stderr, "generate on %s\n", fn_head->next->filename));
do_file(fn_head->next);
}
}

29
templates/rcorder/template Normal file
View File

@ -0,0 +1,29 @@
# Template file for 'rcorder'
pkgname=rcorder
version=2009.01
build_style=custom-install
short_desc="The NetBSD rcorder(8) program"
maintainer="Juan RP <xtraeme@gmail.com>"
long_desc="
rcorder is designed to print out a dependency ordering of a set of
interdependent files. Typically it is used to find an execution sequence
for a set of shell scripts in which certain files must be executed before
others.
This package is the same program than is available on NetBSD."
Add_dependency run glibc
do_install()
{
local destdir=$XBPS_DESTDIR/$pkgname-$version
mkdir -p ${destdir}/sbin
mkdir -p ${destdir}/usr/share/man/man8
cd $XBPS_TEMPLATESDIR/rcorder/files
make || exit 1
install -m755 ./rcorder ${destdir}/sbin
install -m644 ./rcorder.8 ${destdir}/usr/share/man/man8
make clean
}