From f60c772c11154d16c12d30a7f19c2c2e07068642 Mon Sep 17 00:00:00 2001 From: Ginger Bill Date: Tue, 6 Jun 2017 23:54:33 +0100 Subject: [PATCH] Make `rune` a basic type and not an alias; Remove `byte` --- core/_preload.odin | 31 +++++++++-------- core/decimal.odin | 18 +++++----- core/fmt.odin | 80 ++++++++++++++++++++++++------------------- core/hash.odin | 16 ++++----- core/mem.odin | 8 ++--- core/opengl.odin | 10 +++--- core/os.odin | 8 ++--- core/os_linux.odin | 6 ++-- core/os_windows.odin | 34 +++++++++--------- core/os_x.odin | 6 ++-- core/raw.odin | 2 +- core/strconv.odin | 32 ++++++++--------- core/strings.odin | 8 ++--- core/sys/wgl.odin | 44 ++++++++++++------------ core/sys/windows.odin | 22 ++++++------ core/utf8.odin | 42 +++++++++++------------ src/check_expr.c | 26 +++++++++++--- src/checker.c | 53 ++++++++++++++-------------- src/ir.c | 4 +++ src/ir_print.c | 2 ++ src/tokenizer.c | 6 ++-- src/types.c | 33 ++++++++++++------ 22 files changed, 270 insertions(+), 221 deletions(-) diff --git a/core/_preload.odin b/core/_preload.odin index f85c5b5e3..c13622c4e 100644 --- a/core/_preload.odin +++ b/core/_preload.odin @@ -52,6 +52,7 @@ TypeInfo :: union { Named{name: string, base: ^TypeInfo}, Integer{signed: bool}, + Rune{}, Float{}, Complex{}, String{}, @@ -110,7 +111,7 @@ TypeInfo :: union { // This will be set by the compiler __type_table: []TypeInfo; -__argv__: ^^byte; +__argv__: ^^u8; __argc__: i32; type_info_base :: proc(info: ^TypeInfo) -> ^TypeInfo { @@ -376,8 +377,8 @@ __string_decode_rune :: proc(s: string) -> (rune, int) #inline { __mem_set :: proc(data: rawptr, value: i32, len: int) -> rawptr { - llvm_memset_64bit :: proc(dst: rawptr, val: byte, len: int, align: i32, is_volatile: bool) #foreign __llvm_core "llvm.memset.p0i8.i64"; - llvm_memset_64bit(data, byte(value), len, 1, false); + llvm_memset_64bit :: proc(dst: rawptr, val: u8, len: int, align: i32, is_volatile: bool) #foreign __llvm_core "llvm.memset.p0i8.i64"; + llvm_memset_64bit(data, u8(value), len, 1, false); return data; } __mem_zero :: proc(data: rawptr, len: int) -> rawptr { @@ -396,7 +397,7 @@ __mem_copy_non_overlapping :: proc(dst, src: rawptr, len: int) -> rawptr { return dst; } -__mem_compare :: proc(a, b: ^byte, n: int) -> int { +__mem_compare :: proc(a, b: ^u8, n: int) -> int { for i in 0.. 0 { - data := ^byte(slice.data); + data := ^u8(slice.data); assert(data != nil); __mem_copy(data + (elem_size*slice.len), items, elem_size * item_count); slice.len += item_count; @@ -537,8 +538,8 @@ __slice_append :: proc(slice_: rawptr, elem_size, elem_align: int, // Map stuff -__default_hash :: proc(data: []byte) -> u128 { - fnv128a :: proc(data: []byte) -> u128 { +__default_hash :: proc(data: []u8) -> u128 { + fnv128a :: proc(data: []u8) -> u128 { h: u128 = 0x6c62272e07bb014262b821756295c58d; for b in data { h = (h ~ u128(b)) * 0x1000000000000000000013b; @@ -548,7 +549,7 @@ __default_hash :: proc(data: []byte) -> u128 { return fnv128a(data); } __default_hash_string :: proc(s: string) -> u128 { - return __default_hash([]byte(s)); + return __default_hash([]u8(s)); } __INITIAL_MAP_CAP :: 16; @@ -606,7 +607,7 @@ __dynamic_map_rehash :: proc(using header: __MapHeader, new_count: int) { } entry_header := __dynamic_map_get_entry(header, i); - data := ^byte(entry_header); + data := ^u8(entry_header); fr := __dynamic_map_find(new_header, entry_header.key); j := __dynamic_map_add_entry(new_header, entry_header.key); @@ -619,7 +620,7 @@ __dynamic_map_rehash :: proc(using header: __MapHeader, new_count: int) { e := __dynamic_map_get_entry(new_header, j); e.next = fr.entry_index; - ndata := ^byte(e); + ndata := ^u8(e); __mem_copy(ndata+value_offset, data+value_offset, value_size); if __dynamic_map_full(new_header) { @@ -634,7 +635,7 @@ __dynamic_map_rehash :: proc(using header: __MapHeader, new_count: int) { __dynamic_map_get :: proc(h: __MapHeader, key: __MapKey) -> rawptr { index := __dynamic_map_find(h, key).entry_index; if index >= 0 { - data := ^byte(__dynamic_map_get_entry(h, index)); + data := ^u8(__dynamic_map_get_entry(h, index)); val := data + h.value_offset; return val; } @@ -666,7 +667,7 @@ __dynamic_map_set :: proc(using h: __MapHeader, key: __MapKey, value: rawptr) { { e := __dynamic_map_get_entry(h, index); e.key = key; - val := ^byte(e) + value_offset; + val := ^u8(e) + value_offset; __mem_copy(val, value, value_size); } @@ -733,7 +734,7 @@ __dynamic_map_delete :: proc(using h: __MapHeader, key: __MapKey) { } __dynamic_map_get_entry :: proc(using h: __MapHeader, index: int) -> ^__MapEntryHeader { - data := ^byte(m.entries.data) + index*entry_size; + data := ^u8(m.entries.data) + index*entry_size; return ^__MapEntryHeader(data); } diff --git a/core/decimal.odin b/core/decimal.odin index a758ea3af..a8713730d 100644 --- a/core/decimal.odin +++ b/core/decimal.odin @@ -3,14 +3,14 @@ // NOTE: This is only for floating point printing and nothing else Decimal :: struct { - digits: [384]byte, // big-endian digits + digits: [384]u8, // big-endian digits count: int, decimal_point: int, neg, trunc: bool, } -decimal_to_string :: proc(buf: []byte, a: ^Decimal) -> string { - digit_zero :: proc(buf: []byte) -> int { +decimal_to_string :: proc(buf: []u8, a: ^Decimal) -> string { + digit_zero :: proc(buf: []u8) -> int { for _, i in buf { buf[i] = '0'; } @@ -59,12 +59,12 @@ trim :: proc(a: ^Decimal) { assign :: proc(a: ^Decimal, i: u64) { - buf: [32]byte; + buf: [32]u8; n := 0; for i > 0 { j := i/10; i -= 10*j; - buf[n] = byte('0'+i); + buf[n] = u8('0'+i); n++; i = j; } @@ -110,7 +110,7 @@ shift_right :: proc(a: ^Decimal, k: uint) { c := uint(a.digits[r]); dig := n>>k; n &= mask; - a.digits[w] = byte('0' + dig); + a.digits[w] = u8('0' + dig); w++; n = n*10 + c - '0'; } @@ -119,7 +119,7 @@ shift_right :: proc(a: ^Decimal, k: uint) { dig := n>>k; n &= mask; if w < len(a.digits) { - a.digits[w] = byte('0' + dig); + a.digits[w] = u8('0' + dig); w++; } else if dig > 0 { a.trunc = true; @@ -145,7 +145,7 @@ shift_left :: proc(a: ^Decimal, k: uint) { rem := n - 10*quo; w--; if w < len(a.digits) { - a.digits[w] = byte('0' + rem); + a.digits[w] = u8('0' + rem); } else if rem != 0 { a.trunc = true; } @@ -157,7 +157,7 @@ shift_left :: proc(a: ^Decimal, k: uint) { rem := n - 10*quo; w--; if 0 <= w && w < len(a.digits) { - a.digits[w] = byte('0' + rem); + a.digits[w] = u8('0' + rem); } else if rem != 0 { a.trunc = true; } diff --git a/core/fmt.odin b/core/fmt.odin index 780183546..c1057a406 100644 --- a/core/fmt.odin +++ b/core/fmt.odin @@ -9,8 +9,8 @@ _BUFFER_SIZE :: 1<<12; StringBuffer :: union { - Static {buf: []byte}, - Dynamic{buf: [dynamic]byte}, + Static {buf: []u8}, + Dynamic{buf: [dynamic]u8}, } FmtInfo :: struct { @@ -33,14 +33,14 @@ FmtInfo :: struct { } -make_string_buffer_from_slice :: proc(b: []byte) -> StringBuffer { +make_string_buffer_from_slice :: proc(b: []u8) -> StringBuffer { return StringBuffer.Static{b}; } make_string_dynamic_buffer :: proc() -> StringBuffer { - return StringBuffer.Dynamic{make([dynamic]byte)}; + return StringBuffer.Dynamic{make([dynamic]u8)}; } -string_buffer_data :: proc(buf: ^StringBuffer) -> []byte { +string_buffer_data :: proc(buf: ^StringBuffer) -> []u8 { match b in buf { case StringBuffer.Static: return b.buf[..]; @@ -49,7 +49,7 @@ string_buffer_data :: proc(buf: ^StringBuffer) -> []byte { } return nil; } -string_buffer_data :: proc(buf: StringBuffer) -> []byte { +string_buffer_data :: proc(buf: StringBuffer) -> []u8 { match b in buf { case StringBuffer.Static: return b.buf[..]; @@ -64,9 +64,9 @@ to_string :: proc(buf: StringBuffer) -> string { write_string :: proc(buf: ^StringBuffer, s: string) { - write_bytes(buf, []byte(s)); + write_bytes(buf, []u8(s)); } -write_bytes :: proc(buf: ^StringBuffer, data: []byte) { +write_bytes :: proc(buf: ^StringBuffer, data: []u8) { match b in buf { case StringBuffer.Static: append(b.buf, ..data); @@ -74,7 +74,7 @@ write_bytes :: proc(buf: ^StringBuffer, data: []byte) { append(b.buf, ..data); } } -write_byte :: proc(buf: ^StringBuffer, data: byte) { +write_byte :: proc(buf: ^StringBuffer, data: u8) { match b in buf { case StringBuffer.Static: append(b.buf, data); @@ -84,7 +84,7 @@ write_byte :: proc(buf: ^StringBuffer, data: byte) { } write_rune :: proc(buf: ^StringBuffer, r: rune) { if r < utf8.RUNE_SELF { - write_byte(buf, byte(r)); + write_byte(buf, u8(r)); return; } @@ -93,12 +93,12 @@ write_rune :: proc(buf: ^StringBuffer, r: rune) { } write_int :: proc(buf: ^StringBuffer, i: i128, base: int) { - b: [129]byte; + b: [129]u8; s := strconv.append_bits(b[0..<0], u128(i), base, true, 128, strconv.digits, 0); write_string(buf, s); } write_int :: proc(buf: ^StringBuffer, i: i64, base: int) { - b: [129]byte; + b: [129]u8; s := strconv.append_bits(b[0..<0], u128(i), base, true, 64, strconv.digits, 0); write_string(buf, s); } @@ -106,7 +106,7 @@ write_int :: proc(buf: ^StringBuffer, i: i64, base: int) { fprint :: proc(fd: os.Handle, args: ..any) -> int { - data: [_BUFFER_SIZE]byte; + data: [_BUFFER_SIZE]u8; buf := make_string_buffer_from_slice(data[0..<0]); sbprint(&buf, ..args); res := string_buffer_data(buf); @@ -115,7 +115,7 @@ fprint :: proc(fd: os.Handle, args: ..any) -> int { } fprintln :: proc(fd: os.Handle, args: ..any) -> int { - data: [_BUFFER_SIZE]byte; + data: [_BUFFER_SIZE]u8; buf := make_string_buffer_from_slice(data[0..<0]); sbprintln(&buf, ..args); res := string_buffer_data(buf); @@ -123,7 +123,7 @@ fprintln :: proc(fd: os.Handle, args: ..any) -> int { return len(res); } fprintf :: proc(fd: os.Handle, fmt: string, args: ..any) -> int { - data: [_BUFFER_SIZE]byte; + data: [_BUFFER_SIZE]u8; buf := make_string_buffer_from_slice(data[0..<0]); sbprintf(&buf, fmt, ..args); res := string_buffer_data(buf); @@ -162,15 +162,15 @@ aprintf :: proc(fmt: string, args: ..any) -> string { // bprint* procedures return a string that was allocated with the current context // They must be freed accordingly -bprint :: proc(buf: []byte, args: ..any) -> string { +bprint :: proc(buf: []u8, args: ..any) -> string { sb := make_string_buffer_from_slice(buf[0..<0.. string { +bprintln :: proc(buf: []u8, args: ..any) -> string { sb := make_string_buffer_from_slice(buf[0..<0.. string { +bprintf :: proc(buf: []u8, fmt: string, args: ..any) -> string { sb := make_string_buffer_from_slice(buf[0..<0.. string { fprint_type :: proc(fd: os.Handle, info: ^TypeInfo) { - data: [_BUFFER_SIZE]byte; + data: [_BUFFER_SIZE]u8; buf := make_string_buffer_from_slice(data[0..<0]); write_type(&buf, info); os.write(fd, string_buffer_data(buf)); @@ -204,6 +204,8 @@ write_type :: proc(buf: ^StringBuffer, ti: ^TypeInfo) { write_string(buf, info.signed ? "i" : "u"); write_int(buf, i64(8*info.size), 10); } + case Rune: + write_string(buf, "rune"); case Float: match info.size { case 2: write_string(buf, "f16"); @@ -500,7 +502,7 @@ fmt_write_padding :: proc(fi: ^FmtInfo, width: int) { if width <= 0 { return; } - pad_byte: byte = '0'; + pad_byte: u8 = '0'; if fi.space { pad_byte = ' '; } @@ -549,7 +551,7 @@ _fmt_int :: proc(fi: ^FmtInfo, u: u128, base: int, is_signed: bool, bit_size: in panic("_fmt_int: unknown base, whoops"); } - buf: [256]byte; + buf: [256]u8; start := 0; @@ -560,7 +562,7 @@ _fmt_int :: proc(fi: ^FmtInfo, u: u128, base: int, is_signed: bool, bit_size: in s := strconv.append_bits(buf[start.. utf8.MAX_RUNE { @@ -637,7 +644,7 @@ fmt_float :: proc(fi: ^FmtInfo, v: f64, bit_size: int, verb: rune) { prec = fi.prec; } - buf: [386]byte; + buf: [386]u8; str := strconv.append_float(buf[1..<1], v, 'f', prec, bit_size); str = string(buf[0..len(str)]); if str[1] == '+' || str[1] == '-' { @@ -729,6 +736,7 @@ fmt_enum :: proc(fi: ^FmtInfo, v: any, verb: rune) { ok := false; a := any{v.data, type_info_base(e.base)}; match v in a { + case rune: i = i128(v); case i8: i = i128(v); case i16: i = i128(v); case i32: i = i128(v); @@ -801,7 +809,7 @@ fmt_value :: proc(fi: ^FmtInfo, v: any, verb: rune) { } write_string(fi.buf, b.names[i]); write_string(fi.buf, " = "); - data := ^byte(v.data) + b.offsets[i]; + data := ^u8(v.data) + b.offsets[i]; fmt_arg(fi, any{rawptr(data), b.types[i]}, 'v'); } write_byte(fi.buf, '}'); @@ -812,6 +820,7 @@ fmt_value :: proc(fi: ^FmtInfo, v: any, verb: rune) { case Boolean: fmt_arg(fi, v, verb); case Integer: fmt_arg(fi, v, verb); + case Rune: fmt_arg(fi, v, verb); case Float: fmt_arg(fi, v, verb); case Complex: fmt_arg(fi, v, verb); case String: fmt_arg(fi, v, verb); @@ -833,7 +842,7 @@ fmt_value :: proc(fi: ^FmtInfo, v: any, verb: rune) { if i > 0 { write_string(fi.buf, ", "); } - data := ^byte(v.data) + i*info.elem_size; + data := ^u8(v.data) + i*info.elem_size; fmt_arg(fi, any{rawptr(data), info.elem}, verb); } @@ -845,14 +854,14 @@ fmt_value :: proc(fi: ^FmtInfo, v: any, verb: rune) { if i > 0 { write_string(fi.buf, ", "); } - data := ^byte(array.data) + i*info.elem_size; + data := ^u8(array.data) + i*info.elem_size; fmt_arg(fi, any{rawptr(data), info.elem}, verb); } case Slice: write_byte(fi.buf, '['); defer write_byte(fi.buf, ']'); - slice := ^[]byte(v.data); + slice := ^[]u8(v.data); for _, i in slice { if i > 0 { write_string(fi.buf, ", "); @@ -870,7 +879,7 @@ fmt_value :: proc(fi: ^FmtInfo, v: any, verb: rune) { write_string(fi.buf, ", "); } - data := ^byte(v.data) + i*info.elem_size; + data := ^u8(v.data) + i*info.elem_size; fmt_value(fi, any{rawptr(data), info.elem}, verb); } @@ -892,7 +901,7 @@ fmt_value :: proc(fi: ^FmtInfo, v: any, verb: rune) { if i > 0 { write_string(fi.buf, ", "); } - data := ^byte(entries.data) + i*entry_size; + data := ^u8(entries.data) + i*entry_size; header := ^__MapEntryHeader(data); if types.is_string(info.key) { @@ -920,7 +929,7 @@ fmt_value :: proc(fi: ^FmtInfo, v: any, verb: rune) { } write_string(fi.buf, info.names[i]); write_string(fi.buf, " = "); - data := ^byte(v.data) + info.offsets[i]; + data := ^u8(v.data) + info.offsets[i]; fmt_value(fi, any{rawptr(data), info.types[i]}, 'v'); } @@ -936,7 +945,7 @@ fmt_value :: proc(fi: ^FmtInfo, v: any, verb: rune) { } write_string(fi.buf, cf.names[i]); write_string(fi.buf, " = "); - data := ^byte(v.data) + cf.offsets[i]; + data := ^u8(v.data) + cf.offsets[i]; fmt_value(fi, any{rawptr(data), cf.types[i]}, 'v'); } @@ -999,8 +1008,9 @@ fmt_arg :: proc(fi: ^FmtInfo, arg: any, verb: rune) { base_arg := arg; base_arg.type_info = type_info_base(base_arg.type_info); match a in base_arg { - case any: fmt_arg(fi, a, verb); + case any: fmt_arg(fi, a, verb); case bool: fmt_bool(fi, a, verb); + case rune: fmt_rune(fi, a, verb); case f32: fmt_float(fi, f64(a), 32, verb); case f64: fmt_float(fi, a, 64, verb); diff --git a/core/hash.odin b/core/hash.odin index ac40ca938..df7f3c01b 100644 --- a/core/hash.odin +++ b/core/hash.odin @@ -1,11 +1,11 @@ -crc32 :: proc(data: []byte) -> u32 { +crc32 :: proc(data: []u8) -> u32 { result := ~u32(0); for b in data { result = result>>8 ~ _crc32_table[(result ~ u32(b)) & 0xff]; } return ~result; } -crc64 :: proc(data: []byte) -> u64 { +crc64 :: proc(data: []u8) -> u64 { result := ~u64(0); for b in data { result = result>>8 ~ _crc64_table[(result ~ u64(b)) & 0xff]; @@ -13,7 +13,7 @@ crc64 :: proc(data: []byte) -> u64 { return ~result; } -fnv32 :: proc(data: []byte) -> u32 { +fnv32 :: proc(data: []u8) -> u32 { h: u32 = 0x811c9dc5; for b in data { h = (h * 0x01000193) ~ u32(b); @@ -21,7 +21,7 @@ fnv32 :: proc(data: []byte) -> u32 { return h; } -fnv64 :: proc(data: []byte) -> u64 { +fnv64 :: proc(data: []u8) -> u64 { h: u64 = 0xcbf29ce484222325; for b in data { h = (h * 0x100000001b3) ~ u64(b); @@ -29,7 +29,7 @@ fnv64 :: proc(data: []byte) -> u64 { return h; } -fnv32a :: proc(data: []byte) -> u32 { +fnv32a :: proc(data: []u8) -> u32 { h: u32 = 0x811c9dc5; for b in data { h = (h ~ u32(b)) * 0x01000193; @@ -37,7 +37,7 @@ fnv32a :: proc(data: []byte) -> u32 { return h; } -fnv64a :: proc(data: []byte) -> u64 { +fnv64a :: proc(data: []u8) -> u64 { h: u64 = 0xcbf29ce484222325; for b in data { h = (h ~ u64(b)) * 0x100000001b3; @@ -45,7 +45,7 @@ fnv64a :: proc(data: []byte) -> u64 { return h; } -murmur32 :: proc(data: []byte) -> u32 { +murmur32 :: proc(data: []u8) -> u32 { c1_32: u32 : 0xcc9e2d51; c2_32: u32 : 0x1b873593; @@ -95,7 +95,7 @@ murmur32 :: proc(data: []byte) -> u32 { return h1; } -murmur64 :: proc(data: []byte) -> u64 { +murmur64 :: proc(data: []u8) -> u64 { SEED :: 0x9747b28c; when size_of(int) == 8 { diff --git a/core/mem.odin b/core/mem.odin index fc4a72d07..c9e0300df 100644 --- a/core/mem.odin +++ b/core/mem.odin @@ -18,7 +18,7 @@ copy :: proc(dst, src: rawptr, len: int) -> rawptr { copy_non_overlapping :: proc(dst, src: rawptr, len: int) -> rawptr { return __mem_copy_non_overlapping(dst, src, len); } -compare :: proc(a, b: []byte) -> int { +compare :: proc(a, b: []u8) -> int { return __mem_compare(&a[0], &b[0], min(len(a), len(b))); } @@ -81,7 +81,7 @@ allocation_header :: proc(data: rawptr) -> ^AllocationHeader { Arena :: struct { backing: Allocator, offset: int, - memory: []byte, + memory: []u8, temp_count: int, } @@ -94,7 +94,7 @@ ArenaTempMemory :: struct { -init_arena_from_memory :: proc(using a: ^Arena, data: []byte) { +init_arena_from_memory :: proc(using a: ^Arena, data: []u8) { backing = Allocator{}; memory = data[0..<0]; temp_count = 0; @@ -102,7 +102,7 @@ init_arena_from_memory :: proc(using a: ^Arena, data: []byte) { init_arena_from_context :: proc(using a: ^Arena, size: int) { backing = context.allocator; - memory = make([]byte, size); + memory = make([]u8, size); temp_count = 0; } diff --git a/core/opengl.odin b/core/opengl.odin index 847c0faab..1d3ad630c 100644 --- a/core/opengl.odin +++ b/core/opengl.odin @@ -23,7 +23,7 @@ Ortho :: proc(left, right, bottom, top, near, far: f64) #foreign lib "gl Color3f :: proc(r, g, b: f32) #foreign lib "glColor3f"; Vertex3f :: proc(x, y, z: f32) #foreign lib "glVertex3f"; GetError :: proc() -> i32 #foreign lib "glGetError"; -GetString :: proc(name: i32) -> ^byte #foreign lib "glGetString"; +GetString :: proc(name: i32) -> ^u8 #foreign lib "glGetString"; GetIntegerv :: proc(name: i32, v: ^i32) #foreign lib "glGetIntegerv"; TexCoord2f :: proc(x, y: f32) #foreign lib "glTexCoord2f"; TexImage2D :: proc(target, level, internal_format, @@ -69,7 +69,7 @@ VertexAttribPointer: proc(index: u32, size, type_: i32, normalized: i32, st EnableVertexAttribArray: proc(index: u32) #cc_c; CreateShader: proc(shader_type: i32) -> u32 #cc_c; -ShaderSource: proc(shader: u32, count: u32, str: ^^byte, length: ^i32) #cc_c; +ShaderSource: proc(shader: u32, count: u32, str: ^^u8, length: ^i32) #cc_c; CompileShader: proc(shader: u32) #cc_c; CreateProgram: proc() -> u32 #cc_c; AttachShader: proc(program, shader: u32) #cc_c; @@ -82,8 +82,8 @@ DeleteProgram: proc(program: u32) #cc_c; GetShaderiv: proc(shader: u32, pname: i32, params: ^i32) #cc_c; GetProgramiv: proc(program: u32, pname: i32, params: ^i32) #cc_c; -GetShaderInfoLog: proc(shader: u32, max_length: u32, length: ^u32, info_long: ^byte) #cc_c; -GetProgramInfoLog: proc(program: u32, max_length: u32, length: ^u32, info_long: ^byte) #cc_c; +GetShaderInfoLog: proc(shader: u32, max_length: u32, length: ^u32, info_long: ^u8) #cc_c; +GetProgramInfoLog: proc(program: u32, max_length: u32, length: ^u32, info_long: ^u8) #cc_c; ActiveTexture: proc(texture: i32) #cc_c; GenerateMipmap: proc(target: i32) #cc_c; @@ -106,7 +106,7 @@ Uniform3f: proc(loc: i32, v0, v1, v2: f32) #cc_c; Uniform4f: proc(loc: i32, v0, v1, v2, v3: f32) #cc_c; UniformMatrix4fv: proc(loc: i32, count: u32, transpose: i32, value: ^f32) #cc_c; -GetUniformLocation: proc(program: u32, name: ^byte) -> i32 #cc_c; +GetUniformLocation: proc(program: u32, name: ^u8) -> i32 #cc_c; init :: proc() { set_proc_address :: proc(p: rawptr, name: string) #inline { diff --git a/core/os.odin b/core/os.odin index e83efc3c8..8e25cb566 100644 --- a/core/os.odin +++ b/core/os.odin @@ -3,10 +3,10 @@ #load "os_linux.odin" when ODIN_OS == "linux"; write_string :: proc(fd: Handle, str: string) -> (int, Errno) { - return write(fd, []byte(str)); + return write(fd, []u8(str)); } -read_entire_file :: proc(name: string) -> ([]byte, bool) { +read_entire_file :: proc(name: string) -> ([]u8, bool) { fd, err := open(name, O_RDONLY, 0); if err != 0 { return nil, false; @@ -22,7 +22,7 @@ read_entire_file :: proc(name: string) -> ([]byte, bool) { return nil, true; } - data := make([]byte, length); + data := make([]u8, length); if data == nil { return nil, false; } @@ -35,7 +35,7 @@ read_entire_file :: proc(name: string) -> ([]byte, bool) { return data[0.. bool { +write_entire_file :: proc(name: string, data: []u8) -> bool { fd, err := open(name, O_WRONLY, 0); if err != 0 { return false; diff --git a/core/os_linux.odin b/core/os_linux.odin index 22d31fe9c..78761d4c8 100644 --- a/core/os_linux.odin +++ b/core/os_linux.odin @@ -164,12 +164,12 @@ close :: proc(fd: Handle) { _unix_close(fd); } -read :: proc(fd: Handle, data: []byte) -> (int, Errno) { +read :: proc(fd: Handle, data: []u8) -> (int, Errno) { sz := _unix_read(fd, &data[0], len(data)); return sz, 0; } -write :: proc(fd: Handle, data: []byte) -> (int, Errno) { +write :: proc(fd: Handle, data: []u8) -> (int, Errno) { sz := _unix_write(fd, &data[0], len(data)); return sz, 0; } @@ -213,7 +213,7 @@ access :: proc(path: string, mask: int) -> bool #inline { -// read_entire_file :: proc(name: string) -> ([]byte, bool) { +// read_entire_file :: proc(name: string) -> ([]u8, bool) { // fd: Handle; // err: Errno; // size: i64; diff --git a/core/os_windows.odin b/core/os_windows.odin index 156eb89fc..4c04bd814 100644 --- a/core/os_windows.odin +++ b/core/os_windows.odin @@ -93,8 +93,8 @@ open :: proc(path: string, mode: int, perm: u32) -> (Handle, Errno) { create_mode = win32.OPEN_EXISTING; } - buf: [300]byte; - copy(buf[..], []byte(path)); + buf: [300]u8; + copy(buf[..], []u8(path)); handle := Handle(win32.create_file_a(&buf[0], access, share_mode, sa, create_mode, win32.FILE_ATTRIBUTE_NORMAL, nil)); if handle != INVALID_HANDLE { @@ -109,7 +109,7 @@ close :: proc(fd: Handle) { } -write :: proc(fd: Handle, data: []byte) -> (int, Errno) { +write :: proc(fd: Handle, data: []u8) -> (int, Errno) { if len(data) == 0 { return 0, ERROR_NONE; } @@ -136,7 +136,7 @@ write :: proc(fd: Handle, data: []byte) -> (int, Errno) { return int(total_write), ERROR_NONE; } -read :: proc(fd: Handle, data: []byte) -> (int, Errno) { +read :: proc(fd: Handle, data: []u8) -> (int, Errno) { if len(data) == 0 { return 0, ERROR_NONE; } @@ -225,11 +225,11 @@ last_write_time :: proc(fd: Handle) -> FileTime { last_write_time_by_name :: proc(name: string) -> FileTime { last_write_time: win32.Filetime; data: win32.FileAttributeData; - buf: [1024]byte; + buf: [1024]u8; assert(len(buf) > len(name)); - copy(buf[..], []byte(name)); + copy(buf[..], []u8(name)); if win32.get_file_attributes_ex_a(&buf[0], win32.GetFileExInfoStandard, &data) != 0 { last_write_time = data.last_write_time; @@ -283,7 +283,7 @@ _alloc_command_line_arguments :: proc() -> []string { wstr_len++; } len := 2*wstr_len-1; - buf := make([]byte, len+1); + buf := make([]u8, len+1); str := slice_ptr(wstr, wstr_len+1); i, j := 0, 0; @@ -293,24 +293,24 @@ _alloc_command_line_arguments :: proc() -> []string { if i+1 > len { return ""; } - buf[i] = byte(str[j]); i++; + buf[i] = u8(str[j]); i++; j++; case str[j] < 0x800: if i+2 > len { return ""; } - buf[i] = byte(0xc0 + (str[j]>>6)); i++; - buf[i] = byte(0x80 + (str[j]&0x3f)); i++; + buf[i] = u8(0xc0 + (str[j]>>6)); i++; + buf[i] = u8(0x80 + (str[j]&0x3f)); i++; j++; case 0xd800 <= str[j] && str[j] < 0xdc00: if i+4 > len { return ""; } c := rune((str[j] - 0xd800) << 10) + rune((str[j+1]) - 0xdc00) + 0x10000; - buf[i] = byte(0xf0 + (c >> 18)); i++; - buf[i] = byte(0x80 + ((c >> 12) & 0x3f)); i++; - buf[i] = byte(0x80 + ((c >> 6) & 0x3f)); i++; - buf[i] = byte(0x80 + ((c ) & 0x3f)); i++; + buf[i] = u8(0xf0 + (c >> 18)); i++; + buf[i] = u8(0x80 + ((c >> 12) & 0x3f)); i++; + buf[i] = u8(0x80 + ((c >> 6) & 0x3f)); i++; + buf[i] = u8(0x80 + ((c ) & 0x3f)); i++; j += 2; case 0xdc00 <= str[j] && str[j] < 0xe000: return ""; @@ -318,9 +318,9 @@ _alloc_command_line_arguments :: proc() -> []string { if i+3 > len { return ""; } - buf[i] = 0xe0 + byte (str[j] >> 12); i++; - buf[i] = 0x80 + byte((str[j] >> 6) & 0x3f); i++; - buf[i] = 0x80 + byte((str[j] ) & 0x3f); i++; + buf[i] = 0xe0 + u8 (str[j] >> 12); i++; + buf[i] = 0x80 + u8((str[j] >> 6) & 0x3f); i++; + buf[i] = 0x80 + u8((str[j] ) & 0x3f); i++; j++; } } diff --git a/core/os_x.odin b/core/os_x.odin index fd3bd53be..5d3d29cdd 100644 --- a/core/os_x.odin +++ b/core/os_x.odin @@ -166,7 +166,7 @@ close :: proc(fd: Handle) { unix_close(fd); } -write :: proc(fd: Handle, data: []byte) -> (AddressSize, Errno) { +write :: proc(fd: Handle, data: []u8) -> (AddressSize, Errno) { assert(fd != -1); bytes_written := unix_write(fd, &data[0], len(data)); @@ -176,7 +176,7 @@ write :: proc(fd: Handle, data: []byte) -> (AddressSize, Errno) { return bytes_written, 0; } -read :: proc(fd: Handle, data: []byte) -> (AddressSize, Errno) { +read :: proc(fd: Handle, data: []u8) -> (AddressSize, Errno) { assert(fd != -1); bytes_read := unix_read(fd, &data[0], len(data)); @@ -229,7 +229,7 @@ access :: proc(path: string, mask: int) -> bool #inline { return unix_access(cstr, mask) == 0; } -// read_entire_file :: proc(name: string) -> ([]byte, bool) { +// read_entire_file :: proc(name: string) -> ([]u8, bool) { // handle, err := open_simple(name, O_RDONLY); // if(err != 0) { diff --git a/core/raw.odin b/core/raw.odin index 2f105f886..394c9a86f 100644 --- a/core/raw.odin +++ b/core/raw.odin @@ -4,7 +4,7 @@ Any :: struct #ordered { } String :: struct #ordered { - data: ^byte, + data: ^u8, len: int, }; diff --git a/core/strconv.odin b/core/strconv.odin index 942a5c1be..9faed8dc2 100644 --- a/core/strconv.odin +++ b/core/strconv.odin @@ -189,21 +189,21 @@ parse_f64 :: proc(s: string) -> f64 { } -append_bool :: proc(buf: []byte, b: bool) -> string { +append_bool :: proc(buf: []u8, b: bool) -> string { s := b ? "true" : "false"; - append(buf, ..[]byte(s)); + append(buf, ..[]u8(s)); return string(buf); } -append_uint :: proc(buf: []byte, u: u64, base: int) -> string { +append_uint :: proc(buf: []u8, u: u64, base: int) -> string { return append_bits(buf, u128(u), base, false, 8*size_of(uint), digits, 0); } -append_int :: proc(buf: []byte, i: i64, base: int) -> string { +append_int :: proc(buf: []u8, i: i64, base: int) -> string { return append_bits(buf, u128(i), base, true, 8*size_of(int), digits, 0); } -itoa :: proc(buf: []byte, i: int) -> string { return append_int(buf, i64(i), 10); } +itoa :: proc(buf: []u8, i: int) -> string { return append_int(buf, i64(i), 10); } -append_float :: proc(buf: []byte, f: f64, fmt: byte, prec, bit_size: int) -> string { +append_float :: proc(buf: []u8, f: f64, fmt: u8, prec, bit_size: int) -> string { return string(generic_ftoa(buf, f, fmt, prec, bit_size)); } @@ -211,7 +211,7 @@ append_float :: proc(buf: []byte, f: f64, fmt: byte, prec, bit_size: int) -> str DecimalSlice :: struct { - digits: []byte, + digits: []u8, count: int, decimal_point: int, neg: bool, @@ -228,7 +228,7 @@ _f32_info := Float_Info{23, 8, -127}; _f64_info := Float_Info{52, 11, -1023}; -generic_ftoa :: proc(buf: []byte, val: f64, fmt: byte, prec, bit_size: int) -> []byte { +generic_ftoa :: proc(buf: []u8, val: f64, fmt: u8, prec, bit_size: int) -> []u8 { bits: u64; flt: ^Float_Info; match bit_size { @@ -256,7 +256,7 @@ generic_ftoa :: proc(buf: []byte, val: f64, fmt: byte, prec, bit_size: int) -> [ } else { s = "+Inf"; } - append(buf, ..[]byte(s)); + append(buf, ..[]u8(s)); return buf; case 0: // denormalized @@ -300,7 +300,7 @@ generic_ftoa :: proc(buf: []byte, val: f64, fmt: byte, prec, bit_size: int) -> [ -format_digits :: proc(buf: []byte, shortest: bool, neg: bool, digs: DecimalSlice, prec: int, fmt: byte) -> []byte { +format_digits :: proc(buf: []u8, shortest: bool, neg: bool, digs: DecimalSlice, prec: int, fmt: u8) -> []u8 { match fmt { case 'f', 'F': append(buf, neg ? '-' : '+'); @@ -321,7 +321,7 @@ format_digits :: proc(buf: []byte, shortest: bool, neg: bool, digs: DecimalSlice if prec > 0 { append(buf, '.'); for i in 0.. (unsigne return u, neg; } -append_bits :: proc(buf: []byte, u_: u128, base: int, is_signed: bool, bit_size: int, digits: string, flags: IntFlag) -> string { +append_bits :: proc(buf: []u8, u_: u128, base: int, is_signed: bool, bit_size: int, digits: string, flags: IntFlag) -> string { if base < 2 || base > MAX_BASE { panic("strconv: illegal base passed to append_bits"); } - a: [129]byte; + a: [129]u8; i := len(a); u, neg := is_integer_negative(u_, is_signed, bit_size); b := u128(base); diff --git a/core/strings.odin b/core/strings.odin index bbd5ec303..fd9d090f5 100644 --- a/core/strings.odin +++ b/core/strings.odin @@ -1,11 +1,11 @@ -new_c_string :: proc(s: string) -> ^byte { - c := make([]byte, len(s)+1); - copy(c, []byte(s)); +new_c_string :: proc(s: string) -> ^u8 { + c := make([]u8, len(s)+1); + copy(c, []u8(s)); c[len(s)] = 0; return &c[0]; } -to_odin_string :: proc(c: ^byte) -> string { +to_odin_string :: proc(c: ^u8) -> string { len := 0; for (c+len)^ != 0 { len++; diff --git a/core/sys/wgl.odin b/core/sys/wgl.odin index 333513423..ab35f2252 100644 --- a/core/sys/wgl.odin +++ b/core/sys/wgl.odin @@ -16,26 +16,26 @@ LayerPlaneDescriptor :: struct { size: u16, version: u16, flags: u32, - pixel_type: byte, - color_bits: byte, - red_bits: byte, - red_shift: byte, - green_bits: byte, - green_shift: byte, - blue_bits: byte, - blue_shift: byte, - alpha_bits: byte, - alpha_shift: byte, - accum_bits: byte, - accum_red_bits: byte, - accum_green_bits: byte, - accum_blue_bits: byte, - accum_alpha_bits: byte, - depth_bits: byte, - stencil_bits: byte, - aux_buffers: byte, - layer_type: byte, - reserved: byte, + pixel_type: u8, + color_bits: u8, + red_bits: u8, + red_shift: u8, + green_bits: u8, + green_shift: u8, + blue_bits: u8, + blue_shift: u8, + alpha_bits: u8, + alpha_shift: u8, + accum_bits: u8, + accum_red_bits: u8, + accum_green_bits: u8, + accum_blue_bits: u8, + accum_alpha_bits: u8, + depth_bits: u8, + stencil_bits: u8, + aux_buffers: u8, + layer_type: u8, + reserved: u8, transparent: ColorRef, } @@ -53,8 +53,8 @@ Glyph_MetricsFloat :: struct { CreateContextAttribsARBType :: #type proc(hdc: Hdc, h_share_context: rawptr, attribList: ^i32) -> Hglrc; ChoosePixelFormatARBType :: #type proc(hdc: Hdc, attrib_i_list: ^i32, attrib_f_list: ^f32, max_formats: u32, formats: ^i32, num_formats : ^u32) -> Bool #cc_c; -SwapIntervalEXTType :: #type proc(interval : i32) -> bool #cc_c; -GetExtensionsStringARBType :: #type proc(Hdc) -> ^byte #cc_c; +SwapIntervalEXTType :: #type proc(interval: i32) -> bool #cc_c; +GetExtensionsStringARBType :: #type proc(Hdc) -> ^u8 #cc_c; create_context_attribs_arb: CreateContextAttribsARBType; diff --git a/core/sys/windows.odin b/core/sys/windows.odin index e985dc4c1..cabd3c090 100644 --- a/core/sys/windows.odin +++ b/core/sys/windows.odin @@ -73,7 +73,7 @@ Point :: struct #ordered { WndClassExA :: struct #ordered { size, style: u32, - wndproc: WndProc, + wnd_proc: WndProc, cls_extra, wnd_extra: i32, instance: Hinstance, icon: Hicon, @@ -140,8 +140,8 @@ FindData :: struct #ordered { file_size_low : u32, reserved0 : u32, reserved1 : u32, - file_name : [MAX_PATH]byte, - alternate_file_name : [14]byte, + file_name : [MAX_PATH]u8, + alternate_file_name : [14]u8, } @@ -225,7 +225,7 @@ read_file :: proc(h: Handle, buf: rawptr, to_read: u32, bytes_read: ^i32, overl write_file :: proc(h: Handle, buf: rawptr, len: i32, written_result: ^i32, overlapped: rawptr) -> Bool #foreign kernel32 "WriteFile"; get_file_size_ex :: proc(file_handle: Handle, file_size: ^i64) -> Bool #foreign kernel32 "GetFileSizeEx"; -get_file_attributes_a :: proc(filename: ^byte) -> u32 #foreign kernel32 "GetFileAttributesA"; +get_file_attributes_a :: proc(filename: ^u8) -> u32 #foreign kernel32 "GetFileAttributesA"; get_file_attributes_ex_a :: proc(filename: ^u8, info_level_id: GET_FILEEX_INFO_LEVELS, file_info: rawptr) -> Bool #foreign kernel32 "GetFileAttributesExA"; get_file_information_by_handle :: proc(file_handle: Handle, file_info: ^ByHandleFileInformation) -> Bool #foreign kernel32 "GetFileInformationByHandle"; @@ -234,7 +234,7 @@ set_file_pointer :: proc(file_handle: Handle, distance_to_move: i32, distance_to set_handle_information :: proc(obj: Handle, mask, flags: u32) -> Bool #foreign kernel32 "SetHandleInformation"; -find_first_file_a :: proc(file_name : ^byte, data : ^FindData) -> Handle #foreign kernel32 "FindFirstFileA"; +find_first_file_a :: proc(file_name : ^u8, data : ^FindData) -> Handle #foreign kernel32 "FindFirstFileA"; find_next_file_a :: proc(file : Handle, data : ^FindData) -> Bool #foreign kernel32 "FindNextFileA"; find_close :: proc(file : Handle) -> Bool #foreign kernel32 "FindClose"; @@ -312,7 +312,7 @@ Security_Attributes :: struct #ordered { INFINITE :: 0xffffffff; -create_semaphore_a :: proc(attributes: ^Security_Attributes, initial_count, maximum_count: i32, name: ^byte) -> Handle #foreign kernel32 "CreateSemaphoreA"; +create_semaphore_a :: proc(attributes: ^Security_Attributes, initial_count, maximum_count: i32, name: ^u8) -> Handle #foreign kernel32 "CreateSemaphoreA"; release_semaphore :: proc(semaphore: Handle, release_count: i32, previous_count: ^i32) -> Bool #foreign kernel32 "ReleaseSemaphore"; wait_for_single_object :: proc(handle: Handle, milliseconds: u32) -> u32 #foreign kernel32 "WaitForSingleObject"; @@ -383,7 +383,7 @@ get_window_rect :: proc(wnd: Hwnd, rect: ^Rect) -> Bool get_window_long_ptr_a :: proc(wnd: Hwnd, index: i32) -> i64 #foreign user32 "GetWindowLongPtrA"; set_window_long_ptr_a :: proc(wnd: Hwnd, index: i32, new: i64) -> i64 #foreign user32 "SetWindowLongPtrA"; -get_window_text :: proc(wnd: Hwnd, str: ^byte, maxCount: i32) -> i32 #foreign user32 "GetWindowText"; +get_window_text :: proc(wnd: Hwnd, str: ^u8, maxCount: i32) -> i32 #foreign user32 "GetWindowText"; HIWORD :: proc(wParam: Wparam) -> u16 { return u16((u32(wParam) >> 16) & 0xffff); } HIWORD :: proc(lParam: Lparam) -> u16 { return u16((u32(lParam) >> 16) & 0xffff); } @@ -416,7 +416,7 @@ BitmapInfo :: struct #ordered { } -RgbQuad :: struct #ordered { blue, green, red, reserved: byte } +RgbQuad :: struct #ordered { blue, green, red, reserved: u8 } BI_RGB :: 0; DIB_RGB_COLORS :: 0x00; @@ -486,18 +486,18 @@ PixelFormatDescriptor :: struct #ordered { stencil_bits, aux_buffers, layer_type, - reserved: byte, + reserved: u8, layer_mask, visible_mask, damage_mask: u32, } -get_d_c :: proc(h: Hwnd) -> Hdc #foreign user32 "GetDC"; +get_dc :: proc(h: Hwnd) -> Hdc #foreign user32 "GetDC"; set_pixel_format :: proc(hdc: Hdc, pixel_format: i32, pfd: ^PixelFormatDescriptor) -> Bool #foreign gdi32 "SetPixelFormat"; choose_pixel_format :: proc(hdc: Hdc, pfd: ^PixelFormatDescriptor) -> i32 #foreign gdi32 "ChoosePixelFormat"; swap_buffers :: proc(hdc: Hdc) -> Bool #foreign gdi32 "SwapBuffers"; -release_d_c :: proc(wnd: Hwnd, hdc: Hdc) -> i32 #foreign user32 "ReleaseDC"; +release_dc :: proc(wnd: Hwnd, hdc: Hdc) -> i32 #foreign user32 "ReleaseDC"; Proc :: #type proc() #cc_c; diff --git a/core/utf8.odin b/core/utf8.odin index 9f932e9c4..7f07d48c6 100644 --- a/core/utf8.odin +++ b/core/utf8.odin @@ -38,7 +38,7 @@ immutable accept_ranges := [5]AcceptRange{ {0x80, 0x8f}, }; -immutable accept_sizes := [256]byte{ +immutable accept_sizes := [256]u8{ 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x00-0x0f 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x10-0x1f 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x20-0x2f @@ -58,17 +58,17 @@ immutable accept_sizes := [256]byte{ 0x34, 0x04, 0x04, 0x04, 0x44, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, // 0xf0-0xff }; -encode_rune :: proc(r: rune) -> ([4]byte, int) { - buf: [4]byte; +encode_rune :: proc(r: rune) -> ([4]u8, int) { + buf: [4]u8; i := u32(r); - mask: byte : 0x3f; + mask: u8 : 0x3f; if i <= 1<<7-1 { - buf[0] = byte(r); + buf[0] = u8(r); return buf, 1; } if i <= 1<<11-1 { - buf[0] = 0xc0 | byte(r>>6); - buf[1] = 0x80 | byte(r) & mask; + buf[0] = 0xc0 | u8(r>>6); + buf[1] = 0x80 | u8(r) & mask; return buf, 2; } @@ -79,21 +79,21 @@ encode_rune :: proc(r: rune) -> ([4]byte, int) { } if i <= 1<<16-1 { - buf[0] = 0xe0 | byte(r>>12); - buf[1] = 0x80 | byte(r>>6) & mask; - buf[2] = 0x80 | byte(r) & mask; + buf[0] = 0xe0 | u8(r>>12); + buf[1] = 0x80 | u8(r>>6) & mask; + buf[2] = 0x80 | u8(r) & mask; return buf, 3; } - buf[0] = 0xf0 | byte(r>>18); - buf[1] = 0x80 | byte(r>>12) & mask; - buf[2] = 0x80 | byte(r>>6) & mask; - buf[3] = 0x80 | byte(r) & mask; + buf[0] = 0xf0 | u8(r>>18); + buf[1] = 0x80 | u8(r>>12) & mask; + buf[2] = 0x80 | u8(r>>6) & mask; + buf[3] = 0x80 | u8(r) & mask; return buf, 4; } -decode_rune :: proc(s: string) -> (rune, int) #inline { return decode_rune([]byte(s)); } -decode_rune :: proc(s: []byte) -> (rune, int) { +decode_rune :: proc(s: string) -> (rune, int) #inline { return decode_rune([]u8(s)); } +decode_rune :: proc(s: []u8) -> (rune, int) { n := len(s); if n < 1 { return RUNE_ERROR, 0; @@ -132,8 +132,8 @@ decode_rune :: proc(s: []byte) -> (rune, int) { -decode_last_rune :: proc(s: string) -> (rune, int) #inline { return decode_last_rune([]byte(s)); } -decode_last_rune :: proc(s: []byte) -> (rune, int) { +decode_last_rune :: proc(s: string) -> (rune, int) #inline { return decode_last_rune([]u8(s)); } +decode_last_rune :: proc(s: []u8) -> (rune, int) { r: rune; size: int; start, end, limit: int; @@ -215,10 +215,10 @@ valid_string :: proc(s: string) -> bool { return true; } -rune_start :: proc(b: byte) -> bool #inline { return b&0xc0 != 0x80; } +rune_start :: proc(b: u8) -> bool #inline { return b&0xc0 != 0x80; } -rune_count :: proc(s: string) -> int #inline { return rune_count([]byte(s)); } -rune_count :: proc(s: []byte) -> int { +rune_count :: proc(s: string) -> int #inline { return rune_count([]u8(s)); } +rune_count :: proc(s: []u8) -> int { count := 0; n := len(s); diff --git a/src/check_expr.c b/src/check_expr.c index 667ae48fd..75d38f4fc 100644 --- a/src/check_expr.c +++ b/src/check_expr.c @@ -156,7 +156,7 @@ i64 check_distance_between_types(Checker *c, Operand *operand, Type *type) { if (is_type_typed(dst) && src->kind == Type_Basic) { switch (src->Basic.kind) { case Basic_UntypedInteger: - if (is_type_integer(dst)) { + if (is_type_integer(dst) || is_type_rune(dst)) { return 1; } break; @@ -2102,7 +2102,7 @@ bool check_representable_as_constant(Checker *c, ExactValue in_value, Type *type return in_value.kind == ExactValue_Bool; } else if (is_type_string(type)) { return in_value.kind == ExactValue_String; - } else if (is_type_integer(type)) { + } else if (is_type_integer(type) || is_type_rune(type)) { ExactValue v = exact_value_to_integer(in_value); if (v.kind != ExactValue_Integer) { return false; @@ -2127,6 +2127,7 @@ bool check_representable_as_constant(Checker *c, ExactValue in_value, Type *type i128 imax = i128_shl(I128_ONE, s-1ll); switch (type->Basic.kind) { + case Basic_rune: case Basic_i8: case Basic_i16: case Basic_i32: @@ -2212,7 +2213,15 @@ void check_is_expressible(Checker *c, Operand *o, Type *type) { if (!is_type_integer(o->type) && is_type_integer(type)) { error_node(o->expr, "`%s` truncated to `%s`", a, b); } else { - error_node(o->expr, "`%s = %lld` overflows `%s`", a, i128_to_i64(o->value.value_integer), b); + char buf[127] = {0}; + String str = {0}; + i128 i = o->value.value_integer; + if (is_type_unsigned(o->type)) { + str = u128_to_string(*cast(u128 *)&i, buf, gb_size_of(buf)); + } else { + str = i128_to_string(i, buf, gb_size_of(buf)); + } + error_node(o->expr, "`%s = %.*s` overflows `%s`", a, str, b); } } else { error_node(o->expr, "Cannot convert `%s` to `%s`", a, b); @@ -2623,6 +2632,13 @@ bool check_is_castable_to(Checker *c, Operand *operand, Type *y) { } } + if (is_type_integer(src) && is_type_rune(dst)) { + return true; + } + if (is_type_rune(src) && is_type_integer(dst)) { + return true; + } + if (is_type_complex(src) && is_type_complex(dst)) { return true; } @@ -4349,7 +4365,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id } break; case BuiltinProc_slice_to_bytes: { - // slice_to_bytes :: proc(a: []T) -> []byte + // slice_to_bytes :: proc(a: []T) -> []u8 Type *slice_type = base_type(operand->type); if (!is_type_slice(slice_type)) { gbString type_str = type_to_string(operand->type); @@ -4358,7 +4374,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id return false; } - operand->type = t_byte_slice; + operand->type = t_u8_slice; operand->mode = Addressing_Value; } break; diff --git a/src/checker.c b/src/checker.c index 8aafccb73..b416a6871 100644 --- a/src/checker.c +++ b/src/checker.c @@ -658,13 +658,12 @@ void init_universal_scope(void) { add_global_entity(make_entity_type_name(a, NULL, make_token_ident(basic_types[i].Basic.name), &basic_types[i])); } #if 1 - for (isize i = 0; i < gb_count_of(basic_type_aliases); i++) { - add_global_entity(make_entity_type_name(a, NULL, make_token_ident(basic_type_aliases[i].Basic.name), &basic_type_aliases[i])); - } + // for (isize i = 0; i < gb_count_of(basic_type_aliases); i++) { + // add_global_entity(make_entity_type_name(a, NULL, make_token_ident(basic_type_aliases[i].Basic.name), &basic_type_aliases[i])); + // } #else { t_byte = add_global_type_alias(a, str_lit("byte"), &basic_types[Basic_u8]); - t_rune = add_global_type_alias(a, str_lit("rune"), &basic_types[Basic_i32]); } #endif @@ -700,7 +699,7 @@ void init_universal_scope(void) { t_i64_ptr = make_type_pointer(a, t_i64); t_i128_ptr = make_type_pointer(a, t_i128); t_f64_ptr = make_type_pointer(a, t_f64); - t_byte_slice = make_type_slice(a, t_byte); + t_u8_slice = make_type_slice(a, t_u8); t_string_slice = make_type_slice(a, t_string); } @@ -1204,33 +1203,35 @@ void init_preload(Checker *c) { - if (record->variant_count != 22) { + if (record->variant_count != 23) { compiler_error("Invalid `TypeInfo` layout"); } t_type_info_named = record->variants[ 1]->type; t_type_info_integer = record->variants[ 2]->type; - t_type_info_float = record->variants[ 3]->type; - t_type_info_complex = record->variants[ 4]->type; - t_type_info_string = record->variants[ 5]->type; - t_type_info_boolean = record->variants[ 6]->type; - t_type_info_any = record->variants[ 7]->type; - t_type_info_pointer = record->variants[ 8]->type; - t_type_info_atomic = record->variants[ 9]->type; - t_type_info_procedure = record->variants[10]->type; - t_type_info_array = record->variants[11]->type; - t_type_info_dynamic_array = record->variants[12]->type; - t_type_info_slice = record->variants[13]->type; - t_type_info_vector = record->variants[14]->type; - t_type_info_tuple = record->variants[15]->type; - t_type_info_struct = record->variants[16]->type; - t_type_info_raw_union = record->variants[17]->type; - t_type_info_union = record->variants[18]->type; - t_type_info_enum = record->variants[19]->type; - t_type_info_map = record->variants[20]->type; - t_type_info_bit_field = record->variants[21]->type; + t_type_info_rune = record->variants[ 3]->type; + t_type_info_float = record->variants[ 4]->type; + t_type_info_complex = record->variants[ 5]->type; + t_type_info_string = record->variants[ 6]->type; + t_type_info_boolean = record->variants[ 7]->type; + t_type_info_any = record->variants[ 8]->type; + t_type_info_pointer = record->variants[ 9]->type; + t_type_info_atomic = record->variants[10]->type; + t_type_info_procedure = record->variants[11]->type; + t_type_info_array = record->variants[12]->type; + t_type_info_dynamic_array = record->variants[13]->type; + t_type_info_slice = record->variants[14]->type; + t_type_info_vector = record->variants[15]->type; + t_type_info_tuple = record->variants[16]->type; + t_type_info_struct = record->variants[17]->type; + t_type_info_raw_union = record->variants[18]->type; + t_type_info_union = record->variants[19]->type; + t_type_info_enum = record->variants[20]->type; + t_type_info_map = record->variants[21]->type; + t_type_info_bit_field = record->variants[22]->type; t_type_info_named_ptr = make_type_pointer(c->allocator, t_type_info_named); t_type_info_integer_ptr = make_type_pointer(c->allocator, t_type_info_integer); + t_type_info_rune_ptr = make_type_pointer(c->allocator, t_type_info_rune); t_type_info_float_ptr = make_type_pointer(c->allocator, t_type_info_float); t_type_info_complex_ptr = make_type_pointer(c->allocator, t_type_info_complex); t_type_info_string_ptr = make_type_pointer(c->allocator, t_type_info_string); @@ -2118,12 +2119,14 @@ void check_parsed_files(Checker *c) { } } + /* for (isize i = 0; i < gb_count_of(basic_type_aliases)-1; i++) { Type *t = &basic_type_aliases[i]; if (t->Basic.size > 0) { add_type_info_type(c, t); } } + */ #endif diff --git a/src/ir.c b/src/ir.c index e4b086eb1..e014cb229 100644 --- a/src/ir.c +++ b/src/ir.c @@ -7526,6 +7526,10 @@ void ir_gen_tree(irGen *s) { ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 2), is_signed); } break; + case Basic_rune: + tag = ir_emit_conv(proc, ti_ptr, t_type_info_rune_ptr); + break; + // case Basic_f16: case Basic_f32: case Basic_f64: diff --git a/src/ir_print.c b/src/ir_print.c index d66a99c23..c7dec10cb 100644 --- a/src/ir_print.c +++ b/src/ir_print.c @@ -193,6 +193,8 @@ void ir_print_type(irFileBuffer *f, irModule *m, Type *t) { case Basic_i128: ir_fprintf(f, "i128"); return; case Basic_u128: ir_fprintf(f, "i128"); return; + case Basic_rune: ir_fprintf(f, "i32"); return; + // case Basic_f16: ir_fprintf(f, "half"); return; case Basic_f32: ir_fprintf(f, "float"); return; case Basic_f64: ir_fprintf(f, "double"); return; diff --git a/src/tokenizer.c b/src/tokenizer.c index 868ed93cc..459fca163 100644 --- a/src/tokenizer.c +++ b/src/tokenizer.c @@ -890,9 +890,9 @@ Token tokenizer_get_token(Tokenizer *t) { case '}': token.kind = Token_CloseBrace; break; case '\\': token.kind = Token_BackSlash; break; - case '≠': token.kind = Token_NotEq; break; - case '≤': token.kind = Token_LtEq; break; - case '≥': token.kind = Token_GtEq; break; + case 0x2260: token.kind = Token_NotEq; break; // '≠' + case 0x2264: token.kind = Token_LtEq; break; // '≤' + case 0x2265: token.kind = Token_GtEq; break; // '≥' case '%': token.kind = token_kind_dub_eq(t, '%', Token_Mod, Token_ModEq, Token_ModMod, Token_ModModEq); break; diff --git a/src/types.c b/src/types.c index 1364191d8..c98046a22 100644 --- a/src/types.c +++ b/src/types.c @@ -14,6 +14,8 @@ typedef enum BasicKind { Basic_i128, Basic_u128, + Basic_rune, + // Basic_f16, Basic_f32, Basic_f64, @@ -39,7 +41,6 @@ typedef enum BasicKind { Basic_COUNT, Basic_byte = Basic_u8, - Basic_rune = Basic_i32, } BasicKind; typedef enum BasicFlag { @@ -54,8 +55,8 @@ typedef enum BasicFlag { BasicFlag_Untyped = GB_BIT(8), BasicFlag_Numeric = BasicFlag_Integer | BasicFlag_Float | BasicFlag_Complex, - BasicFlag_Ordered = BasicFlag_Integer | BasicFlag_Float | BasicFlag_String | BasicFlag_Pointer, - BasicFlag_ConstantType = BasicFlag_Boolean | BasicFlag_Numeric | BasicFlag_Pointer | BasicFlag_String | BasicFlag_Rune, + BasicFlag_Ordered = BasicFlag_Integer | BasicFlag_Float | BasicFlag_String | BasicFlag_Pointer | BasicFlag_Rune, + BasicFlag_ConstantType = BasicFlag_Boolean | BasicFlag_Numeric | BasicFlag_String | BasicFlag_Pointer | BasicFlag_Rune, } BasicFlag; typedef struct BasicType { @@ -235,6 +236,7 @@ gb_global Type basic_types[] = { {Type_Basic, {Basic_i128, BasicFlag_Integer, 16, STR_LIT("i128")}}, {Type_Basic, {Basic_u128, BasicFlag_Integer | BasicFlag_Unsigned, 16, STR_LIT("u128")}}, + {Type_Basic, {Basic_rune, BasicFlag_Integer | BasicFlag_Rune, 4, STR_LIT("rune")}}, // {Type_Basic, {Basic_f16, BasicFlag_Float, 2, STR_LIT("f16")}}, {Type_Basic, {Basic_f32, BasicFlag_Float, 4, STR_LIT("f32")}}, @@ -260,10 +262,10 @@ gb_global Type basic_types[] = { {Type_Basic, {Basic_UntypedNil, BasicFlag_Untyped, 0, STR_LIT("untyped nil")}}, }; -gb_global Type basic_type_aliases[] = { - {Type_Basic, {Basic_byte, BasicFlag_Integer | BasicFlag_Unsigned, 1, STR_LIT("byte")}}, - {Type_Basic, {Basic_rune, BasicFlag_Integer, 4, STR_LIT("rune")}}, -}; +// gb_global Type basic_type_aliases[] = { +// // {Type_Basic, {Basic_byte, BasicFlag_Integer | BasicFlag_Unsigned, 1, STR_LIT("byte")}}, +// // {Type_Basic, {Basic_rune, BasicFlag_Integer, 4, STR_LIT("rune")}}, +// }; gb_global Type *t_invalid = &basic_types[Basic_Invalid]; gb_global Type *t_bool = &basic_types[Basic_bool]; @@ -278,6 +280,8 @@ gb_global Type *t_u64 = &basic_types[Basic_u64]; gb_global Type *t_i128 = &basic_types[Basic_i128]; gb_global Type *t_u128 = &basic_types[Basic_u128]; +gb_global Type *t_rune = &basic_types[Basic_rune]; + // gb_global Type *t_f16 = &basic_types[Basic_f16]; gb_global Type *t_f32 = &basic_types[Basic_f32]; gb_global Type *t_f64 = &basic_types[Basic_f64]; @@ -301,15 +305,13 @@ gb_global Type *t_untyped_string = &basic_types[Basic_UntypedString]; gb_global Type *t_untyped_rune = &basic_types[Basic_UntypedRune]; gb_global Type *t_untyped_nil = &basic_types[Basic_UntypedNil]; -gb_global Type *t_byte = &basic_type_aliases[0]; -gb_global Type *t_rune = &basic_type_aliases[1]; gb_global Type *t_u8_ptr = NULL; gb_global Type *t_int_ptr = NULL; gb_global Type *t_i64_ptr = NULL; gb_global Type *t_i128_ptr = NULL; gb_global Type *t_f64_ptr = NULL; -gb_global Type *t_byte_slice = NULL; +gb_global Type *t_u8_slice = NULL; gb_global Type *t_string_slice = NULL; @@ -323,6 +325,7 @@ gb_global Type *t_type_info_enum_value_ptr = NULL; gb_global Type *t_type_info_named = NULL; gb_global Type *t_type_info_integer = NULL; +gb_global Type *t_type_info_rune = NULL; gb_global Type *t_type_info_float = NULL; gb_global Type *t_type_info_complex = NULL; gb_global Type *t_type_info_any = NULL; @@ -345,6 +348,7 @@ gb_global Type *t_type_info_bit_field = NULL; gb_global Type *t_type_info_named_ptr = NULL; gb_global Type *t_type_info_integer_ptr = NULL; +gb_global Type *t_type_info_rune_ptr = NULL; gb_global Type *t_type_info_float_ptr = NULL; gb_global Type *t_type_info_complex_ptr = NULL; gb_global Type *t_type_info_quaternion_ptr = NULL; @@ -646,6 +650,13 @@ bool is_type_unsigned(Type *t) { } return false; } +bool is_type_rune(Type *t) { + t = core_type(t); + if (t->kind == Type_Basic) { + return (t->Basic.flags & BasicFlag_Rune) != 0; + } + return false; +} bool is_type_numeric(Type *t) { t = core_type(t); if (t->kind == Type_Basic) { @@ -932,6 +943,8 @@ bool is_type_comparable(Type *t) { case Basic_UntypedNil: case Basic_any: return false; + case Basic_rune: + return true; } return true; case Type_Pointer: