regexconvert.c

nedit 是一款linux下的开发源码的功能强大的编辑器

                  a_z_flag = 0;
               } else if (A_Z_flag) {
                  emit_convert_byte ('A');
                  emit_convert_byte ('-');
                  emit_convert_byte ('Z');

                  A_Z_flag = 0;
               } else if (u_score_flag) {
                  emit_convert_byte ('_');

                  u_score_flag = 0;
               }
            }

            /* Output our buffered class characters. */

            for (head = 0; buffer [head] != '\0'; head++) {
               emit_convert_byte (buffer [head]);
            }

            if (do_brackets) {
               emit_convert_byte (']');
            }
         }

         break; /* End of character class code. */

         /* Fall through to Default case to handle literal escapes. */

      default:
         Reg_Parse--; /* If we fell through from the above code, we are now
                         pointing at the back slash (\) character. */
         {
            unsigned char *parse_save, *emit_save;
                     int   emit_diff, len = 0;

            /* Loop until we find a meta character or end of regex string. */

            for (; *Reg_Parse != '\0' &&
                   !strchr ((char *) Meta_Char, (int) *Reg_Parse);
                 len++) {

               /* Save where we are in case we have to back
                  this character out. */

               parse_save = Reg_Parse;
               emit_save  = Code_Emit_Ptr;

               if (*Reg_Parse == '\\') {
                  if ((test = literal_escape (*(Reg_Parse + 1), 0))) {
                     if (*(Reg_Parse + 1) != '\"') {
                        emit_convert_byte ('\\');
                     }

                     Reg_Parse++; /* Point to escaped character */
                     emit_convert_byte (*Reg_Parse);

                  } else {
                     sprintf (Error_Text,
                              "\\%c is an invalid escape sequence(2)",
                              *(Reg_Parse + 1));

                     CONVERT_FAIL (Error_Text);
                  }

                  Reg_Parse++;
               } else {
                  /* Ordinary character */

                  if ((test = literal_escape (*Reg_Parse, 1))) {
                     /* Ordinary character matches an escape sequence;
                        convert it to the escape sequence. */

                     emit_convert_byte ('\\');

                     if (test == '0') {
                        test = *Reg_Parse;
                        emit_convert_byte ('0');
                        emit_convert_byte ('0' + (test / 64));
                        test -= (test / 64) * 64;
                        emit_convert_byte ('0' + (test / 8));
                        test -= (test / 8) * 8;
                        emit_convert_byte ('0' +  test);
                     } else {
                        emit_convert_byte (test);
                     }
                  } else {
                     emit_convert_byte (*Reg_Parse);
                  }

                  Reg_Parse++;
               }

               /* If next regex token is a quantifier (?, +. *, or {m,n}) and
                  our EXACTLY node so far is more than one character, leave the
                  last character to be made into an EXACTLY node one character
                  wide for the multiplier to act on.  For example 'abcd* would
                  have an EXACTLY node with an 'abc' operand followed by a STAR
                  node followed by another EXACTLY node with a 'd' operand. */

               if (IS_QUANTIFIER (*Reg_Parse) && len > 0) {
                  Reg_Parse = parse_save; /* Point to previous regex token. */
                  emit_diff = (Code_Emit_Ptr - emit_save);

                  if (Code_Emit_Ptr == &Compute_Size) {
                     Convert_Size -= emit_diff;
                  } else { /* Write over previously emitted byte. */
                     Code_Emit_Ptr = emit_save;
                  }

                  break;
               }
            }

            if (len <= 0) CONVERT_FAIL ("internal error #4, `atom\'");

            *flag_param |= HAS_WIDTH;

            if (len == 1) *flag_param |= SIMPLE;
         }
      } /* END switch (*Reg_Parse++) */

   return (ret_val);
}

/*----------------------------------------------------------------------*
 * emit_convert_byte
 *
 * Emit (if appropriate) a byte of converted code.
 *----------------------------------------------------------------------*/

static void emit_convert_byte (unsigned char c) {

   if (Code_Emit_Ptr == &Compute_Size) {
      Convert_Size++;
   } else {
      *Code_Emit_Ptr++ = c;
   }
}

/*--------------------------------------------------------------------*
 * literal_escape
 *
 * Recognize escaped literal characters (prefixed with backslash),
 * and translate them into the corresponding character.
 *
 * Returns the proper character value or NULL if not a valid literal
 * escape.
 *--------------------------------------------------------------------*/

static unsigned char literal_escape (unsigned char c, int action) {

   static unsigned char control_escape [] =  {
      'a', 'b',
      'e',
      'f', 'n', 'r', 't', 'v', '\0'
   };

   static unsigned char control_actual [] =  {
      '\a', '\b',
#ifdef EBCDIC_CHARSET
      0x27,  /* Escape character in IBM's EBCDIC character set. */
#else
      0x1B,  /* Escape character in ASCII character set. */
#endif
      '\f', '\n', '\r', '\t', '\v', '\0'
   };

   static unsigned char valid_escape [] =  {
      'a',   'b',   'f',   'n',   'r',   't',   'v',   '(',    ')',   '[',
      ']',   '<',   '>',   '.',   '\\',  '|',   '^',   '$',   '*',   '+',
      '?',   '&',   '\"',  '\0'
   };

   static unsigned char value [] = {
      '\a',  '\b',  '\f',  '\n',  '\r',  '\t',  '\v',  '(',   ')',   '[',
      ']',   '<',   '>',   '.',   '\\',   '|',  '^',   '$',   '*',   '+',
      '?',   '&',   '\"',  '\0'
   };

   int i;

   if (action == 0) {
      for (i = 0; valid_escape [i] != '\0'; i++) {
         if (c == valid_escape [i]) return value [i];
      }
   } else if (action == 1) {
      for (i = 0; control_actual [i] != '\0'; i++) {
         if (c == control_actual [i]) {
            return control_escape [i];
         }
      }
   }

   if (action == 1) {
      if (!isprint (c)) {
         /* Signal to generate an numeric (octal) escape. */
         return '0';
      }
   }

   return 0;
}

/*----------------------------------------------------------------------*
 * ConvertSubstituteRE - Perform substitutions after a `regexp' match.
 *----------------------------------------------------------------------*/

void ConvertSubstituteRE (
   const char   *source,
   char   *dest,
   int     max) {

   register unsigned char *src;
   register unsigned char *dst;
   register unsigned char  c;
   register unsigned char  test;

   if (source == NULL || dest == NULL) {
      reg_error ("NULL parm to `ConvertSubstituteRE\'");

      return;
   }

   src = (unsigned char *) source;
   dst = (unsigned char *) dest;

   while ((c = *src++) != '\0') {

      if (c == '\\') {
         /* Process any case altering tokens, i.e \u, \U, \l, \L. */

         if (*src == 'u' || *src == 'U' || *src == 'l' || *src == 'L') {
            *dst++ = '\\';
             c     = *src++;
            *dst++ = c;

            if (c == '\0') {
               break;
            } else {
               c = *src++;
            }
         }
      }

      if (c == '&') {
         *dst++ = '&';

      } else if (c == '\\') {
         if (*src == '0') {
            /* Convert `\0' to `&' */

            *dst++ = '&'; src++;

         } else if ('1' <= *src && *src <=  '9') {
            *dst++ = '\\';
            *dst++ = *src++;

         } else if ((test = literal_escape (*src, 0)) != '\0') {
            *dst++ = '\\';
            *dst++ = *src++;

         } else if (*src == '\0') {
            /* If '\' is the last character of the replacement string, it is
               interpreted as a literal backslash. */

            *dst++ = '\\';
         } else {
            /* Old regex's allowed any escape sequence.  Convert these to
               unescaped characters that replace themselves; i.e. they don't
               need to be escaped. */

            *dst++ = *src++;
         }
      } else {
         /* Ordinary character. */

         if (((char *) dst - (char *) dest) >= (max - 1)) {
            break;
         } else {
            if ((test = literal_escape (c, 1))) {
               /* Ordinary character matches an escape sequence;
                  convert it to the escape sequence. */

               *dst++ = '\\';

               if (test == '0') { /* Make octal escape. */
                  test   = c;
                  *dst++ = '0';
                  *dst++ = ('0' + (test / 64));
                  test  -= (test / 64) * 64;
                  *dst++ = ('0' + (test / 8));
                  test  -= (test / 8) * 8;
                  *dst++ = ('0' +  test);
               } else {
                  *dst++ = test;
               }

            } else {
               *dst++ = c;
            }
         }
      }
   }

   *dst = '\0';
}

/*----------------------------------------------------------------------*
 * reg_error
 *----------------------------------------------------------------------*/

static void reg_error (char *str) {

   fprintf (
      stderr,
      "NEdit: Internal error processing regular expression (%s)\n",
      str);
}