static void cfollow(B *b, VT *vt, off_t byte)
{
W *w;
int xn;
if (vt && piscol(vt->vtcur) >= vt->width)
xn = 1; /* xn glitch: cursor is past end of line */
else
xn = 0;
if (b->oldcur && b->shell_flag) {
b->shell_flag = 0;
pgoto(b->oldcur, byte);
b->oldcur->xcol = piscol(b->oldcur);
if (xn)
b->oldcur->xcol = vt->width - 1;
}
if ((w = maint->topwin) != NULL) {
do {
if (w->watom->what & TYPETW) {
BW *bw = (BW *)w->object;
if (bw->shell_flag) {
bw->shell_flag = 0;
pgoto(bw->cursor, byte);
bw->cursor->xcol = piscol(bw->cursor);
if (xn)
bw->cursor->xcol = vt->width - 1;
if (vt && bw->top->line != vt->top->line && (1 + vt->vtcur->line - vt->top->line) <= bw->h)
pline(bw->top, vt->top->line);
dofollows();
}
}
w = w->link.next;
} while (w != maint->topwin);
}
}
int ucenter(BW *bw)
{
P *p = bw->cursor, *q;
long endcol, begcol, x;
int c;
p_goto_eol(p);
while (joe_isblank(bw->b->o.charmap, (c = prgetc(p))))
/* do nothing */;
if (c == '\n') {
pgetc(p);
goto done;
}
if (c == NO_MORE_DATA)
goto done;
pgetc(p);
endcol = piscol(p);
p_goto_bol(p);
while (joe_isblank(bw->b->o.charmap, (c = pgetc(p))))
/* do nothing */;
if (c == '\n') {
prgetc(p);
goto done;
}
if (c == NO_MORE_DATA)
goto done;
prgetc(p);
begcol = piscol(p);
if (endcol - begcol > bw->o.rmargin + bw->o.lmargin)
goto done;
q = pdup(p, USTR "ucenter");
p_goto_bol(q);
bdel(q, p);
prm(q);
for (x = 0; x != (bw->o.lmargin + bw->o.rmargin) / 2 - (endcol - begcol) / 2; ++x)
binsc(p, ' ');
done:
if (!pnextl(p)) {
binsc(p, '\n');
pgetc(p);
return -1;
} else
return 0;
}
static long prefix(BW *bw, P *p,int up)
{
long len;
P *q = pdup(p, USTR "prefix");
p_goto_bol(q);
while (cpara(bw, brch(q)))
pgetc(q);
while (!pisbol(q)) {
/* int c; */
if (!joe_isblank(p->b->o.charmap, ( /* c = */ prgetc(q)))) {
/*
if (up && (c == '*' || c == '-')) {
if (!pisbol(q)) {
c = prgetc(q);
pgetc(q);
if (c == ' ' || c == '\t')
goto skip;
} else
goto skip;
}
pgetc(q);
*/
break;
/* skip:; */
}
}
len = piscol(q);
prm(q);
return len;
}
int utag(BW *bw)
{
BW *pbw;
pbw = wmkpw(bw->parent, joe_gettext(_("Tag search: ")), &taghist, dotag, NULL, NULL, tag_cmplt, NULL, NULL, locale_map, 0);
if (pbw && joe_isalnum_(bw->b->o.charmap,brch(bw->cursor))) {
P *p = pdup(bw->cursor, "utag");
P *q = pdup(p, "utag");
int c;
while (joe_isalnum_(bw->b->o.charmap,(c = prgetc(p))))
/* do nothing */;
if (c != NO_MORE_DATA) {
pgetc(p);
}
pset(q, p);
while (joe_isalnum_(bw->b->o.charmap,(c = pgetc(q))))
/* do nothing */;
if (c != NO_MORE_DATA) {
prgetc(q);
}
binsb(pbw->cursor, bcpy(p, q));
pset(pbw->cursor, pbw->b->eof);
pbw->cursor->xcol = piscol(pbw->cursor);
prm(p);
prm(q);
}
if (pbw) {
return 0;
} else {
return -1;
}
}
static void cfollow(B *b,long byte)
{
W *w;
if ((w = maint->topwin) != NULL) {
do {
if ((w->watom->what&TYPETW) && ((BW *)w->object)->b==b && ((BW *)w->object)->cursor->byte==byte) {
BW *bw = (BW *)w->object;
p_goto_eof(bw->cursor);
bw->cursor->xcol = piscol(bw->cursor);
}
w = w->link.next;
} while (w != maint->topwin);
}
}
static void disppw(BW *bw, int flg)
{
W *w = bw->parent;
PW *pw = (PW *) bw->object;
if (!flg) {
return;
}
/* Scroll buffer and position prompt */
if (pw->promptlen > w->w - 5) {
pw->promptofst = pw->promptlen - w->w / 2;
if (piscol(bw->cursor) < w->w - (pw->promptlen - pw->promptofst)) {
bw->offset = 0;
} else {
bw->offset = piscol(bw->cursor) - (w->w - (pw->promptlen - pw->promptofst) - 1);
}
} else {
if (piscol(bw->cursor) < w->w - pw->promptlen) {
pw->promptofst = 0;
bw->offset = 0;
} else if (piscol(bw->cursor) >= w->w) {
pw->promptofst = pw->promptlen;
bw->offset = piscol(bw->cursor) - (w->w - 1);
} else {
pw->promptofst = pw->promptlen - (w->w - piscol(bw->cursor) - 1);
bw->offset = piscol(bw->cursor) - (w->w - (pw->promptlen - pw->promptofst) - 1);
}
}
/* Set cursor position */
w->curx = piscol(bw->cursor) - bw->offset + pw->promptlen - pw->promptofst;
w->cury = 0;
/* Generate prompt */
w->t->t->updtab[w->y] = 1;
genfmt(w->t->t, w->x, w->y, pw->promptofst, pw->prompt, BG_COLOR(bg_prompt), 0);
/* Position and size buffer */
bwmove(bw, w->x + pw->promptlen - pw->promptofst, w->y);
bwresz(bw, w->w - (pw->promptlen - pw->promptofst), 1);
/* Generate buffer */
bwgen(bw, 0);
}
int jump_to_file_line(BW *bw,unsigned char *file,int line,unsigned char *msg)
{
int omid;
if (!bw->b->name || zcmp(file, bw->b->name)) {
if (doswitch(bw, vsdup(file), NULL, NULL))
return -1;
bw = (BW *) maint->curwin->object;
}
omid = mid;
mid = 1;
pline(bw->cursor, line);
dofollows();
mid = omid;
bw->cursor->xcol = piscol(bw->cursor);
msgnw(bw->parent, msg);
return 0;
}
int ubuild(BW *bw)
{
if (buildhist) {
if ((bw=wmkpw(bw->parent, joe_gettext(_("Build command: ")), &buildhist, dobuild, USTR "Run", NULL, NULL, NULL, NULL, locale_map, 1))) {
uuparw(bw);
u_goto_eol(bw);
bw->cursor->xcol = piscol(bw->cursor);
return 0;
} else {
return -1;
}
} else {
if (wmkpw(bw->parent, joe_gettext(_("Enter build command (for example, 'make'): ")), &buildhist, dobuild, USTR "Run", NULL, NULL, NULL, NULL, locale_map, 1)) {
return 0;
} else {
return -1;
}
}
}
int ugrep(BW *bw)
{
/* Set parser to grep */
bw->b->parseone = parseone_grep;
if (grephist) {
if ((bw=wmkpw(bw->parent, joe_gettext(_("Grep command: ")), &grephist, dobuild, USTR "Run", NULL, NULL, NULL, NULL, locale_map, 1))) {
uuparw(bw);
u_goto_eol(bw);
bw->cursor->xcol = piscol(bw->cursor);
return 0;
} else {
return -1;
}
} else {
if (wmkpw(bw->parent, joe_gettext(_("Enter grep command (for example, 'grep -n foo *.c'): ")), &grephist, dobuild, USTR "Run", NULL, NULL, NULL, NULL, locale_map, 1)) {
return 0;
} else {
return -1;
}
}
}
/* When called with c==-1, it just creates the prompt */
static int itype(W *w, int c, void *obj, int *notify)
{
IREC *i;
int omid;
BW *bw;
struct isrch *isrch = (struct isrch *)obj;
WIND_BW(bw,w);
if (isrch->quote) {
goto in;
}
if (c == 8 || c == 127) { /* Backup */
if ((i = isrch->irecs.link.prev) != &isrch->irecs) {
pgoto(bw->cursor, i->disp);
if (globalsrch)
globalsrch->wrap_flag = i->wrap_flag;
omid = opt_mid;
opt_mid = 1;
dofollows();
opt_mid = omid;
isrch->pattern = vstrunc(isrch->pattern, sLEN(isrch->pattern) - i->what);
frirec(deque_f(IREC, link, i));
} else {
if(joe_beep)
ttputc(7);
}
} else if (c == 'Q' - '@' /* || c == '`' */) {
isrch->quote = 1;
} else if (c == 'S' - '@' || c == '\\' - '@' || c == 'L' - '@' || c == 'R' - '@') {
/* Repeat */
if (c == 'R' - '@') {
isrch->dir = 1;
} else {
isrch->dir = 0;
}
if (qempty(IREC, link, &isrch->irecs)) {
if (lastpat && lastpat[0]) {
iappend(bw, isrch, sv(lastpat));
}
} else {
SRCH *srch;
i = alirec();
i->disp = i->start = bw->cursor->byte;
i->what = 0;
if (!globalsrch)
srch = mksrch(NULL,NULL,opt_icase,isrch->dir,-1,0,0,0,0);
else {
srch = globalsrch;
globalsrch = 0;
}
srch->addr = bw->cursor->byte;
if (!srch->wrap_p || srch->wrap_p->b!=bw->b) {
prm(srch->wrap_p);
srch->wrap_p = pdup(bw->cursor, "itype");
srch->wrap_p->owner = &srch->wrap_p;
srch->wrap_flag = 0;
}
i->wrap_flag = srch->wrap_flag;
setpat(srch, vsncpy(NULL, 0, isrch->pattern, sLen(isrch->pattern)));
srch->backwards = isrch->dir;
if (dopfnext(bw, srch, NULL)) {
if(joe_beep)
ttputc(7);
frirec(i);
} else {
enqueb(IREC, link, &isrch->irecs, i);
}
}
} else if (c >= 0 && c < 32) {
/* Done when a control character is received */
nungetc(c);
if (notify) {
*notify = 1;
}
smode = 2;
if (lastisrch) {
lastpat = vstrunc(lastpat, 0);
lastpat = vsncpy(lastpat, 0, lastisrch->pattern, sLen(lastisrch->pattern));
rmisrch(lastisrch);
}
lastisrch = isrch;
return 0;
} else if (c != -1) {
char buf[16];
ptrdiff_t buf_len;
/* Search */
in:
if (bw->b->o.charmap->type) {
buf_len = utf8_encode(buf, c);
} else {
buf[0] = TO_CHAR_OK(from_uni(bw->b->o.charmap, c));
buf_len = 1;
}
isrch->quote = 0;
iappend(bw, isrch, buf, buf_len);
}
omid = opt_mid;
opt_mid = 1;
bw->cursor->xcol = piscol(bw->cursor);
dofollows();
opt_mid = omid;
isrch->prompt = vstrunc(isrch->prompt, isrch->ofst);
if (locale_map->type && !bw->b->o.charmap->type) {
/* Translate bytes to utf-8 */
char buf[16];
int x;
for (x=0; x!=sLEN(isrch->pattern); ++x) {
int tc = to_uni(bw->b->o.charmap, isrch->pattern[x]);
utf8_encode(buf, tc);
isrch->prompt = vsncpy(sv(isrch->prompt),sz(buf));
}
} else if (!locale_map->type && bw->b->o.charmap->type) {
/* Translate utf-8 to bytes */
const char *p = isrch->pattern;
ptrdiff_t len = sLEN(isrch->pattern);
while (len) {
int tc = utf8_decode_fwrd(&p, &len);
if (tc >= 0) {
tc = from_uni(locale_map, tc);
isrch->prompt = vsadd(isrch->prompt, TO_CHAR_OK(tc));
}
}
} else {
/* FIXME: translate when charmaps do not match */
isrch->prompt = vsncpy(sv(isrch->prompt),sv(isrch->pattern));
}
if (mkqwnsr(bw->parent, sv(isrch->prompt), itype, iabrt, isrch, notify)) {
return 0;
} else {
rmisrch(isrch);
return -1;
}
}
int uformat(BW *bw)
{
long indent;
unsigned char *indents;
B *buf;
P *b;
long curoff;
int c;
P *p, *q;
p = pdup(bw->cursor, USTR "uformat");
p_goto_bol(p);
/* Do nothing if we're not on a paragraph line */
if (pisnpara(bw, p)) {
prm(p);
return 0;
}
/* Move p to beginning of paragraph, bw->cursor to end of paragraph and
* set curoff to original cursor offset within the paragraph */
pbop(bw, p);
curoff = bw->cursor->byte - p->byte;
pset(bw->cursor, p);
peop(bw, bw->cursor);
/* Ensure that paragraph ends on a beginning of a line */
if (!pisbol(bw->cursor))
binsc(bw->cursor, '\n'), pgetc(bw->cursor);
/* Record indentation of second line of paragraph, of first line if there
* is only one line */
q = pdup(p, USTR "uformat");
pnextl(q);
if (q->line != bw->cursor->line) {
P *r = pdup(q, USTR "uformat");
indent = nindent(bw, q, 0);
pcol(r, indent);
indents = brs(q, r->byte - q->byte);
prm(r);
} else {
P *r = pdup(p, USTR "uformat");
int x, y;
indent = nindent(bw, p, 1); /* allowing * and - here */
pcol(r, indent);
indents = brs(p, r->byte - p->byte);
prm(r);
if (!bw->o.autoindent) {
/* Don't indent second line of single-line paragraphs if autoindent is off */
int x = zlen(indents);
while (x && (indents[x - 1] == ' ' || indents[x - 1] == '\t'))
indents[--x] = 0;
if (x) {
indents[x++] = ' ';
indents[x] = 0;
}
indent = txtwidth1(bw->o.charmap, bw->o.tab, indents, x);
}
for (x = 0; indents[x] && (indents[x] == ' ' || indents[x] == '\t'); ++x);
y = zlen(indents);
while (y && (indents[y - 1] == ' ' || indents[y - 1] == '\t'))
--y;
/* Don't duplicate if it looks like a bullet */
/* if (y && (indents[y - 1] == '*' || indents[y - 1] == '-') &&
(y == 1 || indents[y - 2] == ' ' || indents[y - 2] == '\t'))
indents[y - 1] = ' '; */
/* Fix C comment */
if (indents[x] == '/' && indents[x + 1] == '*')
indents[x] = ' ';
}
prm(q);
/* But if the left margin is greater, we use that instead */
if (bw->o.lmargin > indent) {
int x;
for (x = 0; indents[x] == ' ' || indents[x] == '\t'; ++x);
if (!indents[x]) {
joe_free(indents);
indent = bw->o.lmargin;
indents = joe_malloc(indent+1);
for (x = 0; x != indent; ++x)
indents[x] = ' ';
indents[x] = 0;
}
}
/* Cut paragraph into new buffer */
/* New buffer needs to inherit UTF-8 and CR-LF options */
buf = bcpy(p, bw->cursor);
buf->o.crlf = p->b->o.crlf;
buf->o.charmap = p->b->o.charmap;
bdel(p, bw->cursor);
/* text is in buffer. insert it at cursor */
/* Do first line */
b = pdup(buf->bof, USTR "uformat");
while (!piseof(b)) {
/* Set cursor position if we're at original offset */
if (b->byte == curoff)
pset(bw->cursor, p);
/* Get character from buffer */
c = pgetc(b);
/* Stop if we found end of line */
if (c == '\n') {
prgetc(b);
break;
}
/* Stop if we found white-space followed by end of line */
if (joe_isblank(b->b->o.charmap, c) && piseolblank(b)) {
prgetc(b);
break;
}
/* Insert character, advance pointer */
binsc(p, c);
pgetc(p);
/* Do word wrap if we reach right margin */
if (piscol(p) > bw->o.rmargin && !joe_isblank(p->b->o.charmap,c)) {
wrapword(bw, p, indent, bw->o.french, 1, indents);
break;
}
}
/* Do rest */
while (!piseof(b)) {
c = brch(b);
if (joe_isblank(b->b->o.charmap,c) || c == '\n') {
int f = 0;
P *d;
int g;
/* Set f if there are two spaces after . ? or ! instead of one */
/* (What is c was '\n'?) */
d=pdup(b, USTR "uformat");
g=prgetc(d);
if (g=='.' || g=='?' || g=='!') {
f = 1;
/* pset(d,b);
pgetc(d);
if (c == '\n' || piseol(d) || joe_isspace(bw->b->o.charmap,brch(d))) {
f = 1;
}
*/
}
prm(d);
/* Skip past the whitespace. Skip over indentations */
loop:
c = brch(b);
if (c == '\n') {
if (b->byte == curoff)
pset(bw->cursor, p);
pgetc(b);
while (cpara(bw, (c=brch(b)))) {
if (b->byte == curoff)
pset(bw->cursor, p);
pgetc(b);
}
}
if (joe_isblank(b->b->o.charmap,c)) {
if(b->byte == curoff)
pset(bw->cursor, p);
pgetc(b);
goto loop;
}
/* Insert proper amount of whitespace */
if (!piseof(b)) {
if (f && !bw->o.french)
binsc(p, ' '), pgetc(p);
binsc(p, ' ');
pgetc(p);
}
} else {
/* Insert characters of word and wrap if necessary */
if (b->byte == curoff)
pset(bw->cursor, p);
binsc(p, pgetc(b));
pgetc(p);
if (piscol(p) > bw->o.rmargin)
wrapword(bw, p, indent, bw->o.french, 1, indents);
}
}
binsc(p, '\n');
prm(p);
brm(buf);
joe_free(indents);
return 0;
}
void wrapword(BW *bw, P *p, long int indent, int french, int no_over, unsigned char *indents)
{
P *q;
P *r;
P *s;
int rmf = 0;
int c;
long to = p->byte;
int my_indents = 0;
/* autoindent when called by utype */
if (!indents) {
/* Get indentation prefix from beginning of line */
s = pdup(p, USTR "wrapword");
p_goto_bol(s);
pbop(bw, s);
/* Record indentation of second line of paragraph, of first
* line if there is only one line */
q = pdup(s, USTR "wrapword");
pnextl(q);
if (q->line < p->line) {
/* Second line */
P *r = pdup(q, USTR "wrapword");
indent = nindent(bw, q, 0);
pcol(r, indent);
indents = brs(q, r->byte - q->byte);
prm(r);
} else {
/* First line */
P *r = pdup(s, USTR "uformat");
int x, y;
indent = nindent(bw, s, 1);
pcol(r, indent);
indents = brs(s, r->byte - s->byte);
prm(r);
if (!bw->o.autoindent) {
/* Don't indent second line of single-line paragraphs if autoindent is off */
int x = zlen(indents);
while (x && (indents[x - 1] == ' ' || indents[x - 1] == '\t'))
indents[--x] = 0;
if (x) {
indents[x++] = ' ';
indents[x] = 0;
}
indent = txtwidth1(bw->o.charmap, bw->o.tab, indents, x);
}
for (x = 0; indents[x] && (indents[x] == ' ' || indents[x] == '\t'); ++x);
y = zlen(indents);
while (y && (indents[y - 1] == ' ' || indents[y - 1] == '\t'))
--y;
/* Don't duplicate bullet */
/* if (y && (indents[y - 1] == '*' || indents[y - 1] == '-') &&
(y == 1 || indents[y - 2] == ' ' || indents[y - 2] == '\t'))
indents[y - 1] = ' '; */
/* Fix C comment */
if (indents[x] == '/' && indents[x + 1] == '*')
indents[x] = ' ';
}
if (bw->o.lmargin > indent) {
int x;
for (x = 0; indents[x] == ' ' || indents[x] == '\t'; ++x);
if (!indents[x]) {
joe_free(indents);
indent = bw->o.lmargin;
indents = joe_malloc(indent+1);
for (x = 0; x != indent; ++x)
indents[x] = ' ';
indents[x] = 0;
}
}
my_indents = 1;
prm(q);
prm(s);
}
/*
if(!indents) {
int f = 0;
P *r = pdup(p);
p_goto_bol(r);
q = pdup(r);
while(cpara(c = brc(q))) {
if(!joe_isblank(c))
f = 1;
pgetc(q);
}
if(f) {
indents = brs(r, q->byte-r->byte);
rmf = 1;
if(indents[0] == '/' && indents[1] == '*')
indents[0] = ' ';
}
prm(r);
prm(q);
}
*/
/* Get to beginning of word */
while (!pisbol(p) && piscol(p) > indent && !joe_isblank(p->b->o.charmap, prgetc(p)))
/* do nothing */;
/* If we found the beginning of a word... */
if (!pisbol(p) && piscol(p) > indent) {
/* Move q to two (or one if 'french' is set) spaces after end of previous
word */
q = pdup(p, USTR "wrapword");
while (!pisbol(q))
if (!joe_isblank(p->b->o.charmap, (c = prgetc(q)))) {
pgetc(q);
if ((c == '.' || c == '?' || c == '!')
&& q->byte != p->byte && !french)
pgetc(q);
break;
}
pgetc(p);
/* Delete space between start of word and end of previous word */
to -= p->byte - q->byte;
bdel(q, p);
prm(q);
if (bw->o.flowed) {
binsc(p, ' ');
pgetc(p);
++to;
}
/* Move word to beginning of next line */
binsc(p, '\n');
/* When overtype is on, do not insert lines */
if (!no_over && p->b->o.overtype){
/* delete the next line break which is unnecessary */
r = pdup(p, USTR "wrapword");
/* p_goto_eol(r); */
pgetc(r);
p_goto_eol(r);
s = pdup(r, USTR "wrapword");
pgetc(r);
bdel(s,r);
binsc(r, ' ');
/* Now we got to take care that all subsequent lines are not longer than the right margin */
/* Move cursor to right margin */
pfwrd(r, r->b->o.rmargin - r->col);
/* Make a copy of the cursor and move the copied cursor to the end of the line */
prm(s);
s = pdup(r, USTR "wrapword");
p_goto_eol(s);
/* If s is located behind r then the line goes beyond the right margin and we need to call wordwrap() for that line. */
/*
if (r->byte < s->byte){
wrapword(bw, r, indent, french, 1, indents);
}
*/
prm(r);
prm(s);
}
++to;
if (p->b->o.crlf)
++to;
pgetc(p);
/* Indent to left margin */
if (indents) {
binss(p, indents);
to += zlen(indents);
} else
while (indent--) {
binsc(p, ' ');
++to;
}
if (rmf)
joe_free(indents);
}
/* Move cursor back to original position */
pfwrd(p, to - p->byte);
if (my_indents)
joe_free(indents);
}
int execmd(CMD *cmd, int k)
{
BW *bw = (BW *) maint->curwin->object;
int ret = -1;
/* Warning: bw is a BW * only if maint->curwin->watom->what &
(TYPETW|TYPEPW) */
#if junk
/* Send data to shell window: this is broken ^K ^H (help) sends its ^H to shell */
if ((maint->curwin->watom->what & TYPETW) && bw->b->pid && !bw->b->vt && piseof(bw->cursor) &&
(k==3 || k==9 || k==13 || k==8 || k==127 || k==4 || (cmd->func==utype /* && k>=32 && k<256 */))) {
unsigned char c = k;
joe_write(bw->b->out, &c, 1);
return 0;
}
#endif
if (cmd->m)
return exmacro(cmd->m, 0);
/* We don't execute if we have to fix the column position first
* (i.e., left arrow when cursor is in middle of nowhere) */
if (cmd->flag & ECHKXCOL) {
if (bw->o.hex)
bw->cursor->xcol = piscol(bw->cursor);
else if (bw->cursor->xcol != piscol(bw->cursor))
goto skip;
}
/* Don't execute command if we're in wrong type of window */
if (!(cmd->flag & maint->curwin->watom->what))
goto skip;
/* Complete selection for block commands */
if ((cmd->flag & EBLOCK) && nowmarking)
utoggle_marking(maint->curwin->object);
/* We are about to modify the file */
if ((maint->curwin->watom->what & TYPETW) && (cmd->flag & EMOD)) {
if (!modify_logic(bw,bw->b))
goto skip;
}
/* Execute command */
ret = cmd->func(maint->curwin->object, k);
if (smode)
--smode;
/* Don't update anything if we're going to leave */
if (leave)
return 0;
/* cmd->func could have changed bw on us */
/* This is bad: maint->curwin might not be the same window */
/* Safer would be to attach a pointer to curwin- if curwin
gets clobbered, so does pointer. */
bw = (BW *) maint->curwin->object;
/* Maintain position history */
/* If command was not a positioning command */
if (!(cmd->flag & EPOS)
&& (maint->curwin->watom->what & (TYPETW | TYPEPW)))
afterpos();
/* If command was not a movement */
if (!(cmd->flag & (EMOVE | EPOS)) && (maint->curwin->watom->what & (TYPETW | TYPEPW)))
aftermove(maint->curwin, bw->cursor);
if (cmd->flag & EKILL)
justkilled = 1;
else
justkilled = 0;
skip:
/* Make dislayed cursor column equal the actual cursor column
* for commands which arn't simple vertical movements */
if ((cmd->flag & EFIXXCOL) && (maint->curwin->watom->what & (TYPETW | TYPEPW)))
bw->cursor->xcol = piscol(bw->cursor);
/* Recenter cursor to middle of screen */
if (cmd->flag & EMID) {
int omid = mid;
mid = 1;
dofollows();
mid = omid;
}
if (joe_beep && ret)
ttputc(7);
return ret;
}
static int dotag(BW *bw, unsigned char *s, void *obj, int *notify)
{
unsigned char buf[512];
unsigned char buf1[512];
FILE *f;
unsigned char *t = NULL;
if (notify) {
*notify = 1;
}
if (bw->b->name) {
t = vsncpy(t, 0, sz(bw->b->name));
t = vsncpy(sv(t), sc(":"));
t = vsncpy(sv(t), sv(s));
}
/* first try to open the tags file in the current directory */
f = fopen("tags", "r");
if (!f) {
/* if there's no tags file in the current dir, then query
for the environment variable TAGS.
*/
char *tagspath = getenv("TAGS");
if(tagspath){
f = fopen(tagspath, "r");
}
if(!f){
msgnw(bw->parent, joe_gettext(_("Couldn't open tags file")));
vsrm(s);
vsrm(t);
return -1;
}
}
while (fgets((char *)buf, 512, f)) {
int x, y, c;
for (x = 0; buf[x] && buf[x] != ' ' && buf[x] != '\t'; ++x) ;
c = buf[x];
buf[x] = 0;
if (!strcmp(s, buf) || (t && !strcmp(t, buf))) {
buf[x] = c;
while (buf[x] == ' ' || buf[x] == '\t') {
++x;
}
for (y = x; buf[y] && buf[y] != ' ' && buf[y] != '\t' && buf[y] != '\n'; ++y) ;
if (x != y) {
c = buf[y];
buf[y] = 0;
if (doswitch(bw, vsncpy(NULL, 0, sz(buf + x)), NULL, NULL)) {
vsrm(s);
vsrm(t);
fclose(f);
return -1;
}
bw = (BW *) maint->curwin->object;
p_goto_bof(bw->cursor);
buf[y] = c;
while (buf[y] == ' ' || buf[y] == '\t') {
++y;
}
for (x = y; buf[x] && buf[x] != '\n'; ++x) ;
buf[x] = 0;
if (x != y) {
long line = 0;
if (buf[y] >= '0' && buf[y] <= '9') {
/* It's a line number */
sscanf((char *)(buf + y), "%ld", &line);
if (line >= 1) {
int omid = mid;
mid = 1;
pline(bw->cursor, line - 1), bw->cursor->xcol = piscol(bw->cursor);
dofollows();
mid = omid;
} else {
msgnw(bw->parent, joe_gettext(_("Invalid line number")));
}
} else {
int z = 0;
/* It's a search string. New versions of
ctags have real regex with vi command. Old
ones do not always quote / and depend on it
being last char on line. */
if (buf[y] == '/' || buf[y] == '?') {
int ch = buf[y++];
/* Find terminating / or ? */
for (x = y + strlen(buf + y); x != y; --x)
if (buf[x] == ch)
break;
/* Copy characters, convert to JOE regex... */
if (buf[y] == '^') {
buf1[z++] = '\\';
buf1[z++] = '^';
++y;
}
while (buf[y] && buf[y] != '\n' && !(buf[y] == ch && y == x)) {
if (buf[y] == '$' && buf[y+1] == ch) {
++y;
buf1[z++] = '\\';
buf1[z++] = '$';
} else if (buf[y] == '\\' && buf[y+1]) {
/* This is going to cause problem...
old ctags did not have escape */
++y;
if (buf[y] == '\\')
buf1[z++] = '\\';
buf1[z++] = buf[y++];
} else {
buf1[z++] = buf[y++];
}
}
}
if (z) {
vsrm(s);
vsrm(t);
fclose(f);
buf1[z] = 0;
return dopfnext(bw, mksrch(vsncpy(NULL, 0, sz(buf1)), NULL, 0, 0, -1, 0, 0, 0), NULL);
}
}
}
vsrm(s);
vsrm(t);
fclose(f);
return 0;
}
}
}
msgnw(bw->parent, joe_gettext(_("Not found")));
vsrm(s);
vsrm(t);
fclose(f);
return -1;
}
