/*
* AddBitmapToToolBar - add a toolbar item ([temp], bitmap, help & command)
*/
vi_rc AddBitmapToToolBar( const char *data )
{
char file[FILENAME_MAX];
char help[MAX_STR];
char dont_save[MAX_STR];
tool_item *item;
int cmd_len;
int name_len;
dont_save[0] = 0;
data = SkipLeadingSpaces( data );
if( strnicmp( data, "temp", 4 ) == 0 ) {
/* get to the command */
GetStringWithPossibleQuote( &data, dont_save );
}
GetStringWithPossibleQuote( &data, file );
GetStringWithPossibleQuote( &data, help );
data = SkipLeadingSpaces( data );
cmd_len = strlen( data );
name_len = strlen( file );
item = MemAlloc( sizeof( tool_item ) + cmd_len + name_len + strlen( help ) + 2 );
strcpy( item->cmd, data );
if( name_len != 0 ) {
item->id = NextMenuId();
} else {
item->is_blank = true;
}
item->dont_save = ( strlen( dont_save ) != 0 );
if( file[0] && item->cmd[0] ) {
item->bmp = LoadBitmap( InstanceHandle, file );
if( item->bmp == HNULL ) {
item->bmp = ReadBitmapFile( ToolBarWindow( toolBar ), file, NULL );
}
item->name = &item->cmd[cmd_len + 1];
strcpy( item->name, file );
item->help = &item->name[name_len + 1];
strcpy( item->help, help );
} else {
item->bmp = HNULL;
}
if( toolBar ) {
addToolBarItem( item );
}
AddLLItemAtEnd( &toolBarHead, &toolBarTail, &item->tool_head );
return( ERR_NO_ERR );
} /* AddBitmapToToolBar */
vi_rc DoHelp( const char *data )
{
// Use the windows help till we get one of our own
LPSTR vi_chmfile = "editor.chm";
LPSTR vi_helpfile = "editor.hlp";
#ifdef __NT__
//LPSTR win_helpfile = "api32wh.hlp";
LPSTR win_helpfile = "win32sdk.hlp";
#else
LPSTR win_helpfile = "win31wh.hlp";
#endif
data = SkipLeadingSpaces( data );
if( strcmp( data, "OnHelp" ) == 0 ) {
WWinHelp( root_window_id, NULL, HELP_HELPONHELP, (HELP_DATA)0 );
} else if( strcmp( data, "Contents" ) == 0 ) {
if( !WHtmlHelp( root_window_id, vi_chmfile, HELP_CONTENTS, (HELP_DATA)0 ) ) {
WWinHelp( root_window_id, vi_helpfile, HELP_CONTENTS, (HELP_DATA)0 );
}
} else if( strcmp( data, "Search" ) == 0 ) {
if( !WHtmlHelp( root_window_id, vi_chmfile, HELP_PARTIALKEY, (HELP_DATA)(LPCSTR)"" ) ) {
WWinHelp( root_window_id, vi_helpfile, HELP_PARTIALKEY, (HELP_DATA)(LPCSTR)"" );
}
} else {
WWinHelp( root_window_id, win_helpfile, HELP_KEY, (HELP_DATA)(LPCSTR)data );
}
return ( ERR_NO_ERR );
}
/*
* EnterHexKey - enter a hexidecimal key stroke and insert it into the text
*/
vi_rc EnterHexKey( void )
{
int i;
char st[MAX_STR], val;
vi_rc rc;
const char *ptr;
rc = ModificationTest();
if( rc != ERR_NO_ERR ) {
return( rc );
}
if( CurrentLine->len >= EditVars.MaxLine - 1 ) {
return( ERR_LINE_FULL );
}
rc = PromptForString( "Enter the number of char to insert:", st, sizeof( st ) - 1, NULL );
if( rc != ERR_NO_ERR ) {
if( rc == NO_VALUE_ENTERED ) {
return( ERR_NO_ERR );
}
return( rc );
}
/*
* get value
*/
ptr = SkipLeadingSpaces( st );
val = (char)strtol( ptr, NULL, 0 );
if( val == '\0' ) {
return( ERR_INVALID_VALUE );
}
/*
* build undo record
*/
StartUndoGroup( UndoStack );
CurrentLineReplaceUndoStart();
CurrentLineReplaceUndoEnd( true );
EndUndoGroup( UndoStack );
/*
* add the char
*/
GetCurrentLine();
for( i = WorkLine->len; i >= CurrentPos.column - 1; i-- ) {
WorkLine->data[i + 1] = WorkLine->data[i];
}
WorkLine->data[CurrentPos.column - 1] = val;
WorkLine->len++;
DisplayWorkLine( true );
if( CurrentPos.column < WorkLine->len ) {
GoToColumn( CurrentPos.column + 1, WorkLine->len + 1 );
}
ReplaceCurrentLine();
EditFlags.Dotable = true;
return( ERR_NO_ERR );
} /* EnterHexKey */
vi_rc DoHelp( const char *data )
{
char *hfile;
char *tstr;
int token;
vi_rc rc;
char path[_MAX_PATH];
char tmp[MAX_STR];
int i;
data = SkipLeadingSpaces( data );
token = Tokenize( HelpCmdTokens, data, false );
if( token == TOK_INVALID ) {
if( data[0] == '\0' ) {
strcpy( tmp, "Topics: " );
for( i = 0; i < nHelpFiles; i++ ) {
if( i != 0 ) {
strcat( tmp, ", " );
}
strcat( tmp, GetTokenString( HelpCmdTokens, i ) );
}
Message1( "%s", tmp );
} else {
Error( "No help on topic %s", data );
}
return( DO_NOT_CLEAR_MESSAGE_WINDOW );
}
hfile = helpFiles[token];
GetFromEnv( hfile, path );
if( path[0] == '\0' ) {
Error( "Help file %s not found", hfile );
return( DO_NOT_CLEAR_MESSAGE_WINDOW );
}
EditFlags.ViewOnly = true;
rc = EditFile( path, false );
EditFlags.ViewOnly = false;
if( rc != ERR_NO_ERR ) {
return( rc );
}
tstr = GetTokenString( HelpCmdTokens, token );
strcpy( tmp, tstr );
strlwr( tmp );
strcat( tmp, " Help" );
tmp[0] = toupper( tmp[0] );
CurrentFile->read_only = false;
ReplaceString( &(CurrentFile->name), tmp );
SetFileWindowTitle( current_window_id, CurrentInfo, true );
DisplayFileStatus();
return( ERR_NO_ERR );
} /* DoHelp */
/*
* removeGenericAlias
*/
static vi_rc removeGenericAlias( const char *which, alias_list **head, alias_list **tail )
{
alias_list *curr;
which = SkipLeadingSpaces( which );
curr = checkGenericAlias( which, 0, *head );
if( curr == NULL ) {
return( ERR_NO_SUCH_ALIAS );
}
DeleteLLItem( (ss **)head, (ss **)tail, (ss *)curr );
Message1( "%s removed", which );
return( ERR_NO_ERR );
} /* removeGenericAlias */
/*
* OpenWindowOnFile - open a window on a file
*/
vi_rc OpenWindowOnFile( const char *data )
{
vi_rc rc;
window_id wid;
data = SkipLeadingSpaces( data );
if( data[0] == '\0' ) {
data = NULL;
}
wid = current_window_id;
rc = NewFile( data, true );
if( rc == ERR_NO_ERR ) {
InactiveWindow( wid );
DCDisplayAllLines();
}
return( rc );
} /* OpenWindowOnFile */
/*
* setGenericAlias - define an alias/abbreviation
*/
static vi_rc setGenericAlias( const char *what, alias_list **head, alias_list **tail )
{
alias_list *curr;
char str[MAX_STR];
what = GetNextWord1( what, str );
if( *str == '\0' ) {
return( ERR_INVALID_ALIAS );
}
what = SkipLeadingSpaces( what );
/*
* see if alias is already in list: if so, and there is expansion data,
* then replace the data, else delete the item
*/
for( curr = *head; curr != NULL; curr = curr->next ) {
if( strcmp( str, curr->alias ) == 0 ) {
MemFree( curr->expand );
if( *what == '\0' ) {
MemFree( curr->alias );
MemFree( DeleteLLItem( (ss **)head, (ss **)tail, (ss *)curr ) );
} else {
curr->expand = DupString( what );
}
}
}
/*
* add the new item
*/
curr = MemAlloc( sizeof( alias_list ) );
curr->alias = DupString( str );
curr->expand = DupString( what );
AddLLItemAtEnd( (ss **)head, (ss **)tail, (ss *)curr );
Message1( "%s set to \"%s\"", str, what );
return( DO_NOT_CLEAR_MESSAGE_WINDOW );
} /* setGenericAlias */
/*
* ParseCommandLine - parse a command line
*/
vi_rc ParseCommandLine( const char *cmdl, linenum *n1, bool *n1flag, linenum *n2, bool *n2flag, int *token, const char **data )
{
char *tres, *tmp;
int j;
linenum l;
vi_rc rc;
/*
* set up for parse
*/
tres = alloca( MAX_INPUT_LINE );
tmp = alloca( MAX_INPUT_LINE );
if( tmp == NULL || tres == NULL ) {
return( ERR_NO_STACK );
}
*n1flag = false;
*n2flag = false;
*data = "";
/*
* change null command to '.'
*/
cmdl = SkipLeadingSpaces( cmdl );
if( *cmdl == '\0' ) {
cmdl = ".";
}
/*
* check for magic '%' - all lines
*/
if( *cmdl == '%' ) {
*n1flag = true;
*n2flag = true;
*n1 = 1;
rc = CFindLastLine( n2 );
if( rc != ERR_NO_ERR ) {
return( rc );
}
cmdl = SkipLeadingSpaces( cmdl + 1 );
/*
* check for magic '#' - selected region
*/
} else if( *cmdl == '#' || *cmdl == '@' ) {
if( !SelRgn.selected ) {
if( *cmdl == '#' ) {
return( ERR_NO_SELECTION );
} else {
// use @ in scripts (eg mcsel.vi) when
// we KNOW something was just selected
SelRgn.selected = true;
}
}
*n1flag = true;
*n2flag = true;
if( SelRgn.start.line > SelRgn.end.line ) {
*n1 = SelRgn.end.line;
*n2 = SelRgn.start.line;
} else {
*n1 = SelRgn.start.line;
*n2 = SelRgn.end.line;
}
cmdl = SkipLeadingSpaces( cmdl + 1 );
/*
* try to get line range
*/
} else {
rc = GetAddress( &cmdl, &l );
if( rc > ERR_NO_ERR || rc == DO_NOT_CLEAR_MESSAGE_WINDOW ) {
return( rc );
}
if( rc == ERR_NO_ERR ) {
*n1flag = true;
*n1 = l;
cmdl = SkipLeadingSpaces( cmdl );
if( *cmdl == ',' ) {
cmdl = SkipLeadingSpaces( cmdl + 1 );
rc = GetAddress( &cmdl, &l );
if( rc > ERR_NO_ERR ) {
return( rc );
}
if( rc != ERR_NO_ERR ) {
return( ERR_INVALID_COMMAND );
}
*n2flag = true;
/*
* swap order (if start > end)
*/
if( *n1 > l ) {
*n2 = *n1;
*n1 = l;
} else {
*n2 = l;
}
}
}
}
/*
* check for system token
*/
if( *cmdl == '!' ) {
*data = cmdl + 1;
*token = PCL_T_SYSTEM;
return( ERR_NO_ERR );
}
/*
* get token and data
*/
cmdl = GetNextWord( cmdl, tres, pkwDelims );
if( *tres == '\0' ) {
return( ERR_NO_ERR );
}
if( CheckAlias( tres, tmp ) == ERR_NO_ERR ) {
strcat( tmp, cmdl );
cmdl = GetNextWord( tmp, tres, pDelims );
if( *tres == '\0' ) {
return( ERR_NO_ERR );
}
}
j = Tokenize( TokensCmdLine, tres, false );
if( j == TOK_INVALID ) {
j = Tokenize( TokensEx, tres, false );
if( j != TOK_INVALID ) {
j += 1000;
}
}
*token = j;
*data = cmdl;
return( ERR_NO_ERR );
} /* ParseCommandLine */
/*
* SelectLineInFile - select a line in a given file
*/
vi_rc SelectLineInFile( selflinedata *sfd )
{
int i, winflag;
int leftcol = 0, key2;
bool done = false;
bool redraw = true;
bool hiflag = false;
bool drawbord = false;
int farx, text_lines;
linenum pagetop = 1, lln = 1;
char tmp[MAX_STR];
hilst *ptr;
linenum cln;
linenum endline;
vi_rc rc;
vi_key key;
/*
* create the window
*/
cln = sfd->cln;
endline = sfd->f->fcbs.tail->end_line;
farx = sfd->wi->area.x2;
if( sfd->show_lineno ) {
farx++;
}
if( sfd->hilite != NULL ) {
hiflag = true;
}
rc = NewWindow2( &cwid, sfd->wi );
if( rc != ERR_NO_ERR ) {
return( rc );
}
if( !sfd->is_menu ) {
WindowAuxUpdate( cwid, WIND_INFO_HAS_SCROLL_GADGETS, true );
DrawBorder( cwid );
}
owid = sfd->eiw;
isMenu = sfd->is_menu;
PushMouseEventHandler( SelectLineMouseHandler );
KillCursor();
text_lines = WindowAuxInfo( cwid, WIND_INFO_TEXT_LINES );
sfd->sl = -1;
if( sfd->title != NULL ) {
WindowTitle( cwid, sfd->title );
}
pagetop = text_lines * (cln / text_lines);
if( cln % text_lines != 0 ) {
pagetop++;
}
key = 0;
if( LastEvent == VI_KEY( MOUSEEVENT ) ) {
DisplayMouse( true );
}
/*
* now, allow free scrolling and selection
*/
while( !done ) {
if( redraw ) {
if( sfd->show_lineno ) {
MySprintf(tmp, "%l/%l", cln, endline );
i = sfd->wi->area.x2 - sfd->wi->area.x1;
WindowBorderData( cwid, tmp, i - strlen( tmp ) );
drawbord = true;
}
if( hiflag ) {
ptr = sfd->hilite;
ptr += cln - 1;
if( ptr->_char == (char)-1 ) {
if( cln > lln ) {
cln++;
} else if( cln < lln ) {
cln--;
}
}
}
if( drawbord ) {
DrawBorder( cwid );
}
displayGenericLines( sfd->f, pagetop, leftcol, cln, &(sfd->wi->hilight_style), sfd->hilite, sfd->vals, sfd->valoff );
}
lln = cln;
redraw = true;
drawbord = false;
mouseLine = -1;
rlMenu = false;
if( key == VI_KEY( MOUSEEVENT ) ) {
DisplayMouse( true );
}
key = GetNextEvent( true );
if( hiflag && ((key >= VI_KEY( ALT_A ) && key <= VI_KEY( ALT_Z )) ||
(key >= VI_KEY( a ) && key <= VI_KEY( z )) || (key >= VI_KEY( A ) && key <= VI_KEY( Z )) ||
(key >= VI_KEY( 1 ) && key <= VI_KEY( 9 ))) ) {
i = 0;
if( key >= VI_KEY( ALT_A ) && key <= VI_KEY( ALT_Z ) ) {
key2 = key - VI_KEY( ALT_A ) + 'A';
} else if( key >= VI_KEY( a ) && key <= VI_KEY( z ) ) {
key2 = key - VI_KEY( a ) + 'A';
} else {
key2 = key;
}
ptr = sfd->hilite;
while( ptr->_char != '\0' ) {
if( toupper( ptr->_char ) == key2 ) {
cln = i + 1;
key = VI_KEY( ENTER );
break;
}
++i;
++ptr;
}
}
/*
* check if a return-event has been selected
*/
if( sfd->retevents != NULL ) {
i = 0;
if( key == VI_KEY( MOUSEEVENT ) ) {
if( mouse_wid == owid && LastMouseEvent == VI_MOUSE_PRESS ) {
DisplayMouse( false );
sfd->event = sfd->retevents[mouseLine];
key = VI_KEY( ENTER );
}
} else {
while( sfd->retevents[i] != 0 ) {
if( key == sfd->retevents[i] ) {
sfd->event = key;
key = VI_KEY( ENTER );
break;
}
i++;
}
}
}
/*
* process key stroke
*/
switch( key ) {
case VI_KEY( MOUSEEVENT ):
DisplayMouse( false );
if( hiflag ) {
ptr = sfd->hilite;
ptr += mouseLine;
if( ptr->_char == (char) -1 ) {
break;
}
}
if( rlMenu && sfd->allowrl != NULL ) {
*(sfd->allowrl) = rlMenuNum;
done = true;
break;
}
if( mouseScroll != MS_NONE ) {
switch( mouseScroll ) {
case MS_UP: goto evil_up;
case MS_DOWN: goto evil_down;
case MS_PAGEUP: goto evil_pageup;
case MS_PAGEDOWN: goto evil_pagedown;
case MS_EXPOSEDOWN:
adjustCLN( &cln, &pagetop, pagetop + text_lines - cln - 1, endline, text_lines );
adjustCLN( &cln, &pagetop, 1, endline, text_lines );
drawbord = true;
break;
case MS_EXPOSEUP:
adjustCLN( &cln, &pagetop, pagetop - cln, endline, text_lines );
adjustCLN( &cln, &pagetop, -1, endline, text_lines );
drawbord = true;
break;
}
break;
}
switch( LastMouseEvent ) {
case VI_MOUSE_DRAG:
if( mouse_wid != cwid ) {
break;
}
cln = mouseLine + pagetop;
break;
case VI_MOUSE_RELEASE:
if( !sfd->is_menu ) {
break;
}
if( mouse_wid == cwid ) {
cln = mouseLine + pagetop;
if( cln <= endline ) {
goto evil_enter;
}
}
break;
case VI_MOUSE_DCLICK:
if( mouse_wid != cwid ) {
AddCurrentMouseEvent();
done = true;
} else {
cln = mouseLine + pagetop;
if( cln <= endline ) {
goto evil_enter;
}
}
break;
case VI_MOUSE_PRESS_R:
if( mouse_wid != cwid ) {
AddCurrentMouseEvent();
done = true;
}
break;
case VI_MOUSE_PRESS:
if( mouse_wid != cwid ) {
AddCurrentMouseEvent();
done = true;
} else {
cln = mouseLine + pagetop;
}
break;
}
break;
case VI_KEY( ESC ):
done = true;
break;
evil_enter:
case VI_KEY( ENTER ):
case VI_KEY( SPACE ):
/*
* see if we need to do a callback for this
*/
if( sfd->checkres != NULL ) {
line *cline;
fcb *cfcb;
char *ptr;
i = cln - 1;
GimmeLinePtr( cln, sfd->f, &cfcb, &cline );
ptr = SkipLeadingSpaces( cline->data );
strcpy( tmp, sfd->vals[i] );
rc = sfd->checkres( ptr, tmp, &winflag );
if( winflag == 2 ) {
MoveWindowToFront( cwid );
}
if( rc == ERR_NO_ERR ) {
ReplaceString( &(sfd->vals[i]), tmp );
redraw = true;
}
break;
/*
* no value window, so just return line selected
*/
} else {
if( isMenu && InvokeMenuHook( CurrentMenuNumber, cln ) == -1 ) {
break;
}
sfd->sl = cln;
done = true;
}
break;
case VI_KEY( LEFT ):
case VI_KEY( h ):
if( sfd->allowrl != NULL ) {
*(sfd->allowrl) = -1;
done = true;
}
break;
case VI_KEY( RIGHT ):
case VI_KEY( l ):
if( sfd->allowrl != NULL ) {
*(sfd->allowrl) = 1;
done = true;
}
break;
evil_up:
case VI_KEY( UP ):
case VI_KEY( k ):
drawbord = adjustCLN( &cln, &pagetop, -1, endline, text_lines );
break;
evil_down:
case VI_KEY( DOWN ):
case VI_KEY( j ):
drawbord = adjustCLN( &cln, &pagetop, 1, endline, text_lines );
break;
case VI_KEY( CTRL_PAGEUP ):
drawbord = adjustCLN( &cln, &pagetop, -cln + 1, endline, text_lines );
break;
case VI_KEY( CTRL_PAGEDOWN ):
drawbord = adjustCLN( &cln, &pagetop, endline - cln, endline, text_lines );
break;
evil_pageup:
case VI_KEY( PAGEUP ):
case VI_KEY( CTRL_B ):
drawbord = adjustCLN( &cln, &pagetop, -text_lines, endline, text_lines );
break;
evil_pagedown:
case VI_KEY( PAGEDOWN ):
case VI_KEY( CTRL_F ):
drawbord = adjustCLN( &cln, &pagetop, text_lines, endline, text_lines );
break;
case VI_KEY( HOME ):
drawbord = true;
cln = 1;
pagetop = 1;
break;
case VI_KEY( END ):
drawbord = true;
cln = endline;
pagetop = endline - text_lines + 1;
if( pagetop < 1 ) {
pagetop = 1;
}
break;
default:
redraw = false;
break;
}
}
PopMouseEventHandler();
CloseAWindow( cwid );
RestoreCursor();
SetWindowCursor();
return( rc );
} /* SelectLineInFile */
/*
* SrcAssign - assign a value to a variable
*/
vi_rc SrcAssign( const char *data, vlist *vl )
{
int i, j, k, l;
long val;
bool rxflag = false;
bool envflag = false;
bool setflag = false;
bool expflag = false;
bool timeflag = false;
bool lnumflag = false;
char tmp[MAX_SRC_LINE], tmp1[MAX_SRC_LINE], name[MAX_SRC_LINE];
const char *v1;
char *t;
vars *v;
jmp_buf jmpaddr;
time_t tod;
bool check_end;
char tmpstr[MAX_STR];
/*
* get assign syntax :
* ASSIGN %v = /v1/(r)($)(@)(x)(l)(t)
* possible v1:
* strlen %a
* strchr %a ch
* substr %a n1 n2
*/
data = GetNextWord1( data, tmp );
if( *tmp == '\0' ) {
return( ERR_SRC_INVALID_ASSIGN );
}
if( !VarName( name, tmp, vl ) ) {
return( ERR_SRC_INVALID_ASSIGN );
}
data = GetNextWord1( data, tmp );
if( *tmp == '\0' ) {
return( ERR_SRC_INVALID_ASSIGN );
}
if( stricmp( tmp, "=" ) != 0 ) {
return( ERR_SRC_INVALID_ASSIGN );
}
data = SkipLeadingSpaces( data );
if( data[0] == '/' || data[0] == '"' ) {
check_end = false;
if( data[0] == '"' ) {
data = GetNextWord( data, tmp, SingleQuote );
if( data[0] == '"' ) {
check_end = true;
}
} else {
data = GetNextWord( data, tmp, SingleSlash );
if( data[0] == '/' ) {
check_end = true;
}
}
if( check_end ) {
for( ++data; data[0] != '\0'; data++ ) {
switch( data[0] ) {
case 't':
timeflag = true;
break;
case 'r':
rxflag = true;
break;
case '$':
envflag = true;
break;
case '@':
setflag = true;
break;
case 'x':
expflag = true;
break;
case 'l':
lnumflag = true;
break;
}
}
}
Expand( tmp1, tmp, vl );
} else {
data = GetNextWord1( data, tmp );
if( *tmp == '\0' ) {
return( ERR_SRC_INVALID_ASSIGN );
}
j = Tokenize( StrTokens, tmp, false );
if( j != TOK_INVALID ) {
data = GetNextWord1( data, tmp );
if( *tmp == '\0' ) {
return( ERR_SRC_INVALID_ASSIGN );
}
if( !VarName( tmp1, tmp, vl ) ) {
return( ERR_SRC_INVALID_ASSIGN );
}
v = VarFind( tmp1, vl );
switch( j ) {
case STR_T_STRLEN:
if( v != NULL ) {
sprintf( tmp1, "%d", v->len );
} else {
strcpy( tmp1, "0" );
}
break;
case STR_T_SUBSTR:
data = GetNextWord1( data, tmp );
if( *tmp == '\0' ) {
return( ERR_SRC_INVALID_ASSIGN );
}
Expand( tmp1, tmp, vl );
i = atoi( tmp1 ) - 1;
data = GetNextWord1( data, tmp );
if( *tmp == '\0' ) {
return( ERR_SRC_INVALID_ASSIGN );
}
Expand( tmp1, tmp, vl );
j = atoi( tmp1 ) - 1;
if( v == NULL ) {
tmp1[0] = '\0';
break;
}
if( j >= v->len || i < 0 ) {
tmp1[0] = '\0';
} else {
l = 0;
for( k = i; k <= j; k++ ) {
tmp1[l++] = v->value[k];
}
tmp1[l] = '\0';
}
break;
case STR_T_STRCHR:
data = GetNextWord1( data, tmp );
if( *tmp == '\0' ) {
return( ERR_SRC_INVALID_ASSIGN );
}
Expand( tmp1, tmp, vl );
if( v == NULL ) {
j = -1;
} else {
t = strchr( v->value, tmp1[0] );
if( t != NULL ) {
j = t - v->value;
} else {
j = -1;
}
j++;
}
sprintf( tmp1, "%d", j );
break;
}
} else {
Expand( tmp1, tmp, vl );
}
}
/*
* regular expression subs.
*/
if( rxflag && CurrentRegularExpression != NULL ) {
RegSub( CurrentRegularExpression, tmp1, tmp, CurrentPos.line );
strcpy( tmp1, tmp );
}
/*
* special processing
*/
if( envflag ) {
v1 = getenv( tmp1 );
if( v1 == NULL ) {
v1 = "";
}
} else if( setflag ) {
v1 = GetASetVal( tmp1, tmpstr );
} else if( timeflag ) {
tod = time( NULL );
strftime( tmp, sizeof( tmp ), tmp1, localtime( &tod ) );
v1 = tmp;
} else if( expflag || lnumflag ) {
i = setjmp( jmpaddr );
if( i != 0 ) {
return( (vi_rc)i );
}
StartExprParse( tmp1, jmpaddr );
val = GetConstExpr();
if( lnumflag ) {
fcb *cfcb;
line *cline;
vi_rc rc;
rc = CGimmeLinePtr( val, &cfcb, &cline );
v1 = cline->data;
if( rc != ERR_NO_ERR ) {
v1 = "";
}
} else {
v1 = ltoa( val, tmp1, EditVars.Radix );
}
} else {
v1 = tmp1;
}
VarAddStr( name, v1, vl );
return( ERR_NO_ERR );
} /* SrcAssign */
/*
* RemoveFromAutoSaveList - take a file that we are quitting out of the list
*/
void RemoveFromAutoSaveList( void )
{
FILE *f, *f2;
char as_path[FILENAME_MAX];
char as2_path[FILENAME_MAX];
char path[FILENAME_MAX];
char path2[FILENAME_MAX];
char data[FILENAME_MAX];
// bool found;
int i;
char *p;
if( EditVars.AutoSaveInterval == 0 ) {
return;
}
if( CurrentFile == NULL ) {
return;
}
if( !CurrentFile->been_autosaved ) {
return;
}
MakeTmpPath( as_path, checkFileName );
MakeTmpPath( as2_path, checkFileTmpName );
GetCurrentFilePath( path );
// found = false;
f = fopen( as_path, "r" );
if( f == NULL ) {
return;
}
f2 = fopen( as2_path, "w" );
if( f2 == NULL ) {
fclose( f );
return;
}
while( (p = fgets( path2, FILENAME_MAX, f )) != NULL ) {
for( i = strlen( p ); i && isWSorCtrlZ( p[i - 1] ); --i ) {
p[i - 1] = '\0';
}
p = GetNextWord1( p, data );
p = SkipLeadingSpaces( p );
if( strcmp( path, p ) == 0 ) {
p = MakeTmpPath( path2, CurrentFile->as_name );
if( strcmp( data, p ) == 0 ) {
// found = true;
remove( p );
while( fgets( data, FILENAME_MAX, f ) != NULL ) {
for( i = strlen( data ); i && isWSorCtrlZ( data[i - 1] ); --i ) {
data[i - 1] = '\0';
}
MyFprintf( f2, "%s\n", data );
}
break;
}
}
MyFprintf( f2, "%s %s\n", data, p );
}
fclose( f );
fclose( f2 );
remove( as_path );
rename( as2_path, as_path );
} /* RemoveFromAutoSaveList */
/*
* AutoSaveInit - initialize for auto-save
*/
void AutoSaveInit( void )
{
char path[FILENAME_MAX];
char path2[FILENAME_MAX];
char as_path[FILENAME_MAX];
char asl_path[FILENAME_MAX];
int len;
int cnt;
FILE *f;
int pid;
int ch;
int handle;
int off;
// int old_len;
int i;
char *p;
/*
* initialize tmpname
*/
#ifdef __UNIX__
strcpy( currTmpName,"aaaaaaaaaaaa.tmp" );
#else
strcpy( currTmpName,"aaaaaaaa.tmp" );
#endif
pid = getpid();
itoa( pid, path, 36 );
len = strlen( path );
memcpy( &currTmpName[TMP_FNAME_LEN - len], path, len );
#ifdef __QNX__
{
int len2, len3;
int nid, uid;
nid = getnid();
itoa( nid, path, 36 );
len2 = strlen( path );
memcpy( &currTmpName[TMP_FNAME_LEN - len - len2], path, len2 );
uid = getuid();
itoa( uid, path, 36 );
len3 = strlen( path );
memcpy( &currTmpName[TMP_FNAME_LEN - len - len2 - len3], path, len3 );
memcpy( &checkFileName[EXTRA_EXT_OFF], path, len3 );
memcpy( &checkFileTmpName[EXTRA_EXT_OFF], path, len3 );
memcpy( &lockFileName[EXTRA_EXT_OFF], path, len3 );
}
#endif
/*
* check if we need to recover lost files
*/
if( EditFlags.RecoverLostFiles ) {
cnt = 0;
MakeTmpPath( as_path, checkFileName );
MakeTmpPath( asl_path, lockFileName );
off = strlen( as_path ) - 5;
for( ch = START_CHAR; ch <= END_CHAR; ch++ ) {
as_path[off] = ch;
asl_path[off] = ch;
handle = sopen3( as_path, O_RDONLY | O_TEXT, SH_DENYRW );
if( handle < 0 ) {
continue;
}
f = fdopen( handle, "r" );
if( f != NULL ) {
while( (p = fgets( path2, FILENAME_MAX, f )) != NULL ) {
for( i = strlen( p ); i && isWSorCtrlZ( p[i - 1] ); --i ) {
p[i - 1] = '\0';
}
p = GetNextWord1( p, path );
p = SkipLeadingSpaces( p );
NewFile( path, false );
ReplaceString( &(CurrentFile->name), p );
SetFileWindowTitle( CurrentWindow, CurrentInfo, true );
FileSPVAR();
CurrentFile->modified = true;
CurrentFile->check_readonly = true;
FTSRunCmds( p );
cnt++;
}
fclose( f );
remove( as_path );
} else {
close( handle );
}
remove( asl_path );
}
if( cnt == 0 ) {
MyPrintf( "No files recovered!\n" );
ExitEditor( -1 );
}
Message1( "%d files recovered", cnt );
}
if( EditVars.AutoSaveInterval == 0 ) {
return;
}
// old_len = strlen( lockFileName );
MakeTmpPath( path, lockFileName );
len = strlen( path ) - strlen( lockFileName );
off = len + CHAR_OFF;
for( ch = START_CHAR; ch <= END_CHAR; ch++ ) {
path[off] = ch;
lockFileHandle = sopen4( path, O_CREAT | O_TRUNC | O_RDWR | O_TEXT, SH_DENYRW, PMODE_RW );
if( lockFileHandle > 0 ) {
break;
}
}
if( lockFileHandle < 0 ) {
// MyPrintf( "Too many editors running!\n" );
MyPrintf( "Error opening temp file - '%s'\n", strerror( errno ) );
ExitEditor( -1 );
}
lockFileName[CHAR_OFF] = ch;
checkFileName[CHAR_OFF] = ch;
checkFileTmpName[CHAR_OFF] = ch;
} /* AutoSaveInit */
/*
* RunCommandLine - run a command line command
*/
vi_rc RunCommandLine( const char *cmdl )
{
int i, x, y, x2, y2;
bool n1f, n2f;
int tkn, flag;
bool test1;
linenum n1, n2;
char st[FILENAME_MAX];
info *cinfo;
long val;
jmp_buf jmpaddr;
vi_rc rc;
const char *data;
/*
* parse command string
*/
tkn = TOK_INVALID;
rc = ParseCommandLine( cmdl, &n1, &n1f, &n2, &n2f, &tkn, &data );
if( rc != ERR_NO_ERR ) {
return( rc );
}
if( !n2f ) {
if( !n1f ) {
n1 = n2 = CurrentPos.line;
} else {
n2 = n1;
}
}
/*
* process tokens
*/
rc = ERR_INVALID_COMMAND;
test1 = n1f || n2f;
switch( tkn ) {
case PCL_T_ABOUT:
rc = DoAboutBox();
break;
case PCL_T_PUSH:
rc = PushFileStackAndMsg();
break;
case PCL_T_POP:
rc = PopFileStack();
break;
case PCL_T_EXECUTE:
data = SkipLeadingSpaces( data );
if( *data != '\0' ) {
key_map scr;
rc = AddKeyMap( &scr, data );
if( rc != ERR_NO_ERR ) {
break;
}
rc = RunKeyMap( &scr, 1L );
MemFree( scr.data );
}
break;
case PCL_T_DELETEMENU:
rc = DoMenuDelete( data );
break;
case PCL_T_DELETEMENUITEM:
rc = DoItemDelete( data );
break;
case PCL_T_ADDMENUITEM:
rc = AddMenuItem( data );
break;
case PCL_T_MAXIMIZE:
rc = MaximizeCurrentWindow();
break;
case PCL_T_MINIMIZE:
rc = MinimizeCurrentWindow();
break;
case PCL_T_EXITFILESONLY:
if( !ExitWithPrompt( false, false ) ) {
rc = ERR_EXIT_ABORTED;
} else {
rc = ERR_NO_ERR;
}
break;
case PCL_T_EXITALL:
if( !ExitWithPrompt( true, false ) ) {
rc = ERR_EXIT_ABORTED;
} else {
rc = ERR_NO_ERR;
}
break;
case PCL_T_QUITALL:
ExitWithVerify();
rc = ERR_NO_ERR;
break;
case PCL_T_KEYADD:
data = SkipLeadingSpaces( data );
KeyAddString( data );
rc = ERR_NO_ERR;
break;
case PCL_T_UNALIAS:
rc = UnAlias( data );
break;
case PCL_T_UNABBREV:
rc = UnAbbrev( data );
break;
case PCL_T_UNMAP:
case PCL_T_UNMAP_DMT:
flag = MAPFLAG_MESSAGE + MAPFLAG_UNMAP;
if( tkn == PCL_T_UNMAP_DMT ) {
flag |= MAPFLAG_DAMMIT;
}
rc = MapKey( flag, data );
break;
case PCL_T_EVAL:
data = Expand( dataBuff, data, NULL );
i = setjmp( jmpaddr );
if( i != 0 ) {
rc = (vi_rc)i;
} else {
StartExprParse( data, jmpaddr );
val = GetConstExpr();
ltoa( val, st, EditVars.Radix );
Message1( "%s", st );
rc = ERR_NO_ERR;
}
break;
case PCL_T_COMPILE:
case PCL_T_SOURCE:
case PCL_T_LOAD:
{
char *tstr;
srcline sline;
data = GetNextWord1( data, st );
if( *st == '\0' ) {
rc = ERR_NO_FILE_SPECIFIED;
break;
}
if( tkn == PCL_T_COMPILE ) {
EditFlags.CompileScript = true;
if( st[0] == '-' ) {
if( st[1] == 'a' || st[1] == 'A' ) {
EditFlags.CompileAssignments = true;
if( st[1] == 'A' ) {
EditFlags.CompileAssignmentsDammit = true;
}
data = GetNextWord1( data, st);
if( *st == '\0' ) {
rc = ERR_NO_FILE_SPECIFIED;
break;
}
}
}
}
if( tkn == PCL_T_LOAD ) {
EditFlags.LoadResidentScript = true;
}
sline = 0;
rc = Source( st, data, &sline );
EditFlags.LoadResidentScript = false;
EditFlags.CompileScript = false;
EditFlags.CompileAssignments = false;
EditFlags.CompileAssignmentsDammit = false;
if( EditFlags.SourceScriptActive ) {
LastError = rc;
}
if( rc > ERR_NO_ERR ) {
Error( "%s on line %u of \"%s\"", GetErrorMsg( rc ), sline, st );
} else {
if( rc != DO_NOT_CLEAR_MESSAGE_WINDOW ) {
if( tkn != PCL_T_SOURCE ) {
if( tkn == PCL_T_LOAD ) {
tstr = strLoad;
} else {
tstr = strCompile;
}
Message1( "Script \"%s\" %s, %u lines generated, %d errors",
st, tstr, sline, SourceErrCount );
rc = DO_NOT_CLEAR_MESSAGE_WINDOW;
}
}
}
break;
}
case PCL_T_GENCONFIG:
#ifndef __WIN__
data = GetNextWord1( data,st );
if( *st != '\0' ) {
rc = GenerateConfiguration( st, true );
} else {
rc = GenerateConfiguration( NULL, true );
}
#else
{
bool temp = EditFlags.SaveConfig;
EditFlags.SaveConfig = true;
WriteProfile();
EditFlags.SaveConfig = temp;
rc = ERR_NO_ERR;
}
#endif
break;
case PCL_T_COMPRESS:
rc = CompressWhiteSpace();
break;
case PCL_T_EXPAND:
rc = ExpandWhiteSpace();
break;
case PCL_T_SHOVE:
rc = Shift( n1, n2, '>', true );
break;
case PCL_T_SUCK:
rc = Shift( n1, n2, '<', true );
break;
case PCL_T_FILES:
if( EditFlags.LineDisplay ) {
rc = DisplayFileStatus();
} else {
rc = EditFileFromList();
}
break;
case PCL_T_NEXT:
rc = RotateFileForward();
break;
case PCL_T_PREV:
rc = RotateFileBackwards();
break;
case PCL_T_HELP:
rc = DoHelp( data );
break;
case PCL_T_VIEW:
case PCL_T_VIEW_DMT:
EditFlags.ViewOnly = true;
case PCL_T_EDIT:
case PCL_T_EDIT_DMT:
rc = EditFile( data, ( tkn == PCL_T_VIEW_DMT || tkn == PCL_T_EDIT_DMT ) );
EditFlags.ViewOnly = false;
break;
case PCL_T_OPEN:
rc = OpenWindowOnFile( data );
break;
case PCL_T_HIDE:
case PCL_T_HIDE_DMT:
rc = HideLineRange( n1, n2, ( tkn == PCL_T_HIDE_DMT ) );
break;
case PCL_T_DELETE:
rc = SetSavebufNumber( data );
if( rc != ERR_NO_ERR ) {
break;
}
if( SelRgn.selected && !EditFlags.LineBased ) {
AddSelRgnToSavebufAndDelete();
rc = ERR_NO_ERR;
// @ may have turned this on - it is now definitely off
SelRgn.selected = false;
} else {
rc = DeleteLineRange( n1, n2, SAVEBUF_FLAG );
}
if( rc == ERR_NO_ERR ) {
DCDisplayAllLines();
LineDeleteMessage( n1, n2 );
}
break;
case PCL_T_SAVEANDEXIT:
data = GetNextWord1( data, st );
if( *st == '\0' ) {
rc = SaveAndExit( st );
} else {
rc = SaveAndExit( NULL );
}
break;
case PCL_T_PUT:
case PCL_T_PUT_DMT:
rc = SetSavebufNumber( data );
if( rc != ERR_NO_ERR ) {
break;
}
rc = SaveAndResetFilePos( n1 );
if( rc == ERR_NO_ERR ) {
if( tkn == PCL_T_PUT ) {
rc = InsertSavebufAfter();
} else {
rc = InsertSavebufBefore();
}
RestoreCurrentFilePos();
}
break;
case PCL_T_YANK:
rc = SetSavebufNumber( data );
if( rc != ERR_NO_ERR ) {
break;
}
if( SelRgn.selected && !EditFlags.LineBased ) {
rc = YankSelectedRegion();
// @ may have turned this on - it is now definitely off
SelRgn.selected = false;
} else {
rc = YankLineRange( n1, n2 );
}
break;
case PCL_T_SUBSTITUTE:
rc = Substitute( n1, n2, data );
break;
case PCL_T_GLOBAL:
case PCL_T_GLOBAL_DMT:
if( !test1 ) {
n1 = 1;
rc = CFindLastLine( &n2 );
if( rc != ERR_NO_ERR ) {
break;
}
}
rc = Global( n1,n2, data, ( tkn == PCL_T_GLOBAL_DMT ) );
break;
case PCL_T_WRITEQUIT:
if( CurrentFile == NULL ) {
rc = NextFile();
} else {
CurrentFile->modified = true;
data = GetNextWord1( data, st );
if( *st != '\0' ) {
rc = SaveAndExit( st );
} else {
rc = SaveAndExit( NULL );
}
}
break;
case PCL_T_WRITE:
case PCL_T_WRITE_DMT:
data = GetNextWord1( data, st );
if( test1 ) {
if( *st == '\0' ) {
rc = ERR_NO_FILE_SPECIFIED;
} else {
rc = SaveFile( st, n1, n2, ( tkn == PCL_T_WRITE_DMT ) );
}
} else {
if( st[0] != '\0' ) {
#ifdef __WIN__
if( st[0] == '?' && st[1] == '\0' ) {
rc = SaveFileAs();
break;
} else {
rc = SaveFile( st, -1, -1, ( tkn == PCL_T_WRITE_DMT ) );
}
#else
rc = SaveFile( st, -1, -1, ( tkn == PCL_T_WRITE_DMT ) );
#endif
} else {
rc = SaveFile( NULL, -1, -1, ( tkn == PCL_T_WRITE_DMT ) );
if( rc == ERR_NO_ERR ) {
Modified( false );
}
}
}
break;
case PCL_T_READ:
rc = ReadAFile( n1, data );
break;
case PCL_T_QUIT:
#ifdef __WIN__
rc = CurFileExitOptionSaveChanges();
#else
rc = NextFile();
#endif
break;
case PCL_T_QUIT_DMT:
rc = NextFileDammit();
break;
case PCL_T_DATE:
GetDateTimeString( st );
Message1( st );
rc = DO_NOT_CLEAR_MESSAGE_WINDOW;
break;
case PCL_T_CD:
data = GetNextWord1( data, st );
if( *st != '\0' ) {
rc = SetCWD( st );
} else {
rc = ERR_NO_ERR;
}
if( rc == ERR_NO_ERR ) {
Message1( "Current directory is %s",CurrentDirectory );
}
break;
case PCL_T_SHELL:
EVIL_SHELL:
{
#if defined( __NT__ ) && !defined( __WIN__ )
ExecCmd( NULL, NULL, NULL );
#else
char foo[FILENAME_MAX];
strcpy( foo, Comspec );
ExecCmd( NULL, NULL, foo );
#endif
DoVersion();
rc = ERR_NO_ERR;
}
break;
case PCL_T_SYSTEM:
if( n1f && n2f ) {
rc = DoGenericFilter( n1, n2, data );
} else {
data = SkipLeadingSpaces( data );
if( *data == '\0' ) {
goto EVIL_SHELL;
}
ExecCmd( NULL, NULL, data );
rc = ERR_NO_ERR;
}
break;
case PCL_T_RESIZE:
rc = ResizeCurrentWindowWithKeys();
break;
case PCL_T_TILE:
data = GetNextWord1( data, st );
if( st[0] != '\0' ) {
if( st[0] == 'v' ) {
y = 1;
for( x = 0, cinfo = InfoHead; cinfo != NULL; cinfo = cinfo->next ) {
x++;
}
} else if( st[0] == 'h' ) {
x = 1;
for( y = 0, cinfo = InfoHead; cinfo != NULL; cinfo = cinfo->next ) {
y++;
}
} else {
x = atoi( st );
data = GetNextWord1( data, st );
if( *st == '\0' ) {
break;
} else {
y = atoi( st );
}
}
} else {
x = EditVars.MaxWindowTileX;
y = EditVars.MaxWindowTileY;
}
if( x > 0 && y > 0) {
rc = WindowTile( x, y );
}
break;
case PCL_T_CASCADE:
rc = WindowCascade();
break;
case PCL_T_MOVEWIN:
rc = MoveCurrentWindowWithKeys();
break;
case PCL_T_TAG:
data = GetNextWord1( data, st );
if( *st != '\0' ) {
rc = TagHunt( st );
}
break;
case PCL_T_FGREP:
{
bool ci;
data = SkipLeadingSpaces( data );
ci = EditFlags.CaseIgnore;
if( data[0] == '-' ) {
if( data[1] == 'c' ) {
ci = false;
data += 2;
data = SkipLeadingSpaces( data );
rc = GetStringWithPossibleQuote( &data, st );
} else if( data[1] == 'i' ) {
ci = true;
data += 2;
data = SkipLeadingSpaces( data );
rc = GetStringWithPossibleQuote( &data, st );
} else if( data[1] == 'f' ) {
data += 2;
data = SkipLeadingSpaces( data );
#ifdef __WIN__
// call fancy grep window
{
fancy_find *ff;
/* ff will be set to point at a static fancy find struct
* in the snoop module */
char snoopbuf[FILENAME_MAX];
if( !GetSnoopStringDialog( &ff ) ) {
return( ERR_NO_ERR );
}
strcpy( snoopbuf, ff->path );
/* assume no string means current directory */
if( strlen( snoopbuf ) &&
snoopbuf[strlen( snoopbuf ) - 1] != '\\' ){
strcat( snoopbuf, "\\" );
}
MySprintf( st, "%s", ff->find );
strcat( snoopbuf, ff->ext );
ci = ff->case_ignore;
if( !ff->use_regexp ) {
//MakeExpressionNonRegular( st );
rc = DoFGREP( snoopbuf, st, ci );
} else {
rc = DoEGREP( snoopbuf, st );
}
break;
}
#endif
}
} else {
rc = GetStringWithPossibleQuote( &data, st );
}
if( rc != ERR_NO_STRING ) {
rc = DoFGREP( data, st, ci );
}
}
break;
case PCL_T_EGREP:
rc = GetStringWithPossibleQuote( &data, st );
if( rc != ERR_NO_STRING ) {
rc = DoEGREP( data, st );
}
break;
case PCL_T_SIZE:
data = GetNextWord1( data, st );
if( *st == '\0' ) {
break;
}
x = atoi( st );
data = GetNextWord1( data, st );
if( *st == '\0' ) {
break;
}
y = atoi( st );
data = GetNextWord1( data, st );
if( *st == '\0' ) {
break;
}
x2 = atoi( st );
data = GetNextWord1( data, st );
if( *st == '\0' ) {
break;
}
y2 = atoi( st );
rc = CurrentWindowResize( x, y, x2, y2 );
break;
case PCL_T_ECHO:
data = GetNextWord1( data, st );
if( *st == '\0' ) {
break;
}
rc = ERR_NO_ERR;
if( !stricmp( st, "on" ) ) {
EditFlags.EchoOn = true;
break;
} else if( !stricmp( st, "off" ) ) {
EditFlags.EchoOn = false;
break;
}
x = atoi( st );
data = SkipLeadingSpaces( data );
/*
* FIXME: This is not good - I will definately have to
* fix this code up. But right now I have to get the
* editor ready for tomorrow. Brad.
*/
if( data[0] == '"' || data[0] == '/' ) {
GetStringWithPossibleQuote( &data, st );
if( x > 2 ) {
/* this is obviously a sick individual */
Error( "Invalid Echo" );
} else if( x == 1 ) {
Message1( st );
} else if( x == 2 ) {
Message2( st );
}
// DisplayLineInWindow( MessageWindow, x, st );
} else {
if( x > 2 ) {
/* this is obviously a sick individual */
Error( "Invalid Echo" );
} else if( x == 1 ) {
Message1( data );
} else if( x == 2 ) {
Message2( data );
}
// DisplayLineInWindow( MessageWindow, x, data );
}
break;
#ifdef VI_RCS
case PCL_T_CHECKOUT:
rc = ERR_NO_ERR;
#ifdef __WINDOWS__
if( isOS2() ) break; // OS/2 shell returns before checkout finishes
#endif
if( CurrentFile != NULL ) {
rc = ViRCSCheckout( rc );
}
break;
case PCL_T_CHECKIN:
if( CurrentFile != NULL ) {
rc = ViRCSCheckin( rc );
}
break;
#endif
default:
if( tkn >= 1000 ) {
rc = ProcessEx( n1, n2, n2f, tkn - 1000, data );
break;
}
rc = TryCompileableToken( tkn, data, true );
if( rc != NOT_COMPILEABLE_TOKEN ) {
break;
}
rc = ProcessWindow( tkn, data );
if( rc >= ERR_NO_ERR ) {
break;
}
case TOK_INVALID:
if( n1f && !n2f ) {
if( !n1 ) {
n1 = 1;
}
MemorizeCurrentContext();
rc = GoToLineNoRelCurs( n1 );
if( rc == ERR_NO_ERR ) {
GoToColumnOnCurrentLine( 1 );
if( EditFlags.LineDisplay ) {
MyPrintf( "%s\n", CurrentLine->data );
}
}
return( rc );
}
rc = ERR_INVALID_COMMAND;
break;
}
if( rc == ERR_NO_ERR ) {
rc = DO_NOT_CLEAR_MESSAGE_WINDOW;
}
return( rc );
} /* RunCommandLine */
/*
* EditFile - read a file into text
*/
vi_rc EditFile( const char *name, bool dammit )
{
char *fn, **list, *currfn;
int i, cnt, ocnt;
int j, len;
window_id wid = NO_WINDOW;
char cdir[FILENAME_MAX];
info *ci, *il;
bool usedir = false;
char mask[FILENAME_MAX];
bool reset_dir;
int index;
#ifdef __WIN__
char *altname = NULL;
#endif
vi_rc rc;
fn = MemAlloc( FILENAME_MAX );
/*
* get file name
*/
strcpy( cdir, CurrentDirectory );
reset_dir = false;
name = SkipLeadingSpaces( name );
if( name[0] == '$' ) {
++name;
usedir = true;
}
fn[0] = '\0';
// if( NextWord1FN( name, fn ) <= 0 )
if( GetStringWithPossibleQuote2( &name, fn, false ) != ERR_NO_ERR ) {
usedir = true;
mask[0] = '*';
mask[1] = '\0';
}
if( usedir ) {
if( EditFlags.ExMode ) {
MemFree( fn );
return( ERR_INVALID_IN_EX_MODE );
}
len = strlen( fn );
if( len > 0 ) {
strcpy( mask, fn );
cnt = 0;
for( i = len; i-- > 0; ) {
if( fn[i] == FILE_SEP ) {
for( j = i + 1; j <= len; j++ ) {
mask[j - (i + 1)] = fn[j];
}
cnt = i;
break;
}
}
fn[cnt] = '\0';
}
if( fn[0] != '\0' ) {
rc = SelectFileOpen( fn, &fn, mask, true );
} else {
#ifdef __WIN__
if( name[0] == '\0' ) {
altname = MemAlloc( 1000 );
rc = SelectFileOpen( CurrentDirectory, &altname, mask, true );
name = GetNextFileName( altname, fn ); // if multiple, kill path
if( isMultipleFiles( name ) ) {
name = GetNextFileName( name, fn ); // get 1st name
}
} else {
rc = SelectFileOpen( CurrentDirectory, &fn, mask, true );
}
#else
rc = SelectFileOpen( CurrentDirectory, &fn, mask, true );
#endif
}
if( rc != ERR_NO_ERR || fn[0] == '\0' ) {
MemFree( fn );
SetCWD( cdir );
return( rc );
}
}
/*
* loop through all files
*/
rc = ERR_NO_ERR;
EditFlags.WatchForBreak = true;
#ifdef __WIN__
ToggleHourglass( true );
#endif
do {
if( IsDirectory( fn ) ) {
if( EditFlags.ExMode ) {
rc = ERR_INVALID_IN_EX_MODE;
reset_dir = true;
break;
}
rc = SelectFileOpen( fn, &fn, "*", false );
if( rc != ERR_NO_ERR ) {
reset_dir = true;
break;
}
if( fn[0] == '\0' ) {
reset_dir = true;
rc = ERR_NO_ERR;
break;
}
}
currfn = fn;
ocnt = cnt = ExpandFileNames( currfn, &list );
if( !cnt ) {
cnt = 1;
} else {
currfn = list[0];
}
/*
* loop through all expanded files
*/
index = 1;
while( cnt > 0 ) {
cnt--;
/*
* quit current file if ! specified, else just save current state
*/
if( dammit ) {
ci = InfoHead;
if( CurrentInfo == ci ) {
ci = ci->next;
}
RemoveFromAutoSaveList();
#ifdef __WIN__
CloseAChildWindow( current_window_id );
#else
CloseAWindow( current_window_id );
#endif
FreeUndoStacks();
FreeMarkList();
FreeEntireFile( CurrentFile );
MemFree( DeleteLLItem( (ss **)&InfoHead, (ss **)&InfoTail,
(ss *)CurrentInfo ) );
CurrentInfo = NULL;
current_window_id = NO_WINDOW;
} else {
ci = CurrentInfo;
SaveCurrentInfo();
wid = current_window_id;
}
/*
* see if new file is already being edited
*/
SaveCurrentInfo();
for( il = InfoHead; il != NULL; il = il->next ) {
if( SameFile( il->CurrentFile->name, currfn ) ) {
break;
}
if( strcmp( CurrentDirectory, il->CurrentFile->home ) ) {
/* directory has changed -- check with full path
* note that this will fail if an absolute path
* was specified thus we do the regular check first */
char path[FILENAME_MAX];
char drive[_MAX_DRIVE];
char dir[_MAX_DIR];
char fname[_MAX_FNAME];
char ext[_MAX_EXT];
size_t path_len;
_splitpath( il->CurrentFile->name, drive, dir, fname, ext );
if( drive[0] == '\0' ) {
_splitpath( il->CurrentFile->home, drive, NULL, NULL, NULL );
}
strcpy( path, il->CurrentFile->home );
path_len = strlen( path );
if( path_len-- > 0 ) {
#ifdef __UNIX__
if( path[path_len] != FILE_SEP ) {
#else
if( path[path_len] != DRV_SEP && path[path_len] != FILE_SEP ) {
#endif
strcat( path, FILE_SEP_STR );
}
}
if( dir[0] == '\0' ) {
_splitpath( path, NULL, dir, NULL, NULL );
} else if( dir[0] != FILE_SEP ) {
char dir2[_MAX_DIR];
_splitpath( path, NULL, dir2, NULL, NULL );
strcat( dir2, dir );
strcpy( dir, dir2 );
}
_makepath( path, drive, dir, fname, ext );
if( SameFile( path, currfn ) ) {
break;
}
}
}
if( il != NULL ) {
BringUpFile( il, true );
} else {
/*
* file not edited, go get it
*/
rc = NewFile( currfn, false );
if( rc != ERR_NO_ERR && rc != NEW_FILE ) {
RestoreInfo( ci );
DCDisplayAllLines();
break;
}
if( !dammit ) {
InactiveWindow( wid );
}
if( EditFlags.BreakPressed ) {
break;
}
}
if( cnt > 0 ) {
currfn = list[index];
index++;
}
}
if( ocnt > 0 ) {
MemFreeList( ocnt, list );
}
if( EditFlags.BreakPressed ) {
ClearBreak();
break;
}
name = GetNextFileName( name, fn );
} while( *fn != '\0' );
#ifdef __WIN__
if( altname != NULL ) {
MemFree( altname );
}
#endif
MemFree( fn );
#ifdef __WIN__
ToggleHourglass( false );
#endif
EditFlags.WatchForBreak = false;
if( reset_dir ) {
SetCWD( cdir );
}
return( rc );
} /* EditFile */
#ifndef __WIN__
static const char *fileOpts[] = {
(const char *)"<F1> Go To",
(const char *)"<F2> Quit",
(const char *)"<F3> Save & Quit"
};
static const vi_key fileopts_evlist[] = {
VI_KEY( F1 ),
VI_KEY( F2 ),
VI_KEY( F3 ),
VI_KEY( DUMMY )
};
/*
* EditFileFromList - edit from file in current active list
*/
vi_rc EditFileFromList( void )
{
int i, tmp, j, n = 0, fcnt;
window_id wid;
bool repeat = true;
info *cinfo;
char **list, modchar;
bool show_lineno;
window_info wi;
selectitem si;
vi_rc rc;
/*
* set up options for file list
*/
memcpy( &wi, &extraw_info, sizeof( window_info ) );
wi.area.x1 = 2;
wi.area.x2 = 19;
rc = DisplayExtraInfo( &wi, &wid, fileOpts, sizeof( fileOpts ) / sizeof( fileOpts[0] ) );
if( rc != ERR_NO_ERR ) {
return( rc );
}
while( repeat > 0 ) {
/*
* set up for this pass
*/
repeat = false;
MoveWindowToFrontDammit( wid, false );
SaveCurrentInfo();
/*
* allocate a buffer for strings, add strings
*/
list = (char **) MemAlloc( GimmeFileCount() * sizeof( char * ) );
for( j = 0, cinfo = InfoHead; cinfo != NULL; cinfo = cinfo->next, ++j ) {
list[j] = MemAlloc( strlen( cinfo->CurrentFile->name ) + 3 );
if( cinfo->CurrentFile->modified ) {
modchar = '*';
} else {
modchar = ' ';
}
MySprintf( list[j], "%c %s", modchar, cinfo->CurrentFile->name );
}
fcnt = j;
tmp = filelistw_info.area.y2;
i = filelistw_info.area.y2 - filelistw_info.area.y1 + 1;
if( filelistw_info.has_border ) {
i -= 2;
}
if( j < i ) {
filelistw_info.area.y2 -= ( i - j );
}
show_lineno = true;
/*
* get file
*/
if( n + 1 > j ) {
n = j - 1;
}
memset( &si, 0, sizeof( si ) );
si.wi = &filelistw_info;
si.title = "Current Files";
si.list = list;
si.maxlist = j;
si.num = n;
si.retevents = fileopts_evlist;
si.event = VI_KEY( DUMMY );
si.show_lineno = show_lineno;
si.cln = n + 1;
si.eiw = wid;
rc = SelectItem( &si );
n = si.num;
if( rc == ERR_NO_ERR ) {
if( n >= 0 ) {
cinfo = InfoHead;
for( j = 0; j < n; ++j ) {
cinfo = cinfo->next;
}
BringUpFile( cinfo, true );
switch( si.event ) {
case VI_KEY( DUMMY ):
case VI_KEY( F1 ):
break;
case VI_KEY( F2 ):
rc = NextFile();
if( rc <= ERR_NO_ERR ) {
repeat = true;
}
break;
case VI_KEY( F3 ):
rc = SaveAndExit( NULL );
if( rc <= ERR_NO_ERR ) {
repeat = true;
}
break;
}
}
}
filelistw_info.area.y2 = tmp;
MemFreeList( fcnt, list );
}
/*
* get rid of option stuff
*/
CloseAWindow( wid );
return( rc );
} /* EditFileFromList */
/*
* Global - perform global command
*/
vi_rc Global( linenum n1, linenum n2, const char *data, int dmt )
{
char *sstr, *linedata;
bool match;
vi_rc rc;
vi_rc rc1;
long changecnt = 0;
linenum ll;
fcb *cfcb;
line *cline;
regexp crx;
i_mark pos;
/*
* get search string and command
*/
rc = ModificationTest();
if( rc != ERR_NO_ERR ) {
return( rc );
}
sstr = alloca( MAX_INPUT_LINE );
if( sstr == NULL ) {
return( ERR_NO_STACK );
}
data = SkipLeadingSpaces( data );
data = GetNextWord( data, sstr, SingleSlash );
if( *sstr == '\0' ) {
return( ERR_INVALID_GLOBAL_CMD );
}
if( *data == '/' )
++data; // skip one slash character
data = SkipLeadingSpaces( data );
/*
* verify last line
*/
if( n2 > CurrentFile->fcbs.tail->end_line ) {
rc = CFindLastLine( &ll );
if( rc != ERR_NO_ERR ) {
return( rc );
}
if( n2 > ll ) {
return( ERR_INVALID_LINE_RANGE );
}
}
/*
* set for start of search
*/
if( EditFlags.Verbose && EditFlags.EchoOn ) {
ClearWindow( MessageWindow );
}
rc = CurrentRegComp( sstr );
if( rc != ERR_NO_ERR ) {
return( rc );
}
SaveCurrentFilePos();
StartUndoGroup( UndoStack );
EditFlags.DisplayHold = true;
/*
* pass one - find all matches
*/
for( pos.line = n1; pos.line <= n2; pos.line++ ) {
/*
* go thorugh file, marking global lines
*/
pos.column = 0;
rc = FindRegularExpression( NULL, &pos, &linedata, n2, 0 );
if( rc != ERR_NO_ERR ) {
if( rc == ERR_FIND_PAST_TERM_LINE || rc == ERR_FIND_NOT_FOUND ||
rc == ERR_FIND_END_OF_FILE ) {
break;
}
RestoreCurrentFilePos();
EditFlags.DisplayHold = false;
return( rc );
}
if( pos.line > n2 ) {
break;
}
/*
* go to appropriate spot in file
*/
rc = GoToLineNoRelCurs( pos.line );
if( rc != ERR_NO_ERR ) {
RestoreCurrentFilePos();
EditFlags.DisplayHold = false;
return( rc );
}
/*
* mark fcb and line for a match
*/
CurrentFcb->globalmatch = true;
CurrentLine->u.ld.globmatch = true;
if( EditFlags.Verbose && EditFlags.EchoOn ) {
// WPrintfLine( MessageWindow,1,"Match on line %l",clineno );
Message1( "Match on line %l", pos.line );
}
}
/*
* negate range, if needed
*/
if( dmt ) {
/*
* run through each line, flipping globmatch flag on lines
*/
CGimmeLinePtr( n1, &CurrentFcb, &CurrentLine );
match = false;
for( CurrentPos.line = n1; CurrentPos.line <= n2; CurrentPos.line++ ) {
if( CurrentLine->u.ld.globmatch ) {
CurrentLine->u.ld.globmatch = false;
} else {
match = true;
CurrentLine->u.ld.globmatch = true;
}
CurrentLine = CurrentLine->next;
if( CurrentLine == NULL ) {
CurrentFcb->globalmatch = match;
CurrentFcb = CurrentFcb->next;
FetchFcb( CurrentFcb );
CurrentLine = CurrentFcb->lines.head;
match = false;
}
}
}
/*
* Pass 2: do all changes
*/
rc = ERR_NO_ERR;
EditFlags.GlobalInProgress = true;
memcpy( &crx, CurrentRegularExpression, sizeof( crx ) );
for( CurrentFcb = CurrentFile->fcbs.head; CurrentFcb != NULL; CurrentFcb = CurrentFcb->next ) {
if( !CurrentFcb->globalmatch )
continue;
FetchFcb( CurrentFcb );
CurrentPos.line = CurrentFcb->start_line;
for( CurrentLine = CurrentFcb->lines.head; CurrentLine != NULL; CurrentLine = CurrentLine->next, CurrentPos.line++ ) {
if( !CurrentLine->u.ld.globmatch )
continue;
CurrentLine->u.ld.globmatch = false;
changecnt++;
CurrentPos.column = 1;
ProcessingMessage( CurrentPos.line );
/*
* build command line
*/
rc = RunCommandLine( data );
if( rc > ERR_NO_ERR ) {
break;
}
}
if( rc > ERR_NO_ERR ) {
break;
}
CurrentFcb->globalmatch = false;
}
/*
* we have an error, so fix up fcbs
*/
if( rc > ERR_NO_ERR ) {
for( cfcb = CurrentFile->fcbs.head; cfcb != NULL; cfcb = cfcb->next ) {
if( cfcb->globalmatch ) {
cfcb->globalmatch = false;
cfcb->non_swappable = false;
for( cline = cfcb->lines.head; cline != NULL; cline = cline->next ) {
cline->u.ld.globmatch = false;
}
}
}
}
/*
* display results
*/
EditFlags.GlobalInProgress = false;
EditFlags.DisplayHold = false;
EndUndoGroup( UndoStack );
RestoreCurrentFilePos();
rc1 = SetCurrentLine( CurrentPos.line );
if( rc1 != ERR_NO_ERR ) {
if( rc1 == ERR_NO_SUCH_LINE ) {
SetCurrentLine( 1 );
} else {
return( rc1 );
}
}
Message1( "%l matches found",changecnt );
DCDisplayAllLines();
return( rc );
} /* Global */
int main( int argc, char *argv[] )
{
char *buff = NULL;
char *buff2, *buff3;
char *buffn, *buffs;
char *ptr;
int i, bytes, j, k, sl;
FILE *f;
struct stat fs;
char drive[_MAX_DRIVE], dir[_MAX_DIR];
char fname[_MAX_FNAME], ext[_MAX_EXT];
char path[_MAX_PATH];
char tmppath[_MAX_PATH];
char tmpfname[_MAX_FNAME], tmpext[_MAX_EXT];
unsigned cnt;
unsigned lines;
bind_size *index;
bind_size *entries;
for( j = argc - 1; j > 0; --j ) {
if( argv[j][0] == '/' || argv[j][0] == '-' ) {
sl = strlen( argv[j] );
for( i = 1; i < sl; i++ ) {
switch( argv[j][i] ) {
case 's': sflag = true; break;
case 'q': qflag = true; break;
case 'd':
bindfile = &argv[j][i + 1];
i = sl;
break;
case '?':
Banner();
Usage( NULL );
default:
Banner();
Usage( "Invalid option" );
}
}
for( i = j; i < argc; i++ ) {
argv[i]= argv[i + 1];
}
argc--;
}
}
Banner();
/*
* now, check for null file name
*/
if( argc < 2 ) {
Usage( "No executable to bind" );
}
_splitpath( argv[1], drive, dir, fname, ext );
if( ext[0] == 0 ) {
_makepath( path, drive, dir, fname, ".exe" );
} else {
strcpy( path, argv[1] );
}
if( stat( path, &fs ) == -1 ) {
Abort( "Could not find executable \"%s\"", path );
}
cnt = 0;
if( !sflag ) {
buff = MyAlloc( 65000 );
buff2 = MyAlloc( 32000 );
buff3 = MyAlloc( MAX_LINE_LEN );
/*
* read in all data files
*/
MyPrintf( "Getting data files from" );
f = GetFromEnvAndOpen( bindfile );
MyPrintf( "\n" );
if( f == NULL ) {
Abort( "Could not open %s", bindfile );
}
while( (ptr = fgets( buff3, MAX_LINE_LEN, f )) != NULL ) {
for( i = strlen( ptr ); i && isWSorCtrlZ( ptr[i - 1] ); --i ) {
ptr[i - 1] = '\0';
}
if( ptr[0] == '\0' ) {
continue;
}
ptr = SkipLeadingSpaces( ptr );
if( ptr[0] == '#' ) {
continue;
}
dats[FileCount] = MyAlloc( strlen( ptr ) + 1 );
strcpy( dats[FileCount], ptr );
FileCount++;
if( FileCount >= MAX_DATA_FILES ) {
Abort( "Too many files to bind!" );
}
}
fclose( f );
index = MyAlloc( FileCount * sizeof( bind_size ) );
entries = MyAlloc( FileCount * sizeof( bind_size ) );
buffn = buff;
*(bind_size *)buffn = FileCount;
buffn += sizeof( bind_size );
cnt += sizeof( bind_size );
buffs = buffn;
buffn += sizeof( bind_size );
cnt += sizeof( bind_size );
k = 0;
for( i = 0; i < FileCount; i++ ) {
// j = strlen( dats[i] ) + 1;
// memcpy( buffn, dats[i], j );
_splitpath( dats[i], NULL, NULL, tmpfname, tmpext );
_makepath( tmppath, NULL, NULL, tmpfname, tmpext );
j = strlen( tmppath ) + 1;
memcpy( buffn, tmppath, j );
buffn += j;
cnt += j;
k += j;
}
*(bind_size *)buffs = k + 1; /* size of token list */
*buffn = 0; /* trailing zero */
buffn++;
cnt++;
buffs = buffn;
buffn += FileCount * ( sizeof( bind_size ) + sizeof( bind_size ) );
cnt += FileCount * ( sizeof( bind_size ) + sizeof( bind_size ) );
for( j = 0; j < FileCount; j++ ) {
MyPrintf( "Loading" );
f = GetFromEnvAndOpen( dats[j] );
if( f == NULL ) {
Abort( "\nLoad of %s failed!", dats[j] );
}
setvbuf( f, buff2, _IOFBF, 32000 );
bytes = lines = 0;
index[j] = cnt;
while( (ptr = fgets( buff3, MAX_LINE_LEN, f )) != NULL ) {
unsigned len;
for( len = strlen( ptr ); len && isWSorCtrlZ( ptr[len - 1] ); --len )
ptr[len - 1] = '\0';
if( ptr[0] == '\0' ) {
continue;
}
ptr = SkipLeadingSpaces( ptr );
if( ptr[0] == '#' ) {
continue;
}
len = strlen( ptr );
*buffn = (char)len;
buffn++;
memcpy( buffn, ptr, len );
buffn += len;
cnt += len + 1;
lines++;
bytes += len;
}
fclose( f );
entries[j] = lines;
MyPrintf( "Added %d lines (%d bytes)\n", lines, bytes );
}
memcpy( buffs, index, FileCount * sizeof( bind_size ) );
buffs += FileCount * sizeof( bind_size );
memcpy( buffs, entries, FileCount * sizeof( bind_size ) );
}
AddDataToEXE( path, buff, cnt, fs.st_size );
if( !sflag ) {
MyPrintf( "Added %d bytes to \"%s\"\n", cnt, path );
} else {
MyPrintf( "\"%s\" has been stripped of configuration information\n", path );
}
return( 0 );
} /* main */
/*
* Substitute - perform substitution
*/
vi_rc Substitute( linenum n1, linenum n2, const char *data )
{
char *sstr, *rstr, *newr;
char c;
char *linedata;
bool iflag = false;
bool gflag = false;
bool undoflag = false;
bool restline = false;
bool splitpending = false;
bool undoline = false;
int rlen, slen;
bool splitme;
long changecnt = 0, linecnt = 0;
linenum llineno, ll, lastline = 0, extra;
i_mark pos;
vi_rc rc;
rc = ModificationTest();
if( rc != ERR_NO_ERR ) {
return( rc );
}
LastSubstituteCancelled = 0;
LastChangeCount = 0;
LastLineCount = 0;
sstr = alloca( MAX_INPUT_LINE );
if( sstr == NULL ) {
return( ERR_NO_STACK );
}
rstr = alloca( MAX_INPUT_LINE );
if( rstr == NULL ) {
return( ERR_NO_STACK );
}
data = GetNextWord( data, sstr, SingleSlash );
if( *sstr == '\0' ) {
return( ERR_INVALID_SUBS_CMD );
}
data = GetNextWord( data, rstr, SingleSlash );
if( *rstr == '\0' ) {
return( ERR_INVALID_SUBS_CMD );
}
if( *data == '/' )
++data;
data = SkipLeadingSpaces( data );
while( (c = *data) != '\0' ) {
if( c == 'g' ) {
gflag = true;
} else if( c == 'i' || c == 'c' ) {
iflag = true;
}
++data;
}
rc = CurrentRegComp( sstr );
if( rc != ERR_NO_ERR ) {
return( rc );
}
/*
* verify last line
*/
if( n2 > CurrentFile->fcbs.tail->end_line ) {
rc = CFindLastLine( &ll );
if( rc != ERR_NO_ERR ) {
return( rc );
}
if( n2 > ll ) {
return( ERR_INVALID_LINE_RANGE );
}
}
/*
* set for start of search
*/
if( EditFlags.Verbose && EditFlags.EchoOn ) {
ClearWindow( message_window_id );
}
SaveCurrentFilePos();
llineno = n1 - 1;
EditFlags.AllowRegSubNewline = true;
newr = StaticAlloc();
for( pos.column = 0, pos.line = n1;
pos.line <= n2;
nextSearchStartPos( &pos, gflag, rlen ) ) {
/*
* get regular expression, and build replacement string
*/
rc = FindRegularExpression( NULL, &pos, &linedata, n2, 0 );
if( rc != ERR_NO_ERR || pos.line > n2 ) {
break;
}
slen = GetCurrRegExpLength();
splitme = RegSub( CurrentRegularExpression, rstr, newr, pos.line );
rlen = strlen( newr );
ProcessingMessage( pos.line );
/*
* if in global mode, see if we already have an undo for
* this line
*/
if( gflag ) {
if( lastline != pos.line ) {
undoline = false;
}
}
/*
* interactive mode? yes, then display text and ask to change
*/
if( iflag ) {
change_resp rsp;
if( !restline ) {
ClearWindow( message_window_id );
}
restline = true;
GoToLineNoRelCurs( pos.line );
if( EditFlags.GlobalInProgress ) {
EditFlags.DisplayHold = false;
DCDisplayAllLines();
EditFlags.DisplayHold = true;
}
HilightSearchString( &pos, slen );
rsp = ChangePrompt();
if( rsp == CHANGE_NO ) {
ResetDisplayLine();
rlen = 1;
continue;
} else if( rsp == CHANGE_CANCEL ) {
ResetDisplayLine();
LastSubstituteCancelled = 1;
break;
} else if( rsp == CHANGE_ALL ) {
ResetDisplayLine();
iflag = false;
}
}
/*
* set up for global undo if we haven't already
*/
if( !undoflag ) {
StartUndoGroup( UndoStack );
undoflag = true;
}
/*
* bump change counts
*/
changecnt++;
if( llineno != pos.line ) {
if( splitpending ) {
splitpending = false;
extra = SplitUpLine( llineno );
n2 += extra;
pos.line += extra;
}
linecnt++;
llineno = pos.line;
}
/*
* get copy of line, and verify that new stuff fits
*/
CurrentPos.line = pos.line;
rc = CGimmeLinePtr( pos.line, &CurrentFcb, &CurrentLine );
if( rc != ERR_NO_ERR ) {
break;
}
if( CurrentLine->len + rlen - slen >= EditVars.MaxLine ) {
rc = ERR_LINE_FULL;
break;
}
/*
* now build the individual undo
*/
CurrentFcb->non_swappable = true;
if( !undoline ) {
CurrentLineReplaceUndoStart();
CurrentLineReplaceUndoEnd( true );
if( gflag ) {
undoline = true;
lastline = pos.line;
}
}
/*
* remove the old string
*/
GetCurrentLine();
WorkLine->len = ReplaceSubString( WorkLine->data, WorkLine->len,
pos.column, pos.column + slen - 1, newr, rlen );
if( iflag ) {
DisplayWorkLine( true );
}
ReplaceCurrentLine();
/*
* if not global, only do this change on this line
*/
if( splitme ) {
splitpending = true;
}
CurrentFcb->non_swappable = false;
}
StaticFree( newr );
EditFlags.AllowRegSubNewline = false;
/*
* is there still a split line pending?
*/
if( splitpending ) {
SplitUpLine( llineno );
}
RestoreCurrentFilePos();
if( restline ) {
SetCurrentLine( CurrentPos.line );
GoToColumnOK( CurrentPos.column );
}
if( undoflag ) {
EndUndoGroup( UndoStack );
}
switch( rc ) {
case ERR_NO_ERR:
case ERR_LINE_FULL:
case ERR_FIND_PAST_TERM_LINE:
case ERR_FIND_NOT_FOUND:
case ERR_FIND_END_OF_FILE:
/*
* display results
*/
if( rc == ERR_LINE_FULL ) {
Message1( "Stopped at line %l - line full", pos.line );
} else {
Message1( "%l changes on %l lines", changecnt, linecnt );
LastLineCount = linecnt;
LastChangeCount = changecnt;
}
DCDisplayAllLines();
rc = ERR_NO_ERR;
break;
default:
break;
}
return( rc );
} /* Substitute */