/*
* windowSwap - swap a windows data
*/
void static windowSwap( wind *w )
{
int i, size;
long pos;
pos = (long)w->id * buffSize();
FileSeek( swapHandle, pos );
size = w->width * w->height;
i = write( swapHandle, w->overlap, size * sizeof( window_id ) );
if( i != size * sizeof( window_id ) ) {
return;
}
i = write( swapHandle, w->whooverlapping, size * sizeof( window_id ) );
if( i != size * sizeof( window_id ) ) {
return;
}
i = write( swapHandle, w->text, size * sizeof( char_info ) );
if( i != size * sizeof( char_info ) ) {
return;
}
MemFreePtr( (void **)&w->text );
MemFreePtr( (void **)&w->whooverlapping );
MemFreePtr( (void **)&w->overlap );
w->isswapped = true;
} /* windowSwap */
/*
* FreeUndoStacks - do just that
*/
void FreeUndoStacks( void )
{
FreeAllUndos();
MemFree( UndoStack->stack );
MemFreePtr( (void **)&UndoStack );
MemFree( UndoUndoStack->stack );
MemFreePtr( (void **)&UndoUndoStack );
} /* FreeUndoStacks */
/*
* UpdateCurrentDirectory - update the current directory variable
*/
void UpdateCurrentDirectory( void )
{
MemFreePtr( (void **)&CurrentDirectory );
GetCWD1( &CurrentDirectory );
} /* UpdateCurrentDirectory */
PUBLIC
void
ListGlobalFree( void )
{
ALLOC_UNIT * table, *tblptr;
WAIT_FOR_LOCK( LIST_MUTEX );
if( !GLOBAL_ALLOC_TABLE )
return;
table = GLOBAL_ALLOC_TABLE;
while( table -> prev )
table = table -> prev;
for( ; table ; )
{
tblptr = table -> next;
#ifdef USE_SH_POOLS
MemFreePtr( table );
#else
MemFree( table );
#endif
table = tblptr;
}
GLOBAL_ALLOC_TABLE = NULL;
RELEASE_LOCK( LIST_MUTEX );
}
void O_Output::SetTextWidth(long w)
{
_SetOType_(_OUT_TEXT_);
if(Label_)
{
if(flags_ & C_BIT_FIXEDSIZE)
{
if(w == LabelLen_)
return;
#ifdef USE_SH_POOLS
MemFreePtr(Label_);
#else
delete Label_;
#endif
}
else
{
MonoPrint("ERROR:Calling SetFixedWidth() when a string has already been assigned\n");
}
}
LabelLen_= static_cast<short>(w);
#ifdef USE_SH_POOLS
Label_=(_TCHAR*)MemAllocPtr(UI_Pools[UI_GENERAL_POOL],sizeof(_TCHAR)*(LabelLen_+1),FALSE);
#else
Label_=new _TCHAR[LabelLen_+1];
#endif
memset(Label_,0,sizeof(_TCHAR)*(LabelLen_));
SetFlags(flags_ | C_BIT_FIXEDSIZE);
SetInfo();
}
void ObjectParent::CleanupTable( void ){
// Make sure all the parent objects are freed
FlushReferences();
// Free the LOD table
ObjectLOD::CleanupTable();
// Free the texture, palette, and color banks
TheTextureBank.Cleanup();
ThePaletteBank.Cleanup();
TheColorBank.Cleanup();
// Free our array of parent objects
#ifdef USE_SH_POOLS
MemFreePtr( TheObjectList );
#else
delete[] TheObjectList;
#endif
TheObjectList = NULL;
TheObjectListLength = 0;
#ifdef USE_SH_POOLS
if ( gBSPLibMemPool != NULL )
{
MemPoolFree(gBSPLibMemPool);
gBSPLibMemPool = NULL;
}
#endif
}
/*
* tossBoundData - get rid of bound data
*/
static void tossBoundData( void )
{
if( BoundData ) {
if( !EditFlags.BndMemoryLocked ) {
MemFreePtr( (void **)&BndMemory );
}
}
} /* tossBoundData */
ObjectParent::~ObjectParent(){
ShiAssert( refCount == 0 );
#ifdef USE_SH_POOLS
MemFreePtr( pSlotAndDynamicPositions );
#else
delete[] pSlotAndDynamicPositions;
#endif
pSlotAndDynamicPositions = NULL;
#ifdef USE_SH_POOLS
MemFreePtr( pLODs );
#else
delete[] pLODs;
#endif
pLODs = NULL;
Locked = false;
}
/*
* shrinkUndoStack - reduce size of undo stack by one
*/
static void shrinkUndoStack( undo_stack *stack )
{
stack->current--;
if( stack->current < 0 ) {
MemFreePtr( (void **)&stack->stack );
} else {
stack->stack = MemReAlloc( stack->stack, (stack->current + 1) * sizeof( undo * ) );
}
} /* shrinkUndoStack */
ObjectInstance::~ObjectInstance()
{
ParentObject->Release();
ParentObject = NULL;
#ifdef USE_SH_POOLS
if( SwitchValues )
MemFreePtr( SwitchValues );
if( DOFValues )
MemFreePtr( DOFValues );
if( SlotChildren )
MemFreePtr( SlotChildren );
if( DynamicCoords )
MemFreePtr( DynamicCoords );
#else
delete[] SwitchValues;
delete[] DOFValues;
delete[] SlotChildren;
delete[] DynamicCoords;
#endif
}
void O_Output::Cleanup()
{
if(Label_)
{
if(flags_ & C_BIT_FIXEDSIZE)
#ifdef USE_SH_POOLS
MemFreePtr(Label_);
#else
delete Label_;
#endif
Label_=NULL;
SetReady(0);
}
if(Image_)
Image_=NULL;
if(Rows_)
{
#ifdef USE_SH_POOLS
MemFreePtr(Rows_);
#else
delete Rows_;
#endif
Rows_=NULL;
}
if(Cols_)
{
#ifdef USE_SH_POOLS
MemFreePtr(Cols_);
#else
delete Cols_;
#endif
Cols_=NULL;
}
WWCount_=0;
if(Wrap_)
{
delete Wrap_;
Wrap_=NULL;
}
}
void C_Fill::Cleanup(void)
{
if(DitherPattern_ && DitherSize_)
{
#ifdef USE_SH_POOLS
MemFreePtr(DitherPattern_);
#else
delete DitherPattern_;
#endif
DitherPattern_=NULL;
}
}
void ColorBankClass::Cleanup( void )
{
nColors = 0;
nDarkendColors = 0;
#ifdef USE_SH_POOLS
MemFreePtr( ColorBuffer );
#else
delete[] ColorBuffer;
#endif
ColorBuffer = NULL;
DarkenedBuffer = NULL;
GreenIRBuffer = NULL;
GreenTVBuffer = NULL;
}
/*
* PurgeUndoStack - do just that
*/
void PurgeUndoStack( undo_stack *stack )
{
int i;
if( stack == NULL ) {
return;
}
for( i = stack->current; i >= 0; i-- ) {
UndoFree( stack->stack[i], true );
}
MemFreePtr( (void **)&(stack->stack) );
stack->current = -1;
} /* PurgeUndoStack */
void PaletteBankClass::Cleanup( void )
{
// Clear our extra reference which was holding the data in memory
for (int i=0; i<nPalettes; i++) {
PalettePool[i].Release();
}
// Clean up our array of palettes
#ifdef USE_SH_POOLS
MemFreePtr( PalettePool );
#else
delete[] PalettePool;
#endif
PalettePool = NULL;
nPalettes = 0;
}
void C_Custom::Cleanup(void)
{
short i;
if(!Count_)
return;
for(i=0;i<Count_;i++)
Items_[i].Cleanup();
delete Items_;
#ifdef USE_SH_POOLS
MemFreePtr(ItemValues_);
#else
delete ItemValues_;
#endif
Items_=NULL;
ItemValues_=NULL;
Count_=0;
Section_=0;
}
void C_Fill::SetDither(short size,short range)
{
short i,j;
if((size < 3) || !(range))
size=0;
if(size != DitherSize_)
{
if(DitherPattern_)
{
#ifdef USE_SH_POOLS
MemFreePtr(DitherPattern_);
#else
delete DitherPattern_;
#endif
DitherPattern_=NULL;
}
}
DitherSize_=size;
if(DitherSize_)
{
#ifdef USE_SH_POOLS
DitherPattern_=(char*)MemAllocPtr(UI_Pools[UI_ART_POOL],sizeof(char)*(DitherSize_ * DitherSize_),FALSE);
#else
DitherPattern_=new char[DitherSize_ * DitherSize_];
#endif
if(DitherPattern_)
{
for(i=0;i<size;i++)
for(j=0;j<size;j++)
DitherPattern_[i*size +j]=(char)((rand() % range)-range/2);
}
else
DitherSize_=0;
}
}
PRIVATE
void
ListGlobalPack( void )
{
int done = FALSE;
int total = 0;
ALLOC_UNIT * t,
* tbl = NULL;
WAIT_FOR_LOCK( LIST_MUTEX );
for( t = GLOBAL_ALLOC_TABLE; t; t = (ALLOC_UNIT *)t -> prev )
tbl = t;
if (!tbl)
{
ERROR( "List allocation table empty -- cannot pack." );
GLOBAL_ALLOC_TABLE -> index = 0;
RELEASE_LOCK( LIST_MUTEX );
return;
}
do
{
if( (tbl -> avail == ALLOC_UNITS) &&
(tbl -> sleeping) )
{
if( tbl -> prev )
tbl -> prev -> next = tbl -> next;
if( tbl -> next )
tbl -> next -> prev = tbl -> prev;
total += (ALLOC_UNITS - tbl -> avail);
if( tbl -> prev )
t = tbl -> prev;
else
t = tbl -> next;
if( GLOBAL_ALLOC_TABLE == tbl )
GLOBAL_ALLOC_TABLE = t;
#ifdef USE_SH_POOLS
MemFreePtr( tbl );
#else
MemFree( tbl );
#endif
tbl = t;
}
else
{
if( tbl -> avail > (GLOBAL_ALLOC_TABLE -> avail + ALLOC_SWAP_SIZE) ) {
GLOBAL_ALLOC_TABLE = tbl;
}
total += (ALLOC_UNITS - tbl -> avail);
tbl = tbl -> next;
}
} while( tbl );
if( !GLOBAL_ALLOC_TABLE || (GLOBAL_ALLOC_TABLE -> avail < ALLOC_SWAP_SIZE) )
ListGlobalAlloc();
GLOBAL_ALLOC_TABLE -> index = 0;
RELEASE_LOCK( LIST_MUTEX );
}
/*
* processSetToken - set value for set token
*/
static vi_rc processSetToken( int j, char *value, int *winflag, bool isnonbool )
{
char fn[MAX_STR], str[MAX_STR];
#ifndef VICOMP
char tmp[3];
char settokstr[TOK_MAX_LEN + 1];
char save[MAX_STR];
vi_rc rc = ERR_NO_ERR;
int i, clr, k;
bool newset;
bool set1, toggle, *ptr;
jmp_buf jmpaddr;
cursor_type ct;
char *name;
command_rtn fptr;
event_bits eb;
bool redisplay = FALSE;
#endif
bool bvalue;
#ifdef VICOMP
winflag = winflag;
isnonbool = isnonbool;
#endif
/*
* set up value for boolean set commands
*/
if( j < 0 ) {
j *= -1;
bvalue = FALSE;
} else {
bvalue = TRUE;
}
#ifndef VICOMP
if( !(*winflag) ) {
toggle = TRUE;
set1 = isnonbool;
} else {
toggle = FALSE;
#endif
if( j >= SET1_T_ ) {
#ifndef VICOMP
if( EditFlags.CompileScript ) {
#endif
if( !bvalue ) {
j *= -1;
}
itoa( j, str, 10 );
StrMerge( 2, WorkLine->data, str, SingleBlank );
return( ERR_NO_ERR );
#ifndef VICOMP
}
set1 = FALSE;
j -= SET1_T_;
} else {
set1 = TRUE;
#endif
}
#ifndef VICOMP
}
*winflag = FALSE;
/*
* process boolean settings
*/
if( !set1 ) {
if( j >= SET2_T_ ) {
return( ERR_INVALID_SET_COMMAND );
}
ptr = &(((bool *)&EditFlags)[j]);
newset = bvalue;
if( toggle ) {
newset = !(*ptr);
}
switch( j ) {
case SET2_T_MODELESS:
if( (newset && !EditFlags.Modeless) ||
(!newset && EditFlags.Modeless) ) {
for( k = 0; k < MAX_EVENTS; k++ ) {
fptr = EventList[k].rtn;
eb = EventList[k].b;
EventList[k].rtn = EventList[k].alt_rtn;
EventList[k].alt_rtn = fptr;
EventList[k].b = EventList[k].alt_b;
EventList[k].alt_b = eb;
}
if( !EditFlags.Modeless ) {
if( MenuWindow != NO_WINDOW ) {
UpdateCurrentStatus( CSTATUS_INSERT );
}
EditFlags.WasOverstrike = FALSE;
NewCursor( CurrentWindow, EditVars.InsertCursorType );
} else {
if( MenuWindow != NO_WINDOW ) {
UpdateCurrentStatus( CSTATUS_COMMAND );
}
NewCursor( CurrentWindow, EditVars.NormalCursorType );
// nomodeless must be line based or it dies!
EditFlags.LineBased = TRUE;
}
/* re-position cursor in window
*/
SetWindowCursor();
}
EditFlags.Modeless = newset;
break;
case SET2_T_UNDO:
if( EditFlags.Undo && !newset ) {
FreeAllUndos();
}
EditFlags.Undo = newset;
break;
case SET2_T_STATUSINFO:
EditFlags.StatusInfo = newset;
#ifdef __WIN__
ResizeRoot();
#endif
rc = NewStatusWindow();
break;
case SET2_T_WINDOWGADGETS:
EditFlags.WindowGadgets = newset;
ResetAllWindows();
*winflag = TRUE;
redisplay = TRUE;
break;
case SET2_T_REALTABS:
EditFlags.RealTabs = newset;
redisplay = TRUE;
break;
case SET2_T_CLOCK:
EditFlags.Clock = newset;
redisplay = TRUE;
break;
case SET2_T_TOOLBAR:
EditFlags.Toolbar = newset;
#ifdef __WIN__
ResizeRoot();
#endif
break;
case SET2_T_COLORBAR:
EditFlags.Colorbar = newset;
#ifdef __WIN__
if( Root == NULL ) {
EditFlags.Colorbar = FALSE;
} else {
RefreshColorbar();
}
#endif
break;
case SET2_T_SSBAR:
EditFlags.SSbar = newset;
#ifdef __WIN__
if( Root == NULL ) {
EditFlags.SSbar = FALSE;
} else {
RefreshSSbar();
}
#endif
break;
case SET2_T_FONTBAR:
EditFlags.Fontbar = newset;
#ifdef __WIN__
if( Root == NULL ) {
EditFlags.Fontbar = FALSE;
} else {
RefreshFontbar();
}
#endif
break;
case SET2_T_MARKLONGLINES:
EditFlags.MarkLongLines = newset;
break;
case SET2_T_MENUS:
EditFlags.Menus = newset;
InitMenu();
break;
case SET2_T_LINENUMBERS:
if( toggle ) {
newset = !EditFlags.LineNumbers;
}
if( newset != EditFlags.LineNumbers ) {
EditFlags.LineNumbers = newset;
rc = LineNumbersSetup();
*winflag = TRUE;
}
break;
case SET2_T_CURRENTSTATUS:
EditFlags.CurrentStatus = newset;
InitMenu();
break;
case SET2_T_DISPLAYSECONDS:
EditFlags.DisplaySeconds = newset;
redisplay = TRUE;
break;
case SET2_T_PPKEYWORDONLY:
EditFlags.PPKeywordOnly = newset;
redisplay = TRUE;
break;
case SET2_T_LASTEOL:
#ifndef __WIN__
*ptr = TRUE;
toggle = FALSE;
break;
#endif
default:
*ptr = newset;
break;
}
if( msgFlag ) {
if( !newset ) {
tmp[0] = 'n';
tmp[1] = 'o';
tmp[2] = 0;
} else {
tmp[0] = 0;
}
MySprintf( fn, "%s%s set", tmp, GetTokenStringCVT( SetTokens2, j, settokstr, TRUE ) );
}
if( toggle ) {
strcpy( save, BoolStr[(int) newset] );
(*winflag) += 1;
}
/*
* process value settings
*/
} else {
if( toggle ) {
rc = GetNewValueDialog( value );
if( rc != ERR_NO_ERR ) {
return( rc );
}
strcpy( save, value );
}
#endif /* VICOMP */
RemoveLeadingSpaces( value );
if( value[0] == '"' ) {
NextWord( value, fn, "\"" );
EliminateFirstN( value, 1 );
} else {
NextWord1( value, fn );
}
#ifndef VICOMP
if( EditFlags.CompileScript ) {
#endif
itoa( j, str, 10 );
strcat( WorkLine->data, str );
if( fn[0] == '\0' )
return( ERR_NO_ERR );
switch( j ) {
case SET1_T_STATUSSTRING:
case SET1_T_FILEENDSTRING:
case SET1_T_HISTORYFILE:
case SET1_T_TMPDIR:
case SET1_T_TAGFILENAME:
StrMerge( 4, WorkLine->data, SingleBlank, SingleQuote, fn, SingleQuote );
break;
case SET1_T_COMMANDCURSORTYPE:
case SET1_T_OVERSTRIKECURSORTYPE:
case SET1_T_INSERTCURSORTYPE:
StrMerge( 2, WorkLine->data, SingleBlank, fn );
if( NextWord1( value, fn ) <= 0 ) {
break;
}
StrMerge( 2, WorkLine->data, SingleBlank, fn );
break;
case SET1_T_TILECOLOR:
StrMerge( 2, WorkLine->data, SingleBlank, fn );
if( NextWord1( value, fn ) <= 0 ) {
return( ERR_INVALID_SET_COMMAND );
}
if( NextWord1( value, str ) <= 0 ) {
return( ERR_INVALID_SET_COMMAND );
}
StrMerge( 4, WorkLine->data, fn, SingleBlank, str, SingleBlank );
break;
case SET1_T_STATUSSECTIONS:
StrMerge( 2, WorkLine->data, SingleBlank, fn );
while( NextWord1( value, fn ) > 0 ) {
#ifdef VICOMP
int k;
#endif
k = atoi( fn );
if( k <= 0 ) {
break;
}
StrMerge( 2, WorkLine->data, SingleBlank, fn );
}
break;
default:
StrMerge( 2, WorkLine->data, SingleBlank, fn );
break;
}
return( ERR_NO_ERR );
#ifndef VICOMP
}
switch( j ) {
case SET1_T_STATUSSECTIONS:
if( EditVars.StatusSections != NULL ) {
MemFree( EditVars.StatusSections );
EditVars.StatusSections = NULL;
EditVars.NumStatusSections = 0;
}
for( ;; ) {
k = atoi( fn );
if( k <= 0 ) {
break;
}
EditVars.StatusSections = MemReAlloc( EditVars.StatusSections,
sizeof( short ) * (EditVars.NumStatusSections + 1) );
EditVars.StatusSections[EditVars.NumStatusSections] = k;
EditVars.NumStatusSections++;
if( NextWord1( value, fn ) <= 0 ) {
break;
}
}
if( EditVars.StatusSections == NULL ) {
MySprintf( fn, "statussections turned off" );
} else {
MySprintf( fn, "statussections set" );
}
break;
case SET1_T_FILEENDSTRING:
AddString2( &EditVars.FileEndString, fn );
ResetAllWindows();
redisplay = TRUE;
break;
case SET1_T_STATUSSTRING:
AddString2( &EditVars.StatusString, fn );
if( StatusWindow != NO_WINDOW ) {
ClearWindow( StatusWindow );
UpdateStatusWindow();
}
if( msgFlag ) {
MySprintf( fn, "statusstring set to %s", EditVars.StatusString );
}
break;
case SET1_T_GREPDEFAULT:
AddString2( &EditVars.GrepDefault, fn );
break;
case SET1_T_TILECOLOR:
if( EditVars.TileColors == NULL ) {
EditVars.TileColors = (type_style *) MemAlloc( sizeof( type_style ) * ( EditVars.MaxTileColors + 1 ) );
for( i = 0; i <= EditVars.MaxTileColors; ++i ) {
EditVars.TileColors[i].foreground = -1;
EditVars.TileColors[i].background = -1;
EditVars.TileColors[i].font = -1;
}
}
clr = atoi( fn );
if( clr > EditVars.MaxTileColors ) {
return( ERR_INVALID_SET_COMMAND );
}
if( NextWord1( value, fn ) <= 0 ) {
return( ERR_INVALID_SET_COMMAND );
}
EditVars.TileColors[clr].foreground = atoi( fn );
if( NextWord1( value, fn ) <= 0 ) {
return( ERR_INVALID_SET_COMMAND );
}
EditVars.TileColors[clr].background = atoi( fn );
EditVars.TileColors[clr].font = FONT_DEFAULT;
if( msgFlag ) {
MySprintf( fn, "tilecolor %d set", clr );
}
break;
case SET1_T_GADGETSTRING:
SetGadgetString( fn );
if( msgFlag ) {
MySprintf( fn, "gadget string set to %s", EditVars.GadgetString );
}
ResetAllWindows();
break;
case SET1_T_SHELLPROMPT:
AddString2( &EditVars.SpawnPrompt, fn );
if( msgFlag ) {
MySprintf( fn, "prompt string set to %s", EditVars.SpawnPrompt );
}
break;
case SET1_T_FIGNORE:
if( fn[0] == 0 ) {
MemFreePtr( (void **)&EditVars.FIgnore );
EditVars.CurrFIgnore = 0;
if( msgFlag ) {
MySprintf( fn, "fignore reset" );
}
} else {
EditVars.FIgnore = MemReAlloc( EditVars.FIgnore, EXTENSION_LENGTH * (EditVars.CurrFIgnore + 1) );
str[0] = '.';
str[1] = 0;
strcat( str, fn );
str[EXTENSION_LENGTH - 1] = 0;
strcpy( &EditVars.FIgnore[EXTENSION_LENGTH * EditVars.CurrFIgnore], str );
EditVars.CurrFIgnore++;
if( msgFlag ) {
MySprintf( fn, "%s added to fignore", str );
}
}
break;
case SET1_T_HISTORYFILE:
AddString2( &EditVars.HistoryFile, fn );
if( msgFlag ) {
MySprintf( fn, "history file set to %s", EditVars.HistoryFile );
}
break;
case SET1_T_TAGFILENAME:
AddString2( &EditVars.TagFileName, fn );
if( msgFlag ) {
MySprintf( fn, "tag file name set to %s", EditVars.TagFileName );
}
break;
case SET1_T_FILENAME:
if( CurrentFile != NULL ) {
AddString2( &(CurrentFile->name), fn );
SetFileWindowTitle( CurrentWindow, CurrentInfo, TRUE );
if( msgFlag ) {
MySprintf( fn, "filename set to %s", CurrentFile->name );
}
FileSPVAR();
}
break;
case SET1_T_TMPDIR:
AddString2( &EditVars.TmpDir, fn );
VerifyTmpDir();
if( msgFlag ) {
MySprintf( fn, "tmpdir set to %s", EditVars.TmpDir );
}
break;
case SET1_T_WORD:
AddString2( &EditVars.WordDefn, fn );
InitWordSearch( EditVars.WordDefn );
if( msgFlag ) {
MySprintf( fn, "word set to %s", EditVars.WordDefn );
}
break;
case SET1_T_WORDALT:
AddString2( &EditVars.WordAltDefn, fn );
if( msgFlag ) {
MySprintf( fn, "wordalt set to %s", EditVars.WordAltDefn );
}
break;
case SET1_T_MAGICSTRING:
AddString2( &EditVars.Majick, fn );
if( msgFlag ) {
MySprintf( fn, "magicstring set to %s", EditVars.Majick );
}
break;
case SET1_T_COMMANDCURSORTYPE:
case SET1_T_OVERSTRIKECURSORTYPE:
case SET1_T_INSERTCURSORTYPE:
i = setjmp( jmpaddr );
if( i != 0 ) {
return( ERR_INVALID_SET_COMMAND );
}
StartExprParse( fn, jmpaddr );
ct.height = GetConstExpr();
if( NextWord1( value, fn ) <= 0 ) {
ct.width = 100;
} else {
i = setjmp( jmpaddr );
if( i != 0 ) {
return( ERR_INVALID_SET_COMMAND );
}
StartExprParse( fn, jmpaddr );
ct.width = GetConstExpr();
}
if( j == SET1_T_COMMANDCURSORTYPE ) {
EditVars.NormalCursorType = ct;
name = "command";
} else if( j == SET1_T_OVERSTRIKECURSORTYPE ) {
EditVars.OverstrikeCursorType = ct;
name = "overstrike";
} else {
EditVars.InsertCursorType = ct;
name = "insert";
}
if( msgFlag ) {
MySprintf( fn, "%s cursor type set to %d,%d", name,
ct.height, ct.width );
}
break;
default:
i = setjmp( jmpaddr );
if( i != 0 ) {
return( ERR_INVALID_SET_COMMAND );
}
StartExprParse( fn, jmpaddr );
i = GetConstExpr();
if( i < 0 ) {
i = 0;
}
switch( j ) {
case SET1_T_WRAPMARGIN:
EditVars.WrapMargin = i;
break;
case SET1_T_CURSORBLINKRATE:
SetCursorBlinkRate( i );
break;
case SET1_T_MAXPUSH:
EditVars.MaxPush = i;
if( EditVars.MaxPush < 1 ) {
EditVars.MaxPush = 1;
}
InitFileStack();
break;
case SET1_T_RADIX:
EditVars.Radix = i;
break;
case SET1_T_AUTOSAVEINTERVAL:
EditVars.AutoSaveInterval = i;
SetNextAutoSaveTime();
break;
case SET1_T_LANGUAGE:
if( i < LANG_NONE || i >= LANG_MAX ) {
return( ERR_INVALID_SET_COMMAND );
}
if( CurrentInfo != NULL ) {
LangFini( CurrentInfo->fsi.Language );
LangInit( i );
redisplay = TRUE;
}
break;
case SET1_T_MOVECOLOR:
EditVars.MoveColor = i;
break;
case SET1_T_RESIZECOLOR:
EditVars.ResizeColor = i;
break;
case SET1_T_MOUSEDCLICKSPEED:
EditVars.MouseDoubleClickSpeed = i;
break;
case SET1_T_MOUSESPEED:
SetMouseSpeed( i );
break;
case SET1_T_MOUSEREPEATDELAY:
EditVars.MouseRepeatDelay = i;
break;
case SET1_T_CURRENTSTATUSCOLUMN:
EditVars.CurrentStatusColumn = i;
InitMenu();
break;
case SET1_T_ENDOFLINECHAR:
EditVars.EndOfLineChar = i;
break;
case SET1_T_EXITATTR:
EditVars.ExitAttr = (char) i;
break;
case SET1_T_INACTIVEWINDOWCOLOR:
EditVars.InactiveWindowColor = i;
break;
case SET1_T_TABAMOUNT:
EditVars.TabAmount = i;
break;
case SET1_T_SHIFTWIDTH:
EditVars.ShiftWidth = i;
break;
case SET1_T_PAGELINESEXPOSED:
EditVars.PageLinesExposed = i;
break;
case SET1_T_HARDTAB:
EditVars.HardTab = i;
redisplay = TRUE;
break;
case SET1_T_STACKK:
if( EditFlags.Starting ) {
EditVars.StackK = i;
}
break;
case SET1_T_LINENUMWINWIDTH:
EditVars.LineNumWinWidth = i;
break;
case SET1_T_MAXWINDOWTILEX:
EditVars.MaxWindowTileX = i;
break;
case SET1_T_MAXWINDOWTILEY:
EditVars.MaxWindowTileY = i;
break;
case SET1_T_MAXSWAPK:
SwapBlockInit( i );
break;
case SET1_T_MAXEMSK:
#ifndef NOEMS
EMSBlockInit( i );
#endif
break;
case SET1_T_MAXXMSK:
#ifndef NOXMS
XMSBlockInit( i );
#endif
break;
case SET1_T_MAXFILTERHISTORY:
FilterHistInit( i );
break;
case SET1_T_MAXCLHISTORY:
CLHistInit( i );
break;
case SET1_T_MAXFINDHISTORY:
FindHistInit( i );
break;
case SET1_T_MAXLASTFILESHISTORY:
LastFilesHistInit( i );
break;
case SET1_T_MAXTILECOLORS:
k = (EditVars.TileColors == NULL) ? 0 : EditVars.MaxTileColors + 1;
EditVars.MaxTileColors = i;
EditVars.TileColors = MemReAlloc( EditVars.TileColors, sizeof( type_style ) * ( EditVars.MaxTileColors + 1 ) );
for( ; k <= EditVars.MaxTileColors; ++k ) {
EditVars.TileColors[k].foreground = -1;
EditVars.TileColors[k].background = -1;
EditVars.TileColors[k].font = -1;
}
break;
case SET1_T_CLOCKX:
EditVars.ClockX = i;
GetClockStart();
break;
case SET1_T_CLOCKY:
EditVars.ClockY = i;
GetClockStart();
break;
case SET1_T_SPINX:
EditVars.SpinX = i;
GetSpinStart();
break;
case SET1_T_SPINY:
EditVars.SpinY = i;
GetSpinStart();
break;
case SET1_T_MAXLINELEN:
/* file save fails if 1 line is > MAX_IO_BUFFER */
i = __min( i, MAX_IO_BUFFER );
EditVars.MaxLine = i;
StaticStart();
WorkLine = MemReAlloc( WorkLine, sizeof( line ) + EditVars.MaxLine + 2 );
break;
case SET1_T_TOOLBARBUTTONHEIGHT:
EditVars.ToolBarButtonHeight = i;
#ifdef __WIN__
ResizeRoot();
#endif
break;
case SET1_T_TOOLBARBUTTONWIDTH:
EditVars.ToolBarButtonWidth = i;
#ifdef __WIN__
ResizeRoot();
#endif
break;
case SET1_T_TOOLBARCOLOR:
EditVars.ToolBarColor = i;
#ifdef __WIN__
if( GetToolbarWindow() != NULL ) {
InvalidateRect( GetToolbarWindow(), NULL, TRUE );
UpdateWindow( GetToolbarWindow() );
}
#endif
break;
default:
return( ERR_INVALID_SET_COMMAND );
}
if( msgFlag ) {
MySprintf( fn, "%s set to %d", GetTokenStringCVT( SetTokens1, j, settokstr, TRUE ), i );
}
break;
}
}
if( msgFlag && rc == ERR_NO_ERR && !EditFlags.Quiet ) {
setMessage( fn, redisplay );
rc = DO_NOT_CLEAR_MESSAGE_WINDOW;
}
if( rc == ERR_NO_ERR && toggle ) {
strcpy( value, save );
}
return( rc );
#endif /* VICOMP */
} /* processSetToken */
/*
* ReadFcbData - read fcb data
*/
vi_rc ReadFcbData( file *f, bool *crlf_reached )
{
int cnt, used, linecnt;
bool eofflag;
fcb *cfcb;
vi_rc rc;
f->bytes_pending = false;
/*
* go to appropriate location in file
*/
if( f->is_stdio ) {
if( extraData != NULL ) {
memcpy( ReadBuffer, extraData, extraDataSize );
MemFreePtr( &extraData );
}
} else {
rc = FileSeek( f->handle, f->curr_pos );
if( rc != ERR_NO_ERR ) {
return( rc );
}
}
/*
* read file data
*/
if( f->is_stdio ) {
cnt = fread( ReadBuffer + extraDataSize, 1, MAX_IO_BUFFER - extraDataSize, stdin );
cnt += extraDataSize;
extraDataSize = 0;
if( ferror( stdin ) ) {
return( ERR_READ );
}
} else {
cnt = read( f->handle, ReadBuffer, MAX_IO_BUFFER );
if( cnt == -1 ) {
return( ERR_READ );
}
}
/*
* get new fcb
*/
cfcb = FcbAlloc( f );
AddLLItemAtEnd( (ss **)&(f->fcbs.head), (ss **)&(f->fcbs.tail), (ss *)cfcb );
/*
* create lines from buffer info
*/
eofflag = CreateLinesFromFileBuffer( cnt, &cfcb->lines, &used, &linecnt, &(cfcb->byte_cnt), crlf_reached );
if( used == 0 ) {
CreateNullLine( cfcb );
eofflag = true;
} else {
/*
* update position
*/
f->curr_pos += used;
if( f->fcbs.tail->prev == NULL ) {
cfcb->start_line = 1;
} else {
cfcb->start_line = f->fcbs.tail->prev->end_line + 1;
}
if( f->is_stdio && feof( stdin ) && used >= cnt || !f->is_stdio && f->curr_pos >= f->size ) {
eofflag = true;
if( !EditFlags.LastEOL && ReadBuffer[used - 1] == LF ) {
++linecnt;
AddLLItemAtEnd( (ss **)&(cfcb->lines.head), (ss **)&(cfcb->lines.tail), (ss *)LineAlloc( NULL, 0 ) );
}
}
/*
* update line numbers
*/
cfcb->end_line = cfcb->start_line + linecnt - 1;
cfcb->non_swappable = false;
}
if( eofflag ) {
if( !f->is_stdio ) {
close( f->handle );
f->handle = -1;
}
return( END_OF_FILE );
}
f->bytes_pending = true;
if( f->is_stdio ) {
extraDataSize = cnt - used;
extraData = MemAlloc( extraDataSize );
memcpy( extraData, ReadBuffer + used, extraDataSize );
}
return( ERR_NO_ERR );
} /* ReadFcbData */
void operator delete(void *mem) { if (mem) MemFreePtr(mem); };
