C++ skip_whitespace函数代码示例

static gboolean
parse_rgba (ClutterColor *color,
            gchar        *str,
            gboolean      has_alpha)
{
  skip_whitespace (&str);

  if (*str != '(')
    return FALSE;

  str += 1;

  /* red */
  parse_rgb_value (str, &color->red, &str);
  skip_whitespace (&str);
  if (*str != ',')
    return FALSE;

  str += 1;

  /* green */
  parse_rgb_value (str, &color->green, &str);
  skip_whitespace (&str);
  if (*str != ',')
    return FALSE;

  str += 1;

  /* blue */
  parse_rgb_value (str, &color->blue, &str);
  skip_whitespace (&str);

  /* alpha (optional); since the alpha channel value can only
   * be between 0 and 1 we don't use the parse_rgb_value()
   * function
   */
  if (has_alpha)
    {
      gdouble number;

      if (*str != ',')
        return FALSE;

      str += 1;

      skip_whitespace (&str);
      number = g_ascii_strtod (str, &str);

      color->alpha = CLAMP (number * 255.0, 0, 255);
    }
  else
    color->alpha = 255;

  skip_whitespace (&str);
  if (*str != ')')
    return FALSE;

  return TRUE;
}

//-------------------------------------------------------------------
static void process_title(const char *title)
{
    register const char *ptr = title;
    register int i=0;

    ptr = skip_whitespace(ptr);
    while (i<(sizeof(script_title)-1) && ptr[i] && ptr[i]!='\r' && ptr[i]!='\n')
    {
        script_title[i]=ptr[i];
        ++i;
    }
    script_title[i]=0;
}

/**
 * Execute the BASIC command in 's'.
 */
void execute(char *s) {
  unsigned char command;
  char * args;
  reset_interrupted();
  s = skip_whitespace(s);
  args = find_args(s);
  command = find_keyword(s);
  if (command != CMD_UNKNOWN) {
    command_functions[command](args);
  } else {
    lcd_puts("Unknown command!\n");
  }
}

//-------------------------------------------------------------------
// Process one entry "@param VAR TITLE" to check if it exists
//      param = ptr right after descriptor (should point to var)
// RETURN VALUE: 0 if not found, 1..26 = id of var
// Used to ensure that a param loaded from an old saved paramset does
// not overwrite defaults from script
//-------------------------------------------------------------------
static int check_param(const char *param)
{
    register const char *ptr = param;
    register int n=0, l;

    ptr = skip_whitespace(ptr);
    if (ptr[0] && (ptr[0]>='a' && ptr[0]<='a'+SCRIPT_NUM_PARAMS) && (ptr[1]==' ' || ptr[1]=='\t'))
    {
        n = ptr[0]-'a';                                 // VAR
        ptr = skip_whitespace(ptr+2);                   // skip to TITLE
        l = skip_toeol(ptr) - ptr;                      // get length of TITLE
        if (l > MAX_PARAM_NAME_LEN)
            l = MAX_PARAM_NAME_LEN;
        if (l != strlen(script_params[n]))              // Check length matches existing TITLE length
            n = 0;
        else if (strncmp(ptr,script_params[n],l) != 0)  // Check that TITLE matches existing TITLE
            n = 0;
        else
            n++;
    }
    return n; // n=1 if '@param a' was processed, n=2 for 'b' ... n=26 for 'z'. n=0 if failed.
}

//-------------------------------------------------------------------
// Process one entry "@range VAR MIN MAX"
//      param = ptr right after descriptor (should point to var)
//-------------------------------------------------------------------
static void process_range(const char *param)
{
    register const char *ptr = param;
    register int n;

    ptr = skip_whitespace(ptr);
    if (ptr[0] && (ptr[0]>='a' && ptr[0]<='a'+SCRIPT_NUM_PARAMS) && (ptr[1]==' ' || ptr[1]=='\t'))
    {
        n = ptr[0]-'a';
        ptr = skip_whitespace(ptr+2);
        int min = strtol(ptr,NULL,0);
        ptr = skip_whitespace(skip_token(ptr));
        int max = strtol(ptr,NULL,0);
        script_range_values[n] = MENU_MINMAX(min,max);
        if ((min == 0) && (max == 1))
            script_range_types[n] = MENUITEM_BOOL;
        else if ((min >= 0) && (max >= 0)) 
            script_range_types[n] = MENUITEM_INT|MENUITEM_F_MINMAX|MENUITEM_F_UNSIGNED;
        else
            script_range_types[n] = MENUITEM_INT|MENUITEM_F_MINMAX;
    } // ??? else produce error message
}

static void read_map(JSONSource* self, rich_Sink* to) {
  Input* in = self->in;
  call(to, sink, RICH_MAP, NULL);
  bool first = true;
  for (;;) {
    int ch = skip_whitespace(in);
    if (ch == '}') break;
    if (first) {
      first = false;
    } else {
      if (ch != ',') RAISE(MALFORMED);
      ch = skip_whitespace(in);
    }
    if (ch != '"') RAISE(MALFORMED);
    read_string(self);
    call(to, sink, RICH_KEY, &self->sval);
    ch = skip_whitespace(in);
    if (ch != ':') RAISE(MALFORMED);
    read_value(self, to);
  }
  call(to, sink, RICH_ENDMAP, NULL);
}

	void streamtools_object::test<1>()
	{
		char arr[255];
		std::string str;
		std::string expected_result;
		std::string actual_result;
		std::istringstream is;

		is.str(str = "");
		ensure("skip_whitespace: empty string", (false == skip_whitespace(is)));

		is.clear();
		is.str(str = " SecondLife is a 3D World");
		skip_whitespace(is);
		is.get(arr, 255, '\0');
		expected_result = "SecondLife is a 3D World";
		ensure_equals("skip_whitespace: space", arr, expected_result);

		is.clear();
		is.str(str = "\t          \tSecondLife is a 3D World");
		skip_whitespace(is);
		is.get(arr, 255, '\0');
		expected_result = "SecondLife is a 3D World";
		ensure_equals("skip_whitespace: space and tabs", arr, expected_result);

		is.clear();
		is.str(str = "\t          \tSecondLife is a 3D World       ");
		skip_whitespace(is);
		is.get(arr, 255, '\0');
		expected_result = "SecondLife is a 3D World       ";
		ensure_equals("skip_whitespace: space at end", arr, expected_result);

		is.clear();
		is.str(str = "\t \r\nSecondLife is a 3D World");
		skip_whitespace(is);
		is.get(arr, 255, '\0');
		expected_result = "\r\nSecondLife is a 3D World";
		ensure_equals("skip_whitespace: space at end", arr, expected_result);
	}

bool line_has_word (char *ptr, const char *word, int word_len) {

	ptr = skip_whitespace(ptr);
	//make sure the file doesn't end before the end of the word + required whitespace,
	// then see if the word's found on the line
	if (strnlen (ptr, word_len) == word_len && !strncasecmp (ptr, word, word_len)) {
		//then make sure it isn't just the start of another word
		ptr += word_len;
		//if (isspace (*ptr) || is_end_of_code_line (ptr))
			return true;
	}
	return false;
}

/* Each line in the file consists of up to four whitespace separated fields:
 *  id [description] [x_name] [y_name]
 */
static bool parse_fa_id_line(const char **line, bool seen[])
{
    int id;
    bool ok =
        parse_int(line, &id)  &&
        TEST_OK_(0 <= id  &&  (uint32_t) id < id_list_length,
            "FA id %d out of range", id)  &&
        TEST_OK_(!seen[id], "FA id %u repeated", id);
    if (ok)
    {
        seen[id] = true;
        struct fa_id_list *entry = &fa_id_list[id];
        IGNORE(
            skip_whitespace(line)  &&
            maybe_parse_word(line, &entry->description)  &&
            skip_whitespace(line)  &&
            maybe_parse_word(line, &entry->x_name)  &&
            skip_whitespace(line)  &&
            maybe_parse_word(line, &entry->y_name));
    }
    return ok;
}

void process_memstate ( void ) 
{
   char *p;

   if ( ! slurpfile( "/proc/meminfo" ) ){
      return;
   }

   p = strstr( buffer, "MemFree:" );
   p = skip_token(p);
   p = skip_whitespace(p);

   now.mem_free  = strtod( p, (char **)NULL);

   p = strstr( buffer, "MemShared:" );
   p = skip_token(p);
   p = skip_whitespace(p);
   
   now.mem_shared = strtod( p, (char **)NULL);

   p = strstr( buffer, "Buffers:" );
   p = skip_token(p);
   p = skip_whitespace(p);

   now.mem_buffers = strtod( p, (char **)NULL);

   p = strstr( buffer, "Cached:" );
   p = skip_token(p);
   p = skip_whitespace(p);

   now.mem_cached = strtod( p, (char **)NULL);

   p = strstr( buffer, "SwapFree:" );
   p = skip_token(p);
   p = skip_whitespace(p);

   now.swap_free = strtod( p, (char **)NULL );

}

/**
 * Parses first line of request
 */
uint8_t* ICACHE_FLASH_ATTR http_request_parse_method_line( http_request_object_type* request, uint8_t* data )
{
    uint8_t* w, v, *end, ev;
    char hpost[ 5 ] = "POST", hget[ 4 ] = "GET";

    ev = *( end = get_line_ending( data ));
    ( *end ) = '\0';
    request->method = HTTP_METHOD_NONE;
    data = skip_whitespace( data );
    v = *( w = skip_to_whitespace( data ) );
    ( *w ) = '\0';
    if( strcmp( hget, ( char* ) data ) == 0 ) request->method = HTTP_METHOD_GET;
    if( strcmp( hpost, ( char* ) data ) == 0 ) request->method = HTTP_METHOD_POST;
    ( *w ) = v;

    data = skip_whitespace( w );
    v = *( w = skip_to_whitespace( data ) );
    ( *w ) = '\0';
    url_parse_path( request->location, data );
    ( *w ) = v;
    ( *end ) = ev;
    return skip_line_ending( end );
}

// Parses a pair, assuming the opening left parenthesis has already been read.
static struct ParseResult parse_pair(const char *text) {
	struct ParseResult result;
	result.err_type = -1;
	const char *s = text;
	s += skip_whitespace(s);

	if (*s == ')') {
		s++;
		result.expr = new_null();
		goto chars_read;
	}

	struct ParseResult first = parse(s);
	s += first.chars_read;
	if (first.err_type != -1) {
		result.err_type = first.err_type;
		goto chars_read;
	}

	if (*s == '.') {
		s++;
		struct ParseResult second = parse(s);
		s += second.chars_read;
		if (second.err_type != -1) {
			result.err_type = second.err_type;
			release_expression(first.expr);
			goto chars_read;
		}
		if (*s != ')') {
			result.err_type = *s ? ERR_EXPECTED_RPAREN : ERR_UNEXPECTED_EOI;
			release_expression(first.expr);
			goto chars_read;
		}
		s++;
		result.expr = new_pair(first.expr, second.expr);
	} else {
		struct ParseResult rest = parse_pair(s);
		s += rest.chars_read;
		if (rest.err_type != -1) {
			result.err_type = rest.err_type;
			release_expression(first.expr);
			goto chars_read;
		}
		result.expr = new_pair(first.expr, rest.expr);
	}

chars_read:
	result.chars_read = (size_t)(s - text);
	return result;
}

bool hfp_context_close_container(struct hfp_context *context)
{
	skip_whitespace(context);

	/* The list shall be followed by a right parenthesis (")" V250 5.7.3.1*/
	if (context->data[context->offset] != ')')
		return false;

	context->offset++;

	next_field(context);

	return true;
}

// Extract name up to maxlen, find or create sc_param based on name
// Return pointer past name.
// Sets *sp to sc_param entry, or 0 if not found
const char* get_name(const char *p, int maxlen, sc_param **sp, int create)
{
    char str[MAX_PARAM_NAME_LEN+1];
    *sp = 0;
    p = skip_whitespace(p);
    if (p[0] && isalpha(p[0]))
    {
        p = get_token(p, str, maxlen);
        *sp = find_param(str);
        if ((*sp == 0) && create)
            *sp = new_param(str);
    }
    return p;
}

static int cmd_layerdef(const char *p)
{
	int fn, n, ret = ERR_INVALID_ARGS;
	unsigned char fn_combo = 0;

	p = skip_whitespace(p);
	for (p = skip_whitespace(p); *p; p = skip_token(p)) {
		fn = parse_function_n(p);
		if (fn == INVALID_NUMBER) break;
		fn_combo |= (unsigned char)(1 << (fn - 1));
	}
	if (!fn_combo) goto ret;

	/* layer id */
	n = parse_int(p, 1, 255);
	if (n == INVALID_NUMBER) goto ret;

	pair_list_push(LAYERDEF_LIST, fn_combo, (unsigned char)n);
	ret = 0;

ret:
	return ret;
}