comparing 4cacad16218ba85d7d7f7566b2b3de46574c7d60 and trunk on pci.express/flanterm.zig

+2 -1

.gitignore

+1 -1

README.md

···

       35
       35
        
       To then print to the terminal instance, simply use the `flanterm_write()`

     

       36
       36
        
       function on the given instance. For example:

     

       37
       37
        
       ```c

     

       38
       38
       -
       #include <flanterm/flanterm.h>

     

       38
       38
       +
       #include <flanterm.h>

     

       39
       39
        
       

     

       40
       40
        
       const char msg[] = "Hello world\n";

     

       41
       41

+17

README.zig.md

···

       1
       1
       +
       # Flanterm

     

       2
       2
       +
       Adapted from [https://codeberg.org/Mintsuki/Flanterm](https://codeberg.org/Mintsuki/Flanterm)

     

       3
       3
       +
       for Zig. Read the C code and original README for more information.

     

       4
       4
       +
       

     

       5
       5
       +
       ## Usage

     

       6
       6
       +
       First, add the package to your build.zig.zon:

     

       7
       7
       +
       `zig fetch --save git+https://tangled.sh/@sydney.blue/flanterm.zig#trunk`

     

       8
       8
       +
       Then, add the following to your build.zig:

     

       9
       9
       +
       ```zig

     

       10
       10
       +
       const flanterm_dep = b.dependency("flanterm", .{});

     

       11
       11
       +
       const flanterm_mod = flanterm.module("flanterm");

     

       12
       12
       +
       exe.root_module.addImport("flanterm", flanterm_mod);

     

       13
       13
       +
       ```

     

       14
       14
       +
       

     

       15
       15
       +
       Now, you can import the `flanterm` module and use the helpers. More

     

       16
       16
       +
       bindings will be added as needed, feel free to contribute anything

     

       17
       17
       +
       you would find useful.

+17

build.zig

···

       1
       1
       +
       const std = @import("std");

     

       2
       2
       +
       

     

       3
       3
       +
       pub fn build(b: *std.Build) void {

     

       4
       4
       +
           // Create the exported module

     

       5
       5
       +
           const mod = b.addModule("flanterm", .{

     

       6
       6
       +
               .root_source_file = b.path("src/root.zig"),

     

       7
       7
       +
           });

     

       8
       8
       +
       

     

       9
       9
       +
           // Add the C source files and includes

     

       10
       10
       +
           mod.addIncludePath(b.path("src"));

     

       11
       11
       +
           mod.addCSourceFiles(.{

     

       12
       12
       +
               .files = &.{

     

       13
       13
       +
                   "src/flanterm.c",

     

       14
       14
       +
                   "src/flanterm_backends/fb.c",

     

       15
       15
       +
               },

     

       16
       16
       +
           });

     

       17
       17
       +
       }

+15

build.zig.zon

···

       1
       1
       +
       .{

     

       2
       2
       +
           .name = .flanterm,

     

       3
       3
       +
           .version = "2.0.0",

     

       4
       4
       +
           .fingerprint = 0x5e517d869e9f7b42, // Changing this has security and trust implications.

     

       5
       5
       +
           .minimum_zig_version = "0.15.1",

     

       6
       6
       +
           .dependencies = .{},

     

       7
       7
       +
           .paths = .{

     

       8
       8
       +
               "build.zig",

     

       9
       9
       +
               "build.zig.zon",

     

       10
       10
       +
               "src",

     

       11
       11
       +
               "LICENSE",

     

       12
       12
       +
               "README.md",

     

       13
       13
       +
               ".gitignore",

     

       14
       14
       +
           },

     

       15
       15
       +
       }

+60

src/colors.zig

···

       1
       1
       +
       const std = @import("std");

     

       2
       2
       +
       

     

       3
       3
       +
       pub const Palette = extern struct {

     

       4
       4
       +
           black: u32,

     

       5
       5
       +
           red: u32,

     

       6
       6
       +
           green: u32,

     

       7
       7
       +
           yellow: u32,

     

       8
       8
       +
           blue: u32,

     

       9
       9
       +
           magenta: u32,

     

       10
       10
       +
           cyan: u32,

     

       11
       11
       +
           white: u32,

     

       12
       12
       +
       };

     

       13
       13
       +
       

     

       14
       14
       +
       /// Used for escape sequences

     

       15
       15
       +
       pub const Color = enum(u8) {

     

       16
       16
       +
           black = 30,

     

       17
       17
       +
           red = 31,

     

       18
       18
       +
           green = 32,

     

       19
       19
       +
           yellow = 33,

     

       20
       20
       +
           blue = 34,

     

       21
       21
       +
           magenta = 35,

     

       22
       22
       +
           cyan = 36,

     

       23
       23
       +
           white = 37,

     

       24
       24
       +
           default = 39,

     

       25
       25
       +
           bright_black = 90,

     

       26
       26
       +
           bright_red = 91,

     

       27
       27
       +
           bright_green = 92,

     

       28
       28
       +
           bright_yellow = 93,

     

       29
       29
       +
           bright_blue = 94,

     

       30
       30
       +
           bright_magenta = 95,

     

       31
       31
       +
           bright_cyan = 96,

     

       32
       32
       +
           bright_white = 97,

     

       33
       33
       +
       

     

       34
       34
       +
           pub fn esc_seq(comptime self: Color) []const u8 {

     

       35
       35
       +
               if (self == .default) return "\x1b[0m";

     

       36
       36
       +
               return std.fmt.comptimePrint("\x1b[{}m", .{@intFromEnum(self)});

     

       37
       37
       +
           }

     

       38
       38
       +
       };

     

       39
       39
       +
       

     

       40
       40
       +
       pub var default_colors: Palette = .{

     

       41
       41
       +
           .black = 0x000000,

     

       42
       42
       +
           .red = 0xff0000,

     

       43
       43
       +
           .green = 0x37dd21,

     

       44
       44
       +
           .yellow = 0xfee409,

     

       45
       45
       +
           .blue = 0x1460d2,

     

       46
       46
       +
           .magenta = 0xff005d,

     

       47
       47
       +
           .cyan = 0x00bbbb,

     

       48
       48
       +
           .white = 0xbbbbbb,

     

       49
       49
       +
       };

     

       50
       50
       +
       

     

       51
       51
       +
       pub var default_bold_colors: Palette = .{

     

       52
       52
       +
           .black = 0x545454,

     

       53
       53
       +
           .red = 0xf40d17,

     

       54
       54
       +
           .green = 0x3bcf1d,

     

       55
       55
       +
           .yellow = 0xecc809,

     

       56
       56
       +
           .blue = 0x5555ff,

     

       57
       57
       +
           .magenta = 0xff55ff,

     

       58
       58
       +
           .cyan = 0x6ae3f9,

     

       59
       59
       +
           .white = 0xffffff,

     

       60
       60
       +
       };

+50 -14

src/flanterm.c

···

       35
       35
        
       #include <stddef.h>

     

       36
       36
        
       #include <stdbool.h>

     

       37
       37
        
       

     

       38
       38
       +
       #ifndef FLANTERM_IN_FLANTERM

     

       38
       39
        
       #define FLANTERM_IN_FLANTERM

     

       40
       40
       +
       #endif

     

       39
       41
        
       

     

       40
       42
        
       #include "flanterm.h"

     

       41
       43
        
       

     
···

       94
       96
        
           ctx->reverse_video = false;

     

       95
       97
        
           ctx->dec_private = false;

     

       96
       98
        
           ctx->insert_mode = false;

     

       99
       99
       +
           ctx->csi_unhandled = false;

     

       97
       100
        
           ctx->unicode_remaining = 0;

     

       98
       101
        
           ctx->g_select = 0;

     

       99
       102
        
           ctx->charsets[0] = CHARSET_DEFAULT;

     
···

       461
       464
        
           }

     

       462
       465
        
       }

     

       463
       466
        
       

     

       464
       464
       -
       static void osc_parse(struct flanterm_context *ctx, uint8_t c) {

     

       465
       465
       -
           if (ctx->osc_escape && c == '\\') {

     

       466
       466
       -
               goto cleanup;

     

       467
       467
       +
       static bool osc_parse(struct flanterm_context *ctx, uint8_t c) {

     

       468
       468
       +
           // ESC \ terminates an OSC sequence cleanly

     

       469
       469
       +
           // but if ESC is followed by non-\, report failure from osc_parse and

     

       470
       470
       +
           // try parsing the character as another escape code

     

       471
       471
       +
           if (ctx->osc_escape) {

     

       472
       472
       +
               if (c == '\\') {

     

       473
       473
       +
                   ctx->osc = false;

     

       474
       474
       +
                   ctx->osc_escape = false;

     

       475
       475
       +
                   ctx->escape = false;

     

       476
       476
       +
                   return true;

     

       477
       477
       +
               } else {

     

       478
       478
       +
                   ctx->osc_escape = false;

     

       479
       479
       +
                   ctx->osc = false;

     

       480
       480
       +
                   // escape stays true here

     

       481
       481
       +
                   return false;

     

       482
       482
       +
               }

     

       467
       483
        
           }

     

       468
       468
       -
       

     

       469
       469
       -
           ctx->osc_escape = false;

     

       470
       470
       -
       

     

       471
       484
        
           switch (c) {

     

       472
       485
        
               case 0x1b:

     

       473
       486
        
                   ctx->osc_escape = true;

     

       474
       474
       -
                   return;

     

       487
       487
       +
                   break;

     

       488
       488
       +
               // BEL is the other terminator 

     

       475
       489
        
               case '\a':

     

       490
       490
       +
                   ctx->osc_escape = false;

     

       491
       491
       +
                   ctx->osc = false;

     

       492
       492
       +
                   ctx->escape = false;

     

       493
       493
       +
                   break;

     

       476
       494
        
               default:

     

       477
       495
        
                   break;

     

       478
       496
        
           }

     

       479
       479
       -
       

     

       480
       480
       -
       cleanup:

     

       481
       481
       -
           ctx->osc_escape = false;

     

       482
       482
       -
           ctx->osc = false;

     

       483
       483
       -
           ctx->escape = false;

     

       497
       497
       +
           return true;

     

       484
       498
        
       }

     

       485
       499
        
       

     

       486
       500
        
       static void control_sequence_parse(struct flanterm_context *ctx, uint8_t c) {

     
···

       540
       554
        
           ctx->scroll_enabled = false;

     

       541
       555
        
           size_t x, y;

     

       542
       556
        
           ctx->get_cursor_pos(ctx, &x, &y);

     

       557
       557
       +
          

     

       558
       558
       +
           // CSI sequences are terminated by a byte in [0x40,0x7E]

     

       559
       559
       +
           // so skip all bytes until the terminator byte

     

       560
       560
       +
           if (ctx->csi_unhandled) {

     

       561
       561
       +
               if (c >= 0x40 && c <= 0x7E) {

     

       562
       562
       +
                   ctx->csi_unhandled = false;

     

       563
       563
       +
                   goto cleanup;

     

       564
       564
       +
               }

     

       565
       565
       +
               return;

     

       566
       566
       +
           }

     

       543
       567
        
       

     

       544
       568
        
           switch (c) {

     

       569
       569
       +
               // Got ESC in the middle of an escape sequence, start a new one

     

       570
       570
       +
               case 0x1B:

     

       571
       571
       +
                   return;

     

       545
       572
        
               case 'F':

     

       546
       573
        
                   x = 0;

     

       547
       574
        
                   // FALLTHRU

     
···

       780
       807
        
               case ']':

     

       781
       808
        
                   linux_private_parse(ctx);

     

       782
       809
        
                   break;

     

       810
       810
       +
               default:

     

       811
       811
       +
                   ctx->csi_unhandled = true;

     

       812
       812
       +
                   return;

     

       783
       813
        
           }

     

       784
       814
        
       

     

       785
       815
        
           ctx->scroll_enabled = r;

     
···

       815
       845
        
           ctx->escape_offset++;

     

       816
       846
        
       

     

       817
       847
        
           if (ctx->osc == true) {

     

       818
       818
       -
               osc_parse(ctx, c);

     

       819
       819
       -
               return;

     

       848
       848
       +
               // ESC \ is one of the two possible terminators of OSC sequences,

     

       849
       849
       +
               // so osc_parse consumes ESC.

     

       850
       850
       +
               // If it is then followed by \ it cleans correctly,

     

       851
       851
       +
               // otherwise it returns false, and it tries parsing it as another escape sequence

     

       852
       852
       +
               if (osc_parse(ctx, c)) {

     

       853
       853
       +
                   return;

     

       854
       854
       +
               }

     

       820
       855
        
           }

     

       821
       856
        
       

     

       822
       857
        
           if (ctx->control_sequence == true) {

     
···

       837
       872
        
                       ctx->esc_values[i] = 0;

     

       838
       873
        
                   ctx->esc_values_i = 0;

     

       839
       874
        
                   ctx->rrr = false;

     

       875
       875
       +
                   ctx->csi_unhandled = false;

     

       840
       876
        
                   ctx->control_sequence = true;

     

       841
       877
        
                   return;

     

       842
       878
        
               case '7':

src/flanterm_backends/fb.c

···

       43
       43
        
       #include <stddef.h>

     

       44
       44
        
       #include <stdbool.h>

     

       45
       45
        
       

     

       46
       46
       +
       #ifndef FLANTERM_IN_FLANTERM

     

       46
       47
        
       #define FLANTERM_IN_FLANTERM

     

       48
       48
       +
       #endif

     

       47
       49
        
       

     

       48
       50
        
       #include "../flanterm.h"

     

       49
       51
        
       #include "fb.h"

src/flanterm_private.h

···

       58
       58
        
           bool reverse_video;

     

       59
       59
        
           bool dec_private;

     

       60
       60
        
           bool insert_mode;

     

       61
       61
       +
           bool csi_unhandled;

     

       61
       62
        
           uint64_t code_point;

     

       62
       63
        
           size_t unicode_remaining;

     

       63
       64
        
           uint8_t g_select;

+92

src/root.zig

···

       1
       1
       +
       pub const Colors = @import("colors.zig");

     

       2
       2
       +
       const std = @import("std");

     

       3
       3
       +
       const c = @cImport({

     

       4
       4
       +
           @cInclude("flanterm.h");

     

       5
       5
       +
           @cInclude("flanterm_backends/fb.h");

     

       6
       6
       +
       });

     

       7
       7
       +
       

     

       8
       8
       +
       pub const Context = struct {

     

       9
       9
       +
           backing: ?*c.struct_flanterm_context,

     

       10
       10
       +
       

     

       11
       11
       +
           const Self = @This();

     

       12
       12
       +
       

     

       13
       13
       +
           /// Initialize the context

     

       14
       14
       +
           pub fn init(

     

       15
       15
       +
               args: struct {

     

       16
       16
       +
                   // Malloc and Free

     

       17
       17
       +
                   malloc: ?*const fn (usize) callconv(.c) ?*anyopaque = null,

     

       18
       18
       +
                   free: ?*const fn (?*anyopaque, usize) callconv(.c) void = null,

     

       19
       19
       +
                   // Framebuffer Info (required)

     

       20
       20
       +
                   fb: [*]u32,

     

       21
       21
       +
                   width: usize,

     

       22
       22
       +
                   height: usize,

     

       23
       23
       +
                   pitch: usize,

     

       24
       24
       +
                   // Framebuffer Color Info

     

       25
       25
       +
                   red_mask_size: u8,

     

       26
       26
       +
                   red_mask_shift: u8,

     

       27
       27
       +
                   green_mask_size: u8,

     

       28
       28
       +
                   green_mask_shift: u8,

     

       29
       29
       +
                   blue_mask_size: u8,

     

       30
       30
       +
                   blue_mask_shift: u8,

     

       31
       31
       +
                   // Canvas (scratch space)

     

       32
       32
       +
                   canvas: ?[*]u32 = null,

     

       33
       33
       +
                   // Color Pointers

     

       34
       34
       +
                   ansi_colours: *Colors.Palette = &Colors.default_colors,

     

       35
       35
       +
                   ansi_bright_colours: *Colors.Palette = &Colors.default_bold_colors,

     

       36
       36
       +
                   // Default Color choices

     

       37
       37
       +
                   default_bg: *u32 = &Colors.default_colors.black,

     

       38
       38
       +
                   default_fg: *u32 = &Colors.default_colors.cyan,

     

       39
       39
       +
                   default_bg_bright: *u32 = &Colors.default_bold_colors.black,

     

       40
       40
       +
                   default_fg_bright: *u32 = &Colors.default_bold_colors.cyan,

     

       41
       41
       +
                   // Font Information

     

       42
       42
       +
                   font: ?*anyopaque = null,

     

       43
       43
       +
                   font_width: usize = 0,

     

       44
       44
       +
                   font_height: usize = 0,

     

       45
       45
       +
                   font_spacing: usize = 1,

     

       46
       46
       +
                   // Font Scale values

     

       47
       47
       +
                   font_scale_x: usize = 0,

     

       48
       48
       +
                   font_scale_y: usize = 0,

     

       49
       49
       +
                   // Margin

     

       50
       50
       +
                   margin: usize = 0,

     

       51
       51
       +
               },

     

       52
       52
       +
           ) Self {

     

       53
       53
       +
               const ansi_colours: [*]u32 = @ptrCast(args.ansi_colours);

     

       54
       54
       +
               const ansi_bright_colours: [*]u32 = @ptrCast(args.ansi_bright_colours);

     

       55
       55
       +
               const ctx = c.flanterm_fb_init(

     

       56
       56
       +
                   args.malloc,

     

       57
       57
       +
                   args.free,

     

       58
       58
       +
                   args.fb,

     

       59
       59
       +
                   args.width,

     

       60
       60
       +
                   args.height,

     

       61
       61
       +
                   args.pitch,

     

       62
       62
       +
                   args.red_mask_size,

     

       63
       63
       +
                   args.red_mask_shift,

     

       64
       64
       +
                   args.green_mask_size,

     

       65
       65
       +
                   args.green_mask_shift,

     

       66
       66
       +
                   args.blue_mask_size,

     

       67
       67
       +
                   args.blue_mask_shift,

     

       68
       68
       +
                   args.canvas,

     

       69
       69
       +
                   ansi_colours,

     

       70
       70
       +
                   ansi_bright_colours,

     

       71
       71
       +
                   args.default_bg,

     

       72
       72
       +
                   args.default_fg,

     

       73
       73
       +
                   args.default_bg_bright,

     

       74
       74
       +
                   args.default_fg_bright,

     

       75
       75
       +
                   args.font,

     

       76
       76
       +
                   args.font_width,

     

       77
       77
       +
                   args.font_height,

     

       78
       78
       +
                   args.font_spacing,

     

       79
       79
       +
                   args.font_scale_x,

     

       80
       80
       +
                   args.font_scale_y,

     

       81
       81
       +
                   args.margin,

     

       82
       82
       +
               );

     

       83
       83
       +
               return .{

     

       84
       84
       +
                   .backing = ctx,

     

       85
       85
       +
               };

     

       86
       86
       +
           }

     

       87
       87
       +
       

     

       88
       88
       +
           /// Write to the console

     

       89
       89
       +
           pub fn write_slice(self: *Self, buf: []u8) void {

     

       90
       90
       +
               c.flanterm_write(self.backing, buf.ptr, buf.len);

     

       91
       91
       +
           }

     

       92
       92
       +
       };

Compare changes