void asm_declare_stringlit(enum section_type sec, const stringlit *lit)
{
FILE *const f = cc_out[sec];
/* could be SECTION_RODATA */
asm_nam_begin3(sec, lit->lbl, /*align:*/1);
if(lit->wide){
const char *join = "";
size_t i;
fprintf(f, ".long ");
for(i = 0; i < lit->len; i++){
fprintf(f, "%s%d", join, lit->str[i]);
join = ", ";
}
}else{
fprintf(f, ".ascii \"");
literal_print(f, lit->str, lit->len);
fputc('"', f);
}
fputc('\n', f);
}
void dump_strliteral_indent(dump *ctx, int indent, const char *str, size_t len)
{
if(indent)
dump_indent(ctx);
fprintf(ctx->fout, "%s\"", maybe_colour(ctx->fout, col_strlit));
literal_print(ctx->fout, str, len);
fprintf(ctx->fout, "\"%s\n", maybe_colour(ctx->fout, col_off));
}
void gen_expr_str_str(expr *e)
{
FILE *f = gen_file();
stringlit *lit = e->bits.strlit.lit_at.lit;
idt_printf("%sstring at %s\n", lit->wide ? "wide " : "", lit->lbl);
gen_str_indent++;
idt_print();
literal_print(f,
e->bits.strlit.lit_at.lit->str,
e->bits.strlit.lit_at.lit->len);
gen_str_indent--;
fputc('\n', f);
}
void gen_expr_style_str(expr *e)
{
literal_print(gen_file(),
e->bits.strlit.lit_at.lit->str,
e->bits.strlit.lit_at.lit->len);
}
struct type *expr_typecheck(struct expr *e){
if (e == NULL) {
return type_create(TYPE_VOID,0,0,0);
}
struct type *l = malloc(sizeof(struct type));
struct type *r = malloc(sizeof(struct type));
switch (e->kind){
case (EXPR_ADD):
l = expr_typecheck(e->left);
r = expr_typecheck(e->right);
if ((l->kind != TYPE_INTEGER) || (r->kind != TYPE_INTEGER)){
error_counter += 1;
printf("Error #%i ",error_counter);
printf("type error: cannot add ");
type_print(l);
literal_print(e->left);
printf(" to ");
type_print(r);
literal_print(e->right);
printf("\n");
e->type = 0;
} else {
e->type = type_create(TYPE_INTEGER,0,0,0);
}
break;
case (EXPR_SUB):
l = expr_typecheck(e->left);
r = expr_typecheck(e->right);
if ((l->kind != TYPE_INTEGER) || (r->kind != TYPE_INTEGER)){
error_counter += 1;
printf("Error #%i ",error_counter);
printf("type error: cannot subtract ");
type_print(l);
literal_print(e->left);
printf(" from ");
type_print(r);
literal_print(e->right);
printf("\n");
e->type = 0;
} else {
e->type = type_create(TYPE_INTEGER,0,0,0);
}
break;
case (EXPR_MUL):
l = expr_typecheck(e->left);
r = expr_typecheck(e->right);
if ((l->kind != TYPE_INTEGER) || (r->kind != TYPE_INTEGER)){
error_counter += 1;
printf("Error #%i ",error_counter);
printf("type error: cannot multiply ");
type_print(l);
literal_print(e->left);
printf(" and ");
type_print(r);
literal_print(e->right);
printf("\n");
e->type = 0;
} else {
e->type = type_create(TYPE_INTEGER,0,0,0);
}
break;
case (EXPR_DIV):
l = expr_typecheck(e->left);
r = expr_typecheck(e->right);
if ((l->kind != TYPE_INTEGER) || (r->kind != TYPE_INTEGER)){
error_counter += 1;
printf("Error #%i ",error_counter);
printf("type error: cannot divide ");
type_print(l);
literal_print(e->left);
printf(" by ");
type_print(r);
literal_print(e->right);
printf("\n");
e->type = 0;
} else {
e->type = type_create(TYPE_INTEGER,0,0,0);
}
break;
case (EXPR_INCREMENT):
l = expr_typecheck(e->left);
if (l->kind != TYPE_INTEGER){
error_counter += 1;
printf("Error #%i ",error_counter);
printf("type error: cannot increment ");
type_print(l);
literal_print(e->left);
printf("\n");
e->type = 0;
} else {
e->type = type_create(TYPE_INTEGER,0,0,0);
}
break;
case (EXPR_DECREMENT):
l = expr_typecheck(e->left);
if (l->kind != TYPE_INTEGER){
error_counter += 1;
printf("Error #%i ",error_counter);
printf("type error: cannot decrement ");
type_print(l);
literal_print(e->left);
printf("\n");
e->type = 0;
} else {
e->type = type_create(TYPE_INTEGER,0,0,0);
}
break;
case (EXPR_NOT):
r = expr_typecheck(e->right);
if (r->kind != TYPE_BOOLEAN){
error_counter += 1;
printf("Error #%i ",error_counter);
printf("type error: cannot negate ");
type_print(r);
literal_print(e->right);
printf("\n");
e->type = 0;
} else {
e->type = type_create(TYPE_BOOLEAN,0,0,0);
}
break;
case (EXPR_POWER):
l = expr_typecheck(e->left);
r = expr_typecheck(e->right);
if ((l->kind != TYPE_INTEGER) || (r->kind != TYPE_INTEGER)){
error_counter += 1;
printf("Error #%i ",error_counter);
printf("type error: cannot raise ");
type_print(l);
literal_print(e->left);
printf(" to power ");
type_print(r);
literal_print(e->right);
printf("\n");
e->type = 0;
} else {
e->type = type_create(TYPE_INTEGER,0,0,0);
}
break;
case (EXPR_MODULO):
l = expr_typecheck(e->left);
r = expr_typecheck(e->right);
if ((l->kind != TYPE_INTEGER) || (r->kind != TYPE_INTEGER)){
error_counter += 1;
printf("Error #%i ",error_counter);
printf("type error: cannot take modulus of ");
type_print(l);
literal_print(e->left);
printf(" and ");
type_print(r);
literal_print(e->right);
printf("\n");
e->type = 0;
} else {
e->type = type_create(TYPE_INTEGER,0,0,0);
}
break;
case (EXPR_LESS_THAN):
l = expr_typecheck(e->left);
r = expr_typecheck(e->right);
if ((l->kind != TYPE_INTEGER) || (r->kind != TYPE_INTEGER)){
error_counter += 1;
printf("Error #%i ",error_counter);
printf("type error: cannot compare ");
type_print(l);
literal_print(e->left);
printf(" to ");
type_print(r);
literal_print(e->right);
printf("\n");
e->type = 0;
} else {
e->type = type_create(TYPE_BOOLEAN,0,0,0);
}
break;
case (EXPR_GREATER_THAN):
l = expr_typecheck(e->left);
r = expr_typecheck(e->right);
if ((l->kind != TYPE_INTEGER) || (r->kind != TYPE_INTEGER)){
error_counter += 1;
printf("Error #%i ",error_counter);
printf("type error: cannot compare ");
type_print(l);
literal_print(e->left);
printf(" to ");
type_print(r);
literal_print(e->right);
printf("\n");
e->type = 0;
} else {
e->type = type_create(TYPE_BOOLEAN,0,0,0);
}
break;
case (EXPR_LESS_THAN_OR_EQUAL):
l = expr_typecheck(e->left);
r = expr_typecheck(e->right);
if ((l->kind != TYPE_INTEGER) || (r->kind != TYPE_INTEGER)){
error_counter += 1;
printf("Error #%i ",error_counter);
printf("type error: cannot compare ");
type_print(l);
literal_print(e->left);
printf(" to ");
type_print(r);
literal_print(e->right);
printf("\n");
e->type = 0;
} else {
e->type = type_create(TYPE_BOOLEAN,0,0,0);
}
break;
case (EXPR_GREATER_THAN_OR_EQUAL):
l = expr_typecheck(e->left);
r = expr_typecheck(e->right);
if ((l->kind != TYPE_INTEGER) || (r->kind != TYPE_INTEGER)){
error_counter += 1;
printf("Error #%i ",error_counter);
printf("type error: cannot compare ");
type_print(l);
literal_print(e->left);
printf(" to ");
type_print(r);
literal_print(e->right);
printf("\n");
e->type = 0;
} else {
e->type = type_create(TYPE_BOOLEAN,0,0,0);
}
break;
case (EXPR_EQUIVALENCE_COMPARISON):
l = expr_typecheck(e->left);
r = expr_typecheck(e->right);
if ((l->kind == TYPE_FUNCTION) || (r->kind == TYPE_FUNCTION)){
error_counter += 1;
printf("Error #%i ",error_counter);
printf("type error: cannot compare equivalence of functions\n");
e->type = 0;
} else if ((l->kind == TYPE_ARRAY) || (r->kind == TYPE_ARRAY)){
error_counter += 1;
printf("Error #%i ",error_counter);
printf("type error: cannot compare equivalence of arrays\n");
e->type = 0;
} else if (l->kind != r->kind){
error_counter += 1;
printf("Error #%i ",error_counter);
printf("type error: cannot compare equivalence of ");
type_print(l);
literal_print(e->left);
printf(" to ");
type_print(r);
literal_print(e->right);
printf("\n");
e->type = 0;
} else {
e->type = type_create(TYPE_BOOLEAN,0,0,0);
}
break;
case (EXPR_NONEQUIVALENCE_COMPARISON):
l = expr_typecheck(e->left);
r = expr_typecheck(e->right);
if ((l->kind == TYPE_FUNCTION) || (r->kind == TYPE_FUNCTION)){
error_counter += 1;
printf("Error #%i ",error_counter);
printf("type error: cannot compare equivalence of functions\n");
e->type = 0;
} else if ((l->kind == TYPE_ARRAY) || (r->kind == TYPE_ARRAY)){
error_counter += 1;
printf("Error #%i ",error_counter);
printf("type error: cannot compare equivalence of arrays\n");
e->type = 0;
} else if (l->kind != r->kind){
error_counter += 1;
printf("Error #%i ",error_counter);
printf("type error: cannot compare equivalence of ");
type_print(l);
literal_print(e->left);
printf(" to ");
type_print(r);
literal_print(e->right);
printf("\n");
e->type = 0;
} else {
e->type = type_create(TYPE_BOOLEAN,0,0,0);
}
break;
case (EXPR_AND):
l = expr_typecheck(e->left);
r = expr_typecheck(e->right);
if ((l->kind != TYPE_BOOLEAN) || (r->kind != TYPE_BOOLEAN)){
error_counter += 1;
printf("Error #%i ",error_counter);
printf("type error: cannot compare ");
type_print(l);
literal_print(e->left);
printf(" to ");
type_print(r);
literal_print(e->right);
printf("\n");
e->type = 0;
} else {
e->type = type_create(TYPE_BOOLEAN,0,0,0);
}
break;
case (EXPR_OR):
l = expr_typecheck(e->left);
r = expr_typecheck(e->right);
if ((l->kind != TYPE_BOOLEAN) || (r->kind != TYPE_BOOLEAN)){
error_counter += 1;
printf("Error #%i ",error_counter);
printf("type error: cannot compare ");
type_print(l);
literal_print(e->left);
printf(" to ");
type_print(r);
literal_print(e->right);
printf("\n");
e->type = 0;
} else {
e->type = type_create(TYPE_BOOLEAN,0,0,0);
}
break;
case (EXPR_ASSIGNMENT):
l = expr_typecheck(e->left);
r = expr_typecheck(e->right);
//if ((l->kind == TYPE_FUNCTION) || (r->kind == TYPE_FUNCTION)){
if (l->kind == TYPE_FUNCTION){
error_counter += 1;
printf("Error #%i ",error_counter);
printf("type error: cannot assign a function\n");
e->type = 0;
} else if (l->kind != r->kind) {
error_counter += 1;
printf("Error #%i ",error_counter);
printf("type error: cannot assign ");
type_print(l);
literal_print(e->left);
printf(" to ");
type_print(r);
literal_print(e->right);
printf("\n");
e->type = 0;
} else {
e->type = type_create(l->kind,0,0,0);
}
break;
case (EXPR_BOOLEAN_LITERAL):
e->type = type_create(TYPE_BOOLEAN, 0, 0, 0);
break;
case (EXPR_INTEGER_LITERAL):
e->type = type_create(TYPE_INTEGER, 0, 0, 0);
break;
case (EXPR_CHARACTER_LITERAL):
e->type = type_create(TYPE_CHARACTER, 0, 0, 0);
break;
case (EXPR_STRING_LITERAL):
e->type = type_create(TYPE_STRING, 0, 0, 0);
break;
case (EXPR_IDENTIFIER):
e->type = e->symbol->type;
break;
case (EXPR_PARENTHESES):
e->type = expr_typecheck(e->left);
break;
case (EXPR_FUNCTION_CALL):
param_list_typecheck();
e->type = e->left->symbol->type->subtype;
break;
case (EXPR_ARRAY_INDEX):
e->type = type_create(TYPE_ARRAY, 0, 0, 0);
break;
}
return e->type;
}
