/* 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 <ctype.h>
#include <setjmp.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "ed.h"
enum Status { QUIT = -1, ERR = -2, EMOD = -3, FATAL = -4 };
static char def_filename[1024] = ""; /* default filename */
static char errmsg[80] = ""; /* error message buffer */
static char prompt_str[80] = "*"; /* command prompt */
static int first_addr = 0, second_addr = 0;
static bool prompt_on = false; /* if set, show command prompt */
static bool verbose = false; /* if set, print all error messages */
void set_def_filename( const char * const s )
{
strncpy( def_filename, s, sizeof def_filename );
def_filename[sizeof(def_filename)-1] = 0;
}
void set_error_msg( const char * msg )
{
if( !msg ) msg = "";
strncpy( errmsg, msg, sizeof errmsg );
errmsg[sizeof(errmsg)-1] = 0;
}
void set_prompt( const char * const s )
{
prompt_on = true;
strncpy( prompt_str, s, sizeof prompt_str );
prompt_str[sizeof(prompt_str)-1] = 0;
}
void set_verbose( void ) { verbose = true; }
static const line_t * mark[26]; /* line markers */
static int markno; /* line marker count */
static bool mark_line_node( const line_t * const lp, int c )
{
c -= 'a';
if( c < 0 || c >= 26 )
{ set_error_msg( "Invalid mark character" ); return false; }
if( !mark[c] ) ++markno;
mark[c] = lp;
return true;
}
void unmark_line_node( const line_t * const lp )
{
int i;
for( i = 0; markno && i < 26; ++i )
if( mark[i] == lp )
{ mark[i] = 0; --markno; }
}
/* return address of a marked line */
static int get_marked_node_addr( int c )
{
c -= 'a';
if( c < 0 || c >= 26 )
{ set_error_msg( "Invalid mark character" ); return -1; }
return get_line_node_addr( mark[c] );
}
/* Returns pointer to copy of shell command in the command buffer */
static const char * get_shell_command( const char ** const ibufpp )
{
static char * buf = 0; /* temporary buffer */
static int bufsz = 0;
static char * shcmd = 0; /* shell command buffer */
static int shcmdsz = 0; /* shell command buffer size */
static int shcmdlen = 0; /* shell command length */
int i = 0, len = 0;
bool replacement = false;
if( restricted() ) { set_error_msg( "Shell access restricted" ); return 0; }
if( !get_extended_line( ibufpp, &len, true ) ) return 0;
if( !resize_buffer( &buf, &bufsz, len + 1 ) ) return 0;
if( **ibufpp != '!' ) buf[i++] = '!'; /* prefix command w/ bang */
else
{
if( shcmdlen <= 0 || ( traditional() && !shcmd[1] ) )
{ set_error_msg( "No previous command" ); return 0; }
memcpy( buf, shcmd, shcmdlen ); /* bufsz >= shcmdlen */
i += shcmdlen; ++*ibufpp; replacement = true;
}
while( **ibufpp != '\n' )
{
if( **ibufpp == '%' )
{
const char * p;
if( !def_filename[0] )
{ set_error_msg( "No current filename" ); return 0; }
p = strip_escapes( def_filename );
len = strlen( p );
if( !resize_buffer( &buf, &bufsz, i + len ) ) return 0;
memcpy( buf + i, p, len );
i += len; ++*ibufpp; replacement = true;
}
else
{
if( !resize_buffer( &buf, &bufsz, i + 2 ) ) return 0;
if( ( buf[i++] = *(*ibufpp)++ ) == '\\' ) buf[i++] = *(*ibufpp)++;
}
}
while( **ibufpp == '\n' ) ++*ibufpp; /* skip newline */
if( !resize_buffer( &shcmd, &shcmdsz, i + 1 ) ) return 0;
memcpy( shcmd, buf, i );
shcmd[i] = 0; shcmdlen = i;
if( replacement ) printf( "%s\n", shcmd + 1 );
return shcmd;
}
static const char * skip_blanks( const char * p )
{
while( isspace( (unsigned char)*p ) && *p != '\n' ) ++p;
return p;
}
/* Returns pointer to copy of filename in the command buffer */
static const char * get_filename( const char ** const ibufpp,
const bool traditional_f_command )
{
static char * buf = 0;
static int bufsz = 0;
const int pmax = path_max( 0 );
int n;
*ibufpp = skip_blanks( *ibufpp );
if( **ibufpp != '\n' )
{
int size = 0;
if( !get_extended_line( ibufpp, &size, true ) ) return 0;
if( **ibufpp == '!' )
{ ++*ibufpp; return get_shell_command( ibufpp ); }
else if( size > pmax )
{ set_error_msg( "Filename too long" ); return 0; }
}
else if( !traditional_f_command && !def_filename[0] )
{ set_error_msg( "No current filename" ); return 0; }
if( !resize_buffer( &buf, &bufsz, pmax + 1 ) ) return 0;
for( n = 0; **ibufpp != '\n'; ++n, ++*ibufpp ) buf[n] = **ibufpp;
buf[n] = 0;
while( **ibufpp == '\n' ) ++*ibufpp; /* skip newline */
return ( may_access_filename( buf ) ? buf : 0 );
}
static void invalid_address( void ) { set_error_msg( "Invalid address" ); }
/* Get line addresses from the command buffer until an invalid address
is seen. Returns the number of addresses read, or -1 if error.
If no addresses are found, both addresses are set to the current address.
If one address is found, both addresses are set to that address. */
static int extract_addresses( const char ** const ibufpp )
{
bool first = true; /* true == addr, false == offset */
first_addr = second_addr = -1; /* set to undefined */
*ibufpp = skip_blanks( *ibufpp );
while( true )
{
int n;
const unsigned char ch = **ibufpp;
if( isdigit( ch ) )
{
if( !parse_int( &n, *ibufpp, ibufpp ) ) return -1;
if( first ) { first = false; second_addr = n; } else second_addr += n;
}
else switch( ch )
{
case '\t':
case ' ': *ibufpp = skip_blanks( ++*ibufpp ); break;
case '+':
case '-': if( first ) { first = false; second_addr = current_addr(); }
if( isdigit( (unsigned char)(*ibufpp)[1] ) )
{
if( !parse_int( &n, *ibufpp, ibufpp ) ) return -1;
second_addr += n;
}
else { ++*ibufpp;
if( ch == '+' ) ++second_addr; else --second_addr; }
break;
case '.':
case '$': if( !first ) { invalid_address(); return -1; };
first = false; ++*ibufpp;
second_addr = ( ( ch == '.' ) ? current_addr() : last_addr() );
break;
case '/':
case '?': if( !first ) { invalid_address(); return -1; };
second_addr = next_matching_node_addr( ibufpp, ch == '/' );
if( second_addr < 0 ) return -1;
if( ch == **ibufpp ) ++*ibufpp; /* remove delimiter */
first = false; break;
case '\'':if( !first ) { invalid_address(); return -1; };
first = false; ++*ibufpp;
second_addr = get_marked_node_addr( *(*ibufpp)++ );
if( second_addr < 0 ) return -1;
break;
case '%':
case ',':
case ';': if( first )
{
if( first_addr < 0 )
{ first_addr = ( ( ch == ';' ) ? current_addr() : 1 );
second_addr = last_addr(); }
}
else
{
if( second_addr < 0 || second_addr > last_addr() )
{ invalid_address(); return -1; }
if( ch == ';' ) set_current_addr( second_addr );
first_addr = second_addr; first = true;
}
++*ibufpp;
break;
default :
if( !first && ( second_addr < 0 || second_addr > last_addr() ) )
{ invalid_address(); return -1; }
{
int addr_cnt = 0; /* limited to 2 */
if( second_addr >= 0 ) addr_cnt = ( first_addr >= 0 ) ? 2 : 1;
if( addr_cnt <= 0 ) second_addr = current_addr();
if( addr_cnt <= 1 ) first_addr = second_addr;
return addr_cnt;
}
}
}
}
/* get a valid address from the command buffer */
static bool get_third_addr( const char ** const ibufpp, int * const addr )
{
const int old1 = first_addr;
const int old2 = second_addr;
int addr_cnt = extract_addresses( ibufpp );
if( addr_cnt < 0 ) return false;
if( traditional() && addr_cnt == 0 )
{ set_error_msg( "Destination expected" ); return false; }
if( second_addr < 0 || second_addr > last_addr() )
{ invalid_address(); return false; }
*addr = second_addr;
first_addr = old1; second_addr = old2;
return true;
}
/* set default range and return true if address range is valid */
static bool check_addr_range( const int n, const int m, const int addr_cnt )
{
if( addr_cnt == 0 ) { first_addr = n; second_addr = m; }
if( first_addr < 1 || first_addr > second_addr || second_addr > last_addr() )
{ invalid_address(); return false; }
return true;
}
/* set defaults to current_addr and return true if address range is valid */
static bool check_addr_range2( const int addr_cnt )
{
return check_addr_range( current_addr(), current_addr(), addr_cnt );
}
/* set default second_addr and return true if second_addr is valid */
static bool check_second_addr( const int addr, const int addr_cnt )
{
if( addr_cnt == 0 ) second_addr = addr;
if( second_addr < 1 || second_addr > last_addr() )
{ invalid_address(); return false; }
return true;
}
/* verify the command suffixes in the command buffer */
static bool get_command_suffix( const char ** const ibufpp,
int * const pflagsp, int * const snump )
{
bool nos_or_rep = !snump; /* not s command or repeated g/count */
bool error = false;
while( true )
{
const unsigned char ch = **ibufpp;
if( ch >= '1' && ch <= '9' )
{
int n = 0;
if( nos_or_rep || !parse_int( &n, *ibufpp, ibufpp ) || n <= 0 )
{ error = true; break; }
nos_or_rep = true; *snump = n; continue;
}
else if( ch == 'g' )
{ if( nos_or_rep ) break; else { nos_or_rep = true; *snump = 0; } }
else if( ch == 'l' ) { if( *pflagsp & GLS ) break; else *pflagsp |= GLS; }
else if( ch == 'n' ) { if( *pflagsp & GNP ) break; else *pflagsp |= GNP; }
else if( ch == 'p' ) { if( *pflagsp & GPR ) break; else *pflagsp |= GPR; }
else break;
++*ibufpp;
}
if( error || *(*ibufpp)++ != '\n' )
{ set_error_msg( "Invalid command suffix" ); return false; }
return true;
}
static bool unexpected_address( const int addr_cnt )
{
if( addr_cnt > 0 ) { set_error_msg( "Unexpected address" ); return true; }
return false;
}
static bool unexpected_command_suffix( const unsigned char ch )
{
if( !isspace( ch ) )
{ set_error_msg( "Unexpected command suffix" ); return true; }
return false;
}
static bool command_s( const char ** const ibufpp, int * const pflagsp,
const int addr_cnt, const bool isglobal )
{
static int pflags = 0; /* print suffixes */
static int gmask = GPR; /* the print suffixes to be toggled */
static int snum = 1; /* > 0 count, <= 0 global substitute */
enum Sflags {
SGG = 0x01, /* complement previous global substitute suffix */
SGP = 0x02, /* complement previous print suffix */
SGR = 0x04, /* use regex of last search (if newer) */
SGF = 0x08
} sflags = 0; /* if sflags != 0, repeat last substitution */
if( !check_addr_range2( addr_cnt ) ) return false;
do {
bool error = false;
if( **ibufpp >= '1' && **ibufpp <= '9' )
{
int n = 0;
if( ( sflags & SGG ) || !parse_int( &n, *ibufpp, ibufpp ) || n <= 0 )
error = true;
else
{ sflags |= SGG; snum = n; }
}
else switch( **ibufpp )
{
case '\n':sflags |= SGF; break;
case 'g': if( sflags & SGG ) error = true;
else { sflags |= SGG; snum = !snum; ++*ibufpp; }
break;
case 'p': if( sflags & SGP ) error = true;
else { sflags |= SGP; ++*ibufpp; } break;
case 'r': if( sflags & SGR ) error = true;
else { sflags |= SGR; ++*ibufpp; } break;
default : if( sflags ) error = true;
}
if( error ) { set_error_msg( "Invalid command suffix" ); return false; }
}
while( sflags && **ibufpp != '\n' );
if( sflags && !subst_regex() )
{ set_error_msg( "No previous substitution" ); return false; }
if( ( !sflags || ( sflags & SGR ) ) && !set_subst_regex( ibufpp ) )
return false;
if( !sflags )
{
const char delimiter = **ibufpp;
pflags = 0; snum = 1;
if( !extract_replacement( ibufpp, isglobal ) ) return false;
if( **ibufpp == '\n' ) pflags = GPR; /* omitted last delimiter */
else if( **ibufpp == delimiter ) ++*ibufpp; /* skip delimiter */
if( !get_command_suffix( ibufpp, &pflags, &snum ) ) return false;
gmask = pflags & ( GPR | GLS | GNP ); if( gmask == 0 ) gmask = GPR;
}
else if( sflags & SGP ) pflags ^= gmask;
*pflagsp = pflags;
if( !isglobal ) clear_undo_stack();
if( !search_and_replace( first_addr, second_addr, snum, isglobal ) )
return false;
return true;
}
static bool exec_global( const char ** const ibufpp, const int pflags,
const bool interactive );
/* execute the next command in command buffer; return error status */
static int exec_command( const char ** const ibufpp, const int prev_status,
const bool isglobal )
{
const char * fnp; /* filename */
int pflags = 0; /* print suffixes */
int addr, c, n;
const int addr_cnt = extract_addresses( ibufpp );
if( addr_cnt < 0 ) return ERR;
*ibufpp = skip_blanks( *ibufpp );
c = *(*ibufpp)++;
switch( c )
{
case 'a': if( !get_command_suffix( ibufpp, &pflags, 0 ) ) return ERR;
if( !isglobal ) clear_undo_stack();
if( !append_lines( ibufpp, second_addr, false, isglobal ) )
return ERR;
break;
case 'c': if( first_addr == 0 ) first_addr = 1;
if( second_addr == 0 ) second_addr = 1;
if( !check_addr_range2( addr_cnt ) ||
!get_command_suffix( ibufpp, &pflags, 0 ) ) return ERR;
if( !isglobal ) clear_undo_stack();
if( !delete_lines( first_addr, second_addr, isglobal ) ||
!append_lines( ibufpp, current_addr(),
current_addr() >= first_addr, isglobal ) )
return ERR;
break;
case 'd': if( !check_addr_range2( addr_cnt ) ||
!get_command_suffix( ibufpp, &pflags, 0 ) ) return ERR;
if( !isglobal ) clear_undo_stack();
if( !delete_lines( first_addr, second_addr, isglobal ) ) return ERR;
break;
case 'e': if( modified() && prev_status != EMOD ) return EMOD;
/* fall through */
case 'E': if( unexpected_address( addr_cnt ) ||
unexpected_command_suffix( **ibufpp ) ) return ERR;
fnp = get_filename( ibufpp, false );
if( !fnp || !delete_lines( 1, last_addr(), isglobal ) ||
!close_sbuf() ) return ERR;
if( !open_sbuf() ) return FATAL;
if( fnp[0] && fnp[0] != '!' ) set_def_filename( fnp );
if( read_file( fnp[0] ? fnp : def_filename, 0 ) < 0 )
return ERR;
reset_undo_state(); set_modified( false );
break;
case 'f': if( unexpected_address( addr_cnt ) ||
unexpected_command_suffix( **ibufpp ) ) return ERR;
fnp = get_filename( ibufpp, traditional() );
if( !fnp ) return ERR;
if( fnp[0] == '!' )
{ set_error_msg( "Invalid redirection" ); return ERR; }
if( fnp[0] ) set_def_filename( fnp );
printf( "%s\n", strip_escapes( def_filename ) );
break;
case 'g':
case 'v':
case 'G':
case 'V': if( isglobal )
{ set_error_msg( "Cannot nest global commands" ); return ERR; }
n = ( c == 'g' || c == 'G' ); /* mark matching lines */
if( !check_addr_range( 1, last_addr(), addr_cnt ) ||
!build_active_list( ibufpp, first_addr, second_addr, n ) )
return ERR;
n = ( c == 'G' || c == 'V' ); /* interactive */
if( ( n && !get_command_suffix( ibufpp, &pflags, 0 ) ) ||
!exec_global( ibufpp, pflags, n ) )
return ERR;
break;
case 'h':
case 'H': if( unexpected_address( addr_cnt ) ||
!get_command_suffix( ibufpp, &pflags, 0 ) ) return ERR;
if( c == 'H' ) verbose = !verbose;
if( ( c == 'h' || verbose ) && errmsg[0] )
printf( "%s\n", errmsg );
break;
case 'i': if( !get_command_suffix( ibufpp, &pflags, 0 ) ) return ERR;
if( !isglobal ) clear_undo_stack();
if( !append_lines( ibufpp, second_addr, true, isglobal ) )
return ERR;
break;
case 'j': if( !check_addr_range( current_addr(), current_addr() + 1, addr_cnt ) ||
!get_command_suffix( ibufpp, &pflags, 0 ) ) return ERR;
if( !isglobal ) clear_undo_stack();
if( first_addr < second_addr &&
!join_lines( first_addr, second_addr, isglobal ) ) return ERR;
break;
case 'k': n = *(*ibufpp)++;
if( second_addr == 0 ) { invalid_address(); return ERR; }
if( !get_command_suffix( ibufpp, &pflags, 0 ) ||
!mark_line_node( search_line_node( second_addr ), n ) )
return ERR;
break;
case 'l':
case 'n':
case 'p': if( c == 'l' ) n = GLS; else if( c == 'n' ) n = GNP; else n = GPR;
if( !check_addr_range2( addr_cnt ) ||
!get_command_suffix( ibufpp, &pflags, 0 ) ||
!print_lines( first_addr, second_addr, pflags | n ) )
return ERR;
pflags = 0;
break;
case 'm': if( !check_addr_range2( addr_cnt ) ||
!get_third_addr( ibufpp, &addr ) ) return ERR;
if( addr >= first_addr && addr < second_addr )
{ set_error_msg( "Invalid destination" ); return ERR; }
if( !get_command_suffix( ibufpp, &pflags, 0 ) ) return ERR;
if( !isglobal ) clear_undo_stack();
if( !move_lines( first_addr, second_addr, addr, isglobal ) )
return ERR;
break;
case 'P':
case 'q':
case 'Q': if( unexpected_address( addr_cnt ) ||
!get_command_suffix( ibufpp, &pflags, 0 ) ) return ERR;
if( c == 'P' ) prompt_on = !prompt_on;
else if( c == 'q' && modified() && prev_status != EMOD )
return EMOD;
else return QUIT;
break;
case 'r': if( unexpected_command_suffix( **ibufpp ) ) return ERR;
if( addr_cnt == 0 ) second_addr = last_addr();
fnp = get_filename( ibufpp, false );
if( !fnp ) return ERR;
if( !def_filename[0] && fnp[0] != '!' ) set_def_filename( fnp );
if( !isglobal ) clear_undo_stack();
addr = read_file( fnp[0] ? fnp : def_filename, second_addr );
if( addr < 0 ) return ERR;
if( addr ) set_modified( true );
break;
case 's': if( !command_s( ibufpp, &pflags, addr_cnt, isglobal ) )
return ERR;
break;
case 't': if( !check_addr_range2( addr_cnt ) ||
!get_third_addr( ibufpp, &addr ) ||
!get_command_suffix( ibufpp, &pflags, 0 ) ) return ERR;
if( !isglobal ) clear_undo_stack();
if( !copy_lines( first_addr, second_addr, addr ) ) return ERR;
break;
case 'u': if( unexpected_address( addr_cnt ) ||
!get_command_suffix( ibufpp, &pflags, 0 ) ||
!undo( isglobal ) ) return ERR;
break;
case 'w':
case 'W': n = **ibufpp;
if( n == 'q' || n == 'Q' ) ++*ibufpp;
if( unexpected_command_suffix( **ibufpp ) ) return ERR;
fnp = get_filename( ibufpp, false );
if( !fnp ) return ERR;
if( addr_cnt == 0 && last_addr() == 0 )
first_addr = second_addr = 0;
else if( !check_addr_range( 1, last_addr(), addr_cnt ) )
return ERR;
if( !def_filename[0] && fnp[0] != '!' ) set_def_filename( fnp );
addr = write_file( fnp[0] ? fnp : def_filename,
( c == 'W' ) ? "a" : "w", first_addr, second_addr );
if( addr < 0 ) return ERR;
if( addr == last_addr() && fnp[0] != '!' ) set_modified( false );
else if( n == 'q' && modified() && prev_status != EMOD )
return EMOD;
if( n == 'q' || n == 'Q' ) return QUIT;
break;
case 'x': if( second_addr < 0 || second_addr > last_addr() )
{ invalid_address(); return ERR; }
if( !get_command_suffix( ibufpp, &pflags, 0 ) ) return ERR;
if( !isglobal ) clear_undo_stack();
if( !put_lines( second_addr ) ) return ERR;
break;
case 'y': if( !check_addr_range2( addr_cnt ) ||
!get_command_suffix( ibufpp, &pflags, 0 ) ||
!yank_lines( first_addr, second_addr ) ) return ERR;
break;
case 'z': if( !check_second_addr( current_addr() + !isglobal, addr_cnt ) )
return ERR;
if( **ibufpp > '0' && **ibufpp <= '9' )
{ if( parse_int( &n, *ibufpp, ibufpp ) ) set_window_lines( n );
else return ERR; }
if( !get_command_suffix( ibufpp, &pflags, 0 ) ||
!print_lines( second_addr,
min( last_addr(), second_addr + window_lines() - 1 ),
pflags ) )
return ERR;
pflags = 0;
break;
case '=': if( !get_command_suffix( ibufpp, &pflags, 0 ) ) return ERR;
printf( "%d\n", addr_cnt ? second_addr : last_addr() );
break;
case '!': if( unexpected_address( addr_cnt ) ) return ERR;
fnp = get_shell_command( ibufpp );
if( !fnp ) return ERR;
if( system( fnp + 1 ) < 0 )
{ set_error_msg( "Can't create shell process" ); return ERR; }
if( !scripted() ) fputs( "!\n", stdout );
break;
case '\n': if( !check_second_addr( current_addr() +
( traditional() || !isglobal ), addr_cnt ) ||
!print_lines( second_addr, second_addr, 0 ) )
return ERR;
break;
case '#': while( *(*ibufpp)++ != '\n' ) ;
break;
default : set_error_msg( "Unknown command" ); return ERR;
}
if( pflags && !print_lines( current_addr(), current_addr(), pflags ) )
return ERR;
return 0;
}
/* apply command list in the command buffer to the active lines in a
range; return false if error */
static bool exec_global( const char ** const ibufpp, const int pflags,
const bool interactive )
{
static char * buf = 0;
static int bufsz = 0;
const char * cmd = 0;
if( !interactive )
{
if( traditional() && strcmp( *ibufpp, "\n" ) == 0 )
cmd = "p\n"; /* null cmd_list == 'p' */
else
{
if( !get_extended_line( ibufpp, 0, false ) ) return false;
cmd = *ibufpp;
}
}
clear_undo_stack();
while( true )
{
const line_t * const lp = next_active_node();
if( !lp ) break;
set_current_addr( get_line_node_addr( lp ) );
if( current_addr() < 0 ) return false;
if( interactive )
{
/* print current_addr; get a command in global syntax */
int len = 0;
if( !print_lines( current_addr(), current_addr(), pflags ) )
return false;
*ibufpp = get_stdin_line( &len );
if( !*ibufpp ) return false; /* error */
if( len <= 0 ) return false; /* EOF */
if( len == 1 && strcmp( *ibufpp, "\n" ) == 0 ) continue;
if( len == 2 && strcmp( *ibufpp, "&\n" ) == 0 )
{ if( !cmd ) { set_error_msg( "No previous command" ); return false; } }
else
{
if( !get_extended_line( ibufpp, &len, false ) ||
!resize_buffer( &buf, &bufsz, len + 1 ) ) return false;
memcpy( buf, *ibufpp, len + 1 );
cmd = buf;
}
}
*ibufpp = cmd;
while( **ibufpp ) if( exec_command( ibufpp, 0, true ) < 0 ) return false;
}
return true;
}
static void script_error( void )
{
if( verbose ) fprintf( stderr, "script, line %d: %s\n", linenum(), errmsg );
}
int main_loop( const bool loose )
{
extern jmp_buf jmp_state;
const char * ibufp; /* pointer to command buffer */
volatile int err_status = 0; /* program exit status */
int len = 0, status;
disable_interrupts();
set_signals();
status = setjmp( jmp_state );
if( !status ) enable_interrupts();
else { status = -1; fputs( "\n?\n", stdout ); set_error_msg( "Interrupt" ); }
while( true )
{
fflush( stdout ); fflush( stderr );
if( status < 0 && verbose ) { printf( "%s\n", errmsg ); fflush( stdout ); }
if( prompt_on ) { fputs( prompt_str, stdout ); fflush( stdout ); }
ibufp = get_stdin_line( &len );
if( !ibufp ) return 2; /* an error happened */
if( len <= 0 ) /* EOF on stdin ('q') */
{
if( !modified() || status == EMOD ) status = QUIT;
else { status = EMOD; if( !loose ) err_status = 2; }
}
else status = exec_command( &ibufp, status, false );
if( status == 0 ) continue;
if( status == QUIT ) return err_status;
fputs( "?\n", stdout ); /* give warning */
if( !loose && err_status == 0 ) err_status = 1;
if( status == EMOD ) set_error_msg( "Warning: buffer modified" );
if( is_regular_file( 0 ) )
{ script_error(); return ( ( status == FATAL ) ? 1 : err_status ); }
if( status == FATAL )
{ if( verbose ) { printf( "%s\n", errmsg ); } return 1; }
}
}