static void
digest_file (const char *file)
{
scanner_t *scanner = scanner_new (file);
parse_program (scanner);
scanner_free (scanner);
}
void test_scanner (void)
{
scanner_t *scanner = scanner_new(testdata);
assert(!scanner_is_at_end(scanner));
assert(scanner_line_number(scanner) == 1);
assert(scanner_next_token(scanner) == TOKEN_SYMBOL);
assert(scanner_token_type(scanner) == TOKEN_SYMBOL);
assert(strcmp(scanner_token_string_value(scanner), "a") == 0);
assert(scanner_next_token(scanner) == '.');
assert(scanner_next_token(scanner) == TOKEN_SYMBOL);
assert(strcmp(scanner_token_string_value(scanner), "_b") == 0);
assert(scanner_next_token(scanner) == TOKEN_EQUAL);
assert(scanner_next_token(scanner) == TOKEN_SYMBOL);
assert(strcmp(scanner_token_string_value(scanner), "len") == 0);
assert(scanner_next_token(scanner) == '(');
assert(scanner_next_token(scanner) == TOKEN_STRING);
assert(strcmp(scanner_token_string_value(scanner), "x\"") == 0);
assert(scanner_next_token(scanner) == ')');
assert(scanner_next_token(scanner) == '+');
assert(scanner_next_token(scanner) == TOKEN_NUMBER);
assert(scanner_token_double_value(scanner) == 1.7e1);
assert(!scanner_is_at_end(scanner));
assert(scanner_line_number(scanner) == 2);
assert(scanner_next_token(scanner) == TOKEN_STRING);
assert(strcmp(scanner_token_string_value(scanner),
"\\'\t\n\1234\x1a\018") == 0);
assert(scanner_is_at_end(scanner));
assert(scanner_line_number(scanner) == 3);
assert(scanner_next_token(scanner) == TOKEN_NONE);
assert(scanner_position(scanner) == strlen(testdata));
scanner_free(scanner);
}
struct verilog_module *verilog_parse_fd(FILE *fd)
{
struct scanner *s;
int tok;
void *p;
char *stoken;
struct verilog_module *m;
//ParseTrace(stdout, "parser: ");
s = scanner_new(fd);
m = verilog_new_module();
p = ParseAlloc(malloc);
assert(p != NULL);
tok = scanner_scan(s);
while(tok != TOK_EOF) {
stoken = scanner_get_token(s);
Parse(p, tok, stoken, m);
tok = scanner_scan(s);
}
Parse(p, TOK_EOF, NULL, m);
ParseFree(p, free);
scanner_free(s);
return m;
}
void parse_free(void)
{
named_buffer_free(s->initial_named_buffer);
map_free(s->initial_symbols);
named_buffer_free(s->named_buffer);
chunkpool_free(s->atom_pool);
chunkpool_free2(s->vec_pool, (cb_free*)free_vec_pool);
named_buffer_free(s->named_buffer);
map_free(s->sym_table);
scanner_free();
expr_free();
}
static void
freeze_main(struct value *args, struct value *result)
{
struct process *p;
struct scanner *sc;
struct reporter *r;
struct value term;
struct value *termfile, *binfile;
struct value termfile_sym, binfile_sym;
value_symbol_new(&termfile_sym, "termfile", 8);
value_symbol_new(&binfile_sym, "binfile", 7);
termfile = value_dict_fetch(args, &termfile_sym);
binfile = value_dict_fetch(args, &binfile_sym);
r = reporter_new("Freezing", NULL, 1);
/*
* Parse.
*/
sc = scanner_new(r);
if (!scanner_open(sc, value_symbol_get_token(termfile))) {
value_integer_set(result, 1);
return;
}
if (!value_discern(&term, sc)) {
report(r, REPORT_ERROR, "Could not parse input term");
}
/*
* Write out.
*/
p = file_open(value_symbol_get_token(binfile), "w");
if (!value_save(p, &term)) {
report(r, REPORT_ERROR,
"Could not write term to '%s'", binfile);
}
stream_close(NULL, p);
/*
* Finish up.
*/
scanner_close(sc);
scanner_free(sc);
value_integer_set(result, reporter_has_errors(r) ? 1 : 0);
reporter_free(r);
}
static int
filter_lines (struct scanner *s)
{
char b[8192] = { 0 };
if (s == NULL)
return -1;
while (scanner_readline (s, b, sizeof (b)) >= 0) {
filter (b);
if (*b)
puts (b);
}
scanner_free (s);
return 0;
}
static int randvar_read_PHI ()
{
# define CUR_PROC "randvar_read_PHI"
int res = -1;
char filename = "ghmm/PHI_001_20.dat";
scanner_t *s = NULL;
//#warning "PHI_DATA_FILE deprecated!"
s = scanner_alloc (filename);
if (!s) {
mes_proc ();
goto STOP;
}
scanner_get_name (s);
scanner_consume (s, '=');
if (s->err)
goto STOP;
if (!strcmp (s->id, "PHI")) {
scanner_consume (s, '{');
if (s->err)
goto STOP;
PHI = scanner_get_double_earray (s, &PHI_len);
if (s->err)
goto STOP;
scanner_consume (s, ';');
if (s->err)
goto STOP;
scanner_consume (s, '}');
if (s->err)
goto STOP;
scanner_consume (s, ';');
if (s->err)
goto STOP;
}
else {
scanner_error (s, "unknown identifier");
goto STOP;
}
// printf("%.4f\n", PHI[PHI_len-1]);
res = 0;;
STOP:
scanner_free (&s);
return res;
# undef CUR_PROC
}
