From e86d06400234dce2ee505eb58bb4a2cfeddc4303 Mon Sep 17 00:00:00 2001 From: Matthias Schiffer Date: Thu, 9 Apr 2015 05:18:47 +0200 Subject: lex: use std::string * instead of char * --- src/lex.cpp | 22 ++++++----------- src/lex.hpp | 4 +-- src/parser.cpp | 70 ++++++++++++++++++++++++++-------------------------- src/parser.hpp | 2 +- src/parser_state.cpp | 18 +++++++------- src/parser_state.hpp | 26 +++++++++---------- src/symbol.hpp | 6 ++--- 7 files changed, 70 insertions(+), 78 deletions(-) (limited to 'src') diff --git a/src/lex.cpp b/src/lex.cpp index 38d138c..63549c9 100644 --- a/src/lex.cpp +++ b/src/lex.cpp @@ -234,10 +234,10 @@ int lex_t::lex_keyword(parser_value_t *value) { break; } - char *token = get_token(); - const keyword_t key = { .keyword = token, .token = 0 }; + std::string *token = get_token(); + const keyword_t key = { .keyword = token->c_str(), .token = 0 }; const keyword_t *ret = static_cast(bsearch(&key, keywords, array_size(keywords), sizeof(keyword_t), compare_keywords)); - free(token); + delete token; if (!ret) return syntax_error(value); @@ -262,15 +262,13 @@ int lex_t::lex_block(parser_value_t *value) { bool str = false; bool pp = false; - size_t pos = 0; - size_t len = 1024; - char *buf = static_cast(std::malloc(len)); + std::string *buf = new std::string; char prev = 0; while (true) { if (!next(true)) { - std::free(buf); + delete buf; return unterminated_block(value); } @@ -316,17 +314,11 @@ int lex_t::lex_block(parser_value_t *value) { } } - if (pos >= len) { - len *= 2; - buf = static_cast(std::realloc(buf, len)); - } - - buf[pos++] = cur; + *buf += cur; prev = cur; } - value->str = strndup(buf, pos); - std::free(buf); + value->str = buf; next(true); consume(true); diff --git a/src/lex.hpp b/src/lex.hpp index 8f7e038..7405279 100644 --- a/src/lex.hpp +++ b/src/lex.hpp @@ -78,8 +78,8 @@ private: return buffer[start + tok_len]; } - char * get_token() { - return strndup(buffer+start, tok_len); + std::string * get_token() { + return new std::string(buffer+start, tok_len); } diff --git a/src/parser.cpp b/src/parser.cpp index 0333243..ce408eb 100644 --- a/src/parser.cpp +++ b/src/parser.cpp @@ -66,8 +66,8 @@ int parser_push(parser_t *parser, int token, const parser_value_t *value, parser switch (token) { case TOK_SYMBOL_LC: parser->state = STATE_RULE_BAR; - state->new_rule(value->str); - free(value->str); + state->new_rule(*value->str); + delete value->str; return 1; case TOK_TYPE: @@ -111,13 +111,13 @@ int parser_push(parser_t *parser, int token, const parser_value_t *value, parser case STATE_RULE: switch (token) { case TOK_SYMBOL_LC: - state->add_rule_nonterminal(value->str); - free(value->str); + state->add_rule_nonterminal(*value->str); + delete value->str; return 1; case TOK_SYMBOL_UC: - state->add_rule_terminal(value->str); - free(value->str); + state->add_rule_terminal(*value->str); + delete value->str; return 1; case TOK_CHAR: @@ -125,8 +125,8 @@ int parser_push(parser_t *parser, int token, const parser_value_t *value, parser return 1; case TOK_BLOCK: - state->add_rule(value->str); - free(value->str); + state->add_rule(*value->str); + delete value->str; parser->state = STATE_INIT; return 1; @@ -147,8 +147,8 @@ int parser_push(parser_t *parser, int token, const parser_value_t *value, parser case TOK_SYMBOL: case TOK_SYMBOL_UC: case TOK_SYMBOL_LC: - state->add_rule_var(value->str); - free(value->str); + state->add_rule_var(*value->str); + delete value->str; parser->state = STATE_RULE_VAR; return 1; } @@ -166,13 +166,13 @@ int parser_push(parser_t *parser, int token, const parser_value_t *value, parser case STATE_RULE_VAR_POST: switch (token) { case TOK_SYMBOL_LC: - state->add_rule_nonterminal(value->str); - free(value->str); + state->add_rule_nonterminal(*value->str); + delete value->str; return 1; case TOK_SYMBOL_UC: - state->add_rule_terminal(value->str); - free(value->str); + state->add_rule_terminal(*value->str); + delete value->str; return 1; case TOK_CHAR: @@ -180,8 +180,8 @@ int parser_push(parser_t *parser, int token, const parser_value_t *value, parser return 1; case TOK_BLOCK: - state->add_rule(value->str); - free(value->str); + state->add_rule(*value->str); + delete value->str; parser->state = STATE_INIT; return 1; @@ -196,14 +196,14 @@ int parser_push(parser_t *parser, int token, const parser_value_t *value, parser case STATE_TYPE: switch (token) { case TOK_SYMBOL_LC: - state->add_type_nonterminal(value->str); - free(value->str); + state->add_type_nonterminal(*value->str); + delete value->str; parser->state = STATE_TYPE_NONTERM; return 1; case TOK_SYMBOL_UC: - state->add_type_terminal(value->str); - free(value->str); + state->add_type_terminal(*value->str); + delete value->str; parser->state = STATE_TYPE_TERM; return 1; } @@ -212,8 +212,8 @@ int parser_push(parser_t *parser, int token, const parser_value_t *value, parser case STATE_TYPE_NONTERM: if (token == TOK_BLOCK) { - state->set_type_nonterminal(value->str); - free(value->str); + state->set_type_nonterminal(*value->str); + delete value->str; parser->state = STATE_INIT; return 1; } @@ -222,8 +222,8 @@ int parser_push(parser_t *parser, int token, const parser_value_t *value, parser case STATE_TYPE_TERM: if (token == TOK_BLOCK) { - state->set_type_terminal(value->str); - free(value->str); + state->set_type_terminal(*value->str); + delete value->str; parser->state = STATE_TYPE_TERM_BLOCK; return 1; } @@ -235,8 +235,8 @@ int parser_push(parser_t *parser, int token, const parser_value_t *value, parser case TOK_SYMBOL: case TOK_SYMBOL_UC: case TOK_SYMBOL_LC: - state->set_type_terminal_name(value->str); - free(value->str); + state->set_type_terminal_name(*value->str); + delete value->str; parser->state = STATE_INIT; return 1; } @@ -244,8 +244,8 @@ int parser_push(parser_t *parser, int token, const parser_value_t *value, parser case STATE_HEADER: if (token == TOK_BLOCK) { - state->set_header_block(value->str); - free(value->str); + state->set_header_block(*value->str); + delete value->str; parser->state = STATE_INIT; return 1; } @@ -254,8 +254,8 @@ int parser_push(parser_t *parser, int token, const parser_value_t *value, parser case STATE_SOURCE: if (token == TOK_BLOCK) { - state->set_source_block(value->str); - free(value->str); + state->set_source_block(*value->str); + delete value->str; parser->state = STATE_INIT; return 1; } @@ -264,8 +264,8 @@ int parser_push(parser_t *parser, int token, const parser_value_t *value, parser case STATE_EXTRA_ARG: if (token == TOK_BLOCK) { - state->add_extra_arg(value->str); - free(value->str); + state->add_extra_arg(*value->str); + delete value->str; parser->state = STATE_EXTRA_ARG_NAME; return 1; } @@ -276,8 +276,8 @@ int parser_push(parser_t *parser, int token, const parser_value_t *value, parser case TOK_SYMBOL: case TOK_SYMBOL_UC: case TOK_SYMBOL_LC: - state->set_extra_arg_name(value->str); - free(value->str); + state->set_extra_arg_name(*value->str); + delete value->str; parser->state = STATE_INIT; return 1; } @@ -289,7 +289,7 @@ int parser_push(parser_t *parser, int token, const parser_value_t *value, parser case TOK_SYMBOL_LC: case TOK_CHAR: case TOK_BLOCK: - free(value->str);; + delete value->str;; } return -1; diff --git a/src/parser.hpp b/src/parser.hpp index c5dd139..cc139fa 100644 --- a/src/parser.hpp +++ b/src/parser.hpp @@ -46,7 +46,7 @@ enum parser_token_t { }; typedef struct parser_value { - char *str; + std::string *str; uint64_t number; const char *error; } parser_value_t; diff --git a/src/parser_state.cpp b/src/parser_state.cpp index f0e9bdd..7ecffd9 100644 --- a/src/parser_state.cpp +++ b/src/parser_state.cpp @@ -29,7 +29,7 @@ namespace solar { -void parser_state_t::new_rule(const char *nonterm) { +void parser_state_t::new_rule(const std::string &nonterm) { if (grammar.rules.empty()) { // start rule add_rule_nonterminal(nonterm); @@ -40,12 +40,12 @@ void parser_state_t::new_rule(const char *nonterm) { current_vars = std::vector(); } -void parser_state_t::add_rule_nonterminal(const char *nonterm) { +void parser_state_t::add_rule_nonterminal(const std::string &nonterm) { current.get_rhs().emplace_back(symbol_t::make_nonterm(nonterm)); current_vars.emplace_back(); } -void parser_state_t::add_rule_terminal(const char *term) { +void parser_state_t::add_rule_terminal(const std::string &term) { current.get_rhs().emplace_back(symbol_t::make_term(term)); current_vars.emplace_back(); } @@ -59,27 +59,27 @@ void parser_state_t::add_rule(const std::string &action) { grammar.rules.emplace_back(rule_t{std::move(current), std::move(current_vars), action}); } -void parser_state_t::add_rule_var(const char *var) { +void parser_state_t::add_rule_var(const std::string &var) { current_vars.back() = var; } -void parser_state_t::add_type_nonterminal(const char *nonterm) { +void parser_state_t::add_type_nonterminal(const std::string &nonterm) { current_var = nonterm; } -void parser_state_t::add_type_terminal(const char *term) { +void parser_state_t::add_type_terminal(const std::string &term) { current_var = term; } -void parser_state_t::set_type_nonterminal(const char *type) { +void parser_state_t::set_type_nonterminal(const std::string &type) { grammar.nonterm_types.insert(std::make_pair(current_var, type)); } -void parser_state_t::set_type_terminal(const char *type) { +void parser_state_t::set_type_terminal(const std::string &type) { current_type = type; } -void parser_state_t::set_type_terminal_name(const char *name) { +void parser_state_t::set_type_terminal_name(const std::string &name) { grammar.term_types.insert(std::make_pair(symbol_t::make_term(current_var.c_str()), std::make_pair(current_type, name))); } diff --git a/src/parser_state.hpp b/src/parser_state.hpp index 4fd057d..c1bbdda 100644 --- a/src/parser_state.hpp +++ b/src/parser_state.hpp @@ -49,35 +49,35 @@ public: return grammar; } - void set_header_block(const char *value) { + void set_header_block(const std::string &value) { grammar.header_block = value; } - void set_source_block(const char *value) { + void set_source_block(const std::string &value) { grammar.source_block = value; } - void add_extra_arg(const char *type) { + void add_extra_arg(const std::string &type) { current_extra_arg = type; } - void set_extra_arg_name(const char *name) { + void set_extra_arg_name(const std::string &name) { grammar.extra_args.emplace_back(current_extra_arg, name); } - void new_rule(const char *nonterm); - void add_rule_nonterminal(const char *nonterm); - void add_rule_terminal(const char *term); + void new_rule(const std::string &nonterm); + void add_rule_nonterminal(const std::string &nonterm); + void add_rule_terminal(const std::string &term); void add_rule_terminal(unsigned char term); void add_rule(const std::string &action = ""); - void add_rule_var(const char *var); + void add_rule_var(const std::string &var); - void add_type_nonterminal(const char *nonterm); - void add_type_terminal(const char *term); - void set_type_nonterminal(const char *type); - void set_type_terminal(const char *type); - void set_type_terminal_name(const char *name); + void add_type_nonterminal(const std::string &nonterm); + void add_type_terminal(const std::string &term); + void set_type_nonterminal(const std::string &type); + void set_type_terminal(const std::string &type); + void set_type_terminal_name(const std::string &name); }; } diff --git a/src/symbol.hpp b/src/symbol.hpp index 68222e2..0e79eb6 100644 --- a/src/symbol.hpp +++ b/src/symbol.hpp @@ -39,7 +39,7 @@ enum symbol_type_t { }; struct symbol_t : public std::tuple { - symbol_t(symbol_type_t type, const char *value) : std::tuple(type, value) {} + symbol_t(symbol_type_t type, const std::string &value) : std::tuple(type, value) {} symbol_type_t get_type() const { return std::get<0>(*this); @@ -49,11 +49,11 @@ struct symbol_t : public std::tuple { return std::get<1>(*this); } - static symbol_t make_nonterm(const char *value) { + static symbol_t make_nonterm(const std::string &value) { return symbol_t(SYMBOL_TYPE_NONTERM, value); } - static symbol_t make_term(const char *value) { + static symbol_t make_term(const std::string &value) { return symbol_t(SYMBOL_TYPE_TERM, value); } -- cgit v1.2.3