void expression_prune(Sentence sent)
{
int N_deleted;
X_node * x;
size_t w;
Connector *ct[CONTABSZ];
Connector *dummy_list = NULL;
zero_connector_table(ct);
N_deleted = 1; /* a lie to make it always do at least 2 passes */
while (1)
{
/* Left-to-right pass */
/* For every word */
for (w = 0; w < sent->length; w++)
{
/* For every expression in word */
for (x = sent->word[w].x; x != NULL; x = x->next)
{
DBG(printf("before marking: "); print_expression(x->exp); printf("\n"););
N_deleted += mark_dead_connectors(ct, x->exp, '-');
DBG(printf(" after marking: "); print_expression(x->exp); printf("\n"););
}
for (x = sent->word[w].x; x != NULL; x = x->next)
{
DBG(printf("before purging: "); print_expression(x->exp); printf("\n"););
x->exp = purge_Exp(x->exp);
DBG(printf("after purging: "); print_expression(x->exp); printf("\n"););
void print_alloc_fun(struct funcall *f)
{
assert(strcmp(f->fun_ident, "allouer") == 0);
print_expression(f->args.data[0]->e);
printf(" = malloc(sizeof(*(");
print_expression(f->args.data[0]->e);
printf(")));\n");
}
static void print_array_access_expression(const array_access_expression_t *access)
{
fprintf(out, "(");
print_expression(access->array_ref);
fprintf(out, ")[");
print_expression(access->index);
fprintf(out, "]");
}
void print_exprlist(exprlist_t l)
{
unsigned i = 0;
for (; i + 1 < l.size; ++i)
{
print_expression(l.data[i]);
printf(", ");
}
if (l.size > 0)
print_expression(list_nth(l, i));
}
void print_arg(struct arg *arg)
{
if (arg->global)
{
printf("&(");
print_expression(arg->e);
printf(")");
}
else
print_expression(arg->e);
}
static void vertex_printer(NODE *vertex, void *data)
{
DAA_SET *set = NULL;
if (data)
{
DFA *dfa = data;
LIST *input = get_from_hash(dfa->inputs, vertex, sizeof(void *));
set = input->size ? input->items[0] : NULL;
}
if (tree_is_type(vertex, STMT_ASSIGN))
{
EXPRESSION *dest = tree_get_child(vertex, 0);
print_expression(dest, set);
printf(" = ");
EXPRESSION *src = tree_get_child(vertex, 1);
print_expression(src, set);
}
else if (tree_is_type(vertex, STMT_RETURN))
{
printf("return ");
EXPRESSION *expr = tree_get_child(vertex, 0);
print_expression(expr, set);
}
else if (tree_is_type(vertex, STMT_TEST))
{
printf("test ");
EXPRESSION *expr = tree_get_child(vertex, 0);
print_expression(expr, set);
}
else if (tree_is_type(vertex, STMT_PASS))
{
printf("pass");
}
else if (tree_is_type(vertex, STMT_JOIN))
{
printf("join");
}
else if (tree_is_type(vertex, STMT_ENTER))
{
printf("enter");
}
else if (tree_is_type(vertex, STMT_EXIT))
{
printf("exit");
}
else if (tree_is_type(vertex, DEF_VARIABLE))
{
DECLARATION *decl = CAST_TO_DECLARATION(vertex);
printf("%s", decl->name);
}
else
printf("?%d?", vertex->type);
}
static void print_binary_expression(const binary_expression_t *binexpr)
{
fprintf(out, "(");
print_expression(binexpr->left);
fprintf(out, " ");
switch (binexpr->base.kind) {
case EXPR_BINARY_ASSIGN:
fprintf(out, "<-");
break;
case EXPR_BINARY_ADD:
fprintf(out, "+");
break;
case EXPR_BINARY_SUB:
fprintf(out, "-");
break;
case EXPR_BINARY_MUL:
fprintf(out, "*");
break;
case EXPR_BINARY_DIV:
fprintf(out, "/");
break;
case EXPR_BINARY_NOTEQUAL:
fprintf(out, "/=");
break;
case EXPR_BINARY_EQUAL:
fprintf(out, "=");
break;
case EXPR_BINARY_LESS:
fprintf(out, "<");
break;
case EXPR_BINARY_LESSEQUAL:
fprintf(out, "<=");
break;
case EXPR_BINARY_GREATER:
fprintf(out, ">");
break;
case EXPR_BINARY_GREATEREQUAL:
fprintf(out, ">=");
break;
default:
/* TODO: add missing ops */
fprintf(out, "op%d", binexpr->base.kind);
break;
}
fprintf(out, " ");
print_expression(binexpr->right);
fprintf(out, ")");
}
static void print_array_type(const array_type_t *type)
{
print_type(type->element_type);
fputs("[", out);
print_expression(type->size_expression);
fputs("]", out);
}
/**
* print the expression, in prefix-style
*/
void print_expression(Exp * n)
{
E_list * el;
int i, icost;
if (n == NULL)
{
printf("NULL expression");
return;
}
icost = (int) (n->cost);
if (n->type == CONNECTOR_type)
{
for (i=0; i<icost; i++) printf("[");
if (n->multi) printf("@");
printf("%s%c", n->u.string, n->dir);
for (i=0; i<icost; i++) printf("]");
if (icost > 0) printf(" ");
}
else
{
for (i=0; i<icost; i++) printf("[");
if (icost == 0) printf("(");
if (n->type == AND_type) printf("& ");
if (n->type == OR_type) printf("or ");
for (el = n->u.l; el != NULL; el = el->next)
{
print_expression(el->e);
}
for (i=0; i<icost; i++) printf("]");
if (icost > 0) printf(" ");
if (icost == 0) printf(") ");
}
}
void print_expression_list(expression_list_t * node, int spaces) {
print_spaces(spaces);
fprintf(stderr, "EXPR_LIST:\n");
for(; node != NULL; node = node->next)
print_expression(node->expression, spaces + SP_INDENT);
}
/*
* list expressions
*/
void print_expression(expression *e)
{
if (!e) return;
printf("%s, ", e->value);
if (e->next) print_expression(e->next);
}
void print_free_fun(struct funcall *f)
{
assert(strcmp(f->fun_ident, "liberer") == 0);
printf("free(");
print_expression(f->args.data[0]->e);
printf(");\n");
}
static void print_call_expression(const call_expression_t *call)
{
print_expression(call->function);
fprintf(out, "(");
call_argument_t *argument = call->arguments;
int first = 1;
while (argument != NULL) {
if (!first) {
fprintf(out, ", ");
} else {
first = 0;
}
print_expression(argument->expression);
argument = argument->next;
}
fprintf(out, ")");
}
static void rprint_dictionary_data(Dict_node * n)
{
if (n == NULL) return;
rprint_dictionary_data(n->left);
printf("%s: ", n->string);
print_expression(n->exp);
printf("\n");
rprint_dictionary_data(n->right);
}
/**
* Prints the prefix part of a typeof type.
*
* @param type The typeof type.
*/
static void print_typeof_type_pre(const typeof_type_t *const type)
{
print_string("typeof(");
if (type->expression != NULL) {
print_expression(type->expression);
} else {
print_type(type->typeof_type);
}
print_char(')');
}
/*
* list rules
*/
void print_rule(rule *r)
{
if (!r) return;
printf("\nNEW RULE:\n");
printf("\n\tLEFT: ");
if (r->left) print_expression(r->left); else printf("ALL");
if (r->left_exceptions) {
printf("\n\tLEFT EXCEPTIONS: ");
print_expression(r->left_exceptions);
}
printf("\n\tRIGHT: ");
if (r->right) print_expression(r->right); else printf("ALL");
if (r->right_exceptions) {
printf("\n\tRIGHT EXCEPTIONS: ");
print_expression(r->right_exceptions);
}
printf("\n");
if (r->next) print_rule(r->next);
}
static void print_select_expression(const select_expression_t *select)
{
fprintf(out, "(");
print_expression(select->compound);
fprintf(out, ").");
if (select->compound_entry != NULL) {
fputs(select->compound_entry->symbol->string, out);
} else {
fprintf(out, "?%s", select->symbol->string);
}
}
void print_type(const type_t *type)
{
if (type == NULL) {
fputs("nil type", out);
return;
}
switch (type->kind) {
case TYPE_INVALID:
fputs("invalid", out);
return;
case TYPE_TYPEOF: {
const typeof_type_t *typeof_type = (const typeof_type_t*) type;
fputs("typeof(", out);
print_expression(typeof_type->expression);
fputs(")", out);
return;
}
case TYPE_ERROR:
fputs("error", out);
return;
case TYPE_VOID:
fputs("void", out);
return;
case TYPE_ATOMIC:
print_atomic_type(&type->atomic);
return;
case TYPE_COMPOUND_UNION:
case TYPE_COMPOUND_STRUCT:
print_compound_type(&type->compound);
return;
case TYPE_FUNCTION:
print_function_type(&type->function);
return;
case TYPE_POINTER:
print_pointer_type(&type->pointer);
return;
case TYPE_ARRAY:
print_array_type(&type->array);
return;
case TYPE_REFERENCE:
print_type_reference(&type->reference);
return;
case TYPE_REFERENCE_TYPE_VARIABLE:
print_type_reference_variable(&type->reference);
return;
case TYPE_BIND_TYPEVARIABLES:
print_bind_type_variables(&type->bind_typevariables);
return;
}
fputs("unknown", out);
}
static void print_constant(const constant_t *constant)
{
fprintf(out, "const %s", constant->base.symbol->string);
if (constant->type != NULL) {
fprintf(out, " ");
print_type(constant->type);
}
if (constant->expression != NULL) {
fprintf(out, " <- ");
print_expression(constant->expression);
}
fprintf(out, "\n");
}
void print_case(struct caseblock *c, int indent)
{
for(size_t i = 0; i<c->exprlist.size;i++)
{
print_indent(indent);
printf("case ");
print_expression(c->exprlist.data[i]);
printf(":\n");
}
print_instructions(c->instructions, indent + INDENT_WIDTH);
print_indent(indent + INDENT_WIDTH);
printf("break;\n");
}
void print_expression(struct expr *e)
{
switch (e->exprtype)
{
case valtype:
print_val(e->val.val);
break;
case binopexprtype:
printf("(");
print_expression(e->val.binopexpr.e1);
printf(" %s ", getopstr(e->val.binopexpr.op));
print_expression(e->val.binopexpr.e2);
printf(")");
break;
case unopexprtype:
printf("(");
printf("%s ", getopstr(e->val.unopexpr.op));
print_expression(e->val.unopexpr.e);
printf(")");
break;
case arrayexprtype:
print_expression(e->val.arrayexpr.e1);
for (unsigned i = 0; i < e->val.arrayexpr.indices.size; ++i)
{
printf("[");
print_expression(list_nth(e->val.arrayexpr.indices, i));
printf(" - 1]");
}
break;
case identtype:
if (e->argref)
printf("*(%s)", e->val.ident);
else
printf("%s", e->val.ident);
break;
case dereftype:
printf("*");
print_expression(e->val.deref.e);
break;
case funcalltype:
printf("%s(", e->val.funcall.fun_ident);
print_arglist(e->val.funcall.args);
printf(")");
break;
case structelttype:
printf("(");
print_expression(e->val.structelt.record);
printf(").%s", e->val.structelt.field);
break;
default:
printf("expr not handled yet in print_expression\n");
}
}
static void print_if_statement(const if_statement_t *statement)
{
fprintf(out, "if ");
print_expression(statement->condition);
fprintf(out, ":\n");
if (statement->true_statement != NULL)
print_statement(statement->true_statement);
if (statement->false_statement != NULL) {
print_indent();
fprintf(out, "else:\n");
print_statement(statement->false_statement);
}
}
/**
* Prints the postfix part of an array type.
*
* @param type The array type.
*/
static void print_array_type_post(const array_type_t *type)
{
print_char('[');
if (type->is_static) {
print_string("static ");
}
print_type_qualifiers(type->base.qualifiers, QUAL_SEP_END);
if (type->size_expression != NULL
&& (print_implicit_array_size || !type->has_implicit_size)) {
print_expression(type->size_expression);
}
print_char(']');
intern_print_type_post(type->element_type);
}
void print_expression(node_t *root)
{
if (!root) return;
printf("%s", "( ");
print_expression(root->left_child);
switch (root->type) {
case OP:
printf(" %i ", root->value.op);
break;
case FIELD:
printf(" (%s", root->value.field.fieldname);
break;
case STRING:
printf("%s) ", root->value.string_literal);
break;
case INT:
printf(" %llu) ", (long long unsigned) root->value.int_literal);
break;
default:
break;
}
print_expression(root->right_child);
printf("%s", " )");
}
static void print_unary_expression(const unary_expression_t *unexpr)
{
fprintf(out, "(");
switch (unexpr->base.kind) {
case EXPR_UNARY_CAST:
fprintf(out, "cast<");
print_type(unexpr->base.type);
fprintf(out, "> ");
print_expression(unexpr->value);
break;
default:
fprintf(out, "*unexpr %d*", unexpr->base.kind);
break;
}
fprintf(out, ")");
}
void
dump_prefix_expression (struct expression *exp, struct ui_file *stream)
{
int elt;
fprintf_filtered (stream, "Dump of expression @ ");
gdb_print_host_address (exp, stream);
fputs_filtered (", after conversion to prefix form:\nExpression: `", stream);
print_expression (exp, stream);
fprintf_filtered (stream, "'\n\tLanguage %s, %d elements, %ld bytes each.\n",
exp->language_defn->la_name, exp->nelts,
(long) sizeof (union exp_element));
fputs_filtered ("\n", stream);
for (elt = 0; elt < exp->nelts;)
elt = dump_subexp (exp, stream, elt);
fputs_filtered ("\n", stream);
}
static Dict_node * db_lookup_list(Dictionary dict, const char *s)
{
cbdata bs;
bs.dict = dict;
bs.dn = NULL;
db_lookup_common(dict, s, morph_cb, &bs);
if (3 < verbosity)
{
if (bs.dn)
{
printf("Found expression for word %s: ", s);
print_expression(bs.dn->exp);
}
else
{
printf("No expression for word %s\n", s);
}
}
return bs.dn;
}
static void
db_lookup_exp(Dictionary dict, const char *s, cbdata* bs)
{
sqlite3 *db = dict->db_handle;
dyn_str *qry;
/* The token to look up is called the 'morpheme'. */
qry = dyn_str_new();
dyn_strcat(qry, "SELECT disjunct, cost FROM Disjuncts WHERE classname = \'");
dyn_strcat(qry, s);
dyn_strcat(qry, "\';");
sqlite3_exec(db, qry->str, exp_cb, bs, NULL);
dyn_str_delete(qry);
if (4 < verbosity)
{
printf("Found expression for class %s: ", s);
print_expression(bs->exp);
}
}
void print_enum_definition(const enum_t *enume)
{
print_string("{\n");
change_indent(1);
for (const entity_t *entry = enume->first_value;
entry != NULL && entry->kind == ENTITY_ENUM_VALUE;
entry = entry->base.next) {
print_indent();
print_string(entry->base.symbol->string);
if (entry->enum_value.value != NULL) {
print_string(" = ");
print_expression(entry->enum_value.value);
}
print_string(",\n");
}
change_indent(-1);
print_indent();
print_char('}');
}
void repl(FILE *input, environment_t **env, int interactive) {
int check = 0;
do {
if (check == 0 && interactive < 2) {
printf("evaluate> ");
}
expression_t *ptr = read_expression(input);
if (ptr != NULL) {
//print_expression(ptr); printf(" = "); print_expression(evaluate_expression(ptr, env)); printf("\n");
print_expression(evaluate_expression(ptr, env)); printf("\n");
if (check != 0) {
check = 0;
}
} else {
check = 1;
}
} while (1);
}
