Nyaaori/rockbox
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
rockbox/utils/hwstub/tools/prompt.c

1660 lines
42 KiB
C
Raw Normal View History

hwstub: Add completion and some pretty printing to the shell This uses slightly hacked luaprompt to provide all the goodis. See https://github.com/dpapavas/luaprompt for original. Change-Id: Iedddb79abae5809299322bc215722dd928c35cca
2015-06-28 15:51:43 +00:00
/* Copyright (C) 2012-2015 Papavasileiou Dimitris
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation
* files (the "Software"), to deal in the Software without
* restriction, including without limitation the rights to use, copy,
* modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <stdbool.h>
#include <sys/stat.h>
#include <unistd.h>
#include "prompt.h"
#ifdef HAVE_IOCTL
#include <sys/ioctl.h>
#endif
#include <glob.h>
#include <lualib.h>
#include <lauxlib.h>
#if LUA_VERSION_NUM == 501
#define lua_pushglobaltable(L) lua_pushvalue (L, LUA_GLOBALSINDEX)
#define LUA_OK 0
#define lua_rawlen lua_objlen
#endif
#ifdef HAVE_LIBREADLINE
#include <readline/readline.h>
#else
/* This is a simple readline-like function in case readline is not
* available. */
#define MAXINPUT 1024
static char *readline(char *prompt)
{
char *line = NULL;
int k;
line = malloc (MAXINPUT);
fputs(prompt, stdout);
fflush(stdout);
if (!fgets(line, MAXINPUT, stdin)) {
return NULL;
}
k = strlen (line);
if (line[k - 1] == '\n') {
line[k - 1] = '\0';
}
return line;
}
#endif /* HAVE_LIBREADLINE */
#ifdef HAVE_READLINE_HISTORY
#include <readline/history.h>
#endif /* HAVE_READLINE_HISTORY */
#if LUA_VERSION_NUM == 501
#define EOF_MARKER "'<eof>'"
#else
#define EOF_MARKER "<eof>"
#endif
#define print_output(...) fprintf (stdout, __VA_ARGS__), fflush(stdout)
#define print_error(...) fprintf (stderr, __VA_ARGS__), fflush(stderr)
#define absolute(L, i) (i < 0 ? lua_gettop (L) + i + 1 : i)
#define COLOR(i) (colorize ? colors[i] : "")
static lua_State *M;
static int initialized = 0;
static char *logfile, *chunkname, *prompts[2][2], *buffer = NULL;
#ifdef SAVE_RESULTS
static int results = LUA_REFNIL, results_n = 0;
#endif
static int colorize = 1;
static const char *colors[] = {"\033[0m",
"\033[0;31m",
"\033[1;31m",
"\033[0;32m",
"\033[1;32m",
"\033[0;33m",
"\033[1;33m",
"\033[1m",
"\033[22m"};
#ifdef HAVE_LIBREADLINE
static void display_matches (char **matches, int num_matches, int max_length)
{
print_output ("%s", COLOR(7));
rl_display_match_list (matches, num_matches, max_length);
print_output ("%s", COLOR(0));
rl_on_new_line ();
}
#ifdef COMPLETE_KEYWORDS
static char *keyword_completions (const char *text, int state)
{
static const char **c, *keywords[] = {
#if LUA_VERSION_NUM == 502
"goto",
#endif
"and", "break", "do", "else", "elseif", "end", "false", "for",
"function", "if", "in", "local", "nil", "not", "or",
"repeat", "return", "then", "true", "until", "while", NULL
};
int s, t;
if (state == 0) {
c = keywords - 1;
}
/* Loop through the list of keywords and return the ones that
* match. */
for (c += 1 ; *c ; c += 1) {
s = strlen (*c);
t = strlen(text);
if (s >= t && !strncmp (*c, text, t)) {
return strdup (*c);
}
}
return NULL;
}
#endif
#ifdef COMPLETE_TABLE_KEYS
static int look_up_metatable;
static char *table_key_completions (const char *text, int state)
{
static const char *c, *token;
static char oper;
static int h;
if (state == 0) {
h = lua_gettop(M);
/* Scan to the beginning of the to-be-completed token. */
for (c = text + strlen (text) - 1;
c >= text && *c != '.' && *c != ':' && *c != '[';
c -= 1);
if (c > text) {
oper = *c;
token = c + 1;
/* Get the iterable value, the keys of which we wish to
* complete. */
lua_pushliteral (M, "return ");
lua_pushlstring (M, text, token - text - 1);
lua_concat (M, 2);
if (luaL_loadstring (M, lua_tostring (M, -1)) ||
lua_pcall (M, 0, 1, 0) ||
(lua_type (M, -1) != LUA_TUSERDATA &&
lua_type (M, -1) != LUA_TTABLE)) {
lua_settop(M, h);
return NULL;
}
} else {
oper = 0;
token = text;
lua_pushglobaltable(M);
}
if (look_up_metatable) {
/* Replace the to-be-iterated value with it's metatable
* and set up a call to next. */
if (!luaL_getmetafield(M, -1, "__index") ||
(lua_type (M, -1) != LUA_TUSERDATA &&
lua_type (M, -1) != LUA_TTABLE)) {
lua_settop(M, h);
return NULL;
}
lua_getglobal(M, "next");
lua_replace(M, -3);
lua_pushnil(M);
} else {
/* Call the standard pairs function. */
lua_getglobal (M, "pairs");
lua_insert (M, -2);
if(lua_type (M, -2) != LUA_TFUNCTION ||
lua_pcall (M, 1, 3, 0)) {
lua_settop(M, h);
return NULL;
}
}
}
/* Iterate the table/userdata and generate matches. */
while (lua_pushvalue(M, -3), lua_insert (M, -3),
lua_pushvalue(M, -2), lua_insert (M, -4),
lua_pcall (M, 2, 2, 0) == 0) {
char *candidate;
size_t l, m;
int suppress, type, keytype;
if (lua_isnil(M, -2)) {
lua_settop(M, h);
return NULL;
}
/* Make some notes about the value we're completing. We'll
* make use of them later on. */
type = lua_type (M, -1);
suppress = (type == LUA_TTABLE || type == LUA_TUSERDATA ||
type == LUA_TFUNCTION);
keytype = LUA_TNIL;
if (type == LUA_TTABLE) {
lua_pushnil(M);
if (lua_next(M, -2)) {
keytype = lua_type (M, -2);
lua_pop (M, 2);
} else {
/* There are no keys in the table so we won't want to
* index it. Add a space. */
suppress = 0;
}
}
/* Pop the value, keep the key. */
lua_pop (M, 1);
/* We're mainly interested in strings at this point but if
* we're completing for the table[key] syntax we consider
* numeric keys too. */
if (lua_type (M, -1) == LUA_TSTRING ||
(oper == '[' && lua_type (M, -1) == LUA_TNUMBER)) {
if (oper == '[') {
if (lua_type (M, -1) == LUA_TNUMBER) {
lua_Number n;
int i;
n = lua_tonumber (M, -1);
i = lua_tointeger (M, -1);
/* If this isn't an integer key, we may as well
* forget about it. */
if ((lua_Number)i == n) {
l = asprintf (&candidate, "%d]", i);
} else {
continue;
}
} else {
char q;
q = token[0];
if (q != '"' && q != '\'') {
q = '"';
}
l = asprintf (&candidate, "%c%s%c]",
q, lua_tostring (M, -1), q);
}
} else {
candidate = strdup((char *)lua_tolstring (M, -1, &l));
}
m = strlen(token);
if (l >= m && !strncmp (token, candidate, m) &&
(oper != ':' || type == LUA_TFUNCTION)
#ifdef HIDDEN_KEY_PREFIX
&& strncmp(candidate, HIDDEN_KEY_PREFIX,
sizeof(HIDDEN_KEY_PREFIX) - 1)
#endif
) {
char *match;
/* If the candidate has been fully typed (or
* previously completed) consider adding certain
* helpful suffixes. */
#ifndef ALWAYS_APPEND_SUFFIXES
if (l == m) {
#endif
if (type == LUA_TFUNCTION) {
rl_completion_append_character = '('; suppress = 0;
} else if (type == LUA_TTABLE) {
if (keytype == LUA_TSTRING) {
rl_completion_append_character = '.'; suppress = 0;
} else if (keytype != LUA_TNIL) {
rl_completion_append_character = '['; suppress = 0;
}
}
#ifndef ALWAYS_APPEND_SUFFIXES
};
#endif
if (token > text) {
/* Were not completing a global variable. Put the
* completed string together out of the table and
* the key. */
match = (char *)malloc ((token - text) + l + 1);
strncpy (match, text, token - text);
strcpy (match + (token - text), candidate);
free(candidate);
} else {
/* Return the whole candidate as is, to be freed
* by Readline. */
match = candidate;
}
/* Suppress the newline when completing a table
* or other potentially complex value. */
if (suppress) {
rl_completion_suppress_append = 1;
}
return match;
} else {
free(candidate);
}
}
}
lua_settop(M, h);
return NULL;
}
#endif
#ifdef COMPLETE_MODULES
static char *module_completions (const char *text, int state)
{
char *match = NULL;
static int h;
if (state == 0) {
glob_t vector;
const char *b, *d, *q, *s, *t, *strings[3];
int i, n = 0, ondot, hasdot, quoted;
hasdot = strchr(text, '.') != NULL;
ondot = text[0] != '\0' && text[strlen(text) - 1] == '.';
quoted = text[0] == '\'' || text[0] == '"';
#ifdef NO_MODULE_LOAD
if(!quoted) {
return NULL;
}
#endif
lua_newtable(M);
h = lua_gettop(M);
/* Try to load the input as a module. */
lua_getglobal(M, "require");
if (!lua_isfunction (M, -1)) {
lua_settop(M, h - 1);
return NULL;
}
lua_pushliteral(M, "package");
if(lua_pcall(M, 1, 1, 0) != LUA_OK) {
lua_settop(M, h - 1);
return NULL;
}
if (!ondot && !quoted && text[0] != '\0') {
lua_getfield(M, -1, "loaded");
lua_pushstring(M, text);
lua_gettable(M, -2);
/* If it's not an already loaded module, check whether the
* input is an available module by searching for it and/or
* trying to load it. */
if (!lua_toboolean(M, -1)) {
int load = 1;
lua_pop(M, 2);
#ifdef CONFIRM_MODULE_LOAD
/* Look for the module as require would and ask the
* user whether it should be loaded or not. */
#if LUA_VERSION_NUM == 501
lua_getfield(M, -1, "loaders");
#else
lua_getfield(M, -1, "searchers");
#endif
lua_pushnil(M);
while((load = lua_next(M, -2))) {
lua_pushstring(M, text);
lua_call(M, 1, 1);
if (lua_isfunction(M, -1)) {
char c;
print_output ("\nLoad module '%s' (y or n)", text);
while ((c = tolower(rl_read_key())) != 'y' && c != 'n');
if (c == 'y') {
lua_pop(M, 3);
break;
} else {
print_output ("\n");
rl_on_new_line ();
/* If it was found but not loaded, return
* the module name as a match to avoid
* asking the user againg if the tab key
* is pressed repeatedly. */
lua_settop(M, h);
return strdup(text);
}
}
lua_pop(M, 1);
}
#endif
/* Load the model if needed. */
if (load) {
lua_pushfstring (M, "%s=require(\"%s\")", text, text);
if (luaL_loadstring (M, lua_tostring (M, -1)) == LUA_OK &&
lua_pcall (M, 0, 0, 0) == LUA_OK) {
#ifdef CONFIRM_MODULE_LOAD
print_output (" ...loaded\n");
#else
print_output ("\nLoaded module '%s'.\n", text);
#endif
rl_on_new_line ();
lua_settop(M, h - 1);
return NULL;
}
}
} else {
lua_settop(M, h - 1);
return NULL;
}
/* Clean up but leave the package.table on the stack. */
lua_settop(M, h + 1);
}
/* Look for matches in package.preload. */
lua_getfield(M, -1, "preload");
lua_pushnil(M);
while(lua_next(M, -2)) {
lua_pop(M, 1);
if (lua_type(M, -1) == LUA_TSTRING &&
!strncmp(text + quoted, lua_tostring(M, -1),
strlen(text + quoted))) {
lua_pushstring(M, text);
lua_rawseti (M, h, (n += 1));
}
}
lua_pop(M, 1);
/* Get the configuration (directory, path separators, module
* name wildcard). */
lua_getfield(M, -1, "config");
for (s = (char *)lua_tostring(M, -1), i = 0;
i < 3;
s = t + 1, i += 1) {
t = strchr(s, '\n');
lua_pushlstring(M, s, t - s);
strings[i] = lua_tostring(M, -1);
}
lua_remove(M, -4);
/* Get the path and cpath */
lua_getfield(M, -4, "path");
lua_pushstring(M, strings[1]);
lua_getfield(M, -6, "cpath");
lua_pushstring(M, strings[1]);
lua_concat(M, 4);
/* Synthesize the pattern. */
if (hasdot) {
luaL_gsub(M, text + quoted, ".", strings[0]);
} else {
lua_pushstring(M, text + quoted);
}
lua_pushliteral(M, "*");
lua_concat(M, 2);
for (b = d = lua_tostring(M, -2) ; d ; b = d + 1) {
size_t i;
d = strstr(b, strings[1]);
q = strstr(b, strings[2]);
if (!q || q > d) {
continue;
}
lua_pushlstring(M, b, d - b);
luaL_gsub(M, lua_tostring(M, -1), strings[2],
lua_tostring(M, -2));
glob(lua_tostring(M, -1), 0, NULL, &vector);
lua_pop(M, 2);
for (i = 0 ; i < vector.gl_pathc ; i += 1) {
char *p = vector.gl_pathv[i];
if (quoted) {
lua_pushlstring(M, text, 1);
}
lua_pushlstring(M, p + (q - b), strlen(p) - (d - b) + 1);
if (hasdot) {
luaL_gsub(M, lua_tostring(M, -1), strings[0], ".");
lua_replace(M, -2);
}
{
const char *s;
size_t l;
s = lua_tolstring(M, -1, &l);
/* Suppress submodules named init. */
if (l < sizeof("init") - 1 ||
strcmp(s + l - sizeof("init") + 1, "init")) {
if (quoted) {
lua_pushlstring(M, text, 1);
lua_concat(M, 3);
}
lua_rawseti(M, h, (n += 1));
} else {
lua_pop(M, 1 + quoted);
}
}
}
globfree(&vector);
}
lua_pop(M, 6);
}
/* Return the next match from the table of matches. */
lua_pushnil(M);
if (lua_next(M, -2)) {
match = strdup(lua_tostring(M, -1));
rl_completion_suppress_append = !(match[0] == '"' || match[0] == '\'');
/* Pop the match. */
lua_pushnil(M);
lua_rawseti(M, -4, lua_tointeger(M, -3));
/* Pop key/value. */
lua_pop(M, 2);
} else {
/* Pop the empty table. */
lua_pop(M, 1);
}
return match;
}
#endif
static char *generator (const char *text, int state)
{
static int which;
char *match = NULL;
if (state == 0) {
which = 0;
}
/* Try to complete a keyword. */
if (which == 0) {
#ifdef COMPLETE_KEYWORDS
if ((match = keyword_completions (text, state))) {
return match;
}
#endif
which += 1;
state = 0;
}
/* Try to complete a module name. */
if (which == 1) {
#ifdef COMPLETE_MODULES
if ((match = module_completions (text, state))) {
return match;
}
#endif
which += 1;
state = 0;
}
/* Try to complete a table access. */
if (which == 2) {
#ifdef COMPLETE_TABLE_KEYS
look_up_metatable = 0;
if ((match = table_key_completions (text, state))) {
return match;
}
#endif
which += 1;
state = 0;
}
/* Try to complete a metatable access. */
if (which == 3) {
#ifdef COMPLETE_METATABLE_KEYS
look_up_metatable = 1;
if ((match = table_key_completions (text, state))) {
return match;
}
#endif
which += 1;
state = 0;
}
#ifdef COMPLETE_FILE_NAMES
/* Try to complete a file name. */
if (which == 4) {
if (text[0] == '\'' || text[0] == '"') {
match = rl_filename_completion_function (text + 1, state);
if (match) {
struct stat s;
int n;
n = strlen (match);
stat(match, &s);
/* If a match was produced, add the quote
* characters. */
match = (char *)realloc (match, n + 3);
memmove (match + 1, match, n);
match[0] = text[0];
/* If the file's a directory, add a trailing backslash
* and suppress the space, otherwise add the closing
* quote. */
if (S_ISDIR(s.st_mode)) {
match[n + 1] = '/';
rl_completion_suppress_append = 1;
} else {
match[n + 1] = text[0];
}
match[n + 2] = '\0';
}
}
}
#endif
return match;
}
#endif
static void finish ()
{
#ifdef HAVE_READLINE_HISTORY
/* Save the command history on exit. */
if (logfile) {
write_history (logfile);
}
#endif
}
static int traceback(lua_State *L)
{
lua_Debug ar;
int i;
if (lua_isnoneornil (L, 1) ||
(!lua_isstring (L, 1) &&
!luaL_callmeta(L, 1, "__tostring"))) {
lua_pushliteral(L, "(no error message)");
}
if (lua_gettop (L) > 1) {
lua_replace (L, 1);
lua_settop (L, 1);
}
/* Print the Lua stack. */
lua_pushstring(L, "\n\nStack trace:\n");
for (i = 0 ; lua_getstack (L, i, &ar) ; i += 1) {
#if LUA_VERSION_NUM == 501
lua_getinfo(M, "Snl", &ar);
#else
lua_getinfo(M, "Snlt", &ar);
if (ar.istailcall) {
lua_pushfstring(L, "\t... tail calls\n");
}
#endif
if (!strcmp (ar.what, "C")) {
lua_pushfstring(L, "\t#%d %s[C]:%s in function ",
i, COLOR(7), COLOR(8));
if (ar.name) {
lua_pushfstring(L, "'%s%s%s'\n",
COLOR(7), ar.name, COLOR(8));
} else {
lua_pushfstring(L, "%s?%s\n", COLOR(7), COLOR(8));
}
} else if (!strcmp (ar.what, "main")) {
lua_pushfstring(L, "\t#%d %s%s:%d:%s in the main chunk\n",
i, COLOR(7), ar.short_src, ar.currentline,
COLOR(8));
} else if (!strcmp (ar.what, "Lua")) {
lua_pushfstring(L, "\t#%d %s%s:%d:%s in function ",
i, COLOR(7), ar.short_src, ar.currentline,
COLOR(8));
if (ar.name) {
lua_pushfstring(L, "'%s%s%s'\n",
COLOR(7), ar.name, COLOR(8));
} else {
lua_pushfstring(L, "%s?%s\n", COLOR(7), COLOR(8));
}
}
}
if (i == 0) {
lua_pushstring (L, "No activation records.\n");
}
lua_concat (L, lua_gettop(L));
return 1;
}
static int execute ()
{
int i, h_0, h, status;
#ifdef SAVE_RESULTS
/* Get the results table, and stash it behind the to-be-executed
* chunk. */
lua_rawgeti(M, LUA_REGISTRYINDEX, results);
lua_insert(M, -2);
#endif
h_0 = lua_gettop(M);
status = luap_call (M, 0);
h = lua_gettop (M) - h_0 + 1;
for (i = h ; i > 0 ; i -= 1) {
const char *result;
result = luap_describe (M, -i);
#ifdef SAVE_RESULTS
lua_pushvalue (M, -i);
lua_rawseti(M, h_0 - 1, (results_n += 1));
print_output ("%s%s[%d]%s = %s%s\n",
COLOR(4), RESULTS_TABLE_NAME, results_n,
COLOR(3), result, COLOR(0));
#else
if (h == 1) {
print_output ("%s%s%s\n", COLOR(3), result, COLOR(0));
} else {
print_output ("%s%d%s: %s%s\n", COLOR(4), h - i + 1,
COLOR(3), result, COLOR(0));
}
#endif
}
/* Clean up. We need to remove the results table as well if we
* track results. */
#ifdef SAVE_RESULTS
lua_settop (M, h_0 - 2);
#else
lua_settop (M, h_0 - 1);
#endif
return status;
}
/* This is the pretty-printing related stuff. */
static char *dump;
static int length, offset, indent, column, linewidth, ancestors;
#define dump_literal(s) (check_fit(sizeof(s) - 1), \
strcpy (dump + offset, s), \
offset += sizeof(s) - 1, \
column += width(s))
#define dump_character(c) (check_fit(1), \
dump[offset] = c, \
offset += 1, \
column += 1)
static int width (const char *s)
{
const char *c;
int n, discard = 0;
/* Calculate the printed width of the chunk s ignoring escape
* sequences. */
for (c = s, n = 0 ; *c ; c += 1) {
if (!discard && *c == '\033') {
discard = 1;
}
if (!discard) {
n+= 1;
}
if (discard && *c == 'm') {
discard = 0;
}
}
return n;
}
static void check_fit (int size)
{
/* Check if a chunk fits in the buffer and expand as necessary. */
if (offset + size + 1 > length) {
length = offset + size + 1;
dump = (char *)realloc (dump, length * sizeof (char));
}
}
static int is_identifier (const char *s, int n)
{
int i;
/* Check whether a string can be used as a key without quotes and
* braces. */
for (i = 0 ; i < n ; i += 1) {
if (!isalpha(s[i]) &&
(i == 0 || !isalnum(s[i])) &&
s[i] != '_') {
return 0;
}
}
return 1;
}
static void break_line ()
{
int i;
check_fit (indent + 1);
/* Add a line break. */
dump[offset] = '\n';
/* And indent to the current level. */
for (i = 1 ; i <= indent ; i += 1) {
dump[offset + i] = ' ';
}
offset += indent + 1;
column = indent;
}
static void dump_string (const char *s, int n)
{
int l;
/* Break the line if the current chunk doesn't fit but it would
* fit if we started on a fresh line at the current indent. */
l = width(s);
if (column + l > linewidth && indent + l <= linewidth) {
break_line();
}
check_fit (n);
/* Copy the string to the buffer. */
memcpy (dump + offset, s, n);
dump[offset + n] = '\0';
offset += n;
column += l;
}
static void describe (lua_State *L, int index)
{
char *s;
size_t n;
int type;
index = absolute (L, index);
type = lua_type (L, index);
if (luaL_getmetafield (L, index, "__tostring")) {
lua_pushvalue (L, index);
lua_pcall (L, 1, 1, 0);
s = (char *)lua_tolstring (L, -1, &n);
lua_pop (L, 1);
dump_string (s, n);
} else if (type == LUA_TNUMBER) {
/* Copy the value to avoid mutating it. */
lua_pushvalue (L, index);
s = (char *)lua_tolstring (L, -1, &n);
lua_pop (L, 1);
dump_string (s, n);
} else if (type == LUA_TSTRING) {
int i, started, score, level, uselevel = 0;
s = (char *)lua_tolstring (L, index, &n);
/* Scan the string to decide how to print it. */
for (i = 0, score = n, started = 0 ; i < (int)n ; i += 1) {
if (s[i] == '\n' || s[i] == '\t' ||
s[i] == '\v' || s[i] == '\r') {
/* These characters show up better in a long sting so
* bias towards that. */
score += linewidth / 2;
} else if (s[i] == '\a' || s[i] == '\b' ||
s[i] == '\f' || !isprint(s[i])) {
/* These however go better with an escaped short
* string (unless you like the bell or weird
* characters). */
score -= linewidth / 4;
}
/* Check what long string delimeter level to use so that
* the string won't be closed prematurely. */
if (!started) {
if (s[i] == ']') {
started = 1;
level = 0;
}
} else {
if (s[i] == '=') {
level += 1;
} else if (s[i] == ']') {
if (level >= uselevel) {
uselevel = level + 1;
}
} else {
started = 0;
}
}
}
if (score > linewidth) {
/* Dump the string as a long string. */
dump_character ('[');
for (i = 0 ; i < uselevel ; i += 1) {
dump_character ('=');
}
dump_literal ("[\n");
dump_string (s, n);
dump_character (']');
for (i = 0 ; i < uselevel ; i += 1) {
dump_character ('=');
}
dump_literal ("]");
} else {
/* Escape the string as needed and print it as a normal
* string. */
dump_literal ("\"");
for (i = 0 ; i < (int)n ; i += 1) {
if (s[i] == '"' || s[i] == '\\') {
dump_literal ("\\");
dump_character (s[i]);
} else if (s[i] == '\a') {
dump_literal ("\\a");
} else if (s[i] == '\b') {
dump_literal ("\\b");
} else if (s[i] == '\f') {
dump_literal ("\\f");
} else if (s[i] == '\n') {
dump_literal ("\\n");
} else if (s[i] == '\r') {
dump_literal ("\\r");
} else if (s[i] == '\t') {
dump_literal ("\\t");
} else if (s[i] == '\v') {
dump_literal ("\\v");
} else if (isprint(s[i])) {
dump_character (s[i]);
} else {
char t[5];
size_t n;
n = sprintf (t, "\\%03u", ((unsigned char *)s)[i]);
dump_string (t, n);
}
}
dump_literal ("\"");
}
} else if (type == LUA_TNIL) {
n = asprintf (&s, "%snil%s", COLOR(7), COLOR(8));
dump_string (s, n);
free(s);
} else if (type == LUA_TBOOLEAN) {
n = asprintf (&s, "%s%s%s",
COLOR(7),
lua_toboolean (L, index) ? "true" : "false",
COLOR(8));
dump_string (s, n);
free(s);
} else if (type == LUA_TFUNCTION) {
n = asprintf (&s, "<%sfunction:%s %p>",
COLOR(7), COLOR(8), lua_topointer (L, index));
dump_string (s, n);
free(s);
} else if (type == LUA_TUSERDATA) {
n = asprintf (&s, "<%suserdata:%s %p>",
COLOR(7), COLOR(8), lua_topointer (L, index));
dump_string (s, n);
free(s);
} else if (type == LUA_TTHREAD) {
n = asprintf (&s, "<%sthread:%s %p>",
COLOR(7), COLOR(8), lua_topointer (L, index));
dump_string (s, n);
free(s);
} else if (type == LUA_TTABLE) {
int i, l, n, oldindent, multiline, nobreak;
/* Check if table is too deeply nested. */
if (indent > 8 * linewidth / 10) {
char *s;
size_t n;
n = asprintf (&s, "{ %s...%s }", COLOR(7), COLOR(8));
dump_string (s, n);
free(s);
return;
}
/* Check if the table introduces a cycle by checking whether
* it is a back-edge (that is equal to an ancestor table. */
lua_rawgeti (L, LUA_REGISTRYINDEX, ancestors);
n = lua_rawlen(L, -1);
for (i = 0 ; i < n ; i += 1) {
lua_rawgeti (L, -1, n - i);
#if LUA_VERSION_NUM == 501
if(lua_equal (L, -1, -3)) {
#else
if(lua_compare (L, -1, -3, LUA_OPEQ)) {
#endif
char *s;
size_t n;
n = asprintf (&s, "{ %s[%d]...%s }",
COLOR(7), -(i + 1), COLOR(8));
dump_string (s, n);
free(s);
lua_pop (L, 2);
return;
}
lua_pop (L, 1);
}
/* Add the table to the ancestor list and pop the ancestor
* list table. */
lua_pushvalue (L, index);
lua_rawseti (L, -2, n + 1);
lua_pop (L, 1);
/* Open the table and update the indentation level to the
* current column. */
dump_literal ("{ ");
oldindent = indent;
indent = column;
multiline = 0;
nobreak = 0;
l = lua_rawlen (L, index);
/* Traverse the array part first. */
for (i = 0 ; i < l ; i += 1) {
lua_pushinteger (L, i + 1);
lua_gettable (L, index);
/* Start a fresh line when dumping tables to make sure
* there's plenty of room. */
if (lua_istable (L, -1)) {
if (!nobreak) {
break_line();
}
multiline = 1;
}
nobreak = 0;
/* Dump the value and separating comma. */
describe (L, -1);
dump_literal (", ");
if (lua_istable (L, -1) && i != l - 1) {
break_line();
nobreak = 1;
}
lua_pop (L, 1);
}
/* Now for the hash part. */
lua_pushnil (L);
while (lua_next (L, index) != 0) {
if (lua_type (L, -2) != LUA_TNUMBER ||
lua_tonumber (L, -2) != lua_tointeger (L, -2) ||
lua_tointeger (L, -2) < 1 ||
lua_tointeger (L, -2) > l) {
/* Keep each key-value pair on a separate line. */
break_line ();
multiline = 1;
/* Dump the key and value. */
if (lua_type (L, -2) == LUA_TSTRING) {
char *s;
size_t n;
s = (char *)lua_tolstring (L, -2, &n);
if(is_identifier (s, n)) {
dump_string (COLOR(7), strlen(COLOR(7)));
dump_string (s, n);
dump_string (COLOR(8), strlen(COLOR(8)));
} else {
dump_literal ("[");
describe (L, -2);
dump_literal ("]");
}
} else {
dump_literal ("[");
describe (L, -2);
dump_literal ("]");
}
dump_literal (" = ");
describe (L, -1);
dump_literal (",");
}
lua_pop (L, 1);
}
/* Remove the table from the ancestor list. */
lua_rawgeti (L, LUA_REGISTRYINDEX, ancestors);
lua_pushnil (L);
lua_rawseti (L, -2, n + 1);
lua_pop (L, 1);
/* Pop the indentation level. */
indent = oldindent;
if (multiline) {
break_line();
dump_literal ("}");
} else {
dump_literal (" }");
}
}
}
char *luap_describe (lua_State *L, int index)
{
int oldcolorize;
#ifdef HAVE_IOCTL
struct winsize w;
/* Initialize the state. */
if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &w) < 0) {
linewidth = 80;
} else {
linewidth = w.ws_col;
}
#else
linewidth = 80;
#endif
index = absolute (L, index);
offset = 0;
indent = 0;
column = 0;
/* Suppress colorization, to avoid escape sequences in the
* returned strings. */
oldcolorize = colorize;
colorize = 0;
/* Create a table to hold the ancestors for checking for cycles
* when printing table hierarchies. */
lua_newtable (L);
ancestors = luaL_ref (L, LUA_REGISTRYINDEX);
describe (L, index);
luaL_unref (L, LUA_REGISTRYINDEX, ancestors);
colorize = oldcolorize;
return dump;
}
/* These are custom commands. */
#ifdef HAVE_LIBREADLINE
static int describe_stack (int count, int key)
{
int i, h;
print_output ("%s", COLOR(7));
h = lua_gettop (M);
if (count < 0) {
i = h + count + 1;
if (i > 0 && i <= h) {
print_output ("\nValue at stack index %d(%d):\n%s%s",
i, -h + i - 1, COLOR(3), luap_describe (M, i));
} else {
print_error ("Invalid stack index.\n");
}
} else {
if (h > 0) {
print_output ("\nThe stack contains %d values.\n", h);
for (i = 1 ; i <= h ; i += 1) {
print_output ("\n%d(%d):\t%s", i, -h + i - 1, lua_typename(M, lua_type(M, i)));
}
} else {
print_output ("\nThe stack is empty.");
}
}
print_output ("%s\n", COLOR(0));
rl_on_new_line ();
return 0;
}
#endif
int luap_call (lua_State *L, int n) {
int h, status;
/* We can wind up here before reaching luap_enter, so this is
* needed. */
M = L;
/* Push the error handler onto the stack. */
h = lua_gettop(L) - n;
lua_pushcfunction (L, traceback);
lua_insert (L, h);
/* Try to execute the supplied chunk and keep note of any return
* values. */
status = lua_pcall(L, n, LUA_MULTRET, h);
/* Print any errors. */
if (status != LUA_OK) {
print_error ("%s%s%s\n", COLOR(1), lua_tostring (L, -1), COLOR(0));
lua_pop (L, 1);
}
/* Remove the error handler. */
lua_remove (L, h);
return status;
}
void luap_setprompts(lua_State *L, const char *single, const char *multi)
{
/* Plain, uncolored prompts. */
prompts[0][0] = (char *)realloc (prompts[0][0], strlen (single) + 1);
prompts[0][1] = (char *)realloc (prompts[0][1], strlen (multi) + 1);
strcpy(prompts[0][0], single);
strcpy(prompts[0][1], multi);
/* Colored prompts. */
prompts[1][0] = (char *)realloc (prompts[1][0], strlen (single) + 16);
prompts[1][1] = (char *)realloc (prompts[1][1], strlen (multi) + 16);
#ifdef HAVE_LIBREADLINE
sprintf (prompts[1][0], "\001%s\002%s\001%s\002",
COLOR(6), single, COLOR(0));
sprintf (prompts[1][1], "\001%s\002%s\001%s\002",
COLOR(6), multi, COLOR(0));
#else
sprintf (prompts[1][0], "%s%s%s", COLOR(6), single, COLOR(0));
sprintf (prompts[1][1], "%s%s%s", COLOR(6), multi, COLOR(0));
#endif
}
void luap_sethistory(lua_State *L, const char *file)
{
if (file) {
logfile = realloc (logfile, strlen(file) + 1);
strcpy (logfile, file);
} else if (logfile) {
free(logfile);
logfile = NULL;
}
}
void luap_setcolor(lua_State *L, int enable)
{
/* Don't allow color if we're not writing to a terminal. */
if (!isatty (STDOUT_FILENO) || !isatty (STDERR_FILENO)) {
colorize = 0;
} else {
colorize = enable;
}
}
void luap_setname(lua_State *L, const char *name)
{
chunkname = (char *)realloc (chunkname, strlen(name) + 2);
chunkname[0] = '=';
strcpy (chunkname + 1, name);
}
void luap_getprompts(lua_State *L, const char **single, const char **multi)
{
*single = prompts[0][0];
*multi = prompts[0][1];
}
void luap_gethistory(lua_State *L, const char **file)
{
*file = logfile;
}
void luap_getcolor(lua_State *L, int *enabled)
{
*enabled = colorize;
}
void luap_getname(lua_State *L, const char **name)
{
*name = chunkname + 1;
}
void luap_enter(lua_State *L, bool *terminate)
{
int incomplete = 0, s = 0, t = 0, l;
char *line, *prepended;
#ifdef SAVE_RESULTS
int cleanup = 0;
#endif
/* Save the state since it needs to be passed to some readline
* callbacks. */
M = L;
if (!initialized) {
#ifdef HAVE_LIBREADLINE
rl_basic_word_break_characters = " \t\n`@$><=;|&{(";
rl_completion_entry_function = generator;
rl_completion_display_matches_hook = display_matches;
rl_add_defun ("lua-describe-stack", describe_stack, META('s'));
#endif
#ifdef HAVE_READLINE_HISTORY
/* Load the command history if there is one. */
if (logfile) {
read_history (logfile);
}
#endif
if (!chunkname) {
luap_setname (L, "lua");
}
if (!prompts[0][0]) {
luap_setprompts (L, "> ", ">> ");
}
atexit (finish);
initialized = 1;
}
#ifdef SAVE_RESULTS
if (results == LUA_REFNIL) {
lua_newtable(L);
#ifdef WEAK_RESULTS
lua_newtable(L);
lua_pushliteral(L, "v");
lua_setfield(L, -2, "__mode");
lua_setmetatable(L, -2);
#endif
results = luaL_ref(L, LUA_REGISTRYINDEX);
}
lua_getglobal(L, RESULTS_TABLE_NAME);
if (lua_isnil(L, -1)) {
lua_rawgeti(L, LUA_REGISTRYINDEX, results);
lua_setglobal(L, RESULTS_TABLE_NAME);
cleanup = 1;
}
lua_pop(L, 1);
#endif
while (!(*terminate) &&
(line = readline (incomplete ?
prompts[colorize][1] : prompts[colorize][0]))) {
int status;
if (*line == '\0') {
free(line);
continue;
}
/* Add/copy the line to the buffer. */
if (incomplete) {
s += strlen (line) + 1;
if (s > t) {
buffer = (char *)realloc (buffer, s + 1);
t = s;
}
strcat (buffer, "\n");
strcat (buffer, line);
} else {
s = strlen (line);
if (s > t) {
buffer = (char *)realloc (buffer, s + 1);
t = s;
}
strcpy (buffer, line);
}
/* Try to execute the line with a return prepended first. If
* this works we can show returned values. */
l = asprintf (&prepended, "return %s", buffer);
if (luaL_loadbuffer(L, prepended, l, chunkname) == LUA_OK) {
execute();
incomplete = 0;
} else {
lua_pop (L, 1);
/* Try to execute the line as-is. */
status = luaL_loadbuffer(L, buffer, s, chunkname);
incomplete = 0;
if (status == LUA_ERRSYNTAX) {
const char *message;
const int k = sizeof(EOF_MARKER) / sizeof(char) - 1;
size_t n;
message = lua_tolstring (L, -1, &n);
/* If the error message mentions an unexpected eof
* then consider this a multi-line statement and wait
* for more input. If not then just print the error
* message.*/
if ((int)n > k &&
!strncmp (message + n - k, EOF_MARKER, k)) {
incomplete = 1;
} else {
print_error ("%s%s%s\n", COLOR(1), lua_tostring (L, -1),
COLOR(0));
}
lua_pop (L, 1);
} else if (status == LUA_ERRMEM) {
print_error ("%s%s%s\n", COLOR(1), lua_tostring (L, -1),
COLOR(0));
lua_pop (L, 1);
} else {
/* Try to execute the loaded chunk. */
execute ();
incomplete = 0;
}
}
#ifdef HAVE_READLINE_HISTORY
/* Add the line to the history if non-empty. */
if (!incomplete) {
add_history (buffer);
}
#endif
free (prepended);
free (line);
}
#ifdef SAVE_RESULTS
if (cleanup) {
lua_pushnil(L);
lua_setglobal(L, RESULTS_TABLE_NAME);
}
#endif
print_output ("\n");
}
Reference in a new issue Copy permalink