/* a, a-b, or a-b:c */
static int parse_range(char_stream_t cs, int_list_t il) {
  int a = parse_int(cs);
  if (a == -1) return 0;	/* NG */
  int b = a + 1;
  int c = 1;			/* stride */
  int x;
  if (cur_char(cs) == '-') {
    next_char(cs);
    b = parse_int(cs);
    if (b == -1) return 0;
    if (cur_char(cs) == ':') {
      next_char(cs);
      c = parse_int(cs);
      if (c == -1) return 0; /* NG */
    }
  } 
  for (x = a; x < b; x += c) {
    if (!int_list_add(il, x)) {
      parse_error(cs, 
		  "myth_parse_cpu_list: too many numbers in MYTH_CPU_LIST\n");
      return 0;
    }
  }
  return 1;			/* OK */
}
Beispiel #2
0
void sax_parser<_Handler,_Config>::characters()
{
    size_t first = m_pos;
    const char* p0 = m_char;
    for (; has_char(); next())
    {
        if (cur_char() == '<')
            break;

        if (cur_char() == '&')
        {
            // Text span with one or more encoded characters. Parse using cell buffer.
            cell_buffer& buf = get_cell_buffer();
            buf.reset();
            buf.append(p0, m_pos-first);
            characters_with_encoded_char(buf);
            if (buf.empty())
                m_handler.characters(pstring(), false);
            else
                m_handler.characters(pstring(buf.get(), buf.size()), true);
            return;
        }
    }

    if (m_pos > first)
    {
        size_t size = m_pos - first;
        pstring val(m_content + first, size);
        m_handler.characters(val, false);
    }
}
void parser_base::characters_with_encoded_char(cell_buffer& buf)
{
    assert(cur_char() == '&');
    parse_encoded_char(buf);

    size_t first = m_pos;

    while (has_char())
    {
        if (cur_char() == '&')
        {
            if (m_pos > first)
                buf.append(m_content+first, m_pos-first);

            parse_encoded_char(buf);
            first = m_pos;
        }

        if (cur_char() == '<')
            break;

        if (cur_char() != '&')
            next();
    }

    if (m_pos > first)
        buf.append(m_content+first, m_pos-first);
}
Beispiel #4
0
static void parse_ascii_number(struct context_t *ctx, struct lexem_t *lexem)
{
    locate_lexem(lexem, ctx);
    /* skip ' */
    advance(ctx, 1);
    /* we expect n<=4 character and then '  */
    int len = 0;
    uint32_t value = 0;
    while(!eof(ctx))
    {
        if(cur_char(ctx) != '\'')
        {
            value = value << 8 | cur_char(ctx);
            len++;
            advance(ctx, 1);
        }
        else
            break;
    }
    if(eof(ctx) || cur_char(ctx) != '\'')
        parse_error(ctx, "Unterminated ascii number literal\n");
    if(len == 0 || len > 4)
        parse_error(ctx, "Invalid ascii number literal length: only 1 to 4 characters allowed\n");
    /* skip ' */
    advance(ctx, 1);
    lexem->type = LEX_NUMBER;
    lexem->num = value;
}
Beispiel #5
0
int Scanner::read_num() {
  clear_token();
  bool hex_dec_mode = false;
  if (cur_char() == '0' &&
      next_char() == 'x') {
    push_char(cur_char());
    go_ahead();
    push_char(cur_char());
    go_ahead();
    hex_dec_mode = true;
  }
  while (true) {
    char c = cur_char();
    if (hex_dec_mode) {
      if (!is_hex_dec(c)) {
	break;
      }
    } else {
      if (!is_dec(c)) {
	break;
      }
    }
    push_char(cur_char());
    go_ahead();
  }
  return s_info->num_token;
}
Beispiel #6
0
int Scanner::read_sym() {
  clear_token();
  while (is_symbody(cur_char())) {
    push_char(cur_char());
    go_ahead();
  }
  return s_info->sym_token;
}
Beispiel #7
0
void Scanner::go_ahead() {
  if (cur_char()) {
    cur_ ++;
  }
  char c = cur_char();
  if (c == '\n') {
    ln_ ++;
  }
}
Beispiel #8
0
void parser_base::literal(const char*& p, size_t& len, char quote)
{
    assert(cur_char() == quote);
    next();
    skip_to(p, len, quote);

    if (cur_char() != quote)
        throw css::parse_error("literal: end quote has never been reached.");
}
Beispiel #9
0
void json_parser<_Handler>::number_with_exp(double base)
{
    assert(cur_char() == 'e' || cur_char() == 'E');
    next();
    if (!has_char())
        throw json::parse_error("number_with_exp: illegal exponent value.", offset());

    long exp = parse_long_or_throw();
    base *= std::pow(10.0, exp);
    m_handler.number(base);
    skip_blanks();
}
void parser_base::blank()
{
    char c = cur_char();
    while (is_blank(c))
    {
        next();
        if (!has_char())
            return;

        c = cur_char();
    }
}
Beispiel #11
0
static void parse_identifier(struct context_t *ctx, struct lexem_t *lexem)
{
    locate_lexem(lexem, ctx);
    /* remember position */
    char *old = ctx->ptr;
    while(!eof(ctx) && (isalnum(cur_char(ctx)) || cur_char(ctx) == '_'))
        advance(ctx, 1);
    lexem->type = LEX_IDENTIFIER;
    int len = ctx->ptr - old;
    lexem->str = xmalloc(len + 1);
    lexem->str[len] = 0;
    memcpy(lexem->str, old, len);
}
Beispiel #12
0
static void __parse_string(struct context_t *ctx, void *user, void (*emit_fn)(void *user, char c))
{
    while(!eof(ctx))
    {
        if(cur_char(ctx) == '"')
            break;
        else if(cur_char(ctx) == '\\')
        {
            advance(ctx, 1);
            if(eof(ctx))
                parse_error(ctx, "Unfinished string\n");
            if(cur_char(ctx) == '\\') emit_fn(user, '\\');
            else if(cur_char(ctx) == '\'') emit_fn(user, '\'');
            else if(cur_char(ctx) == '\"') emit_fn(user, '\"');
            else parse_error(ctx, "Unknown escape sequence \\%c\n", cur_char(ctx));
            advance(ctx, 1);
        }
        else
        {
            emit_fn(user, cur_char(ctx));
            advance(ctx, 1);
        }
    }
    if(eof(ctx) || cur_char(ctx) != '"')
        parse_error(ctx, "Unfinished string\n");
    advance(ctx, 1);
}
/* get a non-negative number or return -1 */
static int parse_int(char_stream_t cs) {
  int x = 0;
  int n_digits = 0;
  while (isdigit(cur_char(cs))) {
    n_digits++;
    x = x * 10 + (cur_char(cs) - '0');
    next_char(cs);
  }
  if (n_digits == 0) { 
    parse_error(cs, "expected a digit"); 
    return -1; 
  }
  return x;
}
static int parse_range_list(char_stream_t cs, int_list_t il) {
  if (!parse_range(cs, il)) return 0;
  set_ok_pos(cs);
  while (cur_char(cs) == ',') {
    next_char(cs);
    if (!parse_range(cs, il)) return 0;
    set_ok_pos(cs);
  }
  if (cur_char(cs) != '\0') { 
    next_char(cs);
    parse_error(cs, "junk at the end of CPU list"); 
    return 0;
  }
  return 1;			/* OK */
}
Beispiel #15
0
int Scanner::GetToken(int *sub) {
  *sub = 0;
  skip_non_token();
  //
  char c = cur_char();
  if (is_dec(c)) {
    return read_num();
  }
  //
  struct OperatorTableEntry *op = lookup_op();
  if (op) {
    int r;
    r = read_op(op);
    *sub = op->sub_op;
    return r;
  }
  //
  if (c == '\"') {
    return read_str();
  }
  if (is_symhead(c)) {
    return read_sym();
  }
  return -1;
}
bool parser_base::value(pstring& str, bool decode)
{
    char c = cur_char();
    if (c != '"')
        throw malformed_xml_error("value must be quoted");

    c = next_char_checked();
    size_t first = m_pos;
    const char* p0 = m_char;

    for (; c != '"'; c = next_char_checked())
    {
        if (decode && c == '&')
        {
            // This value contains one or more encoded characters.
            cell_buffer& buf = get_cell_buffer();
            buf.reset();
            buf.append(p0, m_pos-first);
            value_with_encoded_char(buf, str);
            return true;
        }
    }

    str = pstring(p0, m_pos-first);

    // Skip the closing quote.
    next();

    return false;
}
Beispiel #17
0
bool Scanner::is_comment_start() {
  if (cur_char() == '/' &&
      (next_char() == '*' || next_char() == '/')) {
    return true;
  }
  return false;
}
void parser_base::comment()
{
    // Parse until we reach '-->'.
    size_t len = remains();
    assert(len > 3);
    char c = cur_char();
    size_t i = 0;
    bool hyphen = false;
    for (; i < len; ++i, c = next_char())
    {
        if (c == '-')
        {
            if (!hyphen)
                // first hyphen.
                hyphen = true;
            else
                // second hyphen.
                break;
        }
        else
            hyphen = false;
    }

    if (len - i < 2 || next_char() != '>')
        throw malformed_xml_error("'--' should not occur in comment other than in the closing tag.");

    next();
}
Beispiel #19
0
uint8_t parser_base::parse_uint8()
{
    // 0 - 255
    int val = 0;
    size_t len = 0;
    for (; has_char() && len <= 3; next())
    {
        char c = cur_char();
        if (!is_numeric(c))
            break;

        ++len;
        val *= 10;
        val += c - '0';
    }

    if (!len)
        throw css::parse_error("parse_uint8: no digit encountered.");

    int maxval = std::numeric_limits<uint8_t>::max();
    if (val > maxval)
        val = maxval;

    return static_cast<uint8_t>(val);
}
Beispiel #20
0
void sax_parser<_Handler,_Config>::attribute()
{
    sax::parser_attribute attr;
    pstring attr_ns_name, attr_name, attr_value;
    attribute_name(attr.ns, attr.name);

#if ORCUS_DEBUG_SAX_PARSER
    std::ostringstream os;
    os << "sax_parser::attribute: ns='" << attr.ns << "', name='" << attr.name << "'";
#endif

    char c = cur_char();
    if (c != '=')
    {
        std::ostringstream os;
        os << "Attribute must begin with 'name=..'. (ns='" << attr.ns << "', name='" << attr.name << "')";
        throw sax::malformed_xml_error(os.str());
    }

    next_check();
    attr.transient = value(attr.value, true);
    if (attr.transient)
        // Value is stored in a temporary buffer. Push a new buffer.
        inc_buffer_pos();

#if ORCUS_DEBUG_SAX_PARSER
    os << " value='" << attr.value << "'" << endl;
    cout << os.str();
#endif

    m_handler.attribute(attr);
}
Beispiel #21
0
void sax_parser<_Handler,_Config>::cdata()
{
    size_t len = remains();
    assert(len > 3);

    // Parse until we reach ']]>'.
    const char* p0 = m_char;
    size_t i = 0, match = 0;
    for (char c = cur_char(); i < len; ++i, c = next_char())
    {
        if (c == ']')
        {
            // Be aware that we may encounter a series of more than two ']'
            // characters, in which case we'll only count the last two.

            if (match == 0)
                // First ']'
                ++match;
            else if (match == 1)
                // Second ']'
                ++match;
        }
        else if (c == '>' && match == 2)
        {
            // Found ']]>'.
            size_t cdata_len = i - 2;
            m_handler.characters(pstring(p0, cdata_len), false);
            next();
            return;
        }
        else
            match = 0;
    }
    throw sax::malformed_xml_error("malformed CDATA section.");
}
Beispiel #22
0
void json_parser<_Handler>::root_value()
{
    char c = cur_char();

    switch (c)
    {
        case '[':
            array();
        break;
        case '{':
            object();
        break;
        default:
            json::parse_error::throw_with(
                "root_value: either '[' or '{' was expected, but '", cur_char(), "' was found.", offset());
    }
}
Beispiel #23
0
void json_parser<_Handler>::number()
{
    assert(is_numeric(cur_char()) || cur_char() == '-');

    double val = parse_double_or_throw();
    switch (cur_char())
    {
        case 'e':
        case 'E':
            number_with_exp(val);
            return;
        default:
            ;
    }
    m_handler.number(val);
    skip_blanks();
}
Beispiel #24
0
void parser_base::comment()
{
    assert(cur_char() == '*');

    // Parse until we reach either EOF or '*/'.
    bool has_star = false;
    for (next(); has_char(); next())
    {
        char c = cur_char();
        if (has_star && c == '/')
        {
            next();
            return;
        }
        has_star = (c == '*');
    }

    // EOF reached.
}
Beispiel #25
0
void sax_parser<_Handler,_Config>::element_open(const char* begin_pos)
{
    assert(is_alpha(cur_char()));

    sax::parser_element elem;
    element_name(elem, begin_pos);

    while (true)
    {
        blank();
        char c = cur_char();
        if (c == '/')
        {
            // Self-closing element: <element/>
            if (next_char() != '>')
                throw sax::malformed_xml_error("expected '/>' to self-close the element.");
            next();
            elem.end_pos = m_char;
            m_handler.start_element(elem);
            reset_buffer_pos();
            m_handler.end_element(elem);
#if ORCUS_DEBUG_SAX_PARSER
            cout << "element_open: ns='" << elem.ns << "', name='" << elem.name << "' (self-closing)" << endl;
#endif
            return;
        }
        else if (c == '>')
        {
            // End of opening element: <element>
            next();
            elem.end_pos = m_char;
            nest_up();
            m_handler.start_element(elem);
            reset_buffer_pos();
#if ORCUS_DEBUG_SAX_PARSER
            cout << "element_open: ns='" << elem.ns << "', name='" << elem.name << "'" << endl;
#endif
            return;
        }
        else
            attribute();
    }
}
Beispiel #26
0
void parser_base::skip_to(const char*&p, size_t& len, char c)
{
    p = mp_char;
    len = 0;
    for (; has_char(); next(), ++len)
    {
        if (cur_char() == c)
            return;
    }
}
void parser_base::attribute_name(pstring& attr_ns, pstring& attr_name)
{
    name(attr_name);
    if (cur_char() == ':')
    {
        // Attribute name is namespaced.
        attr_ns = attr_name;
        next_check();
        name(attr_name);
    }
}
Beispiel #28
0
void sax_parser<_Handler,_Config>::element_close(const char* begin_pos)
{
    assert(cur_char() == '/');
    nest_down();
    next_check();
    sax::parser_element elem;
    element_name(elem, begin_pos);

    if (cur_char() != '>')
        throw sax::malformed_xml_error("expected '>' to close the element.");
    next();
    elem.end_pos = m_char;

    m_handler.end_element(elem);
#if ORCUS_DEBUG_SAX_PARSER
    cout << "element_close: ns='" << elem.ns << "', name='" << elem.name << "'" << endl;
#endif
    if (!m_nest_level)
        m_root_elem_open = false;
}
Beispiel #29
0
void Scanner::skip_comment() {
  if (!is_comment_start()) {
    return ;
  }
  char c = next_char();
  if (c == '/') {
    while (cur_char() != '\n' && cur_char() != 0) {
      go_ahead();
    }
    go_ahead();
  } else {
    go_ahead();
    go_ahead();
    while (cur_char() != '*' || next_char() != '/') {
      go_ahead();
    }
    go_ahead();
    go_ahead();
  }
}
Beispiel #30
0
void Scanner::skip_non_token() {
  while (1) {
    if ((is_space(cur_char()))) {
      go_ahead();
    } else if (is_comment_start()) {
      skip_comment();
    } else {
      return ;
    }
  }
}