static void test_fingerprints(void *fixture)
{
struct dm_pool *mem = fixture;
struct dm_regex *scanner;
scanner = make_scanner(mem, dev_patterns);
T_ASSERT_EQUAL(dm_regex_fingerprint(scanner), 0x7f556c09);
scanner = make_scanner(mem, random_patterns);
T_ASSERT_EQUAL(dm_regex_fingerprint(scanner), 0x9f11076c);
}
static void test_matching(void *fixture)
{
struct dm_pool *mem = fixture;
struct dm_regex *scanner;
int i;
scanner = make_scanner(mem, dev_patterns);
for (i = 0; devices[i].str; ++i)
T_ASSERT_EQUAL(dm_regex_match(scanner, devices[i].str), devices[i].expected - 1);
scanner = make_scanner(mem, nonprint_patterns);
for (i = 0; nonprint[i].str; ++i)
T_ASSERT_EQUAL(dm_regex_match(scanner, nonprint[i].str), nonprint[i].expected - 1);
}
void write_value(scanner& sc, writer& wr, const value& val) {
switch (val.type()) {
case value_type::number_type: {
read_value(sc);
wr.append(stringize_number(val.number_value()));
break;
}
case value_type::string_type: {
read_value(sc);
wr.append("\"");
wr.append(escape_string(val.string_value()));
wr.append("\"");
break;
}
case value_type::bool_type: {
read_value(sc);
wr.append(val.bool_value() ? "true" : "false");
break;
}
case value_type::group_type: {
if (sc.peek_token().is_char('{')) {
write_group(sc, wr, true, val.group_value());
} else {
read_value(sc);
scanner dummy_scanner = make_scanner("{}");
write_group(dummy_scanner, wr, true, val.group_value());
}
break;
}
case value_type::vector_type: {
if (sc.peek_token().is_char('[')) {
write_vector(sc, wr, val.vector_value());
} else {
read_value(sc);
scanner dummy_scanner = make_scanner("[]");
write_vector(dummy_scanner, wr, val.vector_value());
}
break;
}
default: {
break;
}
}
}
void write_vector(scanner& sc, writer& wr, const value_vector_type& vec) {
bool wrap = vector_length(vec) > wr.wrap_length;
wr.append("[ ");
wr.indent();
if (wrap) {
wr.newline();
}
sc.expect('[');
unsigned int vals_read = 0;
while (!sc.peek_token().is_char(']')) {
if (vals_read < vec.size()) {
write_value(sc, wr, vec[vals_read]);
vals_read++;
} else {
read_value(sc);
}
bool terminate = sc.peek_token().is_char(']') && vals_read == vec.size();
if (!terminate) {
if (wrap) {
wr.newline();
} else {
wr.append(", ");
}
} else if (!wrap) {
wr.append(" ");
}
sc.expect(',', true);
}
for (unsigned int i = vals_read; i < vec.size(); i++) {
scanner dummy_scanner = make_scanner("0");
write_value(dummy_scanner, wr, vec[i]);
if (i < vec.size() - 1) {
if (wrap) {
wr.newline();
} else {
wr.append(", ");
}
} else if (!wrap) {
wr.append(" ");
}
}
wr.unindent();
if (wrap) {
wr.newline();
}
sc.expect(']');
wr.append("]");
}
/*
Parses a given file with a GScanner and stores a word count in the given GHashTable
@param {char *} filename - path of the file to parse
@param {GHashTable *} table - hash table in which to store the word counts
*/
void parse_file(char* filename, GHashTable* table) {
GScanner* scanner = make_scanner(filename);
char *key;
int i = 0;
while (1) {
g_scanner_get_next_token(scanner);
if (scanner->token == G_TOKEN_EOF) break;
if (scanner->token == G_TOKEN_IDENTIFIER) {
if (scanner->value.v_string != NULL) {
//g_printf("string->%s\n", scanner->value.v_string);
insert_word(scanner->value.v_string, table);
i++;
}
}
}
//g_printf("Total Word Count: %i\n", i);
g_scanner_destroy(scanner);
}
inline std::string write(const group& grp, const std::string& src, int wrap_length) {
scanner sc;
writer wr;
wr.wrap_length = wrap_length;
scanner_params params;
params.flags = allow_comments_flag | blank_line_comment_flag;
params.comment_function = [&](const std::string& str) {
wr.append(str);
wr.newline();
};
sc.scan(src, params);
try {
write_group(sc, wr, false, grp);
} catch (parse_error e) {
// if we fail to parse the source file to update, just write as if writing a brand new file
scanner dummy_scanner = make_scanner("");
write_group(dummy_scanner, wr, false, grp);
}
return wr.buf;
}
void write_group(scanner& sc, writer& wr, bool braces, const group& gr) {
bool wrap = !braces || group_length(gr) > wr.wrap_length;
if (braces) {
wr.append("{ ");
wr.indent();
if (wrap) {
wr.newline();
}
sc.expect('{');
}
std::vector<std::string> keys;
for (const auto& key : gr) {
keys.push_back(key);
}
while (sc.peek_token().type != token_type::eof_token && !(braces && sc.peek_token().is_char('}'))) {
std::string key = sc.expect_identifier();
sc.expect('=');
auto key_it = std::find(std::begin(keys), std::end(keys), key);
if (key_it != keys.end()) {
wr.append(key);
wr.append(" = ");
write_value(sc, wr, gr.get<value>(*key_it));
keys.erase(key_it);
bool terminate = sc.peek_token().is_char('}') && keys.empty();
if (!terminate) {
if (wrap) {
wr.newline();
} else {
wr.append(", ");
}
} else if (!wrap) {
wr.append(" ");
}
} else {
read_value(sc);
}
sc.expect(',', true);
if (braces && sc.peek_token().is_char('}')) {
break;
}
}
unsigned int i = 0;
for (const auto& key : keys) {
wr.append(key);
wr.append(" = ");
scanner dummy_scanner = make_scanner("0");
write_value(dummy_scanner, wr, gr.get<value>(key));
if (i < keys.size() - 1) {
if (wrap) {
wr.newline();
} else {
wr.append(", ");
}
} else if (!wrap) {
wr.append(" ");
}
i++;
}
if (braces) {
wr.unindent();
if (wrap) {
wr.newline();
}
sc.expect('}');
wr.append("}");
}
}
