/* build_active_list: add line matching a pattern to the global-active list */
int
build_active_list(int isgcmd)
{
regex_t *pat;
line_t *lp;
int n;
char *s;
char delimiter;
if ((delimiter = *ibufp) == ' ' || delimiter == '\n') {
seterrmsg("invalid pattern delimiter");
return ERR;
} else if ((pat = get_compiled_pattern()) == NULL)
return ERR;
else if (*ibufp == delimiter)
ibufp++;
clear_active_list();
lp = get_addressed_line_node(first_addr);
for (n = first_addr; n <= second_addr; n++, lp = lp->q_forw) {
if ((s = get_sbuf_line(lp)) == NULL)
return ERR;
if (isbinary)
NUL_TO_NEWLINE(s, lp->len);
if (!regexec(pat, s, 0, NULL, 0) == isgcmd &&
set_active_node(lp) < 0)
return ERR;
}
return 0;
}
/* pop_undo_stack: undo last change to the editor buffer */
int
pop_undo_stack(void)
{
long n;
long o_current_addr = current_addr;
long o_addr_last = addr_last;
if (u_current_addr == -1 || u_addr_last == -1) {
seterrmsg("nothing to undo");
return ERR;
} else if (u_p)
modified = 1;
get_addressed_line_node(0); /* this get_addressed_line_node last! */
SPL1();
for (n = u_p; n-- > 0;) {
switch(ustack[n].type) {
case UADD:
REQUE(ustack[n].h->q_back, ustack[n].t->q_forw);
break;
case UDEL:
REQUE(ustack[n].h->q_back, ustack[n].h);
REQUE(ustack[n].t, ustack[n].t->q_forw);
break;
case UMOV:
case VMOV:
REQUE(ustack[n - 1].h, ustack[n].h->q_forw);
REQUE(ustack[n].t->q_back, ustack[n - 1].t);
REQUE(ustack[n].h, ustack[n].t);
n--;
break;
default:
/*NOTREACHED*/
;
}
ustack[n].type ^= 1;
}
/* reverse undo stack order */
for (n = u_p; n-- > (u_p + 1)/ 2;)
USWAP(ustack[n], ustack[u_p - 1 - n]);
if (isglobal)
clear_active_list();
current_addr = u_current_addr, u_current_addr = o_current_addr;
addr_last = u_addr_last, u_addr_last = o_addr_last;
SPL0();
return 0;
}
/* undo last change to the editor buffer */
bool undo( const bool isglobal )
{
int n;
const int o_current_addr = current_addr_;
const int o_last_addr = last_addr_;
const bool o_modified = modified_;
if( u_ptr <= 0 || u_current_addr < 0 || u_last_addr < 0 )
{ set_error_msg( "Nothing to undo" ); return false; }
search_line_node( 0 ); /* reset cached value */
disable_interrupts();
for( n = u_ptr - 1; n >= 0; --n )
{
switch( ustack[n].type )
{
case UADD: link_nodes( ustack[n].head->q_back, ustack[n].tail->q_forw );
break;
case UDEL: link_nodes( ustack[n].head->q_back, ustack[n].head );
link_nodes( ustack[n].tail, ustack[n].tail->q_forw );
break;
case UMOV:
case VMOV: link_nodes( ustack[n-1].head, ustack[n].head->q_forw );
link_nodes( ustack[n].tail->q_back, ustack[n-1].tail );
link_nodes( ustack[n].head, ustack[n].tail ); --n;
break;
}
ustack[n].type ^= 1;
}
/* reverse undo stack order */
for( n = 0; 2 * n < u_ptr - 1; ++n )
{
undo_t tmp = ustack[n];
ustack[n] = ustack[u_ptr-1-n]; ustack[u_ptr-1-n] = tmp;
}
if( isglobal ) clear_active_list();
current_addr_ = u_current_addr; u_current_addr = o_current_addr;
last_addr_ = u_last_addr; u_last_addr = o_last_addr;
modified_ = u_modified; u_modified = o_modified;
enable_interrupts();
return true;
}
/* add line matching a pattern to the global-active list */
char build_active_list( const char **ibufpp, const int first_addr,
const int second_addr, const char match )
{
regex_t *pat;
line_t *lp;
int addr;
const char delimiter = **ibufpp;
if( delimiter == ' ' || delimiter == '\n' )
{ set_error_msg( "Invalid pattern delimiter" ); return 0; }
if( !( pat = get_compiled_pattern( ibufpp ) ) ) return 0;
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 *s = get_sbuf_line( lp );
if( !s ) return 0;
if( isbinary() ) nul_to_newline( s, lp->len );
if( !regexec( pat, s, 0, 0, 0 ) == match && !set_active_node( lp ) )
return 0;
}
return 1;
}
