C++ command_free函数代码示例

void
command_free(command_t *cmd)
{
	int i;
	
	// It's OK to command_free(NULL).
	if (!cmd)
		return;

	/* Your code here. */
	i=0;
	while(cmd->argv[i]!=NULL&&i<MAXTOKENS+1){
		free(cmd->argv[i++]);
	}
	i=0;
	while(i<3){
		if (cmd->redirect_filename[i]!=NULL)
		{
			free(cmd->redirect_filename[i]);
		}
		i++;
	}
	if(cmd->subshell!=NULL){
		command_free(cmd->subshell);
	}
	if(cmd->next!=NULL){
		command_free(cmd->next);
	}
	free(cmd);


}

static void
command_parse_args(command_t *self, int argc, char **argv) {
  int literal = 0;
  int i, j;

  for (i = 1; i < argc; ++i) {
    const char *arg = argv[i];
    for (j = 0; j < self->option_count; ++j) {
      command_option_t *option = &self->options[j];

      // match flag
      if (!strcmp(arg, option->small) || !strcmp(arg, option->large)) {
        self->arg = NULL;

        // required
        if (option->required_arg) {
          arg = argv[++i];
          if (!arg || '-' == arg[0]) {
            fprintf(stderr, "%s %s argument required\n", option->large, option->argname);
            command_free(self);
            exit(1);
          }
          self->arg = arg;
        }

        // optional
        if (option->optional_arg) {
          if (argv[i + 1] && '-' != argv[i + 1][0]) {
            self->arg = argv[++i];
          }
        }

        // invoke callback
        option->cb(self);
        goto match;
      }
    }

    // --
    if ('-' == arg[0] && '-' == arg[1] && 0 == arg[2]) {
      literal = 1;
      goto match;
    }

    // unrecognized
    if ('-' == arg[0] && !literal) {
      fprintf(stderr, "unrecognized flag %s\n", arg);
      command_free(self);
      exit(1);
    }

    int n = self->argc++;
    if (n == COMMANDER_MAX_ARGS) {
      command_free(self);
      error("Maximum number of arguments exceeded");
    }
    self->argv[n] = (char *) arg;
    match:;
  }
}

static void execute(char *buf)
{
    struct command *cmd = command_new();
    char *arg;
    char *rest;

    if (!cmd)
    {
        fprintf(stderr, "Memory exhausted\n");

        return;
    }

    while (*buf && *buf == ' ')
        buf++;

    if (!*buf)
    {
        command_free(cmd);

        return;
    }

    arg = strtok_r(buf, " ", &rest);

    while (arg)
    {
        if (command_append(cmd, arg) < 0)
        {
            command_free(cmd);

            fprintf(stderr, "Memory exhausted\n");

            return;
        }

        while (*rest && *rest == ' ')
            rest++;

        arg = strtok_r(NULL, " ", &rest);
    }

    command_append(cmd, NULL);

    command_execute(cmd);

    command_free(cmd);
}

enum SamError sam_cmd(Vis *vis, const char *s) {
	enum SamError err = SAM_ERR_OK;
	if (!s)
		return err;

	Command *cmd = sam_parse(vis, s, &err);
	if (!cmd) {
		if (err == SAM_ERR_OK)
			err = SAM_ERR_MEMORY;
		return err;
	}

	Filerange range = text_range_empty();
	sam_execute(vis, vis->win, cmd, NULL, &range);

	if (vis->win) {
		bool completed = true;
		for (Cursor *c = view_cursors(vis->win->view); c; c = view_cursors_next(c)) {
			Filerange sel = view_cursors_selection_get(c);
			if (text_range_valid(&sel)) {
				completed = false;
				break;
			}
		}
		vis_mode_switch(vis, completed ? VIS_MODE_NORMAL : VIS_MODE_VISUAL);
	}
	command_free(cmd);
	return err;
}

int Fill3f(Display *display, int r, int g, int b) {
	/* There's probably more error checking to do here since
	 * changing the colorMode actually defines the max values 
	 * acceptable here. Default is 1.0 so we'll start with that...
	 */
	if (r > 1.0 || g > 1.0 || b > 1.0) {
		return -1;
	}
	Command *cmd = NULL;
    Socket *socket = NULL;
    
    socket = display->socket;
    
    /* cmd = command_format("FI_F %f %f %f", r, g, b); */
    cmd = command_format_json("FI_F", "%f %f %f", r, g, b);
    if (cmd == NULL)
        return -1;
        
    if (command_send(cmd, socket) != 0) {
        command_free(cmd);
        return -1;
    }
    
    return 0;
}

int
main(int argc, char **argv) {
    int rc = 1;
    opts.spaces = 2;

    command_t cmd;
    command_init(&cmd, argv[0], "1.0.0");
    command_option(&cmd
                   , "-v"
                   , "--verbose"
                   , "enable verbose stuff"
                   , set_verbose);
    command_option(&cmd
                   , "-s"
                   , "--spaces [count]"
                   , "optional number of spaces (defaults to 2)"
                   , set_spaces);
    command_parse(&cmd, argc, argv);

    for (int i = 0; i < cmd.argc; ++i) {
        if (-1 == convert_file(cmd.argv[i])) goto cleanup;
    }

    rc = 0;

cleanup:
    command_free(&cmd);
    return rc;
}

/*
 * This is a general purpose way to call jquery from C.
 *
 * Just a front for $("#id").css("name", "value");
 */
int TextAreaSetCss(Display *display, const char *id, const char *name, const char *value)
{
	Command *cmd = NULL;
	Socket *socket = NULL;

	socket = display->socket;

	if (id == NULL)
		return -1;

	if (strlen(id) == 0 || strlen(name) == 0 || strlen(value) == 0)
		return 0;

	cmd = command_format_json("TXT_AREA_CSS", "\"%s\" \"%s\" \"%s\"", id, name, value);
	if (cmd == NULL)
		return -1;

	if (command_send(cmd, socket) != 0) {
		command_free(cmd);
		return -1;
	}

	return 0;

}

/* Create a text area over the canvas to receive text directly */
int CreateTextArea(Display *display, const char *id, int x, int y, int width, int height, int readonly)
{
	Command *cmd = NULL;
    Socket *socket = NULL;
    
    socket = display->socket;
        
    if (id == NULL)
        return -1;
    
    if (strlen(id) == 0)
        return 0;
       
    if (readonly != TRUE && readonly != FALSE)
		return 0;
        
    cmd = command_format_json("NEW_TXT_AREA", "\"%s\" %d %d %d %d %d", id, x, y, width, height, readonly);
    if (cmd == NULL)
        return -1;
    
    if (command_send(cmd, socket) != 0) {
        command_free(cmd);
        return -1;
    }
    
    return 0;
}

int AppendTextArea(Display *display, const char *target, const char *text)
{
	Command *cmd = NULL;
    Socket *socket = NULL;
    
    socket = display->socket;
        
    if (target == NULL || text == NULL)
        return -1;
    
    if (strlen(target) == 0)
        return 0;
       
    if (strlen(text) == 0)
		return 0;
        
    cmd = command_format_json("APPEND", "\"%s\" \"%s\"", target, text);
    if (cmd == NULL)
        return -1;
    
    if (command_send(cmd, socket) != 0) {
        command_free(cmd);
        return -1;
    }
    
    return 0;
}

static struct command *command_new(struct command_context *cmd_ctx,
                                   struct command *parent, const struct command_registration *cr)
{
    assert(cr->name);

    struct command *c = calloc(1, sizeof(struct command));
    if (NULL == c)
        return NULL;

    c->name = strdup(cr->name);
    if (cr->help)
        c->help = strdup(cr->help);
    if (cr->usage)
        c->usage = strdup(cr->usage);

    if (!c->name || (cr->help && !c->help) || (cr->usage && !c->usage))
        goto command_new_error;

    c->parent = parent;
    c->handler = cr->handler;
    c->jim_handler = cr->jim_handler;
    c->jim_handler_data = cr->jim_handler_data;
    c->mode = cr->mode;

    command_add_child(command_list_for_parent(cmd_ctx, parent), c);

    return c;

command_new_error:
    command_free(c);
    return NULL;
}

/* TODO: remove this */
int SendText(Display *display, int x, int y, char *text)
{
    Command *cmd = NULL;
    Socket *socket = NULL;
    int textlen = 0;
    
    socket = display->socket;
        
    if (text == NULL)
        return -1;
    
    textlen = strlen(text);
    if (textlen == 0)
        return 0;
        
    //command_format("TXT %d %d %s", x, y, text);
    cmd = command_format_json("TXT", "\"%s\" %d %d", text, x, y);
    if (cmd == NULL)
        return -1;
    
    if (command_send(cmd, socket) != 0) {
        command_free(cmd);
        return -1;
    }
    
    return 0;
}

static gint sieve_pop_send_queue(SieveSession *session)
{
	SieveCommand *cmd;
	GSList *send_queue = session->send_queue;

	if (session->current_cmd) {
		command_free(session->current_cmd);
		session->current_cmd = NULL;
	}

	if (!send_queue)
		return SE_OK;

	cmd = (SieveCommand *)send_queue->data;
	session->send_queue = g_slist_next(send_queue);
	g_slist_free_1(send_queue);

	log_send(session, cmd);
	session->state = cmd->next_state;
	session->current_cmd = cmd;
	if (session_send_msg(SESSION(session), SESSION_SEND, cmd->msg) < 0)
		return SE_ERROR;

	return SE_OK;
}

void help(command_t* self)
{
	(void)(self);

	std::cout <<
		" _      __   _       __    _     ____ \n"
		"| |\\ | ( (` | |\\ |  / /\\  | |_/ | |_  \n"
		"|_| \\| _)_) |_| \\| /_/--\\ |_| \\ |_|__ \n"
		"v" VERSION "                 (built " DATE ")\n"
		"\n"
		"nsnake is the classical snake game on the\n"
		"terminal.\n"
		"It's settings and scores are stored at:\n"
		"	~/.local/share/nsnake/\n"
		"\n"
		"Usage:\n"
		"	nsnake [options]\n"
		"\n"
		"	-h, --help     Show this message\n"
		"	-v, --version  Show game version and contact info\n"
		"\n"
		"Thank you for playing this game :)\n";

	command_free(self);
	exit(EXIT_SUCCESS);
}

int SendKeyboardCallbackMsg(Display *display, char* type, char* list)
{
	Command *cmd = NULL;
	Socket *socket = NULL;
	int i,size;
	char *str, args[10];

	socket = display->socket;

	if (list == NULL) {
		cmd = command_format_json(type, "\"%s\"", "ALL");
	} else {
		size = strlen(list);
		str = calloc(size*5, sizeof(char));
		for (i = 0; i < size; i ++) {
			if (i != size -1) sprintf(args, "%hu,", list[i]);
			else sprintf(args, "%hu", list[i]);
			strcat(str, args);
		}
		cmd = command_format_json(type, "%s", str);
		free(str);
	}

	if (cmd == NULL)
		return -1;

	if (command_send(cmd, socket) != 0) {
		command_free(cmd);
		return -1;
	}

	return 0;
}

void input_driver_deinit_command(void)
{
#ifdef HAVE_COMMAND
   if (input_driver_command)
      command_free(input_driver_command);
   input_driver_command = NULL;
#endif
}