The R Project SVN – R – Diff – /trunk/src/main/regex.c

 #endif /* not emacs */
 /* Get the interface, including the syntax bits.  */
 #include "Rregex.h"
+/* Compile a fastmap for the compiled pattern in BUFFER; used to
+   accelerate searches.  Return 0 if successful and -2 if was an
+   internal error.  */
+static int re_compile_fastmap _RE_ARGS ((struct re_pattern_buffer *buffer));
+/* Search in the string STRING (with length LENGTH) for the pattern
+   compiled into BUFFER.  Start searching at position START, for RANGE
+   characters.  Return the starting position of the match, -1 for no
+   match, or -2 for an internal error.  Also return register
+   information in REGS (if REGS and BUFFER->no_sub are nonzero).  */
+static int re_search
+  _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string,
+            int length, int start, int range, struct re_registers *regs));
+/* Like `re_search', but search in the concatenation of STRING1 and
+   STRING2.  Also, stop searching at index START + STOP.  */
+static int re_search_2
+  _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string1,
+             int length1, const char *string2, int length2,
+             int start, int range, struct re_registers *regs, int stop));
 /* isalpha etc. are used for the character classes.  */
 #include <ctype.h>
 /* Jim Meyering writes:
 /* Set by `re_set_syntax' to the current regexp syntax to recognize.  Can
    also be assigned to arbitrarily: each pattern buffer stores its own
    syntax, so it can be changed between regex compilations.  */
 /* This has no initializer because initialized variables in Emacs
    become read-only after dumping.  */
+#if 0
-reg_syntax_t re_syntax_options;
+static reg_syntax_t re_syntax_options;
+#endif
 /* Specify the precise syntax of regexps for compilation.  This provides
    for compatibility for various utilities which historically have
    different, incompatible syntaxes.
    The argument SYNTAX is a bit mask comprised of the various bits
    defined in regex.h.  We return the old syntax.  */
+#if 0
-reg_syntax_t
+static reg_syntax_t
 re_set_syntax (syntax)
     reg_syntax_t syntax;
+{
   reg_syntax_t ret = re_syntax_options;
   return ret;
+}
 #ifdef _LIBC
 weak_alias (__re_set_syntax, re_set_syntax)
 #endif
+#endif
 /* This table gives an error message for each of the error codes listed
    in regex.h.  Obviously the order here has to be same as there.
    POSIX doesn't require that we do anything for REG_NOERROR,
    but why not be nice?  */
 #ifdef INT_IS_16BIT
 # if defined MATCH_MAY_ALLOCATE
 /* 4400 was enough to cause a crash on Alpha OSF/1,
    whose default stack limit is 2mb.  */
-const long int re_max_failures = 4000;
+static const long int re_max_failures = 4000;
 # else
-const long int re_max_failures = 2000;
+static const long int re_max_failures = 2000;
 # endif
 union fail_stack_elt
+{
   unsigned char *pointer;
 #else /* not INT_IS_16BIT */
 # if defined MATCH_MAY_ALLOCATE
 /* 4400 was enough to cause a crash on Alpha OSF/1,
    whose default stack limit is 2mb.  */
-const int re_max_failures = 20000;
+static const int re_max_failures = 20000;
 # else
-const int re_max_failures = 2000;
+static const int re_max_failures = 2000;
 # endif
 union fail_stack_elt
+{
   unsigned char *pointer;
    We set the `fastmap', `fastmap_accurate', and `can_be_null' fields in
    the pattern buffer.
    Returns 0 if we succeed, -2 if an internal error.   */
-int
+static int
 re_compile_fastmap (bufp)
      struct re_pattern_buffer *bufp;
+{
   int j, k;
 #ifdef MATCH_MAY_ALLOCATE
    Unless this function is called, the first search or match using
    PATTERN_BUFFER will allocate its own register data, without
    freeing the old data.  */
+#if 0
-void
+static void
 re_set_registers (bufp, regs, num_regs, starts, ends)
     struct re_pattern_buffer *bufp;
     struct re_registers *regs;
     unsigned num_regs;
     regoff_t *starts, *ends;
+    }
+}
 #ifdef _LIBC
 weak_alias (__re_set_registers, re_set_registers)
 #endif
+#endif
 /* Searching routines.  */
 /* Like re_search_2, below, but only one string is specified, and
    doesn't let you say where to stop matching. */
-int
+static int
 re_search (bufp, string, size, startpos, range, regs)
      struct re_pattern_buffer *bufp;
      const char *string;
      int size, startpos, range;
      struct re_registers *regs;
    We return either the position in the strings at which the match was
    found, -1 if no match, or -2 if error (such as failure
    stack overflow).  */
-int
+static int
 re_search_2 (bufp, string1, size1, string2, size2, startpos, range, regs, stop)
      struct re_pattern_buffer *bufp;
      const char *string1, *string2;
      int size1, size2;
      int startpos;
 #define NO_HIGHEST_ACTIVE_REG (1 << BYTEWIDTH)
 #define NO_LOWEST_ACTIVE_REG (NO_HIGHEST_ACTIVE_REG + 1)
 /* Matching routines.  */
+#if 0
 #ifndef emacs   /* Emacs never uses this.  */
 /* re_match is like re_match_2 except it takes only a single string.  */
-int
+static int
 re_match (bufp, string, size, pos, regs)
      struct re_pattern_buffer *bufp;
      const char *string;
      int size, pos;
      struct re_registers *regs;
+}
 # ifdef _LIBC
 weak_alias (__re_match, re_match)
 # endif
 #endif /* not emacs */
+#endif
 static boolean group_match_null_string_p _RE_ARGS ((unsigned char **p,
 						    unsigned char *end,
 						register_info_type *reg_info));
 static boolean alt_match_null_string_p _RE_ARGS ((unsigned char *p,
    We return -1 if no match, -2 if an internal error (such as the
    failure stack overflowing).  Otherwise, we return the length of the
    matched substring.  */
-int
+#if 0
+static int
 re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop)
      struct re_pattern_buffer *bufp;
      const char *string1, *string2;
      int size1, size2;
      int pos;
   return result;
+}
 #ifdef _LIBC
 weak_alias (__re_match_2, re_match_2)
 #endif
+#endif
 /* This is a separate function so that we can force an alloca cleanup
    afterwards.  */
 static int
 re_match_2_internal (bufp, string1, size1, string2, size2, pos, regs, stop)
    Assumes the `allocated' (and perhaps `buffer') and `translate' fields
    are set in BUFP on entry.
    We call regex_compile to do the actual compilation.  */
+#if 0
-const char *
+static const char *
 re_compile_pattern (pattern, length, bufp)
      const char *pattern;
      size_t length;
      struct re_pattern_buffer *bufp;
+{
   return gettext (re_error_msgid + re_error_msgid_idx[(int) ret]);
+}
 #ifdef _LIBC
 weak_alias (__re_compile_pattern, re_compile_pattern)
 #endif
+#endif
 /* Entry points compatible with 4.2 BSD regex library.  We don't define
    them unless specifically requested.  */
 #if defined _REGEX_RE_COMP || defined _LIBC

The R Project SVN R

(root)/trunk/src/main/regex.c – Rev 19912 → 24109