void cmd_walk_and_expand (queue_t *qb)
{
queue_t *q;
queue_t newq;
ui_token_t *t;
int alias_check = TRUE;
int insquote = FALSE;
char *envstr;
q_init(&newq);
while ((t = (ui_token_t *) q_deqnext(qb))) {
if (t->token == '\'') {
alias_check = FALSE;
insquote = !insquote;
/* Check to see if we should try to expand this token */
}
else if (!insquote) {
if (alias_check && !strchr(tokenbreaks,t->token) &&
(envstr = env_getenv(&(t->token)))) {
/* Aliases: stick into token stream if no environment found */
cmd_append_tokens(&newq,envstr);
KFREE(t);
t = NULL;
}
else if (t->token == '$') {
/* non-aliases: remove from token stream if no env found */
envstr = env_getenv(&(t->token)+1);
if (envstr) cmd_append_tokens(&newq,envstr);
KFREE(t);
t = NULL;
}
else {
/* Drop down below, keep this token as-is and append */
}
}
/*
* If token was not removed, add it to the new queue
*/
if (t) {
q_enqueue(&newq,&(t->qb));
alias_check = is_command_separator(t);
}
}
/*
* Put everything back on the original list.
*/
while ((q = q_deqnext(&newq))) {
q_enqueue(qb,q);
}
}
void cmd_build_cmdline(queue_t *head, ui_cmdline_t *cmd)
{
ui_token_t *t;
ui_token_t *next;
memset(cmd, 0, sizeof(ui_cmdline_t));
t = (ui_token_t *) q_deqnext(head);
while (t != NULL) {
if (is_white_space(t)) {
/* do nothing */
}
else if (t->token != '-') {
if(cmd->argc < MAX_TOKENS){
cmd->argv[cmd->argc] = cmd_eat_quoted_arg(head,t);
cmd->argc++;
}
/* Token is a switch */
}
else {
if (cmd->swc < MAX_SWITCHES) {
cmd->swv[cmd->swc].swname = lib_strdup(&(t->token));
if (t->qb.q_next != head) { /* more tokens */
next = (ui_token_t *) t->qb.q_next;
if (next->token == '=') { /* switch has value */
KFREE(t); /* Free switch name */
t = (ui_token_t *) q_deqnext(head); /* eat equal sign */
KFREE(t); /* and free it */
t = (ui_token_t *) q_deqnext(head); /* now have value */
if (t != NULL) {
cmd->swv[cmd->swc].swvalue = cmd_eat_quoted_arg(head,t);
}
}
else { /* no value */
cmd->swv[cmd->swc].swvalue = NULL;
}
}
/*
* swidx is the index of the argument that this
* switch precedes. So, if you have "foo -d bar",
* swidx for "-d" would be 1.
*/
cmd->swv[cmd->swc].swidx = cmd->argc;
cmd->swc++;
}
}
KFREE(t);
t = (ui_token_t *) q_deqnext(head);
}
}
void cmd_free_tokens(queue_t *list)
{
queue_t *q;
while ((q = q_deqnext(list))) {
KFREE(q);
}
}
ui_command_t *cmd_readcommand(queue_t *head)
{
char *ptr;
int insquote = FALSE;
int indquote = FALSE;
ui_command_t *cmd;
int term = CMD_TERM_EOL;
ui_token_t *t;
cmd_eat_leading_white(head);
if (q_isempty(head)) return NULL;
cmd = (ui_command_t *) KMALLOC(sizeof(ui_command_t),0);
q_init(&(cmd->head));
while ((t = (ui_token_t *) q_deqnext(head))) {
ptr = &(t->token);
if (!insquote && !indquote) {
if ((*ptr == ';') || (*ptr == '\n')) {
term = CMD_TERM_SEMI;
break;
}
if ((*ptr == '&') && (*(ptr+1) == '&')) {
term = CMD_TERM_AND;
break;
}
if ((*ptr == '|') && (*(ptr+1) == '|')) {
term = CMD_TERM_OR;
break;
}
}
if (*ptr == '\'') {
insquote = !insquote;
}
if (!insquote) {
if (*ptr == '"') {
indquote = !indquote;
}
}
q_enqueue(&(cmd->head),&(t->qb));
}
cmd->term = term;
/* If we got out by finding a command separator, eat the separator */
if (term != CMD_TERM_EOL) {
KFREE(t);
}
return cmd;
}
static void cmd_append_tokens(queue_t *qb,char *str)
{
queue_t *qq;
queue_t explist;
cmd_build_list(&explist,str);
while ((qq = q_deqnext(&explist))) {
q_enqueue(qb,qq);
}
}
static void console_save(unsigned char *buffer,int length)
{
msgqueue_t *msg;
/*
* Get a pointer to the last message in the queue. If
* it's full, preprare to allocate a new one
*/
msg = (msgqueue_t *) console_msgq.q_prev;
if (q_isempty(&(console_msgq)) || (msg->len == MSGQUEUESIZE)) {
msg = NULL;
}
/*
* Stuff characters into message chunks till we're done
*/
while (length) {
/*
* New chunk
*/
if (msg == NULL) {
msg = (msgqueue_t *) KMALLOC(sizeof(msgqueue_t),0);
if (msg == NULL) return;
msg->len = 0;
q_enqueue(&console_msgq,(queue_t *) msg);
/*
* Remove chunks to prevent chewing too much memory
*/
while (q_count(&console_msgq) > MSGQUEUEMAX) {
msgqueue_t *dropmsg;
dropmsg = (msgqueue_t *) q_deqnext(&console_msgq);
if (dropmsg) KFREE(dropmsg);
}
}
/*
* Save text. If we run off the end of the buffer, prepare
* to allocate a new one
*/
msg->data[msg->len++] = *buffer++;
length--;
if (msg->len == MSGQUEUESIZE) msg = NULL;
}
}
static void console_flushbuffer(void)
{
msgqueue_t *msg;
char *buffer;
int length;
int res;
/*
* Remove console messages from the queue
*/
while ((msg = (msgqueue_t *) q_deqnext(&console_msgq))) {
buffer = msg->data;
length = msg->len;
res = 0;
/*
* Write each message to the console
*/
for (;;) {
res = cfe_write(console_handle,buffer,length);
if (res < 0) break;
buffer += res;
length -= res;
if (length == 0) break;
}
/*
* Free the storage
*/
KFREE(msg);
}
}
static char *cmd_eat_quoted_arg(queue_t *head,ui_token_t *t)
{
int dquote = 0;
int squote = 0;
queue_t qlist;
queue_t *q;
char *dest;
int maxlen = 0;
/*
* If it's not a quoted string, just return this token.
*/
if (!myisquote(t->token)) {
dest = lib_strdup(&(t->token));
/* Note: caller deletes original token */
return dest;
}
/*
* Otherwise, eat tokens in the quotes.
*/
q_init(&qlist);
if (t->token == '"') dquote = 1;
else squote = 1; /* must be one or the other */
t = (ui_token_t *) q_deqnext(head);
while (t != NULL) {
/* A single quote can only be terminated by another single quote */
if (squote && (t->token == '\'')) {
KFREE(t);
break;
}
/* A double quote is only honored if not in a single quote */
if (dquote && !squote && (t->token == '\"')) {
KFREE(t);
break;
}
/* Otherwise, keep this token. */
q_enqueue(&qlist,(queue_t *) t);
t = (ui_token_t *) q_deqnext(head);
}
/*
* Go back through what we collected and figure out the string length.
*/
for (q = qlist.q_next; q != &qlist; q = q->q_next) {
maxlen += strlen(&(((ui_token_t *) q)->token));
}
dest = KMALLOC(maxlen+1,0);
if (!dest) return NULL;
*dest = '\0';
while ((t = (ui_token_t *) q_deqnext(&qlist))) {
strcat(dest,&(t->token));
KFREE(t);
}
return dest;
}
