C++ CMD函数代码示例

int	exec_pipe(char **cmd, char **env)
{
    t_pip	p;

    p.ret = 0;
    if (pipe(p.fd) == -1)
        return (my_putstr("QuadriSH: Error pipe.\n", 2));
    if ((p.pid = fork()) < 0)
        return (1);
    if (p.pid == 0)
    {
        close(p.fd[0]);
        dup2(p.fd[1], 1);
        my_parser(my_str_to_wordtab(CMD(cmd[0])), 1, env);
        exit(0);
    }
    else
    {
        close(p.fd[1]);
        dup2(p.fd[0], 0);
        my_parser(my_str_to_wordtab(CMD(cmd[1])), 1, env);
        wait(&p.ret);
        exit(0);
    }
    return (p.ret);
}

void LCD_INIT()
{

DDRD=0xFF;                                                    

DDRC=0xFF;


PORTD=0x38;
CMD ();
_delay_ms(100);
PORTD=0x0E;
CMD ();
_delay_ms(100);
PORTD=0x01;
CMD ();
_delay_ms(100);
PORTD=0x06;
CMD ();
_delay_ms(100);
PORTD=0x80;
CMD ();
_delay_ms(100);

PORTD=0x00;
}

ReturnType FlashSingleProgram(udword udAddrOff,uCPUBusType ucValue)
/****************************************************************************
* INPUT(S)             :
* OUTPUT(S)            :
* DESIGN DOC.          :
* FUNCTION DESCRIPTION :
*
****************************************************************************/
{
  uCPUBusType val;

  OS_Use(&mSemaFlashDrv);

  FlashWrite( 0x00555, (uCPUBusType)CMD(0x00AA) );  /* 1st cycle */
  FlashWrite( 0x002AA, (uCPUBusType)CMD(0x0055) );  /* 2nd cycle */
  FlashWrite( 0x00555, (uCPUBusType)CMD(0x00A0) );  /* Program command */
  FlashWrite( udAddrOff,ucValue );                  /* Program value */
  FlashDataToggle();
  val = FlashRead( udAddrOff );
  if (val != ucValue)
  {
    return Flash_OperationTimeOut;
  }

  OS_Unuse(&mSemaFlashDrv);

  return Flash_Success;
}

/*-------------------------------------------------------------------*/
int locate_cmd(int argc, char *argv[], char *cmdline)
{
    int rc = 0;

    UNREFERENCED(cmdline);

    if (argc > 1 && CMD(argv[1],sysblk,6))
    {
        rc = locate_sysblk(argc, argv, cmdline);
    }
    else
    if (argc > 1 && CMD(argv[1],regs,4))
    {
        rc = locate_regs(argc, argv, cmdline);
    }
    else
    if (argc > 1 && CMD(argv[1],hostinfo,4))
    {
        rc = locate_hostinfo(argc, argv, cmdline);
    }
    else
    {
        WRMSG( HHC02299, "E", argv[0] );
        rc = -1;
    }

    return rc;
}

void setup_gpioexp_stm32(void)
{
  uint8_t data[16];
  int sz;
  int ret;

  Serial.println("starting stm32 gpio code");

  ret = stm32_cmd(CMD(0, 0), NULL, 0, data, 3);
  if (ret < 0) {
    Serial.println("Failed to find stm32 info");
  } else {
    sz = data[2];
    if (sz > sizeof(data)) {
       Serial.println("truncating info buffer size");
       sz = sizeof(data);
    }
      
    ret = stm32_cmd(CMD(0,0), NULL, 0, data, sz);
    if (ret) {
      Serial.println("failed to read all stm32 info");
    } else {
      Serial.println("Found stm32 info:");
      Serial.print("Major version "); Serial.println(data[0]);
      Serial.print("Minor version "); Serial.println(data[1]);
    }
  }
}

void	manage_env(t_group *grp)
{
	int		i;
	int		j;
	int		pos;

	i = -1;
	j = -1;
	pos = list_to_tab(0, grp->first, NULL);
	while (++i < grp->define_cmd[namenv] &&
		CMD(cmd_split)[i + grp->define_cmd[e_opt] + 1])
		pos += 1;
	grp->env = (char **)malloc(sizeof(char *) * (pos + 1));
	grp->env_save = (char **)malloc(sizeof(char *) * (pos + 1));
	while (++j < pos + 1)
	{
		grp->env[j] = NULL;
		grp->env_save[j] = NULL;
	}
	i = -1;
	pos = list_to_tab(1, grp->first, &(grp->env));
	while (++i < grp->define_cmd[namenv] &&
		CMD(cmd_split)[i + grp->define_cmd[e_opt] + 1])
	{
		grp->env[pos + i] =
		SDUP(CMD(cmd_split)[i + grp->define_cmd[e_opt] + 1]);
	}
}

void shell_run(tree_t e, struct tree_rd_ctx *ctx)
{
   const int ndecls = tree_decls(e);
   hash_t *decl_hash = hash_new(ndecls * 2, true);
   for (int i = 0; i < ndecls; i++) {
      tree_t d = tree_decl(e, i);
      hash_put(decl_hash, tree_ident(d), d);
   }

   Tcl_Interp *interp = Tcl_CreateInterp();

   bool have_quit = false;

   Tcl_CreateExitHandler(shell_exit_handler, &have_quit);

   shell_cmd_t shell_cmds[] = {
      CMD(quit,      &have_quit, "Exit simulation"),
      CMD(run,       ctx,        "Start or resume simulation"),
      CMD(restart,   NULL,       "Restart simulation"),
      CMD(show,      decl_hash,  "Display simulation objects"),
      CMD(help,      shell_cmds, "Display this message"),
      CMD(copyright, NULL,       "Display copyright information"),
      CMD(signals,   e,          "Find signal objects in the design"),
      CMD(now,       NULL,       "Display current simulation time"),
      CMD(watch,     decl_hash,  "Trace changes to a signal"),
      CMD(unwatch,   decl_hash,  "Stop tracing signals"),

      { NULL, NULL, NULL, NULL}
   };

   qsort(shell_cmds, ARRAY_LEN(shell_cmds) - 1, sizeof(shell_cmd_t),
         compare_shell_cmd);

   for (shell_cmd_t *c = shell_cmds; c->name != NULL; c++)
      Tcl_CreateObjCommand(interp, c->name, c->fn, c->cd, NULL);

   show_banner();

   slave_post_msg(SLAVE_RESTART, NULL, 0);

   char *line;
   while (!have_quit && (line = shell_get_line())) {
      switch (Tcl_Eval(interp, line)) {
      case TCL_OK:
         break;
      case TCL_ERROR:
         errorf("%s", Tcl_GetStringResult(interp));
         break;
      default:
         assert(false);
      }

      free(line);
   }

   Tcl_Exit(EXIT_SUCCESS);
}

static void my_commands (void)
{
	extern int nsp (int argc, char *argv[]);
	extern int psp (int argc, char *argv[]);
	extern int keysp (int argc, char *argv[]);

	CMD(ns,		"# list nodes");
	CMD(ps,		"# list processes and avatars");
	CMD(keys,	"# list processes and keys");
}

void init_dir (void)
{
	int		rc;

	rc = sw_local("dir_cmd", &Dir_key);
	if (rc) failure("sw_local", rc);

	CMD(cr,		"<path> # create a dir entry");
	CMD(prtree,	"# have dirfs print full directory tree");
	CMD(prbackup,	"# have dirfs print backup tree");
	CMD(rd,		"[inode num]+ # get and print a dir");
	CMD(ls,		"# list dir tree");
}

void handleCommand(string command)
{
	hC_begin

	CMD("look")
		cout << "You see:" << endl;
		for (unsigned i = 0; i < stuff.size(); i++)
			cout << " * " << stuff[i] << endl;
	CMD("open")
		if (args[1] == "door")
			if (has_item("key"))
			{
				cout << "The door opened!" << endl;
				ACHIEVE(DOOR_OPEN);
				goNextLevel();
			}
			else
				cout << "The door is locked!" << endl;
	CMD("take")
		if (args[1] == "comment")
		{
			if (has_achievement(EA_CAPTCHA)) {
				FIND("comment");
			} else
				cout << "You can't! It's not your's!" << endl;
		}
		if (args[1] == "captcha")
			FIND("captcha");
	CMD("say")
		if (args[1] == "captcha")
			if (has_item("captcha"))
			{
				cout << "Man, that captcha was lamer than i thought!" << endl;
				ACHIEVE(CAPTCHA);
			}
			else
				cout << "What does that captcha say? I don't know!" << endl;
	CMD("post")
		if (args[1] == "comment")
			if (has_item("comment"))
			{
				FIND("key");
				ACHIEVE(COMMENT);
			}
			else
				cout << "You can't! It's not your's!" << endl;
	CMD("help")
		cout << "The following commands are availeble:" << endl << " * look\n * open\n * take\n * say\n * post\n";

	hC_end
}

int main(int argc, const char **argv)
{
    setlocale(LC_ALL, "");
    /* Hack:
     * Right-to-left scripts don't work properly in many terminals.
     * Hebrew speaking people say he_IL.utf8 looks so mangled
     * they prefer en_US.utf8 instead.
     */
    const char *msg_locale = setlocale(LC_MESSAGES, NULL);
    if (msg_locale && strcmp(msg_locale, "he_IL.utf8") == 0)
        setlocale(LC_MESSAGES, "en_US.utf8");
#if ENABLE_NLS
    bindtextdomain(PACKAGE, LOCALEDIR);
    textdomain(PACKAGE);
#endif

    abrt_init((char **)argv);

    argv++;
    argc--;

    const char *abrt_cli_usage_string = _(
                                            "Usage: abrt-cli [--version] COMMAND [DIR]..."
                                        );

    const struct cmd_struct commands[] = {
        CMD(list, _("List problems [in DIRs]")),
        CMD(rm, _("Remove problem directory DIR")),
        CMD(report, _("Analyze and report problem data in DIR")),
        CMD(info, _("Print information about DIR")),
        CMD(status, _("Print the count of the recent crashes")),
        {NULL, NULL, NULL}
    };

    migrate_to_xdg_dirs();

    unsigned skip = handle_internal_options(argc, argv, abrt_cli_usage_string);
    argc -= skip;
    argv += skip;
    if (argc > 0)
        handle_internal_command(argc, argv, commands);

    /* user didn't specify command; print out help */
    printf("%s\n\n", abrt_cli_usage_string);
    list_cmds_help(commands);
    printf("\n%s\n", _("See 'abrt-cli COMMAND --help' for more information"));

    return 0;
}

void st7565Init(FONT_DEF_STRUCT * font)
{
  // Note: This can be optimised to set all pins to output and high
  // in two commands by manipulating the registers directly (assuming
  // that the pins are located in the same GPIO bank).  The code is left
  // as is for clarity sake in case the pins are not all located in the
  // same bank.

	ST7565_CS_DIR	 		= OUTPUT;
	ST7565_RST_DIR	 	= OUTPUT;
	ST7565_A0_DIR	 		= OUTPUT;
	ST7565_SCL_DIR	 	= OUTPUT;
	ST7565_SDA_DIR	 	= OUTPUT;

	ST7565_SDA = 1;
  ST7565_SCL = 1;
	ST7565_A0  = 1;
	ST7565_RST = 1;
	ST7565_CS  = 1;

  // Reset
	ST7565_CS  = 0;
	ST7565_RST = 0;
	_delay_ms(500);
	ST7565_RST = 1;

	currentFont = font;

  // Configure Display
  //CMD(ST7565_CMD_SET_BIAS_7);                       // LCD Bias Select									0xA3		0xA2
  CMD(ST7565_CMD_SET_BIAS_9);                         // LCD Bias Select									0xA3		0xA2
  CMD(ST7565_CMD_SET_ADC_NORMAL);                     // ADC Select												0xA0		0xA6
  CMD(ST7565_CMD_SET_COM_NORMAL);                     // SHL Select												0xC0		0xc8
  //CMD(ST7565_CMD_SET_COM_REVERSE);                     // SHL Select												0xC0		0xc8
  CMD(ST7565_CMD_SET_DISP_START_LINE);                // Initial Display Line							0x40		0x40
  CMD(ST7565_CMD_SET_POWER_CONTROL | 0x04);           // Turn on voltage converter (VC=1, VR=0, VF=0)			0x28		0x24
  _delay_ms(50);                											// Wait 50mS
  CMD(ST7565_CMD_SET_POWER_CONTROL | 0x06);           // Turn on voltage regulator (VC=1, VR=1, VF=0)
  _delay_ms(50);                											// Wait 50mS
  CMD(ST7565_CMD_SET_POWER_CONTROL | 0x07);           // Turn on voltage follower
  _delay_ms(10);                											// Wait 10mS
  CMD(ST7565_CMD_SET_RESISTOR_RATIO | 0x6);           // Set LCD operating voltage

  // Turn display on
  CMD(ST7565_CMD_DISPLAY_ON);													// 0xAF
  CMD(ST7565_CMD_SET_ALLPTS_NORMAL);									// 0xA4
  st7565SetBrightness(0x11);	// 0x18
}

int bot_disconnect(struct bot* b)
{
	printf("Dying...\n");
	CMD(b->conn, "PRIVMSG", NULL, "EXIT CBOT is dying.");
	globalkill=1;
	return 0;
}

void writeBuffer(uint8_t *buffer) 
{
  uint8_t c, p;

  for(p = 0; p < 8; p++) 
  {
    CMD(ST7565_CMD_SET_PAGE | (7-p));
//    CMD(ST7565_CMD_SET_PAGE | (p));
      CMD(ST7565_CMD_SET_COLUMN_LOWER | (0x0 & 0xf));
    CMD(ST7565_CMD_SET_COLUMN_UPPER | ((0x0 >> 4) & 0xf));
    CMD(ST7565_CMD_RMW);
    
    for(c = 0; c < 128; c++) 
    {
      DATA(buffer[(128*p)+c]);
    }
  }
}

extern int stm32_gpio_set(unsigned int gpio, unsigned int state)
{
  uint8_t data;
  int ret;
  
  data = (gpio << 3) | (state ? 1 : 0);
  ret = stm32_cmd(CMD(STM_CMD_SET, 0), &data, 1, NULL, 0);
  return ret;
}