command.cc

Small Device C Compiler 面向Inter8051

/*
 * Simulator of microcontrollers (cmd.src/command.cc)
 *
 * Copyright (C) 2002,02 Drotos Daniel, Talker Bt.
 * 
 * To contact author send email to [e-mail]
 *
 */

/* This file is part of microcontroller simulator: ucsim.

UCSIM is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

UCSIM is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with UCSIM; see the file COPYING.  If not, write to the Free
Software Foundation, 59 Temple Place - Suite 330, Boston, MA
02111-1307, USA. */
/*@1@*/

#include "ddconfig.h"

#include <stdlib.h>
#include "i_string.h"

// prj

// local, cmd
#include "commandcl.h"


/*
 * Command line
 *____________________________________________________________________________
 */

cl_cmdline::cl_cmdline(class cl_app *the_app,
		       char *acmd, class cl_console *acon):
  cl_base()
{
  app= the_app;
  cmd= strdup(acmd);
  params= new cl_list(2, 2);
  tokens= new cl_ustrings(2, 2);
  set_name(0);
  matched_syntax= 0;
  con= acon;
}

cl_cmdline::~cl_cmdline(void)
{
  if (cmd)
    free(cmd);
  delete params;
  delete tokens;
}

int
cl_cmdline::init(void)
{
  split();
  return(0);
}

char *
cl_cmdline::skip_delims(char *start)
{
  while (*start &&
	 strchr(" \t\v\r,", *start))
    start++;
  return(start);
}

int
cl_cmdline::split(void)
{
  //class cl_sim *sim;
  char *start= cmd;
  int i;
  class cl_cmd_arg *arg;

  //sim= app->get_sim();
  set_name(0);
  if (!cmd ||
      !*cmd)
    return(0);
  start+= strspn(start, " \t\v\r,");
  if (start &&
      *start == '\n')
    {
      char *n= (char*)malloc(2);
      strcpy(n, "\n");
      set_name(n);
      return(0);
    }
  if (!*start)
    return(0);
  i= strcspn(start, " \t\v\r,");
  if (i)
    {
      char *n= (char*)malloc(i+1);
      strncpy(n, start, i);
      n[i]= '\0';
      set_name(n);
    }
  start+= i;
  start= skip_delims(start);
  // skip delimiters
  while (*start)
    {
      char *end, *param_str;
      if (*start == '"')
	{
	  // string
	  start++;
	  end= start;
	  while (*end &&
		 *end != '"')
	    {
	      if (*end == '\\')
		{
		  end++;
		  if (*end)
		    end++;
		}
	      else
		end++;
	    }
	  if (*end == '"')
	    end--;
	  else
	    con->dd_printf("Unterminated string\n");
	  param_str= (char *)malloc(end-start+2);
	  strncpy(param_str, start, 1+end-start);
	  param_str[1+end-start]= '\0';
	  tokens->add(strdup(param_str));
	  params->add(arg= new cl_cmd_str_arg(param_str));
	  arg->init();
	  free(param_str);
	  if (*end)
	    end++;
	  if (*end == '"')
	    end++;
	}
      else
	{
	  char *dot;
	  i= strcspn(start, " \t\v\r,");
	  end= start+i;
	  param_str= (char *)malloc(i+1);
	  strncpy(param_str, start, i);
	  param_str[i]= '\0';
	  if (strchr(">", *start))
	    {
	      char *fn, mode[3]= "w\0";
	      switch (*start)
		{
		case '>':
		  if (i == 1 ||
		      (i == 2 &&
		       start[1] == '>')) {
		    con->dd_printf("Unspecified redirection\n");
		    break;
		  }
		  fn= start+1;
		  if (*fn == '>') {
		    fn++;
		    mode[0]= 'a';
		  }
		  con->redirect(fn, mode);
		  break;
		default:
		  break;
		}
	      free(param_str);
	      start= end;
	      start= skip_delims(start);
	      continue;
	    }
	  tokens->add(strdup(param_str));
	  if ((dot= strchr(param_str, '.')) != NULL)
	    {
	      // bit
	      class cl_cmd_arg *sfr, *bit;
	      *dot= '\0';
	      dot++;
	      if (strchr("0123456789", *param_str) != NULL)
		{
		  sfr= new cl_cmd_int_arg((long)strtol(param_str, 0, 0));
		  sfr->init();
		}
	      else
		{
		  sfr= new cl_cmd_sym_arg(param_str);
		  sfr->init();
		}
	      if (*dot == '\0')
		{
		  bit= 0;
		  con->dd_printf("Uncomplete bit address\n");
		  delete sfr;
		}
	      else
		{
		  if (strchr("0123456789", *dot) != NULL)
		    {
		      bit= new cl_cmd_int_arg((long)strtol(dot, 0, 0));
		      bit->init();
		    }
		  else
		    {
		      bit= new cl_cmd_sym_arg(dot);
		      bit->init();
		    }
		  params->add(arg= new cl_cmd_bit_arg(sfr, bit));
		  arg->init();
		}
	    }
	  else if ((dot= strchr(param_str, '[')) != NULL)
	    {
	      // array
	      class cl_cmd_arg *aname, *aindex;
	      *dot= '\0';
	      dot++;
	      if (strchr("0123456789", *param_str) != NULL)
		{
		  aname= new cl_cmd_int_arg((long)strtol(param_str, 0, 0));
		  aname->init();
		}
	      else
		{
		  aname= new cl_cmd_sym_arg(param_str);
		  aname->init();
		}
	      if (*dot == '\0')
		{
		  aname= 0;
		  con->dd_printf("Uncomplete array\n");
		}
	      else
		{
		  char *p;
		  p= dot + strlen(dot) - 1;
		  while (p > dot &&
			 *p != ']')
		    {
		      *p= '\0';
		      p--;
		    }
		  if (*p == ']')
		    *p= '\0';
		  if (strlen(dot) == 0)
		    {
		      con->dd_printf("Uncomplete array index\n");
		      delete aname;
		    }
		  else    
		    {
		      if (strchr("0123456789", *dot) != NULL)
			{
			  aindex= new cl_cmd_int_arg((long)strtol(dot, 0, 0));
			  aindex->init();
			}
		      else
			{
			  aindex= new cl_cmd_sym_arg(dot);
			  aindex->init();
			}
		      params->add(arg= new cl_cmd_array_arg(aname, aindex));
		      arg->init();
		    }
		}
	    }
	  else if (strchr("0123456789", *param_str) != NULL)
	    {
	      // number
	      params->add(arg= new cl_cmd_int_arg((long)
						  strtol(param_str, 0, 0)));
	      arg->init();
	    }
	  else
	    {
	      // symbol
	      params->add(arg= new cl_cmd_sym_arg(param_str));
	      arg->init();
	    }
	  free(param_str);
	}
      start= end;
      start= skip_delims(start);
    }
  return(0);
}

int
cl_cmdline::shift(void)
{
  char *s= skip_delims(cmd);

  set_name(0);
  if (s && *s)
    {
      while (*s &&
	     strchr(" \t\v\r,", *s) == NULL)
	s++;
      s= skip_delims(s);
      char *p= strdup(s);
      free(cmd);
      cmd= p;
      delete params;
      params= new cl_list(2, 2);
      split();
    }
  return(have_real_name());
}

int
cl_cmdline::repeat(void)
{
  char *n;
  return((n= get_name()) &&
	 *n == '\n');
}

class cl_cmd_arg *
cl_cmdline::param(int num)
{
  if (num >= params->count)
    return(0);
  return((class cl_cmd_arg *)(params->at(num)));
}

void
cl_cmdline::insert_param(int pos, class cl_cmd_arg *param)
{
  if (pos >= params->count)
    params->add(param);
  else
    params->add_at(pos, param);
}

bool
cl_cmdline::syntax_match(class cl_uc *uc, char *syntax)
{
  if (!syntax)
    return(DD_FALSE);
  if (!*syntax &&
      !params->count)
    {
      matched_syntax= syntax;
      return(DD_TRUE);
    }
  if (!params->count)
    return(DD_FALSE);
  //printf("syntax %s?\n",syntax);
  char *p= syntax;
  int iparam= 0;
  class cl_cmd_arg *parm= (class cl_cmd_arg *)(params->at(iparam));
  bool match;
  while (*p &&
	 parm)
    {
      //printf("Checking %s as %c\n",parm->get_svalue(),*p);
      if (uc)
	switch (*p)
	  {
	  case SY_ADDR:
	    match= parm->as_address(uc);
	    if (!match)
	      return(match);
	    //printf("ADDRESS match %lx\n",parm->value.address);
	    break;
	  case SY_MEMORY:
	    match= parm->as_memory(uc);
	    if (!match)
	      return(DD_FALSE);
	    //printf("MEMORY match %s\n",parm->value.memory->class_name);
	    break;
	  case SY_BIT:
	    if (!parm->as_bit(uc))
	      return(DD_FALSE);
	    break;
	  }
      switch (*p)
	{
	case SY_ADDR: case SY_MEMORY: case SY_BIT: break;
	case SY_NUMBER:
	  if (!parm->as_number())
	    return(DD_FALSE);
	  break;
	case SY_DATA:
	  if (!parm->as_data())
	    return(DD_FALSE);
	  break;
	case SY_HW:
	  if (!parm->as_hw(uc))
	    return(DD_FALSE);