static int backup(BW *bw)
{
if (!bw->b->backup && !nobackups && !bw->o.nobackup && bw->b->name && bw->b->name[0]) {
char tmp[1024];
char name[1024];
#ifdef __MSDOS__
int x;
if (backpath) {
char *t = vsncpy(NULL,0,sz(backpath));
t = canonical(t);
joe_snprintf_2(name, SIZEOF(name), "%s/%s", t, namepart(tmp, SIZEOF(tmp), bw->b->name));
vsrm(t);
} else {
joe_snprintf_1(name, SIZEOF(name), "%s", bw->b->name);
}
for (x = zlen(name); name[--x] != '.';) {
if (name[x] == '\\' || (name[x] == ':' && x == 1) || x == 0) {
x = zlen(name);
break;
}
}
zlcpy(name + x, SIZEOF(name) - x, ".bak");
#else
/* Create backup file name */
const char *simple_backup_suffix = getenv("SIMPLE_BACKUP_SUFFIX");
if (simple_backup_suffix == NULL) {
simple_backup_suffix = "~";
}
if (backpath) {
char *t = vsncpy(NULL, 0, sz(backpath));
t = canonical(t);
joe_snprintf_3(name, SIZEOF(name), "%s/%s%s", t, namepart(tmp, SIZEOF(tmp), dequote(bw->b->name)), simple_backup_suffix);
vsrm(t);
} else {
joe_snprintf_2(name, SIZEOF(name), "%s%s", dequote(bw->b->name), simple_backup_suffix);
}
/* Attempt to delete backup file first */
unlink(name);
#endif
/* Copy original file to backup file */
if (cp(dequote(bw->b->name), name)) {
return 1;
} else {
bw->b->backup = 1;
return 0;
}
} else {
return 0;
}
}
static char* add_filter(char* result, const char* name, const char* filter)
{
if(!filter)
return result;
szprint(result, "%1 (%2)", name, filter);
szupper(result, 1);
result += zlen(result); *result++ = 0; *result = 0;
zcat(result, filter);
result += zlen(result); *result++ = 0; *result = 0;
return result;
}
void displayTimers()
{
#if defined(TRANSLATIONS_CZ)
#define MAINTMR_LBL_COL (9*FW-FW/2-1)
#else
#define MAINTMR_LBL_COL (9*FW-FW/2+3)
#endif
// Main timer
if (g_model.timers[0].mode) {
TimerState & timerState = timersStates[0];
LcdFlags att = DBLSIZE | (timerState.val<0 ? BLINK|INVERS : 0);
putsTimer(12*FW+2+10*FWNUM-4, FH*2, timerState.val, att, att);
uint8_t xLabel = (timerState.val >= 0 ? MAINTMR_LBL_COL : MAINTMR_LBL_COL-7);
#if defined(CPUARM)
uint8_t len = zlen(g_model.timers[0].name, LEN_TIMER_NAME);
if (len > 0) {
xLabel += (LEN_TIMER_NAME-len)*FW;
lcd_putsnAtt(xLabel, FH*3, g_model.timers[0].name, len, ZCHAR);
}
else {
putsTimerMode(xLabel, FH*3, g_model.timers[0].mode);
}
#else
putsTimerMode(xLabel, FH*3, g_model.timers[0].mode);
#endif
}
}
unsigned char *zdup(unsigned char *bf)
{
int size = zlen(bf);
unsigned char *p = (unsigned char *)joe_malloc(size+1);
memcpy(p,bf,size+1);
return p;
}
void displayHeaderChannelName(uint8_t ch)
{
uint8_t len = zlen(g_model.limitData[ch].name, sizeof(g_model.limitData[ch].name));
if (len) {
lcd_putsnAtt(80, 1, g_model.limitData[ch].name, len, ZCHAR|SMLSIZE);
}
}
int zmcmp(unsigned char *a, unsigned char *b)
{
int x = zlen(a);
do {
if (a[x] == ':' && a[x + 1] == ':')
if ((b[0] == ':' && !zcmp(a + x, b)) || !zcmp(a + x + 2, b))
return 0;
} while (x--);
return zcmp(a, b);
}
int cstart(BW *bw, unsigned char *name, unsigned char **s, void *obj, int *notify, int build, int out_only, unsigned char *first_command, int vt)
{
#ifdef __MSDOS__
if (notify) {
*notify = 1;
}
varm(s);
msgnw(bw->parent, joe_gettext(_("Sorry, no sub-processes in DOS (yet)")));
return -1;
#else
MPX *m;
int shell_w = -1, shell_h = -1;
if (notify) {
*notify = 1;
}
if (bw->b->pid) {
if (!vt) { /* Don't complain if shell already running.. makes F-key switching nicer */
/* Keep old behavior for dumb terminal */
msgnw(bw->parent, joe_gettext(_("Program already running in this window")));
}
varm(s);
return -1;
}
if (vt) {
BW *master = vtmaster(bw->parent->t, bw->b); /* In case of multiple BWs on one B, pick one to be the master */
if (!master) master = bw; /* Should never happen */
shell_w = master->w;
shell_h = master->h;
bw->b->vt = mkvt(bw->b, master->top, master->h, master->w);
bw->b->o.ansi = 1;
bw->b->o.syntax = load_syntax(USTR "ansi");
/* Turn on shell mode for each window */
ansiall(bw->b);
}
/* p_goto_eof(bw->cursor); */
if (!(m = mpxmk(&bw->b->out, name, s, cdata, bw->b, build ? cdone_parse : cdone, bw->b, out_only, shell_w, shell_h))) {
varm(s);
msgnw(bw->parent, joe_gettext(_("No ptys available")));
return -1;
} else {
bw->b->pid = m->pid;
if (first_command)
if (-1 == write(bw->b->out, first_command, zlen(first_command)))
msgnw(bw->parent, joe_gettext(_("Write failed when writing first command to shell")));
}
return 0;
#endif
}
int help_init(JFILE *fd,unsigned char *bf,int line)
{
unsigned char buf[1024]; /* input buffer */
struct help *tmp;
unsigned int bfl; /* buffer length */
unsigned int hlpsiz, hlpbsz; /* number of used/allocated bytes for tmp->text */
unsigned char *tempbuf;
if (bf[0] == '{') { /* start of help screen */
tmp = (struct help *) joe_malloc(sizeof(struct help));
tmp->text = NULL;
tmp->lines = 0;
hlpsiz = 0;
hlpbsz = 0;
tmp->name = vsncpy(NULL, 0, sz(bf + 1) - 1); /* -1 kill the \n */
while ((jfgets(buf, sizeof(buf), fd)) && (buf[0] != '}')) {
++line;
bfl = zlen(buf);
if (hlpsiz + bfl > hlpbsz) {
if (tmp->text) {
tempbuf = (unsigned char *) joe_realloc(tmp->text, hlpbsz + bfl + 1024);
tmp->text = tempbuf;
} else {
tmp->text = (unsigned char *) joe_malloc(bfl + 1024);
tmp->text[0] = 0;
}
hlpbsz += bfl + 1024;
}
zcpy(tmp->text + hlpsiz, buf);
hlpsiz += bfl;
++tmp->lines;
}
tmp->prev = help_ptr;
tmp->next = NULL;
if (help_ptr) {
help_ptr->next = tmp;
} else {
help_actual = tmp;
}
help_ptr = tmp;
if (buf[0] == '}') { /* set new help screen as actual one */
++line;
} else {
fprintf(stderr, (char *)joe_gettext(_("\n%d: EOF before end of help text\n")),line);
}
}
return line;
}
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);
}
