void I_OutputMsg(const char *error, ...)
{
va_list argptr;
va_start(argptr, error);
viprintf(error, argptr);
va_end(argptr);
}
void printLog(const char *format, ...) {
if (isMenuOn() || sharedData->scalingOn)
return;
va_list args;
va_start(args, format);
if (consoleDebugOutput)
viprintf(format, args);
}
/*
* Print out the argument list, with []'s around the current name.
*/
void
pargs(void)
{
unsigned char **av = argv0, *as = args0;
int ac;
for (ac = 0; ac < argc0; ac++) {
if (ac != 0)
putchar(' ');
if (ac + argc == argc0 - 1)
viprintf("[");
lprintf("%s", as);
if (ac + argc == argc0 - 1)
viprintf("]");
as = av ? *++av : strend(as) + 1;
}
noonl();
}
/**
* For this version of REDUCED PRINTF, simply hand off to stdio iprintf and siprintf
* which should reduce code size by about 16KBytes!!
*/
int printf(const char* fmt, ...)
{
int len = 0;
va_list args;
va_start(args, fmt);
len = viprintf(fmt, args);
va_end(args);
return len;
}
void I_Error(const char *error, ...)
{
va_list argptr;
va_start(argptr, error);
viprintf(error, argptr);
va_end(argptr);
for(;;);
}
void error VA_DECL(const char*, line)
{
VA_INIT(line, char *);
char choice;
nds_show_console();
viprintf(line, VA_ARGS);
choice = nds_yn_function("Should I break into the debugger?", "yn", 'y');
if (choice == 'y') {
nds_break_into_debugger();
}
VA_END();
}
/*
* Parse file name for command encoded by comm.
* If comm is E then command is doomed and we are
* parsing just so user won't have to retype the name.
*/
void
filename(int comm)
{
int c = comm, d;
int i;
d = getchar();
if (endcmd(d)) {
if (savedfile[0] == 0 && comm != 'f')
error(value(vi_TERSE) ? gettext("No file") :
gettext("No current filename"));
CP(file, savedfile);
wasalt = (isalt > 0) ? isalt-1 : 0;
isalt = 0;
oldadot = altdot;
if (c == 'e' || c == 'E')
altdot = lineDOT();
if (d == EOF)
ungetchar(d);
} else {
ungetchar(d);
getone();
eol();
if (savedfile[0] == 0 && c != 'E' && c != 'e') {
c = 'e';
edited = 0;
}
wasalt = strcmp(file, altfile) == 0;
oldadot = altdot;
switch (c) {
case 'f':
edited = 0;
/* FALLTHROUGH */
case 'e':
if (savedfile[0]) {
altdot = lineDOT();
CP(altfile, savedfile);
}
CP(savedfile, file);
break;
default:
if (file[0]) {
if (c != 'E')
altdot = lineDOT();
CP(altfile, file);
}
break;
}
}
if (hush && comm != 'f' || comm == 'E')
return;
if (file[0] != 0) {
lprintf("\"%s\"", file);
if (comm == 'f') {
if (value(vi_READONLY))
viprintf(gettext(" [Read only]"));
if (!edited)
viprintf(gettext(" [Not edited]"));
if (tchng)
viprintf(gettext(" [Modified]"));
}
flush();
} else
viprintf(gettext("No file "));
if (comm == 'f') {
if (!(i = lineDOL()))
i++;
/*
* TRANSLATION_NOTE
* Reference order of arguments must not
* be changed using '%digit$', since vi's
* viprintf() does not support it.
*/
viprintf(gettext(" line %d of %d --%ld%%--"), lineDOT(),
lineDOL(), (long)(100 * lineDOT() / i));
}
}
/*
* Read a file from the world.
* C is command, 'e' if this really an edit (or a recover).
*/
void
rop(int c)
{
int i;
struct stat64 stbuf;
short magic;
static int ovro; /* old value(vi_READONLY) */
static int denied; /* 1 if READONLY was set due to file permissions */
io = open(file, 0);
if (io < 0) {
if (c == 'e' && errno == ENOENT) {
edited++;
/*
* If the user just did "ex foo" they're probably
* creating a new file. Don't be an error, since
* this is ugly, and it messes up the + option.
*/
if (!seenprompt) {
viprintf(gettext(" [New file]"));
noonl();
return;
}
}
if (value(vi_READONLY) && denied) {
value(vi_READONLY) = ovro;
denied = 0;
}
syserror(0);
}
if (fstat64(io, &stbuf))
syserror(0);
switch (FTYPE(stbuf) & S_IFMT) {
case S_IFBLK:
error(gettext(" Block special file"));
/* FALLTHROUGH */
case S_IFCHR:
if (isatty(io))
error(gettext(" Teletype"));
if (samei(&stbuf, "/dev/null"))
break;
error(gettext(" Character special file"));
/* FALLTHROUGH */
case S_IFDIR:
error(gettext(" Directory"));
}
if (c != 'r') {
if (value(vi_READONLY) && denied) {
value(vi_READONLY) = ovro;
denied = 0;
}
if ((FMODE(stbuf) & 0222) == 0 || access((char *)file, 2) < 0) {
ovro = value(vi_READONLY);
denied = 1;
value(vi_READONLY) = 1;
}
}
if (hush == 0 && value(vi_READONLY)) {
viprintf(gettext(" [Read only]"));
flush();
}
if (c == 'r')
setdot();
else
setall();
/* If it is a read command, then we must set dot to addr1
* (value of N in :Nr ). In the default case, addr1 will
* already be set to dot.
*
* Next, it is necessary to mark the beginning (undap1) and
* ending (undap2) addresses affected (for undo). Note that
* rop2() and rop3() will adjust the value of undap2.
*/
if (FIXUNDO && inopen && c == 'r') {
dot = addr1;
undap1 = undap2 = dot + 1;
}
rop2();
rop3(c);
}
void
vappend(int ch, int cnt, int indent)
{
int i;
unsigned char *gcursor;
bool escape;
int repcnt, savedoomed;
short oldhold = hold;
int savecnt = cnt;
line *startsrcline;
int startsrccol, endsrccol;
int gotNL = 0;
int imultlinecnt = 0;
int omultlinecnt = 0;
if ((savecnt > 1) && (ch == 'o' || ch == 'O')) {
omultlinecnt = 1;
}
#ifdef XPG6
if ((savecnt > 1) && (ch == 'a' || ch == 'A' || ch == 'i' || ch == 'I'))
imultlinecnt = 1;
#endif /* XPG6 */
/*
* Before a move in hardopen when the line is dirty
* or we are in the middle of the printed representation,
* we retype the line to the left of the cursor so the
* insert looks clean.
*/
if (ch != 'o' && state == HARDOPEN && (rubble || !ateopr())) {
rubble = 1;
gcursor = cursor;
i = *gcursor;
*gcursor = ' ';
wcursor = gcursor;
(void) vmove();
*gcursor = i;
}
/*
* If vrep() passed indent = 0, this is the 'r' command,
* so don't autoindent until the last char.
*/
vaifirst = indent == 0;
/*
* Handle replace character by (eventually)
* limiting the number of input characters allowed
* in the vgetline routine.
*/
if (ch == 'r')
repcnt = 2;
else
repcnt = 0;
/*
* If an autoindent is specified, then
* generate a mixture of blanks to tabs to implement
* it and place the cursor after the indent.
* Text read by the vgetline routine will be placed in genbuf,
* so the indent is generated there.
*/
if (value(vi_AUTOINDENT) && indent != 0) {
unsigned char x;
gcursor = genindent(indent);
*gcursor = 0;
vgotoCL(nqcolumn(lastchr(linebuf, cursor), genbuf));
} else {
gcursor = genbuf;
*gcursor = 0;
if (ch == 'o')
vfixcurs();
}
/*
* Prepare for undo. Pointers delimit inserted portion of line.
*/
vUA1 = vUA2 = cursor;
/*
* If we are not in a repeated command and a ^@ comes in
* then this means the previous inserted text.
* If there is none or it was too long to be saved,
* then beep() and also arrange to undo any damage done
* so far (e.g. if we are a change.)
*/
switch (ch) {
case 'r':
break;
case 'a':
/*
* TRANSLATION_NOTE
* "A" is a terse mode message corresponding to
* "APPEND MODE".
* Translated message of "A" must be 1 character (not byte).
* Or, just leave it.
*/
if (value(vi_TERSE)) {
vshowmode(gettext("A"));
} else {
vshowmode(gettext("APPEND MODE"));
}
break;
case 's':
/*
* TRANSLATION_NOTE
* "S" is a terse mode message corresponding to
* "SUBSTITUTE MODE".
* Translated message of "S" must be 1 character (not byte).
* Or, just leave it.
*/
if (value(vi_TERSE)) {
vshowmode(gettext("S"));
} else {
vshowmode(gettext("SUBSTITUTE MODE"));
}
break;
case 'c':
/*
* TRANSLATION_NOTE
* "C" is a terse mode message corresponding to
* "CHANGE MODE".
* Translated message of "C" must be 1 character (not byte).
* Or, just leave it.
*/
if (value(vi_TERSE)) {
vshowmode(gettext("C"));
} else {
vshowmode(gettext("CHANGE MODE"));
}
break;
case 'R':
/*
* TRANSLATION_NOTE
* "R" is a terse mode message corresponding to
* "REPLACE MODE".
* Translated message of "R" must be 1 character (not byte).
* Or, just leave it.
*/
if (value(vi_TERSE)) {
vshowmode(gettext("R"));
} else {
vshowmode(gettext("REPLACE MODE"));
}
break;
case 'o':
/*
* TRANSLATION_NOTE
* "O" is a terse mode message corresponding to
* "OPEN MODE".
* Translated message of "O" must be 1 character (not byte).
* Or, just leave it.
*/
if (value(vi_TERSE)) {
vshowmode(gettext("O"));
} else {
vshowmode(gettext("OPEN MODE"));
}
break;
case 'i':
/*
* TRANSLATION_NOTE
* "I" is a terse mode message corresponding to
* "INSERT MODE" and the following "INPUT MODE".
* Translated message of "I" must be 1 character (not byte).
* Or, just leave it.
*/
if (value(vi_TERSE)) {
vshowmode(gettext("I"));
} else {
vshowmode(gettext("INSERT MODE"));
}
break;
default:
/*
* TRANSLATION_NOTE
* "I" is a terse mode message corresponding to
* "INPUT MODE" and the previous "INSERT MODE".
* Translated message of "I" must be 1 character (not byte).
* Or, just leave it.
*/
if (value(vi_TERSE)) {
vshowmode(gettext("I"));
} else {
vshowmode(gettext("INPUT MODE"));
}
}
ixlatctl(1);
if ((vglobp && *vglobp == 0) || peekbr()) {
if (INS[128] == 0200) {
(void) beep();
if (!splitw)
ungetkey('u');
doomed = 0;
hold = oldhold;
return;
}
/*
* Unread input from INS.
* An escape will be generated at end of string.
* Hold off n^^2 type update on dumb terminals.
*/
vglobp = INS;
inscdcnt = INSCDCNT;
hold |= HOLDQIK;
} else if (vglobp == 0) {
/*
* Not a repeated command, get
* a new inserted text for repeat.
*/
INS[0] = 0;
INS[128] = 0;
INSCDCNT = 0;
}
/*
* For wrapmargin to hack away second space after a '.'
* when the first space caused a line break we keep
* track that this happened in gobblebl, which says
* to gobble up a blank silently.
*/
gobblebl = 0;
startsrcline = dot;
startsrccol = cursor - linebuf;
/*
* Text gathering loop.
* New text goes into genbuf starting at gcursor.
* cursor preserves place in linebuf where text will eventually go.
*/
if (*cursor == 0 || state == CRTOPEN)
hold |= HOLDROL;
for (;;) {
if (ch == 'r' && repcnt == 0)
escape = 0;
else {
ixlatctl(1);
/*
* When vgetline() returns, gcursor is
* pointing to '\0' and vgetline() has
* read an ESCAPE or NL.
*/
gcursor = vgetline(repcnt, gcursor, &escape, ch);
if (escape == '\n') {
gotNL = 1;
#ifdef XPG6
if (ch == 'r') {
/*
* XPG6 assertion 313 [count]r\n :
* Arrange to set cursor correctly.
*/
endsrccol = gcursor - genbuf - 1;
}
#endif /* XPG6 */
} else {
/*
* Upon escape, gcursor is pointing to '\0'
* terminating the string in genbuf.
*/
endsrccol = gcursor - genbuf - 1;
}
ixlatctl(0);
/*
* After an append, stick information
* about the ^D's and ^^D's and 0^D's in
* the repeated text buffer so repeated
* inserts of stuff indented with ^D as backtab's
* can work.
*/
if (HADUP)
addtext("^");
else if (HADZERO)
addtext("0");
if(!vglobp)
INSCDCNT = CDCNT;
while (CDCNT > 0) {
addtext("\004");
CDCNT--;
}
if (gobbled)
addtext(" ");
addtext(ogcursor);
}
repcnt = 0;
/*
* Smash the generated and preexisting indents together
* and generate one cleanly made out of tabs and spaces
* if we are using autoindent and this isn't 'r' command.
*/
if (!vaifirst && value(vi_AUTOINDENT)) {
i = fixindent(indent);
if (!HADUP)
indent = i;
gcursor = strend(genbuf);
}
/*
* Set cnt to 1 to avoid repeating the text on the same line.
* Do this for commands 'i', 'I', 'a', and 'A', if we're
* inserting anything with a newline for XPG6. Always do this
* for commands 'o' and 'O'.
*/
if ((imultlinecnt && gotNL) || omultlinecnt) {
cnt = 1;
}
/*
* Limit the repetition count based on maximum
* possible line length; do output implied
* by further count (> 1) and cons up the new line
* in linebuf.
*/
cnt = vmaxrep(ch, cnt);
/*
* cursor points to linebuf
* Copy remaining old text (cursor) in original
* line to after new text (gcursor + 1) in genbuf.
*/
CP(gcursor + 1, cursor);
/*
* For [count] r \n command, when replacing [count] chars
* with '\n', this loop replaces [count] chars with "".
*/
do {
/* cp new text (genbuf) into linebuf (cursor) */
CP(cursor, genbuf);
if (cnt > 1) {
int oldhold = hold;
Outchar = vinschar;
hold |= HOLDQIK;
viprintf("%s", genbuf);
hold = oldhold;
Outchar = vputchar;
}
/* point cursor after new text in linebuf */
cursor += gcursor - genbuf;
} while (--cnt > 0);
endim();
vUA2 = cursor;
/* add the remaining old text after the cursor */
if (escape != '\n')
CP(cursor, gcursor + 1);
/*
* If doomed characters remain, clobber them,
* and reopen the line to get the display exact.
* eg. c$ to change to end of line
*/
if (state != HARDOPEN) {
DEPTH(vcline) = 0;
savedoomed = doomed;
if (doomed > 0) {
int cind = cindent();
physdc(cind, cind + doomed);
doomed = 0;
}
if(MB_CUR_MAX > 1)
rewrite = _ON;
i = vreopen(LINE(vcline), lineDOT(), vcline);
if(MB_CUR_MAX > 1)
rewrite = _OFF;
#ifdef TRACE
if (trace)
fprintf(trace, "restoring doomed from %d to %d\n", doomed, savedoomed);
#endif
if (ch == 'R')
doomed = savedoomed;
}
/*
* Unless we are continuing on to another line
* (got a NL), break out of the for loop (got
* an ESCAPE).
*/
if (escape != '\n') {
vshowmode("");
break;
}
/*
* Set up for the new line.
* First save the current line, then construct a new
* first image for the continuation line consisting
* of any new autoindent plus the pushed ahead text.
*/
killU();
addtext(gobblebl ? " " : "\n");
/* save vutmp (for undo state) into temp file */
vsave();
cnt = 1;
if (value(vi_AUTOINDENT)) {
if (value(vi_LISP))
indent = lindent(dot + 1);
else
if (!HADUP && vaifirst)
indent = whitecnt(linebuf);
vaifirst = 0;
strcLIN(vpastwh(gcursor + 1));
gcursor = genindent(indent);
*gcursor = 0;
if (gcursor + strlen(linebuf) > &genbuf[LBSIZE - 2])
gcursor = genbuf;
CP(gcursor, linebuf);
} else {
/*
* Put gcursor at start of genbuf to wipe
* out previous line in preparation for
* the next vgetline() loop.
*/
CP(genbuf, gcursor + 1);
gcursor = genbuf;
}
/*
* If we started out as a single line operation and are now
* turning into a multi-line change, then we had better yank
* out dot before it changes so that undo will work
* correctly later.
*/
if (FIXUNDO && vundkind == VCHNG) {
vremote(1, yank, 0);
undap1--;
}
/*
* Now do the append of the new line in the buffer,
* and update the display, ie: append genbuf to
* the file after dot. If slowopen
* we don't do very much.
*/
vdoappend(genbuf);
vundkind = VMANYINS;
vcline++;
if (state != VISUAL)
vshow(dot, NOLINE);
else {
i += LINE(vcline - 1);
vopen(dot, i);
if (value(vi_SLOWOPEN))
vscrap();
else
vsync1(LINE(vcline));
}
switch (ch) {
case 'r':
break;
case 'a':
if (value(vi_TERSE)) {
vshowmode(gettext("A"));
} else {
vshowmode(gettext("APPEND MODE"));
}
break;
case 's':
if (value(vi_TERSE)) {
vshowmode(gettext("S"));
} else {
vshowmode(gettext("SUBSTITUTE MODE"));
}
break;
case 'c':
if (value(vi_TERSE)) {
vshowmode(gettext("C"));
} else {
vshowmode(gettext("CHANGE MODE"));
}
break;
case 'R':
if (value(vi_TERSE)) {
vshowmode(gettext("R"));
} else {
vshowmode(gettext("REPLACE MODE"));
}
break;
case 'i':
if (value(vi_TERSE)) {
vshowmode(gettext("I"));
} else {
vshowmode(gettext("INSERT MODE"));
}
break;
case 'o':
if (value(vi_TERSE)) {
vshowmode(gettext("O"));
} else {
vshowmode(gettext("OPEN MODE"));
}
break;
default:
if (value(vi_TERSE)) {
vshowmode(gettext("I"));
} else {
vshowmode(gettext("INPUT MODE"));
}
}
strcLIN(gcursor);
/* zero genbuf */
*gcursor = 0;
cursor = linebuf;
vgotoCL(nqcolumn(cursor - 1, genbuf));
} /* end for (;;) loop in vappend() */
if (imultlinecnt && gotNL) {
imultlinerep(savecnt, startsrcline, startsrccol, endsrccol);
} else if (omultlinecnt) {
omultlinerep(savecnt, startsrcline, endsrccol);
#ifdef XPG6
} else if (savecnt > 1 && ch == 'r' && gotNL) {
/*
* XPG6 assertion 313 & 254 : Position cursor for [count]r\n
* then insert [count -1] newlines.
*/
endsrccol = gcursor - genbuf - 1;
rmultlinerep(savecnt, endsrccol);
#endif /* XPG6 */
}
/*
* All done with insertion, position the cursor
* and sync the screen.
*/
hold = oldhold;
if ((imultlinecnt && gotNL) || omultlinecnt) {
fixdisplay();
#ifdef XPG6
} else if (savecnt > 1 && ch == 'r' && gotNL) {
fixdisplay();
/*
* XPG6 assertion 313 & 254 [count]r\n : Set flag to call
* fixdisplay() after operate() has finished. To be sure that
* the text (after the last \n followed by an indent) is always
* displayed, fixdisplay() is called right before getting
* the next command.
*/
redisplay = 1;
#endif /* XPG6 */
} else if (cursor > linebuf) {
cursor = lastchr(linebuf, cursor);
#ifdef XPG6
/*
* XPG6 assertion 313 & 254 [count]r\n :
* For 'r' command, when the replacement char causes new
* lines to be created, point cursor to first non-blank.
* The old code, ie: cursor = lastchr(linebuf, cursor);
* set cursor to the blank before the first non-blank
* for r\n
*/
if (ch == 'r' && gotNL && isblank((int)*cursor))
++cursor;
#endif /* XPG6 */
}
if (state != HARDOPEN)
vsyncCL();
else if (cursor > linebuf)
back1();
doomed = 0;
wcursor = cursor;
(void) vmove();
}
