#include <sys/types.h>

#include <ctype.h>

#include <errno.h>

#include <limits.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <wchar.h>

#include "tmux.h"

#include "tmux-parser.h"

static int yylex(void);

static int yyparse(void);

static void printflike(1,2) yyerror(const char *, ...);

#define CMD_PARSE_MAX_ENVIRON_LEN 16384

TAILQ_HEAD(cmd_parse_nodes, cmd_parse_node);

struct cmd_parse_node {

enum cmd_parse_node_type type;

u_int line;

char *value;

struct cmd_parse_nodes children;

TAILQ_ENTRY(cmd_parse_node) entry;

};

struct cmd_parse_tree {

int references;

char *file;

int flags;

struct cmd_parse_node *root;

};

struct cmd_parse_state {

FILE *f;

const char *buf;

size_t len;

size_t off;

int condition;

int eol;

int eof;

struct cmd_parse_input *input;

u_int escapes;

char *error;

struct cmd_parse_nodes *commands;

};

static struct cmd_parse_state parse_state;

struct cmd_parse_scan {

struct cmd_parse_node *node;

char *text;

size_t len;

};

static char *cmd_parse_get_error(const char *, u_int, const char *);

static struct cmd_parse_node *cmd_parse_new_node(enum cmd_parse_node_type,

u_int);

static struct cmd_parse_node *cmd_parse_copy_node(struct cmd_parse_node *);

static struct cmd_parse_nodes *cmd_parse_new_nodes(void);

static void cmd_parse_free_node(struct cmd_parse_node *);

static void cmd_parse_append(struct cmd_parse_nodes *,

struct cmd_parse_nodes *);

static struct cmd_parse_nodes *cmd_parse_wrap(struct cmd_parse_node *);

static struct cmd_parse_node *cmd_parse_make_assign(enum cmd_parse_node_type,

struct cmd_parse_node *);

static struct cmd_parse_node *cmd_parse_token_from_string(const char *);

static void cmd_parse_onegroup(struct cmd_parse_node *);

static void cmd_parse_print_sequence(char **, struct cmd_parse_node *,

u_int, int);

static void cmd_parse_print_item(char **, struct cmd_parse_node *, u_int,

int);

static char *cmd_parse_make_string(struct cmd_parse_node *);

{

struct cmd_parse_node *node;

struct cmd_parse_nodes *nodes;

}

%token ERROR

%token HIDDEN

%token IF

%token ELSE

%token ELIF

%token ENDIF

%token <node> FORMAT TOKEN EQUALS

%type <node> expanded format argument command_name

%type <node> assign optional_assign hidden_assign

%type <node> commands condition condition1

%type <node> if_open if_elif if_else

%type <nodes> statements statement arguments argument_statements

%type <nodes> command elif elif1

lines : /* empty */

| statements

{

struct cmd_parse_state *ps = &parse_state;

ps->commands = $1;

}

statements : statement '\n'

{

$$ = $1;

}

| statements statement '\n'

{

$$ = $1;

cmd_parse_append($$, $2);

}

statement : /* empty */

{

$$ = cmd_parse_new_nodes();

}

| hidden_assign

{

$$ = cmd_parse_wrap($1);

}

| condition

{

$$ = cmd_parse_wrap($1);

}

| commands

{

$$ = cmd_parse_new_nodes();

if (TAILQ_EMPTY(&$1->children))

cmd_parse_free_node($1);

else

TAILQ_INSERT_TAIL($$, $1, entry);

}

format : FORMAT

{

$$ = $1;

}

| TOKEN

{

$$ = $1;

}

expanded : format

{

$$ = $1;

}

optional_assign : /* empty */

{

$$ = NULL;

}

| assign

{

$$ = $1;

}

assign : EQUALS

{

$$ = cmd_parse_make_assign(CMD_PARSE_ASSIGN, $1);

}

hidden_assign : HIDDEN EQUALS

{

$$ = cmd_parse_make_assign(CMD_PARSE_HIDDEN_ASSIGN, $2);

}

if_open : IF expanded

{

struct cmd_parse_state *ps = &parse_state;

$$ = cmd_parse_new_node(CMD_PARSE_IF, ps->input->line);

TAILQ_INSERT_TAIL(&$$->children, $2, entry);

}

if_else : ELSE

{

struct cmd_parse_state *ps = &parse_state;

$$ = cmd_parse_new_node(CMD_PARSE_ELSE, ps->input->line);

}

if_elif : ELIF expanded

{

struct cmd_parse_state *ps = &parse_state;

$$ = cmd_parse_new_node(CMD_PARSE_ELIF, ps->input->line);

TAILQ_INSERT_TAIL(&$$->children, $2, entry);

}

condition : if_open '\n' statements ENDIF

{

cmd_parse_append(&$1->children, $3);

$$ = $1;

}

| if_open '\n' statements if_else '\n' statements ENDIF

{

cmd_parse_append(&$1->children, $3);

cmd_parse_append(&$4->children, $6);

TAILQ_INSERT_TAIL(&$1->children, $4, entry);

$$ = $1;

}

| if_open '\n' statements elif ENDIF

{

cmd_parse_append(&$1->children, $3);

cmd_parse_append(&$1->children, $4);

$$ = $1;

}

| if_open '\n' statements elif if_else '\n' statements ENDIF

{

cmd_parse_append(&$1->children, $3);

cmd_parse_append(&$1->children, $4);

cmd_parse_append(&$5->children, $7);

TAILQ_INSERT_TAIL(&$1->children, $5, entry);

$$ = $1;

}

elif : if_elif '\n' statements

{

cmd_parse_append(&$1->children, $3);

$$ = cmd_parse_new_nodes();

TAILQ_INSERT_TAIL($$, $1, entry);

}

| if_elif '\n' statements elif

{

cmd_parse_append(&$1->children, $3);

$$ = cmd_parse_new_nodes();

TAILQ_INSERT_TAIL($$, $1, entry);

cmd_parse_append($$, $4);

}

commands : command

{

struct cmd_parse_state *ps = &parse_state;

struct cmd_parse_input *pi = ps->input;

$$ = cmd_parse_new_node(CMD_PARSE_SEQUENCE, pi->line);

cmd_parse_append(&$$->children, $1);

}

| commands ';'

{

$$ = $1;

}

| commands ';' condition1

{

$$ = $1;

TAILQ_INSERT_TAIL(&$$->children, $3, entry);

}

| commands ';' command

{

$$ = $1;

cmd_parse_append(&$$->children, $3);

}

| condition1

{

struct cmd_parse_state *ps = &parse_state;

struct cmd_parse_input *pi = ps->input;

$$ = cmd_parse_new_node(CMD_PARSE_SEQUENCE, pi->line);

TAILQ_INSERT_TAIL(&$$->children, $1, entry);

}

command : assign

{

$$ = cmd_parse_new_nodes();

TAILQ_INSERT_TAIL($$, $1, entry);

}

| optional_assign command_name

{

struct cmd_parse_state *ps = &parse_state;

struct cmd_parse_node *cmd;

struct cmd_parse_input *pi = ps->input;

cmd = cmd_parse_new_node(CMD_PARSE_COMMAND, pi->line);

TAILQ_INSERT_TAIL(&cmd->children, $2, entry);

$$ = cmd_parse_new_nodes();

if ($1 != NULL)

TAILQ_INSERT_TAIL($$, $1, entry);

TAILQ_INSERT_TAIL($$, cmd, entry);

}

| optional_assign command_name arguments

{

struct cmd_parse_state *ps = &parse_state;

struct cmd_parse_node *cmd;

struct cmd_parse_input *pi = ps->input;

cmd = cmd_parse_new_node(CMD_PARSE_COMMAND, pi->line);

TAILQ_INSERT_TAIL(&cmd->children, $2, entry);

cmd_parse_append(&cmd->children, $3);

$$ = cmd_parse_new_nodes();

if ($1 != NULL)

TAILQ_INSERT_TAIL($$, $1, entry);

TAILQ_INSERT_TAIL($$, cmd, entry);

}

command_name : TOKEN

{

$$ = $1;

}

condition1 : if_open commands ENDIF

{

TAILQ_INSERT_TAIL(&$1->children, $2, entry);

$$ = $1;

}

| if_open commands if_else commands ENDIF

{

TAILQ_INSERT_TAIL(&$1->children, $2, entry);

TAILQ_INSERT_TAIL(&$3->children, $4, entry);

TAILQ_INSERT_TAIL(&$1->children, $3, entry);

$$ = $1;

}

| if_open commands elif1 ENDIF

{

TAILQ_INSERT_TAIL(&$1->children, $2, entry);

cmd_parse_append(&$1->children, $3);

$$ = $1;

}

| if_open commands elif1 if_else commands ENDIF

{

TAILQ_INSERT_TAIL(&$1->children, $2, entry);

cmd_parse_append(&$1->children, $3);

TAILQ_INSERT_TAIL(&$4->children, $5, entry);

TAILQ_INSERT_TAIL(&$1->children, $4, entry);

$$ = $1;

}

elif1 : if_elif commands

{

TAILQ_INSERT_TAIL(&$1->children, $2, entry);

$$ = cmd_parse_new_nodes();

TAILQ_INSERT_TAIL($$, $1, entry);

}

| if_elif commands elif1

{

TAILQ_INSERT_TAIL(&$1->children, $2, entry);

$$ = cmd_parse_new_nodes();

TAILQ_INSERT_TAIL($$, $1, entry);

cmd_parse_append($$, $3);

}

arguments : argument

{

$$ = cmd_parse_new_nodes();

TAILQ_INSERT_HEAD($$, $1, entry);

}

| argument arguments

{

TAILQ_INSERT_HEAD($2, $1, entry);

$$ = $2;

}

argument : TOKEN

{

$$ = $1;

}

| EQUALS

{

$$ = $1;

}

| '{' argument_statements

{

struct cmd_parse_state *ps = &parse_state;

struct cmd_parse_input *pi = ps->input;

$$ = cmd_parse_new_node(CMD_PARSE_COMMANDS, pi->line);

cmd_parse_append(&$$->children, $2);

}

argument_statements : statement '}'

{

$$ = $1;

}

| statements statement '}'

{

$$ = $1;

cmd_parse_append($$, $2);

}

%%

static char *

cmd_parse_get_error(const char *file, u_int line, const char *error)

{

char *s;

if (file == NULL)

s = xstrdup(error);

else

xasprintf(&s, "%s:%u: %s", file, line, error);

return (s);

}

static struct cmd_parse_node *

cmd_parse_new_node(enum cmd_parse_node_type type, u_int line)

{

struct cmd_parse_node *node;

node = xcalloc(1, sizeof *node);

node->type = type;

node->line = line;

TAILQ_INIT(&node->children);

return (node);

}

static struct cmd_parse_nodes *

cmd_parse_new_nodes(void)

{

struct cmd_parse_nodes *nodes;

nodes = xmalloc(sizeof *nodes);

TAILQ_INIT(nodes);

return (nodes);

}

static void

cmd_parse_free_node(struct cmd_parse_node *node)

{

struct cmd_parse_node *child, *child1;

if (node == NULL)

return;

TAILQ_FOREACH_SAFE(child, &node->children, entry, child1) {

TAILQ_REMOVE(&node->children, child, entry);

cmd_parse_free_node(child);

}

free(node->value);

free(node);

}

static struct cmd_parse_node *

cmd_parse_copy_node(struct cmd_parse_node *node)

{

struct cmd_parse_node *new, *child, *copy;

new = cmd_parse_new_node(node->type, node->line);

if (node->value != NULL)

new->value = xstrdup(node->value);

TAILQ_FOREACH(child, &node->children, entry) {

copy = cmd_parse_copy_node(child);

TAILQ_INSERT_TAIL(&new->children, copy, entry);

}

return (new);

}

static void

cmd_parse_append(struct cmd_parse_nodes *dst, struct cmd_parse_nodes *src)

{

TAILQ_CONCAT(dst, src, entry);

free(src);

}

static struct cmd_parse_nodes *

cmd_parse_wrap(struct cmd_parse_node *item)

{

struct cmd_parse_nodes *nodes;

struct cmd_parse_node *seq;

seq = cmd_parse_new_node(CMD_PARSE_SEQUENCE, item->line);

TAILQ_INSERT_TAIL(&seq->children, item, entry);

nodes = cmd_parse_new_nodes();

TAILQ_INSERT_TAIL(nodes, seq, entry);

return (nodes);

}

static struct cmd_parse_node *

cmd_parse_make_assign(enum cmd_parse_node_type type,

struct cmd_parse_node *string)

{

struct cmd_parse_node *node, *value, *first, *child, *child1;

const char *cp, *eq;

node = cmd_parse_new_node(type, string->line);

first = TAILQ_FIRST(&string->children);

eq = strchr(first->value, '=');

node->value = xstrndup(first->value, eq - first->value);

value = cmd_parse_new_node(CMD_PARSE_STRING, string->line);

cp = eq + 1;

if (*cp != '\0') {

child = cmd_parse_new_node(CMD_PARSE_TEXT, string->line);

child->value = xstrdup(cp);

TAILQ_INSERT_TAIL(&value->children, child, entry);

}

TAILQ_REMOVE(&string->children, first, entry);

cmd_parse_free_node(first);

TAILQ_FOREACH_SAFE(child, &string->children, entry, child1) {

TAILQ_REMOVE(&string->children, child, entry);

TAILQ_INSERT_TAIL(&value->children, child, entry);

}

cmd_parse_free_node(string);

TAILQ_INSERT_TAIL(&node->children, value, entry);

return (node);

}

static struct cmd_parse_node *

cmd_parse_token_from_string(const char *s)

{

struct cmd_parse_node *node, *child;

struct cmd_parse_state *ps = &parse_state;

struct cmd_parse_input *pi = ps->input;

node = cmd_parse_new_node(CMD_PARSE_STRING, pi->line);

if (*s != '\0') {

child = cmd_parse_new_node(CMD_PARSE_TEXT, pi->line);

child->value = xstrdup(s);

TAILQ_INSERT_TAIL(&node->children, child, entry);

}

return (node);

}

static void

cmd_parse_onegroup(struct cmd_parse_node *node)

{

struct cmd_parse_node *child, *child1, *first = NULL;

TAILQ_FOREACH(child, &node->children, entry)

cmd_parse_onegroup(child);

TAILQ_FOREACH_SAFE(child, &node->children, entry, child1) {

if (child->type != CMD_PARSE_SEQUENCE) {

first = NULL;

continue;

}

if (first == NULL) {

first = child;

continue;

}

TAILQ_CONCAT(&first->children, &child->children, entry);

TAILQ_REMOVE(&node->children, child, entry);

cmd_parse_free_node(child);

}

}

static struct cmd_parse_tree *

cmd_parse_run_parser(char **cause)

{

struct cmd_parse_state *ps = &parse_state;

struct cmd_parse_node *root;

struct cmd_parse_tree *tree;

int retval;

ps->commands = NULL;

retval = yyparse();

if (retval != 0) {

*cause = ps->error;

return (NULL);

}

root = cmd_parse_new_node(CMD_PARSE_ROOT, 0);

if (ps->commands != NULL) {

cmd_parse_append(&root->children, ps->commands);

ps->commands = NULL;

}

if (ps->input->flags & CMD_PARSE_ONEGROUP)

cmd_parse_onegroup(root);

tree = xcalloc(1, sizeof *tree);

tree->references = 1;

tree->file = ps->input->file != NULL ? xstrdup(ps->input->file) : NULL;

tree->flags = (ps->input->flags & ~CMD_PARSE_ONEGROUP);

tree->root = root;

return (tree);

}

static struct cmd_parse_tree *

cmd_parse_do_file(FILE *f, struct cmd_parse_input *pi, char **cause)

{

struct cmd_parse_state *ps = &parse_state;

memset(ps, 0, sizeof *ps);

ps->input = pi;

ps->f = f;

return (cmd_parse_run_parser(cause));

}

static struct cmd_parse_tree *

cmd_parse_do_buffer(const char *buf, size_t len, struct cmd_parse_input *pi,

char **cause)

{

struct cmd_parse_state *ps = &parse_state;

memset(ps, 0, sizeof *ps);

ps->input = pi;

ps->buf = buf;

ps->len = len;

return (cmd_parse_run_parser(cause));

}

struct cmd_parse_tree *

cmd_parse_from_file(FILE *f, struct cmd_parse_input *pi, char **cause)

{

struct cmd_parse_input input;

if (pi == NULL) {

memset(&input, 0, sizeof input);

pi = &input;

}

*cause = NULL;

return (cmd_parse_do_file(f, pi, cause));

}

struct cmd_parse_tree *

cmd_parse_from_buffer(const void *buf, size_t len, struct cmd_parse_input *pi,

char **cause)

{

struct cmd_parse_input input;

if (pi == NULL) {

memset(&input, 0, sizeof input);

pi = &input;

}

*cause = NULL;

return (cmd_parse_do_buffer(buf, len, pi, cause));

}

struct cmd_parse_tree *

cmd_parse_from_string(const char *s, struct cmd_parse_input *pi, char **cause)

{

struct cmd_parse_input input;

if (pi != NULL)

memcpy(&input, pi, sizeof input);

else

memset(&input, 0, sizeof input);

/*

input.flags |= CMD_PARSE_ONEGROUP;

return (cmd_parse_from_buffer(s, strlen(s), &input, cause));

}

struct cmd_parse_tree *

cmd_parse_from_node(struct cmd_parse_tree *tree, struct cmd_parse_node *node)

{

struct cmd_parse_tree *new;

struct cmd_parse_node *root, *child, *copy;

root = cmd_parse_new_node(CMD_PARSE_ROOT, node->line);

TAILQ_FOREACH(child, &node->children, entry) {

copy = cmd_parse_copy_node(child);

TAILQ_INSERT_TAIL(&root->children, copy, entry);

}

new = xcalloc(1, sizeof *new);

new->references = 1;

new->file = tree->file != NULL ? xstrdup(tree->file) : NULL;

new->flags = tree->flags;

new->root = root;

return (new);

}

static struct cmd_parse_node *

cmd_parse_last_top_level_command(struct cmd_parse_tree *tree)

{

struct cmd_parse_node *root, *seq, *node, *last = NULL;

root = cmd_parse_root(tree);

TAILQ_FOREACH(seq, &root->children, entry) {

if (seq->type == CMD_PARSE_SEQUENCE) {

TAILQ_FOREACH(node, &seq->children, entry) {

if (node->type == CMD_PARSE_COMMAND)

last = node;

}

}

}

return (last);

}

cmd_parse_expand_alias(struct cmd_parse_tree *src, struct cmd_parse_node *cmd,

struct cmd_parse_tree **out, char **cause)

{

struct cmd_parse_input pi;

struct cmd_parse_tree *tree;

struct cmd_parse_node *first, *last, *loop, *copy;

char *alias, *name;

*out = NULL;

*cause = NULL;

if (cmd->type != CMD_PARSE_COMMAND)

return (0);

if (cmd_parse_flags(src) & CMD_PARSE_NOALIAS)

return (0);

first = TAILQ_FIRST(&cmd->children);

if (first == NULL)

return (0);

name = cmd_parse_make_string(first);

if (name == NULL)

return (0);

alias = cmd_get_alias(name);

free(name);

if (alias == NULL)

return (0);

memset(&pi, 0, sizeof pi);

pi.file = cmd_parse_file(src);

pi.line = cmd_parse_node_line(cmd);

pi.flags = cmd_parse_flags(src) | CMD_PARSE_NOALIAS;

tree = cmd_parse_from_buffer(alias, strlen(alias), &pi, cause);

free(alias);

if (tree == NULL)

return (-1);

last = cmd_parse_last_top_level_command(tree);

if (last != NULL) {

loop = TAILQ_NEXT(first, entry);

while (loop != NULL) {

copy = cmd_parse_copy_node(loop);

TAILQ_INSERT_TAIL(&last->children, copy, entry);

loop = TAILQ_NEXT(loop, entry);

}

}

*out = tree;

return (1);

}

static struct cmd_parse_node *

cmd_parse_new_string_node(const char *s, u_int line)

{

struct cmd_parse_node *string, *text;

string = cmd_parse_new_node(CMD_PARSE_STRING, line);

if (*s != '\0') {

text = cmd_parse_new_node(CMD_PARSE_TEXT, line);

text->value = xstrdup(s);

TAILQ_INSERT_TAIL(&string->children, text, entry);

}

return (string);

}

static struct cmd_parse_node *

cmd_parse_new_commands_node(struct cmd_parse_tree *tree, u_int line)

{

struct cmd_parse_node *commands, *root, *child, *copy;

commands = cmd_parse_new_node(CMD_PARSE_COMMANDS, line);

root = cmd_parse_root(tree);

TAILQ_FOREACH(child, &root->children, entry) {

copy = cmd_parse_copy_node(child);

TAILQ_INSERT_TAIL(&commands->children, copy, entry);

}

return (commands);

}

static void

cmd_parse_from_arguments_add(struct cmd_parse_node *seq,

struct cmd_parse_node **cmd, struct cmd_parse_node *child, u_int line)

{

if (*cmd == NULL) {

*cmd = cmd_parse_new_node(CMD_PARSE_COMMAND, line);

TAILQ_INSERT_TAIL(&seq->children, *cmd, entry);

}

TAILQ_INSERT_TAIL(&(*cmd)->children, child, entry);

}

struct cmd_parse_tree *

cmd_parse_from_arguments(struct args_value *values, u_int count,

struct cmd_parse_input *pi)

{

struct cmd_parse_tree *new, *new_cmd;

struct cmd_parse_node *root, *seq, *cmd = NULL, *child;

u_int i;

char *copy;

size_t size;

int end;

u_int line = 0;

if (pi != NULL)

line = pi->line;

root = cmd_parse_new_node(CMD_PARSE_ROOT, line);

seq = cmd_parse_new_node(CMD_PARSE_SEQUENCE, line);

TAILQ_INSERT_TAIL(&root->children, seq, entry);

for (i = 0; i < count; i++) {

end = 0;

switch (values[i].type) {

case ARGS_NONE:

continue;

case ARGS_STRING:

copy = xstrdup(values[i].string);

size = strlen(copy);

if (size != 0 && copy[size - 1] == ';') {

copy[--size] = '\0';

if (size > 0 && copy[size - 1] == '\\')

copy[size - 1] = ';';

else

end = 1;

}

if (end && size == 0) {

free(copy);

break;

}

child = cmd_parse_new_string_node(copy, line);

cmd_parse_from_arguments_add(seq, &cmd, child, line);

free(copy);

break;

case ARGS_COMMANDS:

new_cmd = values[i].cmd;

child = cmd_parse_new_commands_node(new_cmd, line);

cmd_parse_from_arguments_add(seq, &cmd, child, line);

break;

default:

fatalx("unknown argument type");

}

if (end)

cmd = NULL;

}

new = xcalloc(1, sizeof *new);

new->references = 1;

if (pi != NULL) {

new->file = pi->file != NULL ? xstrdup(pi->file) : NULL;

new->flags = (pi->flags & ~CMD_PARSE_ONEGROUP);

}

new->root = root;

return (new);

}

struct cmd_parse_tree *

cmd_parse_add_ref(struct cmd_parse_tree *tree)

{

tree->references++;

return (tree);

}

cmd_parse_free(struct cmd_parse_tree *tree)

{

if (tree != NULL && --tree->references == 0) {

cmd_parse_free_node(tree->root);

free(tree->file);

free(tree);

}

}

struct cmd_parse_node *

cmd_parse_root(struct cmd_parse_tree *tree)

{

return (tree->root);

}

const char *

cmd_parse_file(struct cmd_parse_tree *tree)

{

return (tree->file);

}

cmd_parse_flags(struct cmd_parse_tree *tree)

{

return (tree->flags);

}

enum cmd_parse_node_type

cmd_parse_node_type(struct cmd_parse_node *node)

{

return (node->type);

}

const char *

cmd_parse_node_type_string(enum cmd_parse_node_type type)

{

switch (type) {

case CMD_PARSE_ROOT:

return ("ROOT");

case CMD_PARSE_SEQUENCE:

return ("SEQUENCE");

case CMD_PARSE_COMMAND:

return ("COMMAND");

case CMD_PARSE_STRING:

return ("STRING");

case CMD_PARSE_COMMANDS:

return ("COMMANDS");

case CMD_PARSE_TEXT:

return ("TEXT");

case CMD_PARSE_ENVIRONMENT:

return ("ENVIRONMENT");

case CMD_PARSE_TILDE:

return ("TILDE");

case CMD_PARSE_ASSIGN:

return ("ASSIGN");

case CMD_PARSE_HIDDEN_ASSIGN:

return ("HIDDEN_ASSIGN");

case CMD_PARSE_IF:

return ("IF");

case CMD_PARSE_ELIF:

return ("ELIF");

case CMD_PARSE_ELSE:

return ("ELSE");

}

return ("UNKNOWN");

}

const char *

cmd_parse_node_value(struct cmd_parse_node *node)

{

return (node->value);

}

cmd_parse_node_line(struct cmd_parse_node *node)

{

return (node->line);

}

struct cmd_parse_node *

cmd_parse_node_first_child(struct cmd_parse_node *node)

{

return (TAILQ_FIRST(&node->children));

}

struct cmd_parse_node *

cmd_parse_node_next(struct cmd_parse_node *node)

{