static void Term_print(ExprTerm term) {
switch (term.t) {
case TERM_ID:
printf("%s", term.id);
break;
case TERM_LITERAL:
Literal_print(term.val);
break;
case TERM_NULL:
printf("NULL");
break;
case TERM_COLREF:
if (term.ref->tableName)
printf("%s.", term.ref->tableName);
printf("%s", term.ref->columnName);
break;
case TERM_FUNC:
switch (term.f.t) {
case FUNC_AVG:
printf("AVG(");
Expression_print(term.f.expr);
printf(")");
break;
case FUNC_COUNT:
printf("COUNT(");
Expression_print(term.f.expr);
printf(")");
break;
case FUNC_MAX:
printf("MAX(");
Expression_print(term.f.expr);
printf(")");
break;
case FUNC_MIN:
printf("MIN(");
Expression_print(term.f.expr);
printf(")");
break;
case FUNC_SUM:
printf("SUM(");
Expression_print(term.f.expr);
printf(")");
break;
default:
printf("Unknown function");
}
break;
default:
printf("Unknown term type");
}
}
void Expression_printList (Expression_t *expr) {
int first = 1;
printf("[");
while (expr) {
if (first) first = 0; else printf(", ");
Expression_print(expr);
expr = expr->next;
}
printf("]");
}
enum TermType Expression_type(Expression_t *expr) {
enum TermType t1, t2;
switch (expr->t) {
case EXPR_TERM:
return expr->expr.term.t;
case EXPR_NEG:
return Expression_type(expr->expr.unary.expr);
default:
t1 = Expression_type(expr->expr.binary.expr1);
t2 = Expression_type(expr->expr.binary.expr2);
if (t1 != t2) {
fprintf(stderr, "Type mismatch on binary expression:\n");
Expression_print(expr->expr.binary.expr1);
fprintf(stderr, "\nis not the same type as\n");
Expression_print(expr->expr.binary.expr2);
exit(1);
}
return t1;
}
}
int main(int argc, char const *argv[])
{
Expression_t *a = Term("a"),
*b = Term("b"),
*c = TermLiteral(litInt(5)),
*plus = Plus(a,b),
*mult = Multiply(plus, c);
Expression_print(mult);
append_expression(mult, plus);
puts("");
Expression_printList(mult);
puts("");
return 0;
}
void Condition_print(Condition_t *cond)
{
if (!cond) return; /* just in case */
switch(cond->t)
{
case RA_COND_EQ:
Expression_print(cond->cond.comp.expr1);
printf(" = ");
Expression_print(cond->cond.comp.expr2);
break;
case RA_COND_LT:
Expression_print(cond->cond.comp.expr1);
printf(" < ");
Expression_print(cond->cond.comp.expr2);
break;
case RA_COND_GT:
Expression_print(cond->cond.comp.expr1);
printf(" > ");
Expression_print(cond->cond.comp.expr2);
break;
case RA_COND_LEQ:
Expression_print(cond->cond.comp.expr1);
printf(" <= ");
Expression_print(cond->cond.comp.expr2);
break;
case RA_COND_GEQ:
Expression_print(cond->cond.comp.expr1);
printf(" >= ");
Expression_print(cond->cond.comp.expr2);
break;
case RA_COND_AND:
Condition_print(cond->cond.binary.cond1);
printf(" and ");
Condition_print(cond->cond.binary.cond2);
break;
case RA_COND_OR:
Condition_print(cond->cond.binary.cond1);
printf(" or ");
Condition_print(cond->cond.binary.cond2);
break;
case RA_COND_NOT:
if (cond->cond.unary.cond->t == RA_COND_EQ)
{
Expression_print(cond->cond.unary.cond->cond.comp.expr1);
printf(" != ");
Expression_print(cond->cond.unary.cond->cond.comp.expr2);
}
else
{
printf("not (");
Condition_print(cond->cond.unary.cond);
printf(")");
}
break;
case RA_COND_IN:
Expression_print(cond->cond.in.expr);
printf(" in ");
Literal_printList(cond->cond.in.values_list);
break;
default:
puts("Unknown condession type");
}
}
int main(int argc, char* argv[]) {
Context* ctx = Context_new();
register_math(ctx);
for(nextLine(); !feof(stdin); nextLine()) {
/* Strip trailing newline */
char* end;
if((end = strchr(line, '\n')) != NULL) *end = '\0';
if((end = strchr(line, '\r')) != NULL) *end = '\0';
if((end = strchr(line, '#')) != NULL) *end = '\0';
const char* p = line;
/* Get verbosity level */
int verbose = 0;
while(p[0] == '?') {
verbose++;
p++;
}
trimSpaces(&p);
if(*p == '~') {
/* Variable deletion */
p++;
char* name = nextToken(&p);
if(name == NULL) {
/* '~~~' means reset interpreter */
if(p[0] == '~' && p[1] == '~') {
/* Wipe out context */
Context_free(ctx);
ctx = Context_new();
register_math(ctx);
continue;
}
if(*p == '\0') {
RAISE(earlyEnd());
continue;
}
RAISE(badChar(*p));
continue;
}
Context_del(ctx, name);
free(name);
continue;
}
/* Parse the user's input */
Expression* expr = Expression_parse(&p);
/* Print expression depending on verbosity */
Expression_print(expr, ctx, verbose);
/* Error? Go to next loop iteration */
if(Expression_didError(expr)) {
Expression_free(expr);
continue;
}
/* Evaluate expression */
Value* result = Expression_eval(expr, ctx);
Expression_free(expr);
/* Print result */
Value_print(result, ctx);
Value_free(result);
}
Context_free(ctx);
return 0;
}
void Expression_print(Expression_t *expr) {
if (expr->t != EXPR_TERM) printf("(");
switch (expr->t) {
case EXPR_CONCAT:
Expression_print(expr->expr.binary.expr1);
printf(" || ");
Expression_print(expr->expr.binary.expr2);
break;
case EXPR_PLUS:
Expression_print(expr->expr.binary.expr1);
printf(" + ");
Expression_print(expr->expr.binary.expr2);
break;
case EXPR_MINUS:
Expression_print(expr->expr.binary.expr1);
printf(" - ");
Expression_print(expr->expr.binary.expr2);
break;
case EXPR_MULTIPLY:
Expression_print(expr->expr.binary.expr1);
printf(" * ");
Expression_print(expr->expr.binary.expr2);
break;
case EXPR_DIVIDE:
Expression_print(expr->expr.binary.expr1);
printf(" / ");
Expression_print(expr->expr.binary.expr2);
break;
case EXPR_NEG:
printf("-");
Expression_print(expr->expr.unary.expr);
break;
case EXPR_TERM:
Term_print(expr->expr.term);
break;
default:
printf("(Unknown expression type '%d')", expr->t);
}
if (expr->t != EXPR_TERM) printf(")");
if (expr->alias) printf(" as %s", expr->alias);
}
