/* * LocateTag - locate a tag in the tag file */ vi_rc LocateTag( char *str, char *fname, char *buff ) { char tag[MAX_STR]; int i; FILE *f; /* * get file and buffer */ f = GetFromEnvAndOpen( EditVars.TagFileName ); if( !f ) { if( EditFlags.SearchForTagfile ) { f = SearchForTags(); } if( !f ) { return( ERR_FILE_NOT_FOUND ); } } /* * loop until tag found */ for( ;; ) { if( fgets( buff, MAX_STR, f ) == NULL ) { fclose( f ); return( ERR_TAG_NOT_FOUND ); } if( NextWord1( buff, tag ) <= 0 ) { continue; } if( EditFlags.IgnoreTagCase ) { i = stricmp( str, tag ); } else { i = strcmp( str, tag ); if( i < 0 ) { fclose( f ); return( ERR_TAG_NOT_FOUND ); } } if( !i ) { return( selectTag( f, str, buff, fname ) ); } } } /* LocateTag */
static vi_rc getFile( char *fname ) { char dir[MAX_STR]; char *dirptr, ch; vi_rc rc; NextWord1( fname, dir ); rc = EditFile( dir, FALSE ); if( rc != ERR_NO_ERR ) { return( rc ); } dirptr = dir; if( isFgrep ) { if( caseIgn ) { ch = '~'; } else { ch = '@'; } dirptr += 2; strcpy( dirptr, origString ); MakeExpressionNonRegular( dirptr ); dirptr--; *dirptr = ch; if( IsMagicCharRegular( ch ) ) { dirptr--; *dirptr = '\\'; } } else { strcpy( dir, origString ); } AddString2( &(EditVars.FindHist.data[EditVars.FindHist.curr % EditVars.FindHist.max] ), origString ); EditVars.FindHist.curr += 1; ColorFind( dirptr, FINDFL_NOERROR ); SetLastFind( origString ); return( rc ); }
/* * 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; 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( fgets( path2, FILENAME_MAX, f ) != NULL ) { for( i = strlen( path2 ); i && isWSorCtrlZ( path2[i - 1] ); --i ) { path2[i - 1] = '\0'; } NextWord1( path2, data ); RemoveLeadingSpaces( path2 ); if( !strcmp( path, path2 ) ) { MakeTmpPath( path2, CurrentFile->as_name ); if( !strcmp( data, path2 ) ) { // found = TRUE; remove( path2 ); 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, path2 ); } 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; /* * 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( fgets( path2, FILENAME_MAX, f ) != NULL ) { for( i = strlen( path2 ); i && isWSorCtrlZ( path2[i - 1] ); --i ) { path2[i - 1] = '\0'; } NextWord1( path2, path ); RemoveLeadingSpaces( path2 ); NewFile( path, FALSE ); AddString2( &(CurrentFile->name), path2 ); SetFileWindowTitle( CurrentWindow, CurrentInfo, TRUE ); FileSPVAR(); CurrentFile->modified = TRUE; CurrentFile->check_readonly = TRUE; FTSRunCmds( path2 ); 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 */
/* * EditFile - read a file into text */ vi_rc EditFile( char *name, bool dammit ) { char *fn, **list, *currfn; int i, cnt, ocnt; int j, len; window_id wn = NO_WINDOW; char cdir[FILENAME_MAX]; info *ci, *il; bool usedir = false; char mask[FILENAME_MAX]; bool reset_dir; int index; char *altname = NULL; vi_rc rc; fn = MemAlloc( FILENAME_MAX ); /* * get file name */ strcpy( cdir, CurrentDirectory ); reset_dir = false; RemoveLeadingSpaces( name ); if( name[0] == '$' ) { EliminateFirstN( name, 1 ); usedir = true; } fn[0] = 0; // if( NextWord1( 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 ) { i = len - 1; strcpy( mask, fn ); cnt = 0; while( i >= 0 ) { if( fn[i] == FILE_SEP ) { for( j = i + 1; j <= len; j++ ) { mask[j - (i + 1)] = fn[j]; } cnt = i; break; } i--; } 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 ); NextWord1( altname, fn ); // if multiple, kill path if( isMultipleFiles( altname ) ) { NextWord1( altname, fn ); // get 1st name } } else { rc = SelectFileOpen( CurrentDirectory, &fn, mask, true ); } #else rc = SelectFileOpen( CurrentDirectory, &fn, mask, true ); #endif } if( altname ) { name = altname; } 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( CurrentWindow ); #else CloseAWindow( CurrentWindow ); #endif FreeUndoStacks(); FreeMarkList(); FreeEntireFile( CurrentFile ); MemFree( DeleteLLItem( (ss **)&InfoHead, (ss **)&InfoTail, (ss *)CurrentInfo ) ); CurrentInfo = NULL; CurrentWindow = NO_WINDOW; } else { ci = CurrentInfo; SaveCurrentInfo(); wn = CurrentWindow; } /* * 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]; _splitpath( il->CurrentFile->name, drive, dir, fname, ext ); if( !strlen( drive ) ) { _splitpath( il->CurrentFile->home, drive, NULL, NULL, NULL ); } if( !strlen( dir ) ) { _splitpath( il->CurrentFile->home, NULL, dir, NULL, NULL ); } else if( dir[0] != '\\' ) { char dir2[_MAX_DIR]; _splitpath( il->CurrentFile->home, 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( wn ); } if( EditFlags.BreakPressed ) { break; } } if( cnt > 0 ) { currfn = list[index]; index++; } } if( ocnt > 0 ) { MemFreeList( ocnt, list ); } if( EditFlags.BreakPressed ) { ClearBreak(); break; } } while( NextWord1( name, fn ) > 0 ); if( altname ) { MemFree( altname ); } MemFree( fn ); #ifdef __WIN__ ToggleHourglass( false ); #endif EditFlags.WatchForBreak = false; if( reset_dir ) { SetCWD( cdir ); } return( rc ); } /* EditFile */
/* * Source - main driver */ vi_rc Source( char *fn, char *data, int *ln ) { undo_stack *atomic = NULL; labels *lab, lb; vlist vl; files fi; sfile *sf, *curr; char tmp[MAX_SRC_LINE]; char sname[FILENAME_MAX]; vi_rc rc; bool sicmp, wfb, ssa, exm; resident *res; int cTokenID; /* * startup */ LastRC = LastRetCode; memset( &fi, 0, sizeof( fi ) ); vl.head = vl.tail = NULL; res = residentScript( fn ); if( res != NULL && EditFlags.LoadResidentScript ) { return( ERR_SCRIPT_ALREADY_RESIDENT ); } if( EditFlags.CompileScript || res == NULL ) { lab = &lb; memset( lab, 0, sizeof( labels ) ); sf = NULL; } else { lab = &res->lab; sf = res->sf; } if( EditFlags.CompileScript ) { sname[0] = 0; NextWord1( data, sname ); } /* * initialize variables */ memset( &fi, 0, sizeof( fi ) ); rc = initSource( &vl, data ); if( rc != ERR_NO_ERR ) { return( rc ); } /* * pre-process */ sicmp = EditFlags.ScriptIsCompiled; SourceErrCount = 0; if( EditFlags.CompileScript || res == NULL ) { EditFlags.ScriptIsCompiled = FALSE; rc = PreProcess( fn, &sf, lab ); finiSourceErrFile( fn ); if( rc != ERR_NO_ERR || SourceErrCount > 0 ) { EditFlags.ScriptIsCompiled = sicmp; return( rc ); } } else { EditFlags.ScriptIsCompiled = res->scriptcomp; } /* * if we were loading a resident script, then add it */ if( EditFlags.LoadResidentScript ) { finiSource( NULL, &vl, NULL, NULL ); if( SourceErrCount == 0 ) { addResidentScript( fn, sf, lab ); } EditFlags.ScriptIsCompiled = sicmp; return( ERR_NO_ERR ); } /* * if we were compiling, dump results and go back */ if( EditFlags.CompileScript ) { rc = barfScript( fn, sf, &vl, ln, sname ); finiSource( lab, &vl, sf, NULL ); return( rc ); } /* * process each source line */ exm = EditFlags.ExMode; wfb = EditFlags.WatchForBreak; ssa = EditFlags.SourceScriptActive; EditFlags.SourceScriptActive = TRUE; EditFlags.WatchForBreak = TRUE; EditFlags.ExMode = TRUE; curr = sf->next; while( curr != NULL ) { cTokenID = curr->token - SRC_T_NULL - 1; if( !EditFlags.Starting ) { if( EditFlags.BreakPressed ) { ClearBreak(); break; } } rc = LastError = ERR_NO_ERR; if( curr->data != NULL ) { strcpy( tmp, curr->data ); } else { tmp[0] = 0; } if( EditFlags.Appending ) { if( curr->hasvar) { Expand( tmp, &vl ); } rc = AppendAnother( tmp ); goto evil_continue; } if( cTokenID == PCL_T_ENDFILETYPESOURCE ) { rc = FTSEnd(); goto evil_continue; } if( EditFlags.FileTypeSource ) { rc = FTSAddCmd( tmp, curr->token ); goto evil_continue; } if( curr->token > SRC_T_NULL ) { if( curr->hasvar) { Expand( tmp, &vl ); } rc = TryCompileableToken( cTokenID, tmp, FALSE, 0 ); if( rc == NOT_COMPILEABLE_TOKEN ) { rc = ProcessWindow( cTokenID, tmp ); } if( rc < ERR_NO_ERR ) { rc = ERR_NO_ERR; } } else switch( curr->token ) { case SRC_T_ATOMIC: if( atomic == NULL ) { atomic = UndoStack; StartUndoGroup( atomic ); } break; case SRC_T_IF: rc = SrcIf( &curr, &vl ); break; case SRC_T_GOTO: rc = SrcGoTo( &curr, tmp, lab ); break; case SRC_T_LABEL: break; case SRC_T_RETURN: if( curr->data != NULL ) { int ret; GetErrorTokenValue( &ret, curr->data ); rc = ret; } else { rc = ERR_NO_ERR; } goto evil_exit; case SRC_T_GET: SrcGet( tmp, &vl ); rc = ERR_NO_ERR; break; case SRC_T_INPUT: LastRC = SrcInput( tmp, &vl ); if( LastRC != NO_VALUE_ENTERED && LastRC != ERR_NO_ERR ) { rc = LastRC; } break; case SRC_T_NEXTWORD: rc = SrcNextWord( tmp, &vl ); break; case SRC_T_ASSIGN: rc = SrcAssign( tmp, &vl ); break; case SRC_T_EXPR: rc = SrcExpr( curr, &vl ); break; case SRC_T_OPEN: LastRC = SrcOpen( curr, &vl, &fi, tmp ); if( LastRC != ERR_FILE_NOT_FOUND && LastRC != ERR_NO_ERR ) { rc = LastRC; } break; case SRC_T_READ: LastRC = SrcRead( curr, &fi, tmp, &vl ); if( LastRC != END_OF_FILE && LastRC != ERR_NO_ERR ) { rc = LastRC; } break; case SRC_T_WRITE: rc = SrcWrite( curr, &fi, tmp, &vl ); break; case SRC_T_CLOSE: rc = SrcClose( curr, &vl, &fi, tmp ); break; default: #ifdef __WIN__ { if( RunWindowsCommand( tmp, &LastRC, &vl ) ) { rc = LastRC; break; } } #endif if( curr->hasvar ) { Expand( tmp, &vl ); } LastRC = RunCommandLine( tmp ); if( LastRC == DO_NOT_CLEAR_MESSAGE_WINDOW ) { LastRC = LastError; } break; } evil_continue: if( rc != ERR_NO_ERR ) { break; } curr = curr->next; } evil_exit: if( EditFlags.Appending ) { AppendAnother( "." ); } if( curr != NULL ) { *ln = curr->line; } else { *ln = CurrentSrcLine; rc = ERR_NO_ERR; } EditFlags.WatchForBreak = wfb; EditFlags.SourceScriptActive = ssa; EditFlags.ScriptIsCompiled = sicmp; EditFlags.ExMode = exm; if( res != NULL && !EditFlags.CompileScript ) { sf = NULL; lab = NULL; } finiSource( lab, &vl, sf, atomic ); return( rc ); } /* Source */
/* * 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 */
/* * 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 */
/* * Set - set editor control variable */ vi_rc Set( char *name ) { char fn[MAX_STR]; vi_rc rc = ERR_NO_ERR; int j, i; #ifndef VICOMP #ifndef __WIN__ int tmp, tc; char **vals = NULL; char **list; int longest; #endif #endif /* * get item to set */ #ifndef VICOMP msgFlag = FALSE; if( !EditFlags.ScriptIsCompiled ) { #endif RemoveLeadingSpaces( name ); j = strlen( name ); for( i = 0; i < j; i++ ) { if( name[i] == '=' || name[i] == ',' ) { name[i] = ' '; } } #ifndef VICOMP } #endif if( NextWord1( name, fn ) <=0 ) { #ifndef VICOMP if( !EditFlags.WindowsStarted ) { return( ERR_NO_ERR ); } #ifndef __WIN__ tc = getSetInfo( &vals, &list, &longest ); tmp = setw_info.y2; i = setw_info.y2 - setw_info.y1 + 1; if( setw_info.has_border ) { i -= 2; } if( tc < i ) { setw_info.y2 -= (i - tc); } rc = SelectItemAndValue( &setw_info, "Settings", list, tc, SettingSelected, 1, vals, longest + 3 ); setw_info.y2 = tmp; MemFreeList( tc, vals ); MemFreeList( tc, list ); ReDisplayScreen(); #endif #endif /* VICOMP */ return( rc ); } else { #ifndef VICOMP if( !EditFlags.Starting) { msgFlag = TRUE; } #endif do { #ifndef VICOMP if( !EditFlags.ScriptIsCompiled ) { #endif if( tolower( fn[0] ) == 'n' && tolower( fn[1] ) == 'o' ) { EliminateFirstN( fn, 2 ); i = -1; } else { i = 1; } j = Tokenize( SetTokens1, fn, FALSE ); if( j == TOK_INVALID ) { j = Tokenize( SetTokens2a, fn, FALSE ); if( j == TOK_INVALID ) { j = Tokenize( SetTokens2, fn, FALSE ); if( j == TOK_INVALID ) { return( ERR_INVALID_SET_COMMAND ); } } j += SET1_T_; } j *= i; #ifndef VICOMP } else { j = atoi( fn ); } #endif i = TRUE; rc = processSetToken( j, name, &i, FALSE ); if( rc > ERR_NO_ERR ) { break; } RemoveLeadingSpaces( name ); } while( NextWord1( name, fn ) > 0 ); #ifndef VICOMP if( msgFlag ) { putMessage(); } #endif return( rc ); } } /* Set */
/* * PreProcess - pre-process source file */ vi_rc PreProcess( const char *fn, sfile **sf, labels *lab ) { GENERIC_FILE gf; int i, token, k, len; sfile *tsf; char tmp[MAX_SRC_LINE], tmp2[MAX_SRC_LINE]; char tmp3[MAX_SRC_LINE]; bool ret; #ifdef VICOMP bool AppendingFlag = FALSE; #else #define AppendingFlag EditFlags.Appending #endif /* * get source file */ #ifdef VICOMP ret = SpecialOpen( fn, &gf ); #else if( EditFlags.CompileScript ) { EditFlags.OpeningFileToCompile = TRUE; ret = SpecialOpen( fn, &gf, FALSE ); EditFlags.OpeningFileToCompile = FALSE; } else { ret = SpecialOpen( fn, &gf, EditFlags.BoundData ); } #endif if( !ret ) { return( ERR_FILE_NOT_FOUND ); } /* * init control */ CSInit(); CurrentSrcLine = 0L; tsf = MemAlloc( sizeof( sfile ) ); tsf->next = NULL; tsf->prev = NULL; tsf->arg1 = NULL; tsf->arg2 = NULL; tsf->data = NULL; tsf->token = SRC_T_NULL; *sf = tmpTail = tsf; cLab = lab; /* * set up error handler */ i = setjmp( genExit ); if( i != 0 ) { SpecialFclose( &gf ); return( (vi_rc)i ); } /* * process each line */ while( SpecialFgets( tmp, MAX_SRC_LINE - 1, &gf ) >= 0 ) { /* * prepare this line */ CurrentSrcLine++; #ifndef VICOMP if( !EditFlags.ScriptIsCompiled ) { #endif RemoveLeadingSpaces( tmp ); k = strlen( tmp ); memcpy( tmp3, tmp, k + 1 ); if( (len = NextWord1( tmp, tmp2 )) <= 0 ) { continue; } if( tmp2[0] == '#' ) { continue; } hasVar = FALSE; for( i = 0; i < k; i++ ){ if( tmp3[i] == '%' ) { hasVar = TRUE; break; } } /* * if we are appending (ie, an append token was encounterd * before, stop tokenizing */ if( !AppendingFlag ) { token = Tokenize( SourceTokens, tmp2, TRUE ); #ifndef VICOMP if( token == SRC_T_VBJ__ ) { EditFlags.ScriptIsCompiled = TRUE; continue; } #endif } else { token = TOK_INVALID; } #ifndef VICOMP } else { len = NextWord1( tmp, tmp2 ); hasVar = (bool) tmp2[0] - '0'; token = atoi( &tmp2[1] ); } #endif /* * process recognized tokens */ if( token != TOK_INVALID ) { RemoveLeadingSpaces( tmp ); if( token > SRC_T_NULL ) { genItem( token, tmp ); continue; } /* * get parm */ AddString( &CurrentSrcData, tmp ); freeSrcData = TRUE; /* * process token */ switch( token ) { case SRC_T_EXPR: genExpr(); break; case SRC_T_LABEL: GenLabel( tmp ); break; case SRC_T_IF: CSIf(); break; case SRC_T_QUIF: CSQuif(); break; case SRC_T_ELSEIF: CSElseIf(); break; case SRC_T_ELSE: CSElse(); break; case SRC_T_ENDIF: CSEndif(); break; case SRC_T_LOOP: CSLoop(); break; case SRC_T_ENDLOOP: case SRC_T_ENDWHILE: CSEndLoop(); break; case SRC_T_WHILE: CSWhile(); break; case SRC_T_UNTIL: CSUntil(); break; case SRC_T_BREAK: CSBreak(); break; case SRC_T_CONTINUE: CSContinue(); break; default: genItem( token, NULL ); if( token == SRC_T_GOTO ) { #ifndef VICOMP if( EditFlags.ScriptIsCompiled ) { NextWord1( CurrentSrcData, tmp ); tmpTail->branchcond = atoi( CurrentSrcData ); strcpy( CurrentSrcData, tmp ); } else { #endif tmpTail->branchcond = COND_JMP; #ifndef VICOMP } #endif } tmpTail->data = CurrentSrcData; freeSrcData = FALSE; break; } if( freeSrcData ) { MemFree( CurrentSrcData ); } /* * set all other tokens to be processed at run time */ } else { #ifndef VICOMP if( EditFlags.ScriptIsCompiled ) { RemoveLeadingSpaces( tmp ); genItem( token, tmp ); continue; } #endif if( !AppendingFlag ) { token = Tokenize( TokensCmdLine, tmp2, TRUE ); } else { token = TOK_INVALID; } switch( token ) { case PCL_T_COMMANDWINDOW: case PCL_T_STATUSWINDOW: case PCL_T_COUNTWINDOW: case PCL_T_EDITWINDOW: case PCL_T_EXTRAINFOWINDOW: case PCL_T_FILECWINDOW: case PCL_T_LINENUMBERWINDOW: case PCL_T_DIRWINDOW: case PCL_T_FILEWINDOW: case PCL_T_SETWINDOW: case PCL_T_SETVALWINDOW: case PCL_T_MESSAGEWINDOW: case PCL_T_MENUWINDOW: case PCL_T_MENUBARWINDOW: case PCL_T_ENDWINDOW: case PCL_T_SETCOLOR: case PCL_T_MATCH: case PCL_T_DIMENSION: case PCL_T_BORDER: case PCL_T_HILIGHT: case PCL_T_TEXT: case PCL_T_ALIAS: case PCL_T_ABBREV: case PCL_T_MENU: case PCL_T_MENUITEM: case PCL_T_ENDMENU: case PCL_T_WHITESPACE: case PCL_T_SELECTION: case PCL_T_EOFTEXT: case PCL_T_KEYWORD: case PCL_T_OCTAL: case PCL_T_HEX: case PCL_T_INTEGER: case PCL_T_CHAR: case PCL_T_PREPROCESSOR: case PCL_T_SYMBOL: case PCL_T_INVALIDTEXT: case PCL_T_IDENTIFIER: case PCL_T_JUMPLABEL: case PCL_T_COMMENT: case PCL_T_FLOAT: case PCL_T_STRING: case PCL_T_VARIABLE: case PCL_T_FILETYPESOURCE: case PCL_T_ENDFILETYPESOURCE: case PCL_T_LOCATE: case PCL_T_MAP: case PCL_T_MAP_DMT: case PCL_T_MENUFILELIST: case PCL_T_MENULASTFILES: case PCL_T_DEFAULTWINDOW: case PCL_T_ACTIVEMENUWINDOW: case PCL_T_GREYEDMENUWINDOW: case PCL_T_ACTIVEGREYEDMENUWINDOW: RemoveLeadingSpaces( tmp ); token += SRC_T_NULL + 1; genItem( token, tmp ); break; case PCL_T_SET: token += SRC_T_NULL + 1; #ifdef VICOMP WorkLine->data[0] = 0; Set( tmp ); genItem( token, WorkLine->data ); #else if( EditFlags.CompileScript ) { vi_rc rc; WorkLine->data[0] = 0; rc = Set( tmp ); if( rc != ERR_NO_ERR ) { Error( GetErrorMsg( rc ) ); } genItem( token, WorkLine->data ); } else { genItem( token, tmp ); } #endif break; default: if( AppendingFlag ) { if( tmp3[0] == '.' && tmp3[1] == 0 ) { AppendingFlag = FALSE; } } else if( token == TOK_INVALID ) { /* * see if the current token is a Ex token. If * it isn't, then see if the next one is * (i.e., look for <n> append) */ token = Tokenize( TokensEx, tmp2, FALSE ); if( token == TOK_INVALID ) { if( NextWord1( tmp, tmp2 ) >= 0 ) { token = Tokenize( TokensEx, tmp2, FALSE ); if( token == EX_T_APPEND ) { AppendingFlag = TRUE; } } } } if( tmp3[0] == '>' ) { tmp3[0] = ' '; } genItem( TOK_INVALID, tmp3 ); break; } } } SpecialFclose( &gf ); AppendingFlag = FALSE; return( CSFini() ); } /* PreProcess */
/* * genExpr - gen an expression assignment */ static void genExpr( void ) { char v1[MAX_SRC_LINE], v2[MAX_SRC_LINE], tmp[MAX_SRC_LINE]; #ifndef VICOMP expr_oper oper = EXPR_EQ; #endif /* * get expression syntax : * EXPR %v = v1 */ if( NextWord1( CurrentSrcData, v1 ) <= 0 ) { AbortGen( ERR_SRC_INVALID_EXPR ); } if( NextWord1( CurrentSrcData, tmp ) <= 0 ) { AbortGen( ERR_SRC_INVALID_EXPR ); } if( tmp[1] == '=' && tmp[2] == 0 ) { switch( tmp[0] ) { #ifndef VICOMP case '+': oper = EXPR_PLUSEQ; break; case '-': oper = EXPR_MINUSEQ; break; case '*': oper = EXPR_TIMESEQ; break; case '/': oper = EXPR_DIVIDEEQ; break; #else case '+': break; case '-': break; case '*': break; case '/': break; #endif default: AbortGen( ERR_SRC_INVALID_EXPR ); break; } } else { if( tmp[0] != '=' || tmp[1] != 0 ) { AbortGen( ERR_SRC_INVALID_EXPR ); } } strcpy( v2, CurrentSrcData ); RemoveLeadingSpaces( v2 ); if( v2[0] == 0 ) { AbortGen( ERR_SRC_INVALID_EXPR ); } #ifndef VICOMP if( EditFlags.CompileScript ) { #endif genItem( SRC_T_EXPR, StrMerge( 4, v1, SingleBlank, tmp, SingleBlank, v2 ) ); #ifndef VICOMP } else { /* * build the expr data structure */ genItem( SRC_T_EXPR, NULL ); tmpTail->u.oper = oper; AddString( &tmpTail->arg1, v1 ); AddString( &tmpTail->arg2, v2 ); } #endif } /* genExpr */
/* * ProcessEx - process an ex command */ vi_rc ProcessEx( linenum n1, linenum n2, bool n2f, int tkn, char *data ) { vi_rc rc = ERR_INVALID_COMMAND, i; char word[MAX_STR], wordback[MAX_STR]; linenum addr, tlines; fcb *cfcb; line *cline; fcb_list fcblist; NextWord1( data, word ); strcpy( wordback, word ); if( GetAddress( word, &addr ) ) { addr = -1; } tlines = n2 - n1 + 1; switch( tkn ) { case EX_T_APPEND: if( !EditFlags.ExMode ) { return( ERR_ONLY_VALID_IN_EX_MODE ); } if( !n2f ) { rc = Append( n1, true ); } break; case EX_T_CHANGE: if( !EditFlags.ExMode ) { return( ERR_ONLY_VALID_IN_EX_MODE ); } StartUndoGroup( UndoStack ); rc = DeleteLineRange( n1, n2, 0 ); if( rc != ERR_NO_ERR ) { EndUndoGroup( UndoStack ); break; } rc = Append( n1 - 1, false ); if( rc != ERR_NO_ERR ) { EndUndoGroup( UndoStack ); break; } break; case EX_T_COPY: if( addr < 0 || IsPastLastLine( addr ) ) { return( ERR_INVALID_ADDRESS ); } i = GetCopyOfLineRange( n1, n2, &fcblist ); if( i ) { break; } rc = InsertLines( addr, &fcblist, UndoStack ); GoToLineNoRelCurs( addr ); if( rc == ERR_NO_ERR ) { Message1( strCmmsg, tlines, "copied", addr ); } break; case EX_T_INSERT: if( !EditFlags.ExMode ) { return( ERR_ONLY_VALID_IN_EX_MODE ); } if( !n2f ) { rc = Append( n1 - 1, true ); } break; case EX_T_JOIN: if( SaveAndResetFilePos( n1 ) != ERR_NO_ERR ) { rc = ERR_NO_SUCH_LINE; break; } if( tlines == 1 ) { n2 = n1 + 1; tlines = 2; } SetRepeatCount( tlines - 1 ); rc = JoinCurrentLineToNext(); RestoreCurrentFilePos(); GoToLineNoRelCurs( n1 ); if( rc == ERR_NO_ERR ) { Message1( "lines %l to %l joined", n1, n2 ); } break; case EX_T_LIST: if( !EditFlags.ExMode ) { return( ERR_ONLY_VALID_IN_EX_MODE ); } rc = CGimmeLinePtr( n1, &cfcb, &cline ); while( !rc ) { if( EditFlags.LineNumbers ) { MyPrintf( "%M %s\n", n1, cline->data ); } else { MyPrintf( "%s\n", cline->data ); } if( n1 >= n2 ) { break; } n1++; rc = CGimmeNextLinePtr( &cfcb, &cline ); } break; case EX_T_MARK: rc = SetGenericMark( n1, 1, word[0] ); break; case EX_T_MOVE: if( addr < 0 || IsPastLastLine( addr ) ) { return( ERR_INVALID_ADDRESS ); } SavebufNumber = WORK_SAVEBUF; StartUndoGroup( UndoStack ); rc = DeleteLineRange( n1, n2, SAVEBUF_FLAG ); if( SavebufNumber != WORK_SAVEBUF ) { /* if this changes, the command will fail * this could be caused by checking out a read-only file * so fix the deleted text and give an error message */ DoUndo(); return( ERR_INVALID_COMMAND ); } if( rc != ERR_NO_ERR ) { EndUndoGroup( UndoStack ); break; } if( addr > n2 ) { addr -= tlines; } else if( addr >= n1 && addr <= n2 ) { addr = n1; } rc = InsertLines( addr, &WorkSavebuf->u.fcbs, UndoStack ); EndUndoGroup( UndoStack ); GoToLineNoRelCurs( addr ); if( rc == ERR_NO_ERR ) { Message1( strCmmsg, tlines, "moved", addr ); } break; case EX_T_UNDO: rc = DoUndo(); break; case EX_T_UNDO_DMT: rc = DoUndoUndo(); break; case EX_T_EQUALS: Message1( "%l", n1 ); rc = ERR_NO_ERR; break; case EX_T_VERSION: rc = DoVersion(); break; case EX_T_VISUAL: case EX_T_VISUAL_DMT: if( EditFlags.LineDisplay ) { ScreenPage( -1 ); EditFlags.ExMode = false; EditFlags.LineDisplay = false; EditFlags.ClockActive = true; ReDisplayScreen(); DoVersion(); } if( wordback[0] != 0 ) { rc = EditFile( wordback, ( tkn == EX_T_VISUAL_DMT ) ); } else { rc = ERR_NO_ERR; } break; } return( rc ); } /* ProcessEx */
/* * MapKey - set up a key mapping */ vi_rc MapKey( int flag, char *data ) { char keystr[MAX_STR]; key_map *maps; int j; vi_key key; vi_rc rc; #ifndef VICOMP if( !EditFlags.ScriptIsCompiled || (flag & MAPFLAG_UNMAP) ) { #endif rc = readKeyData(); if( rc != ERR_NO_ERR ) { return( rc ); } #ifndef VICOMP } #endif /* * get if it is an input/regular key mapping */ if( flag & MAPFLAG_DAMMIT ) { maps = InputKeyMaps; } else { maps = KeyMaps; } if( NextWord1( data, keystr ) <= 0 ) { return( ERR_INVALID_MAP ); } RemoveLeadingSpaces( data ); /* * get key we are using */ #ifndef VICOMP if( !EditFlags.ScriptIsCompiled || (flag & MAPFLAG_UNMAP) ) { #endif j = Tokenize( charTokens, keystr, TRUE ); if( j == TOK_INVALID ) { key = (unsigned char)keystr[0]; } else { key = keyVals[j]; } if( key >= MAX_EVENTS ) { return( ERR_INVALID_KEY ); } #ifndef VICOMP } else { long keyl; keyl = atol( keystr ); if( keyl < 0 || keyl >= MAX_EVENTS ) { return( ERR_INVALID_KEY ); } key = (vi_key)keyl; } #endif #ifndef VICOMP if( EditFlags.CompileScript ) { #endif if( !(flag & MAPFLAG_UNMAP) ) { key_map scr; rc = AddKeyMap( &scr, data ); if( rc == ERR_NO_ERR ) { if( scr.no_input_window ) { MySprintf( WorkLine->data, "%d \\x%s", key, scr.data ); } else { MySprintf( WorkLine->data, "%d %s", key, scr.data ); } } MemFree( scr.data ); return( rc ); } else { MySprintf( WorkLine->data, "%d %s", key, data ); return( ERR_NO_ERR ); } #ifndef VICOMP } maps[key].inuse = FALSE; maps[key].is_base = FALSE; MemFree( maps[key].data ); maps[key].data = NULL; if( !(flag & MAPFLAG_UNMAP ) ) { if( flag & MAPFLAG_BASE ) { maps[key].is_base = TRUE; } return( AddKeyMap( &maps[key], data ) ); } return( ERR_NO_ERR ); #endif } /* MapKey */
vi_rc ReadDataFile( char *file, char **buffer, bool (*fn_alloc)( int ), bool (*fn_save)( int, char* ), bool bounddata ) #endif { GENERIC_FILE gf; int i, dcnt, len, size; char token[MAX_STR], buff[MAX_STR]; char *buffdata; bool hasvals; /* * get file and buffer */ #ifdef VICOMP if( !SpecialOpen( file, &gf ) ) { #else if( !SpecialOpen( file, &gf, bounddata ) ) { #endif return( ERR_FILE_NOT_FOUND ); } /* * get counts */ if( SpecialFgets( buff, MAX_STR - 1, &gf ) < 0 ) { SpecialFclose( &gf ); return( ERR_INVALID_DATA_FILE ); } dcnt = atoi( buff ); hasvals = fn_alloc( dcnt ); buffdata = NULL; size = 0; /* * read all tokens */ for( i = 0; i < dcnt; i++ ) { len = SpecialFgets( buff, sizeof( buff ) - 1, &gf ); if( len < 0 ) { SpecialFclose( &gf ); return( ERR_INVALID_DATA_FILE ); } if( hasvals ) { len = NextWord1( buff, token ); if( len <= 0 ) { SpecialFclose( &gf ); return( ERR_INVALID_DATA_FILE ); } } else { memcpy( token, buff, len + 1 ); } len++; buffdata = MemReAlloc( buffdata, size + len + 1 ); memcpy( &buffdata[size], token, len ); size += len; buffdata[size] = 0; if( hasvals ) { if( NextWord1( buff, token ) <= 0 ) { SpecialFclose( &gf ); return( ERR_INVALID_DATA_FILE ); } fn_save( i, token ); } } SpecialFclose( &gf ); *buffer = buffdata; return( ERR_NO_ERR ); } /* ReadDataFile */