neocturne/solar
Archived
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

lex: use std::string * instead of char *

Browse source
This commit is contained in:
Matthias Schiffer 2015-04-09 05:18:47 +02:00
parent 7a65ee0c61
commit e86d064002
7 changed files with 70 additions and 78 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

22
src/lex.cpp
View file

@ -234,10 +234,10 @@ int lex_t::lex_keyword(parser_value_t *value) {
break; break;
} }
char *token = get_token(); std::string *token = get_token();
const keyword_t key = { .keyword = token, .token = 0 }; const keyword_t key = { .keyword = token->c_str(), .token = 0 };
const keyword_t *ret = static_cast<const keyword_t*>(bsearch(&key, keywords, array_size(keywords), sizeof(keyword_t), compare_keywords)); const keyword_t *ret = static_cast<const keyword_t*>(bsearch(&key, keywords, array_size(keywords), sizeof(keyword_t), compare_keywords));
free(token); delete token;
if (!ret) if (!ret)
return syntax_error(value); return syntax_error(value);
@ -262,15 +262,13 @@ int lex_t::lex_block(parser_value_t *value) {
bool str = false; bool str = false;
bool pp = false; bool pp = false;
size_t pos = 0; std::string *buf = new std::string;
size_t len = 1024;
char *buf = static_cast<char*>(std::malloc(len));
char prev = 0; char prev = 0;
while (true) { while (true) {
if (!next(true)) { if (!next(true)) {
std::free(buf); delete buf;
return unterminated_block(value); return unterminated_block(value);
} }
@ -316,17 +314,11 @@ int lex_t::lex_block(parser_value_t *value) {
} }
} }
if (pos >= len) { *buf += cur;
len *= 2;
buf = static_cast<char*>(std::realloc(buf, len));
}
buf[pos++] = cur;
prev = cur; prev = cur;
} }
value->str = strndup(buf, pos); value->str = buf;
std::free(buf);
next(true); next(true);
consume(true); consume(true);

4
src/lex.hpp
View file

@ -78,8 +78,8 @@ private:
return buffer[start + tok_len]; return buffer[start + tok_len];
} }
char * get_token() { std::string * get_token() {
return strndup(buffer+start, tok_len); return new std::string(buffer+start, tok_len);
} }

70
src/parser.cpp
View file

@ -66,8 +66,8 @@ int parser_push(parser_t *parser, int token, const parser_value_t *value, parser
switch (token) { switch (token) {
case TOK_SYMBOL_LC: case TOK_SYMBOL_LC:
parser->state = STATE_RULE_BAR; parser->state = STATE_RULE_BAR;
state->new_rule(value->str); state->new_rule(*value->str);
free(value->str); delete value->str;
return 1; return 1;
case TOK_TYPE: case TOK_TYPE:
@ -111,13 +111,13 @@ int parser_push(parser_t *parser, int token, const parser_value_t *value, parser
case STATE_RULE: case STATE_RULE:
switch (token) { switch (token) {
case TOK_SYMBOL_LC: case TOK_SYMBOL_LC:
state->add_rule_nonterminal(value->str); state->add_rule_nonterminal(*value->str);
free(value->str); delete value->str;
return 1; return 1;
case TOK_SYMBOL_UC: case TOK_SYMBOL_UC:
state->add_rule_terminal(value->str); state->add_rule_terminal(*value->str);
free(value->str); delete value->str;
return 1; return 1;
case TOK_CHAR: case TOK_CHAR:
@ -125,8 +125,8 @@ int parser_push(parser_t *parser, int token, const parser_value_t *value, parser
return 1; return 1;
case TOK_BLOCK: case TOK_BLOCK:
state->add_rule(value->str); state->add_rule(*value->str);
free(value->str); delete value->str;
parser->state = STATE_INIT; parser->state = STATE_INIT;
return 1; 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:
case TOK_SYMBOL_UC: case TOK_SYMBOL_UC:
case TOK_SYMBOL_LC: case TOK_SYMBOL_LC:
state->add_rule_var(value->str); state->add_rule_var(*value->str);
free(value->str); delete value->str;
parser->state = STATE_RULE_VAR; parser->state = STATE_RULE_VAR;
return 1; 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: case STATE_RULE_VAR_POST:
switch (token) { switch (token) {
case TOK_SYMBOL_LC: case TOK_SYMBOL_LC:
state->add_rule_nonterminal(value->str); state->add_rule_nonterminal(*value->str);
free(value->str); delete value->str;
return 1; return 1;
case TOK_SYMBOL_UC: case TOK_SYMBOL_UC:
state->add_rule_terminal(value->str); state->add_rule_terminal(*value->str);
free(value->str); delete value->str;
return 1; return 1;
case TOK_CHAR: case TOK_CHAR:
@ -180,8 +180,8 @@ int parser_push(parser_t *parser, int token, const parser_value_t *value, parser
return 1; return 1;
case TOK_BLOCK: case TOK_BLOCK:
state->add_rule(value->str); state->add_rule(*value->str);
free(value->str); delete value->str;
parser->state = STATE_INIT; parser->state = STATE_INIT;
return 1; return 1;
@ -196,14 +196,14 @@ int parser_push(parser_t *parser, int token, const parser_value_t *value, parser
case STATE_TYPE: case STATE_TYPE:
switch (token) { switch (token) {
case TOK_SYMBOL_LC: case TOK_SYMBOL_LC:
state->add_type_nonterminal(value->str); state->add_type_nonterminal(*value->str);
free(value->str); delete value->str;
parser->state = STATE_TYPE_NONTERM; parser->state = STATE_TYPE_NONTERM;
return 1; return 1;
case TOK_SYMBOL_UC: case TOK_SYMBOL_UC:
state->add_type_terminal(value->str); state->add_type_terminal(*value->str);
free(value->str); delete value->str;
parser->state = STATE_TYPE_TERM; parser->state = STATE_TYPE_TERM;
return 1; return 1;
} }
@ -212,8 +212,8 @@ int parser_push(parser_t *parser, int token, const parser_value_t *value, parser
case STATE_TYPE_NONTERM: case STATE_TYPE_NONTERM:
if (token == TOK_BLOCK) { if (token == TOK_BLOCK) {
state->set_type_nonterminal(value->str); state->set_type_nonterminal(*value->str);
free(value->str); delete value->str;
parser->state = STATE_INIT; parser->state = STATE_INIT;
return 1; return 1;
} }
@ -222,8 +222,8 @@ int parser_push(parser_t *parser, int token, const parser_value_t *value, parser
case STATE_TYPE_TERM: case STATE_TYPE_TERM:
if (token == TOK_BLOCK) { if (token == TOK_BLOCK) {
state->set_type_terminal(value->str); state->set_type_terminal(*value->str);
free(value->str); delete value->str;
parser->state = STATE_TYPE_TERM_BLOCK; parser->state = STATE_TYPE_TERM_BLOCK;
return 1; 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:
case TOK_SYMBOL_UC: case TOK_SYMBOL_UC:
case TOK_SYMBOL_LC: case TOK_SYMBOL_LC:
state->set_type_terminal_name(value->str); state->set_type_terminal_name(*value->str);
free(value->str); delete value->str;
parser->state = STATE_INIT; parser->state = STATE_INIT;
return 1; return 1;
} }
@ -244,8 +244,8 @@ int parser_push(parser_t *parser, int token, const parser_value_t *value, parser
case STATE_HEADER: case STATE_HEADER:
if (token == TOK_BLOCK) { if (token == TOK_BLOCK) {
state->set_header_block(value->str); state->set_header_block(*value->str);
free(value->str); delete value->str;
parser->state = STATE_INIT; parser->state = STATE_INIT;
return 1; return 1;
} }
@ -254,8 +254,8 @@ int parser_push(parser_t *parser, int token, const parser_value_t *value, parser
case STATE_SOURCE: case STATE_SOURCE:
if (token == TOK_BLOCK) { if (token == TOK_BLOCK) {
state->set_source_block(value->str); state->set_source_block(*value->str);
free(value->str); delete value->str;
parser->state = STATE_INIT; parser->state = STATE_INIT;
return 1; return 1;
} }
@ -264,8 +264,8 @@ int parser_push(parser_t *parser, int token, const parser_value_t *value, parser
case STATE_EXTRA_ARG: case STATE_EXTRA_ARG:
if (token == TOK_BLOCK) { if (token == TOK_BLOCK) {
state->add_extra_arg(value->str); state->add_extra_arg(*value->str);
free(value->str); delete value->str;
parser->state = STATE_EXTRA_ARG_NAME; parser->state = STATE_EXTRA_ARG_NAME;
return 1; 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:
case TOK_SYMBOL_UC: case TOK_SYMBOL_UC:
case TOK_SYMBOL_LC: case TOK_SYMBOL_LC:
state->set_extra_arg_name(value->str); state->set_extra_arg_name(*value->str);
free(value->str); delete value->str;
parser->state = STATE_INIT; parser->state = STATE_INIT;
return 1; 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_SYMBOL_LC:
case TOK_CHAR: case TOK_CHAR:
case TOK_BLOCK: case TOK_BLOCK:
free(value->str);; delete value->str;;
} }
return -1; return -1;

2
src/parser.hpp
View file

@ -46,7 +46,7 @@ enum parser_token_t {
}; };
typedef struct parser_value { typedef struct parser_value {
char *str; std::string *str;
uint64_t number; uint64_t number;
const char *error; const char *error;
} parser_value_t; } parser_value_t;

18
src/parser_state.cpp
View file

@ -29,7 +29,7 @@
namespace solar { 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()) { if (grammar.rules.empty()) {
// start rule // start rule
add_rule_nonterminal(nonterm); add_rule_nonterminal(nonterm);
@ -40,12 +40,12 @@ void parser_state_t::new_rule(const char *nonterm) {
current_vars = std::vector<std::string>(); current_vars = std::vector<std::string>();
} }
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.get_rhs().emplace_back(symbol_t::make_nonterm(nonterm));
current_vars.emplace_back(); 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.get_rhs().emplace_back(symbol_t::make_term(term));
current_vars.emplace_back(); 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}); 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; 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; 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; 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)); 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; 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))); grammar.term_types.insert(std::make_pair(symbol_t::make_term(current_var.c_str()), std::make_pair(current_type, name)));
} }

26
src/parser_state.hpp
View file

@ -49,35 +49,35 @@ public:
return grammar; return grammar;
} }
void set_header_block(const char *value) { void set_header_block(const std::string &value) {
grammar.header_block = value; grammar.header_block = value;
} }
void set_source_block(const char *value) { void set_source_block(const std::string &value) {
grammar.source_block = value; grammar.source_block = value;
} }
void add_extra_arg(const char *type) { void add_extra_arg(const std::string &type) {
current_extra_arg = 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); grammar.extra_args.emplace_back(current_extra_arg, name);
} }
void new_rule(const char *nonterm); void new_rule(const std::string &nonterm);
void add_rule_nonterminal(const char *nonterm); void add_rule_nonterminal(const std::string &nonterm);
void add_rule_terminal(const char *term); void add_rule_terminal(const std::string &term);
void add_rule_terminal(unsigned char term); void add_rule_terminal(unsigned char term);
void add_rule(const std::string &action = ""); 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_nonterminal(const std::string &nonterm);
void add_type_terminal(const char *term); void add_type_terminal(const std::string &term);
void set_type_nonterminal(const char *type); void set_type_nonterminal(const std::string &type);
void set_type_terminal(const char *type); void set_type_terminal(const std::string &type);
void set_type_terminal_name(const char *name); void set_type_terminal_name(const std::string &name);
}; };
} }

6
src/symbol.hpp
View file

@ -39,7 +39,7 @@ enum symbol_type_t {
}; };
struct symbol_t : public std::tuple<symbol_type_t, std::string> { struct symbol_t : public std::tuple<symbol_type_t, std::string> {
symbol_t(symbol_type_t type, const char *value) : std::tuple<symbol_type_t, std::string>(type, value) {} symbol_t(symbol_type_t type, const std::string &value) : std::tuple<symbol_type_t, std::string>(type, value) {}
symbol_type_t get_type() const { symbol_type_t get_type() const {
return std::get<0>(*this); return std::get<0>(*this);
@ -49,11 +49,11 @@ struct symbol_t : public std::tuple<symbol_type_t, std::string> {
return std::get<1>(*this); 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); 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); return symbol_t(SYMBOL_TYPE_TERM, value);
} }