lib/regextype.c

   1
   2 /* regextype.c -- Decode the name of a regular expression syntax into am
   3                   option name.
   4
   5    Copyright 2005 Free Software Foundation, Inc.
   6
   7    This program is free software: you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation, either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19 */
  20 /* Written by James Youngman, <jay@gnu.org>. */
  21
  22 #if HAVE_CONFIG_H
  23 # include <config.h>
  24 #endif
  25
  26 #include <string.h>
  27 #include <stdio.h>
  28
  29 #include "regextype.h"
  30 #include "regex.h"
  31 #include "quote.h"
  32 #include "xalloc.h"
  33 #include "error.h"
  34
  35
  36 #if ENABLE_NLS
  37 # include <libintl.h>
  38 # define _(Text) gettext (Text)
  39 #else
  40 # define _(Text) Text
  41 #endif
  42 #ifdef gettext_noop
  43 # define N_(String) gettext_noop (String)
  44 #else
  45 /* See locate.c for explanation as to why not use (String) */
  46 # define N_(String) String
  47 #endif
  48
  49
  50 struct tagRegexTypeMap
  51 {
  52   char *name;
  53   int  context;
  54   int   option_val;
  55 };
  56
  57 struct tagRegexTypeMap regex_map[] =
  58   {
  59    { "findutils-default",     CONTEXT_FINDUTILS, RE_SYNTAX_EMACS|RE_DOT_NEWLINE  },
  60    { "awk",                   CONTEXT_ALL,       RE_SYNTAX_AWK                   },
  61    { "egrep",                 CONTEXT_ALL,       RE_SYNTAX_EGREP                 },
  62    { "ed",                    CONTEXT_GENERIC,   RE_SYNTAX_ED                    },
  63    { "emacs",                 CONTEXT_ALL,       RE_SYNTAX_EMACS                 },
  64    { "gnu-awk",               CONTEXT_ALL,       RE_SYNTAX_GNU_AWK               },
  65    { "grep",                  CONTEXT_ALL,       RE_SYNTAX_GREP                  },
  66    { "posix-awk",             CONTEXT_ALL,       RE_SYNTAX_POSIX_AWK             },
  67    { "posix-basic",           CONTEXT_ALL,       RE_SYNTAX_POSIX_BASIC           },
  68    { "posix-egrep",           CONTEXT_ALL,       RE_SYNTAX_POSIX_EGREP           },
  69    { "posix-extended",        CONTEXT_ALL,       RE_SYNTAX_POSIX_EXTENDED        },
  70    { "posix-minimal-basic",   CONTEXT_GENERIC,   RE_SYNTAX_POSIX_MINIMAL_BASIC    },
  71    { "sed",                   CONTEXT_GENERIC,   RE_SYNTAX_SED                   },
  72    /*    ,{ "posix-common",   CONTEXT_GENERIC,  _RE_SYNTAX_POSIX_COMMON   } */
  73   };
  74 enum { N_REGEX_MAP_ENTRIES = sizeof(regex_map)/sizeof(regex_map[0]) };
  75
  76 int
  77 get_regex_type(const char *s)
  78 {
  79   unsigned i;
  80   size_t msglen;
  81   char *buf, *p;
  82
  83   msglen = 0u;
  84   for (i=0u; i<N_REGEX_MAP_ENTRIES; ++i)
  85     {
  86       if (0 == strcmp(regex_map[i].name, s))
  87         return regex_map[i].option_val;
  88       else
  89         msglen += strlen(quote(regex_map[i].name)) + 2u;
  90     }
  91
  92   /* We didn't find a match for the type of regular expression that the
  93    * user indicated they wanted.  Tell them what the options are.
  94    */
  95   p = buf = xmalloc(1u + msglen);
  96   for (i=0u; i<N_REGEX_MAP_ENTRIES; ++i)
  97     {
  98       if (i > 0u)
  99         {
 100           strcpy(p, ", ");
 101           p += 2;
 102         }
 103       p += sprintf(p, "%s", quote(regex_map[i].name));
 104     }
 105
 106   error(1, 0, _("Unknown regular expression type %s; valid types are %s."),
 107         quote(s),
 108         buf);
 109   /*NOTREACHED*/
 110   return -1;
 111 }
 112
 113
 114 const char *
 115 get_regex_type_name(unsigned int ix)
 116 {
 117   if (ix < N_REGEX_MAP_ENTRIES)
 118     return regex_map[ix].name;
 119   else
 120     return NULL;
 121 }
 122
 123 int
 124 get_regex_type_flags(unsigned int ix)
 125 {
 126   if (ix < N_REGEX_MAP_ENTRIES)
 127     return regex_map[ix].option_val;
 128   else
 129     return -1;
 130 }
 131
 132 unsigned int get_regex_type_context(unsigned int ix)
 133 {
 134   if (ix < N_REGEX_MAP_ENTRIES)
 135     return regex_map[ix].context;
 136   else
 137     return 0u;
 138 }
 139
 140 int get_regex_type_synonym(unsigned int ix)
 141 {
 142   unsigned i;
 143   int flags;
 144
 145   if (ix >= N_REGEX_MAP_ENTRIES)
 146     return -1;
 147
 148   flags = regex_map[ix].option_val;
 149   for (i=0u; i<ix; ++i)
 150     {
 151       if (flags == regex_map[i].option_val)
 152         {
 153           return i;
 154         }
 155     }
 156   return -1;
 157 }
 158
 159
 160