/* regex.c: regular expression interface routines for the ed line editor. */

/*  GNU ed - The GNU line editor.

    Copyright (C) 1993, 1994 Andrew Moore, Talke Studio

    Copyright (C) 2006-2017 Antonio Diaz Diaz.

    This program is free software: you can redistribute it and/or modify

    it under the terms of the GNU General Public License as published by

    the Free Software Foundation, either version 2 of the License, or

    (at your option) any later version.

    This program is distributed in the hope that it will be useful,

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License

    along with this program.  If not, see <http://www.gnu.org/licenses/>.

*/

#include <stddef.h>

#include <errno.h>

#include <sys/types.h>

#include <regex.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include "ed.h"

static regex_t * subst_regex_ = 0;	/* regex of previous substitution */

static char * rbuf = 0;		/* replacement buffer */

static int rbufsz = 0;		/* replacement buffer size */

static int rlen = 0;		/* replacement length */

bool subst_regex( void ) { return subst_regex_ != 0; }

/* translate characters in a string */

static void translit_text( char * p, int len, const char from, const char to )

  {

  while( --len >= 0 )

    {

    if( *p == from ) *p = to;

    ++p;

    }

  }

/* overwrite newlines with ASCII NULs */

static void newline_to_nul( char * const s, const int len )

  { translit_text( s, len, '\n', '\0' ); }

/* overwrite ASCII NULs with newlines */

static void nul_to_newline( char * const s, const int len )

  { translit_text( s, len, '\0', '\n' ); }

/* expand a POSIX character class */

static const char * parse_char_class( const char * p )

  {

  char c, d;

  if( *p == '^' ) ++p;

  if( *p == ']' ) ++p;

  for( ; *p != ']' && *p != '\n'; ++p )

    if( *p == '[' && ( ( d = p[1] ) == '.' || d == ':' || d == '=' ) )

      for( ++p, c = *++p; *p != ']' || c != d; ++p )

        if( ( c = *p ) == '\n' )

          return 0;

  return ( ( *p == ']' ) ? p : 0 );

  }

/* copy a pattern string from the command buffer; return pointer to the copy */

static char * extract_pattern( const char ** const ibufpp, const char delimiter )

  {

  static char * buf = 0;

  static int bufsz = 0;

  const char * nd = *ibufpp;

  int len;

  while( *nd != delimiter && *nd != '\n' )

    {

    if( *nd == '[' )

      {

      nd = parse_char_class( ++nd );

      if( !nd ) { set_error_msg( "Unbalanced brackets ([])" ); return 0; }

      }

    else if( *nd == '\\' && *++nd == '\n' )

      { set_error_msg( "Trailing backslash (\\)" ); return 0; }

    ++nd;

    }

  len = nd - *ibufpp;

  if( !resize_buffer( &buf, &bufsz, len + 1 ) ) return 0;

  memcpy( buf, *ibufpp, len );

  buf[len] = 0;

  *ibufpp = nd;

  if( isbinary() ) nul_to_newline( buf, len );

  return buf;

  }

/* return pointer to compiled regex from command buffer, or to previous

   compiled regex if empty RE. return 0 if error */

static regex_t * get_compiled_regex( const char ** const ibufpp,

                                     const bool test_delimiter )

  {

  static regex_t store[2];		/* space for two compiled regexes */

  static regex_t * exp = 0;

  const char * pat;

  const char delimiter = **ibufpp;

  int n;

  if( delimiter == ' ' )

    { set_error_msg( "Invalid pattern delimiter" ); return 0; }

  if( delimiter == '\n' || *++*ibufpp == delimiter ||

      ( **ibufpp == '\n' && !test_delimiter ) )

    {

    if( !exp ) set_error_msg( "No previous pattern" );

    return exp;

    }

  pat = extract_pattern( ibufpp, delimiter );

  if( !pat ) return 0;

  if( test_delimiter && delimiter != **ibufpp )

    { set_error_msg( "Missing pattern delimiter" ); return 0; }

  /* exp compiled && not copied */

  if( exp && exp != subst_regex_ ) regfree( exp );

  else exp = ( &store[0] != subst_regex_ ) ? &store[0] : &store[1];

  n = regcomp( exp, pat, 0 );

  if( n )

    {

    char buf[80];

    regerror( n, exp, buf, sizeof buf );

    set_error_msg( buf );

    exp = 0;

    }

  return exp;

  }

bool set_subst_regex( const char ** const ibufpp )

  {

  regex_t * exp;

  disable_interrupts();

  exp = get_compiled_regex( ibufpp, true );

  if( exp && exp != subst_regex_ )

    {

    if( subst_regex_ ) regfree( subst_regex_ );

    subst_regex_ = exp;

    }

  enable_interrupts();

  return ( exp ? true : false );

  }

/* add line matching a regular expression to the global-active list */

bool build_active_list( const char ** const ibufpp, const int first_addr,

                        const int second_addr, const bool match )

  {

  const regex_t * exp;

  const line_t * lp;

  int addr;

  const char delimiter = **ibufpp;

  if( delimiter == ' ' || delimiter == '\n' )

    { set_error_msg( "Invalid pattern delimiter" ); return false; }

  exp = get_compiled_regex( ibufpp, false );

  if( !exp ) return false;

  if( **ibufpp == delimiter ) ++*ibufpp;

  clear_active_list();

  lp = search_line_node( first_addr );

  for( addr = first_addr; addr <= second_addr; ++addr, lp = lp->q_forw )

    {

    char * const s = get_sbuf_line( lp );

    if( !s ) return false;

    if( isbinary() ) nul_to_newline( s, lp->len );

    if( match == !regexec( exp, s, 0, 0, 0 ) && !set_active_node( lp ) )

      return false;

    }

  return true;

  }

/* return the address of the next line matching a regular expression in a

   given direction. wrap around begin/end of editor buffer if necessary */

int next_matching_node_addr( const char ** const ibufpp, const bool forward )

  {

  const regex_t * const exp = get_compiled_regex( ibufpp, false );

  int addr = current_addr();

  if( !exp ) return -1;

  do {

    addr = ( forward ? inc_addr( addr ) : dec_addr( addr ) );

    if( addr )

      {

      const line_t * const lp = search_line_node( addr );

      char * const s = get_sbuf_line( lp );

      if( !s ) return -1;

      if( isbinary() ) nul_to_newline( s, lp->len );

      if( !regexec( exp, s, 0, 0, 0 ) ) return addr;

      }

    }

  while( addr != current_addr() );

  set_error_msg( "No match" );

  return -1;

  }

/* extract substitution replacement from the command buffer */

bool extract_replacement( const char ** const ibufpp, const bool isglobal )

  {

  static char * buf = 0;		/* temporary buffer */

  static int bufsz = 0;

  int i = 0;

  const char delimiter = **ibufpp;

  if( delimiter == '\n' )

    { set_error_msg( "Missing pattern delimiter" ); return false; }

  ++*ibufpp;

  if( **ibufpp == '%' && ( (*ibufpp)[1] == delimiter || (*ibufpp)[1] == '\n' ) )

    {

    ++*ibufpp;

    if( !rbuf ) { set_error_msg( "No previous substitution" ); return false; }

    return true;

    }

  while( **ibufpp != delimiter )

    {

    if( **ibufpp == '\n' )

      {

      if( isglobal && (*ibufpp)[1] != 0 )

        { set_error_msg( "Invalid newline substitution" ); return false; }

      break;

      }

    if( !resize_buffer( &buf, &bufsz, i + 2 ) ) return false;

    if( ( buf[i++] = *(*ibufpp)++ ) == '\\' &&

        ( buf[i++] = *(*ibufpp)++ ) == '\n' && !isglobal )

      {

      /* not reached if isglobal; in command-list, newlines are unescaped */

      int size = 0;

      *ibufpp = get_stdin_line( &size );

      if( !*ibufpp ) return false;			/* error */

      if( size <= 0 ) return false;			/* EOF */

      }

    }

  /* make sure that buf gets allocated if empty replacement */

  if( !resize_buffer( &buf, &bufsz, i + 1 ) ) return false;

  buf[i] = 0;

  disable_interrupts();

  { char * p = buf; buf = rbuf; rbuf = p;		/* swap buffers */

    rlen = i; i = bufsz; bufsz = rbufsz; rbufsz = i; }

  enable_interrupts();

  return true;

  }

/* Produce replacement text from matched text and replacement template.

   Return new offset to end of replacement text, or -1 if error. */

static int replace_matched_text( char ** txtbufp, int * const txtbufszp,

                                 const char * const txt,

                                 const regmatch_t * const rm, int offset,

                                 const int re_nsub )

  {

  const char * sub = rbuf;

  for( ; sub - rbuf < rlen; ++sub )

    {

    int n;

    if( *sub == '&' )

      {

      int j = rm[0].rm_so; int k = rm[0].rm_eo;

      if( !resize_buffer( txtbufp, txtbufszp, offset + k - j ) ) return -1;

      while( j < k ) (*txtbufp)[offset++] = txt[j++];

      }

    else if( *sub == '\\' && *++sub >= '1' && *sub <= '9' &&

             ( n = *sub - '0' ) <= re_nsub )

      {

      int j = rm[n].rm_so; int k = rm[n].rm_eo;

      if( !resize_buffer( txtbufp, txtbufszp, offset + k - j ) ) return -1;

      while( j < k ) (*txtbufp)[offset++] = txt[j++];

      }

    else

      {

      if( !resize_buffer( txtbufp, txtbufszp, offset + 1 ) ) return -1;

      (*txtbufp)[offset++] = *sub;

      }

    }

  if( !resize_buffer( txtbufp, txtbufszp, offset + 1 ) ) return -1;

  (*txtbufp)[offset] = 0;

  return offset;

  }

/* Produce new text with one or all matches replaced in a line.

   Return size of the new line text, 0 if no change, -1 if error */

static int line_replace( char ** txtbufp, int * const txtbufszp,

                         const line_t * const lp, const int snum )

  {

  enum { se_max = 30 };	/* max subexpressions in a regular expression */

  regmatch_t rm[se_max];

  char * txt = get_sbuf_line( lp );

  const char * eot;

  int i = 0, offset = 0;

  const bool global = ( snum <= 0 );

  bool changed = false;

  if( !txt ) return -1;

  if( isbinary() ) nul_to_newline( txt, lp->len );

  eot = txt + lp->len;

  if( !regexec( subst_regex_, txt, se_max, rm, 0 ) )

    {

    int matchno = 0;

    do {

      if( global || snum == ++matchno )

        {

        changed = true; i = rm[0].rm_so;

        if( !resize_buffer( txtbufp, txtbufszp, offset + i ) ) return -1;

        if( isbinary() ) newline_to_nul( txt, rm[0].rm_eo );

        memcpy( *txtbufp + offset, txt, i ); offset += i;

        offset = replace_matched_text( txtbufp, txtbufszp, txt, rm, offset,

                                       subst_regex_->re_nsub );

        if( offset < 0 ) return -1;

        }

      else

        {

        i = rm[0].rm_eo;

        if( !resize_buffer( txtbufp, txtbufszp, offset + i ) ) return -1;

        if( isbinary() ) newline_to_nul( txt, i );

        memcpy( *txtbufp + offset, txt, i ); offset += i;

        }

      txt += rm[0].rm_eo;

      }

    while( *txt && ( !changed || ( global && rm[0].rm_eo ) ) &&

           !regexec( subst_regex_, txt, se_max, rm, REG_NOTBOL ) );

    i = eot - txt;

    if( !resize_buffer( txtbufp, txtbufszp, offset + i + 2 ) ) return -1;

    if( global && i > 0 && !rm[0].rm_eo )

      { set_error_msg( "Infinite substitution loop" ); return -1; }

    if( isbinary() ) newline_to_nul( txt, i );

    memcpy( *txtbufp + offset, txt, i );		/* tail copy */

    memcpy( *txtbufp + offset + i, "\n", 2 );

    }

  return ( changed ? offset + i + 1 : 0 );

  }

/* for each line in a range, change text matching a regular expression

   according to a substitution template (replacement); return false if error */

bool search_and_replace( const int first_addr, const int second_addr,

                         const int snum, const bool isglobal )

  {

  static char * txtbuf = 0;		/* new text of line buffer */

  static int txtbufsz = 0;		/* new text of line buffer size */

  int addr = first_addr;

  int lc;

  bool match_found = false;

  for( lc = 0; lc <= second_addr - first_addr; ++lc, ++addr )

    {

    const line_t * const lp = search_line_node( addr );

    const int size = line_replace( &txtbuf, &txtbufsz, lp, snum );

    if( size < 0 ) return false;

    if( size )

      {

      const char * txt = txtbuf;

      const char * const eot = txtbuf + size;

      undo_t * up = 0;

      disable_interrupts();

      if( !delete_lines( addr, addr, isglobal ) )

        { enable_interrupts(); return false; }

      set_current_addr( addr - 1 );

      do {

        txt = put_sbuf_line( txt, eot - txt );

        if( !txt ) { enable_interrupts(); return false; }

        if( up ) up->tail = search_line_node( current_addr() );

        else

          {

          up = push_undo_atom( UADD, current_addr(), current_addr() );

          if( !up ) { enable_interrupts(); return false; }

          }

        }

      while( txt != eot );

      enable_interrupts();

      addr = current_addr();

      match_found = true;

      }

    }

  if( !match_found && !isglobal )

    { set_error_msg( "No match" ); return false; }

  return true;

  }