diff options
| -rw-r--r-- | input/input.c | 219 | ||||
| -rw-r--r-- | input/input.h | 13 | ||||
| -rw-r--r-- | player/lua.c | 23 |
3 files changed, 185 insertions, 70 deletions
diff --git a/input/input.c b/input/input.c index 6ae14f892d..942dd00782 100644 --- a/input/input.c +++ b/input/input.c @@ -871,16 +871,6 @@ static bool read_token(bstr str, bstr *out_rest, bstr *out_token) return true; } -static bool eat_token(bstr *str, const char *tok) -{ - bstr rest, token; - if (read_token(*str, &rest, &token) && bstrcmp0(token, tok) == 0) { - *str = rest; - return true; - } - return false; -} - static bool read_escaped_string(void *talloc_ctx, bstr *str, bstr *literal) { bstr t = *str; @@ -906,6 +896,60 @@ error: return false; } +// Somewhat awkward; the main purpose is supporting both strings and +// pre-split string arrays as input. +struct parse_ctx { + struct mp_log *log; + const char *loc; + void *tmp; + bool array_input; // false: use start/str, true: use num_strs/strs + bstr start, str; + bstr *strs; + int num_strs; +}; + +static int pctx_read_token(struct parse_ctx *ctx, bstr *out) +{ + *out = (bstr){0}; + if (ctx->array_input) { + if (!ctx->num_strs) + return 0; + *out = ctx->strs[0]; + ctx->strs++; + ctx->num_strs--; + return 1; + } else { + ctx->str = bstr_lstrip(ctx->str); + bstr start = ctx->str; + if (bstr_eatstart0(&ctx->str, "\"")) { + if (!read_escaped_string(ctx->tmp, &ctx->str, out)) { + MP_ERR(ctx, "Broken string escapes: ...>%.*s<.\n", BSTR_P(start)); + return -1; + } + if (!bstr_eatstart0(&ctx->str, "\"")) { + MP_ERR(ctx, "Unterminated quotes: ...>%.*s<.\n", BSTR_P(start)); + return -1; + } + return 1; + } + return read_token(ctx->str, &ctx->str, out) ? 1 : 0; + } +} + +static bstr pctx_get_trailing(struct parse_ctx *ctx) +{ + if (ctx->array_input) { + if (ctx->num_strs == 0) + return (bstr){0}; + return ctx->strs[0]; // mentioning the first trailing arg is enough? + } else { + bstr dummy; + if (!read_token(ctx->str, &dummy, &dummy)) + return (bstr){0}; + return ctx->str; + } +} + struct flag { const char *name; unsigned int remove, add; @@ -924,35 +968,40 @@ static const struct flag cmd_flags[] = { {0} }; -// If dest is non-NULL when calling this function, append the command to the -// list formed by dest->queue_next, otherwise just set *dest = new_cmd; -static struct mp_cmd *parse_cmd(struct input_ctx *ictx, bstr *pstr, const char *loc) +static struct mp_cmd *parse_cmd(struct parse_ctx *ctx, int def_flags) { - int def_flags = MP_ON_OSD_AUTO | MP_EXPAND_PROPERTIES; struct mp_cmd *cmd = NULL; - bstr str = *pstr; - bstr start = str; - void *tmp = talloc_new(NULL); + int r; - str = bstr_lstrip(str); - for (const struct legacy_cmd *entry = legacy_cmds; entry->old; entry++) { - bstr old = bstr0(entry->old); - bool silent = bstr_eatstart0(&old, "!"); - if (bstrcasecmp(bstr_splice(str, 0, old.len), old) == 0) { - if (!silent) { - MP_WARN(ictx, "Warning: command '%.*s' is deprecated, replaced " - "with '%s' at %s.\n", BSTR_P(old), entry->new, loc); + if (!ctx->array_input) { + ctx->str = bstr_lstrip(ctx->str); + for (const struct legacy_cmd *entry = legacy_cmds; entry->old; entry++) { + bstr old = bstr0(entry->old); + bool silent = bstr_eatstart0(&old, "!"); + if (bstrcasecmp(bstr_splice(ctx->str, 0, old.len), old) == 0) { + if (!silent) { + MP_WARN(ctx, "Warning: command '%.*s' is deprecated, " + "replaced with '%s' at %s.\n", + BSTR_P(old), entry->new, ctx->loc); + } + bstr s = bstr_cut(ctx->str, old.len); + ctx->str = bstr0(talloc_asprintf(ctx->tmp, "%s%.*s", entry->new, + BSTR_P(s))); + ctx->start = ctx->str; + break; } - bstr s = bstr_cut(str, old.len); - str = bstr0(talloc_asprintf(tmp, "%s%.*s", entry->new, BSTR_P(s))); - start = str; - break; } } + bstr cur_token; + if (pctx_read_token(ctx, &cur_token) < 0) + goto error; + while (1) { for (int n = 0; cmd_flags[n].name; n++) { - if (eat_token(&str, cmd_flags[n].name)) { + if (bstr_equals0(cur_token, cmd_flags[n].name)) { + if (pctx_read_token(ctx, &cur_token) < 0) + goto error; def_flags &= ~cmd_flags[n].remove; def_flags |= cmd_flags[n].add; goto cont; @@ -962,21 +1011,20 @@ static struct mp_cmd *parse_cmd(struct input_ctx *ictx, bstr *pstr, const char * cont: ; } - bstr cmd_name; - if (!read_token(str, &str, &cmd_name)) { - MP_ERR(ictx, "Command name missing.\n"); + if (cur_token.len == 0) { + MP_ERR(ctx, "Command name missing.\n"); goto error; } const struct mp_cmd_def *cmd_def = NULL; for (int n = 0; mp_cmds[n].name; n++) { - if (bstr_equals0(cmd_name, mp_cmds[n].name)) { + if (bstr_equals0(cur_token, mp_cmds[n].name)) { cmd_def = &mp_cmds[n]; break; } } if (!cmd_def) { - MP_ERR(ictx, "Command '%.*s' not found.\n", BSTR_P(cmd_name)); + MP_ERR(ctx, "Command '%.*s' not found.\n", BSTR_P(cur_token)); goto error; } @@ -998,26 +1046,12 @@ static struct mp_cmd *parse_cmd(struct input_ctx *ictx, bstr *pstr, const char * if (!opt->type) break; - str = bstr_lstrip(str); - bstr arg = {0}; - bool got_token = false; - if (bstr_eatstart0(&str, "\"")) { - if (!read_escaped_string(tmp, &str, &arg)) { - MP_ERR(ictx, "Command %s: argument %d has broken string escapes.\n", - cmd->name, i + 1); - goto error; - } - if (!bstr_eatstart0(&str, "\"")) { - MP_ERR(ictx, "Command %s: argument %d is unterminated.\n", - cmd->name, i + 1); - goto error; - } - got_token = true; - } else { - got_token = read_token(str, &str, &arg); + r = pctx_read_token(ctx, &cur_token); + if (r < 0) { + MP_ERR(ctx, "Command %s: error in argument %d.\n", cmd->name, i + 1); + goto error; } - - if (!got_token) { + if (r < 1) { if (is_vararg) continue; // Skip optional arguments @@ -1028,7 +1062,7 @@ static struct mp_cmd *parse_cmd(struct input_ctx *ictx, bstr *pstr, const char * cmd->nargs++; continue; } - MP_ERR(ictx, "Command %s requires more than %d arguments.\n", + MP_ERR(ctx, "Command %s: more than %d arguments required.\n", cmd->name, cmd->nargs); goto error; } @@ -1036,9 +1070,9 @@ static struct mp_cmd *parse_cmd(struct input_ctx *ictx, bstr *pstr, const char * struct mp_cmd_arg *cmdarg = &cmd->args[cmd->nargs]; cmdarg->type = opt; cmd->nargs++; - int r = m_option_parse(opt, bstr0(cmd->name), arg, &cmdarg->v); + r = m_option_parse(opt, bstr0(cmd->name), cur_token, &cmdarg->v); if (r < 0) { - MP_ERR(ictx, "Command %s: argument %d can't be parsed: %s.\n", + MP_ERR(ctx, "Command %s: argument %d can't be parsed: %s.\n", cmd->name, i + 1, m_option_strerror(r)); goto error; } @@ -1046,33 +1080,46 @@ static struct mp_cmd *parse_cmd(struct input_ctx *ictx, bstr *pstr, const char * talloc_steal(cmd, cmdarg->v.s); } - bstr dummy; - if (read_token(str, &dummy, &dummy)) { - MP_ERR(ictx, "Command %s has trailing unused arguments: '%.*s'.\n", - cmd->name, BSTR_P(str)); + bstr left = pctx_get_trailing(ctx); + if (left.len) { + MP_ERR(ctx, "Command %s has trailing unused arguments: '%.*s'.\n", + cmd->name, BSTR_P(left)); // Better make it fatal to make it clear something is wrong. goto error; } - bstr orig = (bstr) {start.start, str.start - start.start}; - cmd->original = bstrdup(cmd, bstr_strip(orig)); - - *pstr = str; + if (!ctx->array_input) { + bstr orig = {ctx->start.start, ctx->str.start - ctx->start.start}; + cmd->original = bstrdup(cmd, bstr_strip(orig)); + } - talloc_free(tmp); return cmd; error: - MP_ERR(ictx, "Command was defined at %s.\n", loc); + MP_ERR(ctx, "Command was defined at %s.\n", ctx->loc); talloc_free(cmd); - talloc_free(tmp); return NULL; } +static struct mp_cmd *parse_cmd_str(struct mp_log *log, bstr *str, const char *loc) +{ + struct parse_ctx ctx = { + .log = log, + .loc = loc, + .tmp = talloc_new(NULL), + .str = *str, + .start = *str, + }; + struct mp_cmd *res = parse_cmd(&ctx, MP_ON_OSD_AUTO | MP_EXPAND_PROPERTIES); + talloc_free(ctx.tmp); + *str = ctx.str; + return res; +} + mp_cmd_t *mp_input_parse_cmd(struct input_ctx *ictx, bstr str, const char *loc) { bstr original = str; - struct mp_cmd *cmd = parse_cmd(ictx, &str, loc); + struct mp_cmd *cmd = parse_cmd_str(ictx->log, &str, loc); if (!cmd) return NULL; @@ -1097,7 +1144,7 @@ mp_cmd_t *mp_input_parse_cmd(struct input_ctx *ictx, bstr str, const char *loc) p_prev = &cmd->queue_next; cmd = list; } - struct mp_cmd *sub = parse_cmd(ictx, &str, loc); + struct mp_cmd *sub = parse_cmd_str(ictx->log, &str, loc); if (!sub) { talloc_free(cmd); return NULL; @@ -1110,6 +1157,38 @@ mp_cmd_t *mp_input_parse_cmd(struct input_ctx *ictx, bstr str, const char *loc) return cmd; } +struct mp_cmd *mp_input_parse_cmd_strv(struct mp_log *log, int def_flags, + char **argv, const char *location) +{ + bstr args[MP_CMD_MAX_ARGS]; + int num = 0; + for (; argv[num]; num++) { + if (num > MP_CMD_MAX_ARGS) { + mp_err(log, "%s: too many arguments.\n", location); + return NULL; + } + args[num] = bstr0(argv[num]); + } + return mp_input_parse_cmd_bstrv(log, def_flags, num, args, location); +} + +struct mp_cmd *mp_input_parse_cmd_bstrv(struct mp_log *log, int def_flags, + int argc, bstr *argv, + const char *location) +{ + struct parse_ctx ctx = { + .log = log, + .loc = location, + .tmp = talloc_new(NULL), + .array_input = true, + .strs = argv, + .num_strs = argc, + }; + struct mp_cmd *res = parse_cmd(&ctx, def_flags); + talloc_free(ctx.tmp); + return res; +} + #define MP_CMD_MAX_SIZE 4096 static int read_cmd(struct input_fd *mp_fd, char **ret) diff --git a/input/input.h b/input/input.h index 3c6d8dccbd..77afeebac6 100644 --- a/input/input.h +++ b/input/input.h @@ -136,6 +136,7 @@ enum mp_input_section_flags { }; struct input_ctx; +struct mp_log; struct mp_cmd_arg { const struct m_option *type; @@ -228,6 +229,18 @@ struct mp_cmd *mp_input_get_cmd(struct input_ctx *ictx, int time, struct mp_cmd *mp_input_parse_cmd(struct input_ctx *ictx, bstr str, const char *location); +// Similar to mp_input_parse_cmd(), but takes a list of strings instead. +// Also, def_flags contains initial command flags (see mp_cmd_flags; the default +// as used by mp_input_parse_cmd is MP_ON_OSD_AUTO | MP_EXPAND_PROPERTIES). +// Keep in mind that these functions (naturally) don't take multiple commands, +// i.e. a ";" argument does not start a new command. +// The _strv version is limitted to MP_CMD_MAX_ARGS argv array items. +struct mp_cmd *mp_input_parse_cmd_strv(struct mp_log *log, int def_flags, + char **argv, const char *location); +struct mp_cmd *mp_input_parse_cmd_bstrv(struct mp_log *log, int def_flags, + int argc, bstr *argv, + const char *location); + // After getting a command from mp_input_get_cmd you need to free it using this // function void mp_cmd_free(struct mp_cmd *cmd); diff --git a/player/lua.c b/player/lua.c index 3687f75b87..5a3ec1db82 100644 --- a/player/lua.c +++ b/player/lua.c @@ -378,6 +378,28 @@ static int script_send_command(lua_State *L) return 0; } +static int script_send_commandv(lua_State *L) +{ + struct script_ctx *ctx = get_ctx(L); + int num = lua_gettop(L); + bstr args[50]; + if (num > MP_ARRAY_SIZE(args)) + luaL_error(L, "too many arguments"); + for (int n = 1; n <= num; n++) { + size_t len; + const char *s = lua_tolstring(L, n, &len); + if (!s) + luaL_error(L, "argument %d is not a string", n); + args[n - 1] = (bstr){(char *)s, len}; + } + mp_cmd_t *cmd = mp_input_parse_cmd_bstrv(ctx->log, 0, num, args, "<lua>"); + if (!cmd) + luaL_error(L, "error parsing command"); + mp_input_queue_cmd(ctx->mpctx->input, cmd); + + return 0; +} + static int script_property_list(lua_State *L) { const struct m_option *props = mp_get_property_list(); @@ -625,6 +647,7 @@ static struct fn_entry fn_list[] = { FN_ENTRY(log), FN_ENTRY(find_config_file), FN_ENTRY(send_command), + FN_ENTRY(send_commandv), FN_ENTRY(property_list), FN_ENTRY(set_osd_ass), FN_ENTRY(get_osd_resolution), |