예제 #1
0
파일: lex.c 프로젝트: 0xffea/nawk
int regexpr(void)
{
	int c;
	static char *buf = 0;
	static int bufsz = 500;
	char *bp;

	if (buf == 0 && (buf = (char *) malloc(bufsz)) == NULL)
		FATAL("out of space for rex expr");
	bp = buf;
	for ( ; (c = input()) != '/' && c != 0; ) {
		if (!adjbuf(&buf, &bufsz, bp-buf+3, 500, &bp, "regexpr"))
			FATAL("out of space for reg expr %.10s...", buf);
		if (c == '\n') {
			SYNTAX( "newline in regular expression %.10s...", buf ); 
			unput('\n');
			break;
		} else if (c == '\\') {
			*bp++ = '\\'; 
			*bp++ = input();
		} else {
			*bp++ = c;
		}
	}
	*bp = 0;
	if (c == 0)
		SYNTAX("non-terminated regular expression %.10s...", buf);
	yylval.s = tostring(buf);
	unput('/');
	RET(REGEXPR);
}
예제 #2
0
파일: lex.c 프로젝트: OS2World/LIB-POSIX2
int regexpr(void)
{
	int c;
	static char *buf = 0;
	static size_t bufsz = 500;
	char *bp;

	if (buf == 0 && (buf = (char *) malloc(bufsz)) == NULL)
		ERROR "out of space for rex expr" FATAL;
	bp = buf;
	for ( ; (c = input()) != '/' && c != 0; ) {
		if (!adjbuf(&buf, &bufsz, bp-buf+3, 500, &bp, 0))
			ERROR "out of space for reg expr %.10s...", buf FATAL;
		if (c == '\n') {
			ERROR "newline in regular expression %.10s...", buf SYNTAX; 
			unput('\n');
			break;
		} else if (c == '\\') {
			*bp++ = '\\'; 
			*bp++ = input();
		} else {
			*bp++ = c;
		}
	}
	*bp = 0;
	yylval.s = tostring(buf);
	unput('/');
	RET(REGEXPR);
}
예제 #3
0
파일: term.c 프로젝트: mr-justin/freebsd
/*
 * See encode().
 * Do this for a single (probably unicode) value.
 * Does not check for non-decorated glyphs.
 */
static void
encode1(struct termp *p, int c)
{
	enum termfont	  f;

	if (TERMP_SKIPCHAR & p->flags) {
		p->flags &= ~TERMP_SKIPCHAR;
		return;
	}

	if (p->col + 6 >= p->maxcols)
		adjbuf(p, p->col + 6);

	f = term_fonttop(p);

	if (TERMFONT_UNDER == f || TERMFONT_BI == f) {
		p->buf[p->col++] = '_';
		p->buf[p->col++] = 8;
	}
	if (TERMFONT_BOLD == f || TERMFONT_BI == f) {
		if (ASCII_HYPH == c)
			p->buf[p->col++] = '-';
		else
			p->buf[p->col++] = c;
		p->buf[p->col++] = 8;
	}
	p->buf[p->col++] = c;
}
예제 #4
0
파일: term.c 프로젝트: 2asoft/freebsd
/*
 * See encode().
 * Do this for a single (probably unicode) value.
 * Does not check for non-decorated glyphs.
 */
static void
encode1(struct termp *p, int c)
{
	enum termfont	  f;

	if (p->col + 7 >= p->maxcols)
		adjbuf(p, p->col + 7);

	f = (c == ASCII_HYPH || c > 127 || isgraph(c)) ?
	    p->fontq[p->fonti] : TERMFONT_NONE;

	if (p->flags & TERMP_BACKBEFORE) {
		if (p->buf[p->col - 1] == ' ')
			p->col--;
		else
			p->buf[p->col++] = 8;
		p->flags &= ~TERMP_BACKBEFORE;
	}
	if (TERMFONT_UNDER == f || TERMFONT_BI == f) {
		p->buf[p->col++] = '_';
		p->buf[p->col++] = 8;
	}
	if (TERMFONT_BOLD == f || TERMFONT_BI == f) {
		if (ASCII_HYPH == c)
			p->buf[p->col++] = '-';
		else
			p->buf[p->col++] = c;
		p->buf[p->col++] = 8;
	}
	p->buf[p->col++] = c;
	if (p->flags & TERMP_BACKAFTER) {
		p->flags |= TERMP_BACKBEFORE;
		p->flags &= ~TERMP_BACKAFTER;
	}
}
예제 #5
0
파일: term.c 프로젝트: Hooman3/minix
static void
encode(struct termp *p, const char *word, size_t sz)
{
	enum termfont	  f;
	int		  i, len;

	/* LINTED */
	len = sz;

	/*
	 * Encode and buffer a string of characters.  If the current
	 * font mode is unset, buffer directly, else encode then buffer
	 * character by character.
	 */

	if (TERMFONT_NONE == (f = term_fonttop(p))) {
		if (p->col + len >= p->maxcols) 
			adjbuf(p, p->col + len);
		for (i = 0; i < len; i++)
			p->buf[p->col++] = word[i];
		return;
	}

	/* Pre-buffer, assuming worst-case. */

	if (p->col + 1 + (len * 3) >= p->maxcols)
		adjbuf(p, p->col + 1 + (len * 3));

	for (i = 0; i < len; i++) {
		if (ASCII_HYPH != word[i] &&
		    ! isgraph((unsigned char)word[i])) {
			p->buf[p->col++] = word[i];
			continue;
		}

		if (TERMFONT_UNDER == f)
			p->buf[p->col++] = '_';
		else if (ASCII_HYPH == word[i])
			p->buf[p->col++] = '-';
		else
			p->buf[p->col++] = word[i];

		p->buf[p->col++] = 8;
		p->buf[p->col++] = word[i];
	}
}
예제 #6
0
char *cclenter(const char *argp)	/* add a character class */
{
    int i, c, c2;
    uschar *p = (uschar *) argp;
    uschar *op, *bp;
    static uschar *buf = 0;
    static int bufsz = 100;

    op = p;
    if (buf == 0 && (buf = (uschar *) malloc(bufsz)) == NULL)
        FATAL("out of space for character class [%.10s...] 1", p);
    bp = buf;
    for (i = 0; (c = *p++) != 0; ) {
        if (c == '\\') {
            c = quoted((char **) &p);
        } else if (c == '-' && i > 0 && bp[-1] != 0) {
            if (*p != 0) {
                c = bp[-1];
                c2 = *p++;
                if (c2 == '\\')
                    c2 = quoted((char **) &p);
                if (c > c2) {	/* empty; ignore */
                    bp--;
                    i--;
                    continue;
                }
                while (c < c2) {
                    if (!adjbuf((char **) &buf, &bufsz, bp-buf+2, 100, (char **) &bp, "cclenter1"))
                        FATAL("out of space for character class [%.10s...] 2", p);
                    *bp++ = ++c;
                    i++;
                }
                continue;
            }
        }
        if (!adjbuf((char **) &buf, &bufsz, bp-buf+2, 100, (char **) &bp, "cclenter2"))
            FATAL("out of space for character class [%.10s...] 3", p);
        *bp++ = c;
        i++;
    }
    *bp = 0;
    dprintf( ("cclenter: in = |%s|, out = |%s|\n", op, buf) );
    xfree(op);
    return (char *) tostring((char *) buf);
}
예제 #7
0
파일: term.c 프로젝트: ajinkya93/netbsd-src
static void
bufferc(struct termp *p, char c)
{

	if (p->col + 1 >= p->maxcols)
		adjbuf(p, p->col + 1);

	p->buf[p->col++] = c;
}
예제 #8
0
파일: lib.c 프로젝트: GnoConsortium/gno
void recbld(void)	/* create $0 from $1..$NF if necessary */
{
	int i;
	char *r, *p;
	char *buf = record;
	int bufsize = recsize;

	if (donerec == 1)
		return;
	r = buf;
	for (i = 1; i <= *NF; i++) {
		p = getsval(fldtab[i]);
		if (!adjbuf(&buf, &bufsize, 1+strlen(p)+r-buf, recsize, &r, "recbld 1"))
			ERROR "created $0 `%.30s...' too long", buf FATAL;
		while ((*r = *p++) != 0)
			r++;
		if (i < *NF) {
			if (!adjbuf(&buf, &bufsize, 2+strlen(*OFS)+r-buf, recsize, &r, "recbld 2"))
				ERROR "created $0 `%.30s...' too long", buf FATAL;
			for (p = *OFS; (*r = *p++) != 0; )
				r++;
		}
	}
	if (!adjbuf(&buf, &bufsize, 2+r-buf, recsize, &r, "recbld 3"))
		ERROR "built giant record `%.30s...'", buf FATAL;
	*r = '\0';
	   dprintf( ("in recbld inputFS=%s, fldtab[0]=%p\n", inputFS, fldtab[0]) );

	if (buf != record) {	/* increased size of record */
		record = buf;	/* BUG?  memory leak? */
		recsize = bufsize;
	}
	if (freeable(fldtab[0]))
		xfree(fldtab[0]->sval);
	fldtab[0]->tval = REC | STR | DONTFREE;
	fldtab[0]->sval = record;

	   dprintf( ("in recbld inputFS=%s, fldtab[0]=%p\n", inputFS, fldtab[0]) );
	   dprintf( ("recbld = |%s|\n", record) );
	donerec = 1;
}
예제 #9
0
파일: lib.c 프로젝트: darksoul42/bitrig
int readrec(char **pbuf, int *pbufsize, FILE *inf)	/* read one record into buf */
{
	int sep, c;
	char *rr, *buf = *pbuf;
	int bufsize = *pbufsize;

	if (strlen(*FS) >= sizeof(inputFS))
		FATAL("field separator %.10s... is too long", *FS);
	/*fflush(stdout); avoids some buffering problem but makes it 25% slower*/
	strlcpy(inputFS, *FS, sizeof inputFS);	/* for subsequent field splitting */
	if ((sep = **RS) == 0) {
		sep = '\n';
		while ((c=getc(inf)) == '\n' && c != EOF)	/* skip leading \n's */
			;
		if (c != EOF)
			ungetc(c, inf);
	}
	for (rr = buf; ; ) {
		for (; (c=getc(inf)) != sep && c != EOF; ) {
			if (rr-buf+1 > bufsize)
				if (!adjbuf(&buf, &bufsize, 1+rr-buf, recsize, &rr, "readrec 1"))
					FATAL("input record `%.30s...' too long", buf);
			*rr++ = c;
		}
		if (**RS == sep || c == EOF)
			break;
		if ((c = getc(inf)) == '\n' || c == EOF) /* 2 in a row */
			break;
		if (!adjbuf(&buf, &bufsize, 2+rr-buf, recsize, &rr, "readrec 2"))
			FATAL("input record `%.30s...' too long", buf);
		*rr++ = '\n';
		*rr++ = c;
	}
	if (!adjbuf(&buf, &bufsize, 1+rr-buf, recsize, &rr, "readrec 3"))
		FATAL("input record `%.30s...' too long", buf);
	*rr = 0;
	   dprintf( ("readrec saw <%s>, returns %d\n", buf, c == EOF && rr == buf ? 0 : 1) );
	*pbuf = buf;
	*pbufsize = bufsize;
	return c == EOF && rr == buf ? 0 : 1;
}
예제 #10
0
파일: term.c 프로젝트: ajinkya93/netbsd-src
static void
encode(struct termp *p, const char *word, size_t sz)
{
	size_t		  i;

	if (TERMP_SKIPCHAR & p->flags) {
		p->flags &= ~TERMP_SKIPCHAR;
		return;
	}

	/*
	 * Encode and buffer a string of characters.  If the current
	 * font mode is unset, buffer directly, else encode then buffer
	 * character by character.
	 */

	if (p->fontq[p->fonti] == TERMFONT_NONE) {
		if (p->col + sz >= p->maxcols)
			adjbuf(p, p->col + sz);
		for (i = 0; i < sz; i++)
			p->buf[p->col++] = word[i];
		return;
	}

	/* Pre-buffer, assuming worst-case. */

	if (p->col + 1 + (sz * 5) >= p->maxcols)
		adjbuf(p, p->col + 1 + (sz * 5));

	for (i = 0; i < sz; i++) {
		if (ASCII_HYPH == word[i] ||
		    isgraph((unsigned char)word[i]))
			encode1(p, word[i]);
		else
			p->buf[p->col++] = word[i];
	}
}
예제 #11
0
파일: lib.c 프로젝트: jungle0755/minix
void recbld(void)	/* create $0 from $1..$NF if necessary */
{
    int i;
    uschar *r;
    char *p;

    if (donerec == 1)
        return;
    r = record;
    for (i = 1; i <= *NF; i++) {
        p = getsval(fldtab[i]);
        if (!adjbuf(&record, &recsize, 1+strlen(p)+r-record, recsize, &r, "recbld 1"))
            FATAL("created $0 `%.30s...' too long", record);
        while ((*r = *p++) != 0)
            r++;
        if (i < *NF) {
            if (!adjbuf(&record, &recsize, 2+strlen(*OFS)+r-record, recsize, &r, "recbld 2"))
                FATAL("created $0 `%.30s...' too long", record);
            for (p = *OFS; (*r = *p++) != 0; )
                r++;
        }
    }
    if (!adjbuf(&record, &recsize, 2+r-record, recsize, &r, "recbld 3"))
        FATAL("built giant record `%.30s...'", record);
    *r = '\0';
    dprintf( ("in recbld inputFS=%s, fldtab[0]=%p\n", inputFS, fldtab[0]) );

    if (freeable(fldtab[0]))
        xfree(fldtab[0]->sval);
    fldtab[0]->tval = REC | STR | DONTFREE;
    fldtab[0]->sval = record;

    dprintf( ("in recbld inputFS=%s, fldtab[0]=%p\n", inputFS, fldtab[0]) );
    dprintf( ("recbld = |%s|\n", record) );
    donerec = 1;
}
예제 #12
0
파일: term.c 프로젝트: belooussov/mdocml
static void
encode(struct termp *p, const char *word, size_t sz)
{
	size_t		  i;

	if (p->col + 2 + (sz * 5) >= p->maxcols)
		adjbuf(p, p->col + 2 + (sz * 5));

	for (i = 0; i < sz; i++) {
		if (ASCII_HYPH == word[i] ||
		    isgraph((unsigned char)word[i]))
			encode1(p, word[i]);
		else
			p->buf[p->col++] = word[i];
	}
}
예제 #13
0
파일: term.c 프로젝트: Hooman3/minix
/*
 * See encode().
 * Do this for a single (probably unicode) value.
 * Does not check for non-decorated glyphs.
 */
static void
encode1(struct termp *p, int c)
{
	enum termfont	  f;

	if (p->col + 4 >= p->maxcols)
		adjbuf(p, p->col + 4);

	f = term_fonttop(p);

	if (TERMFONT_NONE == f) {
		p->buf[p->col++] = c;
		return;
	} else if (TERMFONT_UNDER == f) {
		p->buf[p->col++] = '_';
	} else
		p->buf[p->col++] = c;

	p->buf[p->col++] = 8;
	p->buf[p->col++] = c;
}
예제 #14
0
Cell *intest(Node **a, int n)	/* a[0] is index (list), a[1] is symtab */
{
	Cell *x, *ap, *k;
	Node *p;
	char *buf;
	char *s;
	int bufsz = recsize;
	int nsub = strlen(*SUBSEP);

	ap = execute(a[1]);	/* array name */
	if (!isarr(ap)) {
		   dprintf( ("making %s into an array\n", ap->nval) );
		if (freeable(ap))
			xfree(ap->sval);
		ap->tval &= ~(STR|NUM|DONTFREE);
		ap->tval |= ARR;
		ap->sval = (char *) makesymtab(NSYMTAB);
	}
	if ((buf = (char *) malloc(bufsz)) == NULL) {
		FATAL("out of memory in intest");
	}
	buf[0] = 0;
	for (p = a[0]; p; p = p->nnext) {
		x = execute(p);	/* expr */
		s = getsval(x);
		if (!adjbuf(&buf, &bufsz, strlen(buf)+strlen(s)+nsub+1, recsize, 0, "intest"))
			FATAL("out of memory deleting %s[%s...]", x->nval, buf);
		strcat(buf, s);
		tempfree(x);
		if (p->nnext)
			strcat(buf, *SUBSEP);
	}
	k = lookup(buf, (Array *) ap->sval);
	tempfree(ap);
	free(buf);
	if (k == NULL)
		return(False);
	else
		return(True);
}
예제 #15
0
Cell *array(Node **a, int n)	/* a[0] is symtab, a[1] is list of subscripts */
{
	Cell *x, *y, *z;
	char *s;
	Node *np;
	char *buf;
	int bufsz = recsize;
	int nsub = strlen(*SUBSEP);

	if ((buf = (char *) malloc(bufsz)) == NULL)
		FATAL("out of memory in array");

	x = execute(a[0]);	/* Cell* for symbol table */
	buf[0] = 0;
	for (np = a[1]; np; np = np->nnext) {
		y = execute(np);	/* subscript */
		s = getsval(y);
		if (!adjbuf(&buf, &bufsz, strlen(buf)+strlen(s)+nsub+1, recsize, 0, "array"))
			FATAL("out of memory for %s[%s...]", x->nval, buf);
		strcat(buf, s);
		if (np->nnext)
			strcat(buf, *SUBSEP);
		tempfree(y);
	}
	if (!isarr(x)) {
		   dprintf( ("making %s into an array\n", NN(x->nval)) );
		if (freeable(x))
			xfree(x->sval);
		x->tval &= ~(STR|NUM|DONTFREE);
		x->tval |= ARR;
		x->sval = (char *) makesymtab(NSYMTAB);
	}
	z = setsymtab(buf, "", 0.0, STR|NUM, (Array *) x->sval);
	z->ctype = OCELL;
	z->csub = CVAR;
	tempfree(x);
	free(buf);
	return(z);
}
예제 #16
0
Cell *awkdelete(Node **a, int n)	/* a[0] is symtab, a[1] is list of subscripts */
{
	Cell *x, *y;
	Node *np;
	char *s;
	int nsub = strlen(*SUBSEP);

	x = execute(a[0]);	/* Cell* for symbol table */
	if (!isarr(x))
		return True;
	if (a[1] == 0) {	/* delete the elements, not the table */
		freesymtab(x);
		x->tval &= ~STR;
		x->tval |= ARR;
		x->sval = (char *) makesymtab(NSYMTAB);
	} else {
		int bufsz = recsize;
		char *buf;
		if ((buf = (char *) malloc(bufsz)) == NULL)
			FATAL("out of memory in adelete");
		buf[0] = 0;
		for (np = a[1]; np; np = np->nnext) {
			y = execute(np);	/* subscript */
			s = getsval(y);
			if (!adjbuf(&buf, &bufsz, strlen(buf)+strlen(s)+nsub+1, recsize, 0, "awkdelete"))
				FATAL("out of memory deleting %s[%s...]", x->nval, buf);
			strcat(buf, s);	
			if (np->nnext)
				strcat(buf, *SUBSEP);
			tempfree(y);
		}
		freeelem(x, buf);
		free(buf);
	}
	tempfree(x);
	return True;
}
예제 #17
0
파일: lex.c 프로젝트: djbclark/bb10qnx
int string(void)
{
	int c, n;
	char *s, *bp;
	static char *buf = 0;
	static int bufsz = 500;

	if (buf == 0 && (buf = (char *) malloc(bufsz)) == NULL)
		FATAL("out of space for strings");
	for (bp = buf; (c = input()) != '"'; ) {
		if (!adjbuf(&buf, &bufsz, bp-buf+2, 500, &bp, 0))
			FATAL("out of space for string %.10s...", buf);
		switch (c) {
		case '\n':
		case '\r':
		case 0:
			SYNTAX( "non-terminated string %.10s...", buf );
			lineno++;
			if (c == 0)	/* hopeless */
				FATAL( "giving up" );
			break;
		case '\\':
			c = input();
			switch (c) {
			case '"': *bp++ = '"'; break;
			case 'n': *bp++ = '\n'; break;	
			case 't': *bp++ = '\t'; break;
			case 'f': *bp++ = '\f'; break;
			case 'r': *bp++ = '\r'; break;
			case 'b': *bp++ = '\b'; break;
			case 'v': *bp++ = '\v'; break;
			case 'a': *bp++ = '\007'; break;
			case '\\': *bp++ = '\\'; break;

			case '0': case '1': case '2': /* octal: \d \dd \ddd */
			case '3': case '4': case '5': case '6': case '7':
				n = c - '0';
				if ((c = peek()) >= '0' && c < '8') {
					n = 8 * n + input() - '0';
					if ((c = peek()) >= '0' && c < '8')
						n = 8 * n + input() - '0';
				}
				*bp++ = n;
				break;

			case 'x':	/* hex  \x0-9a-fA-F + */
			    {	char xbuf[100], *px;
				for (px = xbuf; (c = input()) != 0 && px-xbuf < 100-2; ) {
					if (isdigit(c)
					 || (c >= 'a' && c <= 'f')
					 || (c >= 'A' && c <= 'F'))
						*px++ = c;
					else
						break;
				}
				*px = 0;
				unput(c);
	  			sscanf(xbuf, "%x", &n);
				*bp++ = n;
				break;
			    }

			default: 
				*bp++ = c;
				break;
			}
			break;
		default:
			*bp++ = c;
			break;
		}
	}
	*bp = 0; 
	s = tostring(buf);
	*bp++ = ' '; *bp++ = 0;
	yylval.cp = setsymtab(buf, s, 0.0, CON|STR|DONTFREE, symtab);
	RET(STRING);
}
예제 #18
0
파일: lex.c 프로젝트: djbclark/bb10qnx
int gettok(char **pbuf, int *psz)	/* get next input token */
{
	int c, retc;
	char *buf = *pbuf;
	int sz = *psz;
	char *bp = buf;

	c = input();
	if (c == 0)
		return 0;
	buf[0] = c;
	buf[1] = 0;
	if (!isalnum(c) && c != '.' && c != '_')
		return c;

	*bp++ = c;
	if (isalpha(c) || c == '_') {	/* it's a varname */
		for ( ; (c = input()) != 0; ) {
			if (bp-buf >= sz)
				if (!adjbuf(&buf, &sz, bp-buf+2, 100, &bp, 0))
					FATAL( "out of space for name %.10s...", buf );
			if (isalnum(c) || c == '_')
				*bp++ = c;
			else {
				*bp = 0;
				unput(c);
				break;
			}
		}
		*bp = 0;
		retc = 'a';	/* alphanumeric */
	} else {	/* maybe it's a number, but could be . */
		char *rem;
		/* read input until can't be a number */
		for ( ; (c = input()) != 0; ) {
			if (bp-buf >= sz)
				if (!adjbuf(&buf, &sz, bp-buf+2, 100, &bp, 0))
					FATAL( "out of space for number %.10s...", buf );
			if (isdigit(c) || c == 'e' || c == 'E' 
			  || c == '.' || c == '+' || c == '-')
				*bp++ = c;
			else {
				unput(c);
				break;
			}
		}
		*bp = 0;
		strtod(buf, &rem);	/* parse the number */
		if (rem == buf) {	/* it wasn't a valid number at all */
			buf[1] = 0;	/* return one character as token */
			retc = buf[0];	/* character is its own type */
			unputstr(rem+1); /* put rest back for later */
		} else {	/* some prefix was a number */
			unputstr(rem);	/* put rest back for later */
			rem[0] = 0;	/* truncate buf after number part */
			retc = '0';	/* type is number */
		}
	}
	*pbuf = buf;
	*psz = sz;
	return retc;
}
예제 #19
0
Cell *gsub(Node **a, int nnn)	/* global substitute */
{
	Cell *x, *y;
	char *rptr, *sptr, *t, *pb, *q;
	char *buf;
	fa *pfa;
	int mflag, tempstat, num;
	int bufsz = recsize;

	if ((buf = (char *) malloc(bufsz)) == NULL)
		FATAL("out of memory in gsub");
	mflag = 0;	/* if mflag == 0, can replace empty string */
	num = 0;
	x = execute(a[3]);	/* target string */
	t = getsval(x);
	if (a[0] == 0)		/* 0 => a[1] is already-compiled regexpr */
		pfa = (fa *) a[1];	/* regular expression */
	else {
		y = execute(a[1]);
		pfa = makedfa(getsval(y), 1);
		tempfree(y);
	}
	y = execute(a[2]);	/* replacement string */
	if (pmatch(pfa, t)) {
		tempstat = pfa->initstat;
		pfa->initstat = 2;
		pb = buf;
		rptr = getsval(y);
		do {
			if (patlen == 0 && *patbeg != 0) {	/* matched empty string */
				if (mflag == 0) {	/* can replace empty */
					num++;
					sptr = rptr;
					while (*sptr != 0) {
						adjbuf(&buf, &bufsz, 5+pb-buf, recsize, &pb, "gsub");
						if (*sptr == '\\') {
							backsub(&pb, &sptr);
						} else if (*sptr == '&') {
							sptr++;
							adjbuf(&buf, &bufsz, 1+patlen+pb-buf, recsize, &pb, "gsub");
							for (q = patbeg; q < patbeg+patlen; )
								*pb++ = *q++;
						} else
							*pb++ = *sptr++;
					}
				}
				if (*t == 0)	/* at end */
					goto done;
				adjbuf(&buf, &bufsz, 2+pb-buf, recsize, &pb, "gsub");
				*pb++ = *t++;
				if (pb > buf + bufsz)	/* BUG: not sure of this test */
					FATAL("gsub result0 %.30s too big; can't happen", buf);
				mflag = 0;
			}
			else {	/* matched nonempty string */
				num++;
				sptr = t;
				adjbuf(&buf, &bufsz, 1+(patbeg-sptr)+pb-buf, recsize, &pb, "gsub");
				while (sptr < patbeg)
					*pb++ = *sptr++;
				sptr = rptr;
				while (*sptr != 0) {
					adjbuf(&buf, &bufsz, 5+pb-buf, recsize, &pb, "gsub");
					if (*sptr == '\\') {
						backsub(&pb, &sptr);
					} else if (*sptr == '&') {
						sptr++;
						adjbuf(&buf, &bufsz, 1+patlen+pb-buf, recsize, &pb, "gsub");
						for (q = patbeg; q < patbeg+patlen; )
							*pb++ = *q++;
					} else
						*pb++ = *sptr++;
				}
				t = patbeg + patlen;
				if (patlen == 0 || *t == 0 || *(t-1) == 0)
					goto done;
				if (pb > buf + bufsz)
					FATAL("gsub result1 %.30s too big; can't happen", buf);
				mflag = 1;
			}
		} while (pmatch(pfa,t));
		sptr = t;
		adjbuf(&buf, &bufsz, 1+strlen(sptr)+pb-buf, 0, &pb, "gsub");
		while ((*pb++ = *sptr++) != 0)
			;
	done:	if (pb < buf + bufsz)
			*pb = '\0';
		else if (*(pb-1) != '\0')
			FATAL("gsub result2 %.30s truncated; can't happen", buf);
		setsval(x, buf);	/* BUG: should be able to avoid copy + free */
		pfa->initstat = tempstat;
	}
	tempfree(x);
	tempfree(y);
	x = gettemp();
	x->tval = NUM;
	x->fval = num;
	free(buf);
	return(x);
}
예제 #20
0
int relex(void)		/* lexical analyzer for reparse */
{
    int c, n;
    int cflag;
    static uschar *buf = 0;
    static int bufsz = 100;
    uschar *bp;
    struct charclass *cc;
    int i;

    switch (c = *prestr++) {
    case '|':
        return OR;
    case '*':
        return STAR;
    case '+':
        return PLUS;
    case '?':
        return QUEST;
    case '.':
        return DOT;
    case '\0':
        prestr--;
        return '\0';
    case '^':
    case '$':
    case '(':
    case ')':
        return c;
    case '\\':
        rlxval = quoted((char **) &prestr);
        return CHAR;
    default:
        rlxval = c;
        return CHAR;
    case '[':
        if (buf == 0 && (buf = (uschar *) malloc(bufsz)) == NULL)
            FATAL("out of space in reg expr %.10s..", lastre);
        bp = buf;
        if (*prestr == '^') {
            cflag = 1;
            prestr++;
        }
        else
            cflag = 0;
        n = 2 * strlen((const char *) prestr)+1;
        if (!adjbuf((char **) &buf, &bufsz, n, n, (char **) &bp, "relex1"))
            FATAL("out of space for reg expr %.10s...", lastre);
        for (; ; ) {
            if ((c = *prestr++) == '\\') {
                *bp++ = '\\';
                if ((c = *prestr++) == '\0')
                    FATAL("nonterminated character class %.20s...", lastre);
                *bp++ = c;
                /* } else if (c == '\n') { */
                /* 	FATAL("newline in character class %.20s...", lastre); */
            } else if (c == '[' && *prestr == ':') {
                /* POSIX char class names, Dag-Erling Smorgrav, [email protected] */
                for (cc = charclasses; cc->cc_name; cc++)
                    if (strncmp((const char *) prestr + 1, (const char *) cc->cc_name, cc->cc_namelen) == 0)
                        break;
                if (cc->cc_name != NULL && prestr[1 + cc->cc_namelen] == ':' &&
                        prestr[2 + cc->cc_namelen] == ']') {
                    prestr += cc->cc_namelen + 3;
                    for (i = 0; i < NCHARS; i++) {
                        if (!adjbuf((char **) &buf, &bufsz, bp-buf+1, 100, (char **) &bp, "relex2"))
                            FATAL("out of space for reg expr %.10s...", lastre);
                        if (cc->cc_func(i)) {
                            *bp++ = i;
                            n++;
                        }
                    }
                } else
                    *bp++ = c;
            } else if (c == '\0') {
                FATAL("nonterminated character class %.20s", lastre);
            } else if (bp == buf) {	/* 1st char is special */
                *bp++ = c;
            } else if (c == ']') {
                *bp++ = 0;
                rlxstr = (uschar *) tostring((char *) buf);
                if (cflag == 0)
                    return CCL;
                else
                    return NCCL;
            } else
                *bp++ = c;
        }
    }
}
예제 #21
0
파일: b.c 프로젝트: ajallooeian/libawkcpp
int relex(void)		/* lexical analyzer for reparse */
{
	int c, n;
	int cflag;
	static char *buf = 0;
	static int bufsz = 100;
	char *bp;

	switch (c = *prestr++) {
	case '|': return OR;
	case '*': return STAR;
	case '+': return PLUS;
	case '?': return QUEST;
	case '.': return DOT;
	case '\0': prestr--; return '\0';
	case '^':
	case '$':
	case '(':
	case ')':
		return c;
	case '\\':
		rlxval = quoted(&prestr);
		return CHAR;
	default:
		rlxval = c;
		return CHAR;
	case '[': 
		if (buf == 0 && (buf = (char *) malloc(bufsz)) == NULL)
			ERROR "out of space in reg expr %.10s..", lastre FATAL;
		bp = buf;
		if (*prestr == '^') {
			cflag = 1;
			prestr++;
		}
		else
			cflag = 0;
		n = 2 * strlen(prestr)+1;
		if (!adjbuf(&buf, &bufsz, n, n, &bp, 0))
			ERROR "out of space for reg expr %.10s...", lastre FATAL;
		for (; ; ) {
			if ((c = *prestr++) == '\\') {
				*bp++ = '\\';
				if ((c = *prestr++) == '\0')
					ERROR "nonterminated character class %.20s...", lastre FATAL;
				*bp++ = c;
			} else if (c == '\n') {
				ERROR "newline in character class %.20s...", lastre FATAL;
			} else if (c == '\0') {
				ERROR "nonterminated character class %.20s", lastre FATAL;
			} else if (bp == buf) {	/* 1st char is special */
				*bp++ = c;
			} else if (c == ']') {
				*bp++ = 0;
				rlxstr = tostring(buf);
				if (cflag == 0)
					return CCL;
				else
					return NCCL;
			} else
				*bp++ = c;
		}
	}
}
예제 #22
0
int format(char **pbuf, int *pbufsize, const char *s, Node *a)	/* printf-like conversions */
{
	char *fmt;
	char *p, *t;
	const char *os;
	Cell *x;
	int flag = 0, n;
	int fmtwd; /* format width */
	int fmtsz = recsize;
	char *buf = *pbuf;
	int bufsize = *pbufsize;

	os = s;
	p = buf;
	if ((fmt = (char *) malloc(fmtsz)) == NULL)
		FATAL("out of memory in format()");
	while (*s) {
		adjbuf(&buf, &bufsize, MAXNUMSIZE+1+p-buf, recsize, &p, "format1");
		if (*s != '%') {
			*p++ = *s++;
			continue;
		}
		if (*(s+1) == '%') {
			*p++ = '%';
			s += 2;
			continue;
		}
		/* have to be real careful in case this is a huge number, eg, %100000d */
		fmtwd = atoi(s+1);
		if (fmtwd < 0)
			fmtwd = -fmtwd;
		adjbuf(&buf, &bufsize, fmtwd+1+p-buf, recsize, &p, "format2");
		for (t = fmt; (*t++ = *s) != '\0'; s++) {
			if (!adjbuf(&fmt, &fmtsz, MAXNUMSIZE+1+t-fmt, recsize, &t, "format3"))
				FATAL("format item %.30s... ran format() out of memory", os);
			if (isalpha((uschar)*s) && *s != 'l' && *s != 'h' && *s != 'L')
				break;	/* the ansi panoply */
			if (*s == '*') {
				x = execute(a);
				a = a->nnext;
				sprintf(t-1, "%d", fmtwd=(int) getfval(x));
				if (fmtwd < 0)
					fmtwd = -fmtwd;
				adjbuf(&buf, &bufsize, fmtwd+1+p-buf, recsize, &p, "format");
				t = fmt + strlen(fmt);
				tempfree(x);
			}
		}
		*t = '\0';
		if (fmtwd < 0)
			fmtwd = -fmtwd;
		adjbuf(&buf, &bufsize, fmtwd+1+p-buf, recsize, &p, "format4");

		switch (*s) {
		case 'f': case 'e': case 'g': case 'E': case 'G':
			flag = 'f';
			break;
		case 'd': case 'i':
			flag = 'd';
			if(*(s-1) == 'l') break;
			*(t-1) = 'l';
			*t = 'd';
			*++t = '\0';
			break;
		case 'o': case 'x': case 'X': case 'u':
			flag = *(s-1) == 'l' ? 'd' : 'u';
			break;
		case 's':
			flag = 's';
			break;
		case 'c':
			flag = 'c';
			break;
		default:
			WARNING("weird printf conversion %s", fmt);
			flag = '?';
			break;
		}
		if (a == NULL)
			FATAL("not enough args in printf(%s)", os);
		x = execute(a);
		a = a->nnext;
		n = MAXNUMSIZE;
		if (fmtwd > n)
			n = fmtwd;
		adjbuf(&buf, &bufsize, 1+n+p-buf, recsize, &p, "format5");
		switch (flag) {
		case '?':	sprintf(p, "%s", fmt);	/* unknown, so dump it too */
			t = getsval(x);
			n = strlen(t);
			if (fmtwd > n)
				n = fmtwd;
			adjbuf(&buf, &bufsize, 1+strlen(p)+n+p-buf, recsize, &p, "format6");
			p += strlen(p);
			sprintf(p, "%s", t);
			break;
		case 'f':	sprintf(p, fmt, getfval(x)); break;
		case 'd':	sprintf(p, fmt, (long) getfval(x)); break;
		case 'u':	sprintf(p, fmt, (int) getfval(x)); break;
		case 's':
			t = getsval(x);
			n = strlen(t);
			if (fmtwd > n)
				n = fmtwd;
			if (!adjbuf(&buf, &bufsize, 1+n+p-buf, recsize, &p, "format7"))
				FATAL("huge string/format (%d chars) in printf %.30s... ran format() out of memory", n, t);
			sprintf(p, fmt, t);
			break;
		case 'c':
			if (isnum(x)) {
				if (getfval(x))
					sprintf(p, fmt, (int) getfval(x));
				else {
					*p++ = '\0'; /* explicit null byte */
					*p = '\0';   /* next output will start here */
				}
			} else
				sprintf(p, fmt, getsval(x)[0]);
			break;
		default:
			FATAL("can't happen: bad conversion %c in format()", flag);
		}
		tempfree(x);
		p += strlen(p);
		s++;
	}
	*p = '\0';
	free(fmt);
	for ( ; a; a = a->nnext)		/* evaluate any remaining args */
		execute(a);
	*pbuf = buf;
	*pbufsize = bufsize;
	return p - buf;
}
예제 #23
0
파일: lib.c 프로젝트: jungle0755/minix
int readrec(uschar **pbuf, int *pbufsize, FILE *inf, int newflag)	/* read one record into buf */
{
    int sep, c, isrec, found, tempstat;
    uschar *rr, *buf = *pbuf;
    int bufsize = *pbufsize;
    size_t len;

    if ((len = strlen(*FS)) < len_inputFS) {
        strcpy(inputFS, *FS);	/* for subsequent field splitting */
    } else {
        len_inputFS = len + 1;
        inputFS = realloc(inputFS, len_inputFS);
        if (inputFS == NULL)
            FATAL("field separator %.10s... is too long", *FS);
        memcpy(inputFS, *FS, len_inputFS);
    }
    /*fflush(stdout); avoids some buffering problem but makes it 25% slower*/
    if (**RS && (*RS)[1]) {
        fa *pfa = makedfa(*RS, 1);
        if (newflag)
            found = fnematch(pfa, inf, &buf, &bufsize, recsize);
        else {
            tempstat = pfa->initstat;
            pfa->initstat = 2;
            found = fnematch(pfa, inf, &buf, &bufsize, recsize);
            pfa->initstat = tempstat;
        }
        if (found)
            *patbeg = 0;
    } else {
        if ((sep = **RS) == 0) {
            sep = '\n';
            while ((c=getc(inf)) == '\n' && c != EOF)	/* skip leading \n's */
                ;
            if (c != EOF)
                ungetc(c, inf);
        }
        for (rr = buf; ; ) {
            for (; (c=getc(inf)) != sep && c != EOF; ) {
                if (rr-buf+1 > bufsize)
                    if (!adjbuf(&buf, &bufsize, 1+rr-buf,
                                recsize, &rr, "readrec 1"))
                        FATAL("input record `%.30s...'"
                              " too long", buf);
                *rr++ = c;
            }
            if (**RS == sep || c == EOF)
                break;
            if ((c = getc(inf)) == '\n' || c == EOF)
                /* 2 in a row */
                break;
            if (!adjbuf(&buf, &bufsize, 2+rr-buf, recsize, &rr,
                        "readrec 2"))
                FATAL("input record `%.30s...' too long", buf);
            *rr++ = '\n';
            *rr++ = c;
        }
        if (!adjbuf(&buf, &bufsize, 1+rr-buf, recsize, &rr, "readrec 3"))
            FATAL("input record `%.30s...' too long", buf);
        *rr = 0;
    }
    *pbuf = buf;
    *pbufsize = bufsize;
    isrec = *buf || !feof(inf);
    dprintf( ("readrec saw <%s>, returns %d\n", buf, isrec) );
    return isrec;
}