/*
* addChar - add character to working line
*/
static void addChar( char ch )
{
char overChar;
int i;
if( WorkLine->len == 0 ) {
WorkLine->data[0] = ch;
WorkLine->data[1] = 0;
WorkLine->len = 1;
DisplayWorkLine( SSKillsFlags( ch ) );
return;
}
overChar = WorkLine->data[CurrentPos.column - 1];
DisplayWorkLine( SSKillsFlags( ch ) || SSKillsFlags( overChar ) );
if( !overStrike ) {
for( i = WorkLine->len; i >= CurrentPos.column - 1; i-- ) {
WorkLine->data[i + 1] = WorkLine->data[i];
}
WorkLine->data[CurrentPos.column - 1] = ch;
WorkLine->len++;
} else {
WorkLine->data[CurrentPos.column - 1] = ch;
if( CurrentPos.column - 1 == WorkLine->len ) {
WorkLine->len++;
WorkLine->data[WorkLine->len] = 0;
}
}
} /* addChar */
/*
* IMBackSpace - process the backspace key in insert mode
*/
vi_rc IMBackSpace( void )
{
char killedChar, overChar;
bool mv_right;
bool stay_at_end;
int i;
if( CurrentFile == NULL ) {
return( ERR_NO_FILE );
}
startNewLineUndo();
if( abbrevCnt > 0 ) {
abbrevCnt--;
}
if( CurrentPos.column == 1 ) {
if( !EditFlags.WrapBackSpace ) {
return( ERR_NO_ERR );
}
if( CurrentPos.line ==1 ) {
return( ERR_NO_ERR );
}
stay_at_end = FALSE;
if( WorkLine->len == 0 ) {
stay_at_end = TRUE;
}
doneWithCurrentLine();
abbrevCnt = 0;
GoToLineRelCurs( CurrentPos.line - 1 );
GoToColumnOnCurrentLine( CurrentLine->len );
mv_right = TRUE;
if( CurrentLine->len == 0 ) {
mv_right = FALSE;
}
GenericJoinCurrentLineToNext( FALSE );
if( mv_right && !stay_at_end ) {
GoToColumnOnCurrentLine( CurrentPos.column + 1 );
}
if( stay_at_end ) {
GoToColumnOK( CurrentLine->len + 1 );
}
CurrentLineReplaceUndoStart();
currLineRepUndo = TRUE;
GetCurrentLine();
return( ERR_NO_ERR );
}
killedChar = WorkLine->data[CurrentPos.column - 2];
overChar = WorkLine->data[CurrentPos.column - 1];
for( i = CurrentPos.column - 1; i <= WorkLine->len + 1; i++ ) {
WorkLine->data[i - 1] = WorkLine->data[i];
}
WorkLine->len--;
GoToColumn( CurrentPos.column - 1, WorkLine->len + 1 );
DisplayWorkLine( SSKillsFlags( killedChar ) || SSKillsFlags( overChar ) );
return( ERR_NO_ERR );
} /* IMBackSpace */
/*
* 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 */
/*
* ResetDisplayLine - reset display line, if required (after hilight)
*/
void ResetDisplayLine( void )
{
if( EditFlags.ResetDisplayLine ) {
memcpy( WorkLine->data, CurrentLine->data, CurrentLine->len + 1 );
WorkLine->len = CurrentLine->len;
DisplayWorkLine( false );
DCUpdate();
WorkLine->len = -1;
EditFlags.ResetDisplayLine = false;
}
} /* ResetDisplayLine */
/*
* DeleteRangeOnCurrentLine - perform the deletion
*/
vi_rc DeleteRangeOnCurrentLine( int scol, int ecol, int savebuf_flag )
{
int i;
vi_rc rc;
/*
* verify range
*/
if( scol > ecol ) {
i = scol;
scol = ecol;
ecol = i;
}
/*
* go delete block and set up undo
*/
CurrentLineReplaceUndoStart();
rc = DeleteBlockFromCurrentLine( scol, ecol, savebuf_flag );
if( rc != ERR_NO_ERR ) {
CurrentLineReplaceUndoCancel();
return( rc );
}
DisplayWorkLine( TRUE );
ReplaceCurrentLine();
CurrentLineReplaceUndoEnd( TRUE );
EditFlags.Dotable = TRUE;
if( savebuf_flag ) {
#ifdef __WIN__
if( LastSavebuf == 0 ) {
Message1( "%d characters deleted into the clipboard", ecol - scol + 1 );
} else {
#endif
Message1( "%d %s%s%c", ecol - scol + 1, MSG_CHARACTERS,
MSG_DELETEDINTOBUFFER, LastSavebuf );
#ifdef __WIN__
}
#endif
}
return( ERR_NO_ERR );
} /* DeleteRangeOnCurrentLine */
/*
* IMChar - insert a character in insert mode
*/
vi_rc IMChar( void )
{
if( CurrentFile == NULL ) {
return( ERR_NO_ERR );
}
CurrentFile->need_autosave = TRUE;
startNewLineUndo();
if( EditFlags.EscapedInsertChar ) {
DisplayWorkLine( SSKillsFlags( LastEvent ) ||
SSKillsFlags( WorkLine->data[CurrentPos.column - 1] ) );
WorkLine->data[CurrentPos.column - 1] = LastEvent;
GoToColumn( CurrentPos.column + 1, WorkLine->len + 1 );
EditFlags.EscapedInsertChar = FALSE;
return( ERR_NO_ERR );
}
return( insertChar( TRUE, TRUE ) );
} /* IMChar */
/*
* DeleteAndInsertText - delete text range, then insert at beginning
*/
vi_rc DeleteAndInsertText( int scol, int ecol )
{
int startcol;
vi_rc rc;
StartUndoGroup( UndoStack );
CurrentLineReplaceUndoStart();
currLineRepUndo = TRUE;
if( ecol >= 0 ) {
if( CurrentLine->len > 0 ) {
rc = DeleteBlockFromCurrentLine( scol, ecol, FALSE );
if( rc == ERR_NO_ERR ) {
startcol = CurrentPos.column;
if( scol > ecol ) {
startcol = ecol + 1;
}
if( startcol > WorkLine->len ) {
startcol = WorkLine->len + 1;
}
DisplayWorkLine( TRUE );
ReplaceCurrentLine();
rc = GoToColumnOK( startcol );
}
if( rc != ERR_NO_ERR ) {
CurrentLineReplaceUndoCancel();
EndUndoGroup( UndoStack );
return( rc );
}
} else {
ReplaceCurrentLine();
}
}
continueInsertText( CurrentPos.column, FALSE );
return( ERR_NO_ERR );
} /* DeleteAndInsertText */
/*
* IMTabs - handle tabs in insert mode
*/
vi_rc IMTabs( void )
{
char *buff;
bool back;
int cp, vc, tc, add;
int i, j;
int len;
startNewLineUndo();
CheckAbbrev( abbrevBuff, &abbrevCnt );
abbrevCnt = 0;
switch( LastEvent ) {
case VI_KEY( TAB ):
if( EditFlags.RealTabs ) {
if( WorkLine->len + 1 >= EditVars.MaxLine ) {
break;
}
addChar( '\t' );
GoToColumn( CurrentPos.column + 1, WorkLine->len + 1 );
checkWrapMargin();
break;
}
/* fall through if not real tabs */
case VI_KEY( CTRL_T ):
case VI_KEY( SHIFT_TAB ):
case VI_KEY( CTRL_D ):
/*
* get position of cursor on virtual line
*/
vc = VirtualColumnOnCurrentLine( CurrentPos.column );
if( CurrentPos.column - 1 == WorkLine->len && !EditFlags.Modeless ) {
add = 1;
} else {
add = 0;
}
j = 0;
back = FALSE;
switch( LastEvent ) {
case VI_KEY( SHIFT_TAB ):
j = ShiftTab( vc, EditVars.TabAmount );
back = TRUE;
break;
case VI_KEY( CTRL_D ):
j = ShiftTab( vc, EditVars.ShiftWidth );
back = TRUE;
break;
case VI_KEY( TAB ):
j = Tab( vc, EditVars.TabAmount );
break;
case VI_KEY( CTRL_T ):
j = Tab( vc, EditVars.ShiftWidth );
break;
}
if( back && (vc - j < 1) ) {
break;
} else if( VirtualLineLen( WorkLine->data ) + j >= EditVars.MaxLine ) {
break;
}
/*
* create a real version of the line
*/
buff = StaticAlloc();
ExpandTabsInABufferUpToColumn( CurrentPos.column - 1, WorkLine->data, WorkLine->len, buff, EditVars.MaxLine );
len = strlen( buff );
/*
* put in/suck out the tab
*/
tc = vc - 1;
if( back ) {
for( i = tc; i <= len + 1; i++ ) {
buff[i - j] = buff[i];
}
len -= j;
} else {
for( i = len; i >= tc; i-- ) {
buff[i + j] = buff[i];
}
for( i = 0; i < j; i++ ) {
buff[tc + i] = ' ';
}
len += j;
}
/*
* put tabs back in
*/
if( back ) {
cp = vc - j;
} else {
cp = vc + j;
}
if( EditFlags.RealTabs ) {
ConvertSpacesToTabsUpToColumn( cp, buff, len, WorkLine->data, EditVars.MaxLine );
} else {
strcpy( WorkLine->data, buff );
}
WorkLine->len = strlen( WorkLine->data );
StaticFree( buff );
cp = RealColumnOnCurrentLine( cp ) + add;
GoToColumn( cp, WorkLine->len + 1 );
DisplayWorkLine( FALSE );
break;
}
return( ERR_NO_ERR );
} /* IMTabs */
/*
* insertGenericSavebuf - insert contents of a savebuf before/after current pos
*/
static vi_rc insertGenericSavebuf( int buf, bool afterflag )
{
#ifdef __WIN__
savebuf clip;
#endif
savebuf *tmp;
fcb_list fcblist;
fcb *end;
int i, scol, len;
int maxCursor;
vi_rc rc;
rc = ModificationTest();
if( rc != ERR_NO_ERR ) {
return( rc );
}
if( EditFlags.Modeless ) {
DeleteSelectedRegion();
SelRgn.selected = false;
}
#ifdef __WIN__
if( buf == CLIPBOARD_SAVEBUF ) {
rc = GetClipboardSavebuf( &clip );
if( rc != ERR_NO_ERR ) {
return( rc );
}
tmp = &clip;
} else
#endif
if( buf >= MAX_SAVEBUFS ) {
tmp = &SpecialSavebufs[buf - MAX_SAVEBUFS];
} else {
tmp = &Savebufs[buf];
}
switch( tmp->type ) {
case SAVEBUF_NOP:
rc = ERR_EMPTY_SAVEBUF;
break;
case SAVEBUF_LINE:
/*
* get starting data
*/
len = strlen( tmp->u.data );
if( len + CurrentLine->len >= EditVars.MaxLine ) {
rc = ERR_LINE_FULL;
break;
}
if( afterflag ) {
scol = CurrentPos.column;
} else {
scol = CurrentPos.column - 1;
}
CurrentLineReplaceUndoStart();
GetCurrentLine();
/*
* open up line and copy in data
*/
if( WorkLine->len == 0 ) {
scol = 0;
}
for( i = WorkLine->len; i >= scol; i-- ) {
WorkLine->data[i + len] = WorkLine->data[i];
}
for( i = 0; i < len; i++ ) {
WorkLine->data[i + scol] = tmp->u.data[i];
}
WorkLine->len += len;
DisplayWorkLine( true );
ReplaceCurrentLine();
CurrentLineReplaceUndoEnd( true );
scol += len + 1;
maxCursor = CurrentLine->len;
if( EditFlags.Modeless ) {
maxCursor++;
}
if( scol > maxCursor ) {
scol = maxCursor;
}
rc = GoToColumn( scol, maxCursor );
break;
case SAVEBUF_FCBS:
fcblist.head = NULL;
fcblist.tail = NULL;
end = tmp->u.fcbs.tail->next;
tmp->u.fcbs.tail->next = NULL;
CreateDuplicateFcbList( tmp->u.fcbs.head, &fcblist );
tmp->u.fcbs.tail->next = end;
if( !EditFlags.LineBased ) {
rc = InsertLinesAtCursor( &fcblist, UndoStack );
} else {
if( afterflag) {
rc = InsertLines( CurrentPos.line, &fcblist, UndoStack );
} else {
rc = InsertLines( CurrentPos.line - 1, &fcblist, UndoStack );
}
}
break;
}
#ifdef __WIN__
if( tmp == &clip ) {
freeSavebuf( &clip );
}
#endif
EditFlags.Dotable = true;
return( rc );
} /* insertGenericSavebuf */
/*
* Substitute - perform substitution
*/
vi_rc Substitute( linenum n1, linenum n2, char *data )
{
char *sstr, *rstr, *newr;
char flag[20], *linedata;
bool iflag = false;
bool gflag = false;
bool undoflag = false;
bool restline = false;
bool splitpending = false;
bool undoline = false;
int i, rlen, slen;
bool splitme;
long changecnt = 0, linecnt = 0;
linenum llineno, ll, lastline = 0, extra;
i_mark pos;
vi_rc rc;
LastSubstituteCancelled = 0;
LastChangeCount = 0;
LastLineCount = 0;
sstr = alloca( MAX_INPUT_LINE );
if( sstr == NULL ) {
return( ERR_NO_STACK );
}
strcpy( sstr, data );
rc = ModificationTest();
if( rc != ERR_NO_ERR ) {
return( rc );
}
strcpy( data, sstr );
rstr = alloca( MAX_INPUT_LINE );
if( rstr == NULL ) {
return( ERR_NO_STACK );
}
if( NextWordSlash( data, sstr ) < 0 ) {
return( ERR_INVALID_SUBS_CMD );
}
if( NextWordSlash( data, rstr ) < 0 ) {
return( ERR_INVALID_SUBS_CMD );
}
slen = NextWord1( data, flag );
for( i = 0; i < slen; i++ ) {
switch( flag[i] ) {
case 'g':
gflag = true;
break;
case 'i':
case 'c':
iflag = true;
break;
}
}
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( MessageWindow );
}
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( MessageWindow );
}
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 */
vi_rc Change( range *r )
{
int scol, ecol;
int tmp;
vi_rc rc;
vi_key key;
#ifndef __WIN__
int vecol;
#endif
/*
* change line ranges
*/
if( r->start.line != r->end.line ) {
StartUndoGroup( UndoStack );
if( !r->line_based ) {
rc = Cut( r->start.line, r->start.column, r->end.line, r->end.column, true );
r->end.column = -1;
scol = -1;
ecol = -1;
} else {
if( r->start.line == CurrentPos.line ) {
r->start.line++;
} else {
r->end.line--;
}
if( r->start.line <= r->end.line ) {
rc = DeleteLineRange( r->start.line, r->end.line, 0 );
if( rc != ERR_NO_ERR ) {
EndUndoGroup( UndoStack );
return( rc );
}
}
scol = FindStartOfCurrentLine() - 1;
ecol = CurrentLine->len - 1;
}
DCDisplayAllLines();
rc = DeleteAndInsertText( scol, ecol );
EndUndoGroup( UndoStack );
return( rc );
}
/*
* change text on current line
*/
rc = ERR_NO_ERR;
GoToLineNoRelCurs( r->start.line );
ecol = r->end.column;
scol = r->start.column;
#ifdef __WIN__
// GetCurrentLine();
strcpy( WorkLine->data, CurrentLine->data );
tmp = WorkLine->data[ecol];
WorkLine->data[ecol] = '$';
#else
vecol = VirtualColumnOnCurrentLine( ecol + 1 );
vecol--;
ExpandTabsInABuffer( CurrentLine->data, CurrentLine->len, WorkLine->data, EditVars.MaxLine + 1 );
WorkLine->len = strlen( WorkLine->data );
tmp = WorkLine->data[vecol];
WorkLine->data[vecol] = '$';
#endif
if( WorkLine->len == 0 ) {
WorkLine->data[1] = '\0';
}
EditFlags.InsertModeActive = true;
GoToColumn( scol + 1, CurrentLine->len );
EditFlags.InsertModeActive = false;
DisplayWorkLine( true );
UnselectRegion();
DCUpdate();
#ifndef __WIN__
HiliteAColumnRange( CurrentPos.line, scol, ecol );
#endif
/*
* now, get ready to do change
*/
key = GetNextEvent( false );
#ifdef __WIN__
WorkLine->data[ecol] = tmp;
#else
WorkLine->data[vecol] = tmp;
#endif
DisplayWorkLine( true );
if( key == VI_KEY( ESC ) && !EditFlags.ChangeLikeVI ) {
WorkLine->len = -1;
GoToColumn( scol + 1, CurrentLine->len );
} else {
KeyAdd( key );
rc = DeleteAndInsertText( scol, ecol );
}
return( rc );
} /* Change */
