sync/ports
1
0
Fork 0
mirror of https://git.freebsd.org/ports.git synced 2025-07-17 17:29:23 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

- Update to 1.2

Browse source 
- Take maintainership

PR:		ports/108236
Submitted by:	Marcelo Araujo <araujo@bsdmail.org>
This commit is contained in:
Pav Lucistnik 2007-03-17 13:12:57 +00:00
parent cc003edb69
commit e662f2343c
Notes: svn2git 2021-03-31 03:12:20 +00:00 
svn path=/head/; revision=187571
6 changed files with 51 additions and 655 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

21
net/dgd-net/Makefile
View file

@ -6,35 +6,28 @@
#
PORTNAME= dgd-net
PORTVERSION= 1.1.8
PORTVERSION= 1.2
CATEGORIES= net lang
MASTER_SITES= ftp://ftp.dworkin.nl/pub/dgd/archive/ \
http://dl.droso.net/ports/
DISTNAME= dgd-${PORTVERSION:C/.([0-9]*)$/p\1/}
DISTNAME= dgd-${PORTVERSION}
MAINTAINER= ports@FreeBSD.org
COMMENT= "Dworkin's Generic Driver + extra networking support + regexps"
MAINTAINER= araujo@bsdmail.org
COMMENT= Dworkin's Generic Driver + extra networking support + regexps
NO_CDROM= "no distribution to corporate environment"
RESTRICTED= "license required for commercial use"
NO_CDROM= no distribution to corporate environment
RESTRICTED= license required for commercial use
DIST_SUBDIR= dgd
WRKSRC= ${WRKDIR}/dgd/src
ALL_TARGET= install
.include <bsd.port.pre.mk>
.if ${OSVERSION} >= 502126
USE_GCC= 3.3
.endif
pre-patch:
@${LN} -s dgd ${WRKDIR}/dgd+net
@${MKDIR} ${WRKDIR}/dgd/bin
post-build:
@${MV} ${WRKDIR}/dgd/bin/driver ${WRKDIR}/dgd/bin/driver.net
@${MV} ${WRKDIR}/dgd/bin/precomp ${WRKDIR}/dgd/bin/precomp.net
@${MV} ${WRKDIR}/dgd/doc/Introduction ${WRKDIR}/dgd/doc/Introduction.NET
@${MV} ${WRKDIR}/dgd/doc/kfun/send_message ${WRKDIR}/dgd/doc/kfun/send_message.NET
@${CHMOD} o+r ${WRKDIR}/dgd/doc/kfun/*
@ -44,4 +37,4 @@ do-install:
@${TAR} -C ${WRKDIR} -cf - `${GREP} '^dgd/' ${PLIST}` \
| ${TAR} -C ${PREFIX} -xpf -
.include <bsd.port.post.mk>
.include <bsd.port.mk>

6
net/dgd-net/distinfo
View file

@ -1,3 +1,3 @@
MD5 (dgd/dgd-1.1p8.tar.gz) = 8d2321c5f203609401a4eaa138bec469
SHA256 (dgd/dgd-1.1p8.tar.gz) = 1da9f634b35f7f48e7b780b8fb0bee39bb46342f856fc76465a71b731adcc7ec
SIZE (dgd/dgd-1.1p8.tar.gz) = 383324
MD5 (dgd/dgd-1.2.tar.gz) = adc0c9f601454922d3ebf72a241b1c66
SHA256 (dgd/dgd-1.2.tar.gz) = 0ab958ee3b4f3e39e5c0dae47c76d0598e8f25a95154730665825c642c2f4614
SIZE (dgd/dgd-1.2.tar.gz) = 470260

97
net/dgd-net/files/patch-aa
View file

@ -1,56 +1,41 @@
--- Makefile.orig Sat Dec 15 14:14:50 2001
+++ Makefile Sat Dec 15 14:17:42 2001
@@ -6,19 +6,21 @@
DEBUG=
CCFLAGS=-O2 $(DEFINES) $(DEBUG)
CFLAGS= -I. -Icomp -Ilex -Ied -Ikfun $(CCFLAGS)
-LDFLAGS=
-LIBS=
-CC= gcc
+LDFLAGS= -s
+LIBS= -lcrypt -lgnuregex
+CC?= cc
LD= $(CC)
DMAKE= make
BIN= ../bin
OBJ= alloc.o error.o hash.o swap.o str.o array.o object.o data.o path.o \
- editor.o comm.o call_out.o interpret.o config.o dgd.o
+ editor.o comm.o call_out.o interpret.o config.o dgd.o rgx.o
EDOBJ= alloc.o error.o
LEXOBJ= alloc.o hash.o
COMPOBJ=alloc.o error.o hash.o path.o str.o array.o object.o data.o \
- interpret.o config.o
+ interpret.o config.o rgx.o
+
+all: a.out comp/a.out
a.out: $(OBJ) always
cd comp; $(MAKE) 'DMAKE=$(DMAKE)' 'CC=$(CC)' 'CCFLAGS=$(CCFLAGS)' dgd
@@ -38,7 +40,11 @@
-mv $(BIN)/driver $(BIN)/driver.old
cp a.out $(BIN)/driver
-install: $(BIN)/driver
+$(BIN)/precomp: comp/a.out
+ -mv $(BIN)/precomp $(BIN)/precomp.old
+ cp comp/a.out $(BIN)/precomp
+
+install: $(BIN)/driver $(BIN)/precomp
comp.sub: $(COMPOBJ)
@for i in $(COMPOBJ); do echo ../$$i; done > comp.sub
@@ -54,7 +60,7 @@
comp/a.out:
cd comp; $(DMAKE) 'DMAKE=$(DMAKE)' 'CC=$(CC)' 'CCFLAGS=$(CCFLAGS)' \
- 'LIBS=$(LIBS)' a.out
+ 'LDFLAGS=$(LDFLAGS)' 'LIBS=$(LIBS)' a.out
clean:
rm -f a.out $(OBJ) comp.sub lex.sub ed.sub
@@ -92,3 +98,4 @@
call_out.o config.o dgd.o: call_out.h
error.o comm.o call_out.o config.o dgd.o: comm.h
config.o: version.h
+rgx.o: str.h array.h rgx.h interpret.h
*** ../README.FreeBSD Wed Dec 31 16:00:00 1969
--- ../README.FreeBSD Sun Aug 28 06:43:17 1994
***************
*** 0 ****
--- 1,9 ----
+ This is the core distribution of DGD, providing all the tools needed
+ to implement interactive servers, for instance MUD, IRC, WWW, etc.
+ A reference implementation of a kernel library is provided, which can
+ be further built on. Normally with DGD, there is a kernel library to
+ define the programming environment and a database library to define the
+ interaction environment.
+
+ Mudlib simulations are available for LPmud and LambdaMoo environments.
+ Other such simulations are in various stages of development.
*** ../README.sites Wed Dec 31 16:00:00 1969
--- ../README.sites Sun Aug 28 06:27:25 1994
***************
*** 0 ****
--- 1,22 ----
+ DGD MUDs known to be open as of December 1996 are:
+
+ [LPmud and derivatives]
+ IgorMUD: [194.213.74.34] igor.algonet.se 1701 (good typical LPmud)
+ Albion MUD: [193.4.230.10] mud.veda.is 4000 (play and development)
+ Xyllomer: [131.234.10.45] mud.uni-paderborn.de 3000 (enchanting realism)
+ 3M: [192.89.182.3] mmm.megabaud.fi 6047 (M M & mushrooms)
+ DemonWorld: [194.45.175.45] ??? 3000 (roleplaying)
+ ResWorld: [164.11.100.7] tao.btc.uwe.ac.uk 2000 (fantasy)
+
+ All have a more or less medieval or fantasy theme.
+
+ [moo]
+ MirrorMOO: [129.10.114.196] mirror.ccs.neu.edu 8889 (Alice's Wonderland)
+
+ Other sites are also developing their own special mudlibs with DGD.
+
+ [other]
+ FishRoom: [199.89.234.17] kplace.monrou.com 1025 (aquaria discussion)
+
+ Ichat have developed a commercial product based on DGD, called ROOMS. For
+ further information and a list of chat sites, visit http://www.ichat.com

41
net/dgd-net/files/patch-ab
View file

@ -1,41 +0,0 @@
*** ../README.FreeBSD Wed Dec 31 16:00:00 1969
--- ../README.FreeBSD Sun Aug 28 06:43:17 1994
***************
*** 0 ****
--- 1,9 ----
+ This is the core distribution of DGD, providing all the tools needed
+ to implement interactive servers, for instance MUD, IRC, WWW, etc.
+ A reference implementation of a kernel library is provided, which can
+ be further built on. Normally with DGD, there is a kernel library to
+ define the programming environment and a database library to define the
+ interaction environment.
+
+ Mudlib simulations are available for LPmud and LambdaMoo environments.
+ Other such simulations are in various stages of development.
*** ../README.sites Wed Dec 31 16:00:00 1969
--- ../README.sites Sun Aug 28 06:27:25 1994
***************
*** 0 ****
--- 1,22 ----
+ DGD MUDs known to be open as of December 1996 are:
+
+ [LPmud and derivatives]
+ IgorMUD: [194.213.74.34] igor.algonet.se 1701 (good typical LPmud)
+ Albion MUD: [193.4.230.10] mud.veda.is 4000 (play and development)
+ Xyllomer: [131.234.10.45] mud.uni-paderborn.de 3000 (enchanting realism)
+ 3M: [192.89.182.3] mmm.megabaud.fi 6047 (M M & mushrooms)
+ DemonWorld: [194.45.175.45] ??? 3000 (roleplaying)
+ ResWorld: [164.11.100.7] tao.btc.uwe.ac.uk 2000 (fantasy)
+
+ All have a more or less medieval or fantasy theme.
+
+ [moo]
+ MirrorMOO: [129.10.114.196] mirror.ccs.neu.edu 8889 (Alice's Wonderland)
+
+ Other sites are also developing their own special mudlibs with DGD.
+
+ [other]
+ FishRoom: [199.89.234.17] kplace.monrou.com 1025 (aquaria discussion)
+
+ Ichat have developed a commercial product based on DGD, called ROOMS. For
+ further information and a list of chat sites, visit http://www.ichat.com

532
net/dgd-net/files/patch-ad
View file

@ -1,532 +0,0 @@
*** src.rgx/config.c Thu Jan 2 23:34:31 1997
--- config.c Thu Jan 2 23:51:21 1997
***************
*** 19,24 ****
--- 19,25 ----
# include "compile.h"
# include "csupport.h"
# include "table.h"
+ # include "rgx.h"
typedef struct {
char *name; /* name of the option */
***************
*** 810,815 ****
--- 811,819 ----
/* initialize interpreter */
i_init(conf[CREATE].u.str);
+
+ /* initialize regular expressions */
+ rgx_init();
/* initialize compiler */
c_init(conf[AUTO_OBJECT].u.str,
*** src.rgx/kfun/extra.c Tue Sep 27 09:28:26 1994
--- kfun/extra.c Thu Feb 2 22:25:18 1995
***************
*** 560,562 ****
--- 560,640 ----
error("Not yet implemented");
}
# endif
+
+
+ # ifdef FUNCDEF
+ FUNCDEF("regexp_compile", kf_regexp_compile, p_regexp_compile)
+ # else
+ char p_regexp_compile[] = { C_TYPECHECKED | C_STATIC | C_VARARGS,
+ T_STRING | (1 << REFSHIFT), 2, T_STRING, T_INT };
+
+ /*
+ * NAME: kfun->regexp_compile()
+ * DESCRIPTION: compile a regexp pattern
+ */
+ int kf_regexp_compile(nargs)
+ int nargs;
+ {
+ int case_matters;
+ array *compiled;
+
+ if (nargs < 1)
+ return -1;
+
+ case_matters = (nargs == 2 ? ! (sp++)->u.number : 1);
+
+ compiled = rgx_new(sp->u.string, case_matters);
+
+ str_del(sp->u.string);
+ sp->type = T_ARRAY;
+ arr_ref(sp->u.array = compiled);
+
+ return 0;
+ }
+ # endif
+
+
+ # ifdef FUNCDEF
+ FUNCDEF("regexp_match", kf_regexp_match, p_regexp_match)
+ # else
+ char p_regexp_match[] = { C_TYPECHECKED | C_STATIC | C_VARARGS,
+ T_INT | (1 << REFSHIFT), 3,
+ T_STRING | (1 << REFSHIFT), T_STRING, T_INT };
+
+ /*
+ * NAME: kfun->regexp_match()
+ * DESCRIPTION: perform regexp matching with a previously compiled pattern
+ */
+ int kf_regexp_match(nargs)
+ int nargs;
+ {
+ int reverse;
+ string *subject;
+ array *compiled, *result;
+
+ if (nargs < 2)
+ return -1;
+
+ reverse = (nargs == 3 ? (sp++)->u.number : 0);
+ subject = sp->u.string;
+ compiled = sp[1].u.array;
+
+ if (compiled->size != 3)
+ return 1;
+
+ result = rgx_match(d_get_elts(compiled), subject, reverse);
+
+ str_del((sp++)->u.string);
+ arr_del(sp->u.array);
+
+ if (result == (array *) 0)
+ {
+ sp->type = T_INT;
+ sp->u.number = 0;
+ }
+ else
+ arr_ref(sp->u.array = result);
+
+ return 0;
+ }
+ # endif
*** src.rgx/kfun/kfun.h Sun May 8 08:15:01 1994
--- kfun/kfun.h Thu Feb 2 22:25:18 1995
***************
*** 5,7 ****
--- 5,8 ----
# include "xfloat.h"
# include "interpret.h"
# include "data.h"
+ # include "rgx.h"
*** src.rgx/rgx.c Thu Jan 2 21:41:55 1997
--- rgx.c Thu Jan 2 21:17:46 1997
***************
*** 0 ****
--- 1,213 ----
+ # include "dgd.h"
+ # include "str.h"
+ # include "array.h"
+ # include "interpret.h"
+ # include <gnuregex.h>
+ # include "rgx.h"
+ # include <memory.h>
+
+ static char trans_table[256];
+
+ /*
+ * NAME: regexp->init()
+ * DESCRIPTION: initialize regexp handling
+ */
+ void rgx_init()
+ {
+ register int i;
+
+ for (i = 0; i < 256; ++i)
+ trans_table[i] = i;
+ for (i = 'a'; i <= 'z'; ++i)
+ trans_table[i] = i + 'A' - 'a';
+ }
+
+ /*
+ * NAME: regexp->new()
+ * DESCRIPTION: create a new regexp buffer
+ */
+ array *rgx_new(pattern, case_matters)
+ string *pattern;
+ int case_matters;
+ {
+ char *translate;
+ struct re_pattern_buffer patbuf;
+ char fastmap[256];
+ const char *compile_error;
+ array *result;
+ register value *v;
+ string *s;
+
+ translate = (case_matters ? (char *) 0 : trans_table);
+
+ patbuf.buffer = 0;
+ patbuf.allocated = 0;
+ patbuf.used = 0;
+
+ patbuf.fastmap = fastmap;
+ patbuf.translate = translate;
+
+ patbuf.fastmap_accurate = 0;
+
+ {
+ int i;
+ long n = 0;
+ for (i = 0; i < pattern->len; i++) {
+ switch (pattern->text[i]) {
+ case '[':
+ if (pattern->text[++i] == '^')
+ i++;
+ for (i++; i < pattern->len; i++)
+ if (pattern->text[i] == ']')
+ break;
+ break;
+ case '%':
+ pattern->text[i++] = '\\'; /* skip escaped char */
+ break;
+ case '\\':
+ pattern->text[i] == '%'; /* mark for expansion */
+ n++;
+ break;
+ }
+ }
+ if (n) {
+ int j;
+
+ s = str_new(NULL, pattern->len + n);
+ for (i = j = 0; i < pattern->len; i++, j++) {
+ switch (pattern->text[i]) {
+ case '[':
+ s->text[j++] = pattern->text[i++];
+ if (i == pattern->len)
+ goto breakout;
+ if (pattern->text[i] == '^') {
+ s->text[j++] = pattern->text[i++];
+ if (i == pattern->len)
+ goto breakout;
+ }
+ s->text[j++] = pattern->text[i++];
+ if (i == pattern->len)
+ goto breakout;
+ for ( ; i < pattern->len; i++, j++) {
+ if ((s->text[j] = pattern->text[i]) == ']')
+ break;
+ }
+ break;
+ case '%': /* expand */
+ s->text[j++] = '\\';
+ s->text[j] = '\\';
+ break;
+ case '\\': /* skip escaped char */
+ s->text[j++] = pattern->text[i++];
+ if (i == pattern->len)
+ goto breakout;
+ /* fallthru */
+ default:
+ s->text[j] = pattern->text[i];
+ }
+ }
+ breakout:
+ }
+ }
+ compile_error = re_compile_pattern(s->text, s->len, &patbuf);
+ str_del(s);
+ if (compile_error != (char *) 0)
+ {
+ regfree(&patbuf);
+ error(compile_error);
+ }
+
+ re_compile_fastmap(&patbuf);
+
+ result = arr_new(3L);
+ v = result->elts;
+
+ v->type = T_STRING;
+ str_ref(v->u.string = str_new((char *) &patbuf, (long) sizeof(patbuf)));
+ ++v;
+ v->type = T_STRING;
+ str_ref(v->u.string = str_new((char *) patbuf.buffer,
+ (long) patbuf.allocated));
+ ++v;
+ v->type = T_STRING;
+ str_ref(v->u.string = str_new(fastmap, 256L));
+
+ /* don't let regfree() try to free these */
+ patbuf.fastmap = 0;
+ patbuf.translate = 0;
+
+ regfree(&patbuf);
+
+ return result;
+ }
+
+ /*
+ * NAME: regexp->match()
+ * DESCRIPTION: perform regexp matching, given a pattern and subject string
+ */
+ array *rgx_match(pattern, subject, reverse)
+ value *pattern;
+ string *subject;
+ int reverse;
+ {
+ long sub_len;
+ struct re_pattern_buffer patbuf;
+ struct re_registers regs;
+ regoff_t starts[RGX_NREGS + 1], ends[RGX_NREGS + 1];
+ array *result;
+ register value *v;
+ register int i;
+
+ if (pattern[0].u.string->len != sizeof(struct re_pattern_buffer))
+ error("Invalid compiled pattern");
+
+ memcpy((char *) &patbuf, pattern[0].u.string->text,
+ sizeof(struct re_pattern_buffer));
+
+ if (patbuf.allocated != (unsigned long) pattern[1].u.string->len ||
+ pattern[2].u.string->len != 256)
+ error("Invalid compiled pattern");
+
+ patbuf.buffer = (unsigned char *) pattern[1].u.string->text;
+ patbuf.fastmap = pattern[2].u.string->text;
+
+ regs.num_regs = RGX_NREGS;
+ regs.start = starts;
+ regs.end = ends;
+ patbuf.regs_allocated = REGS_FIXED;
+
+ sub_len = subject->len;
+ if (re_search(&patbuf, subject->text, sub_len, reverse ? sub_len : 0,
+ reverse ? -(sub_len + 1) : sub_len + 1, &regs) == -1)
+ return (array *) 0;
+
+ result = arr_new((long) RGX_NREGS * 2);
+ v = result->elts;
+
+ v->type = T_INT;
+ v->u.number = starts[0];
+ ++v;
+
+ v->type = T_INT;
+ v->u.number = ends[0] - 1;
+ ++v;
+
+ for (i = 1; i < RGX_NREGS; ++i, v += 2)
+ {
+ v[0].type = T_INT;
+ v[1].type = T_INT;
+
+ if (starts[i] == -1)
+ {
+ v[0].u.number = 0;
+ v[1].u.number = -1;
+ }
+ else
+ {
+ v[0].u.number = starts[i];
+ v[1].u.number = ends[i] - 1;
+ }
+ }
+
+ return result;
+ }
*** src.rgx/rgx.h Thu Jan 2 21:42:05 1997
--- rgx.h Fri Feb 3 03:09:54 1995
***************
*** 0 ****
--- 1,5 ----
+ # define RGX_NREGS 10
+
+ extern void rgx_init P((void));
+ extern array *rgx_new P((string*, int));
+ extern array *rgx_match P((value*, string*, int));
*** doc.rgx/rgx_example.c Thu Jan 1 00:00:00 1970
--- ../doc/rgx_example.c Fri Feb 3 03:30:01 1995
***************
*** 0 ****
--- 1,49 ----
+ /*
+ * This file shows how an interface can be built to cache regexp patterns
+ * and ultimately provide a more streamlined interface to the regexp kfuns.
+ *
+ * Note that since regexp_match() severely depends on the return result from
+ * regexp_compile() being unaltered, it is a good idea to provide an
+ * interface like this, and also to mask the regexp_match() kfun from the
+ * auto object.
+ */
+
+ # define CACHE_SIZE 10
+
+ private mapping cache;
+ private string *list;
+ private string last_pattern;
+
+ static
+ void create(void)
+ {
+ cache = ([ ]);
+ list = ({ });
+ }
+
+ int *match(string subject, string pattern)
+ {
+ string *buffer;
+
+ if ((buffer = cache[pattern]) == 0)
+ {
+ buffer = regexp_compile(pattern);
+
+ if (sizeof(list) >= CACHE_SIZE)
+ {
+ cache[list[0]] = 0;
+ list = list[1 ..] + ({ pattern });
+ }
+ else
+ list += ({ pattern });
+
+ cache[pattern] = buffer;
+ }
+ else if (pattern != last_pattern)
+ {
+ list = list - ({ pattern }) + ({ pattern });
+ last_pattern = pattern;
+ }
+
+ return regexp_match(buffer, subject);
+ }
*** doc.rgx/kfun/regexp_compile Thu Jan 1 00:00:00 1970
--- ../doc/kfun/regexp_compile Tue Jul 26 00:02:34 1994
***************
*** 0 ****
--- 1,27 ----
+ NAME
+ regexp_compile - compile a regular expression
+
+ SYNOPSIS
+ varargs string *regexp_compile(string pattern, int case_insensitive)
+
+ DESCRIPTION
+ The argument pattern is compiled as a regular expression. If the
+ argument case_insensitive is nonzero, the pattern is compiled in
+ such a way that subsequent matching will be done without case
+ sensitivity. The default is to be case-sensitive.
+
+ An array of strings is returned; these strings contain binary
+ data and must not be altered in any way before being passed to
+ regexp_match().
+
+ The compiled regexp can be saved and used any number of times with
+ regexp_match().
+
+ ERRORS
+ If the argument pattern contains a syntactically malformed regular
+ expression, an error will result. An error can also occur if the
+ pattern is too complicated, or if there is not enough memory to
+ compile the pattern.
+
+ SEE ALSO
+ kfun/regexp_match
*** doc.rgx/kfun/regexp_match Thu Jan 1 00:00:00 1970
--- ../doc/kfun/regexp_match Mon Jul 25 22:19:42 1994
***************
*** 0 ****
--- 1,34 ----
+ NAME
+ regexp_match - perform regular expression matching
+
+ SYNOPSIS
+ varargs int *regexp_match(string *pattern, string subject, int reverse)
+
+ DESCRIPTION
+ The argument subject is matched against the compiled regular
+ expression pattern. If the argument reverse is nonzero, matching
+ is performed from right-to-left; otherwise, matching is performed
+ left-to-right.
+
+ The pattern argument must be an array of strings exactly as it
+ was received from regexp_compile(); otherwise, the result of
+ calling this function is undefined.
+
+ If the argument subject could not be matched with the regular
+ expression, 0 is returned. Otherwise, an array of 20 integers
+ is returned with this format:
+
+ ({ start0, end0, start1, end1, ..., start9, end9 })
+
+ Each element is a character index into the subject string. The
+ first two elements, start0 and end0, indicate the part of the subject
+ that was matched by the regular expression as a whole. The following
+ elements indicate the starting and ending indices of each
+ subexpression (denoted by "%(" and "%)" pairs in the original
+ pattern) that were matched.
+
+ If any subexpression was not matched, the corresponding start and
+ end elements will be 0 and -1, respectively.
+
+ SEE ALSO
+ kfun/regexp_compile
*** doc.rgx/regexps Thu Jan 1 00:00:00 1970
--- ../doc/regexps Mon Jul 25 22:58:57 1994
***************
*** 0 ****
--- 1,32 ----
+
+ Regular expressions are composed of the following operators:
+
+ . Match any single character
+ XY Match X immediately followed by Y
+ X* Match zero-or-more of X
+ X+ Match one-or-more of X
+ X? Match zero-or-one of X
+ X%|Y Match either X or Y
+ [charset] Match any single character in `charset'
+ [^charset] Match any single character not in `charset'
+ %(X%) Match X, but also remember the match as a subexpression
+ %digit Match the numbered previous subexpression
+ ^X Match X anchored at the beginning of a line
+ X$ Match X anchored at the end of a line
+ %b Match the empty string at the beginning or end of a word
+ %B Match the empty string only within the middle of a word
+ %< Match the beginning of a word
+ %> Match the end of a word
+ %w Match any word-constituent character
+ %W Match any character that is not word-constituent
+
+ Any other character in a regular expression is matched literally with itself.
+ To match any of the special operator characters .*+?%[^$ literally, precede
+ the character with `%'.
+
+ A `charset' is formed by listing all desired characters with brackets. To
+ include a literal `^' in a charset, do not list it in the first position. To
+ include a literal `]', list it immediately after the opening `[' or `[^'. All
+ characters are non-special (and should not be escaped) within a charset,
+ except `-', which denotes a character range. To include a literal `-', list it
+ either first or last.
*** README.rgx.old Fri Jan 3 03:17:21 1997
--- ../README.rgx Fri Jan 3 03:14:29 1997
***************
*** 0 ****
--- 1,18 ----
+ dgd-rgx was written by Robert Leslie <rob@ccs.neu.edu> as an LPC interface to
+ GNU regex, adding two kfuns to DGD for regular expression matching:
+
+ regexp_compile()
+ regexp_match()
+
+ For a description of the regular expression language accepted by these kfuns,
+ please read doc/regexps.
+
+ Complete details for the two kfuns can be found in the doc/kfun directory.
+
+ Adapted by Adam David <adam@veda.is> for DGD 1.0.97 and to use the unmodified
+ GNU regexp library.
+
+ This software is a modification of DGD, and is therefore protected by the
+ DGD Copyright.
+
+ There is no warranty for this software.

9
net/dgd-net/pkg-plist
View file

@ -2,21 +2,17 @@ dgd/Copyright
dgd/Credits
dgd/README
dgd/README.FreeBSD
dgd/README.rgx
dgd/README.sites
dgd/bin/driver.net
dgd/bin/precomp.net
dgd/doc/Commercial
dgd/doc/Introduction.NET
dgd/doc/LPC.html
dgd/doc/Patching
dgd/doc/Platforms
dgd/doc/editor
dgd/doc/kfun/allocate
dgd/doc/kfun/call_other
dgd/doc/kfun/call_out
dgd/doc/kfun/call_trace
dgd/doc/kfun/catch
dgd/doc/kfun/ceil
dgd/doc/kfun/clone_object
dgd/doc/kfun/compile_object
@ -49,8 +45,6 @@ dgd/doc/kfun/query_editor
dgd/doc/kfun/query_ip_number
dgd/doc/kfun/random
dgd/doc/kfun/read_file
dgd/doc/kfun/regexp_compile
dgd/doc/kfun/regexp_match
dgd/doc/kfun/remove_call_out
dgd/doc/kfun/remove_dir
dgd/doc/kfun/remove_file
@ -70,8 +64,6 @@ dgd/doc/kfun/time
dgd/doc/kfun/typeof
dgd/doc/kfun/users
dgd/doc/kfun/write_file
dgd/doc/regexps
dgd/doc/rgx_example.c
dgd/mud/doc/kernel/efun/add_event
dgd/mud/doc/kernel/efun/call_other
dgd/mud/doc/kernel/efun/call_trace
@ -82,7 +74,6 @@ dgd/mud/doc/kernel/efun/event
dgd/mud/doc/kernel/efun/find_object
dgd/mud/doc/kernel/efun/get_dir
dgd/mud/doc/kernel/efun/query_events
dgd/mud/doc/kernel/efun/query_subscribed
dgd/mud/doc/kernel/efun/remove_event
dgd/mud/doc/kernel/efun/status
dgd/mud/doc/kernel/efun/subscribe_event