aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--compile.c87
-rw-r--r--examples/base64/base64.tm83
-rw-r--r--typecheck.c7
-rw-r--r--types.c2
4 files changed, 96 insertions, 83 deletions
diff --git a/compile.c b/compile.c
index 072b4dca..5f274335 100644
--- a/compile.c
+++ b/compile.c
@@ -1590,6 +1590,8 @@ CORD compile_to_pointer_depth(env_t *env, ast_t *ast, int64_t target_depth, bool
static CORD compile_to_type(env_t *env, ast_t *ast, type_t *t)
{
+ if (ast->tag == Int && is_numeric_type(t))
+ return compile_int_to_type(env, ast, t);
CORD code = compile(env, ast);
type_t *actual = get_type(env, ast);
if (!promote(env, &code, actual, t))
@@ -1636,29 +1638,37 @@ CORD compile_int_to_type(env_t *env, ast_t *ast, type_t *target)
if (mpz_cmp_si(i, UINT8_MAX) <= 0 && mpz_cmp_si(i, 0) >= 0)
return CORD_asprintf("(Byte_t)(%s)", Match(ast, Int)->str);
code_err(ast, "This integer cannot fit in a byte");
+ } else if (target->tag == NumType) {
+ if (Match(target, NumType)->bits == TYPE_NBITS64) {
+ return CORD_asprintf("N64(%s)", Match(ast, Int)->str);
+ } else {
+ return CORD_asprintf("N32(%s)", Match(ast, Int)->str);
+ }
+ } else if (target->tag == IntType) {
+ int64_t target_bits = (int64_t)Match(target, IntType)->bits;
+ switch (target_bits) {
+ case TYPE_IBITS64:
+ if (mpz_cmp_si(i, INT64_MAX) <= 0 && mpz_cmp_si(i, INT64_MIN) >= 0)
+ return CORD_asprintf("I64(%s)", Match(ast, Int)->str);
+ break;
+ case TYPE_IBITS32:
+ if (mpz_cmp_si(i, INT32_MAX) <= 0 && mpz_cmp_si(i, INT32_MIN) >= 0)
+ return CORD_asprintf("I32(%s)", Match(ast, Int)->str);
+ break;
+ case TYPE_IBITS16:
+ if (mpz_cmp_si(i, INT16_MAX) <= 0 && mpz_cmp_si(i, INT16_MIN) >= 0)
+ return CORD_asprintf("I16(%s)", Match(ast, Int)->str);
+ break;
+ case TYPE_IBITS8:
+ if (mpz_cmp_si(i, INT8_MAX) <= 0 && mpz_cmp_si(i, INT8_MIN) >= 0)
+ return CORD_asprintf("I8(%s)", Match(ast, Int)->str);
+ break;
+ default: break;
+ }
+ code_err(ast, "This integer cannot fit in a %d-bit value", target_bits);
+ } else {
+ code_err(ast, "I don't know how to compile this to a %T", target);
}
-
- int64_t target_bits = (int64_t)Match(target, IntType)->bits;
- switch (target_bits) {
- case TYPE_IBITS64:
- if (mpz_cmp_si(i, INT64_MAX) <= 0 && mpz_cmp_si(i, INT64_MIN) >= 0)
- return CORD_asprintf("I64(%s)", Match(ast, Int)->str);
- break;
- case TYPE_IBITS32:
- if (mpz_cmp_si(i, INT32_MAX) <= 0 && mpz_cmp_si(i, INT32_MIN) >= 0)
- return CORD_asprintf("I32(%s)", Match(ast, Int)->str);
- break;
- case TYPE_IBITS16:
- if (mpz_cmp_si(i, INT16_MAX) <= 0 && mpz_cmp_si(i, INT16_MIN) >= 0)
- return CORD_asprintf("I16(%s)", Match(ast, Int)->str);
- break;
- case TYPE_IBITS8:
- if (mpz_cmp_si(i, INT8_MAX) <= 0 && mpz_cmp_si(i, INT8_MIN) >= 0)
- return CORD_asprintf("I8(%s)", Match(ast, Int)->str);
- break;
- default: break;
- }
- code_err(ast, "This integer cannot fit in a %d-bit value", target_bits);
}
CORD compile_arguments(env_t *env, ast_t *call_ast, arg_t *spec_args, arg_ast_t *call_args)
@@ -2079,26 +2089,21 @@ CORD compile(env_t *env, ast_t *ast)
}
}
- CORD lhs = compile(env, binop->lhs);
-
- // Special case for bit shifting by an integer literal:
- if (binop->op == BINOP_LSHIFT || binop->op == BINOP_RSHIFT || binop->op == BINOP_ULSHIFT || binop->op == BINOP_URSHIFT) {
- if ((lhs_t->tag == IntType || lhs_t->tag == ByteType) && rhs_t->tag == BigIntType && binop->rhs->tag == Int) {
- CORD shift_amount = compile_int_to_type(env, binop->rhs, lhs_t);
- if (binop->op == BINOP_LSHIFT)
- return CORD_all("(", lhs, " << ", shift_amount, ")");
- else if (binop->op == BINOP_ULSHIFT)
- return CORD_all("(", compile_type(lhs_t), ")((", compile_unsigned_type(lhs_t), ")", lhs, " << ", shift_amount, ")");
- else if (binop->op == BINOP_RSHIFT)
- return CORD_all("(", lhs, " >> ", shift_amount, ")");
- else if (binop->op == BINOP_URSHIFT)
- return CORD_all("(", compile_type(lhs_t), ")((", compile_unsigned_type(lhs_t), ")", lhs, " >> ", shift_amount, ")");
- }
+ CORD lhs, rhs;
+ if (lhs_t->tag == BigIntType && rhs_t->tag != BigIntType && is_numeric_type(rhs_t) && binop->lhs->tag == Int) {
+ lhs = compile_int_to_type(env, binop->lhs, rhs_t);
+ lhs_t = rhs_t;
+ rhs = compile(env, binop->rhs);
+ } else if (rhs_t->tag == BigIntType && lhs_t->tag != BigIntType && is_numeric_type(lhs_t) && binop->rhs->tag == Int) {
+ lhs = compile(env, binop->lhs);
+ rhs = compile_int_to_type(env, binop->rhs, lhs_t);
+ rhs_t = lhs_t;
+ } else {
+ lhs = compile(env, binop->lhs);
+ rhs = compile(env, binop->rhs);
}
- CORD rhs = compile(env, binop->rhs);
type_t *operand_t;
-
if (promote(env, &rhs, rhs_t, lhs_t))
operand_t = lhs_t;
else if (promote(env, &lhs, lhs_t, rhs_t))
@@ -3032,7 +3037,7 @@ CORD compile(env_t *env, ast_t *ast)
type_t *actual = get_type(env, call->args->value);
arg_t *args = new(arg_t, .name="i", .type=actual); // No truncation argument
CORD arg_code = compile_arguments(env, ast, args, call->args);
- if (is_numeric_type(actual) || actual->tag == ByteType) {
+ if (is_numeric_type(actual)) {
return CORD_all(type_to_cord(actual), "_to_", type_to_cord(t), "(", arg_code, ")");
} else if (actual->tag == BoolType) {
if (t->tag == NumType) {
@@ -3045,7 +3050,7 @@ CORD compile(env_t *env, ast_t *ast)
}
} else if (t->tag == IntType || t->tag == ByteType) {
type_t *actual = get_type(env, call->args->value);
- if (is_numeric_type(actual) || actual->tag == ByteType) {
+ if (is_numeric_type(actual)) {
arg_t *args = new(arg_t, .name="i", .type=actual, .next=new(arg_t, .name="truncate", .type=Type(BoolType),
.default_val=FakeAST(Bool, false)));
CORD arg_code = compile_arguments(env, ast, args, call->args);
diff --git a/examples/base64/base64.tm b/examples/base64/base64.tm
index e765d86a..f22883cd 100644
--- a/examples/base64/base64.tm
+++ b/examples/base64/base64.tm
@@ -5,22 +5,23 @@ _enc := "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/":utf8_
_EQUAL_BYTE := 0x3D[B]
_dec := [
- 255[B], 255[B], 255[B], 255[B], 255[B], 255[B], 255[B], 255[B],
- 255[B], 255[B], 255[B], 255[B], 255[B], 255[B], 255[B], 255[B],
- 255[B], 255[B], 255[B], 255[B], 255[B], 255[B], 255[B], 255[B],
- 255[B], 255[B], 255[B], 255[B], 255[B], 255[B], 255[B], 255[B],
- 255[B], 255[B], 255[B], 255[B], 255[B], 255[B], 255[B], 255[B],
- 255[B], 255[B], 255[B], 62[B], 255[B], 255[B], 255[B], 63[B],
- 52[B], 53[B], 54[B], 55[B], 56[B], 57[B], 58[B], 59[B],
- 60[B], 61[B], 255[B], 255[B], 255[B], 255[B], 255[B], 255[B],
- 255[B], 0[B], 1[B], 2[B], 3[B], 4[B], 5[B], 6[B],
- 7[B], 8[B], 9[B], 10[B], 11[B], 12[B], 13[B], 14[B],
- 15[B], 16[B], 17[B], 18[B], 19[B], 20[B], 21[B], 22[B],
- 23[B], 24[B], 25[B], 255[B], 255[B], 255[B], 255[B], 255[B],
- 255[B], 26[B], 27[B], 28[B], 29[B], 30[B], 31[B], 32[B],
- 33[B], 34[B], 35[B], 36[B], 37[B], 38[B], 39[B], 40[B],
- 41[B], 42[B], 43[B], 44[B], 45[B], 46[B], 47[B], 48[B],
- 49[B], 50[B], 51[B], 255[B], 255[B], 255[B], 255[B], 255[B],
+ :Byte
+ 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 62, 255, 255, 255, 63,
+ 52, 53, 54, 55, 56, 57, 58, 59,
+ 60, 61, 255, 255, 255, 255, 255, 255,
+ 255, 0, 1, 2, 3, 4, 5, 6,
+ 7, 8, 9, 10, 11, 12, 13, 14,
+ 15, 16, 17, 18, 19, 20, 21, 22,
+ 23, 24, 25, 255, 255, 255, 255, 255,
+ 255, 26, 27, 28, 29, 30, 31, 32,
+ 33, 34, 35, 36, 37, 38, 39, 40,
+ 41, 42, 43, 44, 45, 46, 47, 48,
+ 49, 50, 51, 255, 255, 255, 255, 255,
]
lang Base64:
@@ -31,32 +32,32 @@ lang Base64:
output := [0[B] for _ in bytes.length * 4 / 3 + 4]
src := 1[64]
dest := 1[64]
- while src + 2[64] <= bytes.length:
+ while src + 2 <= bytes.length:
chunk24 := (
- (Int32(bytes[src]) <<< 16) or (Int32(bytes[src+1[64]]) <<< 8) or Int32(bytes[src+2[64]])
+ (Int32(bytes[src]) <<< 16) or (Int32(bytes[src+1]) <<< 8) or Int32(bytes[src+2])
)
src += 3
- output[dest] = _enc[1[32] + ((chunk24 >>> 18) and 0b111111[32])]
- output[dest+1[64]] = _enc[1[32] + ((chunk24 >>> 12) and 0b111111[32])]
- output[dest+2[64]] = _enc[1[32] + ((chunk24 >>> 6) and 0b111111[32])]
- output[dest+3[64]] = _enc[1[32] + (chunk24 and 0b111111[32])]
+ output[dest] = _enc[1 + ((chunk24 >>> 18) and 0b111111)]
+ output[dest+1] = _enc[1 + ((chunk24 >>> 12) and 0b111111)]
+ output[dest+2] = _enc[1 + ((chunk24 >>> 6) and 0b111111)]
+ output[dest+3] = _enc[1 + (chunk24 and 0b111111)]
dest += 4
- if src + 1[64] == bytes.length:
+ if src + 1 == bytes.length:
chunk16 := (
- (Int32(bytes[src]) <<< 8) or Int32(bytes[src+1[64]])
+ (Int32(bytes[src]) <<< 8) or Int32(bytes[src+1])
)
- output[dest] = _enc[1[32] + ((chunk16 >>> 10) and 0b111111[32])]
- output[dest+1[64]] = _enc[1[32] + ((chunk16 >>> 4) and 0b111111[32])]
- output[dest+2[64]] = _enc[1[32] + ((chunk16 <<< 2)and 0b111111[32])]
- output[dest+3[64]] = _EQUAL_BYTE
+ output[dest] = _enc[1 + ((chunk16 >>> 10) and 0b11111)]
+ output[dest+1] = _enc[1 + ((chunk16 >>> 4) and 0b111111)]
+ output[dest+2] = _enc[1 + ((chunk16 <<< 2)and 0b111111)]
+ output[dest+3] = _EQUAL_BYTE
else if src == bytes.length:
chunk8 := Int32(bytes[src])
- output[dest] = _enc[1[32] + ((chunk8 >>> 2) and 0b111111[32])]
- output[dest+1[64]] = _enc[1[32] + ((chunk8 <<< 4) and 0b111111[32])]
- output[dest+2[64]] = _EQUAL_BYTE
- output[dest+3[64]] = _EQUAL_BYTE
+ output[dest] = _enc[1 + ((chunk8 >>> 2) and 0b111111)]
+ output[dest+1] = _enc[1 + ((chunk8 <<< 4) and 0b111111)]
+ output[dest+2] = _EQUAL_BYTE
+ output[dest+3] = _EQUAL_BYTE
return Base64.without_escaping(Text.from_bytes(output) or return !Base64)
@@ -68,21 +69,21 @@ lang Base64:
output := [0[B] for _ in bytes.length/4 * 3]
src := 1[64]
dest := 1[64]
- while src + 3[64] <= bytes.length:
+ while src + 3 <= bytes.length:
chunk24 := (
- (Int32(_dec[1[B]+bytes[src]]) <<< 18) or
- (Int32(_dec[1[B]+bytes[src+1[64]]]) <<< 12) or
- (Int32(_dec[1[B]+bytes[src+2[64]]]) <<< 6) or
- Int32(_dec[1[B]+bytes[src+3[64]]])
+ (Int32(_dec[1+bytes[src]]) <<< 18) or
+ (Int32(_dec[1+bytes[src+1]]) <<< 12) or
+ (Int32(_dec[1+bytes[src+2]]) <<< 6) or
+ Int32(_dec[1+bytes[src+3]])
)
src += 4
- output[dest] = Byte((chunk24 >>> 16) and 0xFF[32])
- output[dest+1[64]] = Byte((chunk24 >>> 8) and 0xFF[32])
- output[dest+2[64]] = Byte(chunk24 and 0xFF[32])
+ output[dest] = Byte((chunk24 >>> 16) and 0xFF)
+ output[dest+1] = Byte((chunk24 >>> 8) and 0xFF)
+ output[dest+2] = Byte(chunk24 and 0xFF)
dest += 3
- while output[-1] == 0xFF[B]:
+ while output[-1] == 0xFF:
output = output:to(-2)
return output
diff --git a/typecheck.c b/typecheck.c
index 44068f5a..38b6f7fb 100644
--- a/typecheck.c
+++ b/typecheck.c
@@ -900,6 +900,13 @@ type_t *get_type(env_t *env, ast_t *ast)
type_t *lhs_t = get_type(env, binop->lhs),
*rhs_t = get_type(env, binop->rhs);
+ if (lhs_t->tag == BigIntType && rhs_t->tag != BigIntType && is_numeric_type(rhs_t) && binop->lhs->tag == Int) {
+ lhs_t = rhs_t;
+ } else if (rhs_t->tag == BigIntType && lhs_t->tag != BigIntType && is_numeric_type(lhs_t) && binop->rhs->tag == Int) {
+
+ rhs_t = lhs_t;
+ }
+
#define binding_works(name, self, lhs_t, rhs_t, ret_t) \
({ binding_t *b = get_namespace_binding(env, self, name); \
(b && b->type->tag == FunctionType && ({ auto fn = Match(b->type, FunctionType); \
diff --git a/types.c b/types.c
index ddb3f076..8fcff830 100644
--- a/types.c
+++ b/types.c
@@ -394,7 +394,7 @@ PUREFUNC bool is_int_type(type_t *t)
PUREFUNC bool is_numeric_type(type_t *t)
{
- return t->tag == IntType || t->tag == BigIntType || t->tag == NumType;
+ return t->tag == IntType || t->tag == BigIntType || t->tag == NumType || t->tag == ByteType;
}
PUREFUNC size_t unpadded_struct_size(type_t *t)
generated by cgit v1.2.3 (git 2.25.1) at 2026-03-01 10:14:19 +0000