/* Opens new bw with startup log */
int ushowlog(BW *bw)
{
if (startup_log) {
B *copied;
BW *newbw;
void *object;
W *w;
if (uduptw(bw)) {
return -1;
}
copied = bcpy(startup_log->bof, startup_log->eof);
copied->name = zdup(USTR "* Startup Log *");
copied->internal = 1;
newbw = (BW *) maint->curwin->object;
object = newbw->object;
w = newbw->parent;
bwrm(newbw);
w->object = (void *) (newbw = bwmk(w, copied, 0));
wredraw(newbw->parent);
newbw->object = object;
return 0;
}
return 1;
}
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 doundo(BW *bw, UNDOREC *ptr)
{
dostaupd = 1;
if (ptr->del) {
if (ptr->len < SMALL)
binsm(bw->cursor, ptr->small, (int) ptr->len);
else {
B *b = ptr->big;
bonline(b);
binsb(bw->cursor, bcpy(b->bof, b->eof));
boffline(b);
}
} else {
P *q = pdup(bw->cursor, "doundo");
pfwrd(q, ptr->len);
bdel(bw->cursor, q);
prm(q);
}
if (bw->b->changed && !ptr->changed)
bw_unlock(bw);
bw->b->changed = ptr->changed;
}
int ucopy(BW *bw)
{
if (markv(1) && !square) {
B *b = bcpy(markb, markk);
yankdel(markb->byte, b);
brm(b);
if (lightoff)
unmark(bw);
return 0;
} else {
msgnw(bw->parent, joe_gettext(_("No block")));
return -1;
}
}
void promote_history(B *hist, long line)
{
P *q = pdup(hist->bof, USTR "promote_history");
P *r;
P *t;
pline(q, line);
r = pdup(q, USTR "promote_history");
pnextl(r);
t = pdup(hist->eof, USTR "promote_history");
binsb(t, bcpy(q, r));
bdel(q, r);
prm(q);
prm(r);
prm(t);
}
int uyank(BW *bw)
{
UNDOREC *ptr = yanked.link.prev;
if (ptr != &yanked) {
if (ptr->len < SMALL)
binsm(bw->cursor, ptr->small, (int) ptr->len);
else {
B *b = ptr->big;
bonline(b);
binsb(bw->cursor, bcpy(b->bof, b->eof));
boffline(b);
}
pfwrd(bw->cursor, ptr->len);
yankbuf = bw->b;
yankwhere = bw->cursor->byte;
return 0;
} else
return -1;
}
void
solve(const ScalarBCRSMatrix& A,
const ScalarBlockVector& b,
ScalarBlockVector& x) {
Dune::MatrixAdapter<ScalarBCRSMatrix,
ScalarBlockVector,
ScalarBlockVector> opA(A);
Dune::SeqILU0<ScalarBCRSMatrix,
ScalarBlockVector,
ScalarBlockVector> precond(A, 1.0);
int maxit = A.N();
double tol = 5.0e-7;
int verb = 0;
Dune::BiCGSTABSolver<ScalarBlockVector>
solver(opA, precond, tol, maxit, verb);
ScalarBlockVector bcpy(b);
Dune::InverseOperatorResult res;
solver.apply(x, bcpy, res);
}
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;
}
int main(int argc, char **real_argv, char **envv)
{
CAP *cap;
unsigned char **argv = (unsigned char **)real_argv;
struct stat sbuf;
unsigned char *s;
unsigned char *t;
long time_rc;
unsigned char *run;
#ifdef __MSDOS__
unsigned char *rundir;
#endif
SCRN *n;
int opened = 0;
int omid;
int backopt;
int c;
joe_locale();
mainenv = (unsigned char **)envv;
vmem = vtmp();
startup_log = bfind_scratch(USTR "* Startup Log *");
startup_log->internal = 1;
#ifdef __MSDOS__
_fmode = O_BINARY;
zlcpy(stdbuf, sizeof(stdbuf), argv[0]);
joesep(stdbuf);
run = namprt(stdbuf);
rundir = dirprt(stdbuf);
for (c = 0; run[c]; ++c)
if (run[c] == '.') {
run = vstrunc(run, c);
break;
}
#else
run = namprt(argv[0]);
#endif
if ((s = (unsigned char *)getenv("LINES")) != NULL)
sscanf((char *)s, "%d", &lines);
if ((s = (unsigned char *)getenv("COLUMNS")) != NULL)
sscanf((char *)s, "%d", &columns);
if ((s = (unsigned char *)getenv("BAUD")) != NULL)
sscanf((char *)s, "%u", (unsigned *)&Baud);
if (getenv("DOPADDING"))
dopadding = 1;
if (getenv("NOXON"))
noxon = 1;
if ((s = (unsigned char *)getenv("JOETERM")) != NULL)
joeterm = s;
#ifndef __MSDOS__
if (!(cap = my_getcap(NULL, 9600, NULL, NULL))) {
logerror_0((char *)joe_gettext(_("Couldn't load termcap/terminfo entry\n")));
goto exit_errors;
}
#endif
#ifdef __MSDOS__
s = vsncpy(NULL, 0, sv(run));
s = vsncpy(sv(s), sc("rc"));
c = procrc(cap, s);
if (c == 0)
goto donerc;
if (c == 1) {
logerror_1((char *)joe_gettext(_("There were errors in '%s'. Falling back on default.\n")), s);
}
vsrm(s);
s = vsncpy(NULL, 0, sv(rundir));
s = vsncpy(sv(s), sv(run));
s = vsncpy(sv(s), sc("rc"));
c = procrc(cap, s);
if (c == 0)
goto donerc;
if (c == 1) {
logerror_1((char *)joe_gettext(_("There were errors in '%s'. Falling back on default.\n")), s);
}
#else
/* Name of system joerc file. Try to find one with matching language... */
/* Try full language: like joerc.de_DE */
t = vsncpy(NULL, 0, sc(JOERC));
t = vsncpy(sv(t), sv(run));
t = vsncpy(sv(t), sc("rc."));
t = vsncpy(sv(t), sz(locale_msgs));
if (!stat((char *)t,&sbuf))
time_rc = sbuf.st_mtime;
else {
/* Try generic language: like joerc.de */
if (locale_msgs[0] && locale_msgs[1] && locale_msgs[2]=='_') {
vsrm(t);
t = vsncpy(NULL, 0, sc(JOERC));
t = vsncpy(sv(t), sv(run));
t = vsncpy(sv(t), sc("rc."));
t = vsncpy(sv(t), locale_msgs, 2);
if (!stat((char *)t,&sbuf))
time_rc = sbuf.st_mtime;
else
goto nope;
} else {
nope:
vsrm(t);
/* Try Joe's bad english */
t = vsncpy(NULL, 0, sc(JOERC));
t = vsncpy(sv(t), sv(run));
t = vsncpy(sv(t), sc("rc"));
if (!stat((char *)t,&sbuf))
time_rc = sbuf.st_mtime;
else
time_rc = 0;
}
}
/* User's joerc file */
s = (unsigned char *)getenv("HOME");
if (s) {
s = vsncpy(NULL, 0, sz(s));
s = vsncpy(sv(s), sc("/."));
s = vsncpy(sv(s), sv(run));
s = vsncpy(sv(s), sc("rc"));
if (!stat((char *)s,&sbuf)) {
if (sbuf.st_mtime < time_rc) {
logmessage_2((char *)joe_gettext(_("Warning: %s is newer than your %s.\n")),t,s);
}
}
c = procrc(cap, s);
if (c == 0) {
vsrm(t);
goto donerc;
}
if (c == 1) {
logerror_1((char *)joe_gettext(_("There were errors in '%s'. Falling back on default.\n")), s);
}
}
vsrm(s);
s = t;
c = procrc(cap, s);
if (c == 0)
goto donerc;
if (c == 1) {
logerror_1((char *)joe_gettext(_("There were errors in '%s'. Falling back on default.\n")), s);
}
/* Try built-in joerc */
s = vsncpy(NULL, 0, sc("*"));
s = vsncpy(sv(s), sv(run));
s = vsncpy(sv(s), sc("rc"));
c = procrc(cap, s);
if (c != 0 && c != 1) {
/* If *fancyjoerc not present, use *joerc which is always there */
s = vstrunc(s, 0);
s = vsncpy(sv(s),sc("*joerc"));
c = procrc(cap, s);
}
if (c == 0)
goto donerc;
if (c == 1) {
logerror_1((char *)joe_gettext(_("There were errors in '%s'. Falling back on default.\n")), s);
}
#endif
logerror_1((char *)joe_gettext(_("Couldn't open '%s'\n")), s);
goto exit_errors;
return 1;
donerc:
if (validate_rc()) {
logerror_0((char *)joe_gettext(_("rc file has no :main key binding section or no bindings. Bye.\n")));
goto exit_errors;
}
{
unsigned char buf[10];
int x;
zlcpy(buf, sizeof(buf), USTR "\"`\" ` ");
type_backtick = mparse(0, buf, &x, 0);
}
shell_kbd = mkkbd(kmap_getcontext(USTR "shell"));
if (!isatty(fileno(stdin)))
idleout = 0;
for (c = 1; argv[c]; ++c) {
if (argv[c][0] == '-') {
if (argv[c][1])
switch (glopt(argv[c] + 1, argv[c + 1], NULL, 1)) {
case 0:
logerror_1((char *)joe_gettext(_("Unknown option '%s'\n")), argv[c]);
break;
case 1:
break;
case 2:
++c;
break;
} else
idleout = 0;
}
}
/* initialize mouse support */
if (xmouse && (s=(unsigned char *)getenv("TERM")) && strstr((char *)s,"xterm"))
usexmouse=1;
if (!(n = nopen(cap)))
goto exit_errors;
maint = screate(n);
load_state();
/* It would be better if this ran uedit() to load files */
/* The business with backopt is to load the file first, then apply file
* local options afterwords */
/* orphan is not compatible with exemac()- macros need a window to exist */
for (c = 1, backopt = 0; argv[c]; ++c)
if (argv[c][0] == '+' && argv[c][1]>='0' && argv[c][1]<='9') {
if (!backopt)
backopt = c;
} else if (argv[c][0] == '-' && argv[c][1]) {
if (!backopt)
backopt = c;
if (glopt(argv[c] + 1, argv[c + 1], NULL, 0) == 2)
++c;
} else {
B *b = bfind(argv[c]);
BW *bw = NULL;
int er = berror;
/* This is too annoying */
/* set_current_dir(argv[c],1); */
setup_history(&filehist);
append_history(filehist,sz(argv[c]));
/* wmktw inserts the window before maint->curwin */
if (!orphan || !opened) {
bw = wmktw(maint, b);
if (er)
msgnwt(bw->parent, joe_gettext(msgs[-er]));
} else {
long line;
b->orphan = 1;
b->oldcur = pdup(b->bof, USTR "main");
pline(b->oldcur, get_file_pos(b->name));
p_goto_bol(b->oldcur);
line = b->oldcur->line - (maint->h - 1) / 2;
if (line < 0)
line = 0;
b->oldtop = pdup(b->oldcur, USTR "main");
pline(b->oldtop, line);
p_goto_bol(b->oldtop);
}
if (bw) {
long lnum = 0;
bw->o.readonly = bw->b->rdonly;
if (backopt) {
while (backopt != c) {
if (argv[backopt][0] == '+') {
sscanf((char *)(argv[backopt] + 1), "%ld", &lnum);
++backopt;
} else {
if (glopt(argv[backopt] + 1, argv[backopt + 1], &bw->o, 0) == 2)
backopt += 2;
else
backopt += 1;
lazy_opts(bw->b, &bw->o);
}
}
}
bw->b->o = bw->o;
bw->b->rdonly = bw->o.readonly;
/* Put cursor in window, so macros work properly */
maint->curwin = bw->parent;
/* Execute macro */
if (er == -1 && bw->o.mnew)
exmacro(bw->o.mnew,1);
if (er == 0 && bw->o.mold)
exmacro(bw->o.mold,1);
/* Hmm... window might not exist any more... depends on what macro does... */
if (lnum > 0)
pline(bw->cursor, lnum - 1);
else
pline(bw->cursor, get_file_pos(bw->b->name));
p_goto_bol(bw->cursor);
/* Go back to first window so windows are in same order as command line */
if (opened)
wnext(maint);
}
opened = 1;
backopt = 0;
}
if (opened) {
wshowall(maint);
omid = mid;
mid = 1;
dofollows();
mid = omid;
} else {
BW *bw = wmktw(maint, bfind(USTR ""));
if (bw->o.mnew)
exmacro(bw->o.mnew,1);
}
maint->curwin = maint->topwin;
if (logerrors) {
B *copied = bcpy(startup_log->bof, startup_log->eof);
BW *bw = wmktw(maint, copied);
copied->name = zdup(startup_log->name);
copied->internal = 1;
maint->curwin = bw->parent;
wshowall(maint);
}
if (help) {
help_on(maint);
}
if (!nonotice) {
joe_snprintf_3(msgbuf,JOE_MSGBUFSIZE,joe_gettext(_("\\i** Joe's Own Editor v%s ** (%s) ** Copyright %s 2015 **\\i")),VERSION,locale_map->name,(locale_map->type ? "©" : "(C)"));
msgnw(((BASE *)lastw(maint)->object)->parent, msgbuf);
}
if (!idleout) {
if (!isatty(fileno(stdin)) && modify_logic(maint->curwin->object, ((BW *)maint->curwin->object)->b)) {
/* Start shell going in first window */
unsigned char **a;
unsigned char *cmd;
a = vamk(10);
cmd = vsncpy(NULL, 0, sc("/bin/sh"));
a = vaadd(a, cmd);
cmd = vsncpy(NULL, 0, sc("-c"));
a = vaadd(a, cmd);
cmd = vsncpy(NULL, 0, sc("/bin/cat"));
a = vaadd(a, cmd);
cstart (maint->curwin->object, USTR "/bin/sh", a, NULL, NULL, 0, 1, NULL, 0);
}
}
edloop(0);
save_state();
/* Delete all buffer so left over locks get eliminated */
brmall();
vclose(vmem);
nclose(n);
if (noexmsg) {
if (notite)
fprintf(stderr, "\n");
} else {
if (exmsg)
fprintf(stderr, "\n%s\n", exmsg);
else if (notite)
fprintf(stderr, "\n");
}
return 0;
exit_errors:
/* Write out error log to console if we are exiting with errors. */
if (startup_log && startup_log->eof->byte)
bsavefd(startup_log->bof, 2, startup_log->eof->byte);
return 1;
}
static void yankdel(long where, B *b)
{
UNDOREC *rec;
long size = b->eof->byte;
/* Store in yank buffer */
rec = yanked.link.prev;
if (!inyank) {
if (rec != &yanked && where == rec->where && justkilled) {
if (rec->len + size >= SMALL) {
if (rec->len < SMALL) {
rec->big = bmk(NULL);
binsm(rec->big->bof, rec->small, (int) rec->len);
boffline(rec->big);
free(rec->small);
}
bonline(rec->big);
binsb(rec->big->eof, bcpy(b->bof, b->eof));
boffline(rec->big);
} else {
rec->small = (unsigned char *) joe_realloc(rec->small, rec->len + size);
brmem(b->bof, rec->small + rec->len, (int) size);
}
rec->len += size;
} else if (rec != &yanked && where + size == rec->where && justkilled) {
if (rec->len + size >= SMALL) {
if (rec->len < SMALL) {
rec->big = bmk(NULL);
binsm(rec->big->bof, rec->small, (int) rec->len);
boffline(rec->big);
free(rec->small);
}
bonline(rec->big);
binsb(rec->big->bof, bcpy(b->bof, b->eof));
boffline(rec->big);
} else {
rec->small = (unsigned char *) joe_realloc(rec->small, rec->len + size);
memmove(rec->small + size, rec->small, (int) rec->len);
brmem(b->bof, rec->small, (int) size);
}
rec->len += size;
rec->where = where;
} else {
if (++nyanked == MAX_YANK) {
frrec(deque_f(UNDOREC, link, yanked.link.next));
--nyanked;
}
rec = alrec();
if (size < SMALL) {
rec->small = (unsigned char *) joe_malloc(size);
brmem(b->bof, rec->small, (int) b->eof->byte);
} else {
rec->big = bcpy(b->bof, b->eof);
boffline(rec->big);
}
rec->where = where;
rec->len = size;
rec->del = 1;
enqueb(UNDOREC, link, &yanked, rec);
}
}
}
