return true;
}
+static size_t ast_type_to_string_impl(ast_expression *e, char *buf, size_t bufsize, size_t pos)
+{
+ const char *typestr;
+ size_t typelen;
+ size_t i;
+
+ if (!e) {
+ if (pos + 6 >= bufsize)
+ goto full;
+ strcpy(buf + pos, "(null)");
+ return pos + 6;
+ }
+
+ if (pos + 1 >= bufsize)
+ goto full;
+
+ switch (e->expression.vtype) {
+ case TYPE_VARIANT:
+ strcpy(buf + pos, "(variant)");
+ return pos + 9;
+
+ case TYPE_FIELD:
+ buf[pos++] = '.';
+ return ast_type_to_string_impl(e->expression.next, buf, bufsize, pos);
+
+ case TYPE_POINTER:
+ if (pos + 3 >= bufsize)
+ goto full;
+ buf[pos++] = '*';
+ buf[pos++] = '(';
+ pos = ast_type_to_string_impl(e->expression.next, buf, bufsize, pos);
+ if (pos + 1 >= bufsize)
+ goto full;
+ buf[pos++] = ')';
+ return pos;
+
+ case TYPE_FUNCTION:
+ pos = ast_type_to_string_impl(e->expression.next, buf, bufsize, pos);
+ if (pos + 2 >= bufsize)
+ goto full;
+ if (e->expression.params_count == 0) {
+ buf[pos++] = '(';
+ buf[pos++] = ')';
+ return pos;
+ }
+ buf[pos++] = '(';
+ pos = ast_type_to_string_impl((ast_expression*)(e->expression.params[0]), buf, bufsize, pos);
+ for (i = 1; i < e->expression.params_count; ++i) {
+ if (pos + 2 >= bufsize)
+ goto full;
+ buf[pos++] = ',';
+ buf[pos++] = ' ';
+ pos = ast_type_to_string_impl((ast_expression*)(e->expression.params[i]), buf, bufsize, pos);
+ }
+ if (pos + 1 >= bufsize)
+ goto full;
+ buf[pos++] = ')';
+ return pos;
+
+ default:
+ typestr = type_name[e->expression.vtype];
+ typelen = strlen(typestr);
+ if (pos + typelen >= bufsize)
+ goto full;
+ strcpy(buf + pos, typestr);
+ return pos + typelen;
+ }
+
+full:
+ buf[bufsize-3] = '.';
+ buf[bufsize-2] = '.';
+ buf[bufsize-1] = '.';
+ return bufsize;
+}
+
+void ast_type_to_string(ast_expression *e, char *buf, size_t bufsize)
+{
+ size_t pos = ast_type_to_string_impl(e, buf, bufsize-1, 0);
+ buf[pos] = 0;
+}
+
ast_value* ast_value_new(lex_ctx ctx, const char *name, int t)
{
ast_instantiate(ast_value, ctx, ast_value_delete);
self->expression.vtype = t;
self->expression.next = NULL;
self->isconst = false;
+ self->uses = 0;
memset(&self->constval, 0, sizeof(self->constval));
self->ir_v = NULL;
mem_d(self);
}
+bool ast_call_check_types(ast_call *self)
+{
+ size_t i;
+ bool retval = true;
+ const ast_expression *func = self->func;
+ size_t count = self->params_count;
+ if (count > func->expression.params_count)
+ count = func->expression.params_count;
+
+ for (i = 0; i < count; ++i) {
+ if (!ast_compare_type(self->params[i], (ast_expression*)(func->expression.params[i]))) {
+ asterror(ast_ctx(self), "invalid type for parameter %u in function call",
+ (unsigned int)(i+1));
+ /* we don't immediately return */
+ retval = false;
+ }
+ }
+ return retval;
+}
+
ast_store* ast_store_new(lex_ctx ctx, int op,
ast_expression *dest, ast_expression *source)
{
self->dest = dest;
self->source = source;
+ self->expression.vtype = dest->expression.vtype;
+ if (dest->expression.next) {
+ self->expression.next = ast_type_copy(ctx, dest);
+ if (!self->expression.next) {
+ ast_delete(self);
+ return NULL;
+ }
+ }
+ else
+ self->expression.next = NULL;
+
return self;
}
mem_d(self);
}
-static void ast_util_hexitoa(char *buf, size_t size, unsigned int num)
+const char* ast_function_label(ast_function *self, const char *prefix)
{
- unsigned int base = 10;
-#define checknul() do { if (size == 1) { *buf = 0; return; } } while (0)
-#define addch(x) do { *buf++ = (x); --size; checknul(); } while (0)
- if (size < 1)
- return;
- checknul();
- if (!num)
- addch('0');
- else {
- while (num)
- {
- int digit = num % base;
- num /= base;
- addch('0' + digit);
- }
- }
+ size_t id;
+ size_t len;
+ char *from;
- *buf = 0;
-#undef addch
-#undef checknul
-}
+ if (!opts_dump)
+ return NULL;
-const char* ast_function_label(ast_function *self, const char *prefix)
-{
- size_t id = (self->labelcount++);
- size_t len = strlen(prefix);
- strncpy(self->labelbuf, prefix, sizeof(self->labelbuf));
- ast_util_hexitoa(self->labelbuf + len, sizeof(self->labelbuf)-len, id);
- return self->labelbuf;
+ id = (self->labelcount++);
+ len = strlen(prefix);
+
+ from = self->labelbuf + sizeof(self->labelbuf)-1;
+ *from-- = 0;
+ do {
+ unsigned int digit = id % 10;
+ *from = digit + '0';
+ id /= 10;
+ } while (id);
+ memcpy(from - len, prefix, len);
+ return from - len;
}
/*********************************************************************/
if (!func)
return false;
func->context = ast_ctx(self);
+ func->value->context = ast_ctx(self);
self->constval.vfunc->ir_func = func;
self->ir_v = func->value;
* Note: an ast-representation using the comma-operator
* of the form: (a, b, c) = x should not assign to c...
*/
- (void)lvalue;
+ if (lvalue) {
+ asterror(ast_ctx(self), "not an l-value (code-block)");
+ return false;
+ }
+
if (self->expression.outr) {
*out = self->expression.outr;
return true;
/* generate locals */
for (i = 0; i < self->locals_count; ++i)
{
- if (!ast_local_codegen(self->locals[i], func->ir_func, false))
+ if (!ast_local_codegen(self->locals[i], func->ir_func, false)) {
+ if (opts_debug)
+ asterror(ast_ctx(self), "failed to generate local `%s`", self->locals[i]->name);
return false;
+ }
}
for (i = 0; i < self->exprs_count; ++i)
ast_expression_codegen *cgen;
ir_value *left, *right;
- /* In the context of a binary operation, we can disregard
- * the lvalue flag.
- */
- (void)lvalue;
+ /* A binary operation cannot yield an l-value */
+ if (lvalue) {
+ asterror(ast_ctx(self), "not an l-value (binop)");
+ return false;
+ }
+
if (self->expression.outr) {
*out = self->expression.outr;
return true;
ast_expression_codegen *cgen;
ir_value *operand;
- /* In the context of a unary operation, we can disregard
- * the lvalue flag.
- */
- (void)lvalue;
+ /* An unary operation cannot yield an l-value */
+ if (lvalue) {
+ asterror(ast_ctx(self), "not an l-value (binop)");
+ return false;
+ }
+
if (self->expression.outr) {
*out = self->expression.outr;
return true;
ast_expression_codegen *cgen;
ir_value *operand;
- /* In the context of a return operation, we can disregard
- * the lvalue flag.
+ /* In the context of a return operation, we don't actually return
+ * anything...
*/
- (void)lvalue;
+ if (lvalue) {
+ asterror(ast_ctx(self), "return-expression is not an l-value");
+ return false;
+ }
+
if (self->expression.outr) {
asterror(ast_ctx(self), "internal error: ast_return cannot be reused, it bears no result!");
return false;
ir_value *funval = NULL;
/* return values are never lvalues */
- (void)lvalue;
+ if (lvalue) {
+ asterror(ast_ctx(self), "not an l-value (function call)");
+ return false;
+ }
if (self->expression.outr) {
*out = self->expression.outr;