ex_line() should be able to escape "|" character

[kyx0r]

Hello Ali,

I fixed this long time ago in my fork, but there is a problem of not being able to escape "|" in prompt.

Because you can't escape it, ex_line will treat it like a pipe for commands. The implication is that it is impossible to run substitution commands that have "|" character in them as the searchable text.

This commit fixed it ex.c https://github.com/kyx0r/neatvi/commit/c435fd1d1bfce67eeb0c7e9bd54d6c7f1717dbe5

[kyx0r]

Funny enough though, it seems like even if escape is implemented, you can't fix this problem entirely. Because there will still be no way to properly escape the case when | is inside the bracket expression used for substitution. But it will work for all other cases though. In my fork this isn't a problem now, since I do support escapes in brackets.

It's like one problem, chains into another one, ehh pain in the ass. But I think even partially fixing this issue might be worth a try. Or you could also do some different approach say like if it's a substitution command, parse it till the end first, that way you can avoid having to implement escapes. But parsing it won't be any simple code, it be as bad in taste as re_groupcount() currently is.

[kyx0r]

Or you could exclude the posibility of piping anything entirely if it is substitution command. This might be the best middle ground.

[aligrudi]

Hell Kyryl,

Kyryl @.***> wrote:

Or you could exclude the posibility of piping anything entirely if it is substitution command. This might be the best middle ground.

Well, I think the right solution is to do what the "Command Line Parsing in ex" section of ex(1p) says; I shall have a look.

Ali

[kyx0r]

           iii. If the command is an s command, characters up to the first
                non-<backslash>-escaped <newline>, or second
                non-<backslash>-escaped delimiter character, shall be
                skipped and be part of the command.

Basically it says that there has to be means to escape the delimiter. So the escape will make it into the regex

And the the paragraph "Replacement Strings in ex" states: Otherwise, any character following a shall be treated as that literal character, and the escaping shall be discarded.

Having to discard the escapes implies a super ugly implementation. One could avoid it by replacing every escape with a NULL if it's inside the bracket, then treat NULL in regex as it be an escape, having a NULL in bracket is an error but we can repurpose the NULL check and make it be useful. Error checking does not affect valid expressions, invalid ones ehh, thats on them, it will fault either way, but this way with a cool infinite loop and a buffer overflow ;) . But even with this efficient solution it won't work on libc regex because likely the will treat NULL as an error instead of continuing to parse in hopes of finding the closing ].

This is a tough one to solve without writing garbage code that will duplicate strings, shrink the expression by removing only the escapes inside [] brackets.

[kyx0r]

Let me rephrase this - it's not hard to write code that will shrink the expression and discard the escapes. This is perfect example of redundant code, that does bunch of crap only for the sake of satisfying one condition. The "why" of things being done this way is so weak, that likely my students would lose hope in me as their professor. No wonder they call it the poosix standard, it might produce clear designs on paper but difficult to implement in practice.

[aligrudi]

Kyryl @.***> wrote:

           iii. If the command is an s command, characters up to the first
                non-<backslash>-escaped <newline>, or second
                non-<backslash>-escaped delimiter character, shall be
                skipped and be part of the command.

Basically it says that there has to be means to escape the delimiter. So the escape will make it into the regex

And the the paragraph "Replacement Strings in ex" states: Otherwise, any character following a shall be treated as that literal character, and the escaping shall be discarded.

Having to discard the escapes implies a super ugly implementation. One could avoid it by replacing every escape with a NULL if it's inside the bracket, then treat NULL in regex as it be an escape, having a NULL in bracket is an error but we can repurpose the NULL check and make it be useful. Error checking does not affect valid expressions, invalid ones ehh, thats on them, it will fault either way, but this way with a cool infinite loop and a buffer overflow ;) . But even with this efficient solution it won't work on libc regex because likely the will treat NULL as an error instead of continuing to parse in hopes of finding the closing ].

This is a tough one to solve without writing garbage code that will duplicate strings, shrink the expression by removing only the escapes inside [] brackets.

Currently exline() extracts a command and its arguments from input and sends them to one of ec functions. I think these conditions are easier to implement if the input is read character by character directly in ec_ functions.

Ali

[kyx0r]

Well, see if you can come up with a workable patch. But I won't blame you if you decide to simply not solve this problem. Because the spec sucks for not accomodating any kind of escaping in regex brackets. It doesn't leave much of open ended options for us.

[kyx0r]

Though looking at it purely from regex perspective escapes do seem like unnecesary in brk. But because of that users of regex have to build those enourmous ugly workarounds. Sounds like undersight on the standard's side. It would of been way better to keep escapes everywhere so that any regex is consistent everywhere in its string. The cost of 1 if statement, ehh.

[aligrudi]

Kyryl @.***> wrote:

Though looking at it purely from regex perspective escapes do seem like unnecesary in brk. But because of that users of regex have to build those enourmous ugly workarounds. Sounds like undersight on the standard's side. It would of been way better to keep escapes everywhere so that any regex is consistent everywhere in its string. The cost of 1 if statement, ehh.

Pushed a fix. Please report if something is amiss.

Ali

[kyx0r]

Hello Ali,

That came out to be a beefy patch in terms of number of changes. So I thought of course I won't need all of them ported into nextvi, but one question buges me, what justified removing this code

s = ex_cmd(s, arg);
while (isspace((unsigned char) *s))
    s++;

from the function ex_filearg() at the beginning? Can I also do that in nextvi? Running all those paths in my head from where ex_filearg() roughly leaves me under a vague impression that from some places it is necesary to call ex_cmd() and some not because it was called previously. Was that code 100% redundant or not? There are many changes in your last commits so I might be missing something.

I just want to be %100 sure because if I remove that code I don't accidentally make regressions that would be hard to test.

Regards, Kyryl.

[aligrudi]

Hello Kyryl,

Kyryl @.***> wrote:

That came out to be a beefy patch in terms of number of changes. So I thought of course I won't need all of them ported into nextvi, but one question buges me, what justified removing this code

s = ex_cmd(s, arg); while (isspace((unsigned char) *s)) s++;

All ex commands (ec_* functions) expect the whole ex line as a parameter. For each ex line, ex_loc(), ex_cmd(), and ex_arg() may be called to extract command addresses, command name, and command arguments, respectively.

Before this patch, for reading arguments one of ex_arg(), ex_filearg(), or ex_argeol() was called depending on the ex command. That is no longer necessary; ex_arg() extracts the arguments based on the command. The new ex_filearg() merely replaces % and # in the string passed to it; this is useful for commands that expect a path or a command. So now you can first extract the argument using ex_arg() and then pass it to ex_filearg().

It is probably a good idea now to rename ex_filearg(). Suggestions?

from the function ex_filearg() at the beginning? Can I also do that in nextvi? Running all those paths in my head from where ex_filearg() roughly leaves me under a vague impression that from some places it is necesary to call ex_cmd() and some not because it was called previously. Was that code 100% redundant or not? There are many changes in your last commits so I might be missing something.

It is possible to call ex_loc(), ex_cmd(), and ex_arg() once in exexec() and pass three arguments to ec*(). I shall give it a try to see if it simplifies ex.c.

Thanks, Ali

[aligrudi]

How about the following patch?

Ali

diff --git a/ex.c b/ex.c index 7066302..9affa88 100644 --- a/ex.c +++ b/ex.c @@ -114,50 +114,6 @@ char *ex_filetype(void) return bufs[0].ft; }

-static char ex_loc(char src, char loc); -static char ex_cmd(char src, char cmd); -static char ex_arg(char src, char *arg);

-/ read ex command location / -static char ex_loc(char src, char *loc) -{

• while (src == ':' || src == ' ' || *src == '\t')
• src++;
• while (src && !isalpha((unsigned char) src) && src != '=' && src != '!') {
• if (*src == '\'')
• loc++ = src++;
• if (src == '/' || src == '?') {
• int d = *src;
• loc++ = src++;
• while (src && src != d) {
• if (*src == '\' && src[1])
• loc++ = src++;
• loc++ = src++;
• }
• }
• if (*src)
• loc++ = src++;
• }
• *loc = '\0';
• return src; -}

• -/ read ex command name / -static char ex_cmd(char src, char *cmd) -{

• char *cmd0 = cmd;
• src = ex_loc(src, cmd);
• while (src == ' ' || src == '\t')
• src++;
• while (isalpha((unsigned char) *src) && cmd < cmd0 + 16)
• if ((cmd++ = src++) == 'k' && cmd == cmd0 + 1)
• break;
• if (src == '!' || src == '=')
• cmd++ = src++;
• *cmd = '\0';
• return src; -}

• / read ex file argument / static char ex_filearg(char src, int spaceallowed) { @@ -315,26 +271,24 @@ static int ex_region(char loc, int beg, int *end) return 0; }

-static int ec_write(char ec); +static int ec_write(char loc, char cmd, char arg);

static int ex_modifiedbuffer(char *msg) { if (!lbuf_modified(xb)) return 0; if (xaw && ex_path()[0])

• return ec_write("w");
• return ec_write("", "w", ""); if (msg) ex_show(msg); return 1; }

-static int ec_buffer(char ec) +static int ec_buffer(char loc, char cmd, char arg) {

• char arg[EXLEN]; char ln[128]; int id; int i;
• ex_arg(ec, arg); id = arg[0] ? atoi(arg) : 0; for (i = 0; i < LEN(bufs) && bufs[i].lb; i++) { if (id) { @@ -356,10 +310,8 @@ static int ec_buffer(char *ec) return 0; }

-static int ec_quit(char ec) +static int ec_quit(char loc, char cmd, char arg) {

• char cmd[EXLEN];
• ex_cmd(ec, cmd); if (!strchr(cmd, '!')) if (ex_modifiedbuffer("buffer modified\n")) return 1; @@ -367,15 +319,11 @@ static int ec_quit(char *ec) return 0; }

-static int ec_edit(char ec) +static int ec_edit(char loc, char cmd, char arg) { char msg[128];

• char cmd[EXLEN];
• char arg[EXLEN]; char *path; int fd;
• ex_cmd(ec, cmd);
• ex_arg(ec, arg); if (!strchr(cmd, '!')) if (xb && ex_modifiedbuffer("buffer modified\n")) return 1; @@ -408,16 +356,13 @@ static int ec_edit(char *ec) return 0; }

-static int ec_read(char ec) +static int ec_read(char loc, char cmd, char arg) {

• char arg[EXLEN], loc[EXLEN]; char msg[128]; int beg, end; char path; char obuf; int n = lbuf_len(xb);
• ex_arg(ec, arg);
• ex_loc(ec, loc); path = arg[0] ? arg : ex_path(); if (ex_region(loc, &beg, &end)) return 1; @@ -452,19 +397,15 @@ static int ec_read(char *ec) return 0; }

-static int ec_write(char ec) +static int ec_write(char loc, char cmd, char arg) {

• char cmd[EXLEN], arg[EXLEN], loc[EXLEN]; char msg[128]; char path; char ibuf; int beg, end;
• ex_cmd(ec, cmd);
• ex_arg(ec, arg);
• ex_loc(ec, loc); path = arg[0] ? arg : ex_path(); if (cmd[0] == 'x' && !lbuf_modified(xb))
• return ec_quit(cmd);
• return ec_quit("", cmd, ""); if (ex_region(loc, &beg, &end)) return 1; if (!loc[0]) { @@ -516,20 +457,16 @@ static int ec_write(char *ec) if (!strcmp(ex_path(), path)) bufs[0].mtime = mtime(path); if (cmd[0] == 'x' || (cmd[0] == 'w' && cmd[1] == 'q'))
• ec_quit(cmd);
• ec_quit("", cmd, ""); return 0; }

-static int ec_insert(char ec) +static int ec_insert(char loc, char cmd, char arg) {

• char arg[EXLEN], cmd[EXLEN], loc[EXLEN]; struct sbuf sb; char s; int beg, end; int n;
• ex_arg(ec, arg);
• ex_cmd(ec, cmd);
• ex_loc(ec, loc); if (ex_region(loc, &beg, &end) && (beg != 0 || end != 0)) return 1; sb = sbuf_make(); @@ -554,13 +491,10 @@ static int ec_insert(char *ec) return 0; }

-static int ec_print(char ec) +static int ec_print(char loc, char cmd, char arg) {

• char cmd[EXLEN], loc[EXLEN]; int beg, end; int i;
• ex_cmd(ec, cmd);
• ex_loc(ec, loc); if (!cmd[0] && !loc[0]) if (xrow >= lbuf_len(xb)) return 1; @@ -573,13 +507,11 @@ static int ec_print(char *ec) return 0; }

-static int ec_null(char ec) +static int ec_null(char loc, char cmd, char arg) {

• char loc[EXLEN]; int beg, end; if (!xvis)
• return ec_print(ec);
• ex_loc(ec, loc);
• return ec_print(loc, cmd, arg); if (ex_region(loc, &beg, &end)) return 1; xrow = MAX(beg, end - 1); @@ -594,13 +526,9 @@ static void ex_yank(int reg, int beg, int end) free(buf); }

-static int ec_delete(char ec) +static int ec_delete(char loc, char cmd, char arg) {

• char loc[EXLEN];
• char arg[EXLEN]; int beg, end;
• ex_loc(ec, loc);
• ex_arg(ec, arg); if (ex_region(loc, &beg, &end) || !lbuf_len(xb)) return 1; ex_yank(arg[0], beg, end); @@ -609,29 +537,21 @@ static int ec_delete(char *ec) return 0; }

-static int ec_yank(char ec) +static int ec_yank(char loc, char cmd, char arg) {

• char loc[EXLEN];
• char arg[EXLEN]; int beg, end;
• ex_loc(ec, loc);
• ex_arg(ec, arg); if (ex_region(loc, &beg, &end) || !lbuf_len(xb)) return 1; ex_yank(arg[0], beg, end); return 0; }

-static int ec_put(char ec) +static int ec_put(char loc, char cmd, char arg) {

• char loc[EXLEN];
• char arg[EXLEN]; int beg, end; int lnmode; char *buf; int n = lbuf_len(xb);
• ex_loc(ec, loc);
• ex_arg(ec, arg); buf = reg_get(arg[0], &lnmode); if (!buf || ex_region(loc, &beg, &end)) return 1; @@ -640,12 +560,10 @@ static int ec_put(char *ec) return 0; }

-static int ec_lnum(char ec) +static int ec_lnum(char loc, char cmd, char arg) {

• char loc[EXLEN]; char msg[128]; int beg, end;
• ex_loc(ec, loc); if (ex_region(loc, &beg, &end)) return 1; sprintf(msg, "%d\n", end); @@ -653,22 +571,19 @@ static int ec_lnum(char *ec) return 0; }

-static int ec_undo(char ec) +static int ec_undo(char loc, char cmd, char arg) { return lbuf_undo(xb); }

-static int ec_redo(char ec) +static int ec_redo(char loc, char cmd, char arg) { return lbuf_redo(xb); }

-static int ec_mark(char ec) +static int ec_mark(char loc, char cmd, char arg) {

• char loc[EXLEN], arg[EXLEN]; int beg, end;
• ex_arg(ec, arg);
• ex_loc(ec, loc); if (ex_region(loc, &beg, &end)) return 1; lbuf_mark(xb, arg[0], end - 1, 0); @@ -694,9 +609,8 @@ static void replace(struct sbuf dst, char rep, char ln, int offs) } }

-static int ec_substitute(char ec) +static int ec_substitute(char loc, char cmd, char arg) {

• char loc[EXLEN], arg[EXLEN]; struct rset re; int offs[32]; int beg, end; @@ -704,8 +618,6 @@ static int ec_substitute(char ec) char pat = NULL, rep = NULL; char *s = arg; int i;
• ex_loc(ec, loc);
• ex_arg(ec, arg); if (ex_region(loc, &beg, &end)) return 1; pat = re_read(&s); @@ -751,17 +663,13 @@ static int ec_substitute(char *ec) return 0; }

-static int ec_exec(char ec) +static int ec_exec(char loc, char cmd, char arg) {

• char loc[EXLEN];
• char arg[EXLEN]; int beg, end; char text; char rep; char *ecmd; ex_modifiedbuffer(NULL);
• ex_loc(ec, loc);
• ex_arg(ec, arg); if (!(ecmd = ex_filearg(arg, 1))) return 1; if (!loc[0]) { @@ -785,13 +693,11 @@ static int ec_exec(char *ec) return 0; }

-static int ec_make(char ec) +static int ec_make(char log, char cmd, char arg) {

• char arg[EXLEN]; char make[EXLEN]; char *target; ex_modifiedbuffer(NULL);
• ex_arg(ec, arg); if (!(target = ex_filearg(arg, 0))) return 1; sprintf(make, "make %s", target); @@ -802,10 +708,8 @@ static int ec_make(char *ec) return 0; }

-static int ec_ft(char ec) +static int ec_ft(char loc, char cmd, char arg) {

• char arg[EXLEN];
• ex_arg(ec, arg); if (arg[0]) snprintf(bufs[0].ft, sizeof(bufs[0].ft), "%s", arg); else @@ -813,12 +717,8 @@ static int ec_ft(char *ec) return 0; }

-static int ec_cmap(char ec) +static int ec_cmap(char loc, char cmd, char arg) {

• char cmd[EXLEN];
• char arg[EXLEN];
• ex_cmd(ec, cmd);

• ex_arg(ec, arg); if (arg[0]) xkmap_alt = conf_kmapfind(arg); else @@ -830,9 +730,8 @@ static int ec_cmap(char *ec)

  static int ex_exec(char *ln);

-static int ec_glob(char ec) +static int ec_glob(char loc, char cmd, char arg) {

• char loc[EXLEN], cmd[EXLEN], arg[EXLEN]; struct rset re; int offs[32]; int beg, end, not; @@ -840,9 +739,6 @@ static int ec_glob(char ec) char pat; char s = arg; int i;
• ex_cmd(ec, cmd);
• ex_loc(ec, loc);
• ex_arg(ec, arg); if (!loc[0] && !xgdep) strcpy(loc, "%"); if (ex_region(loc, &beg, &end)) @@ -905,15 +801,13 @@ static char cutword(char s, char *d) return s; }

-static int ec_set(char ec) +static int ec_set(char loc, char cmd, char arg) {

• char arg[EXLEN]; char tok[EXLEN]; char opt[EXLEN]; char *s = arg; int val = 0; int i;
• ex_arg(ec, arg); if (s) { s = cutword(s, tok); if (tok[0] == 'n' && tok[1] == 'o') { @@ -946,7 +840,7 @@ static int ec_set(char ec) static struct excmd { char abbr; char name;
• int (ec)(char s);
• int (ec)(char loc, char cmd, char arg); } excmds[] = { {"b", "buffer", ec_buffer}, {"p", "print", ec_print}, @@ -993,6 +887,46 @@ static int ex_idx(char *cmd) return -1; }

+/ read ex command location / +static char ex_loc(char src, char *loc) +{

• while (src == ':' || src == ' ' || *src == '\t')
• src++;
• while (src && !isalpha((unsigned char) src) && src != '=' && src != '!') {
• if (*src == '\'')
• loc++ = src++;
• if (src == '/' || src == '?') {
• int d = *src;
• loc++ = src++;
• while (src && src != d) {
• if (*src == '\' && src[1])
• loc++ = src++;
• loc++ = src++;
• }
• }
• if (*src)
• loc++ = src++;
• }
• *loc = '\0';
• return src; +}

• +/ read ex command name / +static char ex_cmd(char src, char *cmd) +{

• char *cmd0 = cmd;
• src = ex_loc(src, cmd);
• while (src == ' ' || src == '\t')
• src++;
• while (isalpha((unsigned char) *src) && cmd < cmd0 + 16)
• if ((cmd++ = src++) == 'k' && cmd == cmd0 + 1)
• break;
• if (src == '!' || src == '=')
• cmd++ = src++;
• *cmd = '\0';
• return src; +}

• / read ex command argument / static char ex_arg(char src, char dst) { @@ -1039,34 +973,27 @@ static char ex_arg(char src, char dst) }

  / read an ex command and its arguments from src into dst / -static char ex_line(char src, char dst) +static char ex_line(char src, char loc, char cmd, char arg) {

• char loc[EXLEN];
• char cmd[EXLEN];
• char arg[EXLEN]; ex_loc(src, loc); ex_cmd(src, cmd);
• src = ex_arg(src, arg);
• sprintf(dst, "%s%s %s", loc, cmd, arg);
• return src;

• return ex_arg(src, arg); }

  / execute a single ex command / static int ex_exec(char *ln) {

• char ec[EXLEN];
• char cmd[EXLEN];
• char loc[EXLEN], cmd[EXLEN], arg[EXLEN]; int idx; int ret = 0; while (*ln) {
• ex_cmd(ln, cmd); if (strlen(ln) >= EXLEN) { ex_show("command too long"); return 1; }
• ln = ex_line(ln, ec);
• ln = ex_line(ln, loc, cmd, arg); if ((idx = ex_idx(cmd)) >= 0)
• ret = excmds[idx].ec(ec);

• ret = excmds[idx].ec(loc, cmd, arg); } return ret; } @@ -1092,18 +1019,16 @@ void ex(void)

  int ex_init(char **files) {

• char cmd[EXLEN];
• char *s = cmd;
• char arg[EXLEN];
• char s = arg; char r = files[0] ? files[0] : "";
• *s++ = 'e';
• *s++ = ' ';
• while (*r && s + 2 < cmd + sizeof(cmd)) {
• while (r && s + 2 < arg + sizeof(arg)) { if (r == ' ' || r == '%' || r == '#') s++ = '\'; s++ = r++; } s = '\0';
• if (ec_edit(cmd))
• if (ec_edit("", "e", "")) return 1; if (getenv("EXINIT")) ex_command(getenv("EXINIT"));

[aligrudi]

The updated patch.

Ali

diff --git a/ex.c b/ex.c index 7066302..ba725c1 100644 --- a/ex.c +++ b/ex.c @@ -114,50 +114,6 @@ char *ex_filetype(void) return bufs[0].ft; }

-static char ex_loc(char src, char loc); -static char ex_cmd(char src, char cmd); -static char ex_arg(char src, char *arg);

-/ read ex command location / -static char ex_loc(char src, char *loc) -{

• while (src == ':' || src == ' ' || *src == '\t')
• src++;
• while (src && !isalpha((unsigned char) src) && src != '=' && src != '!') {
• if (*src == '\'')
• loc++ = src++;
• if (src == '/' || src == '?') {
• int d = *src;
• loc++ = src++;
• while (src && src != d) {
• if (*src == '\' && src[1])
• loc++ = src++;
• loc++ = src++;
• }
• }
• if (*src)
• loc++ = src++;
• }
• *loc = '\0';
• return src; -}

• -/ read ex command name / -static char ex_cmd(char src, char *cmd) -{

• char *cmd0 = cmd;
• src = ex_loc(src, cmd);
• while (src == ' ' || src == '\t')
• src++;
• while (isalpha((unsigned char) *src) && cmd < cmd0 + 16)
• if ((cmd++ = src++) == 'k' && cmd == cmd0 + 1)
• break;
• if (src == '!' || src == '=')
• cmd++ = src++;
• *cmd = '\0';
• return src; -}

• / read ex file argument / static char ex_filearg(char src, int spaceallowed) { @@ -280,7 +236,7 @@ static int ex_lineno(char **num) return n; }

-/ parse ex command location / +/ parse ex command addresses / static int ex_region(char loc, int beg, int end) { int naddr = 0; @@ -315,26 +271,24 @@ static int ex_region(char loc, int beg, int end) return 0; }

-static int ec_write(char ec); +static int ec_write(char loc, char cmd, char arg);

static int ex_modifiedbuffer(char *msg) { if (!lbuf_modified(xb)) return 0; if (xaw && ex_path()[0])

• return ec_write("w");
• return ec_write("", "w", ""); if (msg) ex_show(msg); return 1; }

-static int ec_buffer(char ec) +static int ec_buffer(char loc, char cmd, char arg) {

• char arg[EXLEN]; char ln[128]; int id; int i;
• ex_arg(ec, arg); id = arg[0] ? atoi(arg) : 0; for (i = 0; i < LEN(bufs) && bufs[i].lb; i++) { if (id) { @@ -356,10 +310,8 @@ static int ec_buffer(char *ec) return 0; }

-static int ec_quit(char ec) +static int ec_quit(char loc, char cmd, char arg) {

• char cmd[EXLEN];
• ex_cmd(ec, cmd); if (!strchr(cmd, '!')) if (ex_modifiedbuffer("buffer modified\n")) return 1; @@ -367,15 +319,11 @@ static int ec_quit(char *ec) return 0; }

-static int ec_edit(char ec) +static int ec_edit(char loc, char cmd, char arg) { char msg[128];

• char cmd[EXLEN];
• char arg[EXLEN]; char *path; int fd;
• ex_cmd(ec, cmd);
• ex_arg(ec, arg); if (!strchr(cmd, '!')) if (xb && ex_modifiedbuffer("buffer modified\n")) return 1; @@ -408,16 +356,13 @@ static int ec_edit(char *ec) return 0; }

-static int ec_read(char ec) +static int ec_read(char loc, char cmd, char arg) {

• char arg[EXLEN], loc[EXLEN]; char msg[128]; int beg, end; char path; char obuf; int n = lbuf_len(xb);
• ex_arg(ec, arg);
• ex_loc(ec, loc); path = arg[0] ? arg : ex_path(); if (ex_region(loc, &beg, &end)) return 1; @@ -452,19 +397,15 @@ static int ec_read(char *ec) return 0; }

-static int ec_write(char ec) +static int ec_write(char loc, char cmd, char arg) {

• char cmd[EXLEN], arg[EXLEN], loc[EXLEN]; char msg[128]; char path; char ibuf; int beg, end;
• ex_cmd(ec, cmd);
• ex_arg(ec, arg);
• ex_loc(ec, loc); path = arg[0] ? arg : ex_path(); if (cmd[0] == 'x' && !lbuf_modified(xb))
• return ec_quit(cmd);
• return ec_quit("", cmd, ""); if (ex_region(loc, &beg, &end)) return 1; if (!loc[0]) { @@ -516,20 +457,16 @@ static int ec_write(char *ec) if (!strcmp(ex_path(), path)) bufs[0].mtime = mtime(path); if (cmd[0] == 'x' || (cmd[0] == 'w' && cmd[1] == 'q'))
• ec_quit(cmd);
• ec_quit("", cmd, ""); return 0; }

-static int ec_insert(char ec) +static int ec_insert(char loc, char cmd, char arg) {

• char arg[EXLEN], cmd[EXLEN], loc[EXLEN]; struct sbuf sb; char s; int beg, end; int n;
• ex_arg(ec, arg);
• ex_cmd(ec, cmd);
• ex_loc(ec, loc); if (ex_region(loc, &beg, &end) && (beg != 0 || end != 0)) return 1; sb = sbuf_make(); @@ -554,13 +491,10 @@ static int ec_insert(char *ec) return 0; }

-static int ec_print(char ec) +static int ec_print(char loc, char cmd, char arg) {

• char cmd[EXLEN], loc[EXLEN]; int beg, end; int i;
• ex_cmd(ec, cmd);
• ex_loc(ec, loc); if (!cmd[0] && !loc[0]) if (xrow >= lbuf_len(xb)) return 1; @@ -573,13 +507,11 @@ static int ec_print(char *ec) return 0; }

-static int ec_null(char ec) +static int ec_null(char loc, char cmd, char arg) {

• char loc[EXLEN]; int beg, end; if (!xvis)
• return ec_print(ec);
• ex_loc(ec, loc);
• return ec_print(loc, cmd, arg); if (ex_region(loc, &beg, &end)) return 1; xrow = MAX(beg, end - 1); @@ -594,13 +526,9 @@ static void ex_yank(int reg, int beg, int end) free(buf); }

-static int ec_delete(char ec) +static int ec_delete(char loc, char cmd, char arg) {

• char loc[EXLEN];
• char arg[EXLEN]; int beg, end;
• ex_loc(ec, loc);
• ex_arg(ec, arg); if (ex_region(loc, &beg, &end) || !lbuf_len(xb)) return 1; ex_yank(arg[0], beg, end); @@ -609,29 +537,21 @@ static int ec_delete(char *ec) return 0; }

-static int ec_yank(char ec) +static int ec_yank(char loc, char cmd, char arg) {

• char loc[EXLEN];
• char arg[EXLEN]; int beg, end;
• ex_loc(ec, loc);
• ex_arg(ec, arg); if (ex_region(loc, &beg, &end) || !lbuf_len(xb)) return 1; ex_yank(arg[0], beg, end); return 0; }

-static int ec_put(char ec) +static int ec_put(char loc, char cmd, char arg) {

• char loc[EXLEN];
• char arg[EXLEN]; int beg, end; int lnmode; char *buf; int n = lbuf_len(xb);
• ex_loc(ec, loc);
• ex_arg(ec, arg); buf = reg_get(arg[0], &lnmode); if (!buf || ex_region(loc, &beg, &end)) return 1; @@ -640,12 +560,10 @@ static int ec_put(char *ec) return 0; }

-static int ec_lnum(char ec) +static int ec_lnum(char loc, char cmd, char arg) {

• char loc[EXLEN]; char msg[128]; int beg, end;
• ex_loc(ec, loc); if (ex_region(loc, &beg, &end)) return 1; sprintf(msg, "%d\n", end); @@ -653,22 +571,19 @@ static int ec_lnum(char *ec) return 0; }

-static int ec_undo(char ec) +static int ec_undo(char loc, char cmd, char arg) { return lbuf_undo(xb); }

-static int ec_redo(char ec) +static int ec_redo(char loc, char cmd, char arg) { return lbuf_redo(xb); }

-static int ec_mark(char ec) +static int ec_mark(char loc, char cmd, char arg) {

• char loc[EXLEN], arg[EXLEN]; int beg, end;
• ex_arg(ec, arg);
• ex_loc(ec, loc); if (ex_region(loc, &beg, &end)) return 1; lbuf_mark(xb, arg[0], end - 1, 0); @@ -694,9 +609,8 @@ static void replace(struct sbuf dst, char rep, char ln, int offs) } }

-static int ec_substitute(char ec) +static int ec_substitute(char loc, char cmd, char arg) {

• char loc[EXLEN], arg[EXLEN]; struct rset re; int offs[32]; int beg, end; @@ -704,8 +618,6 @@ static int ec_substitute(char ec) char pat = NULL, rep = NULL; char *s = arg; int i;
• ex_loc(ec, loc);
• ex_arg(ec, arg); if (ex_region(loc, &beg, &end)) return 1; pat = re_read(&s); @@ -751,17 +663,13 @@ static int ec_substitute(char *ec) return 0; }

-static int ec_exec(char ec) +static int ec_exec(char loc, char cmd, char arg) {

• char loc[EXLEN];
• char arg[EXLEN]; int beg, end; char text; char rep; char *ecmd; ex_modifiedbuffer(NULL);
• ex_loc(ec, loc);
• ex_arg(ec, arg); if (!(ecmd = ex_filearg(arg, 1))) return 1; if (!loc[0]) { @@ -785,13 +693,11 @@ static int ec_exec(char *ec) return 0; }

-static int ec_make(char ec) +static int ec_make(char log, char cmd, char arg) {

• char arg[EXLEN]; char make[EXLEN]; char *target; ex_modifiedbuffer(NULL);
• ex_arg(ec, arg); if (!(target = ex_filearg(arg, 0))) return 1; sprintf(make, "make %s", target); @@ -802,10 +708,8 @@ static int ec_make(char *ec) return 0; }

-static int ec_ft(char ec) +static int ec_ft(char loc, char cmd, char arg) {

• char arg[EXLEN];
• ex_arg(ec, arg); if (arg[0]) snprintf(bufs[0].ft, sizeof(bufs[0].ft), "%s", arg); else @@ -813,12 +717,8 @@ static int ec_ft(char *ec) return 0; }

-static int ec_cmap(char ec) +static int ec_cmap(char loc, char cmd, char arg) {

• char cmd[EXLEN];
• char arg[EXLEN];
• ex_cmd(ec, cmd);

• ex_arg(ec, arg); if (arg[0]) xkmap_alt = conf_kmapfind(arg); else @@ -830,9 +730,8 @@ static int ec_cmap(char *ec)

  static int ex_exec(char *ln);

-static int ec_glob(char ec) +static int ec_glob(char loc, char cmd, char arg) {

• char loc[EXLEN], cmd[EXLEN], arg[EXLEN]; struct rset re; int offs[32]; int beg, end, not; @@ -840,9 +739,6 @@ static int ec_glob(char ec) char pat; char s = arg; int i;
• ex_cmd(ec, cmd);
• ex_loc(ec, loc);
• ex_arg(ec, arg); if (!loc[0] && !xgdep) strcpy(loc, "%"); if (ex_region(loc, &beg, &end)) @@ -905,15 +801,13 @@ static char cutword(char s, char *d) return s; }

-static int ec_set(char ec) +static int ec_set(char loc, char cmd, char arg) {

• char arg[EXLEN]; char tok[EXLEN]; char opt[EXLEN]; char *s = arg; int val = 0; int i;
• ex_arg(ec, arg); if (s) { s = cutword(s, tok); if (tok[0] == 'n' && tok[1] == 'o') { @@ -946,7 +840,7 @@ static int ec_set(char ec) static struct excmd { char abbr; char name;
• int (ec)(char s);
• int (ec)(char loc, char cmd, char arg); } excmds[] = { {"b", "buffer", ec_buffer}, {"p", "print", ec_print}, @@ -993,6 +887,46 @@ static int ex_idx(char *cmd) return -1; }

+/ read ex command addresses / +static char ex_loc(char src, char *loc) +{

• while (src == ':' || src == ' ' || *src == '\t')
• src++;
• while (src && !isalpha((unsigned char) src) && src != '=' && src != '!') {
• if (*src == '\'')
• loc++ = src++;
• if (src == '/' || src == '?') {
• int d = *src;
• loc++ = src++;
• while (src && src != d) {
• if (*src == '\' && src[1])
• loc++ = src++;
• loc++ = src++;
• }
• }
• if (*src)
• loc++ = src++;
• }
• *loc = '\0';
• return src; +}

• +/ read ex command name / +static char ex_cmd(char src, char *cmd) +{

• char *cmd0 = cmd;
• src = ex_loc(src, cmd);
• while (src == ' ' || src == '\t')
• src++;
• while (isalpha((unsigned char) *src) && cmd < cmd0 + 16)
• if ((cmd++ = src++) == 'k' && cmd == cmd0 + 1)
• break;
• if (src == '!' || src == '=')
• cmd++ = src++;
• *cmd = '\0';
• return src; +}

• / read ex command argument / static char ex_arg(char src, char dst) { @@ -1039,34 +973,27 @@ static char ex_arg(char src, char dst) }

  / read an ex command and its arguments from src into dst / -static char ex_line(char src, char dst) +static char ex_line(char src, char loc, char cmd, char arg) {

• char loc[EXLEN];
• char cmd[EXLEN];
• char arg[EXLEN]; ex_loc(src, loc); ex_cmd(src, cmd);
• src = ex_arg(src, arg);
• sprintf(dst, "%s%s %s", loc, cmd, arg);
• return src;

• return ex_arg(src, arg); }

  / execute a single ex command / static int ex_exec(char *ln) {

• char ec[EXLEN];
• char cmd[EXLEN];
• char loc[EXLEN], cmd[EXLEN], arg[EXLEN]; int idx; int ret = 0; while (*ln) {
• ex_cmd(ln, cmd); if (strlen(ln) >= EXLEN) { ex_show("command too long"); return 1; }
• ln = ex_line(ln, ec);
• ln = ex_line(ln, loc, cmd, arg); if ((idx = ex_idx(cmd)) >= 0)
• ret = excmds[idx].ec(ec);

• ret = excmds[idx].ec(loc, cmd, arg); } return ret; } @@ -1092,18 +1019,16 @@ void ex(void)

  int ex_init(char **files) {

• char cmd[EXLEN];
• char *s = cmd;
• char arg[EXLEN];
• char s = arg; char r = files[0] ? files[0] : "";
• *s++ = 'e';
• *s++ = ' ';
• while (*r && s + 2 < cmd + sizeof(cmd)) {
• while (r && s + 2 < arg + sizeof(arg)) { if (r == ' ' || r == '%' || r == '#') s++ = '\'; s++ = r++; } s = '\0';
• if (ec_edit(cmd))
• if (ec_edit("", "e", arg)) return 1; if (getenv("EXINIT")) ex_command(getenv("EXINIT"));

[aligrudi]

Another updated patch: ex_filearg() -> ex_pathexpand()

Ali

diff --git a/ex.c b/ex.c index 7066302..47c2421 100644 --- a/ex.c +++ b/ex.c @@ -114,52 +114,8 @@ char *ex_filetype(void) return bufs[0].ft; }

-static char ex_loc(char src, char loc); -static char ex_cmd(char src, char cmd); -static char ex_arg(char src, char *arg);

-/ read ex command location / -static char ex_loc(char src, char *loc) -{

• while (src == ':' || src == ' ' || *src == '\t')
• src++;
• while (src && !isalpha((unsigned char) src) && src != '=' && src != '!') {
• if (*src == '\'')
• loc++ = src++;
• if (src == '/' || src == '?') {
• int d = *src;
• loc++ = src++;
• while (src && src != d) {
• if (*src == '\' && src[1])
• loc++ = src++;
• loc++ = src++;
• }
• }
• if (*src)
• loc++ = src++;
• }
• *loc = '\0';
• return src; -}

• -/ read ex command name / -static char ex_cmd(char src, char *cmd) -{

• char *cmd0 = cmd;
• src = ex_loc(src, cmd);
• while (src == ' ' || src == '\t')
• src++;
• while (isalpha((unsigned char) *src) && cmd < cmd0 + 16)
• if ((cmd++ = src++) == 'k' && cmd == cmd0 + 1)
• break;
• if (src == '!' || src == '=')
• cmd++ = src++;
• *cmd = '\0';
• return src; -}

• -/ read ex file argument / -static char ex_filearg(char src, int spaceallowed) +/ replace % and # in paths and commands with current and alternate path names / +static char ex_pathexpand(char src, int spaceallowed) { struct sbuf sb = sbuf_make(); while (src && src != '\n' && (spaceallowed || (src != ' ' && *src != '\t'))) { @@ -280,7 +236,7 @@ static int ex_lineno(char **num) return n; }

-/ parse ex command location / +/ parse ex command addresses / static int ex_region(char loc, int beg, int end) { int naddr = 0; @@ -315,26 +271,24 @@ static int ex_region(char loc, int beg, int end) return 0; }

-static int ec_write(char ec); +static int ec_write(char loc, char cmd, char arg);

static int ex_modifiedbuffer(char *msg) { if (!lbuf_modified(xb)) return 0; if (xaw && ex_path()[0])

• return ec_write("w");
• return ec_write("", "w", ""); if (msg) ex_show(msg); return 1; }

-static int ec_buffer(char ec) +static int ec_buffer(char loc, char cmd, char arg) {

• char arg[EXLEN]; char ln[128]; int id; int i;
• ex_arg(ec, arg); id = arg[0] ? atoi(arg) : 0; for (i = 0; i < LEN(bufs) && bufs[i].lb; i++) { if (id) { @@ -356,10 +310,8 @@ static int ec_buffer(char *ec) return 0; }

-static int ec_quit(char ec) +static int ec_quit(char loc, char cmd, char arg) {

• char cmd[EXLEN];
• ex_cmd(ec, cmd); if (!strchr(cmd, '!')) if (ex_modifiedbuffer("buffer modified\n")) return 1; @@ -367,19 +319,15 @@ static int ec_quit(char *ec) return 0; }

-static int ec_edit(char ec) +static int ec_edit(char loc, char cmd, char arg) { char msg[128];

• char cmd[EXLEN];
• char arg[EXLEN]; char *path; int fd;
• ex_cmd(ec, cmd);
• ex_arg(ec, arg); if (!strchr(cmd, '!')) if (xb && ex_modifiedbuffer("buffer modified\n")) return 1;
• if (!(path = ex_filearg(arg, 0)))
• if (!(path = ex_pathexpand(arg, 0))) return 1; if (path[0] && bufs_find(path) >= 0) { bufs_switch(bufs_find(path)); @@ -408,22 +356,19 @@ static int ec_edit(char *ec) return 0; }

-static int ec_read(char ec) +static int ec_read(char loc, char cmd, char arg) {

• char arg[EXLEN], loc[EXLEN]; char msg[128]; int beg, end; char path; char obuf; int n = lbuf_len(xb);
• ex_arg(ec, arg);
• ex_loc(ec, loc); path = arg[0] ? arg : ex_path(); if (ex_region(loc, &beg, &end)) return 1; if (arg[0] == '!') { int pos = MIN(xrow + 1, lbuf_len(xb));
• char *ecmd = ex_filearg(arg, 1);
• char ecmd = ex_pathexpand(arg, 1); if (!ecmd) return 1; obuf = cmd_pipe(ecmd + 1, NULL, 0, 1); @@ -452,19 +397,15 @@ static int ec_read(char ec) return 0; }

-static int ec_write(char ec) +static int ec_write(char loc, char cmd, char arg) {

• char cmd[EXLEN], arg[EXLEN], loc[EXLEN]; char msg[128]; char path; char ibuf; int beg, end;
• ex_cmd(ec, cmd);
• ex_arg(ec, arg);
• ex_loc(ec, loc); path = arg[0] ? arg : ex_path(); if (cmd[0] == 'x' && !lbuf_modified(xb))
• return ec_quit(cmd);
• return ec_quit("", cmd, ""); if (ex_region(loc, &beg, &end)) return 1; if (!loc[0]) { @@ -472,7 +413,7 @@ static int ec_write(char *ec) end = lbuf_len(xb); } if (arg[0] == '!') {
• char *ecmd = ex_filearg(arg, 1);
• char ecmd = ex_pathexpand(arg, 1); if (!ecmd) return 1; ibuf = lbuf_cp(xb, beg, end); @@ -516,20 +457,16 @@ static int ec_write(char ec) if (!strcmp(ex_path(), path)) bufs[0].mtime = mtime(path); if (cmd[0] == 'x' || (cmd[0] == 'w' && cmd[1] == 'q'))
• ec_quit(cmd);
• ec_quit("", cmd, ""); return 0; }

-static int ec_insert(char ec) +static int ec_insert(char loc, char cmd, char arg) {

• char arg[EXLEN], cmd[EXLEN], loc[EXLEN]; struct sbuf sb; char s; int beg, end; int n;
• ex_arg(ec, arg);
• ex_cmd(ec, cmd);
• ex_loc(ec, loc); if (ex_region(loc, &beg, &end) && (beg != 0 || end != 0)) return 1; sb = sbuf_make(); @@ -554,13 +491,10 @@ static int ec_insert(char *ec) return 0; }

-static int ec_print(char ec) +static int ec_print(char loc, char cmd, char arg) {

• char cmd[EXLEN], loc[EXLEN]; int beg, end; int i;
• ex_cmd(ec, cmd);
• ex_loc(ec, loc); if (!cmd[0] && !loc[0]) if (xrow >= lbuf_len(xb)) return 1; @@ -573,13 +507,11 @@ static int ec_print(char *ec) return 0; }

-static int ec_null(char ec) +static int ec_null(char loc, char cmd, char arg) {

• char loc[EXLEN]; int beg, end; if (!xvis)
• return ec_print(ec);
• ex_loc(ec, loc);
• return ec_print(loc, cmd, arg); if (ex_region(loc, &beg, &end)) return 1; xrow = MAX(beg, end - 1); @@ -594,13 +526,9 @@ static void ex_yank(int reg, int beg, int end) free(buf); }

-static int ec_delete(char ec) +static int ec_delete(char loc, char cmd, char arg) {

• char loc[EXLEN];
• char arg[EXLEN]; int beg, end;
• ex_loc(ec, loc);
• ex_arg(ec, arg); if (ex_region(loc, &beg, &end) || !lbuf_len(xb)) return 1; ex_yank(arg[0], beg, end); @@ -609,29 +537,21 @@ static int ec_delete(char *ec) return 0; }

-static int ec_yank(char ec) +static int ec_yank(char loc, char cmd, char arg) {

• char loc[EXLEN];
• char arg[EXLEN]; int beg, end;
• ex_loc(ec, loc);
• ex_arg(ec, arg); if (ex_region(loc, &beg, &end) || !lbuf_len(xb)) return 1; ex_yank(arg[0], beg, end); return 0; }

-static int ec_put(char ec) +static int ec_put(char loc, char cmd, char arg) {

• char loc[EXLEN];
• char arg[EXLEN]; int beg, end; int lnmode; char *buf; int n = lbuf_len(xb);
• ex_loc(ec, loc);
• ex_arg(ec, arg); buf = reg_get(arg[0], &lnmode); if (!buf || ex_region(loc, &beg, &end)) return 1; @@ -640,12 +560,10 @@ static int ec_put(char *ec) return 0; }

-static int ec_lnum(char ec) +static int ec_lnum(char loc, char cmd, char arg) {

• char loc[EXLEN]; char msg[128]; int beg, end;
• ex_loc(ec, loc); if (ex_region(loc, &beg, &end)) return 1; sprintf(msg, "%d\n", end); @@ -653,22 +571,19 @@ static int ec_lnum(char *ec) return 0; }

-static int ec_undo(char ec) +static int ec_undo(char loc, char cmd, char arg) { return lbuf_undo(xb); }

-static int ec_redo(char ec) +static int ec_redo(char loc, char cmd, char arg) { return lbuf_redo(xb); }

-static int ec_mark(char ec) +static int ec_mark(char loc, char cmd, char arg) {

• char loc[EXLEN], arg[EXLEN]; int beg, end;
• ex_arg(ec, arg);
• ex_loc(ec, loc); if (ex_region(loc, &beg, &end)) return 1; lbuf_mark(xb, arg[0], end - 1, 0); @@ -694,9 +609,8 @@ static void replace(struct sbuf dst, char rep, char ln, int offs) } }

-static int ec_substitute(char ec) +static int ec_substitute(char loc, char cmd, char arg) {

• char loc[EXLEN], arg[EXLEN]; struct rset re; int offs[32]; int beg, end; @@ -704,8 +618,6 @@ static int ec_substitute(char ec) char pat = NULL, rep = NULL; char *s = arg; int i;
• ex_loc(ec, loc);
• ex_arg(ec, arg); if (ex_region(loc, &beg, &end)) return 1; pat = re_read(&s); @@ -751,18 +663,14 @@ static int ec_substitute(char *ec) return 0; }

-static int ec_exec(char ec) +static int ec_exec(char loc, char cmd, char arg) {

• char loc[EXLEN];
• char arg[EXLEN]; int beg, end; char text; char rep; char *ecmd; ex_modifiedbuffer(NULL);
• ex_loc(ec, loc);
• ex_arg(ec, arg);
• if (!(ecmd = ex_filearg(arg, 1)))
• if (!(ecmd = ex_pathexpand(arg, 1))) return 1; if (!loc[0]) { int ret; @@ -785,14 +693,12 @@ static int ec_exec(char *ec) return 0; }

-static int ec_make(char ec) +static int ec_make(char log, char cmd, char arg) {

• char arg[EXLEN]; char make[EXLEN]; char *target; ex_modifiedbuffer(NULL);
• ex_arg(ec, arg);
• if (!(target = ex_filearg(arg, 0)))
• if (!(target = ex_pathexpand(arg, 0))) return 1; sprintf(make, "make %s", target); free(target); @@ -802,10 +708,8 @@ static int ec_make(char *ec) return 0; }

-static int ec_ft(char ec) +static int ec_ft(char loc, char cmd, char arg) {

• char arg[EXLEN];
• ex_arg(ec, arg); if (arg[0]) snprintf(bufs[0].ft, sizeof(bufs[0].ft), "%s", arg); else @@ -813,12 +717,8 @@ static int ec_ft(char *ec) return 0; }

-static int ec_cmap(char ec) +static int ec_cmap(char loc, char cmd, char arg) {

• char cmd[EXLEN];
• char arg[EXLEN];
• ex_cmd(ec, cmd);

• ex_arg(ec, arg); if (arg[0]) xkmap_alt = conf_kmapfind(arg); else @@ -830,9 +730,8 @@ static int ec_cmap(char *ec)

  static int ex_exec(char *ln);

-static int ec_glob(char ec) +static int ec_glob(char loc, char cmd, char arg) {

• char loc[EXLEN], cmd[EXLEN], arg[EXLEN]; struct rset re; int offs[32]; int beg, end, not; @@ -840,9 +739,6 @@ static int ec_glob(char ec) char pat; char s = arg; int i;
• ex_cmd(ec, cmd);
• ex_loc(ec, loc);
• ex_arg(ec, arg); if (!loc[0] && !xgdep) strcpy(loc, "%"); if (ex_region(loc, &beg, &end)) @@ -905,15 +801,13 @@ static char cutword(char s, char *d) return s; }

-static int ec_set(char ec) +static int ec_set(char loc, char cmd, char arg) {

• char arg[EXLEN]; char tok[EXLEN]; char opt[EXLEN]; char *s = arg; int val = 0; int i;
• ex_arg(ec, arg); if (s) { s = cutword(s, tok); if (tok[0] == 'n' && tok[1] == 'o') { @@ -946,7 +840,7 @@ static int ec_set(char ec) static struct excmd { char abbr; char name;
• int (ec)(char s);
• int (ec)(char loc, char cmd, char arg); } excmds[] = { {"b", "buffer", ec_buffer}, {"p", "print", ec_print}, @@ -993,15 +887,49 @@ static int ex_idx(char *cmd) return -1; }

-/ read ex command argument / -static char ex_arg(char src, char dst) +/ read ex command addresses / +static char ex_loc(char src, char loc) +{

• while (src == ':' || src == ' ' || *src == '\t')
• src++;
• while (src && !isalpha((unsigned char) src) && src != '=' && src != '!') {
• if (*src == '\'')
• loc++ = src++;
• if (src == '/' || src == '?') {
• int d = *src;
• loc++ = src++;
• while (src && src != d) {
• if (*src == '\' && src[1])
• loc++ = src++;
• loc++ = src++;
• }
• }
• if (*src)
• loc++ = src++;
• }
• *loc = '\0';
• return src; +}

• +/ read ex command name / +static char ex_cmd(char src, char *cmd) +{

• char *cmd0 = cmd;
• while (src == ' ' || src == '\t')
• src++;
• while (isalpha((unsigned char) *src) && cmd < cmd0 + 16)
• if ((cmd++ = src++) == 'k' && cmd == cmd0 + 1)
• break;
• if (src == '!' || src == '=')
• cmd++ = src++;
• *cmd = '\0';
• return src; +}

• +/ read ex command argument for excmd command / +static char ex_arg(char src, char dst, char excmd) {

• char loc[EXLEN];
• char cmd[EXLEN];
• int c0;
• ex_loc(src, loc);
• src = ex_cmd(src, cmd);
• c0 = ex_idx(cmd) >= 0 ? excmds[ex_idx(cmd)].abbr[0] : -1;
• int c0 = excmd[0]; while (src == ' ' || src == '\t') src++; if (c0 == '!' || c0 == 'g' || c0 == 'v' || @@ -1038,35 +966,23 @@ static char ex_arg(char src, char *dst) return src; }

-/ read an ex command and its arguments from src into dst / -static char ex_line(char src, char *dst) -{

• char loc[EXLEN];
• char cmd[EXLEN];
• char arg[EXLEN];
• ex_loc(src, loc);
• ex_cmd(src, cmd);
• src = ex_arg(src, arg);
• sprintf(dst, "%s%s %s", loc, cmd, arg);
• return src; -}

• / execute a single ex command / static int ex_exec(char *ln) {

• char ec[EXLEN];
• char cmd[EXLEN];
• char loc[EXLEN], cmd[EXLEN], arg[EXLEN]; int idx; int ret = 0; while (*ln) {
• ex_cmd(ln, cmd); if (strlen(ln) >= EXLEN) { ex_show("command too long"); return 1; }
• ln = ex_line(ln, ec);
• if ((idx = ex_idx(cmd)) >= 0)
• ret = excmds[idx].ec(ec);
• ln = ex_loc(ln, loc);
• ln = ex_cmd(ln, cmd);
• if ((idx = ex_idx(cmd)) >= 0) {
• ln = ex_arg(ln, arg, excmds[idx].abbr);
• ret = excmds[idx].ec(loc, cmd, arg);

• } } return ret; } @@ -1092,18 +1008,16 @@ void ex(void)

  int ex_init(char **files) {

• char cmd[EXLEN];
• char *s = cmd;
• char arg[EXLEN];
• char s = arg; char r = files[0] ? files[0] : "";
• *s++ = 'e';
• *s++ = ' ';
• while (*r && s + 2 < cmd + sizeof(cmd)) {
• while (r && s + 2 < arg + sizeof(arg)) { if (r == ' ' || r == '%' || r == '#') s++ = '\'; s++ = r++; } s = '\0';
• if (ec_edit(cmd))
• if (ec_edit("", "e", arg)) return 1; if (getenv("EXINIT")) ex_command(getenv("EXINIT"));

[kyx0r]

Thanks for the refactor, now the patch actually stated to make sense. I have applied the changes to nextvi now. In the process I found a few memory leaks not pertaining to the patch though. See this commit: https://github.com/kyx0r/nextvi/commit/bd6dc5cf626a35d8b9743f347763a7da4b989496

The memleaks are in re_read() and ec_substitute() functions. Also take a look how I simplified your ex_arg() function. If the command is 's' I allow escapes to pass though, otherwise I check for them, a single escape will be skipped, if the bar is unescaped we stop. In your implementation I don't know why are you checking for the newline character and the quote character, led_prompt doesn't allow a new line character to be inserted. Just checking for NULL is enough. There is no reason to have this many separators, makes it ugly and complicated to understand.

[aligrudi]

Kyryl @.***> wrote:

Thanks for the refactor, now the patch actually stated to make sense. I have applied the changes to nextvi now. In the process I found a few memory leaks not pertaining to the patch though. See this commit: https://github.com/kyx0r/nextvi/commit/bd6dc5cf626a35d8b9743f347763a7da4b989496

The memleaks are in re_read() and ec_substitute() functions.

Thanks. Both should be fixed now.

Also take a look how I simplified your ex_arg() function. If the command is 's' I allow escapes to pass though, otherwise I check for them, a single escape will be skipped, if the bar is unescaped we stop. In your implementation I don't know why are you checking for the newline character and the quote character, led_prompt doesn't allow a new line character to be inserted. Just checking for NULL is enough. There is no reason to have this many separators, makes it ugly and complicated to understand.

Maybe now it is a good idea to support ~/.exrc?

Ali

[kyx0r]

Well, no I don't think .exrc is a good idea at all. The man page may say it, but generally most people will be compiling from source, so they can customize in source code. This makes it fast, efficient and secure. For anything else we already got EXINIT variable being checked, and having the bar as only separator is sufficient enough.

[kyx0r]

Okay, I changed my solution again, having to check for if a specific command and do some special case handling completely sucks. If someone wants to implement a new ex command they have to be aware of what the heck ex_arg() is doing (and that is not easy to understand) and continue to add into that enourmous if statement which checks for what command is going on. Nextvi has like 5 new ex commands, so obviously I would never want to have a freaking if statement with 10 ors. So instead I opt into a universal solution which will work consitently with any ex command, except the bar and slash condition. Only in that one case in the universe a special treatment is needed. But escape like "|" will remain consistant. And most of the time user will only need one escape, on other cases an | will need more escapes, but this is rather rare in practice.

My simple code:

static char *ex_arg(char *src, char *dst)
{
    while (*src == ' ' || *src == '\t')
        src++;
    while (*src && (*src != '|' || src[-1] == '\\'))
    {
        if (!strncmp(src, "\\\\|", 3))
            src += 2;
        *dst++ = *src++;
    }
    *dst = '\0';
    return src;
}

This is able to get any input/output string combination.

[kyx0r]

Also note that doing src[-1] is completely safe in this situation because there will always be at least 1 byte past src.