C++ skip_token函数代码示例

//-------------------------------------------------------------------
// Process one entry "@default VAR VALUE"
//-------------------------------------------------------------------
static const char* get_default(sc_param *p, const char *ptr, int isScript)
{
    ptr = skip_to_token(ptr);
    if (p)
    {
        int type = MENUITEM_INT|MENUITEM_SCRIPT_PARAM;
        int range = 0;
        if (strncmp(ptr, "true", 4) == 0)
        {
            p->val = 1;
            type = MENUITEM_BOOL|MENUITEM_SCRIPT_PARAM;
            range = MENU_MINMAX(1,0);   // Force boolean data type in Lua (ToDo: this is clunky, needs fixing)

        }
        else if (strncmp(ptr, "false", 5) == 0)
        {
            p->val = 0;
            type = MENUITEM_BOOL|MENUITEM_SCRIPT_PARAM;
            range = MENU_MINMAX(1,0);   // Force boolean data type in Lua (ToDo: this is clunky, needs fixing)
        }
        else
        {
            p->val = strtol(ptr, NULL, 0);
        }
        p->old_val = p->val;
        if (isScript)   // Loading from script file (rather than saved param set file)
        {
            p->def_val = p->val;
            p->range = range;
            p->range_type = type;
        }
    }
    return skip_token(ptr);
}

int *cpu_available_freq_func( void ) {
	char *p;
	static int val[3];

	if ( stat(CPU_FREQ_SCALING_AVAILABLE_FREQ, &struct_stat) == 0 ) {
		if(slurpfile(CPU_FREQ_SCALING_AVAILABLE_FREQ, sys_devices_system_cpu_available, 128)) {
			p = sys_devices_system_cpu_available;
			val[0] = (strtol( p, (char **)NULL , 10 ) / 1000 );
			p = skip_token(p);
			val[1] = (strtol( p, (char **)NULL , 10 ) / 1000 );
			p = skip_token(p);
			val[2] = (strtol( p, (char **)NULL , 10 ) / 1000 );
		}
	}
	return val;
}

/* same as in ACK */
static int zap_unknown(asm86_t *a)
/* An error, zap the rest of the line. */
{
	token_t *t;
#define MAX_ASTR	4096
	char astr[MAX_ASTR];
	unsigned astr_len = 0;

	astr[astr_len++] = '\t';
	while ((t= get_token(0))->type != T_EOF && t->symbol != ';' 
			&& t->type != T_COMMENT) {
		switch(t->type) {
			case T_CHAR: 
				astr[astr_len++] = t->symbol;
				break;
			case T_WORD:
			case T_STRING:
				strncpy(astr + astr_len, t->name, t->len);
				astr_len += t->len;
				break;

		}
		skip_token(1);
	}
	astr[astr_len++] = '\0';
	
	a->raw_string = malloc(astr_len);
	if (!a->raw_string)
		return -1;

	strcpy(a->raw_string, astr);

	return 0;
}

static int parse_meta_handed(const char *p)
{
	char *t;
	int meta;
	int ret = 0;
	if (!p) goto ret;

	while (*p) {
		t = get_token(p);
		if (t) {
			meta = lookup_meta_token(t);
			free(t);
		} else meta = INVALID_NUMBER;

		if (meta == INVALID_NUMBER /*|| !is_meta_handed(meta)*/) {
			ret = INVALID_NUMBER;
			break;
		}

		ret |= meta;
		p = skip_token(p);
	}

ret:
	return ret;
}

static unsigned long
read_boot_time(glibtop *server)
{
	char* line = NULL;
	size_t size = 0;
	FILE* stat;
	unsigned long btime = 0;

	if (!(stat = fopen("/proc/stat", "r"))) {
		glibtop_error_io_r(server, "fopen(\"/proc/stat\")");
		goto out;
	}

	while (getline(&line, &size, stat) != -1) {
		if (!strncmp(line, "btime", 5)) {
			btime = strtoul(skip_token(line), NULL, 10);
			break;
		}
	}

	free(line);
	fclose(stat);
out:
	return btime;
}

/*
 * A helper function to return the total number of cpu jiffies
 */
JT
total_jiffies_func ( void )
{
   char *p;
   JT user_jiffies, nice_jiffies, system_jiffies, idle_jiffies,
                 wio_jiffies, irq_jiffies, sirq_jiffies;

   p = update_file(&proc_stat);
   p = skip_token(p);
   p = skip_whitespace(p);
   user_jiffies = strtod( p, &p );
   p = skip_whitespace(p);
   nice_jiffies = strtod( p, &p );
   p = skip_whitespace(p);
   system_jiffies = strtod( p, &p );
   p = skip_whitespace(p);
   idle_jiffies = strtod( p, &p );

   if(num_cpustates == NUM_CPUSTATES_24X)
     return user_jiffies + nice_jiffies + system_jiffies + idle_jiffies;

   p = skip_whitespace(p);
   wio_jiffies = strtod( p, &p );
   p = skip_whitespace(p);
   irq_jiffies = strtod( p, &p );
   p = skip_whitespace(p);
   sirq_jiffies = strtod( p, &p );

   return user_jiffies + nice_jiffies + system_jiffies + idle_jiffies +
          wio_jiffies + irq_jiffies + sirq_jiffies;
}

parse_size(device *current,
	   device *bus,
	   const char *chp,
	   device_unit *size)
{
  int i;
  int nr;
  const char *curr = chp;
  memset(size, 0, sizeof(*size));
  /* parse the numeric list */
  size->nr_cells = device_nr_size_cells(bus);
  nr = 0;
  ASSERT(size->nr_cells > 0);
  while (1) {
    char *next;
    size->cells[nr] = strtoul(curr, &next, 0);
    if (curr == next)
      device_error(current, "Problem parsing <size> %s", chp);
    nr += 1;
    if (next[0] != ',')
      break;
    if (nr == size->nr_cells)
      device_error(current, "Too many values in <size> %s", chp);
    curr = next + 1;
  }
  ASSERT(nr > 0 && nr <= size->nr_cells);
  /* right align the numbers */
  for (i = 1; i <= size->nr_cells; i++) {
    if (i <= nr)
      size->cells[size->nr_cells - i] = size->cells[nr - i];
    else
      size->cells[size->nr_cells - i] = 0;
  }
  return skip_token(chp);
}

void get_cpu (dbgov_cpu * buf)
{
  char buffer[BUFSIZ], *p;

  memset (buf, 0, sizeof (dbgov_cpu));

  int res = try_file_to_buffer (buffer, FILENAME);
  if (res == TRY_FILE_TO_BUFFER_OK_IOSTAT)
    {
      p = skip_token (buffer);
      buf->user = strtoull (p, &p, 0);
      buf->nice = strtoull (p, &p, 0);
      buf->sys = strtoull (p, &p, 0);
      buf->idle = strtoull (p, &p, 0);
      buf->total = buf->user + buf->nice + buf->sys + buf->idle;

      /* 2.6 kernel */
      if (os_version_code >= LINUX_VERSION_CODE (2, 6, 0))
	{
	  buf->iowait = strtoull (p, &p, 0);
	  buf->irq = strtoull (p, &p, 0);
	  buf->softirq = strtoull (p, &p, 0);

	  buf->total += buf->iowait + buf->irq + buf->softirq;
	}

      buf->frequency = 100;
    }
}

static int parse_multi_set(const char *p)
{
	char *t;
	int s, val = 0;

	while (p && *p) {
		t = get_token(p);
		if (t) {
			s = lookup_set_token(t);
			free(t);

			if (s == INVALID_NUMBER) {
				val = s;
				break;
			}

			if (s) val |= 1 << (s - 1);
			else   val = 0;
		}

		p = skip_token(p);
	}

	return val;
}

g_val_t
cpu_user_func ( void )
{
   char *p;
   static g_val_t val;
   static struct timeval stamp={0, 0};
   static JT last_user_jiffies,  user_jiffies, 
             last_total_jiffies, total_jiffies, diff;

   p = update_file(&proc_stat);
   if((proc_stat.last_read.tv_sec != stamp.tv_sec) &&
      (proc_stat.last_read.tv_usec != stamp.tv_usec)) {
     stamp = proc_stat.last_read;

     p = skip_token(p);
     user_jiffies  = strtod( p , (char **)NULL );
     total_jiffies = total_jiffies_func();

     diff = user_jiffies - last_user_jiffies;

     if ( diff )
       val.f = ((double)diff/(double)(total_jiffies - last_total_jiffies)) * 100.0;
     else
       val.f = 0.0;

     last_user_jiffies  = user_jiffies;
     last_total_jiffies = total_jiffies;

   }
   return val;
}

g_val_t
cpu_user_func ( void )
{
   char *p;
   static g_val_t val;
   static int stamp;
   static double last_user_jiffies,  user_jiffies, 
                 last_total_jiffies, total_jiffies, diff;
   
   p = update_file(&proc_stat);
   if(proc_stat.last_read != stamp) {
     stamp = proc_stat.last_read;
     
     p = skip_token(p);
     user_jiffies  = strtod( p , (char **)NULL );
     total_jiffies = total_jiffies_func();
     
     diff = user_jiffies - last_user_jiffies; 
     
     if ( diff )
       val.f = (diff/(total_jiffies - last_total_jiffies))*100;
     else
       val.f = 0.0;
     
     last_user_jiffies  = user_jiffies;
     last_total_jiffies = total_jiffies;
     
   }
   return val;
}

/* read_config_read_data():
   reads data of a given type from a token(s) on a configuration line.

   Returns: character pointer to the next token in the configuration line.
            NULL if none left.
            NULL if an unknown type.
*/
char *read_config_read_data(int type, char *readfrom, void *dataptr, size_t *len) {

  int *intp;
  char **charpp;
  oid  **oidpp;

  if (dataptr == NULL || readfrom == NULL)
    return NULL;
  
  switch(type) {
    case ASN_INTEGER:
      intp = (int *) dataptr;
      *intp = atoi(readfrom);
      readfrom = skip_token(readfrom);
      return readfrom;
      
    case ASN_OCTET_STR:
      charpp = (char **) dataptr;
      return read_config_read_octet_string(readfrom, (u_char **) charpp, len);

    case ASN_OBJECT_ID:
      oidpp = (oid **) dataptr;
      return read_config_read_objid(readfrom, oidpp, len);

    default:
      DEBUGMSGTL(("read_config_read_data","Fail: Unknown type: %d", type));
      return NULL;
  }
  return NULL;
}

static void
attach_process_add_line (AttachProcess *ap, GtkTreeStore *store, gchar *line)
{
	gchar *pid, *user, *start, *command, *tmp;
	// guint i, level;
	GtkTreeIter *iter;

	pid = skip_spaces (line); // skip leading spaces
	user = skip_token_and_spaces (pid); // skip PID
	start = skip_token_and_spaces (user); // skip USER
	tmp = skip_token (start); // skip START (do not skip spaces)

	command = calc_depth_and_get_iter (ap, store, &iter, tmp);

	if (ap->hide_paths)
	{
		command = skip_path (command);
	}

	if (ap->hide_params)
	{
		remove_params(command);
	}

	gtk_tree_store_set (store, iter,
						PID_COLUMN, pid,
						USER_COLUMN, user,
						START_COLUMN, start,
						COMMAND_COLUMN, command,
						-1);
}

static inline char *
skip_multiple_token (const char *p, size_t count)
{
	while(count--)
		p = skip_token (p);

	return (char *)p;
}

static void zap(void)
/* An error, zap the rest of the line. */
{
	token_t *t;

	while ((t= get_token(0))->type != T_EOF && t->symbol != ';')
		skip_token(1);
}