void history_t::add_with_file_detection(const wcstring &str)
{
ASSERT_IS_MAIN_THREAD();
path_list_t potential_paths;
tokenizer tokenizer;
for( tok_init( &tokenizer, str.c_str(), TOK_SQUASH_ERRORS );
tok_has_next( &tokenizer );
tok_next( &tokenizer ) )
{
int type = tok_last_type( &tokenizer );
if (type == TOK_STRING) {
const wchar_t *token_cstr = tok_last(&tokenizer);
if (token_cstr) {
wcstring potential_path = token_cstr;
if (unescape_string(potential_path, false) && string_could_be_path(potential_path)) {
potential_paths.push_front(potential_path);
}
}
}
}
tok_destroy(&tokenizer);
if (! potential_paths.empty()) {
/* We have some paths. Make a context. */
file_detection_context_t *context = new file_detection_context_t(this, str);
/* Store the potential paths. Reverse them to put them in the same order as in the command. */
potential_paths.reverse();
context->potential_paths.swap(potential_paths);
iothread_perform(threaded_perform_file_detection, perform_file_detection_done, context);
}
}
/*
* Add iCalendar recur-rule-parts to a structured element.
*/
void icalrecurrencetype_add_as_xxx(struct icalrecurrencetype *recur, void *obj,
void (*add_int)(void *, const char *, int),
void (*add_str)(void *, const char *,
const char *))
{
char *rrule, *rpart;
tok_t rparts;
/* generate an iCal RRULE string */
rrule = icalrecurrencetype_as_string_r(recur);
/* split string into rparts & values */
tok_initm(&rparts, rrule, "=;", TOK_TRIMLEFT|TOK_TRIMRIGHT);
while ((rpart = tok_next(&rparts))) {
if (!strcmp(rpart, "UNTIL")) {
/* need to translate date format to ISO */
struct icaltimetype until = icaltime_from_string(tok_next(&rparts));
add_str(obj, "until", icaltime_as_iso_string(until));
}
else {
/* assume the rpart has multiple values - split them */
tok_t vlist;
char *val, *p;
tok_init(&vlist, tok_next(&rparts), ",",
TOK_TRIMLEFT|TOK_TRIMRIGHT);
while ((val = tok_next(&vlist))) {
if (add_int) {
/* try converting value to integer */
int n = strtol(val, &p, 10);
if (n && !*p) {
add_int(obj, lcase(rpart), n);
continue;
}
}
add_str(obj, lcase(rpart), val);
}
tok_fini(&vlist);
}
}
tok_fini(&rparts);
free(rrule);
}
/*
* Split a sub-line and a completion context into a word and a
* completion type. Use the editline tokenizer to handle the quoting
* and splitting.
*/
static char *
split_word(int *cmpltype, const char *cmplarray, LineInfo *li)
{
static Tokenizer *t = NULL;
const char **argv;
char *word;
int argc;
int cursorc;
int cursoro;
int arraylen;
if (t != NULL)
tok_reset(t);
else {
if ((t = tok_init(NULL)) == NULL)
err(EXIT_FAILURE, "tok_init");
}
if (tok_line(t, li, &argc, &argv, &cursorc, &cursoro) == -1)
err(EXIT_FAILURE, "tok_line");
if (cursorc >= argc)
word = __UNCONST("");
else {
word = salloc((size_t)cursoro + 1);
(void)strlcpy(word, argv[cursorc], (size_t)cursoro + 1);
}
/* check for 'continuation' completes (which are uppercase) */
arraylen = (int)strlen(cmplarray);
if (cursorc >= arraylen &&
arraylen > 0 &&
isupper((unsigned char)cmplarray[arraylen - 1]))
cursorc = arraylen - 1;
if (cursorc >= arraylen)
return NULL;
*cmpltype = cmplarray[cursorc];
return word;
}
void parse_util_token_extent( const wchar_t *buff,
int cursor_pos,
const wchar_t **tok_begin,
const wchar_t **tok_end,
const wchar_t **prev_begin,
const wchar_t **prev_end )
{
const wchar_t *begin, *end;
int pos;
wchar_t *buffcpy;
tokenizer tok;
const wchar_t *a = NULL, *b = NULL, *pa = NULL, *pb = NULL;
CHECK( buff, );
assert( cursor_pos >= 0 );
parse_util_cmdsubst_extent( buff, cursor_pos, &begin, &end );
if( !end || !begin )
{
return;
}
pos = cursor_pos - (begin - buff);
a = buff + pos;
b = a;
pa = buff + pos;
pb = pa;
assert( begin >= buff );
assert( begin <= (buff+wcslen(buff) ) );
assert( end >= begin );
assert( end <= (buff+wcslen(buff) ) );
buffcpy = wcsndup( begin, end-begin );
if( !buffcpy )
{
DIE_MEM();
}
for( tok_init( &tok, buffcpy, TOK_ACCEPT_UNFINISHED | TOK_SQUASH_ERRORS );
tok_has_next( &tok );
tok_next( &tok ) )
{
int tok_begin = tok_get_pos( &tok );
int tok_end=tok_begin;
/*
Calculate end of token
*/
if( tok_last_type( &tok ) == TOK_STRING )
{
tok_end +=wcslen(tok_last(&tok));
}
/*
Cursor was before beginning of this token, means that the
cursor is between two tokens, so we set it to a zero element
string and break
*/
if( tok_begin > pos )
{
a = b = (wchar_t *)buff + pos;
break;
}
/*
If cursor is inside the token, this is the token we are
looking for. If so, set a and b and break
*/
if( (tok_last_type( &tok ) == TOK_STRING) && (tok_end >= pos ) )
{
a = begin + tok_get_pos( &tok );
b = a + wcslen(tok_last(&tok));
break;
}
/*
Remember previous string token
*/
if( tok_last_type( &tok ) == TOK_STRING )
{
pa = begin + tok_get_pos( &tok );
pb = pa + wcslen(tok_last(&tok));
}
}
free( buffcpy);
tok_destroy( &tok );
if( tok_begin )
{
*tok_begin = a;
}
if( tok_end )
{
*tok_end = b;
}
if( prev_begin )
{
*prev_begin = pa;
}
if( prev_end )
{
*prev_end = pb;
}
assert( pa >= buff );
assert( pa <= (buff+wcslen(buff) ) );
assert( pb >= pa );
assert( pb <= (buff+wcslen(buff) ) );
}
/**
Get the beginning and end of the job or process definition under the cursor
*/
static void job_or_process_extent( const wchar_t *buff,
int cursor_pos,
const wchar_t **a,
const wchar_t **b,
int process )
{
const wchar_t *begin, *end;
int pos;
wchar_t *buffcpy;
int finished=0;
tokenizer tok;
CHECK( buff, );
if( a )
{
*a=0;
}
if( b )
{
*b = 0;
}
parse_util_cmdsubst_extent( buff, cursor_pos, &begin, &end );
if( !end || !begin )
{
return;
}
pos = cursor_pos - (begin - buff);
if( a )
{
*a = begin;
}
if( b )
{
*b = end;
}
buffcpy = wcsndup( begin, end-begin );
if( !buffcpy )
{
DIE_MEM();
}
for( tok_init( &tok, buffcpy, TOK_ACCEPT_UNFINISHED );
tok_has_next( &tok ) && !finished;
tok_next( &tok ) )
{
int tok_begin = tok_get_pos( &tok );
switch( tok_last_type( &tok ) )
{
case TOK_PIPE:
{
if( !process )
{
break;
}
}
case TOK_END:
case TOK_BACKGROUND:
{
if( tok_begin >= pos )
{
finished=1;
if( b )
{
*b = (wchar_t *)buff + tok_begin;
}
}
else
{
if( a )
{
*a = (wchar_t *)buff + tok_begin+1;
}
}
break;
}
}
}
free( buffcpy);
tok_destroy( &tok );
}
void parse_util_get_parameter_info( const wcstring &cmd, const size_t pos, wchar_t *quote, size_t *offset, int *type )
{
size_t prev_pos=0;
wchar_t last_quote = '\0';
int unfinished;
tokenizer tok;
tok_init( &tok, cmd.c_str(), TOK_ACCEPT_UNFINISHED | TOK_SQUASH_ERRORS );
for( ; tok_has_next( &tok ); tok_next( &tok ) )
{
if( tok_get_pos( &tok ) > pos )
break;
if( tok_last_type( &tok ) == TOK_STRING )
last_quote = get_quote( tok_last( &tok ),
pos - tok_get_pos( &tok ) );
if( type != NULL )
*type = tok_last_type( &tok );
prev_pos = tok_get_pos( &tok );
}
tok_destroy( &tok );
wchar_t *cmd_tmp = wcsdup(cmd.c_str());
cmd_tmp[pos]=0;
size_t cmdlen = wcslen( cmd_tmp );
unfinished = (cmdlen==0);
if( !unfinished )
{
unfinished = (quote != 0);
if( !unfinished )
{
if( wcschr( L" \t\n\r", cmd_tmp[cmdlen-1] ) != 0 )
{
if( ( cmdlen == 1) || (cmd_tmp[cmdlen-2] != L'\\') )
{
unfinished=1;
}
}
}
}
if( quote )
*quote = last_quote;
if( offset != 0 )
{
if( !unfinished )
{
while( (cmd_tmp[prev_pos] != 0) && (wcschr( L";|",cmd_tmp[prev_pos])!= 0) )
prev_pos++;
*offset = prev_pos;
}
else
{
*offset = pos;
}
}
free(cmd_tmp);
}
int
main(int argc, char *argv[])
{
int num;
const char *buf;
Tokenizer *tok;
#if 0
int lastevent = 0;
#endif
int ncontinuation;
History *hist;
HistEvent ev;
(void) signal(SIGINT, sig);
(void) signal(SIGQUIT, sig);
(void) signal(SIGHUP, sig);
(void) signal(SIGTERM, sig);
hist = history_init(); /* Init the builtin history */
/* Remember 100 events */
history(hist, &ev, H_SETSIZE, 100);
tok = tok_init(NULL); /* Initialize the tokenizer */
/* Initialize editline */
el = el_init(*argv, stdin, stdout, stderr);
el_set(el, EL_EDITOR, "vi"); /* Default editor is vi */
el_set(el, EL_SIGNAL, 1); /* Handle signals gracefully */
el_set(el, EL_PROMPT, prompt); /* Set the prompt function */
/* Tell editline to use this history interface */
el_set(el, EL_HIST, history, hist);
/* Add a user-defined function */
el_set(el, EL_ADDFN, "ed-complete", "Complete argument", complete);
/* Bind tab to it */
el_set(el, EL_BIND, "^I", "ed-complete", NULL);
/*
* Bind j, k in vi command mode to previous and next line, instead
* of previous and next history.
*/
el_set(el, EL_BIND, "-a", "k", "ed-prev-line", NULL);
el_set(el, EL_BIND, "-a", "j", "ed-next-line", NULL);
/*
* Source the user's defaults file.
*/
el_source(el, NULL);
while ((buf = el_gets(el, &num)) != NULL && num != 0) {
int ac;
const char **av;
#ifdef DEBUG
(void) fprintf(stderr, "got %d %s", num, buf);
#endif
if (!continuation && num == 1)
continue;
ncontinuation = tok_line(tok, buf, &ac, &av) > 0;
#if 0
if (continuation) {
/*
* Append to the right event in case the user
* moved around in history.
*/
if (history(hist, &ev, H_SET, lastevent) == -1)
err(1, "%d: %s\n", lastevent, ev.str);
history(hist, &ev, H_ADD , buf);
} else {
history(hist, &ev, H_ENTER, buf);
lastevent = ev.num;
}
#else
/* Simpler */
history(hist, &ev, continuation ? H_APPEND : H_ENTER, buf);
#endif
continuation = ncontinuation;
ncontinuation = 0;
if (strcmp(av[0], "history") == 0) {
int rv;
switch (ac) {
case 1:
for (rv = history(hist, &ev, H_LAST); rv != -1;
rv = history(hist, &ev, H_PREV))
(void) fprintf(stdout, "%4d %s",
ev.num, ev.str);
break;
case 2:
if (strcmp(av[1], "clear") == 0)
history(hist, &ev, H_CLEAR);
else
goto badhist;
break;
case 3:
if (strcmp(av[1], "load") == 0)
history(hist, &ev, H_LOAD, av[2]);
else if (strcmp(av[1], "save") == 0)
history(hist, &ev, H_SAVE, av[2]);
break;
badhist:
default:
(void) fprintf(stderr,
"Bad history arguments\n");
break;
}
} else if (el_parse(el, ac, av) == -1) {
switch (fork()) {
case 0:
execvp(av[0], (char *const *)av);
perror(av[0]);
_exit(1);
/*NOTREACHED*/
break;
case -1:
perror("fork");
break;
default:
if (wait(&num) == -1)
perror("wait");
(void) fprintf(stderr, "Exit %x\n", num);
break;
}
}
tok_reset(tok);
}
el_end(el);
tok_end(tok);
history_end(hist);
return (0);
}
/*
* Construct a JSON array for an iCalendar property.
*/
static json_t *icalproperty_as_json_array(icalproperty *prop)
{
icalproperty_kind prop_kind;
const char *x_name, *property_name = NULL;
icalparameter *param;
const char *type = NULL;
const icalvalue *value;
json_t *jprop, *jparams;
if (!prop) return NULL;
prop_kind = icalproperty_isa(prop);
x_name = icalproperty_get_x_name(prop);
if (prop_kind == ICAL_X_PROPERTY && x_name)
property_name = x_name;
else
property_name = icalproperty_kind_to_string(prop_kind);
if (!property_name) {
icalerror_warn("Got a property of an unknown kind.");
return NULL;
}
/* Create property array */
jprop = json_array();
/* Add property name */
json_array_append_new(jprop,
json_string(lcase(icalmemory_tmp_copy(property_name))));
/* Add parameters */
jparams = json_object();
for (param = icalproperty_get_first_parameter(prop, ICAL_ANY_PARAMETER);
param != 0;
param = icalproperty_get_next_parameter(prop, ICAL_ANY_PARAMETER)) {
if (icalparameter_isa(param) == ICAL_VALUE_PARAMETER) continue;
icalparameter_as_json_object_member(param, jparams);
}
json_array_append_new(jprop, jparams);
/* Add type */
type = icalproperty_value_kind_as_string(prop);
json_array_append_new(jprop, json_string(lcase(icalmemory_tmp_copy(type))));
/* Add value */
value = icalproperty_get_value(prop);
if (value) {
switch (icalproperty_isa(prop)) {
case ICAL_CATEGORIES_PROPERTY:
case ICAL_RESOURCES_PROPERTY:
case ICAL_POLLPROPERTIES_PROPERTY:
if (icalvalue_isa(value) == ICAL_TEXT_VALUE) {
/* Handle multi-valued properties */
const char *str = icalvalue_as_ical_string(value);
tok_t tok;
tok_init(&tok, str, ",", TOK_TRIMLEFT|TOK_TRIMRIGHT|TOK_EMPTY);
while ((str = tok_next(&tok))) {
if (*str) json_array_append_new(jprop, json_string(str));
}
tok_fini(&tok);
break;
}
default:
json_array_append_new(jprop, icalvalue_as_json_object(value));
break;
}
}
return jprop;
}
void gnu_parse_init(char *file)
/* Prepare parsing of an GNU assembly file. */
{
tok_init(file, '#');
}
// This function does I/O
static void tokenize( const wchar_t * const buff, std::vector<int> &color, const int pos, wcstring_list_t *error, const wcstring &working_directory, const env_vars_snapshot_t &vars) {
ASSERT_IS_BACKGROUND_THREAD();
wcstring cmd;
int had_cmd=0;
wcstring last_cmd;
int len;
int accept_switches = 1;
int use_function = 1;
int use_command = 1;
int use_builtin = 1;
CHECK( buff, );
len = wcslen(buff);
if( !len )
return;
std::fill(color.begin(), color.end(), -1);
tokenizer tok;
for( tok_init( &tok, buff, TOK_SHOW_COMMENTS | TOK_SQUASH_ERRORS );
tok_has_next( &tok );
tok_next( &tok ) )
{
int last_type = tok_last_type( &tok );
switch( last_type )
{
case TOK_STRING:
{
if( had_cmd )
{
/*Parameter */
wchar_t *param = tok_last( &tok );
if( param[0] == L'-' )
{
if (wcscmp( param, L"--" ) == 0 )
{
accept_switches = 0;
color.at(tok_get_pos( &tok )) = HIGHLIGHT_PARAM;
}
else if( accept_switches )
{
if( complete_is_valid_option( last_cmd.c_str(), param, error, false /* no autoload */ ) )
color.at(tok_get_pos( &tok )) = HIGHLIGHT_PARAM;
else
color.at(tok_get_pos( &tok )) = HIGHLIGHT_ERROR;
}
else
{
color.at(tok_get_pos( &tok )) = HIGHLIGHT_PARAM;
}
}
else
{
color.at(tok_get_pos( &tok )) = HIGHLIGHT_PARAM;
}
if( cmd == L"cd" )
{
wcstring dir = tok_last( &tok );
if (expand_one(dir, EXPAND_SKIP_CMDSUBST))
{
int is_help = string_prefixes_string(dir, L"--help") || string_prefixes_string(dir, L"-h");
if( !is_help && ! is_potential_cd_path(dir, working_directory, PATH_EXPAND_TILDE, NULL))
{
color.at(tok_get_pos( &tok )) = HIGHLIGHT_ERROR;
}
}
}
/* Highlight the parameter. highlight_param wants to write one more color than we have characters (hysterical raisins) so allocate one more in the vector. But don't copy it back. */
const wcstring param_str = param;
int tok_pos = tok_get_pos(&tok);
std::vector<int>::const_iterator where = color.begin() + tok_pos;
std::vector<int> subcolors(where, where + param_str.size());
subcolors.push_back(-1);
highlight_param(param_str, subcolors, pos-tok_pos, error);
/* Copy the subcolors back into our colors array */
std::copy(subcolors.begin(), subcolors.begin() + param_str.size(), color.begin() + tok_pos);
}
else
{
/*
Command. First check that the command actually exists.
*/
cmd = tok_last( &tok );
bool expanded = expand_one(cmd, EXPAND_SKIP_CMDSUBST | EXPAND_SKIP_VARIABLES);
if (! expanded || has_expand_reserved(cmd.c_str()))
{
color.at(tok_get_pos( &tok )) = HIGHLIGHT_ERROR;
}
else
{
bool is_cmd = false;
int is_subcommand = 0;
int mark = tok_get_pos( &tok );
color.at(tok_get_pos( &tok )) = HIGHLIGHT_COMMAND;
if( parser_keywords_is_subcommand( cmd ) )
{
int sw;
if( cmd == L"builtin")
{
use_function = 0;
use_command = 0;
use_builtin = 1;
}
else if( cmd == L"command")
{
use_command = 1;
use_function = 0;
use_builtin = 0;
}
tok_next( &tok );
sw = parser_keywords_is_switch( tok_last( &tok ) );
if( !parser_keywords_is_block( cmd ) &&
sw == ARG_SWITCH )
{
/*
The 'builtin' and 'command' builtins
are normally followed by another
command, but if they are invoked
with a switch, they aren't.
*/
use_command = 1;
use_function = 1;
use_builtin = 2;
}
else
{
if( sw == ARG_SKIP )
{
color.at(tok_get_pos( &tok )) = HIGHLIGHT_PARAM;
mark = tok_get_pos( &tok );
}
is_subcommand = 1;
}
tok_set_pos( &tok, mark );
}
if( !is_subcommand )
{
/*
OK, this is a command, it has been
successfully expanded and everything
looks ok. Lets check if the command
exists.
*/
/*
First check if it is a builtin or
function, since we don't have to stat
any files for that
*/
if (! is_cmd && use_builtin )
is_cmd = builtin_exists( cmd );
if (! is_cmd && use_function )
is_cmd = function_exists_no_autoload( cmd, vars );
/*
Moving on to expensive tests
*/
/*
Check if this is a regular command
*/
if (! is_cmd && use_command )
{
is_cmd = path_get_path( cmd, NULL, vars );
}
/* Maybe it is a path for a implicit cd command. */
if (! is_cmd)
{
if (use_builtin || (use_function && function_exists_no_autoload( L"cd", vars)))
is_cmd = path_can_be_implicit_cd(cmd, NULL, working_directory.c_str(), vars);
}
if( is_cmd )
{
color.at(tok_get_pos( &tok )) = HIGHLIGHT_COMMAND;
}
else
{
if( error ) {
error->push_back(format_string(L"Unknown command \'%ls\'", cmd.c_str()));
}
color.at(tok_get_pos( &tok )) = (HIGHLIGHT_ERROR);
}
had_cmd = 1;
}
if( had_cmd )
{
last_cmd = tok_last( &tok );
}
}
}
break;
}
case TOK_REDIRECT_NOCLOB:
case TOK_REDIRECT_OUT:
case TOK_REDIRECT_IN:
case TOK_REDIRECT_APPEND:
case TOK_REDIRECT_FD:
{
if( !had_cmd )
{
color.at(tok_get_pos( &tok )) = HIGHLIGHT_ERROR;
if( error )
error->push_back(L"Redirection without a command");
break;
}
wcstring target_str;
const wchar_t *target=NULL;
color.at(tok_get_pos( &tok )) = HIGHLIGHT_REDIRECTION;
tok_next( &tok );
/*
Check that we are redirecting into a file
*/
switch( tok_last_type( &tok ) )
{
case TOK_STRING:
{
target_str = tok_last( &tok );
if (expand_one(target_str, EXPAND_SKIP_CMDSUBST)) {
target = target_str.c_str();
}
/*
Redirect filename may contain a cmdsubst.
If so, it will be ignored/not flagged.
*/
}
break;
default:
{
size_t pos = tok_get_pos(&tok);
if (pos < color.size()) {
color.at(pos) = HIGHLIGHT_ERROR;
}
if( error )
error->push_back(L"Invalid redirection");
}
}
if( target != 0 )
{
wcstring dir = target;
size_t slash_idx = dir.find_last_of(L'/');
struct stat buff;
/*
If file is in directory other than '.', check
that the directory exists.
*/
if( slash_idx != wcstring::npos )
{
dir.resize(slash_idx);
if( wstat( dir, &buff ) == -1 )
{
color.at(tok_get_pos( &tok )) = HIGHLIGHT_ERROR;
if( error )
error->push_back(format_string(L"Directory \'%ls\' does not exist", dir.c_str()));
}
}
/*
If the file is read from or appended to, check
if it exists.
*/
if( last_type == TOK_REDIRECT_IN ||
last_type == TOK_REDIRECT_APPEND )
{
if( wstat( target, &buff ) == -1 )
{
color.at(tok_get_pos( &tok )) = HIGHLIGHT_ERROR;
if( error )
error->push_back(format_string(L"File \'%ls\' does not exist", target));
}
}
if( last_type == TOK_REDIRECT_NOCLOB )
{
if( wstat( target, &buff ) != -1 )
{
color.at(tok_get_pos( &tok )) = HIGHLIGHT_ERROR;
if( error )
error->push_back(format_string(L"File \'%ls\' exists", target));
}
}
}
break;
}
case TOK_PIPE:
case TOK_BACKGROUND:
{
if( had_cmd )
{
color.at(tok_get_pos( &tok )) = HIGHLIGHT_END;
had_cmd = 0;
use_command = 1;
use_function = 1;
use_builtin = 1;
accept_switches = 1;
}
else
{
color.at(tok_get_pos( &tok )) = HIGHLIGHT_ERROR;
if( error )
error->push_back(L"No job to put in background" );
}
break;
}
case TOK_END:
{
color.at(tok_get_pos( &tok )) = HIGHLIGHT_END;
had_cmd = 0;
use_command = 1;
use_function = 1;
use_builtin = 1;
accept_switches = 1;
break;
}
case TOK_COMMENT:
{
color.at(tok_get_pos( &tok )) = HIGHLIGHT_COMMENT;
break;
}
case TOK_ERROR:
default:
{
/*
If the tokenizer reports an error, highlight it as such.
*/
if( error )
error->push_back(tok_last( &tok));
color.at(tok_get_pos( &tok )) = HIGHLIGHT_ERROR;
break;
}
}
}
tok_destroy( &tok );
}
/* Parse a command line. Return by reference the last command, its arguments, and the offset in the string of the beginning of the last argument. This is used by autosuggestions */
static bool autosuggest_parse_command(const wcstring &str, wcstring *out_command, wcstring_list_t *out_arguments, int *out_last_arg_pos)
{
if (str.empty())
return false;
wcstring cmd;
wcstring_list_t args;
int arg_pos = -1;
bool had_cmd = false;
tokenizer tok;
for (tok_init( &tok, str.c_str(), TOK_ACCEPT_UNFINISHED | TOK_SQUASH_ERRORS); tok_has_next(&tok); tok_next(&tok))
{
int last_type = tok_last_type(&tok);
switch( last_type )
{
case TOK_STRING:
{
if( had_cmd )
{
/* Parameter to the command. We store these escaped. */
args.push_back(tok_last(&tok));
arg_pos = tok_get_pos(&tok);
}
else
{
/* Command. First check that the command actually exists. */
wcstring local_cmd = tok_last( &tok );
bool expanded = expand_one(cmd, EXPAND_SKIP_CMDSUBST | EXPAND_SKIP_VARIABLES);
if (! expanded || has_expand_reserved(cmd.c_str()))
{
/* We can't expand this cmd, ignore it */
}
else
{
bool is_subcommand = false;
int mark = tok_get_pos(&tok);
if (parser_keywords_is_subcommand(cmd))
{
int sw;
tok_next( &tok );
sw = parser_keywords_is_switch( tok_last( &tok ) );
if( !parser_keywords_is_block( cmd ) &&
sw == ARG_SWITCH )
{
/* It's an argument to the subcommand itself */
}
else
{
if( sw == ARG_SKIP )
mark = tok_get_pos( &tok );
is_subcommand = true;
}
tok_set_pos( &tok, mark );
}
if (!is_subcommand)
{
/* It's really a command */
had_cmd = true;
cmd = local_cmd;
}
}
}
break;
}
case TOK_REDIRECT_NOCLOB:
case TOK_REDIRECT_OUT:
case TOK_REDIRECT_IN:
case TOK_REDIRECT_APPEND:
case TOK_REDIRECT_FD:
{
if( !had_cmd )
{
break;
}
tok_next( &tok );
break;
}
case TOK_PIPE:
case TOK_BACKGROUND:
case TOK_END:
{
had_cmd = false;
cmd.empty();
args.empty();
arg_pos = -1;
break;
}
case TOK_COMMENT:
case TOK_ERROR:
default:
{
break;
}
}
}
tok_destroy( &tok );
/* Remember our command if we have one */
if (had_cmd) {
if (out_command) out_command->swap(cmd);
if (out_arguments) out_arguments->swap(args);
if (out_last_arg_pos) *out_last_arg_pos = arg_pos;
}
return had_cmd;
}
/**
Output the specified selection.
\param begin start of selection
\param end end of selection
\param cut_at_cursor whether printing should stop at the surrent cursor position
\param tokenize whether the string should be tokenized, printing one string token on every line and skipping non-string tokens
*/
static void write_part( const wchar_t *begin,
const wchar_t *end,
int cut_at_cursor,
int tokenize )
{
tokenizer tok;
string_buffer_t out;
wchar_t *buff;
int pos;
pos = get_cursor_pos()-(begin-get_buffer());
if( tokenize )
{
buff = wcsndup( begin, end-begin );
// fwprintf( stderr, L"Subshell: %ls, end char %lc\n", buff, *end );
sb_init( &out );
for( tok_init( &tok, buff, TOK_ACCEPT_UNFINISHED );
tok_has_next( &tok );
tok_next( &tok ) )
{
if( (cut_at_cursor) &&
(tok_get_pos( &tok)+wcslen(tok_last( &tok)) >= pos) )
break;
switch( tok_last_type( &tok ) )
{
case TOK_STRING:
{
wchar_t *tmp = unescape( tok_last( &tok ), UNESCAPE_INCOMPLETE );
sb_append( &out, tmp, L"\n", (void *)0 );
free( tmp );
break;
}
}
}
sb_append( sb_out,
(wchar_t *)out.buff );
free( buff );
tok_destroy( &tok );
sb_destroy( &out );
}
else
{
wchar_t *buff, *esc;
if( cut_at_cursor )
{
end = begin+pos;
}
buff = wcsndup( begin, end-begin );
esc = unescape( buff, UNESCAPE_INCOMPLETE );
// debug( 0, L"woot2 %ls -> %ls", buff, esc );
sb_append( sb_out, esc );
sb_append( sb_out, L"\n" );
free( esc );
free( buff );
}
}
void ack_parse_init(char *file)
/* Prepare parsing of an ACK assembly file. */
{
tok_init(file, '!');
}
/**
Test the tokenizer
*/
static void test_tok()
{
tokenizer t;
say( L"Testing tokenizer" );
say( L"Testing invalid input" );
tok_init( &t, 0, 0 );
if( tok_last_type( &t ) != TOK_ERROR )
{
err(L"Invalid input to tokenizer was undetected" );
}
say( L"Testing use of broken tokenizer" );
if( !tok_has_next( &t ) )
{
err( L"tok_has_next() should return 1 once on broken tokenizer" );
}
tok_next( &t );
if( tok_last_type( &t ) != TOK_ERROR )
{
err(L"Invalid input to tokenizer was undetected" );
}
/*
This should crash if there is a bug. No reliable way to detect otherwise.
*/
say( L"Test destruction of broken tokenizer" );
tok_destroy( &t );
{
wchar_t *str = L"string <redirection 2>&1 'nested \"quoted\" '(string containing subshells ){and,brackets}$as[$well (as variable arrays)]";
const int types[] =
{
TOK_STRING, TOK_REDIRECT_IN, TOK_STRING, TOK_REDIRECT_FD, TOK_STRING, TOK_STRING, TOK_END
}
;
int i;
say( L"Test correct tokenization" );
for( i=0, tok_init( &t, str, 0 ); i<(sizeof(types)/sizeof(int)); i++,tok_next( &t ) )
{
if( types[i] != tok_last_type( &t ) )
{
err( L"Tokenization error:");
wprintf( L"Token number %d of string \n'%ls'\n, expected token type %ls, got token '%ls' of type %ls\n",
i+1,
str,
tok_get_desc(types[i]),
tok_last(&t),
tok_get_desc(tok_last_type( &t )) );
}
}
}
}
/*
* Add the proper XML element for an iCalendar value.
*/
static void icalproperty_add_value_as_xml_element(xmlNodePtr xprop,
icalproperty *prop)
{
const char *type, *str = NULL;
xmlNodePtr xtype;
const icalvalue *value;
char buf[40];
/* Add type */
type = lcase(icalmemory_tmp_copy(
icalproperty_value_kind_as_string(prop)));
xtype = xmlNewChild(xprop, NULL, BAD_CAST type, NULL);
/* Add value */
value = icalproperty_get_value(prop);
switch (icalvalue_isa(value)) {
case ICAL_DATE_VALUE:
str = icaltime_as_iso_string(icalvalue_get_date(value));
break;
case ICAL_DATETIME_VALUE:
str = icaltime_as_iso_string(icalvalue_get_datetime(value));
break;
case ICAL_DATETIMEPERIOD_VALUE: {
struct icaldatetimeperiodtype dtp =
icalvalue_get_datetimeperiod(value);
if (!icaltime_is_null_time(dtp.time)) {
str = icaltime_as_iso_string(dtp.time);
break;
}
else {
icalperiodtype_add_as_xml_element(xtype, dtp.period);
return;
}
}
case ICAL_GEO_VALUE: {
struct icalgeotype geo = icalvalue_get_geo(value);
snprintf(buf, sizeof(buf), "%f", geo.lat);
xmlNewTextChild(xtype, NULL, BAD_CAST "latitude", BAD_CAST buf);
snprintf(buf, sizeof(buf), "%f", geo.lon);
xmlNewTextChild(xtype, NULL, BAD_CAST "longitude", BAD_CAST buf);
return;
}
case ICAL_PERIOD_VALUE:
icalperiodtype_add_as_xml_element(xtype, icalvalue_get_period(value));
return;
case ICAL_RECUR_VALUE: {
struct icalrecurrencetype recur = icalvalue_get_recur(value);
icalrecurrencetype_add_as_xxx(&recur, xtype, NULL,
&icalrecur_add_string_as_xml_element);
return;
}
case ICAL_REQUESTSTATUS_VALUE: {
struct icalreqstattype stat = icalvalue_get_requeststatus(value);
if (!stat.desc) stat.desc = icalenum_reqstat_desc(stat.code);
snprintf(buf, sizeof(buf), "%u.%u",
icalenum_reqstat_major(stat.code),
icalenum_reqstat_minor(stat.code));
xmlNewTextChild(xtype, NULL, BAD_CAST "code", BAD_CAST buf);
xmlNewTextChild(xtype, NULL, BAD_CAST "description", BAD_CAST stat.desc);
if (stat.debug)
xmlNewTextChild(xtype, NULL, BAD_CAST "data", BAD_CAST stat.debug);
return;
}
case ICAL_TRIGGER_VALUE: {
struct icaltriggertype trig = icalvalue_get_trigger(value);
if (!icaltime_is_null_time(trig.time))
str = icaltime_as_iso_string(trig.time);
else
str = icaldurationtype_as_ical_string(trig.duration);
break;
}
case ICAL_UTCOFFSET_VALUE:
str = icalvalue_utcoffset_as_iso_string(value);
break;
default:
str = icalvalue_as_ical_string(value);
switch (icalproperty_isa(prop)) {
case ICAL_CATEGORIES_PROPERTY:
case ICAL_RESOURCES_PROPERTY:
case ICAL_POLLPROPERTIES_PROPERTY:
if (strchr(str, ',')) {
/* Handle multi-valued properties */
tok_t tok;
tok_init(&tok, str, ",", TOK_TRIMLEFT|TOK_TRIMRIGHT|TOK_EMPTY);
str = tok_next(&tok);
xmlAddChild(xtype, xmlNewText(BAD_CAST str));
while ((str = tok_next(&tok))) {
if (*str) {
xtype = xmlNewChild(xprop, NULL, BAD_CAST type, NULL);
xmlAddChild(xtype, xmlNewText(BAD_CAST str));
}
}
tok_fini(&tok);
return;
}
default:
break;
}
break;
}
if (str) xmlAddChild(xtype, xmlNewText(BAD_CAST str));
}
int
main(int argc, char *argv[])
{
EditLine *el = NULL;
int numc, ncontinuation;
const wchar_t *line;
TokenizerW *tok;
HistoryW *hist;
HistEventW ev;
#ifdef DEBUG
int i;
#endif
setlocale(LC_ALL, "");
(void)signal(SIGINT, sig);
(void)signal(SIGQUIT, sig);
(void)signal(SIGHUP, sig);
(void)signal(SIGTERM, sig);
hist = history_winit(); /* Init built-in history */
history_w(hist, &ev, H_SETSIZE, 100); /* Remember 100 events */
history_w(hist, &ev, H_LOAD, hfile);
tok = tok_winit(NULL); /* Init the tokenizer */
el = el_init(argv[0], stdin, stdout, stderr);
el_wset(el, EL_EDITOR, L"vi"); /* Default editor is vi */
el_wset(el, EL_SIGNAL, 1); /* Handle signals gracefully */
el_wset(el, EL_PROMPT_ESC, prompt, '\1'); /* Set the prompt function */
el_wset(el, EL_HIST, history_w, hist); /* FIXME - history_w? */
/* Add a user-defined function */
el_wset(el, EL_ADDFN, L"ed-complete", L"Complete argument", complete);
/* Bind <tab> to it */
el_wset(el, EL_BIND, L"^I", L"ed-complete", NULL);
/*
* Bind j, k in vi command mode to previous and next line, instead
* of previous and next history.
*/
el_wset(el, EL_BIND, L"-a", L"k", L"ed-prev-line", NULL);
el_wset(el, EL_BIND, L"-a", L"j", L"ed-next-line", NULL);
/* Source the user's defaults file. */
el_source(el, NULL);
while((line = el_wgets(el, &numc)) != NULL && numc != 0) {
int ac, cc, co, rc;
const wchar_t **av;
const LineInfoW *li;
li = el_wline(el);
#ifdef DEBUG
(void)fwprintf(stderr, L"==> got %d %ls", numc, line);
(void)fwprintf(stderr, L" > li `%.*ls_%.*ls'\n",
(li->cursor - li->buffer), li->buffer,
(li->lastchar - 1 - li->cursor),
(li->cursor >= li->lastchar) ? L"" : li->cursor);
#endif
if (gotsig) {
(void)fprintf(stderr, "Got signal %d.\n", gotsig);
gotsig = 0;
el_reset(el);
}
if(!continuation && numc == 1)
continue; /* Only got a linefeed */
ac = cc = co = 0;
ncontinuation = tok_wline(tok, li, &ac, &av, &cc, &co);
if (ncontinuation < 0) {
(void) fprintf(stderr, "Internal error\n");
continuation = 0;
continue;
}
#ifdef DEBUG
(void)fprintf(stderr, " > nc %d ac %d cc %d co %d\n",
ncontinuation, ac, cc, co);
#endif
history_w(hist, &ev, continuation ? H_APPEND : H_ENTER, line);
continuation = ncontinuation;
ncontinuation = 0;
if(continuation)
continue;
#ifdef DEBUG
for (i = 0; i < ac; ++i) {
(void)fwprintf(stderr, L" > arg# %2d ", i);
if (i != cc)
(void)fwprintf(stderr, L"`%ls'\n", av[i]);
else
(void)fwprintf(stderr, L"`%.*ls_%ls'\n",
co, av[i], av[i] + co);
}
#endif
if (wcscmp (av[0], L"history") == 0) {
switch(ac) {
case 1:
for(rc = history_w(hist, &ev, H_LAST);
rc != -1;
rc = history_w(hist, &ev, H_PREV))
(void)fwprintf(stdout, L"%4d %ls",
ev.num, ev.str);
break;
case 2:
if (wcscmp(av[1], L"clear") == 0)
history_w(hist, &ev, H_CLEAR);
else
goto badhist;
break;
case 3:
if (wcscmp(av[1], L"load") == 0)
history_w(hist, &ev, H_LOAD,
my_wcstombs(av[2]));
else if (wcscmp(av[1], L"save") == 0)
history_w(hist, &ev, H_SAVE,
my_wcstombs(av[2]));
else
goto badhist;
break;
badhist:
default:
(void)fprintf(stderr,
"Bad history arguments\n");
break;
}
} else if (el_wparse(el, ac, av) == -1) {
switch (fork()) {
case 0: {
Tokenizer *ntok = tok_init(NULL);
int nargc;
const char **nav;
tok_str(ntok, my_wcstombs(line), &nargc, &nav);
execvp(nav[0],(char **)nav);
perror(nav[0]);
_exit(1);
/* NOTREACHED */
break;
}
case -1:
perror("fork");
break;
default:
if (wait(&rc) == -1)
perror("wait");
(void)fprintf(stderr, "Exit %x\n", rc);
break;
}
}
tok_wreset(tok);
}
el_end(el);
tok_wend(tok);
history_w(hist, &ev, H_SAVE, hfile);
history_wend(hist);
fprintf(stdout, "\n");
return 0;
}
int
main(int argc, char *argv[])
{
EditLine *el = NULL;
int num;
const char *buf;
Tokenizer *tok;
#if 0
int lastevent = 0;
#endif
int ncontinuation;
History *hist;
HistEvent ev;
(void) setlocale(LC_CTYPE, "");
(void) signal(SIGINT, sig);
(void) signal(SIGQUIT, sig);
(void) signal(SIGHUP, sig);
(void) signal(SIGTERM, sig);
hist = history_init(); /* Init the builtin history */
/* Remember 100 events */
history(hist, &ev, H_SETSIZE, 100);
tok = tok_init(NULL); /* Initialize the tokenizer */
/* Initialize editline */
el = el_init(*argv, stdin, stdout, stderr);
el_set(el, EL_EDITOR, "vi"); /* Default editor is vi */
el_set(el, EL_SIGNAL, 1); /* Handle signals gracefully */
el_set(el, EL_PROMPT_ESC, prompt, '\1');/* Set the prompt function */
/* Tell editline to use this history interface */
el_set(el, EL_HIST, history, hist);
/* Add a user-defined function */
el_set(el, EL_ADDFN, "ed-complete", "Complete argument", complete);
/* Bind tab to it */
el_set(el, EL_BIND, "^I", "ed-complete", NULL);
/*
* Bind j, k in vi command mode to previous and next line, instead
* of previous and next history.
*/
el_set(el, EL_BIND, "-a", "k", "ed-prev-line", NULL);
el_set(el, EL_BIND, "-a", "j", "ed-next-line", NULL);
/*
* Source the user's defaults file.
*/
el_source(el, NULL);
while ((buf = el_gets(el, &num)) != NULL && num != 0) {
int ac, cc, co;
#ifdef DEBUG
int i;
#endif
const char **av;
const LineInfo *li;
li = el_line(el);
#ifdef DEBUG
(void) fprintf(stderr, "==> got %d %s", num, buf);
(void) fprintf(stderr, " > li `%.*s_%.*s'\n",
(li->cursor - li->buffer), li->buffer,
(li->lastchar - 1 - li->cursor),
(li->cursor >= li->lastchar) ? "" : li->cursor);
#endif
if (gotsig) {
(void) fprintf(stderr, "Got signal %d.\n", (int)gotsig);
gotsig = 0;
el_reset(el);
}
if (!continuation && num == 1)
continue;
ac = cc = co = 0;
ncontinuation = tok_line(tok, li, &ac, &av, &cc, &co);
if (ncontinuation < 0) {
(void) fprintf(stderr, "Internal error\n");
continuation = 0;
continue;
}
#ifdef DEBUG
(void) fprintf(stderr, " > nc %d ac %d cc %d co %d\n",
ncontinuation, ac, cc, co);
#endif
#if 0
if (continuation) {
/*
* Append to the right event in case the user
* moved around in history.
*/
if (history(hist, &ev, H_SET, lastevent) == -1)
err(1, "%d: %s", lastevent, ev.str);
history(hist, &ev, H_ADD , buf);
} else {
history(hist, &ev, H_ENTER, buf);
lastevent = ev.num;
}
#else
/* Simpler */
history(hist, &ev, continuation ? H_APPEND : H_ENTER, buf);
#endif
continuation = ncontinuation;
ncontinuation = 0;
if (continuation)
continue;
#ifdef DEBUG
for (i = 0; i < ac; i++) {
(void) fprintf(stderr, " > arg# %2d ", i);
if (i != cc)
(void) fprintf(stderr, "`%s'\n", av[i]);
else
(void) fprintf(stderr, "`%.*s_%s'\n",
co, av[i], av[i] + co);
}
#endif
if (strcmp(av[0], "history") == 0) {
int rv;
switch (ac) {
case 1:
for (rv = history(hist, &ev, H_LAST); rv != -1;
rv = history(hist, &ev, H_PREV))
(void) fprintf(stdout, "%4d %s",
ev.num, ev.str);
break;
case 2:
if (strcmp(av[1], "clear") == 0)
history(hist, &ev, H_CLEAR);
else
goto badhist;
break;
case 3:
if (strcmp(av[1], "load") == 0)
history(hist, &ev, H_LOAD, av[2]);
else if (strcmp(av[1], "save") == 0)
history(hist, &ev, H_SAVE, av[2]);
break;
badhist:
default:
(void) fprintf(stderr,
"Bad history arguments\n");
break;
}
} else if (el_parse(el, ac, av) == -1) {
switch (fork()) {
case 0:
execvp(av[0], __DECONST(char **, av));
perror(av[0]);
_exit(1);
/*NOTREACHED*/
break;
case -1:
perror("fork");
break;
default:
if (wait(&num) == -1)
perror("wait");
(void) fprintf(stderr, "Exit %x\n", num);
break;
}
}
tok_reset(tok);
}
el_end(el);
tok_end(tok);
history_end(hist);
return (0);
}
static int
elObj_init(EditLineObject *self, PyObject *args, PyObject *kwds)
{
PyObject *pyfd;
int fd_in, fd_out, fd_err, rv;
char *name;
if (!PyArg_ParseTuple(args, "sOOO", &name,
&self->pyin, &self->pyout, &self->pyerr))
return -1;
/* need to ensure I own the refs */
Py_INCREF(self->pyin);
Py_INCREF(self->pyout);
Py_INCREF(self->pyerr);
/* check that there is fileno() on each stream */
pyfd = PyObject_CallMethod(self->pyin, "fileno", NULL);
fd_in = (int) PyLong_AsLong(pyfd);
self->fin = fdopen(fd_in, "r");
pyfd = PyObject_CallMethod(self->pyout, "fileno", NULL);
fd_out = (int) PyLong_AsLong(pyfd);
self->fout = fdopen(fd_out, "w");
pyfd = PyObject_CallMethod(self->pyerr, "fileno", NULL);
fd_err = (int) PyLong_AsLong(pyfd);
self->ferr = fdopen(fd_err, "w");
//printf("in: %d out:%d err:%d\n", fd_in, fd_out, fd_err);
/* save the name */
self->name = PyMem_RawMalloc(strlen(name)+1);
if (self->name == NULL) {
PyErr_NoMemory();
goto error;
}
strcpy(self->name, name);
/* prepare the default prompt */
#define MY_INIT_PROMPT "EL> "
self->prompt = PyMem_RawMalloc(strlen(MY_INIT_PROMPT)+1);
if (self->prompt == NULL) {
PyErr_NoMemory();
goto error;
}
strcpy(self->prompt, MY_INIT_PROMPT);
self->prompt_esc = '\1';
/* prepare the right-prompt to be empty */
self->rprompt = PyMem_RawMalloc(2);
if (self->rprompt == NULL) {
PyErr_NoMemory();
goto error;
}
self->rprompt[0] = '\0';
self->rprompt[1] = '\0';
self->rprompt_esc = '\1';
self->_debug = 0;
self->signature = 0xDEADBEEFUL;
/* prepare the scratch pad */
self->buffer_size = 2048;
self->buffer = PyMem_RawMalloc(self->buffer_size);
if (self->buffer == NULL) {
PyErr_NoMemory();
goto error;
}
/* create the history manager */
self->hist = history_init();
if (self->hist == NULL) {
PyErr_SetString(PyExc_ValueError, "history init failed");
goto error;
}
/* setup the history buffer */
rv = history(self->hist, &self->ev, H_SETSIZE, 100);
if (rv < 0) {
PyErr_SetString(PyExc_ValueError, "setting history size failed");
goto error;
}
rv = history(self->hist, &self->ev, H_SETUNIQUE, 0x1);
if (rv < 0) {
PyErr_SetString(PyExc_ValueError, "setting history uniqueness failed");
goto error;
}
/* create the tokenizer */
self->tok = tok_init(NULL);
if (self->tok == NULL) {
PyErr_SetString(PyExc_ValueError, "tokenizer init failed");
goto error;
}
/* create the libedit instance */
self->el = el_init(name,self->fin, self->fout, self->ferr);
if (self->el == NULL) {
PyErr_SetString(PyExc_ValueError, "libedit init failed");
goto error;
}
/* general init ... */
el_set(self->el, EL_EDITOR, "emacs");
el_set(self->el, EL_SIGNAL, 1);
el_set(self->el, EL_PROMPT_ESC, _prompt, self->prompt_esc);
el_set(self->el, EL_RPROMPT_ESC, _rprompt, self->rprompt_esc);
el_set(self->el, EL_HIST, history, self->hist);
el_set(self->el, EL_ADDFN, "ed-complete", "Complete argument", el_complete);
el_set(self->el, EL_BIND, "^I", "ed-complete", NULL);
el_source(self->el, NULL);
self->begidx = PyLong_FromLong(0L);
self->endidx = PyLong_FromLong(0L);
/* leave myself a breadcrumb... */
el_set(self->el, EL_CLIENTDATA, self);
return 0;
error:
_cleanup_editlineobject(self);
return -1;
}