#else /* not emacs */
-#ifdef USG
-#ifndef BSTRING
-#define bcopy(s,d,n) memcpy((d),(s),(n))
-#define bcmp(s1,s2,n) memcmp((s1),(s2),(n))
-#define bzero(s,n) memset((s),0,(n))
-#endif
-#endif
-
-/* Make alloca work the best possible way. */
-#ifdef __GNUC__
-#define alloca __builtin_alloca
-#else
-#ifdef sparc
-#include <alloca.h>
-#endif
-#endif
+#include "defs.h"
+#include <string.h>
/*
* Define the syntax stuff, so we can do the \<...\> things.
if (done)
return;
- bzero (re_syntax_table, sizeof re_syntax_table);
+ memset (re_syntax_table, '\0', sizeof re_syntax_table);
for (c = 'a'; c <= 'z'; c++)
re_syntax_table[c] = Sword;
#define BYTEWIDTH 8
-#ifndef SIGN_EXTEND_CHAR
-#define SIGN_EXTEND_CHAR(x) (x)
+/* We remove any previous definition of `SIGN_EXTEND_CHAR',
+ since ours (we hope) works properly with all combinations of
+ machines, compilers, `char' and `unsigned char' argument types.
+ (Per Bothner suggested the basic approach.) */
+#undef SIGN_EXTEND_CHAR
+#if __STDC__
+#define SIGN_EXTEND_CHAR(c) ((signed char) (c))
+#else /* not __STDC__ */
+/* As in Harbison and Steele. */
+#define SIGN_EXTEND_CHAR(c) ((((unsigned char) (c)) ^ 128) - 128)
#endif
\f
static int obscure_syntax = 0;
int
re_set_syntax (syntax)
+ int syntax;
{
int ret;
#define PATUNFETCH p--
-#define EXTEND_BUFFER \
- { char *old_buffer = bufp->buffer; \
- if (bufp->allocated == (1<<16)) goto too_big; \
- bufp->allocated *= 2; \
- if (bufp->allocated > (1<<16)) bufp->allocated = (1<<16); \
- if (!(bufp->buffer = (char *) realloc (bufp->buffer, bufp->allocated))) \
- goto memory_exhausted; \
- c = bufp->buffer - old_buffer; \
- b += c; \
- if (fixup_jump) \
- fixup_jump += c; \
- if (laststart) \
- laststart += c; \
- begalt += c; \
- if (pending_exact) \
- pending_exact += c; \
- }
-
-static int store_jump (), insert_jump ();
+/* This is not an arbitrary limit: the arguments which represent offsets
+ into the pattern are two bytes long. So if 2^16 bytes turns out to
+ be too small, many things would have to change. */
+#define MAX_BUF_SIZE (1 << 16)
+
+
+/* Extend the buffer by twice its current size via realloc and
+ reset the pointers that pointed into the old block to point to the
+ correct places in the new one. If extending the buffer results in it
+ being larger than MAX_BUF_SIZE, then flag memory exhausted. */
+#define EXTEND_BUFFER \
+ do { \
+ char *old_buffer = bufp->buffer; \
+ if (bufp->allocated == MAX_BUF_SIZE) \
+ goto too_big; \
+ bufp->allocated <<= 1; \
+ if (bufp->allocated > MAX_BUF_SIZE) \
+ bufp->allocated = MAX_BUF_SIZE; \
+ bufp->buffer = (char *) realloc (bufp->buffer, bufp->allocated);\
+ if (bufp->buffer == NULL) \
+ goto memory_exhausted; \
+ /* If the buffer moved, move all the pointers into it. */ \
+ if (old_buffer != bufp->buffer) \
+ { \
+ b = (b - old_buffer) + bufp->buffer; \
+ begalt = (begalt - old_buffer) + bufp->buffer; \
+ if (fixup_jump) \
+ fixup_jump = (fixup_jump - old_buffer) + bufp->buffer;\
+ if (laststart) \
+ laststart = (laststart - old_buffer) + bufp->buffer; \
+ if (pending_exact) \
+ pending_exact = (pending_exact - old_buffer) + bufp->buffer; \
+ } \
+ } while (0)
+
+static void store_jump (), insert_jump ();
char *
re_compile_pattern (pattern, size, bufp)
PATPUSH ((1 << BYTEWIDTH) / BYTEWIDTH);
/* Clear the whole map */
- bzero (b, (1 << BYTEWIDTH) / BYTEWIDTH);
+ memset (b, '\0', (1 << BYTEWIDTH) / BYTEWIDTH);
/* Read in characters and ranges, setting map bits */
while (1)
{
/* Store where `from' points a jump operation to jump to where `to' points.
`opcode' is the opcode to store. */
-static int
+static void
store_jump (from, opcode, to)
char *from, *to;
char opcode;
If you call this function, you must zero out pending_exact. */
-static int
+static void
insert_jump (op, from, to, current_end)
char op;
char *from, *to, *current_end;
register char *fastmap = bufp->fastmap;
register unsigned char *p = pattern;
register unsigned char *pend = pattern + size;
- register int j, k;
+ register int j;
unsigned char *translate = (unsigned char *) bufp->translate;
unsigned char *stackb[NFAILURES];
unsigned char **stackp = stackb;
- bzero (fastmap, (1 << BYTEWIDTH));
+ memset (fastmap, '\0', (1 << BYTEWIDTH));
bufp->fastmap_accurate = 1;
bufp->can_be_null = 0;
fastmap[j] = 1;
}
break;
+ case unused:
+ case syntaxspec:
+ case notsyntaxspec:
+ default:
+ break;
}
/* Get here means we have successfully found the possible starting characters
int re_max_failures = 2000;
-static int bcmp_translate();
+static int memcmp_translate();
/* Match the pattern described by PBUFP
against data which is the virtual concatenation of STRING1 and STRING2.
SIZE1 and SIZE2 are the sizes of the two data strings.
if (mcnt > dend2 - d2)
mcnt = dend2 - d2;
/* Compare that many; failure if mismatch, else skip them. */
- if (translate ? bcmp_translate (d, d2, mcnt, translate) : bcmp (d, d2, mcnt))
+ if (translate ? memcmp_translate (d, d2, mcnt, translate) : memcmp (d, d2, mcnt))
goto fail;
d += mcnt, d2 += mcnt;
}
return -2;
stackx = (unsigned char **) alloca (2 * (stacke - stackb)
* sizeof (char *));
- bcopy (stackb, stackx, (stacke - stackb) * sizeof (char *));
+ memcpy (stackx, stackb, (stacke - stackb) * sizeof (char *));
stackp = stackx + (stackp - stackb);
stacke = stackx + 2 * (stacke - stackb);
stackb = stackx;
unsigned char **stackx
= (unsigned char **) alloca (2 * (stacke - stackb)
* sizeof (char *));
- bcopy (stackb, stackx, (stacke - stackb) * sizeof (char *));
+ memcpy (stackx, stackb, (stacke - stackb) * sizeof (char *));
stackp = stackx + (stackp - stackb);
stacke = stackx + 2 * (stacke - stackb);
stackb = stackx;
while (--mcnt);
}
break;
+ case unused:
+ case before_dot:
+ case at_dot:
+ case after_dot:
+ case syntaxspec:
+ case notsyntaxspec:
+ default:
+ break;
}
continue; /* Successfully matched one pattern command; keep matching */
}
static int
-bcmp_translate (s1, s2, len, translate)
+memcmp_translate (s1, s2, len, translate)
unsigned char *s1, *s2;
register int len;
unsigned char *translate;
char *
re_comp (s)
- char *s;
+ const char *s;
{
if (!s)
{
for (i = 0; i < buf.used; i++)
printchar (buf.buffer[i]);
- putchar ('\n');
+ putchar_unfiltered ('\n');
- printf ("%d allocated, %d used.\n", buf.allocated, buf.used);
+ printf_unfiltered ("%d allocated, %d used.\n", buf.allocated, buf.used);
re_compile_fastmap (&buf);
- printf ("Allowed by fastmap: ");
+ printf_unfiltered ("Allowed by fastmap: ");
for (i = 0; i < (1 << BYTEWIDTH); i++)
if (fastmap[i]) printchar (i);
- putchar ('\n');
+ putchar_unfiltered ('\n');
}
gets (pat); /* Now read the string to match against */
i = re_match (&buf, pat, strlen (pat), 0, 0);
- printf ("Match value %d.\n", i);
+ printf_unfiltered ("Match value %d.\n", i);
}
}
{
int i;
- printf ("buf is :\n----------------\n");
+ printf_unfiltered ("buf is :\n----------------\n");
for (i = 0; i < bufp->used; i++)
printchar (bufp->buffer[i]);
- printf ("\n%d allocated, %d used.\n", bufp->allocated, bufp->used);
+ printf_unfiltered ("\n%d allocated, %d used.\n", bufp->allocated, bufp->used);
- printf ("Allowed by fastmap: ");
+ printf_unfiltered ("Allowed by fastmap: ");
for (i = 0; i < (1 << BYTEWIDTH); i++)
if (bufp->fastmap[i])
printchar (i);
- printf ("\nAllowed by translate: ");
+ printf_unfiltered ("\nAllowed by translate: ");
if (bufp->translate)
for (i = 0; i < (1 << BYTEWIDTH); i++)
if (bufp->translate[i])
printchar (i);
- printf ("\nfastmap is%s accurate\n", bufp->fastmap_accurate ? "" : "n't");
- printf ("can %s be null\n----------", bufp->can_be_null ? "" : "not");
+ printf_unfiltered ("\nfastmap is%s accurate\n", bufp->fastmap_accurate ? "" : "n't");
+ printf_unfiltered ("can %s be null\n----------", bufp->can_be_null ? "" : "not");
}
#endif
{
if (c < 041 || c >= 0177)
{
- putchar ('\\');
- putchar (((c >> 6) & 3) + '0');
- putchar (((c >> 3) & 7) + '0');
- putchar ((c & 7) + '0');
+ putchar_unfiltered ('\\');
+ putchar_unfiltered (((c >> 6) & 3) + '0');
+ putchar_unfiltered (((c >> 3) & 7) + '0');
+ putchar_unfiltered ((c & 7) + '0');
}
else
- putchar (c);
+ putchar_unfiltered (c);
}
error (string)
char *string;
{
- puts (string);
+ puts_unfiltered (string);
exit (1);
}
projects / deliverable / binutils-gdb.git / blobdiff