From 3cadf4a644c6156e341ea1ad38fcdad886fcc72a Mon Sep 17 00:00:00 2001 From: Brendan Hansen Date: Mon, 25 Oct 2021 21:59:25 -0500 Subject: [PATCH] bugfixes in modules --- modules/bmfont/bmfont_loader.onyx | 5 ++-- modules/bmfont/module.onyx | 2 +- modules/bmfont/position.onyx | 6 ++--- modules/bmfont/types.onyx | 6 ++--- modules/bmfont/utils.onyx | 3 +-- modules/json/decoder.onyx | 12 +++++----- modules/json/parser.onyx | 38 ++++++++++++++++--------------- modules/json/tokenizer.onyx | 17 +++++++------- modules/json/types.onyx | 18 ++++++++++----- 9 files changed, 56 insertions(+), 51 deletions(-) diff --git a/modules/bmfont/bmfont_loader.onyx b/modules/bmfont/bmfont_loader.onyx index 5d7656dc..2de49c74 100644 --- a/modules/bmfont/bmfont_loader.onyx +++ b/modules/bmfont/bmfont_loader.onyx @@ -12,13 +12,12 @@ load_bmfont :: (fnt_data: [] u8) -> BMFont { parse_bmfont(fnt_data, ^bmf); - @Cleanup // this was a stupid way of doing this. Just use a f-ing for loop. - array.map(bmf.glyphs.entries, #code { + for ^it: bmf.glyphs.entries { it.value.tex_x = ~~ it.value.x / cast(f32) bmf.common.scale_width; it.value.tex_y = ~~ it.value.y / cast(f32) bmf.common.scale_height; it.value.tex_w = ~~ it.value.w / cast(f32) bmf.common.scale_width; it.value.tex_h = ~~ it.value.h / cast(f32) bmf.common.scale_height; - }); + } return bmf; } diff --git a/modules/bmfont/module.onyx b/modules/bmfont/module.onyx index a994d2ef..2fed33ce 100644 --- a/modules/bmfont/module.onyx +++ b/modules/bmfont/module.onyx @@ -1,6 +1,6 @@ /* TODO: - + - Add rendering SDF fonts generated using msdf-bmfont-xml from npm. diff --git a/modules/bmfont/position.onyx b/modules/bmfont/position.onyx index 6cd60255..7f16298b 100644 --- a/modules/bmfont/position.onyx +++ b/modules/bmfont/position.onyx @@ -75,7 +75,7 @@ get_character_positions :: (font: ^BMFont, size: f32, text: str, x: f32, y: f32) } renderable_glyph.pos_x = math.floor(rc.x + ~~glyph.xoffset * rc.size + .5); - renderable_glyph.pos_y = math.floor(rc.y + ~~glyph.yoffset * rc.size - rc.baseline + .5); + renderable_glyph.pos_y = math.floor(rc.y + ~~glyph.yoffset * rc.size + .5) - math.floor(rc.baseline); renderable_glyph.pos_w = math.floor(~~glyph.w * rc.size + .5); renderable_glyph.pos_h = math.floor(~~glyph.h * rc.size + .5); @@ -84,8 +84,8 @@ get_character_positions :: (font: ^BMFont, size: f32, text: str, x: f32, y: f32) renderable_glyph.tex_w = glyph.tex_w; renderable_glyph.tex_h = glyph.tex_h; - renderable_glyph.x_advance = ~~glyph.xadvance * rc.size; - rc.x += ~~glyph.xadvance * rc.size; + renderable_glyph.x_advance = math.floor(~~glyph.xadvance * rc.size + 0.5); + rc.x += math.floor(~~glyph.xadvance * rc.size + 0.5); return ^renderable_glyph, true; } diff --git a/modules/bmfont/types.onyx b/modules/bmfont/types.onyx index 9dfe0f6e..b59325ab 100644 --- a/modules/bmfont/types.onyx +++ b/modules/bmfont/types.onyx @@ -10,9 +10,7 @@ BMFont :: struct { pages : Map(i32, str); glyphs : Map(i32, BMFont_Glyph); - get_glyph :: (use bmfont: ^BMFont, char: u8) -> ^BMFont_Glyph { - return map.get_ptr(^glyphs, ~~char); - } + get_glyph :: (use bmfont: ^BMFont, char: u8) => ^glyphs[~~char]; } BMFont_Info :: struct { @@ -76,4 +74,4 @@ BMFont_Glyph :: struct { tex_y: f32 = 0; tex_w: f32 = 0; tex_h: f32 = 0; -} \ No newline at end of file +} diff --git a/modules/bmfont/utils.onyx b/modules/bmfont/utils.onyx index f01e1a32..5e61f5c9 100644 --- a/modules/bmfont/utils.onyx +++ b/modules/bmfont/utils.onyx @@ -2,7 +2,6 @@ package bmfont #private_file math :: package core.math -@Incomplete // does not use the size parameter get_width :: (use font: ^BMFont, text: str, size: f32) -> f32 { max_x := 0.0f; x := 0.0f; @@ -60,4 +59,4 @@ get_height :: (use font: ^BMFont, text: str, size: f32) -> f32 { return y + max_y; } -} \ No newline at end of file +} diff --git a/modules/json/decoder.onyx b/modules/json/decoder.onyx index 39c9e902..c0771f2d 100644 --- a/modules/json/decoder.onyx +++ b/modules/json/decoder.onyx @@ -8,12 +8,12 @@ decode :: (data: str, allocator := context.allocator) -> Json { json.root = null; root, err := parse(data, allocator); - if err != .None { - switch err { - case .EOF do println("Reached EOF"); - case .Illegal_Character do println("Illegal Character"); - case .String_Unterminated do println("Unterminated String"); - case .Unexpected_Token do println("Unexpected Token"); + if err.kind != .None { + switch err.kind { + case .EOF do printf("Reached EOF\n"); + case .Illegal_Character do printf("Illegal Character: {}\n", err.pos); + case .String_Unterminated do printf("Unterminated String: {}\n", err.pos); + case .Unexpected_Token do printf("Unexpected Token: {}\n", err.pos); } return json; diff --git a/modules/json/parser.onyx b/modules/json/parser.onyx index 52edaa65..68f03efa 100644 --- a/modules/json/parser.onyx +++ b/modules/json/parser.onyx @@ -47,8 +47,9 @@ consume_token_if_next :: (use parser: ^Parser, kind: Token.Kind) -> bool { expect_token :: (use parser: ^Parser, kind: Token.Kind) -> (Token, Error) { previous := current_token; consume_token(parser); - if previous.kind == kind do return previous, .None; - else do return previous, .Unexpected_Token; + error := Error.{ .None, previous.position }; + if previous.kind != kind do error.kind = .Unexpected_Token; + return previous, error; } #private @@ -98,25 +99,25 @@ parse_value :: (use parser: ^Parser) -> (^Value, Error) { case .Open_Bracket { value, err := parse_array(parser); - if err != .None do return value, err; + if err.kind != .None do return value, err; return_value = value; } case .Open_Brace { value, err := parse_object(parser); - if err != .None do return value, err; + if err.kind != .None do return value, err; return_value = value; } case #default { consume_token(parser); - return return_value, .Unexpected_Token; + return return_value, .{ .Unexpected_Token, current.position }; } } - return return_value, .None; + return return_value, .{ .None }; } #private_file @@ -124,11 +125,11 @@ parse_array :: (use parser: ^Parser) -> (^Value_Array, Error) { value := new(Value_Array, allocator); _, err := expect_token(parser, .Open_Bracket); - if err != .None do return value, err; + if err.kind != .None do return value, err; // This uses the context allocators because the array resizing needs to happen in a general purpose heap allocator arr := array.make(#type ^Value, allocator=context.allocator); - defer if err != .None { + defer if err.kind != .None { for elem: arr { free(elem, allocator); } @@ -138,7 +139,7 @@ parse_array :: (use parser: ^Parser) -> (^Value_Array, Error) { while current_token.kind != .Close_Bracket { elem, elem_err := parse_value(parser); - if elem_err != .None { + if elem_err.kind != .None { err = elem_err; return value, err; } @@ -151,7 +152,7 @@ parse_array :: (use parser: ^Parser) -> (^Value_Array, Error) { } _, close_err := expect_token(parser, .Close_Bracket); - if close_err != .None { + if close_err.kind != .None { err = close_err; return value, err; } @@ -166,17 +167,17 @@ parse_object :: (use parser: ^Parser) -> (^Value_Object, Error) { value := new(Value_Object, allocator); _, err := expect_token(parser, .Open_Brace); - if err != .None do return value, err; + if err.kind != .None do return value, err; // This uses the context allocators because the array resizing needs to happen in a general purpose heap allocator array.init(^value.object_, allocator=context.allocator); - defer if err != .None { + defer if err.kind != .None { free(value, allocator); } while current_token.kind != .Close_Brace { key_token, key_err := expect_token(parser, .String); - if key_err != .None { + if key_err.kind != .None { err = key_err; return value, err; } @@ -184,13 +185,13 @@ parse_object :: (use parser: ^Parser) -> (^Value_Object, Error) { key := unescape_string(key_token, allocator); _, colon_err := expect_token(parser, .Colon); - if colon_err != .None { + if colon_err.kind != .None { err = colon_err; return value, err; } elem, elem_err := parse_value(parser); - if elem_err != .None { + if elem_err.kind != .None { err = elem_err; return value, err; } @@ -199,7 +200,8 @@ parse_object :: (use parser: ^Parser) -> (^Value_Object, Error) { #if false { for elem: value.object_ { if elem.key == key { - err = .Duplicate_Keys; + err.kind = .Duplicate_Keys; + err.pos = key_token.pos; string.free(key, allocator); return value, err; } @@ -217,7 +219,7 @@ parse_object :: (use parser: ^Parser) -> (^Value_Object, Error) { } _, close_err := expect_token(parser, .Close_Brace); - if close_err != .None { + if close_err.kind != .None { err = close_err; return value, err; } @@ -321,4 +323,4 @@ unescape_string :: (token: Token, allocator: Allocator) -> str { buffer.count = buffer_write; return buffer; -} \ No newline at end of file +} diff --git a/modules/json/tokenizer.onyx b/modules/json/tokenizer.onyx index 5db0009f..0bb7eea4 100644 --- a/modules/json/tokenizer.onyx +++ b/modules/json/tokenizer.onyx @@ -48,7 +48,7 @@ Position :: struct { #private token_get :: (use tkn: ^Tokenizer) -> (Token, Error) { - err := Error.None; + err := Error.{}; skip_whitespace(tkn); token := Token.{}; @@ -56,7 +56,7 @@ token_get :: (use tkn: ^Tokenizer) -> (Token, Error) { curr_char := data[offset]; next_char, has_next := next_character(tkn); - if !has_next do return .{}, .EOF; + if !has_next do return .{}, .{ .EOF, token.position }; switch curr_char { case #char "{" do token.kind = .Open_Brace; @@ -77,11 +77,11 @@ token_get :: (use tkn: ^Tokenizer) -> (Token, Error) { } case #char "-" { - next_character(tkn); switch data[offset] { case #char "0" .. #char "9" --- case #default { - err = .Illegal_Character; + err.kind = .Illegal_Character; + err.pos = token.position; break break; } } @@ -114,7 +114,8 @@ token_get :: (use tkn: ^Tokenizer) -> (Token, Error) { while offset < data.count { ch := data[offset]; if ch == #char "\n" { - err = .String_Unterminated; + err.kind = .String_Unterminated; + err.pos = token.position; break break; } @@ -132,7 +133,7 @@ token_get :: (use tkn: ^Tokenizer) -> (Token, Error) { token.text = data.data[token.offset .. offset]; - if token.kind == .Invalid do err = .Illegal_Character; + if token.kind == .Invalid do err.kind = .Illegal_Character; return token, err; } @@ -143,7 +144,7 @@ next_character :: (use tkn: ^Tokenizer) -> (u8, bool) { retval := data[offset]; offset += 1; - column += offset; + column += 1; return retval, true; } @@ -217,4 +218,4 @@ skip_escape :: (use tkn: ^Tokenizer) { next_character(tkn); } } -} \ No newline at end of file +} diff --git a/modules/json/types.onyx b/modules/json/types.onyx index 2f6567ef..49bc0242 100644 --- a/modules/json/types.onyx +++ b/modules/json/types.onyx @@ -13,14 +13,20 @@ Json :: struct { root: ^Value; } -Error :: enum { - None; - EOF; - Illegal_Character; - String_Unterminated; - Unexpected_Token; +Error :: struct { + Kind :: enum { + None; + EOF; + Illegal_Character; + String_Unterminated; + Unexpected_Token; + } + + kind := Kind.None; + use pos := Position.{ 0, 1, 1 }; } + Value :: struct { Type :: enum { Null :: 0x00; -- 2.25.1