comparing 65e0bd7b631d3a724c5a0c0b1a64e0fa796884cb and trunk on pci.express/flanterm.zig

.gitignore

+18 -5

LICENSE

···

       1
       1
       -
       Copyright (C) 2022-2023 mintsuki and contributors.

     

       1
       1
       +
       Copyright (C) 2022-2025 mintsuki and contributors.

     

       2
       2
        
       

     

       3
       3
       -
       Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

     

       3
       3
       +
       Redistribution and use in source and binary forms, with or without

     

       4
       4
       +
       modification, are permitted provided that the following conditions are met:

     

       4
       5
        
       

     

       5
       5
       -
       1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.

     

       6
       6
       +
       1. Redistributions of source code must retain the above copyright notice, this

     

       7
       7
       +
          list of conditions and the following disclaimer.

     

       6
       8
        
       

     

       7
       7
       -
       2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

     

       9
       9
       +
       2. Redistributions in binary form must reproduce the above copyright notice,

     

       10
       10
       +
          this list of conditions and the following disclaimer in the documentation

     

       11
       11
       +
          and/or other materials provided with the distribution.

     

       8
       12
        
       

     

       9
       9
       -
       THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

     

       13
       13
       +
       THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND

     

       14
       14
       +
       ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

     

       15
       15
       +
       WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

     

       16
       16
       +
       DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE

     

       17
       17
       +
       FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

     

       18
       18
       +
       DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR

     

       19
       19
       +
       SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER

     

       20
       20
       +
       CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,

     

       21
       21
       +
       OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

     

       22
       22
       +
       OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

+23 -9

README.md

···

       6
       6
        
       ### Quick usage

     

       7
       7
        
       

     

       8
       8
        
       To quickly set up and use a framebuffer Flanterm instance, it is possible to

     

       9
       9
       -
       use the `flanterm_fb_simple_init()` function as such:

     

       9
       9
       +
       use the `flanterm_fb_init()` function as such:

     

       10
       10
        
       ```c

     

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

     

       12
       12
       -
       #include <flanterm/backends/fb.h>

     

       11
       11
       +
       #include <flanterm.h>

     

       12
       12
       +
       #include <flanterm_backends/fb.h>

     

       13
       13
        
       

     

       14
       14
       -
       struct flanterm_context *ft_ctx = flanterm_fb_simple_init(

     

       15
       15
       -
           framebuffer_ptr, framebuffer_width, framebuffer_height, framebuffer_pitch

     

       16
       16
       -
       );

     

       14
       14
       +
       struct flanterm_context *ft_ctx = flanterm_fb_init(

     

       15
       15
       +
               NULL,

     

       16
       16
       +
               NULL,

     

       17
       17
       +
               framebuffer_ptr, width, height, pitch,

     

       18
       18
       +
               red_mask_size, red_mask_shift,

     

       19
       19
       +
               green_mask_size, green_mask_shift,

     

       20
       20
       +
               blue_mask_size, blue_mask_shift,

     

       21
       21
       +
               NULL,

     

       22
       22
       +
               NULL, NULL,

     

       23
       23
       +
               NULL, NULL,

     

       24
       24
       +
               NULL, NULL,

     

       25
       25
       +
               NULL, 0, 0, 1,

     

       26
       26
       +
               0, 0,

     

       27
       27
       +
               0

     

       28
       28
       +
           );

     

       17
       29
        
       ```

     

       18
       18
       -
       Where `framebuffer_{ptr,width,height,pitch}` represent the corresponding info

     

       19
       19
       -
       about the framebuffer to use for this given instance.

     

       30
       30
       +
       Where `framebuffer_ptr, width, height, pitch` and `{red,green,blue}_mask_{size,shift}`

     

       31
       31
       +
       represent the corresponding info about the framebuffer to use for this given instance.

     

       32
       32
       +
       

     

       33
       33
       +
       The meaning of the other arguments can be found in `flanterm_backends/fb.h`.

     

       20
       34
        
       

     

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

     

       22
       36
        
       function on the given instance. For example:

     

       23
       37
        
       ```c

     

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

     

       38
       38
       +
       #include <flanterm.h>

     

       25
       39
        
       

     

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

     

       27
       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.

-1160

backends/fb.c

···

       1
       1
       -
       /* Copyright (C) 2022-2023 mintsuki and contributors.

     

       2
       2
       -
        *

     

       3
       3
       -
        * Redistribution and use in source and binary forms, with or without

     

       4
       4
       -
        * modification, are permitted provided that the following conditions are met:

     

       5
       5
       -
        *

     

       6
       6
       -
        * 1. Redistributions of source code must retain the above copyright notice,

     

       7
       7
       -
        *    this list of conditions and the following disclaimer.

     

       8
       8
       -
        *

     

       9
       9
       -
        * 2. Redistributions in binary form must reproduce the above copyright notice,

     

       10
       10
       -
        *    this list of conditions and the following disclaimer in the documentation

     

       11
       11
       -
        *    and/or other materials provided with the distribution.

     

       12
       12
       -
        *

     

       13
       13
       -
        * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

     

       14
       14
       -
        * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

     

       15
       15
       -
        * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

     

       16
       16
       -
        * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE

     

       17
       17
       -
        * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

     

       18
       18
       -
        * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

     

       19
       19
       -
        * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

     

       20
       20
       -
        * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

     

       21
       21
       -
        * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

     

       22
       22
       -
        * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

     

       23
       23
       -
        * POSSIBILITY OF SUCH DAMAGE.

     

       24
       24
       -
        */

     

       25
       25
       -
       

     

       26
       26
       -
       #include <stdint.h>

     

       27
       27
       -
       #include <stddef.h>

     

       28
       28
       -
       

     

       29
       29
       -
       #include "../flanterm.h"

     

       30
       30
       -
       #include "fb.h"

     

       31
       31
       -
       

     

       32
       32
       -
       void *memset(void *, int, size_t);

     

       33
       33
       -
       void *memcpy(void *, const void *, size_t);

     

       34
       34
       -
       

     

       35
       35
       -
       #ifndef FLANTERM_FB_DISABLE_BUMP_ALLOC

     

       36
       36
       -
       

     

       37
       37
       -
       #ifndef FLANTERM_FB_BUMP_ALLOC_POOL_SIZE

     

       38
       38
       -
       #define FLANTERM_FB_BUMP_ALLOC_POOL_SIZE (64*1024*1024)

     

       39
       39
       -
       #endif

     

       40
       40
       -
       

     

       41
       41
       -
       static uint8_t bump_alloc_pool[FLANTERM_FB_BUMP_ALLOC_POOL_SIZE];

     

       42
       42
       -
       static size_t bump_alloc_ptr = 0;

     

       43
       43
       -
       

     

       44
       44
       -
       static void *bump_alloc(size_t s) {

     

       45
       45
       -
           size_t next_ptr = bump_alloc_ptr + s;

     

       46
       46
       -
           if (next_ptr > FLANTERM_FB_BUMP_ALLOC_POOL_SIZE) {

     

       47
       47
       -
               return NULL;

     

       48
       48
       -
           }

     

       49
       49
       -
           void *ret = &bump_alloc_pool[bump_alloc_ptr];

     

       50
       50
       -
           bump_alloc_ptr = next_ptr;

     

       51
       51
       -
           return ret;

     

       52
       52
       -
       }

     

       53
       53
       -
       

     

       54
       54
       -
       #endif

     

       55
       55
       -
       

     

       56
       56
       -
       // Builtin font originally taken from:

     

       57
       57
       -
       // https://github.com/viler-int10h/vga-text-mode-fonts/raw/master/FONTS/PC-OTHER/TOSH-SAT.F16

     

       58
       58
       -
       static const uint8_t builtin_font[] = {

     

       59
       59
       -
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       60
       60
       -
         0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x42, 0x81, 0x81, 0xa5, 0xa5, 0x81,

     

       61
       61
       -
         0x81, 0xa5, 0x99, 0x81, 0x42, 0x3c, 0x00, 0x00, 0x00, 0x3c, 0x7e, 0xff,

     

       62
       62
       -
         0xff, 0xdb, 0xdb, 0xff, 0xff, 0xdb, 0xe7, 0xff, 0x7e, 0x3c, 0x00, 0x00,

     

       63
       63
       -
         0x00, 0x00, 0x00, 0x6c, 0xfe, 0xfe, 0xfe, 0x7c, 0x7c, 0x38, 0x38, 0x10,

     

       64
       64
       -
         0x10, 0x00, 0x00, 0x00, 0x00, 0x10, 0x10, 0x38, 0x38, 0x7c, 0x7c, 0xfe,

     

       65
       65
       -
         0x7c, 0x7c, 0x38, 0x38, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18,

     

       66
       66
       -
         0x3c, 0x3c, 0xdb, 0xff, 0xff, 0xdb, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00,

     

       67
       67
       -
         0x00, 0x00, 0x00, 0x18, 0x3c, 0x7e, 0xff, 0xff, 0xff, 0x66, 0x18, 0x18,

     

       68
       68
       -
         0x3c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x78,

     

       69
       69
       -
         0x78, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,

     

       70
       70
       -
         0xff, 0xff, 0xe7, 0xc3, 0xc3, 0xe7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,

     

       71
       71
       -
         0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0xcc, 0x84, 0x84, 0xcc, 0x78, 0x00,

     

       72
       72
       -
         0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc3, 0x99, 0xbd,

     

       73
       73
       -
         0xbd, 0x99, 0xc3, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x1e,

     

       74
       74
       -
         0x0e, 0x1e, 0x32, 0x78, 0xcc, 0xcc, 0xcc, 0x78, 0x00, 0x00, 0x00, 0x00,

     

       75
       75
       -
         0x00, 0x00, 0x00, 0x78, 0xcc, 0xcc, 0xcc, 0x78, 0x30, 0xfc, 0x30, 0x30,

     

       76
       76
       -
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x18, 0x1c, 0x1e, 0x16, 0x12,

     

       77
       77
       -
         0x10, 0x10, 0x70, 0xf0, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x30, 0x38, 0x2c,

     

       78
       78
       -
         0x26, 0x32, 0x3a, 0x2e, 0x26, 0x22, 0x62, 0xe2, 0xc6, 0x0e, 0x0c, 0x00,

     

       79
       79
       -
         0x00, 0x00, 0x00, 0x18, 0x18, 0xdb, 0x3c, 0xe7, 0x3c, 0xdb, 0x18, 0x18,

     

       80
       80
       -
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xc0, 0xe0, 0xf8, 0xfe,

     

       81
       81
       -
         0xf8, 0xe0, 0xc0, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,

     

       82
       82
       -
         0x06, 0x0e, 0x3e, 0xfe, 0x3e, 0x0e, 0x06, 0x02, 0x00, 0x00, 0x00, 0x00,

     

       83
       83
       -
         0x00, 0x00, 0x30, 0x78, 0xfc, 0x30, 0x30, 0x30, 0x30, 0x30, 0xfc, 0x78,

     

       84
       84
       -
         0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,

     

       85
       85
       -
         0xcc, 0xcc, 0x00, 0xcc, 0xcc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7f, 0xdb,

     

       86
       86
       -
         0xdb, 0xdb, 0xdb, 0x7b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x00, 0x00, 0x00,

     

       87
       87
       -
         0x00, 0x00, 0x7c, 0xc6, 0x60, 0x38, 0x6c, 0xc6, 0xc6, 0x6c, 0x38, 0x0c,

     

       88
       88
       -
         0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       89
       89
       -
         0x00, 0x00, 0xfe, 0xfe, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x78,

     

       90
       90
       -
         0xfc, 0x30, 0x30, 0x30, 0x30, 0x30, 0xfc, 0x78, 0x30, 0xfc, 0x00, 0x00,

     

       91
       91
       -
         0x00, 0x00, 0x30, 0x78, 0xfc, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,

     

       92
       92
       -
         0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,

     

       93
       93
       -
         0x30, 0x30, 0xfc, 0x78, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       94
       94
       -
         0x00, 0x18, 0x0c, 0xfe, 0xfe, 0x0c, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       95
       95
       -
         0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x60, 0xfe, 0xfe, 0x60, 0x30, 0x00,

     

       96
       96
       -
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0,

     

       97
       97
       -
         0xc0, 0xc0, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       98
       98
       -
         0x00, 0x24, 0x66, 0xff, 0xff, 0x66, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       99
       99
       -
         0x00, 0x00, 0x00, 0x00, 0x10, 0x10, 0x38, 0x38, 0x7c, 0x7c, 0xfe, 0xfe,

     

       100
       100
       -
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xfe, 0x7c, 0x7c,

     

       101
       101
       -
         0x38, 0x38, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       102
       102
       -
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       103
       103
       -
         0x00, 0x00, 0x30, 0x78, 0x78, 0x78, 0x78, 0x30, 0x30, 0x30, 0x00, 0x30,

     

       104
       104
       -
         0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0x00,

     

       105
       105
       -
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6c, 0x6c,

     

       106
       106
       -
         0x6c, 0xfe, 0x6c, 0x6c, 0x6c, 0xfe, 0x6c, 0x6c, 0x6c, 0x00, 0x00, 0x00,

     

       107
       107
       -
         0x00, 0x18, 0x18, 0x7c, 0xc6, 0xc0, 0xc0, 0x7c, 0x06, 0x06, 0xc6, 0x7c,

     

       108
       108
       -
         0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0xc6, 0xc6, 0x0c, 0x0c, 0x18, 0x38,

     

       109
       109
       -
         0x30, 0x60, 0x60, 0xc6, 0xc6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x6c,

     

       110
       110
       -
         0x6c, 0x38, 0x30, 0x76, 0xde, 0xcc, 0xcc, 0xde, 0x76, 0x00, 0x00, 0x00,

     

       111
       111
       -
         0x00, 0x00, 0x18, 0x18, 0x18, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       112
       112
       -
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x30, 0x60, 0x60, 0x60, 0x60,

     

       113
       113
       -
         0x60, 0x60, 0x60, 0x30, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x30,

     

       114
       114
       -
         0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x30, 0x60, 0x00, 0x00, 0x00,

     

       115
       115
       -
         0x00, 0x00, 0x00, 0x00, 0x00, 0x6c, 0x38, 0xfe, 0x38, 0x6c, 0x00, 0x00,

     

       116
       116
       -
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x7e,

     

       117
       117
       -
         0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       118
       118
       -
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x30, 0x00, 0x00,

     

       119
       119
       -
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x00, 0x00, 0x00, 0x00,

     

       120
       120
       -
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       121
       121
       -
         0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x06,

     

       122
       122
       -
         0x0c, 0x0c, 0x18, 0x38, 0x30, 0x60, 0x60, 0xc0, 0xc0, 0x00, 0x00, 0x00,

     

       123
       123
       -
         0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xd6, 0xd6, 0xd6, 0xc6, 0xc6, 0xc6,

     

       124
       124
       -
         0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x38, 0x78, 0x18, 0x18, 0x18,

     

       125
       125
       -
         0x18, 0x18, 0x18, 0x18, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6,

     

       126
       126
       -
         0x06, 0x06, 0x0c, 0x18, 0x30, 0x60, 0xc0, 0xc0, 0xfe, 0x00, 0x00, 0x00,

     

       127
       127
       -
         0x00, 0x00, 0x7c, 0xc6, 0x06, 0x06, 0x3c, 0x06, 0x06, 0x06, 0x06, 0xc6,

     

       128
       128
       -
         0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x0c, 0x1c, 0x3c, 0x6c, 0xcc,

     

       129
       129
       -
         0xfe, 0x0c, 0x0c, 0x0c, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xc0,

     

       130
       130
       -
         0xc0, 0xc0, 0xfc, 0x06, 0x06, 0x06, 0x06, 0xc6, 0x7c, 0x00, 0x00, 0x00,

     

       131
       131
       -
         0x00, 0x00, 0x3c, 0x60, 0xc0, 0xc0, 0xfc, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6,

     

       132
       132
       -
         0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xc6, 0x06, 0x06, 0x0c, 0x18,

     

       133
       133
       -
         0x30, 0x30, 0x30, 0x30, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6,

     

       134
       134
       -
         0xc6, 0xc6, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00,

     

       135
       135
       -
         0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0x7e, 0x06, 0x06, 0x06, 0x0c,

     

       136
       136
       -
         0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18,

     

       137
       137
       -
         0x18, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       138
       138
       -
         0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x18, 0x18, 0x30, 0x00, 0x00,

     

       139
       139
       -
         0x00, 0x00, 0x06, 0x0c, 0x18, 0x30, 0x60, 0xc0, 0x60, 0x30, 0x18, 0x0c,

     

       140
       140
       -
         0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x00,

     

       141
       141
       -
         0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x60,

     

       142
       142
       -
         0x30, 0x18, 0x0c, 0x06, 0x0c, 0x18, 0x30, 0x60, 0xc0, 0x00, 0x00, 0x00,

     

       143
       143
       -
         0x00, 0x00, 0x7c, 0xc6, 0xc6, 0x06, 0x0c, 0x18, 0x30, 0x30, 0x00, 0x30,

     

       144
       144
       -
         0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xde, 0xde,

     

       145
       145
       -
         0xde, 0xde, 0xc0, 0xc0, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x6c,

     

       146
       146
       -
         0xc6, 0xc6, 0xc6, 0xc6, 0xfe, 0xc6, 0xc6, 0xc6, 0xc6, 0x00, 0x00, 0x00,

     

       147
       147
       -
         0x00, 0x00, 0xfc, 0xc6, 0xc6, 0xc6, 0xfc, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6,

     

       148
       148
       -
         0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6, 0xc0, 0xc0, 0xc0, 0xc0,

     

       149
       149
       -
         0xc0, 0xc0, 0xc0, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xcc,

     

       150
       150
       -
         0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xcc, 0xf8, 0x00, 0x00, 0x00,

     

       151
       151
       -
         0x00, 0x00, 0xfe, 0xc0, 0xc0, 0xc0, 0xfc, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0,

     

       152
       152
       -
         0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xc0, 0xc0, 0xc0, 0xfc, 0xc0,

     

       153
       153
       -
         0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6,

     

       154
       154
       -
         0xc0, 0xc0, 0xc0, 0xde, 0xc6, 0xc6, 0xc6, 0xc6, 0x7e, 0x00, 0x00, 0x00,

     

       155
       155
       -
         0x00, 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xfe, 0xc6, 0xc6, 0xc6, 0xc6,

     

       156
       156
       -
         0xc6, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x30, 0x30, 0x30, 0x30, 0x30,

     

       157
       157
       -
         0x30, 0x30, 0x30, 0x30, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1e, 0x0c,

     

       158
       158
       -
         0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0xcc, 0xcc, 0x78, 0x00, 0x00, 0x00,

     

       159
       159
       -
         0x00, 0x00, 0xc6, 0xc6, 0xcc, 0xd8, 0xf0, 0xe0, 0xf0, 0xd8, 0xcc, 0xc6,

     

       160
       160
       -
         0xc6, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0,

     

       161
       161
       -
         0xc0, 0xc0, 0xc0, 0xc0, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc6, 0xc6,

     

       162
       162
       -
         0xee, 0xfe, 0xd6, 0xd6, 0xd6, 0xc6, 0xc6, 0xc6, 0xc6, 0x00, 0x00, 0x00,

     

       163
       163
       -
         0x00, 0x00, 0xc6, 0xc6, 0xe6, 0xe6, 0xf6, 0xde, 0xce, 0xce, 0xc6, 0xc6,

     

       164
       164
       -
         0xc6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6,

     

       165
       165
       -
         0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xc6,

     

       166
       166
       -
         0xc6, 0xc6, 0xc6, 0xfc, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0x00, 0x00, 0x00,

     

       167
       167
       -
         0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xf6, 0xda,

     

       168
       168
       -
         0x6c, 0x06, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xc6, 0xc6, 0xc6, 0xc6, 0xfc,

     

       169
       169
       -
         0xd8, 0xcc, 0xcc, 0xc6, 0xc6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6,

     

       170
       170
       -
         0xc0, 0x60, 0x30, 0x18, 0x0c, 0x06, 0x06, 0xc6, 0x7c, 0x00, 0x00, 0x00,

     

       171
       171
       -
         0x00, 0x00, 0xff, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,

     

       172
       172
       -
         0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6,

     

       173
       173
       -
         0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc6, 0xc6,

     

       174
       174
       -
         0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x6c, 0x38, 0x10, 0x00, 0x00, 0x00,

     

       175
       175
       -
         0x00, 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xd6, 0xd6, 0xd6, 0xd6, 0xfe, 0x6c,

     

       176
       176
       -
         0x6c, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc6, 0xc6, 0xc6, 0x6c, 0x38, 0x38,

     

       177
       177
       -
         0x38, 0x6c, 0xc6, 0xc6, 0xc6, 0x00, 0x00, 0x00, 0x00, 0x00, 0xcc, 0xcc,

     

       178
       178
       -
         0xcc, 0xcc, 0xcc, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x00, 0x00, 0x00,

     

       179
       179
       -
         0x00, 0x00, 0xfe, 0x06, 0x06, 0x0c, 0x18, 0x30, 0x60, 0xc0, 0xc0, 0xc0,

     

       180
       180
       -
         0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0x60, 0x60, 0x60, 0x60, 0x60,

     

       181
       181
       -
         0x60, 0x60, 0x60, 0x60, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xc0,

     

       182
       182
       -
         0x60, 0x60, 0x30, 0x38, 0x18, 0x0c, 0x0c, 0x06, 0x06, 0x00, 0x00, 0x00,

     

       183
       183
       -
         0x00, 0x00, 0x78, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,

     

       184
       184
       -
         0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x38, 0x6c, 0xc6, 0x00, 0x00,

     

       185
       185
       -
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       186
       186
       -
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00,

     

       187
       187
       -
         0x00, 0x00, 0x18, 0x18, 0x18, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       188
       188
       -
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0x06, 0x06,

     

       189
       189
       -
         0x7e, 0xc6, 0xc6, 0xc6, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xc0,

     

       190
       190
       -
         0xc0, 0xdc, 0xe6, 0xc6, 0xc6, 0xc6, 0xc6, 0xe6, 0xdc, 0x00, 0x00, 0x00,

     

       191
       191
       -
         0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6, 0xc0, 0xc0, 0xc0, 0xc0, 0xc6,

     

       192
       192
       -
         0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x06, 0x06, 0x76, 0xce, 0xc6,

     

       193
       193
       -
         0xc6, 0xc6, 0xc6, 0xce, 0x76, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       194
       194
       -
         0x00, 0x7c, 0xc6, 0xc6, 0xfe, 0xc0, 0xc0, 0xc0, 0x7e, 0x00, 0x00, 0x00,

     

       195
       195
       -
         0x00, 0x00, 0x1c, 0x36, 0x30, 0x30, 0xfc, 0x30, 0x30, 0x30, 0x30, 0x30,

     

       196
       196
       -
         0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x76, 0xce, 0xc6,

     

       197
       197
       -
         0xc6, 0xc6, 0xce, 0x76, 0x06, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0xc0, 0xc0,

     

       198
       198
       -
         0xc0, 0xdc, 0xe6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x00, 0x00, 0x00,

     

       199
       199
       -
         0x00, 0x00, 0x18, 0x00, 0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,

     

       200
       200
       -
         0x3c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x1e, 0x06, 0x06,

     

       201
       201
       -
         0x06, 0x06, 0x06, 0x06, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0xc0, 0xc0,

     

       202
       202
       -
         0xc0, 0xc6, 0xcc, 0xd8, 0xf0, 0xf0, 0xd8, 0xcc, 0xc6, 0x00, 0x00, 0x00,

     

       203
       203
       -
         0x00, 0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,

     

       204
       204
       -
         0x3c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xec, 0xfe, 0xd6,

     

       205
       205
       -
         0xd6, 0xd6, 0xd6, 0xc6, 0xc6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       206
       206
       -
         0x00, 0xdc, 0xe6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x00, 0x00, 0x00,

     

       207
       207
       -
         0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6,

     

       208
       208
       -
         0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xdc, 0xe6, 0xc6,

     

       209
       209
       -
         0xc6, 0xc6, 0xe6, 0xdc, 0xc0, 0xc0, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       210
       210
       -
         0x00, 0x76, 0xce, 0xc6, 0xc6, 0xc6, 0xce, 0x76, 0x06, 0x06, 0x06, 0x00,

     

       211
       211
       -
         0x00, 0x00, 0x00, 0x00, 0x00, 0xdc, 0xe6, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0,

     

       212
       212
       -
         0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6, 0xc0,

     

       213
       213
       -
         0x70, 0x1c, 0x06, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x30,

     

       214
       214
       -
         0x30, 0xfe, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x1c, 0x00, 0x00, 0x00,

     

       215
       215
       -
         0x00, 0x00, 0x00, 0x00, 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6,

     

       216
       216
       -
         0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc6, 0xc6, 0xc6,

     

       217
       217
       -
         0xc6, 0xc6, 0x6c, 0x38, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       218
       218
       -
         0x00, 0xc6, 0xc6, 0xd6, 0xd6, 0xd6, 0xd6, 0xfe, 0x6c, 0x00, 0x00, 0x00,

     

       219
       219
       -
         0x00, 0x00, 0x00, 0x00, 0x00, 0xc6, 0xc6, 0x6c, 0x38, 0x38, 0x6c, 0xc6,

     

       220
       220
       -
         0xc6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc6, 0xc6, 0xc6,

     

       221
       221
       -
         0xc6, 0xc6, 0xce, 0x76, 0x06, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       222
       222
       -
         0x00, 0xfe, 0x06, 0x0c, 0x18, 0x30, 0x60, 0xc0, 0xfe, 0x00, 0x00, 0x00,

     

       223
       223
       -
         0x00, 0x00, 0x1c, 0x30, 0x30, 0x30, 0x30, 0xe0, 0x30, 0x30, 0x30, 0x30,

     

       224
       224
       -
         0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x30, 0x30, 0x30, 0x30, 0x00,

     

       225
       225
       -
         0x30, 0x30, 0x30, 0x30, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x30,

     

       226
       226
       -
         0x30, 0x30, 0x30, 0x1c, 0x30, 0x30, 0x30, 0x30, 0xe0, 0x00, 0x00, 0x00,

     

       227
       227
       -
         0x00, 0x00, 0x00, 0x76, 0xdc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       228
       228
       -
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x10, 0x38, 0x38, 0x6c,

     

       229
       229
       -
         0x6c, 0xc6, 0xc6, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x66,

     

       230
       230
       -
         0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0x66, 0x3c, 0x18, 0xcc, 0x78, 0x00,

     

       231
       231
       -
         0x00, 0x00, 0x6c, 0x6c, 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6,

     

       232
       232
       -
         0x7c, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x18, 0x30, 0x00, 0x7c, 0xc6, 0xc6,

     

       233
       233
       -
         0xfe, 0xc0, 0xc0, 0xc0, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x10, 0x38, 0x6c,

     

       234
       234
       -
         0x00, 0x7c, 0x06, 0x06, 0x7e, 0xc6, 0xc6, 0xc6, 0x7e, 0x00, 0x00, 0x00,

     

       235
       235
       -
         0x00, 0x00, 0x6c, 0x6c, 0x00, 0x7c, 0x06, 0x06, 0x7e, 0xc6, 0xc6, 0xc6,

     

       236
       236
       -
         0x7e, 0x00, 0x00, 0x00, 0x00, 0x60, 0x30, 0x18, 0x00, 0x7c, 0x06, 0x06,

     

       237
       237
       -
         0x7e, 0xc6, 0xc6, 0xc6, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x38, 0x6c, 0x38,

     

       238
       238
       -
         0x00, 0x7c, 0x06, 0x06, 0x7e, 0xc6, 0xc6, 0xc6, 0x7e, 0x00, 0x00, 0x00,

     

       239
       239
       -
         0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6, 0xc0, 0xc0, 0xc0, 0xc0, 0xc6,

     

       240
       240
       -
         0x7c, 0x18, 0x0c, 0x38, 0x00, 0x10, 0x38, 0x6c, 0x00, 0x7c, 0xc6, 0xc6,

     

       241
       241
       -
         0xfe, 0xc0, 0xc0, 0xc0, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6c, 0x6c,

     

       242
       242
       -
         0x00, 0x7c, 0xc6, 0xc6, 0xfe, 0xc0, 0xc0, 0xc0, 0x7e, 0x00, 0x00, 0x00,

     

       243
       243
       -
         0x00, 0x60, 0x30, 0x18, 0x00, 0x7c, 0xc6, 0xc6, 0xfe, 0xc0, 0xc0, 0xc0,

     

       244
       244
       -
         0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6c, 0x6c, 0x00, 0x38, 0x18, 0x18,

     

       245
       245
       -
         0x18, 0x18, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00, 0x00, 0x10, 0x38, 0x6c,

     

       246
       246
       -
         0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00,

     

       247
       247
       -
         0x00, 0x60, 0x30, 0x18, 0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,

     

       248
       248
       -
         0x3c, 0x00, 0x00, 0x00, 0xc6, 0xc6, 0x10, 0x38, 0x6c, 0xc6, 0xc6, 0xc6,

     

       249
       249
       -
         0xfe, 0xc6, 0xc6, 0xc6, 0xc6, 0x00, 0x00, 0x00, 0x38, 0x6c, 0x38, 0x00,

     

       250
       250
       -
         0x38, 0x6c, 0xc6, 0xc6, 0xc6, 0xfe, 0xc6, 0xc6, 0xc6, 0x00, 0x00, 0x00,

     

       251
       251
       -
         0x18, 0x30, 0x60, 0x00, 0xfe, 0xc0, 0xc0, 0xfc, 0xc0, 0xc0, 0xc0, 0xc0,

     

       252
       252
       -
         0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xec, 0x36, 0x36,

     

       253
       253
       -
         0x76, 0xde, 0xd8, 0xd8, 0x6e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1e, 0x3c,

     

       254
       254
       -
         0x6c, 0xcc, 0xcc, 0xfe, 0xcc, 0xcc, 0xcc, 0xcc, 0xce, 0x00, 0x00, 0x00,

     

       255
       255
       -
         0x00, 0x10, 0x38, 0x6c, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6,

     

       256
       256
       -
         0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6c, 0x6c, 0x00, 0x7c, 0xc6, 0xc6,

     

       257
       257
       -
         0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x60, 0x30, 0x18,

     

       258
       258
       -
         0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00,

     

       259
       259
       -
         0x00, 0x10, 0x38, 0x6c, 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6,

     

       260
       260
       -
         0x7c, 0x00, 0x00, 0x00, 0x00, 0x60, 0x30, 0x18, 0x00, 0xc6, 0xc6, 0xc6,

     

       261
       261
       -
         0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6c, 0x6c,

     

       262
       262
       -
         0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xce, 0x76, 0x06, 0xc6, 0x7c, 0x00,

     

       263
       263
       -
         0x6c, 0x6c, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6,

     

       264
       264
       -
         0x7c, 0x00, 0x00, 0x00, 0x6c, 0x6c, 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6,

     

       265
       265
       -
         0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30,

     

       266
       266
       -
         0x30, 0x78, 0xcc, 0xc0, 0xc0, 0xcc, 0x78, 0x30, 0x30, 0x00, 0x00, 0x00,

     

       267
       267
       -
         0x00, 0x00, 0x38, 0x6c, 0x60, 0x60, 0x60, 0xf8, 0x60, 0x60, 0x60, 0xe6,

     

       268
       268
       -
         0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0xcc, 0xcc, 0xcc, 0x78, 0x30, 0xfc,

     

       269
       269
       -
         0x30, 0xfc, 0x30, 0x30, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xcc,

     

       270
       270
       -
         0xcc, 0xf8, 0xc4, 0xcc, 0xde, 0xcc, 0xcc, 0xcc, 0xc6, 0x00, 0x00, 0x00,

     

       271
       271
       -
         0x00, 0x00, 0x0e, 0x1b, 0x18, 0x18, 0x18, 0x7e, 0x18, 0x18, 0x18, 0x18,

     

       272
       272
       -
         0x18, 0xd8, 0x70, 0x00, 0x00, 0x0c, 0x18, 0x30, 0x00, 0x7c, 0x06, 0x06,

     

       273
       273
       -
         0x7e, 0xc6, 0xc6, 0xc6, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x18, 0x30,

     

       274
       274
       -
         0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00,

     

       275
       275
       -
         0x00, 0x0c, 0x18, 0x30, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6,

     

       276
       276
       -
         0x7c, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x18, 0x30, 0x00, 0xc6, 0xc6, 0xc6,

     

       277
       277
       -
         0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x76, 0xdc, 0x00,

     

       278
       278
       -
         0x00, 0xdc, 0xe6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x00, 0x00, 0x00,

     

       279
       279
       -
         0x76, 0xdc, 0x00, 0xc6, 0xc6, 0xe6, 0xf6, 0xfe, 0xde, 0xce, 0xc6, 0xc6,

     

       280
       280
       -
         0xc6, 0x00, 0x00, 0x00, 0x00, 0x78, 0xd8, 0xd8, 0x6c, 0x00, 0xfc, 0x00,

     

       281
       281
       -
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x6c, 0x6c,

     

       282
       282
       -
         0x38, 0x00, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       283
       283
       -
         0x00, 0x00, 0x18, 0x18, 0x00, 0x18, 0x18, 0x30, 0x60, 0xc0, 0xc6, 0xc6,

     

       284
       284
       -
         0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       285
       285
       -
         0xfe, 0xc0, 0xc0, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       286
       286
       -
         0x00, 0x00, 0x00, 0x00, 0xfe, 0x06, 0x06, 0x06, 0x00, 0x00, 0x00, 0x00,

     

       287
       287
       -
         0x00, 0x00, 0xc0, 0xc2, 0xc6, 0xcc, 0xd8, 0x30, 0x60, 0xdc, 0x86, 0x0c,

     

       288
       288
       -
         0x18, 0x3e, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xc2, 0xc6, 0xcc, 0xd8, 0x30,

     

       289
       289
       -
         0x66, 0xce, 0x9e, 0x3e, 0x06, 0x06, 0x00, 0x00, 0x00, 0x00, 0x30, 0x30,

     

       290
       290
       -
         0x00, 0x30, 0x30, 0x30, 0x78, 0x78, 0x78, 0x78, 0x30, 0x00, 0x00, 0x00,

     

       291
       291
       -
         0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0x6c, 0xd8, 0x6c, 0x36, 0x00, 0x00,

     

       292
       292
       -
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xd8, 0x6c, 0x36,

     

       293
       293
       -
         0x6c, 0xd8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x88, 0x22, 0x88,

     

       294
       294
       -
         0x22, 0x88, 0x22, 0x88, 0x22, 0x88, 0x22, 0x88, 0x22, 0x88, 0x22, 0x88,

     

       295
       295
       -
         0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa,

     

       296
       296
       -
         0x55, 0xaa, 0x55, 0xaa, 0xdd, 0x77, 0xdd, 0x77, 0xdd, 0x77, 0xdd, 0x77,

     

       297
       297
       -
         0xdd, 0x77, 0xdd, 0x77, 0xdd, 0x77, 0xdd, 0x77, 0x18, 0x18, 0x18, 0x18,

     

       298
       298
       -
         0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,

     

       299
       299
       -
         0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xf8, 0xf8, 0x18, 0x18, 0x18,

     

       300
       300
       -
         0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xf8, 0xf8, 0x18,

     

       301
       301
       -
         0x18, 0xf8, 0xf8, 0x18, 0x18, 0x18, 0x18, 0x18, 0x36, 0x36, 0x36, 0x36,

     

       302
       302
       -
         0x36, 0x36, 0x36, 0xf6, 0xf6, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,

     

       303
       303
       -
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xfe, 0x36, 0x36, 0x36,

     

       304
       304
       -
         0x36, 0x36, 0x36, 0x36, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xf8, 0x18,

     

       305
       305
       -
         0x18, 0xf8, 0xf8, 0x18, 0x18, 0x18, 0x18, 0x18, 0x36, 0x36, 0x36, 0x36,

     

       306
       306
       -
         0x36, 0xf6, 0xf6, 0x06, 0x06, 0xf6, 0xf6, 0x36, 0x36, 0x36, 0x36, 0x36,

     

       307
       307
       -
         0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,

     

       308
       308
       -
         0x36, 0x36, 0x36, 0x36, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xfe, 0x06,

     

       309
       309
       -
         0x06, 0xf6, 0xf6, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,

     

       310
       310
       -
         0x36, 0xf6, 0xf6, 0x06, 0x06, 0xfe, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       311
       311
       -
         0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0xfe, 0xfe, 0x00, 0x00, 0x00,

     

       312
       312
       -
         0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x18, 0x18, 0x18, 0xf8, 0xf8, 0x18,

     

       313
       313
       -
         0x18, 0xf8, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       314
       314
       -
         0x00, 0x00, 0x00, 0xf8, 0xf8, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,

     

       315
       315
       -
         0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x1f, 0x1f, 0x00, 0x00, 0x00,

     

       316
       316
       -
         0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xff,

     

       317
       317
       -
         0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       318
       318
       -
         0x00, 0x00, 0x00, 0xff, 0xff, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,

     

       319
       319
       -
         0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x1f, 0x1f, 0x18, 0x18, 0x18,

     

       320
       320
       -
         0x18, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff,

     

       321
       321
       -
         0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x18, 0x18,

     

       322
       322
       -
         0x18, 0x18, 0x18, 0xff, 0xff, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,

     

       323
       323
       -
         0x18, 0x18, 0x18, 0x18, 0x18, 0x1f, 0x1f, 0x18, 0x18, 0x1f, 0x1f, 0x18,

     

       324
       324
       -
         0x18, 0x18, 0x18, 0x18, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x37,

     

       325
       325
       -
         0x37, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,

     

       326
       326
       -
         0x36, 0x37, 0x37, 0x30, 0x30, 0x3f, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       327
       327
       -
         0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x3f, 0x30, 0x30, 0x37, 0x37, 0x36,

     

       328
       328
       -
         0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0xf7, 0xf7, 0x00,

     

       329
       329
       -
         0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       330
       330
       -
         0x00, 0xff, 0xff, 0x00, 0x00, 0xf7, 0xf7, 0x36, 0x36, 0x36, 0x36, 0x36,

     

       331
       331
       -
         0x36, 0x36, 0x36, 0x36, 0x36, 0x37, 0x37, 0x30, 0x30, 0x37, 0x37, 0x36,

     

       332
       332
       -
         0x36, 0x36, 0x36, 0x36, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00,

     

       333
       333
       -
         0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0x36, 0x36, 0x36,

     

       334
       334
       -
         0x36, 0xf7, 0xf7, 0x00, 0x00, 0xf7, 0xf7, 0x36, 0x36, 0x36, 0x36, 0x36,

     

       335
       335
       -
         0x18, 0x18, 0x18, 0x18, 0x18, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00,

     

       336
       336
       -
         0x00, 0x00, 0x00, 0x00, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0xff,

     

       337
       337
       -
         0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       338
       338
       -
         0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x18, 0x18, 0x18, 0x18, 0x18,

     

       339
       339
       -
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x36, 0x36, 0x36,

     

       340
       340
       -
         0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x3f,

     

       341
       341
       -
         0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x18, 0x18,

     

       342
       342
       -
         0x18, 0x1f, 0x1f, 0x18, 0x18, 0x1f, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       343
       343
       -
         0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x1f, 0x18, 0x18, 0x1f, 0x1f, 0x18,

     

       344
       344
       -
         0x18, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f,

     

       345
       345
       -
         0x3f, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,

     

       346
       346
       -
         0x36, 0x36, 0x36, 0xff, 0xff, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,

     

       347
       347
       -
         0x18, 0x18, 0x18, 0x18, 0x18, 0xff, 0xff, 0x18, 0x18, 0xff, 0xff, 0x18,

     

       348
       348
       -
         0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xf8,

     

       349
       349
       -
         0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       350
       350
       -
         0x00, 0x00, 0x00, 0x1f, 0x1f, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,

     

       351
       351
       -
         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,

     

       352
       352
       -
         0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       353
       353
       -
         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0xf0, 0xf0, 0xf0,

     

       354
       354
       -
         0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0,

     

       355
       355
       -
         0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,

     

       356
       356
       -
         0x0f, 0x0f, 0x0f, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,

     

       357
       357
       -
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       358
       358
       -
         0x00, 0x76, 0xd6, 0xdc, 0xc8, 0xc8, 0xdc, 0xd6, 0x76, 0x00, 0x00, 0x00,

     

       359
       359
       -
         0x00, 0x00, 0x78, 0xcc, 0xcc, 0xcc, 0xd8, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,

     

       360
       360
       -
         0xd8, 0xc0, 0xc0, 0x00, 0x00, 0x00, 0xfe, 0xc6, 0xc6, 0xc0, 0xc0, 0xc0,

     

       361
       361
       -
         0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       362
       362
       -
         0x00, 0x7e, 0xfe, 0x24, 0x24, 0x24, 0x24, 0x66, 0xc6, 0x00, 0x00, 0x00,

     

       363
       363
       -
         0x00, 0x00, 0xfe, 0xfe, 0xc2, 0x60, 0x30, 0x18, 0x30, 0x60, 0xc2, 0xfe,

     

       364
       364
       -
         0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7e, 0xc8, 0xcc,

     

       365
       365
       -
         0xcc, 0xcc, 0xcc, 0xcc, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       366
       366
       -
         0x00, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x76, 0x6c, 0x60, 0xc0, 0x00,

     

       367
       367
       -
         0x00, 0x00, 0x00, 0x00, 0x00, 0x66, 0xfc, 0x98, 0x18, 0x18, 0x18, 0x18,

     

       368
       368
       -
         0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x30, 0x30, 0x78, 0xcc, 0xcc,

     

       369
       369
       -
         0xcc, 0x78, 0x30, 0x30, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x6c,

     

       370
       370
       -
         0xc6, 0xc6, 0xc6, 0xfe, 0xc6, 0xc6, 0xc6, 0x6c, 0x38, 0x00, 0x00, 0x00,

     

       371
       371
       -
         0x00, 0x00, 0x38, 0x6c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x6c, 0x6c, 0x6c,

     

       372
       372
       -
         0xee, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0xcc, 0x60, 0x30, 0x78, 0xcc,

     

       373
       373
       -
         0xcc, 0xcc, 0xcc, 0xcc, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       374
       374
       -
         0x00, 0x76, 0xbb, 0x99, 0x99, 0xdd, 0x6e, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       375
       375
       -
         0x00, 0x00, 0x02, 0x06, 0x3c, 0x6c, 0xce, 0xd6, 0xd6, 0xe6, 0x6c, 0x78,

     

       376
       376
       -
         0xc0, 0x80, 0x00, 0x00, 0x00, 0x00, 0x1e, 0x30, 0x60, 0xc0, 0xc0, 0xfe,

     

       377
       377
       -
         0xc0, 0xc0, 0x60, 0x30, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x6c,

     

       378
       378
       -
         0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x00, 0x00, 0x00,

     

       379
       379
       -
         0x00, 0x00, 0x00, 0x00, 0xfe, 0x00, 0x00, 0xfe, 0x00, 0x00, 0xfe, 0x00,

     

       380
       380
       -
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x30, 0xfc,

     

       381
       381
       -
         0x30, 0x30, 0x00, 0x00, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       382
       382
       -
         0x60, 0x30, 0x18, 0x0c, 0x18, 0x30, 0x60, 0x00, 0xfc, 0x00, 0x00, 0x00,

     

       383
       383
       -
         0x00, 0x00, 0x00, 0x00, 0x18, 0x30, 0x60, 0xc0, 0x60, 0x30, 0x18, 0x00,

     

       384
       384
       -
         0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x36, 0x36, 0x30, 0x30, 0x30,

     

       385
       385
       -
         0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x18, 0x18, 0x18, 0x18,

     

       386
       386
       -
         0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xd8, 0xd8, 0x70, 0x00, 0x00, 0x00,

     

       387
       387
       -
         0x00, 0x00, 0x00, 0x00, 0x30, 0x30, 0x00, 0xfc, 0x00, 0x30, 0x30, 0x00,

     

       388
       388
       -
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x76, 0xdc, 0x00,

     

       389
       389
       -
         0x76, 0xdc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0xcc, 0xcc,

     

       390
       390
       -
         0xcc, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       391
       391
       -
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x30, 0x00, 0x00, 0x00,

     

       392
       392
       -
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30,

     

       393
       393
       -
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0c, 0x0c,

     

       394
       394
       -
         0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0xcc, 0x6c, 0x3c, 0x1c, 0x0c, 0x00, 0x00,

     

       395
       395
       -
         0x00, 0xd8, 0xec, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0x00, 0x00, 0x00, 0x00,

     

       396
       396
       -
         0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x6c, 0x0c, 0x18, 0x30, 0x60, 0x7c,

     

       397
       397
       -
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       398
       398
       -
         0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       399
       399
       -
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       400
       400
       -
         0x00, 0x00, 0x00, 0x00

     

       401
       401
       -
       };

     

       402
       402
       -
       

     

       403
       403
       -
       #ifdef FLANTERM_FB_SUPPORT_BPP

     

       404
       404
       -
       static inline __attribute__((always_inline)) uint32_t convert_colour(struct flanterm_context *_ctx, uint32_t colour) {

     

       405
       405
       -
           struct flanterm_fb_context *ctx = (void *)_ctx;

     

       406
       406
       -
           uint32_t r = (colour >> 16) & 0xff;

     

       407
       407
       -
           uint32_t g = (colour >> 8) & 0xff;

     

       408
       408
       -
           uint32_t b =  colour & 0xff;

     

       409
       409
       -
           return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);

     

       410
       410
       -
       }

     

       411
       411
       -
       #else

     

       412
       412
       -
       #define convert_colour(CTX, COLOUR) (COLOUR)

     

       413
       413
       -
       #endif

     

       414
       414
       -
       

     

       415
       415
       -
       static void flanterm_fb_save_state(struct flanterm_context *_ctx) {

     

       416
       416
       -
           struct flanterm_fb_context *ctx = (void *)_ctx;

     

       417
       417
       -
           ctx->saved_state_text_fg = ctx->text_fg;

     

       418
       418
       -
           ctx->saved_state_text_bg = ctx->text_bg;

     

       419
       419
       -
           ctx->saved_state_cursor_x = ctx->cursor_x;

     

       420
       420
       -
           ctx->saved_state_cursor_y = ctx->cursor_y;

     

       421
       421
       -
       }

     

       422
       422
       -
       

     

       423
       423
       -
       static void flanterm_fb_restore_state(struct flanterm_context *_ctx) {

     

       424
       424
       -
           struct flanterm_fb_context *ctx = (void *)_ctx;

     

       425
       425
       -
           ctx->text_fg = ctx->saved_state_text_fg;

     

       426
       426
       -
           ctx->text_bg = ctx->saved_state_text_bg;

     

       427
       427
       -
           ctx->cursor_x = ctx->saved_state_cursor_x;

     

       428
       428
       -
           ctx->cursor_y = ctx->saved_state_cursor_y;

     

       429
       429
       -
       }

     

       430
       430
       -
       

     

       431
       431
       -
       static void flanterm_fb_swap_palette(struct flanterm_context *_ctx) {

     

       432
       432
       -
           struct flanterm_fb_context *ctx = (void *)_ctx;

     

       433
       433
       -
           uint32_t tmp = ctx->text_bg;

     

       434
       434
       -
           ctx->text_bg = ctx->text_fg;

     

       435
       435
       -
           ctx->text_fg = tmp;

     

       436
       436
       -
       }

     

       437
       437
       -
       

     

       438
       438
       -
       static void plot_char(struct flanterm_context *_ctx, struct flanterm_fb_char *c, size_t x, size_t y) {

     

       439
       439
       -
           struct flanterm_fb_context *ctx = (void *)_ctx;

     

       440
       440
       -
       

     

       441
       441
       -
           if (x >= _ctx->cols || y >= _ctx->rows) {

     

       442
       442
       -
               return;

     

       443
       443
       -
           }

     

       444
       444
       -
       

     

       445
       445
       -
       #ifdef FLANTERM_FB_DISABLE_CANVAS

     

       446
       446
       -
           uint32_t default_bg = ctx->default_bg;

     

       447
       447
       -
       #endif

     

       448
       448
       -
       

     

       449
       449
       -
           x = ctx->offset_x + x * ctx->glyph_width;

     

       450
       450
       -
           y = ctx->offset_y + y * ctx->glyph_height;

     

       451
       451
       -
       

     

       452
       452
       -
           bool *glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width];

     

       453
       453
       -
           // naming: fx,fy for font coordinates, gx,gy for glyph coordinates

     

       454
       454
       -
           for (size_t gy = 0; gy < ctx->glyph_height; gy++) {

     

       455
       455
       -
               uint8_t fy = gy / ctx->font_scale_y;

     

       456
       456
       -
               volatile uint32_t *fb_line = ctx->framebuffer + x + (y + gy) * (ctx->pitch / 4);

     

       457
       457
       -
       

     

       458
       458
       -
       #ifndef FLANTERM_FB_DISABLE_CANVAS

     

       459
       459
       -
               uint32_t *canvas_line = ctx->canvas + x + (y + gy) * ctx->width;

     

       460
       460
       -
       #endif

     

       461
       461
       -
       

     

       462
       462
       -
               for (size_t fx = 0; fx < ctx->font_width; fx++) {

     

       463
       463
       -
                   bool draw = glyph[fy * ctx->font_width + fx];

     

       464
       464
       -
                   for (size_t i = 0; i < ctx->font_scale_x; i++) {

     

       465
       465
       -
                       size_t gx = ctx->font_scale_x * fx + i;

     

       466
       466
       -
       #ifndef FLANTERM_FB_DISABLE_CANVAS

     

       467
       467
       -
                       uint32_t bg = c->bg == 0xffffffff ? canvas_line[gx] : c->bg;

     

       468
       468
       -
                       uint32_t fg = c->fg == 0xffffffff ? canvas_line[gx] : c->fg;

     

       469
       469
       -
       #else

     

       470
       470
       -
                       uint32_t bg = c->bg == 0xffffffff ? default_bg : c->bg;

     

       471
       471
       -
                       uint32_t fg = c->fg == 0xffffffff ? default_bg : c->fg;

     

       472
       472
       -
       #endif

     

       473
       473
       -
                       fb_line[gx] = draw ? fg : bg;

     

       474
       474
       -
                   }

     

       475
       475
       -
               }

     

       476
       476
       -
           }

     

       477
       477
       -
       }

     

       478
       478
       -
       

     

       479
       479
       -
       static void plot_char_fast(struct flanterm_context *_ctx, struct flanterm_fb_char *old, struct flanterm_fb_char *c, size_t x, size_t y) {

     

       480
       480
       -
           struct flanterm_fb_context *ctx = (void *)_ctx;

     

       481
       481
       -
       

     

       482
       482
       -
           if (x >= _ctx->cols || y >= _ctx->rows) {

     

       483
       483
       -
               return;

     

       484
       484
       -
           }

     

       485
       485
       -
       

     

       486
       486
       -
           x = ctx->offset_x + x * ctx->glyph_width;

     

       487
       487
       -
           y = ctx->offset_y + y * ctx->glyph_height;

     

       488
       488
       -
       

     

       489
       489
       -
       #ifdef FLANTERM_FB_DISABLE_CANVAS

     

       490
       490
       -
           uint32_t default_bg = ctx->default_bg;

     

       491
       491
       -
       #endif

     

       492
       492
       -
       

     

       493
       493
       -
           bool *new_glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width];

     

       494
       494
       -
           bool *old_glyph = &ctx->font_bool[old->c * ctx->font_height * ctx->font_width];

     

       495
       495
       -
           for (size_t gy = 0; gy < ctx->glyph_height; gy++) {

     

       496
       496
       -
               uint8_t fy = gy / ctx->font_scale_y;

     

       497
       497
       -
               volatile uint32_t *fb_line = ctx->framebuffer + x + (y + gy) * (ctx->pitch / 4);

     

       498
       498
       -
       #ifndef FLANTERM_FB_DISABLE_CANVAS

     

       499
       499
       -
               uint32_t *canvas_line = ctx->canvas + x + (y + gy) * ctx->width;

     

       500
       500
       -
       #endif

     

       501
       501
       -
               for (size_t fx = 0; fx < ctx->font_width; fx++) {

     

       502
       502
       -
                   bool old_draw = old_glyph[fy * ctx->font_width + fx];

     

       503
       503
       -
                   bool new_draw = new_glyph[fy * ctx->font_width + fx];

     

       504
       504
       -
                   if (old_draw == new_draw)

     

       505
       505
       -
                       continue;

     

       506
       506
       -
                   for (size_t i = 0; i < ctx->font_scale_x; i++) {

     

       507
       507
       -
                       size_t gx = ctx->font_scale_x * fx + i;

     

       508
       508
       -
       #ifndef FLANTERM_FB_DISABLE_CANVAS

     

       509
       509
       -
                       uint32_t bg = c->bg == 0xffffffff ? canvas_line[gx] : c->bg;

     

       510
       510
       -
                       uint32_t fg = c->fg == 0xffffffff ? canvas_line[gx] : c->fg;

     

       511
       511
       -
       #else

     

       512
       512
       -
                       uint32_t bg = c->bg == 0xffffffff ? default_bg : c->bg;

     

       513
       513
       -
                       uint32_t fg = c->fg == 0xffffffff ? default_bg : c->fg;

     

       514
       514
       -
       #endif

     

       515
       515
       -
                       fb_line[gx] = new_draw ? fg : bg;

     

       516
       516
       -
                   }

     

       517
       517
       -
               }

     

       518
       518
       -
           }

     

       519
       519
       -
       }

     

       520
       520
       -
       

     

       521
       521
       -
       static inline bool compare_char(struct flanterm_fb_char *a, struct flanterm_fb_char *b) {

     

       522
       522
       -
           return !(a->c != b->c || a->bg != b->bg || a->fg != b->fg);

     

       523
       523
       -
       }

     

       524
       524
       -
       

     

       525
       525
       -
       static void push_to_queue(struct flanterm_context *_ctx, struct flanterm_fb_char *c, size_t x, size_t y) {

     

       526
       526
       -
           struct flanterm_fb_context *ctx = (void *)_ctx;

     

       527
       527
       -
       

     

       528
       528
       -
           if (x >= _ctx->cols || y >= _ctx->rows) {

     

       529
       529
       -
               return;

     

       530
       530
       -
           }

     

       531
       531
       -
       

     

       532
       532
       -
           size_t i = y * _ctx->cols + x;

     

       533
       533
       -
       

     

       534
       534
       -
           struct flanterm_fb_queue_item *q = ctx->map[i];

     

       535
       535
       -
       

     

       536
       536
       -
           if (q == NULL) {

     

       537
       537
       -
               if (compare_char(&ctx->grid[i], c)) {

     

       538
       538
       -
                   return;

     

       539
       539
       -
               }

     

       540
       540
       -
               q = &ctx->queue[ctx->queue_i++];

     

       541
       541
       -
               q->x = x;

     

       542
       542
       -
               q->y = y;

     

       543
       543
       -
               ctx->map[i] = q;

     

       544
       544
       -
           }

     

       545
       545
       -
       

     

       546
       546
       -
           q->c = *c;

     

       547
       547
       -
       }

     

       548
       548
       -
       

     

       549
       549
       -
       static void flanterm_fb_revscroll(struct flanterm_context *_ctx) {

     

       550
       550
       -
           struct flanterm_fb_context *ctx = (void *)_ctx;

     

       551
       551
       -
       

     

       552
       552
       -
           for (size_t i = (_ctx->scroll_bottom_margin - 1) * _ctx->cols - 1;

     

       553
       553
       -
                i >= _ctx->scroll_top_margin * _ctx->cols; i--) {

     

       554
       554
       -
               if (i == (size_t)-1) {

     

       555
       555
       -
                   break;

     

       556
       556
       -
               }

     

       557
       557
       -
               struct flanterm_fb_char *c;

     

       558
       558
       -
               struct flanterm_fb_queue_item *q = ctx->map[i];

     

       559
       559
       -
               if (q != NULL) {

     

       560
       560
       -
                   c = &q->c;

     

       561
       561
       -
               } else {

     

       562
       562
       -
                   c = &ctx->grid[i];

     

       563
       563
       -
               }

     

       564
       564
       -
               push_to_queue(_ctx, c, (i + _ctx->cols) % _ctx->cols, (i + _ctx->cols) / _ctx->cols);

     

       565
       565
       -
           }

     

       566
       566
       -
       

     

       567
       567
       -
           // Clear the first line of the screen.

     

       568
       568
       -
           struct flanterm_fb_char empty;

     

       569
       569
       -
           empty.c  = ' ';

     

       570
       570
       -
           empty.fg = ctx->text_fg;

     

       571
       571
       -
           empty.bg = ctx->text_bg;

     

       572
       572
       -
           for (size_t i = 0; i < _ctx->cols; i++) {

     

       573
       573
       -
               push_to_queue(_ctx, &empty, i, _ctx->scroll_top_margin);

     

       574
       574
       -
           }

     

       575
       575
       -
       }

     

       576
       576
       -
       

     

       577
       577
       -
       static void flanterm_fb_scroll(struct flanterm_context *_ctx) {

     

       578
       578
       -
           struct flanterm_fb_context *ctx = (void *)_ctx;

     

       579
       579
       -
       

     

       580
       580
       -
           for (size_t i = (_ctx->scroll_top_margin + 1) * _ctx->cols;

     

       581
       581
       -
                i < _ctx->scroll_bottom_margin * _ctx->cols; i++) {

     

       582
       582
       -
               struct flanterm_fb_char *c;

     

       583
       583
       -
               struct flanterm_fb_queue_item *q = ctx->map[i];

     

       584
       584
       -
               if (q != NULL) {

     

       585
       585
       -
                   c = &q->c;

     

       586
       586
       -
               } else {

     

       587
       587
       -
                   c = &ctx->grid[i];

     

       588
       588
       -
               }

     

       589
       589
       -
               push_to_queue(_ctx, c, (i - _ctx->cols) % _ctx->cols, (i - _ctx->cols) / _ctx->cols);

     

       590
       590
       -
           }

     

       591
       591
       -
       

     

       592
       592
       -
           // Clear the last line of the screen.

     

       593
       593
       -
           struct flanterm_fb_char empty;

     

       594
       594
       -
           empty.c  = ' ';

     

       595
       595
       -
           empty.fg = ctx->text_fg;

     

       596
       596
       -
           empty.bg = ctx->text_bg;

     

       597
       597
       -
           for (size_t i = 0; i < _ctx->cols; i++) {

     

       598
       598
       -
               push_to_queue(_ctx, &empty, i, _ctx->scroll_bottom_margin - 1);

     

       599
       599
       -
           }

     

       600
       600
       -
       }

     

       601
       601
       -
       

     

       602
       602
       -
       static void flanterm_fb_clear(struct flanterm_context *_ctx, bool move) {

     

       603
       603
       -
           struct flanterm_fb_context *ctx = (void *)_ctx;

     

       604
       604
       -
       

     

       605
       605
       -
           struct flanterm_fb_char empty;

     

       606
       606
       -
           empty.c  = ' ';

     

       607
       607
       -
           empty.fg = ctx->text_fg;

     

       608
       608
       -
           empty.bg = ctx->text_bg;

     

       609
       609
       -
           for (size_t i = 0; i < _ctx->rows * _ctx->cols; i++) {

     

       610
       610
       -
               push_to_queue(_ctx, &empty, i % _ctx->cols, i / _ctx->cols);

     

       611
       611
       -
           }

     

       612
       612
       -
       

     

       613
       613
       -
           if (move) {

     

       614
       614
       -
               ctx->cursor_x = 0;

     

       615
       615
       -
               ctx->cursor_y = 0;

     

       616
       616
       -
           }

     

       617
       617
       -
       }

     

       618
       618
       -
       

     

       619
       619
       -
       static void flanterm_fb_set_cursor_pos(struct flanterm_context *_ctx, size_t x, size_t y) {

     

       620
       620
       -
           struct flanterm_fb_context *ctx = (void *)_ctx;

     

       621
       621
       -
       

     

       622
       622
       -
           if (x >= _ctx->cols) {

     

       623
       623
       -
               if ((int)x < 0) {

     

       624
       624
       -
                   x = 0;

     

       625
       625
       -
               } else {

     

       626
       626
       -
                   x = _ctx->cols - 1;

     

       627
       627
       -
               }

     

       628
       628
       -
           }

     

       629
       629
       -
           if (y >= _ctx->rows) {

     

       630
       630
       -
               if ((int)y < 0) {

     

       631
       631
       -
                   y = 0;

     

       632
       632
       -
               } else {

     

       633
       633
       -
                   y = _ctx->rows - 1;

     

       634
       634
       -
               }

     

       635
       635
       -
           }

     

       636
       636
       -
           ctx->cursor_x = x;

     

       637
       637
       -
           ctx->cursor_y = y;

     

       638
       638
       -
       }

     

       639
       639
       -
       

     

       640
       640
       -
       static void flanterm_fb_get_cursor_pos(struct flanterm_context *_ctx, size_t *x, size_t *y) {

     

       641
       641
       -
           struct flanterm_fb_context *ctx = (void *)_ctx;

     

       642
       642
       -
       

     

       643
       643
       -
           *x = ctx->cursor_x >= _ctx->cols ? _ctx->cols - 1 : ctx->cursor_x;

     

       644
       644
       -
           *y = ctx->cursor_y >= _ctx->rows ? _ctx->rows - 1 : ctx->cursor_y;

     

       645
       645
       -
       }

     

       646
       646
       -
       

     

       647
       647
       -
       static void flanterm_fb_move_character(struct flanterm_context *_ctx, size_t new_x, size_t new_y, size_t old_x, size_t old_y) {

     

       648
       648
       -
           struct flanterm_fb_context *ctx = (void *)_ctx;

     

       649
       649
       -
       

     

       650
       650
       -
           if (old_x >= _ctx->cols || old_y >= _ctx->rows

     

       651
       651
       -
            || new_x >= _ctx->cols || new_y >= _ctx->rows) {

     

       652
       652
       -
               return;

     

       653
       653
       -
           }

     

       654
       654
       -
       

     

       655
       655
       -
           size_t i = old_x + old_y * _ctx->cols;

     

       656
       656
       -
       

     

       657
       657
       -
           struct flanterm_fb_char *c;

     

       658
       658
       -
           struct flanterm_fb_queue_item *q = ctx->map[i];

     

       659
       659
       -
           if (q != NULL) {

     

       660
       660
       -
               c = &q->c;

     

       661
       661
       -
           } else {

     

       662
       662
       -
               c = &ctx->grid[i];

     

       663
       663
       -
           }

     

       664
       664
       -
       

     

       665
       665
       -
           push_to_queue(_ctx, c, new_x, new_y);

     

       666
       666
       -
       }

     

       667
       667
       -
       

     

       668
       668
       -
       static void flanterm_fb_set_text_fg(struct flanterm_context *_ctx, size_t fg) {

     

       669
       669
       -
           struct flanterm_fb_context *ctx = (void *)_ctx;

     

       670
       670
       -
       

     

       671
       671
       -
           ctx->text_fg = ctx->ansi_colours[fg];

     

       672
       672
       -
       }

     

       673
       673
       -
       

     

       674
       674
       -
       static void flanterm_fb_set_text_bg(struct flanterm_context *_ctx, size_t bg) {

     

       675
       675
       -
           struct flanterm_fb_context *ctx = (void *)_ctx;

     

       676
       676
       -
       

     

       677
       677
       -
           ctx->text_bg = ctx->ansi_colours[bg];

     

       678
       678
       -
       }

     

       679
       679
       -
       

     

       680
       680
       -
       static void flanterm_fb_set_text_fg_bright(struct flanterm_context *_ctx, size_t fg) {

     

       681
       681
       -
           struct flanterm_fb_context *ctx = (void *)_ctx;

     

       682
       682
       -
       

     

       683
       683
       -
           ctx->text_fg = ctx->ansi_bright_colours[fg];

     

       684
       684
       -
       }

     

       685
       685
       -
       

     

       686
       686
       -
       static void flanterm_fb_set_text_bg_bright(struct flanterm_context *_ctx, size_t bg) {

     

       687
       687
       -
           struct flanterm_fb_context *ctx = (void *)_ctx;

     

       688
       688
       -
       

     

       689
       689
       -
           ctx->text_bg = ctx->ansi_bright_colours[bg];

     

       690
       690
       -
       }

     

       691
       691
       -
       

     

       692
       692
       -
       static void flanterm_fb_set_text_fg_rgb(struct flanterm_context *_ctx, uint32_t fg) {

     

       693
       693
       -
           struct flanterm_fb_context *ctx = (void *)_ctx;

     

       694
       694
       -
       

     

       695
       695
       -
           ctx->text_fg = convert_colour(_ctx, fg);

     

       696
       696
       -
       }

     

       697
       697
       -
       

     

       698
       698
       -
       static void flanterm_fb_set_text_bg_rgb(struct flanterm_context *_ctx, uint32_t bg) {

     

       699
       699
       -
           struct flanterm_fb_context *ctx = (void *)_ctx;

     

       700
       700
       -
       

     

       701
       701
       -
           ctx->text_bg = convert_colour(_ctx, bg);

     

       702
       702
       -
       }

     

       703
       703
       -
       

     

       704
       704
       -
       static void flanterm_fb_set_text_fg_default(struct flanterm_context *_ctx) {

     

       705
       705
       -
           struct flanterm_fb_context *ctx = (void *)_ctx;

     

       706
       706
       -
       

     

       707
       707
       -
           ctx->text_fg = ctx->default_fg;

     

       708
       708
       -
       }

     

       709
       709
       -
       

     

       710
       710
       -
       static void flanterm_fb_set_text_bg_default(struct flanterm_context *_ctx) {

     

       711
       711
       -
           struct flanterm_fb_context *ctx = (void *)_ctx;

     

       712
       712
       -
       

     

       713
       713
       -
           ctx->text_bg = 0xffffffff;

     

       714
       714
       -
       }

     

       715
       715
       -
       

     

       716
       716
       -
       static void flanterm_fb_set_text_fg_default_bright(struct flanterm_context *_ctx) {

     

       717
       717
       -
           struct flanterm_fb_context *ctx = (void *)_ctx;

     

       718
       718
       -
       

     

       719
       719
       -
           ctx->text_fg = ctx->default_fg_bright;

     

       720
       720
       -
       }

     

       721
       721
       -
       

     

       722
       722
       -
       static void flanterm_fb_set_text_bg_default_bright(struct flanterm_context *_ctx) {

     

       723
       723
       -
           struct flanterm_fb_context *ctx = (void *)_ctx;

     

       724
       724
       -
       

     

       725
       725
       -
           ctx->text_bg = ctx->default_bg_bright;

     

       726
       726
       -
       }

     

       727
       727
       -
       

     

       728
       728
       -
       static void draw_cursor(struct flanterm_context *_ctx) {

     

       729
       729
       -
           struct flanterm_fb_context *ctx = (void *)_ctx;

     

       730
       730
       -
       

     

       731
       731
       -
           if (ctx->cursor_x >= _ctx->cols || ctx->cursor_y >= _ctx->rows) {

     

       732
       732
       -
               return;

     

       733
       733
       -
           }

     

       734
       734
       -
       

     

       735
       735
       -
           size_t i = ctx->cursor_x + ctx->cursor_y * _ctx->cols;

     

       736
       736
       -
       

     

       737
       737
       -
           struct flanterm_fb_char c;

     

       738
       738
       -
           struct flanterm_fb_queue_item *q = ctx->map[i];

     

       739
       739
       -
           if (q != NULL) {

     

       740
       740
       -
               c = q->c;

     

       741
       741
       -
           } else {

     

       742
       742
       -
               c = ctx->grid[i];

     

       743
       743
       -
           }

     

       744
       744
       -
           uint32_t tmp = c.fg;

     

       745
       745
       -
           c.fg = c.bg;

     

       746
       746
       -
           c.bg = tmp;

     

       747
       747
       -
           plot_char(_ctx, &c, ctx->cursor_x, ctx->cursor_y);

     

       748
       748
       -
           if (q != NULL) {

     

       749
       749
       -
               ctx->grid[i] = q->c;

     

       750
       750
       -
               ctx->map[i] = NULL;

     

       751
       751
       -
           }

     

       752
       752
       -
       }

     

       753
       753
       -
       

     

       754
       754
       -
       static void flanterm_fb_double_buffer_flush(struct flanterm_context *_ctx) {

     

       755
       755
       -
           struct flanterm_fb_context *ctx = (void *)_ctx;

     

       756
       756
       -
       

     

       757
       757
       -
           if (_ctx->cursor_enabled) {

     

       758
       758
       -
               draw_cursor(_ctx);

     

       759
       759
       -
           }

     

       760
       760
       -
       

     

       761
       761
       -
           for (size_t i = 0; i < ctx->queue_i; i++) {

     

       762
       762
       -
               struct flanterm_fb_queue_item *q = &ctx->queue[i];

     

       763
       763
       -
               size_t offset = q->y * _ctx->cols + q->x;

     

       764
       764
       -
               if (ctx->map[offset] == NULL) {

     

       765
       765
       -
                   continue;

     

       766
       766
       -
               }

     

       767
       767
       -
               struct flanterm_fb_char *old = &ctx->grid[offset];

     

       768
       768
       -
               if (q->c.bg == old->bg && q->c.fg == old->fg) {

     

       769
       769
       -
                   plot_char_fast(_ctx, old, &q->c, q->x, q->y);

     

       770
       770
       -
               } else {

     

       771
       771
       -
                   plot_char(_ctx, &q->c, q->x, q->y);

     

       772
       772
       -
               }

     

       773
       773
       -
               ctx->grid[offset] = q->c;

     

       774
       774
       -
               ctx->map[offset] = NULL;

     

       775
       775
       -
           }

     

       776
       776
       -
       

     

       777
       777
       -
           if ((ctx->old_cursor_x != ctx->cursor_x || ctx->old_cursor_y != ctx->cursor_y) || _ctx->cursor_enabled == false) {

     

       778
       778
       -
               if (ctx->old_cursor_x < _ctx->cols && ctx->old_cursor_y < _ctx->rows) {

     

       779
       779
       -
                   plot_char(_ctx, &ctx->grid[ctx->old_cursor_x + ctx->old_cursor_y * _ctx->cols], ctx->old_cursor_x, ctx->old_cursor_y);

     

       780
       780
       -
               }

     

       781
       781
       -
           }

     

       782
       782
       -
       

     

       783
       783
       -
           ctx->old_cursor_x = ctx->cursor_x;

     

       784
       784
       -
           ctx->old_cursor_y = ctx->cursor_y;

     

       785
       785
       -
       

     

       786
       786
       -
           ctx->queue_i = 0;

     

       787
       787
       -
       }

     

       788
       788
       -
       

     

       789
       789
       -
       static void flanterm_fb_raw_putchar(struct flanterm_context *_ctx, uint8_t c) {

     

       790
       790
       -
           struct flanterm_fb_context *ctx = (void *)_ctx;

     

       791
       791
       -
       

     

       792
       792
       -
           if (ctx->cursor_x >= _ctx->cols && (ctx->cursor_y < _ctx->scroll_bottom_margin - 1 || _ctx->scroll_enabled)) {

     

       793
       793
       -
               ctx->cursor_x = 0;

     

       794
       794
       -
               ctx->cursor_y++;

     

       795
       795
       -
               if (ctx->cursor_y == _ctx->scroll_bottom_margin) {

     

       796
       796
       -
                   ctx->cursor_y--;

     

       797
       797
       -
                   flanterm_fb_scroll(_ctx);

     

       798
       798
       -
               }

     

       799
       799
       -
               if (ctx->cursor_y >= _ctx->cols) {

     

       800
       800
       -
                   ctx->cursor_y = _ctx->cols - 1;

     

       801
       801
       -
               }

     

       802
       802
       -
           }

     

       803
       803
       -
       

     

       804
       804
       -
           struct flanterm_fb_char ch;

     

       805
       805
       -
           ch.c  = c;

     

       806
       806
       -
           ch.fg = ctx->text_fg;

     

       807
       807
       -
           ch.bg = ctx->text_bg;

     

       808
       808
       -
           push_to_queue(_ctx, &ch, ctx->cursor_x++, ctx->cursor_y);

     

       809
       809
       -
       }

     

       810
       810
       -
       

     

       811
       811
       -
       static void flanterm_fb_full_refresh(struct flanterm_context *_ctx) {

     

       812
       812
       -
           struct flanterm_fb_context *ctx = (void *)_ctx;

     

       813
       813
       -
       

     

       814
       814
       -
       #ifdef FLANTERM_FB_DISABLE_CANVAS

     

       815
       815
       -
           uint32_t default_bg = ctx->default_bg;

     

       816
       816
       -
       #endif

     

       817
       817
       -
       

     

       818
       818
       -
           for (size_t y = 0; y < ctx->height; y++) {

     

       819
       819
       -
               for (size_t x = 0; x < ctx->width; x++) {

     

       820
       820
       -
       #ifndef FLANTERM_FB_DISABLE_CANVAS

     

       821
       821
       -
                   ctx->framebuffer[y * (ctx->pitch / sizeof(uint32_t)) + x] = ctx->canvas[y * ctx->width + x];

     

       822
       822
       -
       #else

     

       823
       823
       -
                   ctx->framebuffer[y * (ctx->pitch / sizeof(uint32_t)) + x] = default_bg;

     

       824
       824
       -
       #endif

     

       825
       825
       -
               }

     

       826
       826
       -
           }

     

       827
       827
       -
       

     

       828
       828
       -
           for (size_t i = 0; i < (size_t)_ctx->rows * _ctx->cols; i++) {

     

       829
       829
       -
               size_t x = i % _ctx->cols;

     

       830
       830
       -
               size_t y = i / _ctx->cols;

     

       831
       831
       -
       

     

       832
       832
       -
               plot_char(_ctx, &ctx->grid[i], x, y);

     

       833
       833
       -
           }

     

       834
       834
       -
       

     

       835
       835
       -
           if (_ctx->cursor_enabled) {

     

       836
       836
       -
               draw_cursor(_ctx);

     

       837
       837
       -
           }

     

       838
       838
       -
       }

     

       839
       839
       -
       

     

       840
       840
       -
       static void flanterm_fb_deinit(struct flanterm_context *_ctx, void (*_free)(void *, size_t)) {

     

       841
       841
       -
           struct flanterm_fb_context *ctx = (void *)_ctx;

     

       842
       842
       -
       

     

       843
       843
       -
           if (_free == NULL) {

     

       844
       844
       -
               return;

     

       845
       845
       -
           }

     

       846
       846
       -
       

     

       847
       847
       -
           _free(ctx->font_bits, ctx->font_bits_size);

     

       848
       848
       -
           _free(ctx->font_bool, ctx->font_bool_size);

     

       849
       849
       -
           _free(ctx->grid, ctx->grid_size);

     

       850
       850
       -
           _free(ctx->queue, ctx->queue_size);

     

       851
       851
       -
           _free(ctx->map, ctx->map_size);

     

       852
       852
       -
       

     

       853
       853
       -
       #ifndef FLANTERM_FB_DISABLE_CANVAS

     

       854
       854
       -
           _free(ctx->canvas, ctx->canvas_size);

     

       855
       855
       -
       #endif

     

       856
       856
       -
       

     

       857
       857
       -
           _free(ctx, sizeof(struct flanterm_fb_context));

     

       858
       858
       -
       }

     

       859
       859
       -
       

     

       860
       860
       -
       struct flanterm_context *flanterm_fb_init(

     

       861
       861
       -
           void *(*_malloc)(size_t),

     

       862
       862
       -
           void (*_free)(void *, size_t),

     

       863
       863
       -
           uint32_t *framebuffer, size_t width, size_t height, size_t pitch,

     

       864
       864
       -
       #ifdef FLANTERM_FB_SUPPORT_BPP

     

       865
       865
       -
           uint8_t red_mask_size, uint8_t red_mask_shift,

     

       866
       866
       -
           uint8_t green_mask_size, uint8_t green_mask_shift,

     

       867
       867
       -
           uint8_t blue_mask_size, uint8_t blue_mask_shift,

     

       868
       868
       -
       #endif

     

       869
       869
       -
       #ifndef FLANTERM_FB_DISABLE_CANVAS

     

       870
       870
       -
           uint32_t *canvas,

     

       871
       871
       -
       #endif

     

       872
       872
       -
           uint32_t *ansi_colours, uint32_t *ansi_bright_colours,

     

       873
       873
       -
           uint32_t *default_bg, uint32_t *default_fg,

     

       874
       874
       -
           uint32_t *default_bg_bright, uint32_t *default_fg_bright,

     

       875
       875
       -
           void *font, size_t font_width, size_t font_height, size_t font_spacing,

     

       876
       876
       -
           size_t font_scale_x, size_t font_scale_y,

     

       877
       877
       -
           size_t margin

     

       878
       878
       -
       ) {

     

       879
       879
       -
       #ifndef FLANTERM_FB_DISABLE_BUMP_ALLOC

     

       880
       880
       -
           size_t orig_bump_alloc_ptr = bump_alloc_ptr;

     

       881
       881
       -
       #endif

     

       882
       882
       -
       

     

       883
       883
       -
       #ifdef FLANTERM_FB_SUPPORT_BPP

     

       884
       884
       -
           if (red_mask_size < 8 || red_mask_size != green_mask_size || red_mask_size != blue_mask_size) {

     

       885
       885
       -
               return NULL;

     

       886
       886
       -
           }

     

       887
       887
       -
       #endif

     

       888
       888
       -
       

     

       889
       889
       -
           if (_malloc == NULL) {

     

       890
       890
       -
       #ifndef FLANTERM_FB_DISABLE_BUMP_ALLOC

     

       891
       891
       -
               _malloc = bump_alloc;

     

       892
       892
       -
       #else

     

       893
       893
       -
               return NULL;

     

       894
       894
       -
       #endif

     

       895
       895
       -
           }

     

       896
       896
       -
       

     

       897
       897
       -
           struct flanterm_fb_context *ctx = NULL;

     

       898
       898
       -
           ctx = _malloc(sizeof(struct flanterm_fb_context));

     

       899
       899
       -
           if (ctx == NULL) {

     

       900
       900
       -
               goto fail;

     

       901
       901
       -
           }

     

       902
       902
       -
       

     

       903
       903
       -
           struct flanterm_context *_ctx = (void *)ctx;

     

       904
       904
       -
           memset(ctx, 0, sizeof(struct flanterm_fb_context));

     

       905
       905
       -
       

     

       906
       906
       -
       #ifdef FLANTERM_FB_SUPPORT_BPP

     

       907
       907
       -
           ctx->red_mask_size = red_mask_size;

     

       908
       908
       -
           ctx->red_mask_shift = red_mask_shift + (red_mask_size - 8);

     

       909
       909
       -
           ctx->green_mask_size = green_mask_size;

     

       910
       910
       -
           ctx->green_mask_shift = green_mask_shift + (green_mask_size - 8);

     

       911
       911
       -
           ctx->blue_mask_size = blue_mask_size;

     

       912
       912
       -
           ctx->blue_mask_shift = blue_mask_shift + (blue_mask_size - 8);

     

       913
       913
       -
       #endif

     

       914
       914
       -
       

     

       915
       915
       -
           if (ansi_colours != NULL) {

     

       916
       916
       -
               for (size_t i = 0; i < 8; i++) {

     

       917
       917
       -
                   ctx->ansi_colours[i] = convert_colour(_ctx, ansi_colours[i]);

     

       918
       918
       -
               }

     

       919
       919
       -
           } else {

     

       920
       920
       -
               ctx->ansi_colours[0] = convert_colour(_ctx, 0x00000000); // black

     

       921
       921
       -
               ctx->ansi_colours[1] = convert_colour(_ctx, 0x00aa0000); // red

     

       922
       922
       -
               ctx->ansi_colours[2] = convert_colour(_ctx, 0x0000aa00); // green

     

       923
       923
       -
               ctx->ansi_colours[3] = convert_colour(_ctx, 0x00aa5500); // brown

     

       924
       924
       -
               ctx->ansi_colours[4] = convert_colour(_ctx, 0x000000aa); // blue

     

       925
       925
       -
               ctx->ansi_colours[5] = convert_colour(_ctx, 0x00aa00aa); // magenta

     

       926
       926
       -
               ctx->ansi_colours[6] = convert_colour(_ctx, 0x0000aaaa); // cyan

     

       927
       927
       -
               ctx->ansi_colours[7] = convert_colour(_ctx, 0x00aaaaaa); // grey

     

       928
       928
       -
           }

     

       929
       929
       -
       

     

       930
       930
       -
           if (ansi_bright_colours != NULL) {

     

       931
       931
       -
               for (size_t i = 0; i < 8; i++) {

     

       932
       932
       -
                   ctx->ansi_bright_colours[i] = convert_colour(_ctx, ansi_bright_colours[i]);

     

       933
       933
       -
               }

     

       934
       934
       -
           } else {

     

       935
       935
       -
               ctx->ansi_bright_colours[0] = convert_colour(_ctx, 0x00555555); // black

     

       936
       936
       -
               ctx->ansi_bright_colours[1] = convert_colour(_ctx, 0x00ff5555); // red

     

       937
       937
       -
               ctx->ansi_bright_colours[2] = convert_colour(_ctx, 0x0055ff55); // green

     

       938
       938
       -
               ctx->ansi_bright_colours[3] = convert_colour(_ctx, 0x00ffff55); // brown

     

       939
       939
       -
               ctx->ansi_bright_colours[4] = convert_colour(_ctx, 0x005555ff); // blue

     

       940
       940
       -
               ctx->ansi_bright_colours[5] = convert_colour(_ctx, 0x00ff55ff); // magenta

     

       941
       941
       -
               ctx->ansi_bright_colours[6] = convert_colour(_ctx, 0x0055ffff); // cyan

     

       942
       942
       -
               ctx->ansi_bright_colours[7] = convert_colour(_ctx, 0x00ffffff); // grey

     

       943
       943
       -
           }

     

       944
       944
       -
       

     

       945
       945
       -
           if (default_bg != NULL) {

     

       946
       946
       -
               ctx->default_bg = convert_colour(_ctx, *default_bg);

     

       947
       947
       -
           } else {

     

       948
       948
       -
               ctx->default_bg = 0x00000000; // background (black)

     

       949
       949
       -
           }

     

       950
       950
       -
       

     

       951
       951
       -
           if (default_fg != NULL) {

     

       952
       952
       -
               ctx->default_fg = convert_colour(_ctx, *default_fg);

     

       953
       953
       -
           } else {

     

       954
       954
       -
               ctx->default_fg = convert_colour(_ctx, 0x00aaaaaa); // foreground (grey)

     

       955
       955
       -
           }

     

       956
       956
       -
       

     

       957
       957
       -
           if (default_bg_bright != NULL) {

     

       958
       958
       -
               ctx->default_bg_bright = convert_colour(_ctx, *default_bg_bright);

     

       959
       959
       -
           } else {

     

       960
       960
       -
               ctx->default_bg_bright = convert_colour(_ctx, 0x00555555); // background (black)

     

       961
       961
       -
           }

     

       962
       962
       -
       

     

       963
       963
       -
           if (default_fg_bright != NULL) {

     

       964
       964
       -
               ctx->default_fg_bright = convert_colour(_ctx, *default_fg_bright);

     

       965
       965
       -
           } else {

     

       966
       966
       -
               ctx->default_fg_bright = convert_colour(_ctx, 0x00ffffff); // foreground (grey)

     

       967
       967
       -
           }

     

       968
       968
       -
       

     

       969
       969
       -
           ctx->text_fg = ctx->default_fg;

     

       970
       970
       -
           ctx->text_bg = 0xffffffff;

     

       971
       971
       -
       

     

       972
       972
       -
           ctx->framebuffer = (void *)framebuffer;

     

       973
       973
       -
           ctx->width = width;

     

       974
       974
       -
           ctx->height = height;

     

       975
       975
       -
           ctx->pitch = pitch;

     

       976
       976
       -
       

     

       977
       977
       -
       #define FONT_BYTES ((font_width * font_height * FLANTERM_FB_FONT_GLYPHS) / 8)

     

       978
       978
       -
       

     

       979
       979
       -
           if (font != NULL) {

     

       980
       980
       -
               ctx->font_width = font_width;

     

       981
       981
       -
               ctx->font_height = font_height;

     

       982
       982
       -
               ctx->font_bits_size = FONT_BYTES;

     

       983
       983
       -
               ctx->font_bits = _malloc(ctx->font_bits_size);

     

       984
       984
       -
               if (ctx->font_bits == NULL) {

     

       985
       985
       -
                   goto fail;

     

       986
       986
       -
               }

     

       987
       987
       -
               memcpy(ctx->font_bits, font, ctx->font_bits_size);

     

       988
       988
       -
           } else {

     

       989
       989
       -
               ctx->font_width = font_width = 8;

     

       990
       990
       -
               ctx->font_height = font_height = 16;

     

       991
       991
       -
               ctx->font_bits_size = FONT_BYTES;

     

       992
       992
       -
               font_spacing = 1;

     

       993
       993
       -
               ctx->font_bits = _malloc(ctx->font_bits_size);

     

       994
       994
       -
               if (ctx->font_bits == NULL) {

     

       995
       995
       -
                   goto fail;

     

       996
       996
       -
               }

     

       997
       997
       -
               memcpy(ctx->font_bits, builtin_font, ctx->font_bits_size);

     

       998
       998
       -
           }

     

       999
       999
       -
       

     

       1000
       1000
       -
       #undef FONT_BYTES

     

       1001
       1001
       -
       

     

       1002
       1002
       -
           ctx->font_width += font_spacing;

     

       1003
       1003
       -
       

     

       1004
       1004
       -
           ctx->font_bool_size = FLANTERM_FB_FONT_GLYPHS * font_height * ctx->font_width * sizeof(bool);

     

       1005
       1005
       -
           ctx->font_bool = _malloc(ctx->font_bool_size);

     

       1006
       1006
       -
           if (ctx->font_bool == NULL) {

     

       1007
       1007
       -
               goto fail;

     

       1008
       1008
       -
           }

     

       1009
       1009
       -
       

     

       1010
       1010
       -
           for (size_t i = 0; i < FLANTERM_FB_FONT_GLYPHS; i++) {

     

       1011
       1011
       -
               uint8_t *glyph = &ctx->font_bits[i * font_height];

     

       1012
       1012
       -
       

     

       1013
       1013
       -
               for (size_t y = 0; y < font_height; y++) {

     

       1014
       1014
       -
                   // NOTE: the characters in VGA fonts are always one byte wide.

     

       1015
       1015
       -
                   // 9 dot wide fonts have 8 dots and one empty column, except

     

       1016
       1016
       -
                   // characters 0xC0-0xDF replicate column 9.

     

       1017
       1017
       -
                   for (size_t x = 0; x < 8; x++) {

     

       1018
       1018
       -
                       size_t offset = i * font_height * ctx->font_width + y * ctx->font_width + x;

     

       1019
       1019
       -
       

     

       1020
       1020
       -
                       if ((glyph[y] & (0x80 >> x))) {

     

       1021
       1021
       -
                           ctx->font_bool[offset] = true;

     

       1022
       1022
       -
                       } else {

     

       1023
       1023
       -
                           ctx->font_bool[offset] = false;

     

       1024
       1024
       -
                       }

     

       1025
       1025
       -
                   }

     

       1026
       1026
       -
                   // fill columns above 8 like VGA Line Graphics Mode does

     

       1027
       1027
       -
                   for (size_t x = 8; x < ctx->font_width; x++) {

     

       1028
       1028
       -
                       size_t offset = i * font_height * ctx->font_width + y * ctx->font_width + x;

     

       1029
       1029
       -
       

     

       1030
       1030
       -
                       if (i >= 0xc0 && i <= 0xdf) {

     

       1031
       1031
       -
                           ctx->font_bool[offset] = (glyph[y] & 1);

     

       1032
       1032
       -
                       } else {

     

       1033
       1033
       -
                           ctx->font_bool[offset] = false;

     

       1034
       1034
       -
                       }

     

       1035
       1035
       -
                   }

     

       1036
       1036
       -
               }

     

       1037
       1037
       -
           }

     

       1038
       1038
       -
       

     

       1039
       1039
       -
           ctx->font_scale_x = font_scale_x;

     

       1040
       1040
       -
           ctx->font_scale_y = font_scale_y;

     

       1041
       1041
       -
       

     

       1042
       1042
       -
           ctx->glyph_width = ctx->font_width * font_scale_x;

     

       1043
       1043
       -
           ctx->glyph_height = font_height * font_scale_y;

     

       1044
       1044
       -
       

     

       1045
       1045
       -
           _ctx->cols = (ctx->width - margin * 2) / ctx->glyph_width;

     

       1046
       1046
       -
           _ctx->rows = (ctx->height - margin * 2) / ctx->glyph_height;

     

       1047
       1047
       -
       

     

       1048
       1048
       -
           ctx->offset_x = margin + ((ctx->width - margin * 2) % ctx->glyph_width) / 2;

     

       1049
       1049
       -
           ctx->offset_y = margin + ((ctx->height - margin * 2) % ctx->glyph_height) / 2;

     

       1050
       1050
       -
       

     

       1051
       1051
       -
           ctx->grid_size = _ctx->rows * _ctx->cols * sizeof(struct flanterm_fb_char);

     

       1052
       1052
       -
           ctx->grid = _malloc(ctx->grid_size);

     

       1053
       1053
       -
           if (ctx->grid == NULL) {

     

       1054
       1054
       -
               goto fail;

     

       1055
       1055
       -
           }

     

       1056
       1056
       -
           for (size_t i = 0; i < _ctx->rows * _ctx->cols; i++) {

     

       1057
       1057
       -
               ctx->grid[i].c = ' ';

     

       1058
       1058
       -
               ctx->grid[i].fg = ctx->text_fg;

     

       1059
       1059
       -
               ctx->grid[i].bg = ctx->text_bg;

     

       1060
       1060
       -
           }

     

       1061
       1061
       -
       

     

       1062
       1062
       -
           ctx->queue_size = _ctx->rows * _ctx->cols * sizeof(struct flanterm_fb_queue_item);

     

       1063
       1063
       -
           ctx->queue = _malloc(ctx->queue_size);

     

       1064
       1064
       -
           if (ctx->queue == NULL) {

     

       1065
       1065
       -
               goto fail;

     

       1066
       1066
       -
           }

     

       1067
       1067
       -
           ctx->queue_i = 0;

     

       1068
       1068
       -
           memset(ctx->queue, 0, ctx->queue_size);

     

       1069
       1069
       -
       

     

       1070
       1070
       -
           ctx->map_size = _ctx->rows * _ctx->cols * sizeof(struct flanterm_fb_queue_item *);

     

       1071
       1071
       -
           ctx->map = _malloc(ctx->map_size);

     

       1072
       1072
       -
           if (ctx->map == NULL) {

     

       1073
       1073
       -
               goto fail;

     

       1074
       1074
       -
           }

     

       1075
       1075
       -
           memset(ctx->map, 0, ctx->map_size);

     

       1076
       1076
       -
       

     

       1077
       1077
       -
       #ifndef FLANTERM_FB_DISABLE_CANVAS

     

       1078
       1078
       -
           ctx->canvas_size = ctx->width * ctx->height * sizeof(uint32_t);

     

       1079
       1079
       -
           ctx->canvas = _malloc(ctx->canvas_size);

     

       1080
       1080
       -
           if (ctx->canvas == NULL) {

     

       1081
       1081
       -
               goto fail;

     

       1082
       1082
       -
           }

     

       1083
       1083
       -
           if (canvas != NULL) {

     

       1084
       1084
       -
               for (size_t i = 0; i < ctx->width * ctx->height; i++) {

     

       1085
       1085
       -
                   ctx->canvas[i] = convert_colour(_ctx, canvas[i]);

     

       1086
       1086
       -
               }

     

       1087
       1087
       -
           } else {

     

       1088
       1088
       -
               for (size_t i = 0; i < ctx->width * ctx->height; i++) {

     

       1089
       1089
       -
                   ctx->canvas[i] = ctx->default_bg;

     

       1090
       1090
       -
               }

     

       1091
       1091
       -
           }

     

       1092
       1092
       -
       #endif

     

       1093
       1093
       -
       

     

       1094
       1094
       -
           _ctx->raw_putchar = flanterm_fb_raw_putchar;

     

       1095
       1095
       -
           _ctx->clear = flanterm_fb_clear;

     

       1096
       1096
       -
           _ctx->set_cursor_pos = flanterm_fb_set_cursor_pos;

     

       1097
       1097
       -
           _ctx->get_cursor_pos = flanterm_fb_get_cursor_pos;

     

       1098
       1098
       -
           _ctx->set_text_fg = flanterm_fb_set_text_fg;

     

       1099
       1099
       -
           _ctx->set_text_bg = flanterm_fb_set_text_bg;

     

       1100
       1100
       -
           _ctx->set_text_fg_bright = flanterm_fb_set_text_fg_bright;

     

       1101
       1101
       -
           _ctx->set_text_bg_bright = flanterm_fb_set_text_bg_bright;

     

       1102
       1102
       -
           _ctx->set_text_fg_rgb = flanterm_fb_set_text_fg_rgb;

     

       1103
       1103
       -
           _ctx->set_text_bg_rgb = flanterm_fb_set_text_bg_rgb;

     

       1104
       1104
       -
           _ctx->set_text_fg_default = flanterm_fb_set_text_fg_default;

     

       1105
       1105
       -
           _ctx->set_text_bg_default = flanterm_fb_set_text_bg_default;

     

       1106
       1106
       -
           _ctx->set_text_fg_default_bright = flanterm_fb_set_text_fg_default_bright;

     

       1107
       1107
       -
           _ctx->set_text_bg_default_bright = flanterm_fb_set_text_bg_default_bright;

     

       1108
       1108
       -
           _ctx->move_character = flanterm_fb_move_character;

     

       1109
       1109
       -
           _ctx->scroll = flanterm_fb_scroll;

     

       1110
       1110
       -
           _ctx->revscroll = flanterm_fb_revscroll;

     

       1111
       1111
       -
           _ctx->swap_palette = flanterm_fb_swap_palette;

     

       1112
       1112
       -
           _ctx->save_state = flanterm_fb_save_state;

     

       1113
       1113
       -
           _ctx->restore_state = flanterm_fb_restore_state;

     

       1114
       1114
       -
           _ctx->double_buffer_flush = flanterm_fb_double_buffer_flush;

     

       1115
       1115
       -
           _ctx->full_refresh = flanterm_fb_full_refresh;

     

       1116
       1116
       -
           _ctx->deinit = flanterm_fb_deinit;

     

       1117
       1117
       -
       

     

       1118
       1118
       -
           flanterm_context_reinit(_ctx);

     

       1119
       1119
       -
           flanterm_fb_full_refresh(_ctx);

     

       1120
       1120
       -
       

     

       1121
       1121
       -
           return _ctx;

     

       1122
       1122
       -
       

     

       1123
       1123
       -
       fail:

     

       1124
       1124
       -
       #ifndef FLANTERM_FB_DISABLE_BUMP_ALLOC

     

       1125
       1125
       -
           if (_malloc == bump_alloc) {

     

       1126
       1126
       -
               bump_alloc_ptr = orig_bump_alloc_ptr;

     

       1127
       1127
       -
               return NULL;

     

       1128
       1128
       -
           }

     

       1129
       1129
       -
       #endif

     

       1130
       1130
       -
       

     

       1131
       1131
       -
           if (_free == NULL) {

     

       1132
       1132
       -
               return NULL;

     

       1133
       1133
       -
           }

     

       1134
       1134
       -
       

     

       1135
       1135
       -
       #ifndef FLANTERM_FB_DISABLE_CANVAS

     

       1136
       1136
       -
           if (ctx->canvas != NULL) {

     

       1137
       1137
       -
               _free(ctx->canvas, ctx->canvas_size);

     

       1138
       1138
       -
           }

     

       1139
       1139
       -
       #endif

     

       1140
       1140
       -
           if (ctx->map != NULL) {

     

       1141
       1141
       -
               _free(ctx->map, ctx->map_size);

     

       1142
       1142
       -
           }

     

       1143
       1143
       -
           if (ctx->queue != NULL) {

     

       1144
       1144
       -
               _free(ctx->queue, ctx->queue_size);

     

       1145
       1145
       -
           }

     

       1146
       1146
       -
           if (ctx->grid != NULL) {

     

       1147
       1147
       -
               _free(ctx->grid, ctx->grid_size);

     

       1148
       1148
       -
           }

     

       1149
       1149
       -
           if (ctx->font_bool != NULL) {

     

       1150
       1150
       -
               _free(ctx->font_bool, ctx->font_bool_size);

     

       1151
       1151
       -
           }

     

       1152
       1152
       -
           if (ctx->font_bits != NULL) {

     

       1153
       1153
       -
               _free(ctx->font_bits, ctx->font_bits_size);

     

       1154
       1154
       -
           }

     

       1155
       1155
       -
           if (ctx != NULL) {

     

       1156
       1156
       -
               _free(ctx, sizeof(struct flanterm_fb_context));

     

       1157
       1157
       -
           }

     

       1158
       1158
       -
       

     

       1159
       1159
       -
           return NULL;

     

       1160
       1160
       -
       }

-184

backends/fb.h

···

       1
       1
       -
       /* Copyright (C) 2022-2023 mintsuki and contributors.

     

       2
       2
       -
        *

     

       3
       3
       -
        * Redistribution and use in source and binary forms, with or without

     

       4
       4
       -
        * modification, are permitted provided that the following conditions are met:

     

       5
       5
       -
        *

     

       6
       6
       -
        * 1. Redistributions of source code must retain the above copyright notice,

     

       7
       7
       -
        *    this list of conditions and the following disclaimer.

     

       8
       8
       -
        *

     

       9
       9
       -
        * 2. Redistributions in binary form must reproduce the above copyright notice,

     

       10
       10
       -
        *    this list of conditions and the following disclaimer in the documentation

     

       11
       11
       -
        *    and/or other materials provided with the distribution.

     

       12
       12
       -
        *

     

       13
       13
       -
        * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

     

       14
       14
       -
        * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

     

       15
       15
       -
        * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

     

       16
       16
       -
        * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE

     

       17
       17
       -
        * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

     

       18
       18
       -
        * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

     

       19
       19
       -
        * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

     

       20
       20
       -
        * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

     

       21
       21
       -
        * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

     

       22
       22
       -
        * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

     

       23
       23
       -
        * POSSIBILITY OF SUCH DAMAGE.

     

       24
       24
       -
        */

     

       25
       25
       -
       

     

       26
       26
       -
       #ifndef _FLANTERM_FR_H

     

       27
       27
       -
       #define _FLANTERM_FB_H 1

     

       28
       28
       -
       

     

       29
       29
       -
       #ifdef __cplusplus

     

       30
       30
       -
       extern "C" {

     

       31
       31
       -
       #endif

     

       32
       32
       -
       

     

       33
       33
       -
       #include <stdint.h>

     

       34
       34
       -
       #include <stddef.h>

     

       35
       35
       -
       #include <stdbool.h>

     

       36
       36
       -
       

     

       37
       37
       -
       #include "../flanterm.h"

     

       38
       38
       -
       

     

       39
       39
       -
       #define FLANTERM_FB_FONT_GLYPHS 256

     

       40
       40
       -
       

     

       41
       41
       -
       struct flanterm_fb_char {

     

       42
       42
       -
           uint32_t c;

     

       43
       43
       -
           uint32_t fg;

     

       44
       44
       -
           uint32_t bg;

     

       45
       45
       -
       };

     

       46
       46
       -
       

     

       47
       47
       -
       struct flanterm_fb_queue_item {

     

       48
       48
       -
           size_t x, y;

     

       49
       49
       -
           struct flanterm_fb_char c;

     

       50
       50
       -
       };

     

       51
       51
       -
       

     

       52
       52
       -
       struct flanterm_fb_context {

     

       53
       53
       -
           struct flanterm_context term;

     

       54
       54
       -
       

     

       55
       55
       -
           size_t font_width;

     

       56
       56
       -
           size_t font_height;

     

       57
       57
       -
           size_t glyph_width;

     

       58
       58
       -
           size_t glyph_height;

     

       59
       59
       -
       

     

       60
       60
       -
           size_t font_scale_x;

     

       61
       61
       -
           size_t font_scale_y;

     

       62
       62
       -
       

     

       63
       63
       -
           size_t offset_x, offset_y;

     

       64
       64
       -
       

     

       65
       65
       -
           volatile uint32_t *framebuffer;

     

       66
       66
       -
           size_t pitch;

     

       67
       67
       -
           size_t width;

     

       68
       68
       -
           size_t height;

     

       69
       69
       -
           size_t bpp;

     

       70
       70
       -
       

     

       71
       71
       -
       #ifdef FLANTERM_FB_SUPPORT_BPP

     

       72
       72
       -
           uint8_t red_mask_size, red_mask_shift;

     

       73
       73
       -
           uint8_t green_mask_size, green_mask_shift;

     

       74
       74
       -
           uint8_t blue_mask_size, blue_mask_shift;

     

       75
       75
       -
       #endif

     

       76
       76
       -
       

     

       77
       77
       -
           size_t font_bits_size;

     

       78
       78
       -
           uint8_t *font_bits;

     

       79
       79
       -
           size_t font_bool_size;

     

       80
       80
       -
           bool *font_bool;

     

       81
       81
       -
       

     

       82
       82
       -
           uint32_t ansi_colours[8];

     

       83
       83
       -
           uint32_t ansi_bright_colours[8];

     

       84
       84
       -
           uint32_t default_fg, default_bg;

     

       85
       85
       -
           uint32_t default_fg_bright, default_bg_bright;

     

       86
       86
       -
       

     

       87
       87
       -
       #ifndef FLANTERM_FB_DISABLE_CANVAS

     

       88
       88
       -
           size_t canvas_size;

     

       89
       89
       -
           uint32_t *canvas;

     

       90
       90
       -
       #endif

     

       91
       91
       -
       

     

       92
       92
       -
           size_t grid_size;

     

       93
       93
       -
           size_t queue_size;

     

       94
       94
       -
           size_t map_size;

     

       95
       95
       -
       

     

       96
       96
       -
           struct flanterm_fb_char *grid;

     

       97
       97
       -
       

     

       98
       98
       -
           struct flanterm_fb_queue_item *queue;

     

       99
       99
       -
           size_t queue_i;

     

       100
       100
       -
       

     

       101
       101
       -
           struct flanterm_fb_queue_item **map;

     

       102
       102
       -
       

     

       103
       103
       -
           uint32_t text_fg;

     

       104
       104
       -
           uint32_t text_bg;

     

       105
       105
       -
           size_t cursor_x;

     

       106
       106
       -
           size_t cursor_y;

     

       107
       107
       -
       

     

       108
       108
       -
           uint32_t saved_state_text_fg;

     

       109
       109
       -
           uint32_t saved_state_text_bg;

     

       110
       110
       -
           size_t saved_state_cursor_x;

     

       111
       111
       -
           size_t saved_state_cursor_y;

     

       112
       112
       -
       

     

       113
       113
       -
           size_t old_cursor_x;

     

       114
       114
       -
           size_t old_cursor_y;

     

       115
       115
       -
       };

     

       116
       116
       -
       

     

       117
       117
       -
       struct flanterm_context *flanterm_fb_init(

     

       118
       118
       -
           void *(*_malloc)(size_t),

     

       119
       119
       -
           void (*_free)(void *, size_t),

     

       120
       120
       -
           uint32_t *framebuffer, size_t width, size_t height, size_t pitch,

     

       121
       121
       -
       #ifdef FLANTERM_FB_SUPPORT_BPP

     

       122
       122
       -
           uint8_t red_mask_size, uint8_t red_mask_shift,

     

       123
       123
       -
           uint8_t green_mask_size, uint8_t green_mask_shift,

     

       124
       124
       -
           uint8_t blue_mask_size, uint8_t blue_mask_shift,

     

       125
       125
       -
       #endif

     

       126
       126
       -
       #ifndef FLANTERM_FB_DISABLE_CANVAS

     

       127
       127
       -
           uint32_t *canvas,

     

       128
       128
       -
       #endif

     

       129
       129
       -
           uint32_t *ansi_colours, uint32_t *ansi_bright_colours,

     

       130
       130
       -
           uint32_t *default_bg, uint32_t *default_fg,

     

       131
       131
       -
           uint32_t *default_bg_bright, uint32_t *default_fg_bright,

     

       132
       132
       -
           void *font, size_t font_width, size_t font_height, size_t font_spacing,

     

       133
       133
       -
           size_t font_scale_x, size_t font_scale_y,

     

       134
       134
       -
           size_t margin

     

       135
       135
       -
       );

     

       136
       136
       -
       

     

       137
       137
       -
       #ifndef FLANTERM_FB_DISABLE_BUMP_ALLOC

     

       138
       138
       -
       static inline struct flanterm_context *flanterm_fb_simple_init(

     

       139
       139
       -
           uint32_t *framebuffer, size_t width, size_t height, size_t pitch

     

       140
       140
       -
       #ifdef FLANTERM_FB_SUPPORT_BPP

     

       141
       141
       -
           ,

     

       142
       142
       -
           uint8_t red_mask_size, uint8_t red_mask_shift,

     

       143
       143
       -
           uint8_t green_mask_size, uint8_t green_mask_shift,

     

       144
       144
       -
           uint8_t blue_mask_size, uint8_t blue_mask_shift

     

       145
       145
       -
       #endif

     

       146
       146
       -
       ) {

     

       147
       147
       -
           size_t font_scale_x = 1;

     

       148
       148
       -
           size_t font_scale_y = 1;

     

       149
       149
       -
           if (width >= (1920 + 1920 / 3) && height >= (1080 + 1080 / 3)) {

     

       150
       150
       -
               font_scale_x = 2;

     

       151
       151
       -
               font_scale_y = 2;

     

       152
       152
       -
           }

     

       153
       153
       -
           if (width >= (3840 + 3840 / 3) && height >= (2160 + 2160 / 3)) {

     

       154
       154
       -
               font_scale_x = 4;

     

       155
       155
       -
               font_scale_y = 4;

     

       156
       156
       -
           }

     

       157
       157
       -
       

     

       158
       158
       -
           return flanterm_fb_init(

     

       159
       159
       -
               NULL,

     

       160
       160
       -
               NULL,

     

       161
       161
       -
               framebuffer, width, height, pitch,

     

       162
       162
       -
       #ifdef FLANTERM_FB_SUPPORT_BPP

     

       163
       163
       -
               red_mask_size, red_mask_shift,

     

       164
       164
       -
               green_mask_size, green_mask_shift,

     

       165
       165
       -
               blue_mask_size, blue_mask_shift,

     

       166
       166
       -
       #endif

     

       167
       167
       -
       #ifndef FLANTERM_FB_DISABLE_CANVAS

     

       168
       168
       -
               NULL,

     

       169
       169
       -
       #endif

     

       170
       170
       -
               NULL, NULL,

     

       171
       171
       -
               NULL, NULL,

     

       172
       172
       -
               NULL, NULL,

     

       173
       173
       -
               NULL, 0, 0, 1,

     

       174
       174
       -
               font_scale_x, font_scale_y,

     

       175
       175
       -
               0

     

       176
       176
       -
           );

     

       177
       177
       -
       }

     

       178
       178
       -
       #endif

     

       179
       179
       -
       

     

       180
       180
       -
       #ifdef __cplusplus

     

       181
       181
       -
       }

     

       182
       182
       -
       #endif

     

       183
       183
       -
       

     

       184
       184
       -
       #endif

+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
       +
       }

-1350

flanterm.c

···

       1
       1
       -
       /* Copyright (C) 2022-2023 mintsuki and contributors.

     

       2
       2
       -
        *

     

       3
       3
       -
        * Redistribution and use in source and binary forms, with or without

     

       4
       4
       -
        * modification, are permitted provided that the following conditions are met:

     

       5
       5
       -
        *

     

       6
       6
       -
        * 1. Redistributions of source code must retain the above copyright notice,

     

       7
       7
       -
        *    this list of conditions and the following disclaimer.

     

       8
       8
       -
        *

     

       9
       9
       -
        * 2. Redistributions in binary form must reproduce the above copyright notice,

     

       10
       10
       -
        *    this list of conditions and the following disclaimer in the documentation

     

       11
       11
       -
        *    and/or other materials provided with the distribution.

     

       12
       12
       -
        *

     

       13
       13
       -
        * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

     

       14
       14
       -
        * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

     

       15
       15
       -
        * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

     

       16
       16
       -
        * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE

     

       17
       17
       -
        * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

     

       18
       18
       -
        * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

     

       19
       19
       -
        * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

     

       20
       20
       -
        * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

     

       21
       21
       -
        * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

     

       22
       22
       -
        * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

     

       23
       23
       -
        * POSSIBILITY OF SUCH DAMAGE.

     

       24
       24
       -
        */

     

       25
       25
       -
       

     

       26
       26
       -
       #include <stdint.h>

     

       27
       27
       -
       #include <stddef.h>

     

       28
       28
       -
       #include <stdbool.h>

     

       29
       29
       -
       

     

       30
       30
       -
       #include "flanterm.h"

     

       31
       31
       -
       

     

       32
       32
       -
       // Tries to implement this standard for terminfo

     

       33
       33
       -
       // https://man7.org/linux/man-pages/man4/console_codes.4.html

     

       34
       34
       -
       

     

       35
       35
       -
       static const uint32_t col256[] = {

     

       36
       36
       -
           0x000000, 0x00005f, 0x000087, 0x0000af, 0x0000d7, 0x0000ff, 0x005f00, 0x005f5f,

     

       37
       37
       -
           0x005f87, 0x005faf, 0x005fd7, 0x005fff, 0x008700, 0x00875f, 0x008787, 0x0087af,

     

       38
       38
       -
           0x0087d7, 0x0087ff, 0x00af00, 0x00af5f, 0x00af87, 0x00afaf, 0x00afd7, 0x00afff,

     

       39
       39
       -
           0x00d700, 0x00d75f, 0x00d787, 0x00d7af, 0x00d7d7, 0x00d7ff, 0x00ff00, 0x00ff5f,

     

       40
       40
       -
           0x00ff87, 0x00ffaf, 0x00ffd7, 0x00ffff, 0x5f0000, 0x5f005f, 0x5f0087, 0x5f00af,

     

       41
       41
       -
           0x5f00d7, 0x5f00ff, 0x5f5f00, 0x5f5f5f, 0x5f5f87, 0x5f5faf, 0x5f5fd7, 0x5f5fff,

     

       42
       42
       -
           0x5f8700, 0x5f875f, 0x5f8787, 0x5f87af, 0x5f87d7, 0x5f87ff, 0x5faf00, 0x5faf5f,

     

       43
       43
       -
           0x5faf87, 0x5fafaf, 0x5fafd7, 0x5fafff, 0x5fd700, 0x5fd75f, 0x5fd787, 0x5fd7af,

     

       44
       44
       -
           0x5fd7d7, 0x5fd7ff, 0x5fff00, 0x5fff5f, 0x5fff87, 0x5fffaf, 0x5fffd7, 0x5fffff,

     

       45
       45
       -
           0x870000, 0x87005f, 0x870087, 0x8700af, 0x8700d7, 0x8700ff, 0x875f00, 0x875f5f,

     

       46
       46
       -
           0x875f87, 0x875faf, 0x875fd7, 0x875fff, 0x878700, 0x87875f, 0x878787, 0x8787af,

     

       47
       47
       -
           0x8787d7, 0x8787ff, 0x87af00, 0x87af5f, 0x87af87, 0x87afaf, 0x87afd7, 0x87afff,

     

       48
       48
       -
           0x87d700, 0x87d75f, 0x87d787, 0x87d7af, 0x87d7d7, 0x87d7ff, 0x87ff00, 0x87ff5f,

     

       49
       49
       -
           0x87ff87, 0x87ffaf, 0x87ffd7, 0x87ffff, 0xaf0000, 0xaf005f, 0xaf0087, 0xaf00af,

     

       50
       50
       -
           0xaf00d7, 0xaf00ff, 0xaf5f00, 0xaf5f5f, 0xaf5f87, 0xaf5faf, 0xaf5fd7, 0xaf5fff,

     

       51
       51
       -
           0xaf8700, 0xaf875f, 0xaf8787, 0xaf87af, 0xaf87d7, 0xaf87ff, 0xafaf00, 0xafaf5f,

     

       52
       52
       -
           0xafaf87, 0xafafaf, 0xafafd7, 0xafafff, 0xafd700, 0xafd75f, 0xafd787, 0xafd7af,

     

       53
       53
       -
           0xafd7d7, 0xafd7ff, 0xafff00, 0xafff5f, 0xafff87, 0xafffaf, 0xafffd7, 0xafffff,

     

       54
       54
       -
           0xd70000, 0xd7005f, 0xd70087, 0xd700af, 0xd700d7, 0xd700ff, 0xd75f00, 0xd75f5f,

     

       55
       55
       -
           0xd75f87, 0xd75faf, 0xd75fd7, 0xd75fff, 0xd78700, 0xd7875f, 0xd78787, 0xd787af,

     

       56
       56
       -
           0xd787d7, 0xd787ff, 0xd7af00, 0xd7af5f, 0xd7af87, 0xd7afaf, 0xd7afd7, 0xd7afff,

     

       57
       57
       -
           0xd7d700, 0xd7d75f, 0xd7d787, 0xd7d7af, 0xd7d7d7, 0xd7d7ff, 0xd7ff00, 0xd7ff5f,

     

       58
       58
       -
           0xd7ff87, 0xd7ffaf, 0xd7ffd7, 0xd7ffff, 0xff0000, 0xff005f, 0xff0087, 0xff00af,

     

       59
       59
       -
           0xff00d7, 0xff00ff, 0xff5f00, 0xff5f5f, 0xff5f87, 0xff5faf, 0xff5fd7, 0xff5fff,

     

       60
       60
       -
           0xff8700, 0xff875f, 0xff8787, 0xff87af, 0xff87d7, 0xff87ff, 0xffaf00, 0xffaf5f,

     

       61
       61
       -
           0xffaf87, 0xffafaf, 0xffafd7, 0xffafff, 0xffd700, 0xffd75f, 0xffd787, 0xffd7af,

     

       62
       62
       -
           0xffd7d7, 0xffd7ff, 0xffff00, 0xffff5f, 0xffff87, 0xffffaf, 0xffffd7, 0xffffff,

     

       63
       63
       -
           0x080808, 0x121212, 0x1c1c1c, 0x262626, 0x303030, 0x3a3a3a, 0x444444, 0x4e4e4e,

     

       64
       64
       -
           0x585858, 0x626262, 0x6c6c6c, 0x767676, 0x808080, 0x8a8a8a, 0x949494, 0x9e9e9e,

     

       65
       65
       -
           0xa8a8a8, 0xb2b2b2, 0xbcbcbc, 0xc6c6c6, 0xd0d0d0, 0xdadada, 0xe4e4e4, 0xeeeeee

     

       66
       66
       -
       };

     

       67
       67
       -
       

     

       68
       68
       -
       #define CHARSET_DEFAULT 0

     

       69
       69
       -
       #define CHARSET_DEC_SPECIAL 1

     

       70
       70
       -
       

     

       71
       71
       -
       void flanterm_context_reinit(struct flanterm_context *ctx) {

     

       72
       72
       -
           ctx->tab_size = 8;

     

       73
       73
       -
           ctx->autoflush = true;

     

       74
       74
       -
           ctx->cursor_enabled = true;

     

       75
       75
       -
           ctx->scroll_enabled = true;

     

       76
       76
       -
           ctx->control_sequence = false;

     

       77
       77
       -
           ctx->csi = false;

     

       78
       78
       -
           ctx->escape = false;

     

       79
       79
       -
           ctx->osc = false;

     

       80
       80
       -
           ctx->osc_escape = false;

     

       81
       81
       -
           ctx->rrr = false;

     

       82
       82
       -
           ctx->discard_next = false;

     

       83
       83
       -
           ctx->bold = false;

     

       84
       84
       -
           ctx->bg_bold = false;

     

       85
       85
       -
           ctx->reverse_video = false;

     

       86
       86
       -
           ctx->dec_private = false;

     

       87
       87
       -
           ctx->insert_mode = false;

     

       88
       88
       -
           ctx->unicode_remaining = 0;

     

       89
       89
       -
           ctx->g_select = 0;

     

       90
       90
       -
           ctx->charsets[0] = CHARSET_DEFAULT;

     

       91
       91
       -
           ctx->charsets[1] = CHARSET_DEC_SPECIAL;

     

       92
       92
       -
           ctx->current_charset = 0;

     

       93
       93
       -
           ctx->escape_offset = 0;

     

       94
       94
       -
           ctx->esc_values_i = 0;

     

       95
       95
       -
           ctx->saved_cursor_x = 0;

     

       96
       96
       -
           ctx->saved_cursor_y = 0;

     

       97
       97
       -
           ctx->current_primary = (size_t)-1;

     

       98
       98
       -
           ctx->current_bg = (size_t)-1;

     

       99
       99
       -
           ctx->scroll_top_margin = 0;

     

       100
       100
       -
           ctx->scroll_bottom_margin = ctx->rows;

     

       101
       101
       -
           ctx->oob_output = FLANTERM_OOB_OUTPUT_ONLCR;

     

       102
       102
       -
       }

     

       103
       103
       -
       

     

       104
       104
       -
       static void flanterm_putchar(struct flanterm_context *ctx, uint8_t c);

     

       105
       105
       -
       

     

       106
       106
       -
       void flanterm_write(struct flanterm_context *ctx, const char *buf, size_t count) {

     

       107
       107
       -
           for (size_t i = 0; i < count; i++) {

     

       108
       108
       -
               flanterm_putchar(ctx, buf[i]);

     

       109
       109
       -
           }

     

       110
       110
       -
       

     

       111
       111
       -
           if (ctx->autoflush) {

     

       112
       112
       -
               ctx->double_buffer_flush(ctx);

     

       113
       113
       -
           }

     

       114
       114
       -
       }

     

       115
       115
       -
       

     

       116
       116
       -
       static void sgr(struct flanterm_context *ctx) {

     

       117
       117
       -
           size_t i = 0;

     

       118
       118
       -
       

     

       119
       119
       -
           if (!ctx->esc_values_i)

     

       120
       120
       -
               goto def;

     

       121
       121
       -
       

     

       122
       122
       -
           for (; i < ctx->esc_values_i; i++) {

     

       123
       123
       -
               size_t offset;

     

       124
       124
       -
       

     

       125
       125
       -
               if (ctx->esc_values[i] == 0) {

     

       126
       126
       -
       def:

     

       127
       127
       -
                   if (ctx->reverse_video) {

     

       128
       128
       -
                       ctx->reverse_video = false;

     

       129
       129
       -
                       ctx->swap_palette(ctx);

     

       130
       130
       -
                   }

     

       131
       131
       -
                   ctx->bold = false;

     

       132
       132
       -
                   ctx->bg_bold = false;

     

       133
       133
       -
                   ctx->current_primary = (size_t)-1;

     

       134
       134
       -
                   ctx->current_bg = (size_t)-1;

     

       135
       135
       -
                   ctx->set_text_bg_default(ctx);

     

       136
       136
       -
                   ctx->set_text_fg_default(ctx);

     

       137
       137
       -
                   continue;

     

       138
       138
       -
               }

     

       139
       139
       -
       

     

       140
       140
       -
               else if (ctx->esc_values[i] == 1) {

     

       141
       141
       -
                   ctx->bold = true;

     

       142
       142
       -
                   if (ctx->current_primary != (size_t)-1) {

     

       143
       143
       -
                       if (!ctx->reverse_video) {

     

       144
       144
       -
                           ctx->set_text_fg_bright(ctx, ctx->current_primary);

     

       145
       145
       -
                       } else {

     

       146
       146
       -
                           ctx->set_text_bg_bright(ctx, ctx->current_primary);

     

       147
       147
       -
                       }

     

       148
       148
       -
                   } else {

     

       149
       149
       -
                       if (!ctx->reverse_video) {

     

       150
       150
       -
                           ctx->set_text_fg_default_bright(ctx);

     

       151
       151
       -
                       } else {

     

       152
       152
       -
                           ctx->set_text_bg_default_bright(ctx);

     

       153
       153
       -
                       }

     

       154
       154
       -
                   }

     

       155
       155
       -
                   continue;

     

       156
       156
       -
               }

     

       157
       157
       -
       

     

       158
       158
       -
               else if (ctx->esc_values[i] == 5) {

     

       159
       159
       -
                   ctx->bg_bold = true;

     

       160
       160
       -
                   if (ctx->current_bg != (size_t)-1) {

     

       161
       161
       -
                       if (!ctx->reverse_video) {

     

       162
       162
       -
                           ctx->set_text_bg_bright(ctx, ctx->current_bg);

     

       163
       163
       -
                       } else {

     

       164
       164
       -
                           ctx->set_text_fg_bright(ctx, ctx->current_bg);

     

       165
       165
       -
                       }

     

       166
       166
       -
                   } else {

     

       167
       167
       -
                       if (!ctx->reverse_video) {

     

       168
       168
       -
                           ctx->set_text_bg_default_bright(ctx);

     

       169
       169
       -
                       } else {

     

       170
       170
       -
                           ctx->set_text_fg_default_bright(ctx);

     

       171
       171
       -
                       }

     

       172
       172
       -
                   }

     

       173
       173
       -
                   continue;

     

       174
       174
       -
               }

     

       175
       175
       -
       

     

       176
       176
       -
               else if (ctx->esc_values[i] == 22) {

     

       177
       177
       -
                   ctx->bold = false;

     

       178
       178
       -
                   if (ctx->current_primary != (size_t)-1) {

     

       179
       179
       -
                       if (!ctx->reverse_video) {

     

       180
       180
       -
                           ctx->set_text_fg(ctx, ctx->current_primary);

     

       181
       181
       -
                       } else {

     

       182
       182
       -
                           ctx->set_text_bg(ctx, ctx->current_primary);

     

       183
       183
       -
                       }

     

       184
       184
       -
                   } else {

     

       185
       185
       -
                       if (!ctx->reverse_video) {

     

       186
       186
       -
                           ctx->set_text_fg_default(ctx);

     

       187
       187
       -
                       } else {

     

       188
       188
       -
                           ctx->set_text_bg_default(ctx);

     

       189
       189
       -
                       }

     

       190
       190
       -
                   }

     

       191
       191
       -
                   continue;

     

       192
       192
       -
               }

     

       193
       193
       -
       

     

       194
       194
       -
               else if (ctx->esc_values[i] == 25) {

     

       195
       195
       -
                   ctx->bg_bold = false;

     

       196
       196
       -
                   if (ctx->current_bg != (size_t)-1) {

     

       197
       197
       -
                       if (!ctx->reverse_video) {

     

       198
       198
       -
                           ctx->set_text_bg(ctx, ctx->current_bg);

     

       199
       199
       -
                       } else {

     

       200
       200
       -
                           ctx->set_text_fg(ctx, ctx->current_bg);

     

       201
       201
       -
                       }

     

       202
       202
       -
                   } else {

     

       203
       203
       -
                       if (!ctx->reverse_video) {

     

       204
       204
       -
                           ctx->set_text_bg_default(ctx);

     

       205
       205
       -
                       } else {

     

       206
       206
       -
                           ctx->set_text_fg_default(ctx);

     

       207
       207
       -
                       }

     

       208
       208
       -
                   }

     

       209
       209
       -
                   continue;

     

       210
       210
       -
               }

     

       211
       211
       -
       

     

       212
       212
       -
               else if (ctx->esc_values[i] >= 30 && ctx->esc_values[i] <= 37) {

     

       213
       213
       -
                   offset = 30;

     

       214
       214
       -
                   ctx->current_primary = ctx->esc_values[i] - offset;

     

       215
       215
       -
       

     

       216
       216
       -
                   if (ctx->reverse_video) {

     

       217
       217
       -
                       goto set_bg;

     

       218
       218
       -
                   }

     

       219
       219
       -
       

     

       220
       220
       -
       set_fg:

     

       221
       221
       -
                   if ((ctx->bold && !ctx->reverse_video)

     

       222
       222
       -
                    || (ctx->bg_bold && ctx->reverse_video)) {

     

       223
       223
       -
                       ctx->set_text_fg_bright(ctx, ctx->esc_values[i] - offset);

     

       224
       224
       -
                   } else {

     

       225
       225
       -
                       ctx->set_text_fg(ctx, ctx->esc_values[i] - offset);

     

       226
       226
       -
                   }

     

       227
       227
       -
                   continue;

     

       228
       228
       -
               }

     

       229
       229
       -
       

     

       230
       230
       -
               else if (ctx->esc_values[i] >= 40 && ctx->esc_values[i] <= 47) {

     

       231
       231
       -
                   offset = 40;

     

       232
       232
       -
                   ctx->current_bg = ctx->esc_values[i] - offset;

     

       233
       233
       -
       

     

       234
       234
       -
                   if (ctx->reverse_video) {

     

       235
       235
       -
                       goto set_fg;

     

       236
       236
       -
                   }

     

       237
       237
       -
       

     

       238
       238
       -
       set_bg:

     

       239
       239
       -
                   if ((ctx->bold && ctx->reverse_video)

     

       240
       240
       -
                    || (ctx->bg_bold && !ctx->reverse_video)) {

     

       241
       241
       -
                       ctx->set_text_bg_bright(ctx, ctx->esc_values[i] - offset);

     

       242
       242
       -
                   } else {

     

       243
       243
       -
                       ctx->set_text_bg(ctx, ctx->esc_values[i] - offset);

     

       244
       244
       -
                   }

     

       245
       245
       -
                   continue;

     

       246
       246
       -
               }

     

       247
       247
       -
       

     

       248
       248
       -
               else if (ctx->esc_values[i] >= 90 && ctx->esc_values[i] <= 97) {

     

       249
       249
       -
                   offset = 90;

     

       250
       250
       -
                   ctx->current_primary = ctx->esc_values[i] - offset;

     

       251
       251
       -
       

     

       252
       252
       -
                   if (ctx->reverse_video) {

     

       253
       253
       -
                       goto set_bg_bright;

     

       254
       254
       -
                   }

     

       255
       255
       -
       

     

       256
       256
       -
       set_fg_bright:

     

       257
       257
       -
                   ctx->set_text_fg_bright(ctx, ctx->esc_values[i] - offset);

     

       258
       258
       -
                   continue;

     

       259
       259
       -
               }

     

       260
       260
       -
       

     

       261
       261
       -
               else if (ctx->esc_values[i] >= 100 && ctx->esc_values[i] <= 107) {

     

       262
       262
       -
                   offset = 100;

     

       263
       263
       -
                   ctx->current_bg = ctx->esc_values[i] - offset;

     

       264
       264
       -
       

     

       265
       265
       -
                   if (ctx->reverse_video) {

     

       266
       266
       -
                       goto set_fg_bright;

     

       267
       267
       -
                   }

     

       268
       268
       -
       

     

       269
       269
       -
       set_bg_bright:

     

       270
       270
       -
                   ctx->set_text_bg_bright(ctx, ctx->esc_values[i] - offset);

     

       271
       271
       -
                   continue;

     

       272
       272
       -
               }

     

       273
       273
       -
       

     

       274
       274
       -
               else if (ctx->esc_values[i] == 39) {

     

       275
       275
       -
                   ctx->current_primary = (size_t)-1;

     

       276
       276
       -
       

     

       277
       277
       -
                   if (ctx->reverse_video) {

     

       278
       278
       -
                       ctx->swap_palette(ctx);

     

       279
       279
       -
                   }

     

       280
       280
       -
       

     

       281
       281
       -
                   if (!ctx->bold) {

     

       282
       282
       -
                       ctx->set_text_fg_default(ctx);

     

       283
       283
       -
                   } else {

     

       284
       284
       -
                       ctx->set_text_fg_default_bright(ctx);

     

       285
       285
       -
                   }

     

       286
       286
       -
       

     

       287
       287
       -
                   if (ctx->reverse_video) {

     

       288
       288
       -
                       ctx->swap_palette(ctx);

     

       289
       289
       -
                   }

     

       290
       290
       -
       

     

       291
       291
       -
                   continue;

     

       292
       292
       -
               }

     

       293
       293
       -
       

     

       294
       294
       -
               else if (ctx->esc_values[i] == 49) {

     

       295
       295
       -
                   ctx->current_bg = (size_t)-1;

     

       296
       296
       -
       

     

       297
       297
       -
                   if (ctx->reverse_video) {

     

       298
       298
       -
                       ctx->swap_palette(ctx);

     

       299
       299
       -
                   }

     

       300
       300
       -
       

     

       301
       301
       -
                   if (!ctx->bg_bold) {

     

       302
       302
       -
                       ctx->set_text_bg_default(ctx);

     

       303
       303
       -
                   } else {

     

       304
       304
       -
                       ctx->set_text_bg_default_bright(ctx);

     

       305
       305
       -
                   }

     

       306
       306
       -
       

     

       307
       307
       -
                   if (ctx->reverse_video) {

     

       308
       308
       -
                       ctx->swap_palette(ctx);

     

       309
       309
       -
                   }

     

       310
       310
       -
       

     

       311
       311
       -
                   continue;

     

       312
       312
       -
               }

     

       313
       313
       -
       

     

       314
       314
       -
               else if (ctx->esc_values[i] == 7) {

     

       315
       315
       -
                   if (!ctx->reverse_video) {

     

       316
       316
       -
                       ctx->reverse_video = true;

     

       317
       317
       -
                       ctx->swap_palette(ctx);

     

       318
       318
       -
                   }

     

       319
       319
       -
                   continue;

     

       320
       320
       -
               }

     

       321
       321
       -
       

     

       322
       322
       -
               else if (ctx->esc_values[i] == 27) {

     

       323
       323
       -
                   if (ctx->reverse_video) {

     

       324
       324
       -
                       ctx->reverse_video = false;

     

       325
       325
       -
                       ctx->swap_palette(ctx);

     

       326
       326
       -
                   }

     

       327
       327
       -
                   continue;

     

       328
       328
       -
               }

     

       329
       329
       -
       

     

       330
       330
       -
               // 256/RGB

     

       331
       331
       -
               else if (ctx->esc_values[i] == 38 || ctx->esc_values[i] == 48) {

     

       332
       332
       -
                   bool fg = ctx->esc_values[i] == 38;

     

       333
       333
       -
       

     

       334
       334
       -
                   i++;

     

       335
       335
       -
                   if (i >= ctx->esc_values_i) {

     

       336
       336
       -
                       break;

     

       337
       337
       -
                   }

     

       338
       338
       -
       

     

       339
       339
       -
                   switch (ctx->esc_values[i]) {

     

       340
       340
       -
                       case 2: { // RGB

     

       341
       341
       -
                           if (i + 3 >= ctx->esc_values_i) {

     

       342
       342
       -
                               goto out;

     

       343
       343
       -
                           }

     

       344
       344
       -
       

     

       345
       345
       -
                           uint32_t rgb_value = 0;

     

       346
       346
       -
       

     

       347
       347
       -
                           rgb_value |= ctx->esc_values[i + 1] << 16;

     

       348
       348
       -
                           rgb_value |= ctx->esc_values[i + 2] << 8;

     

       349
       349
       -
                           rgb_value |= ctx->esc_values[i + 3];

     

       350
       350
       -
       

     

       351
       351
       -
                           i += 3;

     

       352
       352
       -
       

     

       353
       353
       -
                           (fg ? ctx->set_text_fg_rgb : ctx->set_text_bg_rgb)(ctx, rgb_value);

     

       354
       354
       -
       

     

       355
       355
       -
                           break;

     

       356
       356
       -
                       }

     

       357
       357
       -
                       case 5: { // 256 colors

     

       358
       358
       -
                           if (i + 1 >= ctx->esc_values_i) {

     

       359
       359
       -
                               goto out;

     

       360
       360
       -
                           }

     

       361
       361
       -
       

     

       362
       362
       -
                           uint32_t col = ctx->esc_values[i + 1];

     

       363
       363
       -
       

     

       364
       364
       -
                           i++;

     

       365
       365
       -
       

     

       366
       366
       -
                           if (col < 8) {

     

       367
       367
       -
                               (fg ? ctx->set_text_fg : ctx->set_text_bg)(ctx, col);

     

       368
       368
       -
                           } else if (col < 16) {

     

       369
       369
       -
                               (fg ? ctx->set_text_fg_bright : ctx->set_text_bg_bright)(ctx, col - 8);

     

       370
       370
       -
                           } else {

     

       371
       371
       -
                               uint32_t rgb_value = col256[col - 16];

     

       372
       372
       -
                               (fg ? ctx->set_text_fg_rgb : ctx->set_text_bg_rgb)(ctx, rgb_value);

     

       373
       373
       -
                           }

     

       374
       374
       -
       

     

       375
       375
       -
                           break;

     

       376
       376
       -
                       }

     

       377
       377
       -
                       default: continue;

     

       378
       378
       -
                   }

     

       379
       379
       -
               }

     

       380
       380
       -
           }

     

       381
       381
       -
       

     

       382
       382
       -
       out:;

     

       383
       383
       -
       }

     

       384
       384
       -
       

     

       385
       385
       -
       static void dec_private_parse(struct flanterm_context *ctx, uint8_t c) {

     

       386
       386
       -
           ctx->dec_private = false;

     

       387
       387
       -
       

     

       388
       388
       -
           if (ctx->esc_values_i == 0) {

     

       389
       389
       -
               return;

     

       390
       390
       -
           }

     

       391
       391
       -
       

     

       392
       392
       -
           bool set;

     

       393
       393
       -
       

     

       394
       394
       -
           switch (c) {

     

       395
       395
       -
               case 'h':

     

       396
       396
       -
                   set = true; break;

     

       397
       397
       -
               case 'l':

     

       398
       398
       -
                   set = false; break;

     

       399
       399
       -
               default:

     

       400
       400
       -
                   return;

     

       401
       401
       -
           }

     

       402
       402
       -
       

     

       403
       403
       -
           switch (ctx->esc_values[0]) {

     

       404
       404
       -
               case 25: {

     

       405
       405
       -
                   if (set) {

     

       406
       406
       -
                       ctx->cursor_enabled = true;

     

       407
       407
       -
                   } else {

     

       408
       408
       -
                       ctx->cursor_enabled = false;

     

       409
       409
       -
                   }

     

       410
       410
       -
                   return;

     

       411
       411
       -
               }

     

       412
       412
       -
           }

     

       413
       413
       -
       

     

       414
       414
       -
           if (ctx->callback != NULL) {

     

       415
       415
       -
               ctx->callback(ctx, FLANTERM_CB_DEC, ctx->esc_values_i, (uintptr_t)ctx->esc_values, c);

     

       416
       416
       -
           }

     

       417
       417
       -
       }

     

       418
       418
       -
       

     

       419
       419
       -
       static void linux_private_parse(struct flanterm_context *ctx) {

     

       420
       420
       -
           if (ctx->esc_values_i == 0) {

     

       421
       421
       -
               return;

     

       422
       422
       -
           }

     

       423
       423
       -
       

     

       424
       424
       -
           if (ctx->callback != NULL) {

     

       425
       425
       -
               ctx->callback(ctx, FLANTERM_CB_LINUX, ctx->esc_values_i, (uintptr_t)ctx->esc_values, 0);

     

       426
       426
       -
           }

     

       427
       427
       -
       }

     

       428
       428
       -
       

     

       429
       429
       -
       static void mode_toggle(struct flanterm_context *ctx, uint8_t c) {

     

       430
       430
       -
           if (ctx->esc_values_i == 0) {

     

       431
       431
       -
               return;

     

       432
       432
       -
           }

     

       433
       433
       -
       

     

       434
       434
       -
           bool set;

     

       435
       435
       -
       

     

       436
       436
       -
           switch (c) {

     

       437
       437
       -
               case 'h':

     

       438
       438
       -
                   set = true; break;

     

       439
       439
       -
               case 'l':

     

       440
       440
       -
                   set = false; break;

     

       441
       441
       -
               default:

     

       442
       442
       -
                   return;

     

       443
       443
       -
           }

     

       444
       444
       -
       

     

       445
       445
       -
           switch (ctx->esc_values[0]) {

     

       446
       446
       -
               case 4:

     

       447
       447
       -
                   ctx->insert_mode = set; return;

     

       448
       448
       -
           }

     

       449
       449
       -
       

     

       450
       450
       -
           if (ctx->callback != NULL) {

     

       451
       451
       -
               ctx->callback(ctx, FLANTERM_CB_MODE, ctx->esc_values_i, (uintptr_t)ctx->esc_values, c);

     

       452
       452
       -
           }

     

       453
       453
       -
       }

     

       454
       454
       -
       

     

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

     

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

     

       457
       457
       -
               goto cleanup;

     

       458
       458
       -
           }

     

       459
       459
       -
       

     

       460
       460
       -
           ctx->osc_escape = false;

     

       461
       461
       -
       

     

       462
       462
       -
           switch (c) {

     

       463
       463
       -
               case 0x1b:

     

       464
       464
       -
                   ctx->osc_escape = true;

     

       465
       465
       -
                   break;

     

       466
       466
       -
               case '\a':

     

       467
       467
       -
                   goto cleanup;

     

       468
       468
       -
           }

     

       469
       469
       -
       

     

       470
       470
       -
           return;

     

       471
       471
       -
       

     

       472
       472
       -
       cleanup:

     

       473
       473
       -
           ctx->osc_escape = false;

     

       474
       474
       -
           ctx->osc = false;

     

       475
       475
       -
           ctx->escape = false;

     

       476
       476
       -
       }

     

       477
       477
       -
       

     

       478
       478
       -
       static void control_sequence_parse(struct flanterm_context *ctx, uint8_t c) {

     

       479
       479
       -
           if (ctx->escape_offset == 2) {

     

       480
       480
       -
               switch (c) {

     

       481
       481
       -
                   case '[':

     

       482
       482
       -
                       ctx->discard_next = true;

     

       483
       483
       -
                       goto cleanup;

     

       484
       484
       -
                   case '?':

     

       485
       485
       -
                       ctx->dec_private = true;

     

       486
       486
       -
                       return;

     

       487
       487
       -
               }

     

       488
       488
       -
           }

     

       489
       489
       -
       

     

       490
       490
       -
           if (c >= '0' && c <= '9') {

     

       491
       491
       -
               if (ctx->esc_values_i == FLANTERM_MAX_ESC_VALUES) {

     

       492
       492
       -
                   return;

     

       493
       493
       -
               }

     

       494
       494
       -
               ctx->rrr = true;

     

       495
       495
       -
               ctx->esc_values[ctx->esc_values_i] *= 10;

     

       496
       496
       -
               ctx->esc_values[ctx->esc_values_i] += c - '0';

     

       497
       497
       -
               return;

     

       498
       498
       -
           }

     

       499
       499
       -
       

     

       500
       500
       -
           if (ctx->rrr == true) {

     

       501
       501
       -
               ctx->esc_values_i++;

     

       502
       502
       -
               ctx->rrr = false;

     

       503
       503
       -
               if (c == ';')

     

       504
       504
       -
                   return;

     

       505
       505
       -
           } else if (c == ';') {

     

       506
       506
       -
               if (ctx->esc_values_i == FLANTERM_MAX_ESC_VALUES) {

     

       507
       507
       -
                   return;

     

       508
       508
       -
               }

     

       509
       509
       -
               ctx->esc_values[ctx->esc_values_i] = 0;

     

       510
       510
       -
               ctx->esc_values_i++;

     

       511
       511
       -
               return;

     

       512
       512
       -
           }

     

       513
       513
       -
       

     

       514
       514
       -
           size_t esc_default;

     

       515
       515
       -
           switch (c) {

     

       516
       516
       -
               case 'J': case 'K': case 'q':

     

       517
       517
       -
                   esc_default = 0; break;

     

       518
       518
       -
               default:

     

       519
       519
       -
                   esc_default = 1; break;

     

       520
       520
       -
           }

     

       521
       521
       -
       

     

       522
       522
       -
           for (size_t i = ctx->esc_values_i; i < FLANTERM_MAX_ESC_VALUES; i++) {

     

       523
       523
       -
               ctx->esc_values[i] = esc_default;

     

       524
       524
       -
           }

     

       525
       525
       -
       

     

       526
       526
       -
           if (ctx->dec_private == true) {

     

       527
       527
       -
               dec_private_parse(ctx, c);

     

       528
       528
       -
               goto cleanup;

     

       529
       529
       -
           }

     

       530
       530
       -
       

     

       531
       531
       -
           bool r = ctx->scroll_enabled;

     

       532
       532
       -
           ctx->scroll_enabled = false;

     

       533
       533
       -
           size_t x, y;

     

       534
       534
       -
           ctx->get_cursor_pos(ctx, &x, &y);

     

       535
       535
       -
       

     

       536
       536
       -
           switch (c) {

     

       537
       537
       -
               case 'F':

     

       538
       538
       -
                   x = 0;

     

       539
       539
       -
                   // FALLTHRU

     

       540
       540
       -
               case 'A': {

     

       541
       541
       -
                   if (ctx->esc_values[0] > y)

     

       542
       542
       -
                       ctx->esc_values[0] = y;

     

       543
       543
       -
                   size_t orig_y = y;

     

       544
       544
       -
                   size_t dest_y = y - ctx->esc_values[0];

     

       545
       545
       -
                   bool will_be_in_scroll_region = false;

     

       546
       546
       -
                   if ((ctx->scroll_top_margin >= dest_y && ctx->scroll_top_margin <= orig_y)

     

       547
       547
       -
                    || (ctx->scroll_bottom_margin >= dest_y && ctx->scroll_bottom_margin <= orig_y)) {

     

       548
       548
       -
                       will_be_in_scroll_region = true;

     

       549
       549
       -
                   }

     

       550
       550
       -
                   if (will_be_in_scroll_region && dest_y < ctx->scroll_top_margin) {

     

       551
       551
       -
                       dest_y = ctx->scroll_top_margin;

     

       552
       552
       -
                   }

     

       553
       553
       -
                   ctx->set_cursor_pos(ctx, x, dest_y);

     

       554
       554
       -
                   break;

     

       555
       555
       -
               }

     

       556
       556
       -
               case 'E':

     

       557
       557
       -
                   x = 0;

     

       558
       558
       -
                   // FALLTHRU

     

       559
       559
       -
               case 'e':

     

       560
       560
       -
               case 'B': {

     

       561
       561
       -
                   if (y + ctx->esc_values[0] > ctx->rows - 1)

     

       562
       562
       -
                       ctx->esc_values[0] = (ctx->rows - 1) - y;

     

       563
       563
       -
                   size_t orig_y = y;

     

       564
       564
       -
                   size_t dest_y = y + ctx->esc_values[0];

     

       565
       565
       -
                   bool will_be_in_scroll_region = false;

     

       566
       566
       -
                   if ((ctx->scroll_top_margin >= orig_y && ctx->scroll_top_margin <= dest_y)

     

       567
       567
       -
                    || (ctx->scroll_bottom_margin >= orig_y && ctx->scroll_bottom_margin <= dest_y)) {

     

       568
       568
       -
                       will_be_in_scroll_region = true;

     

       569
       569
       -
                   }

     

       570
       570
       -
                   if (will_be_in_scroll_region && dest_y >= ctx->scroll_bottom_margin) {

     

       571
       571
       -
                       dest_y = ctx->scroll_bottom_margin - 1;

     

       572
       572
       -
                   }

     

       573
       573
       -
                   ctx->set_cursor_pos(ctx, x, dest_y);

     

       574
       574
       -
                   break;

     

       575
       575
       -
               }

     

       576
       576
       -
               case 'a':

     

       577
       577
       -
               case 'C':

     

       578
       578
       -
                   if (x + ctx->esc_values[0] > ctx->cols - 1)

     

       579
       579
       -
                       ctx->esc_values[0] = (ctx->cols - 1) - x;

     

       580
       580
       -
                   ctx->set_cursor_pos(ctx, x + ctx->esc_values[0], y);

     

       581
       581
       -
                   break;

     

       582
       582
       -
               case 'D':

     

       583
       583
       -
                   if (ctx->esc_values[0] > x)

     

       584
       584
       -
                       ctx->esc_values[0] = x;

     

       585
       585
       -
                   ctx->set_cursor_pos(ctx, x - ctx->esc_values[0], y);

     

       586
       586
       -
                   break;

     

       587
       587
       -
               case 'c':

     

       588
       588
       -
                   if (ctx->callback != NULL) {

     

       589
       589
       -
                       ctx->callback(ctx, FLANTERM_CB_PRIVATE_ID, 0, 0, 0);

     

       590
       590
       -
                   }

     

       591
       591
       -
                   break;

     

       592
       592
       -
               case 'd':

     

       593
       593
       -
                   ctx->esc_values[0] -= 1;

     

       594
       594
       -
                   if (ctx->esc_values[0] >= ctx->rows)

     

       595
       595
       -
                       ctx->esc_values[0] = ctx->rows - 1;

     

       596
       596
       -
                   ctx->set_cursor_pos(ctx, x, ctx->esc_values[0]);

     

       597
       597
       -
                   break;

     

       598
       598
       -
               case 'G':

     

       599
       599
       -
               case '`':

     

       600
       600
       -
                   ctx->esc_values[0] -= 1;

     

       601
       601
       -
                   if (ctx->esc_values[0] >= ctx->cols)

     

       602
       602
       -
                       ctx->esc_values[0] = ctx->cols - 1;

     

       603
       603
       -
                   ctx->set_cursor_pos(ctx, ctx->esc_values[0], y);

     

       604
       604
       -
                   break;

     

       605
       605
       -
               case 'H':

     

       606
       606
       -
               case 'f':

     

       607
       607
       -
                   if (ctx->esc_values[0] != 0) {

     

       608
       608
       -
                       ctx->esc_values[0]--;

     

       609
       609
       -
                   }

     

       610
       610
       -
                   if (ctx->esc_values[1] != 0) {

     

       611
       611
       -
                       ctx->esc_values[1]--;

     

       612
       612
       -
                   }

     

       613
       613
       -
                   if (ctx->esc_values[1] >= ctx->cols)

     

       614
       614
       -
                       ctx->esc_values[1] = ctx->cols - 1;

     

       615
       615
       -
                   if (ctx->esc_values[0] >= ctx->rows)

     

       616
       616
       -
                       ctx->esc_values[0] = ctx->rows - 1;

     

       617
       617
       -
                   ctx->set_cursor_pos(ctx, ctx->esc_values[1], ctx->esc_values[0]);

     

       618
       618
       -
                   break;

     

       619
       619
       -
               case 'M':

     

       620
       620
       -
                   for (size_t i = 0; i < ctx->esc_values[0]; i++) {

     

       621
       621
       -
                       ctx->scroll(ctx);

     

       622
       622
       -
                   }

     

       623
       623
       -
                   break;

     

       624
       624
       -
               case 'L': {

     

       625
       625
       -
                   size_t old_scroll_top_margin = ctx->scroll_top_margin;

     

       626
       626
       -
                   ctx->scroll_top_margin = y;

     

       627
       627
       -
                   for (size_t i = 0; i < ctx->esc_values[0]; i++) {

     

       628
       628
       -
                       ctx->revscroll(ctx);

     

       629
       629
       -
                   }

     

       630
       630
       -
                   ctx->scroll_top_margin = old_scroll_top_margin;

     

       631
       631
       -
                   break;

     

       632
       632
       -
               }

     

       633
       633
       -
               case 'n':

     

       634
       634
       -
                   switch (ctx->esc_values[0]) {

     

       635
       635
       -
                       case 5:

     

       636
       636
       -
                           if (ctx->callback != NULL) {

     

       637
       637
       -
                               ctx->callback(ctx, FLANTERM_CB_STATUS_REPORT, 0, 0, 0);

     

       638
       638
       -
                           }

     

       639
       639
       -
                           break;

     

       640
       640
       -
                       case 6:

     

       641
       641
       -
                           if (ctx->callback != NULL) {

     

       642
       642
       -
                               ctx->callback(ctx, FLANTERM_CB_POS_REPORT, x + 1, y + 1, 0);

     

       643
       643
       -
                           }

     

       644
       644
       -
                           break;

     

       645
       645
       -
                   }

     

       646
       646
       -
                   break;

     

       647
       647
       -
               case 'q':

     

       648
       648
       -
                   if (ctx->callback != NULL) {

     

       649
       649
       -
                       ctx->callback(ctx, FLANTERM_CB_KBD_LEDS, ctx->esc_values[0], 0, 0);

     

       650
       650
       -
                   }

     

       651
       651
       -
                   break;

     

       652
       652
       -
               case 'J':

     

       653
       653
       -
                   switch (ctx->esc_values[0]) {

     

       654
       654
       -
                       case 0: {

     

       655
       655
       -
                           size_t rows_remaining = ctx->rows - (y + 1);

     

       656
       656
       -
                           size_t cols_diff = ctx->cols - (x + 1);

     

       657
       657
       -
                           size_t to_clear = rows_remaining * ctx->cols + cols_diff + 1;

     

       658
       658
       -
                           for (size_t i = 0; i < to_clear; i++) {

     

       659
       659
       -
                               ctx->raw_putchar(ctx, ' ');

     

       660
       660
       -
                           }

     

       661
       661
       -
                           ctx->set_cursor_pos(ctx, x, y);

     

       662
       662
       -
                           break;

     

       663
       663
       -
                       }

     

       664
       664
       -
                       case 1: {

     

       665
       665
       -
                           ctx->set_cursor_pos(ctx, 0, 0);

     

       666
       666
       -
                           bool b = false;

     

       667
       667
       -
                           for (size_t yc = 0; yc < ctx->rows; yc++) {

     

       668
       668
       -
                               for (size_t xc = 0; xc < ctx->cols; xc++) {

     

       669
       669
       -
                                   ctx->raw_putchar(ctx, ' ');

     

       670
       670
       -
                                   if (xc == x && yc == y) {

     

       671
       671
       -
                                       ctx->set_cursor_pos(ctx, x, y);

     

       672
       672
       -
                                       b = true;

     

       673
       673
       -
                                       break;

     

       674
       674
       -
                                   }

     

       675
       675
       -
                               }

     

       676
       676
       -
                               if (b == true)

     

       677
       677
       -
                                   break;

     

       678
       678
       -
                           }

     

       679
       679
       -
                           break;

     

       680
       680
       -
                       }

     

       681
       681
       -
                       case 2:

     

       682
       682
       -
                       case 3:

     

       683
       683
       -
                           ctx->clear(ctx, false);

     

       684
       684
       -
                           break;

     

       685
       685
       -
                   }

     

       686
       686
       -
                   break;

     

       687
       687
       -
               case '@':

     

       688
       688
       -
                   for (size_t i = ctx->cols - 1; ; i--) {

     

       689
       689
       -
                       ctx->move_character(ctx, i + ctx->esc_values[0], y, i, y);

     

       690
       690
       -
                       ctx->set_cursor_pos(ctx, i, y);

     

       691
       691
       -
                       ctx->raw_putchar(ctx, ' ');

     

       692
       692
       -
                       if (i == x) {

     

       693
       693
       -
                           break;

     

       694
       694
       -
                       }

     

       695
       695
       -
                   }

     

       696
       696
       -
                   ctx->set_cursor_pos(ctx, x, y);

     

       697
       697
       -
                   break;

     

       698
       698
       -
               case 'P':

     

       699
       699
       -
                   for (size_t i = x + ctx->esc_values[0]; i < ctx->cols; i++)

     

       700
       700
       -
                       ctx->move_character(ctx, i - ctx->esc_values[0], y, i, y);

     

       701
       701
       -
                   ctx->set_cursor_pos(ctx, ctx->cols - ctx->esc_values[0], y);

     

       702
       702
       -
                   // FALLTHRU

     

       703
       703
       -
               case 'X':

     

       704
       704
       -
                   for (size_t i = 0; i < ctx->esc_values[0]; i++)

     

       705
       705
       -
                       ctx->raw_putchar(ctx, ' ');

     

       706
       706
       -
                   ctx->set_cursor_pos(ctx, x, y);

     

       707
       707
       -
                   break;

     

       708
       708
       -
               case 'm':

     

       709
       709
       -
                   sgr(ctx);

     

       710
       710
       -
                   break;

     

       711
       711
       -
               case 's':

     

       712
       712
       -
                   ctx->get_cursor_pos(ctx, &ctx->saved_cursor_x, &ctx->saved_cursor_y);

     

       713
       713
       -
                   break;

     

       714
       714
       -
               case 'u':

     

       715
       715
       -
                   ctx->set_cursor_pos(ctx, ctx->saved_cursor_x, ctx->saved_cursor_y);

     

       716
       716
       -
                   break;

     

       717
       717
       -
               case 'K':

     

       718
       718
       -
                   switch (ctx->esc_values[0]) {

     

       719
       719
       -
                       case 0: {

     

       720
       720
       -
                           for (size_t i = x; i < ctx->cols; i++)

     

       721
       721
       -
                               ctx->raw_putchar(ctx, ' ');

     

       722
       722
       -
                           ctx->set_cursor_pos(ctx, x, y);

     

       723
       723
       -
                           break;

     

       724
       724
       -
                       }

     

       725
       725
       -
                       case 1: {

     

       726
       726
       -
                           ctx->set_cursor_pos(ctx, 0, y);

     

       727
       727
       -
                           for (size_t i = 0; i < x; i++)

     

       728
       728
       -
                               ctx->raw_putchar(ctx, ' ');

     

       729
       729
       -
                           break;

     

       730
       730
       -
                       }

     

       731
       731
       -
                       case 2: {

     

       732
       732
       -
                           ctx->set_cursor_pos(ctx, 0, y);

     

       733
       733
       -
                           for (size_t i = 0; i < ctx->cols; i++)

     

       734
       734
       -
                               ctx->raw_putchar(ctx, ' ');

     

       735
       735
       -
                           ctx->set_cursor_pos(ctx, x, y);

     

       736
       736
       -
                           break;

     

       737
       737
       -
                       }

     

       738
       738
       -
                   }

     

       739
       739
       -
                   break;

     

       740
       740
       -
               case 'r':

     

       741
       741
       -
                   if (ctx->esc_values[0] == 0) {

     

       742
       742
       -
                       ctx->esc_values[0] = 1;

     

       743
       743
       -
                   }

     

       744
       744
       -
                   if (ctx->esc_values[1] == 0) {

     

       745
       745
       -
                       ctx->esc_values[1] = 1;

     

       746
       746
       -
                   }

     

       747
       747
       -
                   ctx->scroll_top_margin = 0;

     

       748
       748
       -
                   ctx->scroll_bottom_margin = ctx->rows;

     

       749
       749
       -
                   if (ctx->esc_values_i > 0) {

     

       750
       750
       -
                       ctx->scroll_top_margin = ctx->esc_values[0] - 1;

     

       751
       751
       -
                   }

     

       752
       752
       -
                   if (ctx->esc_values_i > 1) {

     

       753
       753
       -
                       ctx->scroll_bottom_margin = ctx->esc_values[1];

     

       754
       754
       -
                   }

     

       755
       755
       -
                   if (ctx->scroll_top_margin >= ctx->rows

     

       756
       756
       -
                    || ctx->scroll_bottom_margin > ctx->rows

     

       757
       757
       -
                    || ctx->scroll_top_margin >= (ctx->scroll_bottom_margin - 1)) {

     

       758
       758
       -
                       ctx->scroll_top_margin = 0;

     

       759
       759
       -
                       ctx->scroll_bottom_margin = ctx->rows;

     

       760
       760
       -
                   }

     

       761
       761
       -
                   ctx->set_cursor_pos(ctx, 0, 0);

     

       762
       762
       -
                   break;

     

       763
       763
       -
               case 'l':

     

       764
       764
       -
               case 'h':

     

       765
       765
       -
                   mode_toggle(ctx, c);

     

       766
       766
       -
                   break;

     

       767
       767
       -
               case ']':

     

       768
       768
       -
                   linux_private_parse(ctx);

     

       769
       769
       -
                   break;

     

       770
       770
       -
           }

     

       771
       771
       -
       

     

       772
       772
       -
           ctx->scroll_enabled = r;

     

       773
       773
       -
       

     

       774
       774
       -
       cleanup:

     

       775
       775
       -
           ctx->control_sequence = false;

     

       776
       776
       -
           ctx->escape = false;

     

       777
       777
       -
       }

     

       778
       778
       -
       

     

       779
       779
       -
       static void restore_state(struct flanterm_context *ctx) {

     

       780
       780
       -
           ctx->bold = ctx->saved_state_bold;

     

       781
       781
       -
           ctx->bg_bold = ctx->saved_state_bg_bold;

     

       782
       782
       -
           ctx->reverse_video = ctx->saved_state_reverse_video;

     

       783
       783
       -
           ctx->current_charset = ctx->saved_state_current_charset;

     

       784
       784
       -
           ctx->current_primary = ctx->saved_state_current_primary;

     

       785
       785
       -
           ctx->current_bg = ctx->saved_state_current_bg;

     

       786
       786
       -
       

     

       787
       787
       -
           ctx->restore_state(ctx);

     

       788
       788
       -
       }

     

       789
       789
       -
       

     

       790
       790
       -
       static void save_state(struct flanterm_context *ctx) {

     

       791
       791
       -
           ctx->save_state(ctx);

     

       792
       792
       -
       

     

       793
       793
       -
           ctx->saved_state_bold = ctx->bold;

     

       794
       794
       -
           ctx->saved_state_bg_bold = ctx->bg_bold;

     

       795
       795
       -
           ctx->saved_state_reverse_video = ctx->reverse_video;

     

       796
       796
       -
           ctx->saved_state_current_charset = ctx->current_charset;

     

       797
       797
       -
           ctx->saved_state_current_primary = ctx->current_primary;

     

       798
       798
       -
           ctx->saved_state_current_bg = ctx->current_bg;

     

       799
       799
       -
       }

     

       800
       800
       -
       

     

       801
       801
       -
       static void escape_parse(struct flanterm_context *ctx, uint8_t c) {

     

       802
       802
       -
           ctx->escape_offset++;

     

       803
       803
       -
       

     

       804
       804
       -
           if (ctx->osc == true) {

     

       805
       805
       -
               osc_parse(ctx, c);

     

       806
       806
       -
               return;

     

       807
       807
       -
           }

     

       808
       808
       -
       

     

       809
       809
       -
           if (ctx->control_sequence == true) {

     

       810
       810
       -
               control_sequence_parse(ctx, c);

     

       811
       811
       -
               return;

     

       812
       812
       -
           }

     

       813
       813
       -
       

     

       814
       814
       -
           if (ctx->csi == true) {

     

       815
       815
       -
               ctx->csi = false;

     

       816
       816
       -
               goto is_csi;

     

       817
       817
       -
           }

     

       818
       818
       -
       

     

       819
       819
       -
           size_t x, y;

     

       820
       820
       -
           ctx->get_cursor_pos(ctx, &x, &y);

     

       821
       821
       -
       

     

       822
       822
       -
           switch (c) {

     

       823
       823
       -
               case ']':

     

       824
       824
       -
                   ctx->osc_escape = false;

     

       825
       825
       -
                   ctx->osc = true;

     

       826
       826
       -
                   return;

     

       827
       827
       -
               case '[':

     

       828
       828
       -
       is_csi:

     

       829
       829
       -
                   for (size_t i = 0; i < FLANTERM_MAX_ESC_VALUES; i++)

     

       830
       830
       -
                       ctx->esc_values[i] = 0;

     

       831
       831
       -
                   ctx->esc_values_i = 0;

     

       832
       832
       -
                   ctx->rrr = false;

     

       833
       833
       -
                   ctx->control_sequence = true;

     

       834
       834
       -
                   return;

     

       835
       835
       -
               case '7':

     

       836
       836
       -
                   save_state(ctx);

     

       837
       837
       -
                   break;

     

       838
       838
       -
               case '8':

     

       839
       839
       -
                   restore_state(ctx);

     

       840
       840
       -
                   break;

     

       841
       841
       -
               case 'c':

     

       842
       842
       -
                   flanterm_context_reinit(ctx);

     

       843
       843
       -
                   ctx->clear(ctx, true);

     

       844
       844
       -
                   break;

     

       845
       845
       -
               case 'D':

     

       846
       846
       -
                   if (y == ctx->scroll_bottom_margin - 1) {

     

       847
       847
       -
                       ctx->scroll(ctx);

     

       848
       848
       -
                       ctx->set_cursor_pos(ctx, x, y);

     

       849
       849
       -
                   } else {

     

       850
       850
       -
                       ctx->set_cursor_pos(ctx, x, y + 1);

     

       851
       851
       -
                   }

     

       852
       852
       -
                   break;

     

       853
       853
       -
               case 'E':

     

       854
       854
       -
                   if (y == ctx->scroll_bottom_margin - 1) {

     

       855
       855
       -
                       ctx->scroll(ctx);

     

       856
       856
       -
                       ctx->set_cursor_pos(ctx, 0, y);

     

       857
       857
       -
                   } else {

     

       858
       858
       -
                       ctx->set_cursor_pos(ctx, 0, y + 1);

     

       859
       859
       -
                   }

     

       860
       860
       -
                   break;

     

       861
       861
       -
               case 'M':

     

       862
       862
       -
                   // "Reverse linefeed"

     

       863
       863
       -
                   if (y == ctx->scroll_top_margin) {

     

       864
       864
       -
                       ctx->revscroll(ctx);

     

       865
       865
       -
                       ctx->set_cursor_pos(ctx, 0, y);

     

       866
       866
       -
                   } else {

     

       867
       867
       -
                       ctx->set_cursor_pos(ctx, 0, y - 1);

     

       868
       868
       -
                   }

     

       869
       869
       -
                   break;

     

       870
       870
       -
               case 'Z':

     

       871
       871
       -
                   if (ctx->callback != NULL) {

     

       872
       872
       -
                       ctx->callback(ctx, FLANTERM_CB_PRIVATE_ID, 0, 0, 0);

     

       873
       873
       -
                   }

     

       874
       874
       -
                   break;

     

       875
       875
       -
               case '(':

     

       876
       876
       -
               case ')':

     

       877
       877
       -
                   ctx->g_select = c - '\'';

     

       878
       878
       -
                   break;

     

       879
       879
       -
           }

     

       880
       880
       -
       

     

       881
       881
       -
           ctx->escape = false;

     

       882
       882
       -
       }

     

       883
       883
       -
       

     

       884
       884
       -
       static bool dec_special_print(struct flanterm_context *ctx, uint8_t c) {

     

       885
       885
       -
       #define FLANTERM_DEC_SPCL_PRN(C) ctx->raw_putchar(ctx, (C)); return true;

     

       886
       886
       -
           switch (c) {

     

       887
       887
       -
               case '`': FLANTERM_DEC_SPCL_PRN(0x04)

     

       888
       888
       -
               case '0': FLANTERM_DEC_SPCL_PRN(0xdb)

     

       889
       889
       -
               case '-': FLANTERM_DEC_SPCL_PRN(0x18)

     

       890
       890
       -
               case ',': FLANTERM_DEC_SPCL_PRN(0x1b)

     

       891
       891
       -
               case '.': FLANTERM_DEC_SPCL_PRN(0x19)

     

       892
       892
       -
               case 'a': FLANTERM_DEC_SPCL_PRN(0xb1)

     

       893
       893
       -
               case 'f': FLANTERM_DEC_SPCL_PRN(0xf8)

     

       894
       894
       -
               case 'g': FLANTERM_DEC_SPCL_PRN(0xf1)

     

       895
       895
       -
               case 'h': FLANTERM_DEC_SPCL_PRN(0xb0)

     

       896
       896
       -
               case 'j': FLANTERM_DEC_SPCL_PRN(0xd9)

     

       897
       897
       -
               case 'k': FLANTERM_DEC_SPCL_PRN(0xbf)

     

       898
       898
       -
               case 'l': FLANTERM_DEC_SPCL_PRN(0xda)

     

       899
       899
       -
               case 'm': FLANTERM_DEC_SPCL_PRN(0xc0)

     

       900
       900
       -
               case 'n': FLANTERM_DEC_SPCL_PRN(0xc5)

     

       901
       901
       -
               case 'q': FLANTERM_DEC_SPCL_PRN(0xc4)

     

       902
       902
       -
               case 's': FLANTERM_DEC_SPCL_PRN(0x5f)

     

       903
       903
       -
               case 't': FLANTERM_DEC_SPCL_PRN(0xc3)

     

       904
       904
       -
               case 'u': FLANTERM_DEC_SPCL_PRN(0xb4)

     

       905
       905
       -
               case 'v': FLANTERM_DEC_SPCL_PRN(0xc1)

     

       906
       906
       -
               case 'w': FLANTERM_DEC_SPCL_PRN(0xc2)

     

       907
       907
       -
               case 'x': FLANTERM_DEC_SPCL_PRN(0xb3)

     

       908
       908
       -
               case 'y': FLANTERM_DEC_SPCL_PRN(0xf3)

     

       909
       909
       -
               case 'z': FLANTERM_DEC_SPCL_PRN(0xf2)

     

       910
       910
       -
               case '~': FLANTERM_DEC_SPCL_PRN(0xfa)

     

       911
       911
       -
               case '_': FLANTERM_DEC_SPCL_PRN(0xff)

     

       912
       912
       -
               case '+': FLANTERM_DEC_SPCL_PRN(0x1a)

     

       913
       913
       -
               case '{': FLANTERM_DEC_SPCL_PRN(0xe3)

     

       914
       914
       -
               case '}': FLANTERM_DEC_SPCL_PRN(0x9c)

     

       915
       915
       -
           }

     

       916
       916
       -
       #undef FLANTERM_DEC_SPCL_PRN

     

       917
       917
       -
       

     

       918
       918
       -
           return false;

     

       919
       919
       -
       }

     

       920
       920
       -
       

     

       921
       921
       -
       // Following wcwidth related code inherited from:

     

       922
       922
       -
       // https://www.cl.cam.ac.uk/~mgk25/ucs/wcwidth.c

     

       923
       923
       -
       

     

       924
       924
       -
       struct interval {

     

       925
       925
       -
           uint32_t first;

     

       926
       926
       -
           uint32_t last;

     

       927
       927
       -
       };

     

       928
       928
       -
       

     

       929
       929
       -
       /* auxiliary function for binary search in interval table */

     

       930
       930
       -
       static int bisearch(uint32_t ucs, const struct interval *table, int max) {

     

       931
       931
       -
         int min = 0;

     

       932
       932
       -
         int mid;

     

       933
       933
       -
       

     

       934
       934
       -
         if (ucs < table[0].first || ucs > table[max].last)

     

       935
       935
       -
           return 0;

     

       936
       936
       -
         while (max >= min) {

     

       937
       937
       -
           mid = (min + max) / 2;

     

       938
       938
       -
           if (ucs > table[mid].last)

     

       939
       939
       -
             min = mid + 1;

     

       940
       940
       -
           else if (ucs < table[mid].first)

     

       941
       941
       -
             max = mid - 1;

     

       942
       942
       -
           else

     

       943
       943
       -
             return 1;

     

       944
       944
       -
         }

     

       945
       945
       -
       

     

       946
       946
       -
         return 0;

     

       947
       947
       -
       }

     

       948
       948
       -
       

     

       949
       949
       -
       int mk_wcwidth(uint32_t ucs) {

     

       950
       950
       -
         /* sorted list of non-overlapping intervals of non-spacing characters */

     

       951
       951
       -
         /* generated by "uniset +cat=Me +cat=Mn +cat=Cf -00AD +1160-11FF +200B c" */

     

       952
       952
       -
         static const struct interval combining[] = {

     

       953
       953
       -
           { 0x0300, 0x036F }, { 0x0483, 0x0486 }, { 0x0488, 0x0489 },

     

       954
       954
       -
           { 0x0591, 0x05BD }, { 0x05BF, 0x05BF }, { 0x05C1, 0x05C2 },

     

       955
       955
       -
           { 0x05C4, 0x05C5 }, { 0x05C7, 0x05C7 }, { 0x0600, 0x0603 },

     

       956
       956
       -
           { 0x0610, 0x0615 }, { 0x064B, 0x065E }, { 0x0670, 0x0670 },

     

       957
       957
       -
           { 0x06D6, 0x06E4 }, { 0x06E7, 0x06E8 }, { 0x06EA, 0x06ED },

     

       958
       958
       -
           { 0x070F, 0x070F }, { 0x0711, 0x0711 }, { 0x0730, 0x074A },

     

       959
       959
       -
           { 0x07A6, 0x07B0 }, { 0x07EB, 0x07F3 }, { 0x0901, 0x0902 },

     

       960
       960
       -
           { 0x093C, 0x093C }, { 0x0941, 0x0948 }, { 0x094D, 0x094D },

     

       961
       961
       -
           { 0x0951, 0x0954 }, { 0x0962, 0x0963 }, { 0x0981, 0x0981 },

     

       962
       962
       -
           { 0x09BC, 0x09BC }, { 0x09C1, 0x09C4 }, { 0x09CD, 0x09CD },

     

       963
       963
       -
           { 0x09E2, 0x09E3 }, { 0x0A01, 0x0A02 }, { 0x0A3C, 0x0A3C },

     

       964
       964
       -
           { 0x0A41, 0x0A42 }, { 0x0A47, 0x0A48 }, { 0x0A4B, 0x0A4D },

     

       965
       965
       -
           { 0x0A70, 0x0A71 }, { 0x0A81, 0x0A82 }, { 0x0ABC, 0x0ABC },

     

       966
       966
       -
           { 0x0AC1, 0x0AC5 }, { 0x0AC7, 0x0AC8 }, { 0x0ACD, 0x0ACD },

     

       967
       967
       -
           { 0x0AE2, 0x0AE3 }, { 0x0B01, 0x0B01 }, { 0x0B3C, 0x0B3C },

     

       968
       968
       -
           { 0x0B3F, 0x0B3F }, { 0x0B41, 0x0B43 }, { 0x0B4D, 0x0B4D },

     

       969
       969
       -
           { 0x0B56, 0x0B56 }, { 0x0B82, 0x0B82 }, { 0x0BC0, 0x0BC0 },

     

       970
       970
       -
           { 0x0BCD, 0x0BCD }, { 0x0C3E, 0x0C40 }, { 0x0C46, 0x0C48 },

     

       971
       971
       -
           { 0x0C4A, 0x0C4D }, { 0x0C55, 0x0C56 }, { 0x0CBC, 0x0CBC },

     

       972
       972
       -
           { 0x0CBF, 0x0CBF }, { 0x0CC6, 0x0CC6 }, { 0x0CCC, 0x0CCD },

     

       973
       973
       -
           { 0x0CE2, 0x0CE3 }, { 0x0D41, 0x0D43 }, { 0x0D4D, 0x0D4D },

     

       974
       974
       -
           { 0x0DCA, 0x0DCA }, { 0x0DD2, 0x0DD4 }, { 0x0DD6, 0x0DD6 },

     

       975
       975
       -
           { 0x0E31, 0x0E31 }, { 0x0E34, 0x0E3A }, { 0x0E47, 0x0E4E },

     

       976
       976
       -
           { 0x0EB1, 0x0EB1 }, { 0x0EB4, 0x0EB9 }, { 0x0EBB, 0x0EBC },

     

       977
       977
       -
           { 0x0EC8, 0x0ECD }, { 0x0F18, 0x0F19 }, { 0x0F35, 0x0F35 },

     

       978
       978
       -
           { 0x0F37, 0x0F37 }, { 0x0F39, 0x0F39 }, { 0x0F71, 0x0F7E },

     

       979
       979
       -
           { 0x0F80, 0x0F84 }, { 0x0F86, 0x0F87 }, { 0x0F90, 0x0F97 },

     

       980
       980
       -
           { 0x0F99, 0x0FBC }, { 0x0FC6, 0x0FC6 }, { 0x102D, 0x1030 },

     

       981
       981
       -
           { 0x1032, 0x1032 }, { 0x1036, 0x1037 }, { 0x1039, 0x1039 },

     

       982
       982
       -
           { 0x1058, 0x1059 }, { 0x1160, 0x11FF }, { 0x135F, 0x135F },

     

       983
       983
       -
           { 0x1712, 0x1714 }, { 0x1732, 0x1734 }, { 0x1752, 0x1753 },

     

       984
       984
       -
           { 0x1772, 0x1773 }, { 0x17B4, 0x17B5 }, { 0x17B7, 0x17BD },

     

       985
       985
       -
           { 0x17C6, 0x17C6 }, { 0x17C9, 0x17D3 }, { 0x17DD, 0x17DD },

     

       986
       986
       -
           { 0x180B, 0x180D }, { 0x18A9, 0x18A9 }, { 0x1920, 0x1922 },

     

       987
       987
       -
           { 0x1927, 0x1928 }, { 0x1932, 0x1932 }, { 0x1939, 0x193B },

     

       988
       988
       -
           { 0x1A17, 0x1A18 }, { 0x1B00, 0x1B03 }, { 0x1B34, 0x1B34 },

     

       989
       989
       -
           { 0x1B36, 0x1B3A }, { 0x1B3C, 0x1B3C }, { 0x1B42, 0x1B42 },

     

       990
       990
       -
           { 0x1B6B, 0x1B73 }, { 0x1DC0, 0x1DCA }, { 0x1DFE, 0x1DFF },

     

       991
       991
       -
           { 0x200B, 0x200F }, { 0x202A, 0x202E }, { 0x2060, 0x2063 },

     

       992
       992
       -
           { 0x206A, 0x206F }, { 0x20D0, 0x20EF }, { 0x302A, 0x302F },

     

       993
       993
       -
           { 0x3099, 0x309A }, { 0xA806, 0xA806 }, { 0xA80B, 0xA80B },

     

       994
       994
       -
           { 0xA825, 0xA826 }, { 0xFB1E, 0xFB1E }, { 0xFE00, 0xFE0F },

     

       995
       995
       -
           { 0xFE20, 0xFE23 }, { 0xFEFF, 0xFEFF }, { 0xFFF9, 0xFFFB },

     

       996
       996
       -
           { 0x10A01, 0x10A03 }, { 0x10A05, 0x10A06 }, { 0x10A0C, 0x10A0F },

     

       997
       997
       -
           { 0x10A38, 0x10A3A }, { 0x10A3F, 0x10A3F }, { 0x1D167, 0x1D169 },

     

       998
       998
       -
           { 0x1D173, 0x1D182 }, { 0x1D185, 0x1D18B }, { 0x1D1AA, 0x1D1AD },

     

       999
       999
       -
           { 0x1D242, 0x1D244 }, { 0xE0001, 0xE0001 }, { 0xE0020, 0xE007F },

     

       1000
       1000
       -
           { 0xE0100, 0xE01EF }

     

       1001
       1001
       -
         };

     

       1002
       1002
       -
       

     

       1003
       1003
       -
         /* test for 8-bit control characters */

     

       1004
       1004
       -
         if (ucs == 0)

     

       1005
       1005
       -
           return 0;

     

       1006
       1006
       -
         if (ucs < 32 || (ucs >= 0x7f && ucs < 0xa0))

     

       1007
       1007
       -
           return 1;

     

       1008
       1008
       -
       

     

       1009
       1009
       -
         /* binary search in table of non-spacing characters */

     

       1010
       1010
       -
         if (bisearch(ucs, combining,

     

       1011
       1011
       -
       	       sizeof(combining) / sizeof(struct interval) - 1))

     

       1012
       1012
       -
           return 0;

     

       1013
       1013
       -
       

     

       1014
       1014
       -
         /* if we arrive here, ucs is not a combining or C0/C1 control character */

     

       1015
       1015
       -
       

     

       1016
       1016
       -
         return 1 +

     

       1017
       1017
       -
           (ucs >= 0x1100 &&

     

       1018
       1018
       -
            (ucs <= 0x115f ||                    /* Hangul Jamo init. consonants */

     

       1019
       1019
       -
             ucs == 0x2329 || ucs == 0x232a ||

     

       1020
       1020
       -
             (ucs >= 0x2e80 && ucs <= 0xa4cf &&

     

       1021
       1021
       -
              ucs != 0x303f) ||                  /* CJK ... Yi */

     

       1022
       1022
       -
             (ucs >= 0xac00 && ucs <= 0xd7a3) || /* Hangul Syllables */

     

       1023
       1023
       -
             (ucs >= 0xf900 && ucs <= 0xfaff) || /* CJK Compatibility Ideographs */

     

       1024
       1024
       -
             (ucs >= 0xfe10 && ucs <= 0xfe19) || /* Vertical forms */

     

       1025
       1025
       -
             (ucs >= 0xfe30 && ucs <= 0xfe6f) || /* CJK Compatibility Forms */

     

       1026
       1026
       -
             (ucs >= 0xff00 && ucs <= 0xff60) || /* Fullwidth Forms */

     

       1027
       1027
       -
             (ucs >= 0xffe0 && ucs <= 0xffe6) ||

     

       1028
       1028
       -
             (ucs >= 0x20000 && ucs <= 0x2fffd) ||

     

       1029
       1029
       -
             (ucs >= 0x30000 && ucs <= 0x3fffd)));

     

       1030
       1030
       -
       }

     

       1031
       1031
       -
       

     

       1032
       1032
       -
       // End of https://www.cl.cam.ac.uk/~mgk25/ucs/wcwidth.c inherited code

     

       1033
       1033
       -
       

     

       1034
       1034
       -
       static int unicode_to_cp437(uint64_t code_point) {

     

       1035
       1035
       -
           switch (code_point) {

     

       1036
       1036
       -
               case 0x263a: return 1;

     

       1037
       1037
       -
               case 0x263b: return 2;

     

       1038
       1038
       -
               case 0x2665: return 3;

     

       1039
       1039
       -
               case 0x2666: return 4;

     

       1040
       1040
       -
               case 0x2663: return 5;

     

       1041
       1041
       -
               case 0x2660: return 6;

     

       1042
       1042
       -
               case 0x2022: return 7;

     

       1043
       1043
       -
               case 0x25d8: return 8;

     

       1044
       1044
       -
               case 0x25cb: return 9;

     

       1045
       1045
       -
               case 0x25d9: return 10;

     

       1046
       1046
       -
               case 0x2642: return 11;

     

       1047
       1047
       -
               case 0x2640: return 12;

     

       1048
       1048
       -
               case 0x266a: return 13;

     

       1049
       1049
       -
               case 0x266b: return 14;

     

       1050
       1050
       -
               case 0x263c: return 15;

     

       1051
       1051
       -
               case 0x25ba: return 16;

     

       1052
       1052
       -
               case 0x25c4: return 17;

     

       1053
       1053
       -
               case 0x2195: return 18;

     

       1054
       1054
       -
               case 0x203c: return 19;

     

       1055
       1055
       -
               case 0x00b6: return 20;

     

       1056
       1056
       -
               case 0x00a7: return 21;

     

       1057
       1057
       -
               case 0x25ac: return 22;

     

       1058
       1058
       -
               case 0x21a8: return 23;

     

       1059
       1059
       -
               case 0x2191: return 24;

     

       1060
       1060
       -
               case 0x2193: return 25;

     

       1061
       1061
       -
               case 0x2192: return 26;

     

       1062
       1062
       -
               case 0x2190: return 27;

     

       1063
       1063
       -
               case 0x221f: return 28;

     

       1064
       1064
       -
               case 0x2194: return 29;

     

       1065
       1065
       -
               case 0x25b2: return 30;

     

       1066
       1066
       -
               case 0x25bc: return 31;

     

       1067
       1067
       -
       

     

       1068
       1068
       -
               case 0x2302: return 127;

     

       1069
       1069
       -
               case 0x00c7: return 128;

     

       1070
       1070
       -
               case 0x00fc: return 129;

     

       1071
       1071
       -
               case 0x00e9: return 130;

     

       1072
       1072
       -
               case 0x00e2: return 131;

     

       1073
       1073
       -
               case 0x00e4: return 132;

     

       1074
       1074
       -
               case 0x00e0: return 133;

     

       1075
       1075
       -
               case 0x00e5: return 134;

     

       1076
       1076
       -
               case 0x00e7: return 135;

     

       1077
       1077
       -
               case 0x00ea: return 136;

     

       1078
       1078
       -
               case 0x00eb: return 137;

     

       1079
       1079
       -
               case 0x00e8: return 138;

     

       1080
       1080
       -
               case 0x00ef: return 139;

     

       1081
       1081
       -
               case 0x00ee: return 140;

     

       1082
       1082
       -
               case 0x00ec: return 141;

     

       1083
       1083
       -
               case 0x00c4: return 142;

     

       1084
       1084
       -
               case 0x00c5: return 143;

     

       1085
       1085
       -
               case 0x00c9: return 144;

     

       1086
       1086
       -
               case 0x00e6: return 145;

     

       1087
       1087
       -
               case 0x00c6: return 146;

     

       1088
       1088
       -
               case 0x00f4: return 147;

     

       1089
       1089
       -
               case 0x00f6: return 148;

     

       1090
       1090
       -
               case 0x00f2: return 149;

     

       1091
       1091
       -
               case 0x00fb: return 150;

     

       1092
       1092
       -
               case 0x00f9: return 151;

     

       1093
       1093
       -
               case 0x00ff: return 152;

     

       1094
       1094
       -
               case 0x00d6: return 153;

     

       1095
       1095
       -
               case 0x00dc: return 154;

     

       1096
       1096
       -
               case 0x00a2: return 155;

     

       1097
       1097
       -
               case 0x00a3: return 156;

     

       1098
       1098
       -
               case 0x00a5: return 157;

     

       1099
       1099
       -
               case 0x20a7: return 158;

     

       1100
       1100
       -
               case 0x0192: return 159;

     

       1101
       1101
       -
               case 0x00e1: return 160;

     

       1102
       1102
       -
               case 0x00ed: return 161;

     

       1103
       1103
       -
               case 0x00f3: return 162;

     

       1104
       1104
       -
               case 0x00fa: return 163;

     

       1105
       1105
       -
               case 0x00f1: return 164;

     

       1106
       1106
       -
               case 0x00d1: return 165;

     

       1107
       1107
       -
               case 0x00aa: return 166;

     

       1108
       1108
       -
               case 0x00ba: return 167;

     

       1109
       1109
       -
               case 0x00bf: return 168;

     

       1110
       1110
       -
               case 0x2310: return 169;

     

       1111
       1111
       -
               case 0x00ac: return 170;

     

       1112
       1112
       -
               case 0x00bd: return 171;

     

       1113
       1113
       -
               case 0x00bc: return 172;

     

       1114
       1114
       -
               case 0x00a1: return 173;

     

       1115
       1115
       -
               case 0x00ab: return 174;

     

       1116
       1116
       -
               case 0x00bb: return 175;

     

       1117
       1117
       -
               case 0x2591: return 176;

     

       1118
       1118
       -
               case 0x2592: return 177;

     

       1119
       1119
       -
               case 0x2593: return 178;

     

       1120
       1120
       -
               case 0x2502: return 179;

     

       1121
       1121
       -
               case 0x2524: return 180;

     

       1122
       1122
       -
               case 0x2561: return 181;

     

       1123
       1123
       -
               case 0x2562: return 182;

     

       1124
       1124
       -
               case 0x2556: return 183;

     

       1125
       1125
       -
               case 0x2555: return 184;

     

       1126
       1126
       -
               case 0x2563: return 185;

     

       1127
       1127
       -
               case 0x2551: return 186;

     

       1128
       1128
       -
               case 0x2557: return 187;

     

       1129
       1129
       -
               case 0x255d: return 188;

     

       1130
       1130
       -
               case 0x255c: return 189;

     

       1131
       1131
       -
               case 0x255b: return 190;

     

       1132
       1132
       -
               case 0x2510: return 191;

     

       1133
       1133
       -
               case 0x2514: return 192;

     

       1134
       1134
       -
               case 0x2534: return 193;

     

       1135
       1135
       -
               case 0x252c: return 194;

     

       1136
       1136
       -
               case 0x251c: return 195;

     

       1137
       1137
       -
               case 0x2500: return 196;

     

       1138
       1138
       -
               case 0x253c: return 197;

     

       1139
       1139
       -
               case 0x255e: return 198;

     

       1140
       1140
       -
               case 0x255f: return 199;

     

       1141
       1141
       -
               case 0x255a: return 200;

     

       1142
       1142
       -
               case 0x2554: return 201;

     

       1143
       1143
       -
               case 0x2569: return 202;

     

       1144
       1144
       -
               case 0x2566: return 203;

     

       1145
       1145
       -
               case 0x2560: return 204;

     

       1146
       1146
       -
               case 0x2550: return 205;

     

       1147
       1147
       -
               case 0x256c: return 206;

     

       1148
       1148
       -
               case 0x2567: return 207;

     

       1149
       1149
       -
               case 0x2568: return 208;

     

       1150
       1150
       -
               case 0x2564: return 209;

     

       1151
       1151
       -
               case 0x2565: return 210;

     

       1152
       1152
       -
               case 0x2559: return 211;

     

       1153
       1153
       -
               case 0x2558: return 212;

     

       1154
       1154
       -
               case 0x2552: return 213;

     

       1155
       1155
       -
               case 0x2553: return 214;

     

       1156
       1156
       -
               case 0x256b: return 215;

     

       1157
       1157
       -
               case 0x256a: return 216;

     

       1158
       1158
       -
               case 0x2518: return 217;

     

       1159
       1159
       -
               case 0x250c: return 218;

     

       1160
       1160
       -
               case 0x2588: return 219;

     

       1161
       1161
       -
               case 0x2584: return 220;

     

       1162
       1162
       -
               case 0x258c: return 221;

     

       1163
       1163
       -
               case 0x2590: return 222;

     

       1164
       1164
       -
               case 0x2580: return 223;

     

       1165
       1165
       -
               case 0x03b1: return 224;

     

       1166
       1166
       -
               case 0x00df: return 225;

     

       1167
       1167
       -
               case 0x0393: return 226;

     

       1168
       1168
       -
               case 0x03c0: return 227;

     

       1169
       1169
       -
               case 0x03a3: return 228;

     

       1170
       1170
       -
               case 0x03c3: return 229;

     

       1171
       1171
       -
               case 0x00b5: return 230;

     

       1172
       1172
       -
               case 0x03c4: return 231;

     

       1173
       1173
       -
               case 0x03a6: return 232;

     

       1174
       1174
       -
               case 0x0398: return 233;

     

       1175
       1175
       -
               case 0x03a9: return 234;

     

       1176
       1176
       -
               case 0x03b4: return 235;

     

       1177
       1177
       -
               case 0x221e: return 236;

     

       1178
       1178
       -
               case 0x03c6: return 237;

     

       1179
       1179
       -
               case 0x03b5: return 238;

     

       1180
       1180
       -
               case 0x2229: return 239;

     

       1181
       1181
       -
               case 0x2261: return 240;

     

       1182
       1182
       -
               case 0x00b1: return 241;

     

       1183
       1183
       -
               case 0x2265: return 242;

     

       1184
       1184
       -
               case 0x2264: return 243;

     

       1185
       1185
       -
               case 0x2320: return 244;

     

       1186
       1186
       -
               case 0x2321: return 245;

     

       1187
       1187
       -
               case 0x00f7: return 246;

     

       1188
       1188
       -
               case 0x2248: return 247;

     

       1189
       1189
       -
               case 0x00b0: return 248;

     

       1190
       1190
       -
               case 0x2219: return 249;

     

       1191
       1191
       -
               case 0x00b7: return 250;

     

       1192
       1192
       -
               case 0x221a: return 251;

     

       1193
       1193
       -
               case 0x207f: return 252;

     

       1194
       1194
       -
               case 0x00b2: return 253;

     

       1195
       1195
       -
               case 0x25a0: return 254;

     

       1196
       1196
       -
           }

     

       1197
       1197
       -
       

     

       1198
       1198
       -
           return -1;

     

       1199
       1199
       -
       }

     

       1200
       1200
       -
       

     

       1201
       1201
       -
       static void flanterm_putchar(struct flanterm_context *ctx, uint8_t c) {

     

       1202
       1202
       -
           if (ctx->discard_next || (c == 0x18 || c == 0x1a)) {

     

       1203
       1203
       -
               ctx->discard_next = false;

     

       1204
       1204
       -
               ctx->escape = false;

     

       1205
       1205
       -
               ctx->csi = false;

     

       1206
       1206
       -
               ctx->control_sequence = false;

     

       1207
       1207
       -
               ctx->unicode_remaining = 0;

     

       1208
       1208
       -
               ctx->osc = false;

     

       1209
       1209
       -
               ctx->osc_escape = false;

     

       1210
       1210
       -
               ctx->g_select = 0;

     

       1211
       1211
       -
               return;

     

       1212
       1212
       -
           }

     

       1213
       1213
       -
       

     

       1214
       1214
       -
           if (ctx->unicode_remaining != 0) {

     

       1215
       1215
       -
               if ((c & 0xc0) != 0x80) {

     

       1216
       1216
       -
                   ctx->unicode_remaining = 0;

     

       1217
       1217
       -
                   goto unicode_error;

     

       1218
       1218
       -
               }

     

       1219
       1219
       -
       

     

       1220
       1220
       -
               ctx->unicode_remaining--;

     

       1221
       1221
       -
               ctx->code_point |= (uint64_t)(c & 0x3f) << (6 * ctx->unicode_remaining);

     

       1222
       1222
       -
               if (ctx->unicode_remaining != 0) {

     

       1223
       1223
       -
                   return;

     

       1224
       1224
       -
               }

     

       1225
       1225
       -
       

     

       1226
       1226
       -
               int cc = unicode_to_cp437(ctx->code_point);

     

       1227
       1227
       -
       

     

       1228
       1228
       -
               if (cc == -1) {

     

       1229
       1229
       -
                   size_t replacement_width = (size_t)mk_wcwidth(ctx->code_point);

     

       1230
       1230
       -
                   if (replacement_width > 0) {

     

       1231
       1231
       -
                       ctx->raw_putchar(ctx, 0xfe);

     

       1232
       1232
       -
                   }

     

       1233
       1233
       -
                   for (size_t i = 1; i < replacement_width; i++) {

     

       1234
       1234
       -
                       ctx->raw_putchar(ctx, ' ');

     

       1235
       1235
       -
                   }

     

       1236
       1236
       -
               } else {

     

       1237
       1237
       -
                   ctx->raw_putchar(ctx, cc);

     

       1238
       1238
       -
               }

     

       1239
       1239
       -
               return;

     

       1240
       1240
       -
           }

     

       1241
       1241
       -
       

     

       1242
       1242
       -
       unicode_error:

     

       1243
       1243
       -
           if (c >= 0xc0 && c <= 0xf7) {

     

       1244
       1244
       -
               if (c >= 0xc0 && c <= 0xdf) {

     

       1245
       1245
       -
                   ctx->unicode_remaining = 1;

     

       1246
       1246
       -
                   ctx->code_point = (uint64_t)(c & 0x1f) << 6;

     

       1247
       1247
       -
               } else if (c >= 0xe0 && c <= 0xef) {

     

       1248
       1248
       -
                   ctx->unicode_remaining = 2;

     

       1249
       1249
       -
                   ctx->code_point = (uint64_t)(c & 0x0f) << (6 * 2);

     

       1250
       1250
       -
               } else if (c >= 0xf0 && c <= 0xf7) {

     

       1251
       1251
       -
                   ctx->unicode_remaining = 3;

     

       1252
       1252
       -
                   ctx->code_point = (uint64_t)(c & 0x07) << (6 * 3);

     

       1253
       1253
       -
               }

     

       1254
       1254
       -
               return;

     

       1255
       1255
       -
           }

     

       1256
       1256
       -
       

     

       1257
       1257
       -
           if (ctx->escape == true) {

     

       1258
       1258
       -
               escape_parse(ctx, c);

     

       1259
       1259
       -
               return;

     

       1260
       1260
       -
           }

     

       1261
       1261
       -
       

     

       1262
       1262
       -
           if (ctx->g_select) {

     

       1263
       1263
       -
               ctx->g_select--;

     

       1264
       1264
       -
               switch (c) {

     

       1265
       1265
       -
                   case 'B':

     

       1266
       1266
       -
                       ctx->charsets[ctx->g_select] = CHARSET_DEFAULT; break;

     

       1267
       1267
       -
                   case '0':

     

       1268
       1268
       -
                       ctx->charsets[ctx->g_select] = CHARSET_DEC_SPECIAL; break;

     

       1269
       1269
       -
               }

     

       1270
       1270
       -
               ctx->g_select = 0;

     

       1271
       1271
       -
               return;

     

       1272
       1272
       -
           }

     

       1273
       1273
       -
       

     

       1274
       1274
       -
           size_t x, y;

     

       1275
       1275
       -
           ctx->get_cursor_pos(ctx, &x, &y);

     

       1276
       1276
       -
       

     

       1277
       1277
       -
           switch (c) {

     

       1278
       1278
       -
               case 0x00:

     

       1279
       1279
       -
               case 0x7f:

     

       1280
       1280
       -
                   return;

     

       1281
       1281
       -
               case 0x9b:

     

       1282
       1282
       -
                   ctx->csi = true;

     

       1283
       1283
       -
                   // FALLTHRU

     

       1284
       1284
       -
               case 0x1b:

     

       1285
       1285
       -
                   ctx->escape_offset = 0;

     

       1286
       1286
       -
                   ctx->escape = true;

     

       1287
       1287
       -
                   return;

     

       1288
       1288
       -
               case '\t':

     

       1289
       1289
       -
                   if ((x / ctx->tab_size + 1) >= ctx->cols) {

     

       1290
       1290
       -
                       ctx->set_cursor_pos(ctx, ctx->cols - 1, y);

     

       1291
       1291
       -
                       return;

     

       1292
       1292
       -
                   }

     

       1293
       1293
       -
                   ctx->set_cursor_pos(ctx, (x / ctx->tab_size + 1) * ctx->tab_size, y);

     

       1294
       1294
       -
                   return;

     

       1295
       1295
       -
               case 0x0b:

     

       1296
       1296
       -
               case 0x0c:

     

       1297
       1297
       -
               case '\n':

     

       1298
       1298
       -
                   if (y == ctx->scroll_bottom_margin - 1) {

     

       1299
       1299
       -
                       ctx->scroll(ctx);

     

       1300
       1300
       -
                       ctx->set_cursor_pos(ctx, (ctx->oob_output & FLANTERM_OOB_OUTPUT_ONLCR) ? 0 : x, y);

     

       1301
       1301
       -
                   } else {

     

       1302
       1302
       -
                       ctx->set_cursor_pos(ctx, (ctx->oob_output & FLANTERM_OOB_OUTPUT_ONLCR) ? 0 : x, y + 1);

     

       1303
       1303
       -
                   }

     

       1304
       1304
       -
                   return;

     

       1305
       1305
       -
               case '\b':

     

       1306
       1306
       -
                   ctx->set_cursor_pos(ctx, x - 1, y);

     

       1307
       1307
       -
                   return;

     

       1308
       1308
       -
               case '\r':

     

       1309
       1309
       -
                   ctx->set_cursor_pos(ctx, 0, y);

     

       1310
       1310
       -
                   return;

     

       1311
       1311
       -
               case '\a':

     

       1312
       1312
       -
                   // The bell is handled by the kernel

     

       1313
       1313
       -
                   if (ctx->callback != NULL) {

     

       1314
       1314
       -
                       ctx->callback(ctx, FLANTERM_CB_BELL, 0, 0, 0);

     

       1315
       1315
       -
                   }

     

       1316
       1316
       -
                   return;

     

       1317
       1317
       -
               case 14:

     

       1318
       1318
       -
                   // Move to G1 set

     

       1319
       1319
       -
                   ctx->current_charset = 1;

     

       1320
       1320
       -
                   return;

     

       1321
       1321
       -
               case 15:

     

       1322
       1322
       -
                   // Move to G0 set

     

       1323
       1323
       -
                   ctx->current_charset = 0;

     

       1324
       1324
       -
                   return;

     

       1325
       1325
       -
           }

     

       1326
       1326
       -
       

     

       1327
       1327
       -
           if (ctx->insert_mode == true) {

     

       1328
       1328
       -
               for (size_t i = ctx->cols - 1; ; i--) {

     

       1329
       1329
       -
                   ctx->move_character(ctx, i + 1, y, i, y);

     

       1330
       1330
       -
                   if (i == x) {

     

       1331
       1331
       -
                       break;

     

       1332
       1332
       -
                   }

     

       1333
       1333
       -
               }

     

       1334
       1334
       -
           }

     

       1335
       1335
       -
       

     

       1336
       1336
       -
           // Translate character set

     

       1337
       1337
       -
           switch (ctx->charsets[ctx->current_charset]) {

     

       1338
       1338
       -
               case CHARSET_DEFAULT:

     

       1339
       1339
       -
                   break;

     

       1340
       1340
       -
               case CHARSET_DEC_SPECIAL:

     

       1341
       1341
       -
                   if (dec_special_print(ctx, c)) {

     

       1342
       1342
       -
                       return;

     

       1343
       1343
       -
                   }

     

       1344
       1344
       -
                   break;

     

       1345
       1345
       -
           }

     

       1346
       1346
       -
       

     

       1347
       1347
       -
           if (c >= 0x20 && c <= 0x7e) {

     

       1348
       1348
       -
               ctx->raw_putchar(ctx, c);

     

       1349
       1349
       -
           }

     

       1350
       1350
       -
       }

-138

flanterm.h

···

       1
       1
       -
       /* Copyright (C) 2022-2023 mintsuki and contributors.

     

       2
       2
       -
        *

     

       3
       3
       -
        * Redistribution and use in source and binary forms, with or without

     

       4
       4
       -
        * modification, are permitted provided that the following conditions are met:

     

       5
       5
       -
        *

     

       6
       6
       -
        * 1. Redistributions of source code must retain the above copyright notice,

     

       7
       7
       -
        *    this list of conditions and the following disclaimer.

     

       8
       8
       -
        *

     

       9
       9
       -
        * 2. Redistributions in binary form must reproduce the above copyright notice,

     

       10
       10
       -
        *    this list of conditions and the following disclaimer in the documentation

     

       11
       11
       -
        *    and/or other materials provided with the distribution.

     

       12
       12
       -
        *

     

       13
       13
       -
        * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

     

       14
       14
       -
        * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

     

       15
       15
       -
        * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

     

       16
       16
       -
        * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE

     

       17
       17
       -
        * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

     

       18
       18
       -
        * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

     

       19
       19
       -
        * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

     

       20
       20
       -
        * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

     

       21
       21
       -
        * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

     

       22
       22
       -
        * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

     

       23
       23
       -
        * POSSIBILITY OF SUCH DAMAGE.

     

       24
       24
       -
        */

     

       25
       25
       -
       

     

       26
       26
       -
       #ifndef _FLANTERM_H

     

       27
       27
       -
       #define _FLANTERM_H 1

     

       28
       28
       -
       

     

       29
       29
       -
       #ifdef __cplusplus

     

       30
       30
       -
       extern "C" {

     

       31
       31
       -
       #endif

     

       32
       32
       -
       

     

       33
       33
       -
       #include <stddef.h>

     

       34
       34
       -
       #include <stdint.h>

     

       35
       35
       -
       #include <stdbool.h>

     

       36
       36
       -
       

     

       37
       37
       -
       #define FLANTERM_MAX_ESC_VALUES 16

     

       38
       38
       -
       

     

       39
       39
       -
       #define FLANTERM_CB_DEC 10

     

       40
       40
       -
       #define FLANTERM_CB_BELL 20

     

       41
       41
       -
       #define FLANTERM_CB_PRIVATE_ID 30

     

       42
       42
       -
       #define FLANTERM_CB_STATUS_REPORT 40

     

       43
       43
       -
       #define FLANTERM_CB_POS_REPORT 50

     

       44
       44
       -
       #define FLANTERM_CB_KBD_LEDS 60

     

       45
       45
       -
       #define FLANTERM_CB_MODE 70

     

       46
       46
       -
       #define FLANTERM_CB_LINUX 80

     

       47
       47
       -
       

     

       48
       48
       -
       #define FLANTERM_OOB_OUTPUT_OCRNL (1 << 0)

     

       49
       49
       -
       #define FLANTERM_OOB_OUTPUT_OFDEL (1 << 1)

     

       50
       50
       -
       #define FLANTERM_OOB_OUTPUT_OFILL (1 << 2)

     

       51
       51
       -
       #define FLANTERM_OOB_OUTPUT_OLCUC (1 << 3)

     

       52
       52
       -
       #define FLANTERM_OOB_OUTPUT_ONLCR (1 << 4)

     

       53
       53
       -
       #define FLANTERM_OOB_OUTPUT_ONLRET (1 << 5)

     

       54
       54
       -
       #define FLANTERM_OOB_OUTPUT_ONOCR (1 << 6)

     

       55
       55
       -
       #define FLANTERM_OOB_OUTPUT_OPOST (1 << 7)

     

       56
       56
       -
       

     

       57
       57
       -
       struct flanterm_context {

     

       58
       58
       -
           /* internal use */

     

       59
       59
       -
       

     

       60
       60
       -
           size_t tab_size;

     

       61
       61
       -
           bool autoflush;

     

       62
       62
       -
           bool cursor_enabled;

     

       63
       63
       -
           bool scroll_enabled;

     

       64
       64
       -
           bool control_sequence;

     

       65
       65
       -
           bool csi;

     

       66
       66
       -
           bool escape;

     

       67
       67
       -
           bool osc;

     

       68
       68
       -
           bool osc_escape;

     

       69
       69
       -
           bool rrr;

     

       70
       70
       -
           bool discard_next;

     

       71
       71
       -
           bool bold;

     

       72
       72
       -
           bool bg_bold;

     

       73
       73
       -
           bool reverse_video;

     

       74
       74
       -
           bool dec_private;

     

       75
       75
       -
           bool insert_mode;

     

       76
       76
       -
           uint64_t code_point;

     

       77
       77
       -
           size_t unicode_remaining;

     

       78
       78
       -
           uint8_t g_select;

     

       79
       79
       -
           uint8_t charsets[2];

     

       80
       80
       -
           size_t current_charset;

     

       81
       81
       -
           size_t escape_offset;

     

       82
       82
       -
           size_t esc_values_i;

     

       83
       83
       -
           size_t saved_cursor_x;

     

       84
       84
       -
           size_t saved_cursor_y;

     

       85
       85
       -
           size_t current_primary;

     

       86
       86
       -
           size_t current_bg;

     

       87
       87
       -
           size_t scroll_top_margin;

     

       88
       88
       -
           size_t scroll_bottom_margin;

     

       89
       89
       -
           uint32_t esc_values[FLANTERM_MAX_ESC_VALUES];

     

       90
       90
       -
           uint64_t oob_output;

     

       91
       91
       -
           bool saved_state_bold;

     

       92
       92
       -
           bool saved_state_bg_bold;

     

       93
       93
       -
           bool saved_state_reverse_video;

     

       94
       94
       -
           size_t saved_state_current_charset;

     

       95
       95
       -
           size_t saved_state_current_primary;

     

       96
       96
       -
           size_t saved_state_current_bg;

     

       97
       97
       -
       

     

       98
       98
       -
           /* to be set by backend */

     

       99
       99
       -
       

     

       100
       100
       -
           size_t rows, cols;

     

       101
       101
       -
       

     

       102
       102
       -
           void (*raw_putchar)(struct flanterm_context *, uint8_t c);

     

       103
       103
       -
           void (*clear)(struct flanterm_context *, bool move);

     

       104
       104
       -
           void (*set_cursor_pos)(struct flanterm_context *, size_t x, size_t y);

     

       105
       105
       -
           void (*get_cursor_pos)(struct flanterm_context *, size_t *x, size_t *y);

     

       106
       106
       -
           void (*set_text_fg)(struct flanterm_context *, size_t fg);

     

       107
       107
       -
           void (*set_text_bg)(struct flanterm_context *, size_t bg);

     

       108
       108
       -
           void (*set_text_fg_bright)(struct flanterm_context *, size_t fg);

     

       109
       109
       -
           void (*set_text_bg_bright)(struct flanterm_context *, size_t bg);

     

       110
       110
       -
           void (*set_text_fg_rgb)(struct flanterm_context *, uint32_t fg);

     

       111
       111
       -
           void (*set_text_bg_rgb)(struct flanterm_context *, uint32_t bg);

     

       112
       112
       -
           void (*set_text_fg_default)(struct flanterm_context *);

     

       113
       113
       -
           void (*set_text_bg_default)(struct flanterm_context *);

     

       114
       114
       -
           void (*set_text_fg_default_bright)(struct flanterm_context *);

     

       115
       115
       -
           void (*set_text_bg_default_bright)(struct flanterm_context *);

     

       116
       116
       -
           void (*move_character)(struct flanterm_context *, size_t new_x, size_t new_y, size_t old_x, size_t old_y);

     

       117
       117
       -
           void (*scroll)(struct flanterm_context *);

     

       118
       118
       -
           void (*revscroll)(struct flanterm_context *);

     

       119
       119
       -
           void (*swap_palette)(struct flanterm_context *);

     

       120
       120
       -
           void (*save_state)(struct flanterm_context *);

     

       121
       121
       -
           void (*restore_state)(struct flanterm_context *);

     

       122
       122
       -
           void (*double_buffer_flush)(struct flanterm_context *);

     

       123
       123
       -
           void (*full_refresh)(struct flanterm_context *);

     

       124
       124
       -
           void (*deinit)(struct flanterm_context *, void (*)(void *, size_t));

     

       125
       125
       -
       

     

       126
       126
       -
           /* to be set by client */

     

       127
       127
       -
       

     

       128
       128
       -
           void (*callback)(struct flanterm_context *, uint64_t, uint64_t, uint64_t, uint64_t);

     

       129
       129
       -
       };

     

       130
       130
       -
       

     

       131
       131
       -
       void flanterm_context_reinit(struct flanterm_context *ctx);

     

       132
       132
       -
       void flanterm_write(struct flanterm_context *ctx, const char *buf, size_t count);

     

       133
       133
       -
       

     

       134
       134
       -
       #ifdef __cplusplus

     

       135
       135
       -
       }

     

       136
       136
       -
       #endif

     

       137
       137
       -
       

     

       138
       138
       -
       #endif

+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
       +
       };

+1424

src/flanterm.c

···

       1
       1
       +
       /* Copyright (C) 2022-2025 mintsuki and contributors.

     

       2
       2
       +
        *

     

       3
       3
       +
        * Redistribution and use in source and binary forms, with or without

     

       4
       4
       +
        * modification, are permitted provided that the following conditions are met:

     

       5
       5
       +
        *

     

       6
       6
       +
        * 1. Redistributions of source code must retain the above copyright notice,

     

       7
       7
       +
        *    this list of conditions and the following disclaimer.

     

       8
       8
       +
        *

     

       9
       9
       +
        * 2. Redistributions in binary form must reproduce the above copyright notice,

     

       10
       10
       +
        *    this list of conditions and the following disclaimer in the documentation

     

       11
       11
       +
        *    and/or other materials provided with the distribution.

     

       12
       12
       +
        *

     

       13
       13
       +
        * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

     

       14
       14
       +
        * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

     

       15
       15
       +
        * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

     

       16
       16
       +
        * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE

     

       17
       17
       +
        * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

     

       18
       18
       +
        * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

     

       19
       19
       +
        * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

     

       20
       20
       +
        * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

     

       21
       21
       +
        * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

     

       22
       22
       +
        * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

     

       23
       23
       +
        * POSSIBILITY OF SUCH DAMAGE.

     

       24
       24
       +
        */

     

       25
       25
       +
       

     

       26
       26
       +
       #ifdef __cplusplus

     

       27
       27
       +
       #error "Please do not compile Flanterm as C++ code! Flanterm should be compiled as C99 or newer."

     

       28
       28
       +
       #endif

     

       29
       29
       +
       

     

       30
       30
       +
       #ifndef __STDC_VERSION__

     

       31
       31
       +
       #error "Flanterm must be compiled as C99 or newer."

     

       32
       32
       +
       #endif

     

       33
       33
       +
       

     

       34
       34
       +
       #include <stdint.h>

     

       35
       35
       +
       #include <stddef.h>

     

       36
       36
       +
       #include <stdbool.h>

     

       37
       37
       +
       

     

       38
       38
       +
       #ifndef FLANTERM_IN_FLANTERM

     

       39
       39
       +
       #define FLANTERM_IN_FLANTERM

     

       40
       40
       +
       #endif

     

       41
       41
       +
       

     

       42
       42
       +
       #include "flanterm.h"

     

       43
       43
       +
       

     

       44
       44
       +
       // Tries to implement this standard for terminfo

     

       45
       45
       +
       // https://man7.org/linux/man-pages/man4/console_codes.4.html

     

       46
       46
       +
       

     

       47
       47
       +
       static const uint32_t col256[] = {

     

       48
       48
       +
           0x000000, 0x00005f, 0x000087, 0x0000af, 0x0000d7, 0x0000ff, 0x005f00, 0x005f5f,

     

       49
       49
       +
           0x005f87, 0x005faf, 0x005fd7, 0x005fff, 0x008700, 0x00875f, 0x008787, 0x0087af,

     

       50
       50
       +
           0x0087d7, 0x0087ff, 0x00af00, 0x00af5f, 0x00af87, 0x00afaf, 0x00afd7, 0x00afff,

     

       51
       51
       +
           0x00d700, 0x00d75f, 0x00d787, 0x00d7af, 0x00d7d7, 0x00d7ff, 0x00ff00, 0x00ff5f,

     

       52
       52
       +
           0x00ff87, 0x00ffaf, 0x00ffd7, 0x00ffff, 0x5f0000, 0x5f005f, 0x5f0087, 0x5f00af,

     

       53
       53
       +
           0x5f00d7, 0x5f00ff, 0x5f5f00, 0x5f5f5f, 0x5f5f87, 0x5f5faf, 0x5f5fd7, 0x5f5fff,

     

       54
       54
       +
           0x5f8700, 0x5f875f, 0x5f8787, 0x5f87af, 0x5f87d7, 0x5f87ff, 0x5faf00, 0x5faf5f,

     

       55
       55
       +
           0x5faf87, 0x5fafaf, 0x5fafd7, 0x5fafff, 0x5fd700, 0x5fd75f, 0x5fd787, 0x5fd7af,

     

       56
       56
       +
           0x5fd7d7, 0x5fd7ff, 0x5fff00, 0x5fff5f, 0x5fff87, 0x5fffaf, 0x5fffd7, 0x5fffff,

     

       57
       57
       +
           0x870000, 0x87005f, 0x870087, 0x8700af, 0x8700d7, 0x8700ff, 0x875f00, 0x875f5f,

     

       58
       58
       +
           0x875f87, 0x875faf, 0x875fd7, 0x875fff, 0x878700, 0x87875f, 0x878787, 0x8787af,

     

       59
       59
       +
           0x8787d7, 0x8787ff, 0x87af00, 0x87af5f, 0x87af87, 0x87afaf, 0x87afd7, 0x87afff,

     

       60
       60
       +
           0x87d700, 0x87d75f, 0x87d787, 0x87d7af, 0x87d7d7, 0x87d7ff, 0x87ff00, 0x87ff5f,

     

       61
       61
       +
           0x87ff87, 0x87ffaf, 0x87ffd7, 0x87ffff, 0xaf0000, 0xaf005f, 0xaf0087, 0xaf00af,

     

       62
       62
       +
           0xaf00d7, 0xaf00ff, 0xaf5f00, 0xaf5f5f, 0xaf5f87, 0xaf5faf, 0xaf5fd7, 0xaf5fff,

     

       63
       63
       +
           0xaf8700, 0xaf875f, 0xaf8787, 0xaf87af, 0xaf87d7, 0xaf87ff, 0xafaf00, 0xafaf5f,

     

       64
       64
       +
           0xafaf87, 0xafafaf, 0xafafd7, 0xafafff, 0xafd700, 0xafd75f, 0xafd787, 0xafd7af,

     

       65
       65
       +
           0xafd7d7, 0xafd7ff, 0xafff00, 0xafff5f, 0xafff87, 0xafffaf, 0xafffd7, 0xafffff,

     

       66
       66
       +
           0xd70000, 0xd7005f, 0xd70087, 0xd700af, 0xd700d7, 0xd700ff, 0xd75f00, 0xd75f5f,

     

       67
       67
       +
           0xd75f87, 0xd75faf, 0xd75fd7, 0xd75fff, 0xd78700, 0xd7875f, 0xd78787, 0xd787af,

     

       68
       68
       +
           0xd787d7, 0xd787ff, 0xd7af00, 0xd7af5f, 0xd7af87, 0xd7afaf, 0xd7afd7, 0xd7afff,

     

       69
       69
       +
           0xd7d700, 0xd7d75f, 0xd7d787, 0xd7d7af, 0xd7d7d7, 0xd7d7ff, 0xd7ff00, 0xd7ff5f,

     

       70
       70
       +
           0xd7ff87, 0xd7ffaf, 0xd7ffd7, 0xd7ffff, 0xff0000, 0xff005f, 0xff0087, 0xff00af,

     

       71
       71
       +
           0xff00d7, 0xff00ff, 0xff5f00, 0xff5f5f, 0xff5f87, 0xff5faf, 0xff5fd7, 0xff5fff,

     

       72
       72
       +
           0xff8700, 0xff875f, 0xff8787, 0xff87af, 0xff87d7, 0xff87ff, 0xffaf00, 0xffaf5f,

     

       73
       73
       +
           0xffaf87, 0xffafaf, 0xffafd7, 0xffafff, 0xffd700, 0xffd75f, 0xffd787, 0xffd7af,

     

       74
       74
       +
           0xffd7d7, 0xffd7ff, 0xffff00, 0xffff5f, 0xffff87, 0xffffaf, 0xffffd7, 0xffffff,

     

       75
       75
       +
           0x080808, 0x121212, 0x1c1c1c, 0x262626, 0x303030, 0x3a3a3a, 0x444444, 0x4e4e4e,

     

       76
       76
       +
           0x585858, 0x626262, 0x6c6c6c, 0x767676, 0x808080, 0x8a8a8a, 0x949494, 0x9e9e9e,

     

       77
       77
       +
           0xa8a8a8, 0xb2b2b2, 0xbcbcbc, 0xc6c6c6, 0xd0d0d0, 0xdadada, 0xe4e4e4, 0xeeeeee

     

       78
       78
       +
       };

     

       79
       79
       +
       

     

       80
       80
       +
       #define CHARSET_DEFAULT 0

     

       81
       81
       +
       #define CHARSET_DEC_SPECIAL 1

     

       82
       82
       +
       

     

       83
       83
       +
       void flanterm_context_reinit(struct flanterm_context *ctx) {

     

       84
       84
       +
           ctx->tab_size = 8;

     

       85
       85
       +
           ctx->autoflush = true;

     

       86
       86
       +
           ctx->cursor_enabled = true;

     

       87
       87
       +
           ctx->scroll_enabled = true;

     

       88
       88
       +
           ctx->control_sequence = false;

     

       89
       89
       +
           ctx->escape = false;

     

       90
       90
       +
           ctx->osc = false;

     

       91
       91
       +
           ctx->osc_escape = false;

     

       92
       92
       +
           ctx->rrr = false;

     

       93
       93
       +
           ctx->discard_next = false;

     

       94
       94
       +
           ctx->bold = false;

     

       95
       95
       +
           ctx->bg_bold = false;

     

       96
       96
       +
           ctx->reverse_video = false;

     

       97
       97
       +
           ctx->dec_private = false;

     

       98
       98
       +
           ctx->insert_mode = false;

     

       99
       99
       +
           ctx->csi_unhandled = false;

     

       100
       100
       +
           ctx->unicode_remaining = 0;

     

       101
       101
       +
           ctx->g_select = 0;

     

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

     

       103
       103
       +
           ctx->charsets[1] = CHARSET_DEC_SPECIAL;

     

       104
       104
       +
           ctx->current_charset = 0;

     

       105
       105
       +
           ctx->escape_offset = 0;

     

       106
       106
       +
           ctx->esc_values_i = 0;

     

       107
       107
       +
           ctx->saved_cursor_x = 0;

     

       108
       108
       +
           ctx->saved_cursor_y = 0;

     

       109
       109
       +
           ctx->current_primary = (size_t)-1;

     

       110
       110
       +
           ctx->current_bg = (size_t)-1;

     

       111
       111
       +
           ctx->scroll_top_margin = 0;

     

       112
       112
       +
           ctx->scroll_bottom_margin = ctx->rows;

     

       113
       113
       +
           ctx->oob_output = FLANTERM_OOB_OUTPUT_ONLCR;

     

       114
       114
       +
       }

     

       115
       115
       +
       

     

       116
       116
       +
       static void flanterm_putchar(struct flanterm_context *ctx, uint8_t c);

     

       117
       117
       +
       

     

       118
       118
       +
       void flanterm_write(struct flanterm_context *ctx, const char *buf, size_t count) {

     

       119
       119
       +
           for (size_t i = 0; i < count; i++) {

     

       120
       120
       +
               flanterm_putchar(ctx, buf[i]);

     

       121
       121
       +
           }

     

       122
       122
       +
       

     

       123
       123
       +
           if (ctx->autoflush) {

     

       124
       124
       +
               ctx->double_buffer_flush(ctx);

     

       125
       125
       +
           }

     

       126
       126
       +
       }

     

       127
       127
       +
       

     

       128
       128
       +
       static void sgr(struct flanterm_context *ctx) {

     

       129
       129
       +
           size_t i = 0;

     

       130
       130
       +
       

     

       131
       131
       +
           if (!ctx->esc_values_i)

     

       132
       132
       +
               goto def;

     

       133
       133
       +
       

     

       134
       134
       +
           for (; i < ctx->esc_values_i; i++) {

     

       135
       135
       +
               size_t offset;

     

       136
       136
       +
       

     

       137
       137
       +
               if (ctx->esc_values[i] == 0) {

     

       138
       138
       +
       def:

     

       139
       139
       +
                   if (ctx->reverse_video) {

     

       140
       140
       +
                       ctx->reverse_video = false;

     

       141
       141
       +
                       ctx->swap_palette(ctx);

     

       142
       142
       +
                   }

     

       143
       143
       +
                   ctx->bold = false;

     

       144
       144
       +
                   ctx->bg_bold = false;

     

       145
       145
       +
                   ctx->current_primary = (size_t)-1;

     

       146
       146
       +
                   ctx->current_bg = (size_t)-1;

     

       147
       147
       +
                   ctx->set_text_bg_default(ctx);

     

       148
       148
       +
                   ctx->set_text_fg_default(ctx);

     

       149
       149
       +
                   continue;

     

       150
       150
       +
               }

     

       151
       151
       +
       

     

       152
       152
       +
               else if (ctx->esc_values[i] == 1) {

     

       153
       153
       +
                   ctx->bold = true;

     

       154
       154
       +
                   if (ctx->current_primary != (size_t)-1) {

     

       155
       155
       +
                       if (!ctx->reverse_video) {

     

       156
       156
       +
                           ctx->set_text_fg_bright(ctx, ctx->current_primary);

     

       157
       157
       +
                       } else {

     

       158
       158
       +
                           ctx->set_text_bg_bright(ctx, ctx->current_primary);

     

       159
       159
       +
                       }

     

       160
       160
       +
                   } else {

     

       161
       161
       +
                       if (!ctx->reverse_video) {

     

       162
       162
       +
                           ctx->set_text_fg_default_bright(ctx);

     

       163
       163
       +
                       } else {

     

       164
       164
       +
                           ctx->set_text_bg_default_bright(ctx);

     

       165
       165
       +
                       }

     

       166
       166
       +
                   }

     

       167
       167
       +
                   continue;

     

       168
       168
       +
               }

     

       169
       169
       +
       

     

       170
       170
       +
               else if (ctx->esc_values[i] == 5) {

     

       171
       171
       +
                   ctx->bg_bold = true;

     

       172
       172
       +
                   if (ctx->current_bg != (size_t)-1) {

     

       173
       173
       +
                       if (!ctx->reverse_video) {

     

       174
       174
       +
                           ctx->set_text_bg_bright(ctx, ctx->current_bg);

     

       175
       175
       +
                       } else {

     

       176
       176
       +
                           ctx->set_text_fg_bright(ctx, ctx->current_bg);

     

       177
       177
       +
                       }

     

       178
       178
       +
                   } else {

     

       179
       179
       +
                       if (!ctx->reverse_video) {

     

       180
       180
       +
                           ctx->set_text_bg_default_bright(ctx);

     

       181
       181
       +
                       } else {

     

       182
       182
       +
                           ctx->set_text_fg_default_bright(ctx);

     

       183
       183
       +
                       }

     

       184
       184
       +
                   }

     

       185
       185
       +
                   continue;

     

       186
       186
       +
               }

     

       187
       187
       +
       

     

       188
       188
       +
               else if (ctx->esc_values[i] == 22) {

     

       189
       189
       +
                   ctx->bold = false;

     

       190
       190
       +
                   if (ctx->current_primary != (size_t)-1) {

     

       191
       191
       +
                       if (!ctx->reverse_video) {

     

       192
       192
       +
                           ctx->set_text_fg(ctx, ctx->current_primary);

     

       193
       193
       +
                       } else {

     

       194
       194
       +
                           ctx->set_text_bg(ctx, ctx->current_primary);

     

       195
       195
       +
                       }

     

       196
       196
       +
                   } else {

     

       197
       197
       +
                       if (!ctx->reverse_video) {

     

       198
       198
       +
                           ctx->set_text_fg_default(ctx);

     

       199
       199
       +
                       } else {

     

       200
       200
       +
                           ctx->set_text_bg_default(ctx);

     

       201
       201
       +
                       }

     

       202
       202
       +
                   }

     

       203
       203
       +
                   continue;

     

       204
       204
       +
               }

     

       205
       205
       +
       

     

       206
       206
       +
               else if (ctx->esc_values[i] == 25) {

     

       207
       207
       +
                   ctx->bg_bold = false;

     

       208
       208
       +
                   if (ctx->current_bg != (size_t)-1) {

     

       209
       209
       +
                       if (!ctx->reverse_video) {

     

       210
       210
       +
                           ctx->set_text_bg(ctx, ctx->current_bg);

     

       211
       211
       +
                       } else {

     

       212
       212
       +
                           ctx->set_text_fg(ctx, ctx->current_bg);

     

       213
       213
       +
                       }

     

       214
       214
       +
                   } else {

     

       215
       215
       +
                       if (!ctx->reverse_video) {

     

       216
       216
       +
                           ctx->set_text_bg_default(ctx);

     

       217
       217
       +
                       } else {

     

       218
       218
       +
                           ctx->set_text_fg_default(ctx);

     

       219
       219
       +
                       }

     

       220
       220
       +
                   }

     

       221
       221
       +
                   continue;

     

       222
       222
       +
               }

     

       223
       223
       +
       

     

       224
       224
       +
               else if (ctx->esc_values[i] >= 30 && ctx->esc_values[i] <= 37) {

     

       225
       225
       +
                   offset = 30;

     

       226
       226
       +
                   ctx->current_primary = ctx->esc_values[i] - offset;

     

       227
       227
       +
       

     

       228
       228
       +
                   if (ctx->reverse_video) {

     

       229
       229
       +
                       goto set_bg;

     

       230
       230
       +
                   }

     

       231
       231
       +
       

     

       232
       232
       +
       set_fg:

     

       233
       233
       +
                   if ((ctx->bold && !ctx->reverse_video)

     

       234
       234
       +
                    || (ctx->bg_bold && ctx->reverse_video)) {

     

       235
       235
       +
                       ctx->set_text_fg_bright(ctx, ctx->esc_values[i] - offset);

     

       236
       236
       +
                   } else {

     

       237
       237
       +
                       ctx->set_text_fg(ctx, ctx->esc_values[i] - offset);

     

       238
       238
       +
                   }

     

       239
       239
       +
                   continue;

     

       240
       240
       +
               }

     

       241
       241
       +
       

     

       242
       242
       +
               else if (ctx->esc_values[i] >= 40 && ctx->esc_values[i] <= 47) {

     

       243
       243
       +
                   offset = 40;

     

       244
       244
       +
                   ctx->current_bg = ctx->esc_values[i] - offset;

     

       245
       245
       +
       

     

       246
       246
       +
                   if (ctx->reverse_video) {

     

       247
       247
       +
                       goto set_fg;

     

       248
       248
       +
                   }

     

       249
       249
       +
       

     

       250
       250
       +
       set_bg:

     

       251
       251
       +
                   if ((ctx->bold && ctx->reverse_video)

     

       252
       252
       +
                    || (ctx->bg_bold && !ctx->reverse_video)) {

     

       253
       253
       +
                       ctx->set_text_bg_bright(ctx, ctx->esc_values[i] - offset);

     

       254
       254
       +
                   } else {

     

       255
       255
       +
                       ctx->set_text_bg(ctx, ctx->esc_values[i] - offset);

     

       256
       256
       +
                   }

     

       257
       257
       +
                   continue;

     

       258
       258
       +
               }

     

       259
       259
       +
       

     

       260
       260
       +
               else if (ctx->esc_values[i] >= 90 && ctx->esc_values[i] <= 97) {

     

       261
       261
       +
                   offset = 90;

     

       262
       262
       +
                   ctx->current_primary = ctx->esc_values[i] - offset;

     

       263
       263
       +
       

     

       264
       264
       +
                   if (ctx->reverse_video) {

     

       265
       265
       +
                       goto set_bg_bright;

     

       266
       266
       +
                   }

     

       267
       267
       +
       

     

       268
       268
       +
       set_fg_bright:

     

       269
       269
       +
                   ctx->set_text_fg_bright(ctx, ctx->esc_values[i] - offset);

     

       270
       270
       +
                   continue;

     

       271
       271
       +
               }

     

       272
       272
       +
       

     

       273
       273
       +
               else if (ctx->esc_values[i] >= 100 && ctx->esc_values[i] <= 107) {

     

       274
       274
       +
                   offset = 100;

     

       275
       275
       +
                   ctx->current_bg = ctx->esc_values[i] - offset;

     

       276
       276
       +
       

     

       277
       277
       +
                   if (ctx->reverse_video) {

     

       278
       278
       +
                       goto set_fg_bright;

     

       279
       279
       +
                   }

     

       280
       280
       +
       

     

       281
       281
       +
       set_bg_bright:

     

       282
       282
       +
                   ctx->set_text_bg_bright(ctx, ctx->esc_values[i] - offset);

     

       283
       283
       +
                   continue;

     

       284
       284
       +
               }

     

       285
       285
       +
       

     

       286
       286
       +
               else if (ctx->esc_values[i] == 39) {

     

       287
       287
       +
                   ctx->current_primary = (size_t)-1;

     

       288
       288
       +
       

     

       289
       289
       +
                   if (ctx->reverse_video) {

     

       290
       290
       +
                       ctx->swap_palette(ctx);

     

       291
       291
       +
                   }

     

       292
       292
       +
       

     

       293
       293
       +
                   if (!ctx->bold) {

     

       294
       294
       +
                       ctx->set_text_fg_default(ctx);

     

       295
       295
       +
                   } else {

     

       296
       296
       +
                       ctx->set_text_fg_default_bright(ctx);

     

       297
       297
       +
                   }

     

       298
       298
       +
       

     

       299
       299
       +
                   if (ctx->reverse_video) {

     

       300
       300
       +
                       ctx->swap_palette(ctx);

     

       301
       301
       +
                   }

     

       302
       302
       +
       

     

       303
       303
       +
                   continue;

     

       304
       304
       +
               }

     

       305
       305
       +
       

     

       306
       306
       +
               else if (ctx->esc_values[i] == 49) {

     

       307
       307
       +
                   ctx->current_bg = (size_t)-1;

     

       308
       308
       +
       

     

       309
       309
       +
                   if (ctx->reverse_video) {

     

       310
       310
       +
                       ctx->swap_palette(ctx);

     

       311
       311
       +
                   }

     

       312
       312
       +
       

     

       313
       313
       +
                   if (!ctx->bg_bold) {

     

       314
       314
       +
                       ctx->set_text_bg_default(ctx);

     

       315
       315
       +
                   } else {

     

       316
       316
       +
                       ctx->set_text_bg_default_bright(ctx);

     

       317
       317
       +
                   }

     

       318
       318
       +
       

     

       319
       319
       +
                   if (ctx->reverse_video) {

     

       320
       320
       +
                       ctx->swap_palette(ctx);

     

       321
       321
       +
                   }

     

       322
       322
       +
       

     

       323
       323
       +
                   continue;

     

       324
       324
       +
               }

     

       325
       325
       +
       

     

       326
       326
       +
               else if (ctx->esc_values[i] == 7) {

     

       327
       327
       +
                   if (!ctx->reverse_video) {

     

       328
       328
       +
                       ctx->reverse_video = true;

     

       329
       329
       +
                       ctx->swap_palette(ctx);

     

       330
       330
       +
                   }

     

       331
       331
       +
                   continue;

     

       332
       332
       +
               }

     

       333
       333
       +
       

     

       334
       334
       +
               else if (ctx->esc_values[i] == 27) {

     

       335
       335
       +
                   if (ctx->reverse_video) {

     

       336
       336
       +
                       ctx->reverse_video = false;

     

       337
       337
       +
                       ctx->swap_palette(ctx);

     

       338
       338
       +
                   }

     

       339
       339
       +
                   continue;

     

       340
       340
       +
               }

     

       341
       341
       +
       

     

       342
       342
       +
               // 256/RGB

     

       343
       343
       +
               else if (ctx->esc_values[i] == 38 || ctx->esc_values[i] == 48) {

     

       344
       344
       +
                   bool fg = ctx->esc_values[i] == 38;

     

       345
       345
       +
       

     

       346
       346
       +
                   i++;

     

       347
       347
       +
                   if (i >= ctx->esc_values_i) {

     

       348
       348
       +
                       break;

     

       349
       349
       +
                   }

     

       350
       350
       +
       

     

       351
       351
       +
                   switch (ctx->esc_values[i]) {

     

       352
       352
       +
                       case 2: { // RGB

     

       353
       353
       +
                           if (i + 3 >= ctx->esc_values_i) {

     

       354
       354
       +
                               goto out;

     

       355
       355
       +
                           }

     

       356
       356
       +
       

     

       357
       357
       +
                           uint32_t rgb_value = 0;

     

       358
       358
       +
       

     

       359
       359
       +
                           rgb_value |= ctx->esc_values[i + 1] << 16;

     

       360
       360
       +
                           rgb_value |= ctx->esc_values[i + 2] << 8;

     

       361
       361
       +
                           rgb_value |= ctx->esc_values[i + 3];

     

       362
       362
       +
       

     

       363
       363
       +
                           i += 3;

     

       364
       364
       +
       

     

       365
       365
       +
                           (fg ? ctx->set_text_fg_rgb : ctx->set_text_bg_rgb)(ctx, rgb_value);

     

       366
       366
       +
       

     

       367
       367
       +
                           break;

     

       368
       368
       +
                       }

     

       369
       369
       +
                       case 5: { // 256 colors

     

       370
       370
       +
                           if (i + 1 >= ctx->esc_values_i) {

     

       371
       371
       +
                               goto out;

     

       372
       372
       +
                           }

     

       373
       373
       +
       

     

       374
       374
       +
                           uint32_t col = ctx->esc_values[i + 1];

     

       375
       375
       +
       

     

       376
       376
       +
                           i++;

     

       377
       377
       +
       

     

       378
       378
       +
                           if (col < 8) {

     

       379
       379
       +
                               (fg ? ctx->set_text_fg : ctx->set_text_bg)(ctx, col);

     

       380
       380
       +
                           } else if (col < 16) {

     

       381
       381
       +
                               (fg ? ctx->set_text_fg_bright : ctx->set_text_bg_bright)(ctx, col - 8);

     

       382
       382
       +
                           } else if (col < 256) {

     

       383
       383
       +
                               uint32_t rgb_value = col256[col - 16];

     

       384
       384
       +
                               (fg ? ctx->set_text_fg_rgb : ctx->set_text_bg_rgb)(ctx, rgb_value);

     

       385
       385
       +
                           }

     

       386
       386
       +
       

     

       387
       387
       +
                           break;

     

       388
       388
       +
                       }

     

       389
       389
       +
                       default: continue;

     

       390
       390
       +
                   }

     

       391
       391
       +
               }

     

       392
       392
       +
           }

     

       393
       393
       +
       

     

       394
       394
       +
       out:;

     

       395
       395
       +
       }

     

       396
       396
       +
       

     

       397
       397
       +
       static void dec_private_parse(struct flanterm_context *ctx, uint8_t c) {

     

       398
       398
       +
           ctx->dec_private = false;

     

       399
       399
       +
       

     

       400
       400
       +
           if (ctx->esc_values_i == 0) {

     

       401
       401
       +
               return;

     

       402
       402
       +
           }

     

       403
       403
       +
       

     

       404
       404
       +
           bool set;

     

       405
       405
       +
       

     

       406
       406
       +
           switch (c) {

     

       407
       407
       +
               case 'h':

     

       408
       408
       +
                   set = true; break;

     

       409
       409
       +
               case 'l':

     

       410
       410
       +
                   set = false; break;

     

       411
       411
       +
               default:

     

       412
       412
       +
                   return;

     

       413
       413
       +
           }

     

       414
       414
       +
       

     

       415
       415
       +
           switch (ctx->esc_values[0]) {

     

       416
       416
       +
               case 25: {

     

       417
       417
       +
                   if (set) {

     

       418
       418
       +
                       ctx->cursor_enabled = true;

     

       419
       419
       +
                   } else {

     

       420
       420
       +
                       ctx->cursor_enabled = false;

     

       421
       421
       +
                   }

     

       422
       422
       +
                   return;

     

       423
       423
       +
               }

     

       424
       424
       +
           }

     

       425
       425
       +
       

     

       426
       426
       +
           if (ctx->callback != NULL) {

     

       427
       427
       +
               ctx->callback(ctx, FLANTERM_CB_DEC, ctx->esc_values_i, (uintptr_t)ctx->esc_values, c);

     

       428
       428
       +
           }

     

       429
       429
       +
       }

     

       430
       430
       +
       

     

       431
       431
       +
       static void linux_private_parse(struct flanterm_context *ctx) {

     

       432
       432
       +
           if (ctx->esc_values_i == 0) {

     

       433
       433
       +
               return;

     

       434
       434
       +
           }

     

       435
       435
       +
       

     

       436
       436
       +
           if (ctx->callback != NULL) {

     

       437
       437
       +
               ctx->callback(ctx, FLANTERM_CB_LINUX, ctx->esc_values_i, (uintptr_t)ctx->esc_values, 0);

     

       438
       438
       +
           }

     

       439
       439
       +
       }

     

       440
       440
       +
       

     

       441
       441
       +
       static void mode_toggle(struct flanterm_context *ctx, uint8_t c) {

     

       442
       442
       +
           if (ctx->esc_values_i == 0) {

     

       443
       443
       +
               return;

     

       444
       444
       +
           }

     

       445
       445
       +
       

     

       446
       446
       +
           bool set;

     

       447
       447
       +
       

     

       448
       448
       +
           switch (c) {

     

       449
       449
       +
               case 'h':

     

       450
       450
       +
                   set = true; break;

     

       451
       451
       +
               case 'l':

     

       452
       452
       +
                   set = false; break;

     

       453
       453
       +
               default:

     

       454
       454
       +
                   return;

     

       455
       455
       +
           }

     

       456
       456
       +
       

     

       457
       457
       +
           switch (ctx->esc_values[0]) {

     

       458
       458
       +
               case 4:

     

       459
       459
       +
                   ctx->insert_mode = set; return;

     

       460
       460
       +
           }

     

       461
       461
       +
       

     

       462
       462
       +
           if (ctx->callback != NULL) {

     

       463
       463
       +
               ctx->callback(ctx, FLANTERM_CB_MODE, ctx->esc_values_i, (uintptr_t)ctx->esc_values, c);

     

       464
       464
       +
           }

     

       465
       465
       +
       }

     

       466
       466
       +
       

     

       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
       +
               }

     

       483
       483
       +
           }

     

       484
       484
       +
           switch (c) {

     

       485
       485
       +
               case 0x1b:

     

       486
       486
       +
                   ctx->osc_escape = true;

     

       487
       487
       +
                   break;

     

       488
       488
       +
               // BEL is the other terminator 

     

       489
       489
       +
               case '\a':

     

       490
       490
       +
                   ctx->osc_escape = false;

     

       491
       491
       +
                   ctx->osc = false;

     

       492
       492
       +
                   ctx->escape = false;

     

       493
       493
       +
                   break;

     

       494
       494
       +
               default:

     

       495
       495
       +
                   break;

     

       496
       496
       +
           }

     

       497
       497
       +
           return true;

     

       498
       498
       +
       }

     

       499
       499
       +
       

     

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

     

       501
       501
       +
           if (ctx->escape_offset == 2) {

     

       502
       502
       +
               switch (c) {

     

       503
       503
       +
                   case '[':

     

       504
       504
       +
                       ctx->discard_next = true;

     

       505
       505
       +
                       goto cleanup;

     

       506
       506
       +
                   case '?':

     

       507
       507
       +
                       ctx->dec_private = true;

     

       508
       508
       +
                       return;

     

       509
       509
       +
               }

     

       510
       510
       +
           }

     

       511
       511
       +
       

     

       512
       512
       +
           if (c >= '0' && c <= '9') {

     

       513
       513
       +
               if (ctx->esc_values_i == FLANTERM_MAX_ESC_VALUES) {

     

       514
       514
       +
                   return;

     

       515
       515
       +
               }

     

       516
       516
       +
               ctx->rrr = true;

     

       517
       517
       +
               ctx->esc_values[ctx->esc_values_i] *= 10;

     

       518
       518
       +
               ctx->esc_values[ctx->esc_values_i] += c - '0';

     

       519
       519
       +
               return;

     

       520
       520
       +
           }

     

       521
       521
       +
       

     

       522
       522
       +
           if (ctx->rrr == true) {

     

       523
       523
       +
               ctx->esc_values_i++;

     

       524
       524
       +
               ctx->rrr = false;

     

       525
       525
       +
               if (c == ';')

     

       526
       526
       +
                   return;

     

       527
       527
       +
           } else if (c == ';') {

     

       528
       528
       +
               if (ctx->esc_values_i == FLANTERM_MAX_ESC_VALUES) {

     

       529
       529
       +
                   return;

     

       530
       530
       +
               }

     

       531
       531
       +
               ctx->esc_values[ctx->esc_values_i] = 0;

     

       532
       532
       +
               ctx->esc_values_i++;

     

       533
       533
       +
               return;

     

       534
       534
       +
           }

     

       535
       535
       +
       

     

       536
       536
       +
           size_t esc_default;

     

       537
       537
       +
           switch (c) {

     

       538
       538
       +
               case 'J': case 'K': case 'q':

     

       539
       539
       +
                   esc_default = 0; break;

     

       540
       540
       +
               default:

     

       541
       541
       +
                   esc_default = 1; break;

     

       542
       542
       +
           }

     

       543
       543
       +
       

     

       544
       544
       +
           for (size_t i = ctx->esc_values_i; i < FLANTERM_MAX_ESC_VALUES; i++) {

     

       545
       545
       +
               ctx->esc_values[i] = esc_default;

     

       546
       546
       +
           }

     

       547
       547
       +
       

     

       548
       548
       +
           if (ctx->dec_private == true) {

     

       549
       549
       +
               dec_private_parse(ctx, c);

     

       550
       550
       +
               goto cleanup;

     

       551
       551
       +
           }

     

       552
       552
       +
       

     

       553
       553
       +
           bool r = ctx->scroll_enabled;

     

       554
       554
       +
           ctx->scroll_enabled = false;

     

       555
       555
       +
           size_t x, y;

     

       556
       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
       +
           }

     

       567
       567
       +
       

     

       568
       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;

     

       572
       572
       +
               case 'F':

     

       573
       573
       +
                   x = 0;

     

       574
       574
       +
                   // FALLTHRU

     

       575
       575
       +
               case 'A': {

     

       576
       576
       +
                   if (ctx->esc_values[0] > y)

     

       577
       577
       +
                       ctx->esc_values[0] = y;

     

       578
       578
       +
                   size_t orig_y = y;

     

       579
       579
       +
                   size_t dest_y = y - ctx->esc_values[0];

     

       580
       580
       +
                   bool will_be_in_scroll_region = false;

     

       581
       581
       +
                   if ((ctx->scroll_top_margin >= dest_y && ctx->scroll_top_margin <= orig_y)

     

       582
       582
       +
                    || (ctx->scroll_bottom_margin >= dest_y && ctx->scroll_bottom_margin <= orig_y)) {

     

       583
       583
       +
                       will_be_in_scroll_region = true;

     

       584
       584
       +
                   }

     

       585
       585
       +
                   if (will_be_in_scroll_region && dest_y < ctx->scroll_top_margin) {

     

       586
       586
       +
                       dest_y = ctx->scroll_top_margin;

     

       587
       587
       +
                   }

     

       588
       588
       +
                   ctx->set_cursor_pos(ctx, x, dest_y);

     

       589
       589
       +
                   break;

     

       590
       590
       +
               }

     

       591
       591
       +
               case 'E':

     

       592
       592
       +
                   x = 0;

     

       593
       593
       +
                   // FALLTHRU

     

       594
       594
       +
               case 'e':

     

       595
       595
       +
               case 'B': {

     

       596
       596
       +
                   if (y + ctx->esc_values[0] > ctx->rows - 1)

     

       597
       597
       +
                       ctx->esc_values[0] = (ctx->rows - 1) - y;

     

       598
       598
       +
                   size_t orig_y = y;

     

       599
       599
       +
                   size_t dest_y = y + ctx->esc_values[0];

     

       600
       600
       +
                   bool will_be_in_scroll_region = false;

     

       601
       601
       +
                   if ((ctx->scroll_top_margin >= orig_y && ctx->scroll_top_margin <= dest_y)

     

       602
       602
       +
                    || (ctx->scroll_bottom_margin >= orig_y && ctx->scroll_bottom_margin <= dest_y)) {

     

       603
       603
       +
                       will_be_in_scroll_region = true;

     

       604
       604
       +
                   }

     

       605
       605
       +
                   if (will_be_in_scroll_region && dest_y >= ctx->scroll_bottom_margin) {

     

       606
       606
       +
                       dest_y = ctx->scroll_bottom_margin - 1;

     

       607
       607
       +
                   }

     

       608
       608
       +
                   ctx->set_cursor_pos(ctx, x, dest_y);

     

       609
       609
       +
                   break;

     

       610
       610
       +
               }

     

       611
       611
       +
               case 'a':

     

       612
       612
       +
               case 'C':

     

       613
       613
       +
                   if (x + ctx->esc_values[0] > ctx->cols - 1)

     

       614
       614
       +
                       ctx->esc_values[0] = (ctx->cols - 1) - x;

     

       615
       615
       +
                   ctx->set_cursor_pos(ctx, x + ctx->esc_values[0], y);

     

       616
       616
       +
                   break;

     

       617
       617
       +
               case 'D':

     

       618
       618
       +
                   if (ctx->esc_values[0] > x)

     

       619
       619
       +
                       ctx->esc_values[0] = x;

     

       620
       620
       +
                   ctx->set_cursor_pos(ctx, x - ctx->esc_values[0], y);

     

       621
       621
       +
                   break;

     

       622
       622
       +
               case 'c':

     

       623
       623
       +
                   if (ctx->callback != NULL) {

     

       624
       624
       +
                       ctx->callback(ctx, FLANTERM_CB_PRIVATE_ID, 0, 0, 0);

     

       625
       625
       +
                   }

     

       626
       626
       +
                   break;

     

       627
       627
       +
               case 'd':

     

       628
       628
       +
                   ctx->esc_values[0] -= 1;

     

       629
       629
       +
                   if (ctx->esc_values[0] >= ctx->rows)

     

       630
       630
       +
                       ctx->esc_values[0] = ctx->rows - 1;

     

       631
       631
       +
                   ctx->set_cursor_pos(ctx, x, ctx->esc_values[0]);

     

       632
       632
       +
                   break;

     

       633
       633
       +
               case 'G':

     

       634
       634
       +
               case '`':

     

       635
       635
       +
                   ctx->esc_values[0] -= 1;

     

       636
       636
       +
                   if (ctx->esc_values[0] >= ctx->cols)

     

       637
       637
       +
                       ctx->esc_values[0] = ctx->cols - 1;

     

       638
       638
       +
                   ctx->set_cursor_pos(ctx, ctx->esc_values[0], y);

     

       639
       639
       +
                   break;

     

       640
       640
       +
               case 'H':

     

       641
       641
       +
               case 'f':

     

       642
       642
       +
                   if (ctx->esc_values[0] != 0) {

     

       643
       643
       +
                       ctx->esc_values[0]--;

     

       644
       644
       +
                   }

     

       645
       645
       +
                   if (ctx->esc_values[1] != 0) {

     

       646
       646
       +
                       ctx->esc_values[1]--;

     

       647
       647
       +
                   }

     

       648
       648
       +
                   if (ctx->esc_values[1] >= ctx->cols)

     

       649
       649
       +
                       ctx->esc_values[1] = ctx->cols - 1;

     

       650
       650
       +
                   if (ctx->esc_values[0] >= ctx->rows)

     

       651
       651
       +
                       ctx->esc_values[0] = ctx->rows - 1;

     

       652
       652
       +
                   ctx->set_cursor_pos(ctx, ctx->esc_values[1], ctx->esc_values[0]);

     

       653
       653
       +
                   break;

     

       654
       654
       +
               case 'M': {

     

       655
       655
       +
                   size_t count = ctx->esc_values[0] > ctx->rows ? ctx->rows : ctx->esc_values[0];

     

       656
       656
       +
                   for (size_t i = 0; i < count; i++) {

     

       657
       657
       +
                       ctx->scroll(ctx);

     

       658
       658
       +
                   }

     

       659
       659
       +
                   break;

     

       660
       660
       +
               }

     

       661
       661
       +
               case 'L': {

     

       662
       662
       +
                   size_t old_scroll_top_margin = ctx->scroll_top_margin;

     

       663
       663
       +
                   ctx->scroll_top_margin = y;

     

       664
       664
       +
                   size_t count = ctx->esc_values[0] > ctx->rows ? ctx->rows : ctx->esc_values[0];

     

       665
       665
       +
                   for (size_t i = 0; i < count; i++) {

     

       666
       666
       +
                       ctx->revscroll(ctx);

     

       667
       667
       +
                   }

     

       668
       668
       +
                   ctx->scroll_top_margin = old_scroll_top_margin;

     

       669
       669
       +
                   break;

     

       670
       670
       +
               }

     

       671
       671
       +
               case 'n':

     

       672
       672
       +
                   switch (ctx->esc_values[0]) {

     

       673
       673
       +
                       case 5:

     

       674
       674
       +
                           if (ctx->callback != NULL) {

     

       675
       675
       +
                               ctx->callback(ctx, FLANTERM_CB_STATUS_REPORT, 0, 0, 0);

     

       676
       676
       +
                           }

     

       677
       677
       +
                           break;

     

       678
       678
       +
                       case 6:

     

       679
       679
       +
                           if (ctx->callback != NULL) {

     

       680
       680
       +
                               ctx->callback(ctx, FLANTERM_CB_POS_REPORT, x + 1, y + 1, 0);

     

       681
       681
       +
                           }

     

       682
       682
       +
                           break;

     

       683
       683
       +
                   }

     

       684
       684
       +
                   break;

     

       685
       685
       +
               case 'q':

     

       686
       686
       +
                   if (ctx->callback != NULL) {

     

       687
       687
       +
                       ctx->callback(ctx, FLANTERM_CB_KBD_LEDS, ctx->esc_values[0], 0, 0);

     

       688
       688
       +
                   }

     

       689
       689
       +
                   break;

     

       690
       690
       +
               case 'J':

     

       691
       691
       +
                   switch (ctx->esc_values[0]) {

     

       692
       692
       +
                       case 0: {

     

       693
       693
       +
                           size_t rows_remaining = ctx->rows - (y + 1);

     

       694
       694
       +
                           size_t cols_diff = ctx->cols - (x + 1);

     

       695
       695
       +
                           size_t to_clear = rows_remaining * ctx->cols + cols_diff + 1;

     

       696
       696
       +
                           for (size_t i = 0; i < to_clear; i++) {

     

       697
       697
       +
                               ctx->raw_putchar(ctx, ' ');

     

       698
       698
       +
                           }

     

       699
       699
       +
                           ctx->set_cursor_pos(ctx, x, y);

     

       700
       700
       +
                           break;

     

       701
       701
       +
                       }

     

       702
       702
       +
                       case 1: {

     

       703
       703
       +
                           ctx->set_cursor_pos(ctx, 0, 0);

     

       704
       704
       +
                           bool b = false;

     

       705
       705
       +
                           for (size_t yc = 0; yc < ctx->rows; yc++) {

     

       706
       706
       +
                               for (size_t xc = 0; xc < ctx->cols; xc++) {

     

       707
       707
       +
                                   ctx->raw_putchar(ctx, ' ');

     

       708
       708
       +
                                   if (xc == x && yc == y) {

     

       709
       709
       +
                                       ctx->set_cursor_pos(ctx, x, y);

     

       710
       710
       +
                                       b = true;

     

       711
       711
       +
                                       break;

     

       712
       712
       +
                                   }

     

       713
       713
       +
                               }

     

       714
       714
       +
                               if (b == true)

     

       715
       715
       +
                                   break;

     

       716
       716
       +
                           }

     

       717
       717
       +
                           break;

     

       718
       718
       +
                       }

     

       719
       719
       +
                       case 2:

     

       720
       720
       +
                       case 3:

     

       721
       721
       +
                           ctx->clear(ctx, false);

     

       722
       722
       +
                           break;

     

       723
       723
       +
                   }

     

       724
       724
       +
                   break;

     

       725
       725
       +
               case '@':

     

       726
       726
       +
                   for (size_t i = ctx->cols - 1; ; i--) {

     

       727
       727
       +
                       ctx->move_character(ctx, i + ctx->esc_values[0], y, i, y);

     

       728
       728
       +
                       ctx->set_cursor_pos(ctx, i, y);

     

       729
       729
       +
                       ctx->raw_putchar(ctx, ' ');

     

       730
       730
       +
                       if (i == x) {

     

       731
       731
       +
                           break;

     

       732
       732
       +
                       }

     

       733
       733
       +
                   }

     

       734
       734
       +
                   ctx->set_cursor_pos(ctx, x, y);

     

       735
       735
       +
                   break;

     

       736
       736
       +
               case 'P':

     

       737
       737
       +
                   for (size_t i = x + ctx->esc_values[0]; i < ctx->cols; i++)

     

       738
       738
       +
                       ctx->move_character(ctx, i - ctx->esc_values[0], y, i, y);

     

       739
       739
       +
                   ctx->set_cursor_pos(ctx, ctx->cols - ctx->esc_values[0], y);

     

       740
       740
       +
                   // FALLTHRU

     

       741
       741
       +
               case 'X': {

     

       742
       742
       +
                   size_t count = ctx->esc_values[0] > ctx->cols ? ctx->cols : ctx->esc_values[0];

     

       743
       743
       +
                   for (size_t i = 0; i < count; i++)

     

       744
       744
       +
                       ctx->raw_putchar(ctx, ' ');

     

       745
       745
       +
                   ctx->set_cursor_pos(ctx, x, y);

     

       746
       746
       +
                   break;

     

       747
       747
       +
               }

     

       748
       748
       +
               case 'm':

     

       749
       749
       +
                   sgr(ctx);

     

       750
       750
       +
                   break;

     

       751
       751
       +
               case 's':

     

       752
       752
       +
                   ctx->get_cursor_pos(ctx, &ctx->saved_cursor_x, &ctx->saved_cursor_y);

     

       753
       753
       +
                   break;

     

       754
       754
       +
               case 'u':

     

       755
       755
       +
                   ctx->set_cursor_pos(ctx, ctx->saved_cursor_x, ctx->saved_cursor_y);

     

       756
       756
       +
                   break;

     

       757
       757
       +
               case 'K':

     

       758
       758
       +
                   switch (ctx->esc_values[0]) {

     

       759
       759
       +
                       case 0: {

     

       760
       760
       +
                           for (size_t i = x; i < ctx->cols; i++)

     

       761
       761
       +
                               ctx->raw_putchar(ctx, ' ');

     

       762
       762
       +
                           ctx->set_cursor_pos(ctx, x, y);

     

       763
       763
       +
                           break;

     

       764
       764
       +
                       }

     

       765
       765
       +
                       case 1: {

     

       766
       766
       +
                           ctx->set_cursor_pos(ctx, 0, y);

     

       767
       767
       +
                           for (size_t i = 0; i < x; i++)

     

       768
       768
       +
                               ctx->raw_putchar(ctx, ' ');

     

       769
       769
       +
                           break;

     

       770
       770
       +
                       }

     

       771
       771
       +
                       case 2: {

     

       772
       772
       +
                           ctx->set_cursor_pos(ctx, 0, y);

     

       773
       773
       +
                           for (size_t i = 0; i < ctx->cols; i++)

     

       774
       774
       +
                               ctx->raw_putchar(ctx, ' ');

     

       775
       775
       +
                           ctx->set_cursor_pos(ctx, x, y);

     

       776
       776
       +
                           break;

     

       777
       777
       +
                       }

     

       778
       778
       +
                   }

     

       779
       779
       +
                   break;

     

       780
       780
       +
               case 'r':

     

       781
       781
       +
                   if (ctx->esc_values[0] == 0) {

     

       782
       782
       +
                       ctx->esc_values[0] = 1;

     

       783
       783
       +
                   }

     

       784
       784
       +
                   if (ctx->esc_values[1] == 0) {

     

       785
       785
       +
                       ctx->esc_values[1] = 1;

     

       786
       786
       +
                   }

     

       787
       787
       +
                   ctx->scroll_top_margin = 0;

     

       788
       788
       +
                   ctx->scroll_bottom_margin = ctx->rows;

     

       789
       789
       +
                   if (ctx->esc_values_i > 0) {

     

       790
       790
       +
                       ctx->scroll_top_margin = ctx->esc_values[0] - 1;

     

       791
       791
       +
                   }

     

       792
       792
       +
                   if (ctx->esc_values_i > 1) {

     

       793
       793
       +
                       ctx->scroll_bottom_margin = ctx->esc_values[1];

     

       794
       794
       +
                   }

     

       795
       795
       +
                   if (ctx->scroll_top_margin >= ctx->rows

     

       796
       796
       +
                    || ctx->scroll_bottom_margin > ctx->rows

     

       797
       797
       +
                    || ctx->scroll_top_margin >= (ctx->scroll_bottom_margin - 1)) {

     

       798
       798
       +
                       ctx->scroll_top_margin = 0;

     

       799
       799
       +
                       ctx->scroll_bottom_margin = ctx->rows;

     

       800
       800
       +
                   }

     

       801
       801
       +
                   ctx->set_cursor_pos(ctx, 0, 0);

     

       802
       802
       +
                   break;

     

       803
       803
       +
               case 'l':

     

       804
       804
       +
               case 'h':

     

       805
       805
       +
                   mode_toggle(ctx, c);

     

       806
       806
       +
                   break;

     

       807
       807
       +
               case ']':

     

       808
       808
       +
                   linux_private_parse(ctx);

     

       809
       809
       +
                   break;

     

       810
       810
       +
               default:

     

       811
       811
       +
                   ctx->csi_unhandled = true;

     

       812
       812
       +
                   return;

     

       813
       813
       +
           }

     

       814
       814
       +
       

     

       815
       815
       +
           ctx->scroll_enabled = r;

     

       816
       816
       +
       

     

       817
       817
       +
       cleanup:

     

       818
       818
       +
           ctx->control_sequence = false;

     

       819
       819
       +
           ctx->escape = false;

     

       820
       820
       +
       }

     

       821
       821
       +
       

     

       822
       822
       +
       static void restore_state(struct flanterm_context *ctx) {

     

       823
       823
       +
           ctx->bold = ctx->saved_state_bold;

     

       824
       824
       +
           ctx->bg_bold = ctx->saved_state_bg_bold;

     

       825
       825
       +
           ctx->reverse_video = ctx->saved_state_reverse_video;

     

       826
       826
       +
           ctx->current_charset = ctx->saved_state_current_charset;

     

       827
       827
       +
           ctx->current_primary = ctx->saved_state_current_primary;

     

       828
       828
       +
           ctx->current_bg = ctx->saved_state_current_bg;

     

       829
       829
       +
       

     

       830
       830
       +
           ctx->restore_state(ctx);

     

       831
       831
       +
       }

     

       832
       832
       +
       

     

       833
       833
       +
       static void save_state(struct flanterm_context *ctx) {

     

       834
       834
       +
           ctx->save_state(ctx);

     

       835
       835
       +
       

     

       836
       836
       +
           ctx->saved_state_bold = ctx->bold;

     

       837
       837
       +
           ctx->saved_state_bg_bold = ctx->bg_bold;

     

       838
       838
       +
           ctx->saved_state_reverse_video = ctx->reverse_video;

     

       839
       839
       +
           ctx->saved_state_current_charset = ctx->current_charset;

     

       840
       840
       +
           ctx->saved_state_current_primary = ctx->current_primary;

     

       841
       841
       +
           ctx->saved_state_current_bg = ctx->current_bg;

     

       842
       842
       +
       }

     

       843
       843
       +
       

     

       844
       844
       +
       static void escape_parse(struct flanterm_context *ctx, uint8_t c) {

     

       845
       845
       +
           ctx->escape_offset++;

     

       846
       846
       +
       

     

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

     

       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
       +
               }

     

       855
       855
       +
           }

     

       856
       856
       +
       

     

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

     

       858
       858
       +
               control_sequence_parse(ctx, c);

     

       859
       859
       +
               return;

     

       860
       860
       +
           }

     

       861
       861
       +
       

     

       862
       862
       +
           size_t x, y;

     

       863
       863
       +
           ctx->get_cursor_pos(ctx, &x, &y);

     

       864
       864
       +
       

     

       865
       865
       +
           switch (c) {

     

       866
       866
       +
               case ']':

     

       867
       867
       +
                   ctx->osc_escape = false;

     

       868
       868
       +
                   ctx->osc = true;

     

       869
       869
       +
                   return;

     

       870
       870
       +
               case '[':

     

       871
       871
       +
                   for (size_t i = 0; i < FLANTERM_MAX_ESC_VALUES; i++)

     

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

     

       873
       873
       +
                   ctx->esc_values_i = 0;

     

       874
       874
       +
                   ctx->rrr = false;

     

       875
       875
       +
                   ctx->csi_unhandled = false;

     

       876
       876
       +
                   ctx->control_sequence = true;

     

       877
       877
       +
                   return;

     

       878
       878
       +
               case '7':

     

       879
       879
       +
                   save_state(ctx);

     

       880
       880
       +
                   break;

     

       881
       881
       +
               case '8':

     

       882
       882
       +
                   restore_state(ctx);

     

       883
       883
       +
                   break;

     

       884
       884
       +
               case 'c':

     

       885
       885
       +
                   flanterm_context_reinit(ctx);

     

       886
       886
       +
                   ctx->clear(ctx, true);

     

       887
       887
       +
                   break;

     

       888
       888
       +
               case 'D':

     

       889
       889
       +
                   if (y == ctx->scroll_bottom_margin - 1) {

     

       890
       890
       +
                       ctx->scroll(ctx);

     

       891
       891
       +
                       ctx->set_cursor_pos(ctx, x, y);

     

       892
       892
       +
                   } else {

     

       893
       893
       +
                       ctx->set_cursor_pos(ctx, x, y + 1);

     

       894
       894
       +
                   }

     

       895
       895
       +
                   break;

     

       896
       896
       +
               case 'E':

     

       897
       897
       +
                   if (y == ctx->scroll_bottom_margin - 1) {

     

       898
       898
       +
                       ctx->scroll(ctx);

     

       899
       899
       +
                       ctx->set_cursor_pos(ctx, 0, y);

     

       900
       900
       +
                   } else {

     

       901
       901
       +
                       ctx->set_cursor_pos(ctx, 0, y + 1);

     

       902
       902
       +
                   }

     

       903
       903
       +
                   break;

     

       904
       904
       +
               case 'M':

     

       905
       905
       +
                   // "Reverse linefeed"

     

       906
       906
       +
                   if (y == ctx->scroll_top_margin) {

     

       907
       907
       +
                       ctx->revscroll(ctx);

     

       908
       908
       +
                       ctx->set_cursor_pos(ctx, 0, y);

     

       909
       909
       +
                   } else {

     

       910
       910
       +
                       ctx->set_cursor_pos(ctx, 0, y - 1);

     

       911
       911
       +
                   }

     

       912
       912
       +
                   break;

     

       913
       913
       +
               case 'Z':

     

       914
       914
       +
                   if (ctx->callback != NULL) {

     

       915
       915
       +
                       ctx->callback(ctx, FLANTERM_CB_PRIVATE_ID, 0, 0, 0);

     

       916
       916
       +
                   }

     

       917
       917
       +
                   break;

     

       918
       918
       +
               case '(':

     

       919
       919
       +
               case ')':

     

       920
       920
       +
                   ctx->g_select = c - '\'';

     

       921
       921
       +
                   break;

     

       922
       922
       +
           }

     

       923
       923
       +
       

     

       924
       924
       +
           ctx->escape = false;

     

       925
       925
       +
       }

     

       926
       926
       +
       

     

       927
       927
       +
       static bool dec_special_print(struct flanterm_context *ctx, uint8_t c) {

     

       928
       928
       +
       #define FLANTERM_DEC_SPCL_PRN(C) ctx->raw_putchar(ctx, (C)); return true;

     

       929
       929
       +
           switch (c) {

     

       930
       930
       +
               case '`': FLANTERM_DEC_SPCL_PRN(0x04)

     

       931
       931
       +
               case '0': FLANTERM_DEC_SPCL_PRN(0xdb)

     

       932
       932
       +
               case '-': FLANTERM_DEC_SPCL_PRN(0x18)

     

       933
       933
       +
               case ',': FLANTERM_DEC_SPCL_PRN(0x1b)

     

       934
       934
       +
               case '.': FLANTERM_DEC_SPCL_PRN(0x19)

     

       935
       935
       +
               case 'a': FLANTERM_DEC_SPCL_PRN(0xb1)

     

       936
       936
       +
               case 'f': FLANTERM_DEC_SPCL_PRN(0xf8)

     

       937
       937
       +
               case 'g': FLANTERM_DEC_SPCL_PRN(0xf1)

     

       938
       938
       +
               case 'h': FLANTERM_DEC_SPCL_PRN(0xb0)

     

       939
       939
       +
               case 'j': FLANTERM_DEC_SPCL_PRN(0xd9)

     

       940
       940
       +
               case 'k': FLANTERM_DEC_SPCL_PRN(0xbf)

     

       941
       941
       +
               case 'l': FLANTERM_DEC_SPCL_PRN(0xda)

     

       942
       942
       +
               case 'm': FLANTERM_DEC_SPCL_PRN(0xc0)

     

       943
       943
       +
               case 'n': FLANTERM_DEC_SPCL_PRN(0xc5)

     

       944
       944
       +
               case 'q': FLANTERM_DEC_SPCL_PRN(0xc4)

     

       945
       945
       +
               case 's': FLANTERM_DEC_SPCL_PRN(0x5f)

     

       946
       946
       +
               case 't': FLANTERM_DEC_SPCL_PRN(0xc3)

     

       947
       947
       +
               case 'u': FLANTERM_DEC_SPCL_PRN(0xb4)

     

       948
       948
       +
               case 'v': FLANTERM_DEC_SPCL_PRN(0xc1)

     

       949
       949
       +
               case 'w': FLANTERM_DEC_SPCL_PRN(0xc2)

     

       950
       950
       +
               case 'x': FLANTERM_DEC_SPCL_PRN(0xb3)

     

       951
       951
       +
               case 'y': FLANTERM_DEC_SPCL_PRN(0xf3)

     

       952
       952
       +
               case 'z': FLANTERM_DEC_SPCL_PRN(0xf2)

     

       953
       953
       +
               case '~': FLANTERM_DEC_SPCL_PRN(0xfa)

     

       954
       954
       +
               case '_': FLANTERM_DEC_SPCL_PRN(0xff)

     

       955
       955
       +
               case '+': FLANTERM_DEC_SPCL_PRN(0x1a)

     

       956
       956
       +
               case '{': FLANTERM_DEC_SPCL_PRN(0xe3)

     

       957
       957
       +
               case '}': FLANTERM_DEC_SPCL_PRN(0x9c)

     

       958
       958
       +
           }

     

       959
       959
       +
       #undef FLANTERM_DEC_SPCL_PRN

     

       960
       960
       +
       

     

       961
       961
       +
           return false;

     

       962
       962
       +
       }

     

       963
       963
       +
       

     

       964
       964
       +
       // Following wcwidth related code inherited from:

     

       965
       965
       +
       // https://www.cl.cam.ac.uk/~mgk25/ucs/wcwidth.c

     

       966
       966
       +
       

     

       967
       967
       +
       struct interval {

     

       968
       968
       +
           uint32_t first;

     

       969
       969
       +
           uint32_t last;

     

       970
       970
       +
       };

     

       971
       971
       +
       

     

       972
       972
       +
       /* auxiliary function for binary search in interval table */

     

       973
       973
       +
       static int bisearch(uint32_t ucs, const struct interval *table, int max) {

     

       974
       974
       +
         int min = 0;

     

       975
       975
       +
         int mid;

     

       976
       976
       +
       

     

       977
       977
       +
         if (ucs < table[0].first || ucs > table[max].last)

     

       978
       978
       +
           return 0;

     

       979
       979
       +
         while (max >= min) {

     

       980
       980
       +
           mid = (min + max) / 2;

     

       981
       981
       +
           if (ucs > table[mid].last)

     

       982
       982
       +
             min = mid + 1;

     

       983
       983
       +
           else if (ucs < table[mid].first)

     

       984
       984
       +
             max = mid - 1;

     

       985
       985
       +
           else

     

       986
       986
       +
             return 1;

     

       987
       987
       +
         }

     

       988
       988
       +
       

     

       989
       989
       +
         return 0;

     

       990
       990
       +
       }

     

       991
       991
       +
       

     

       992
       992
       +
       int mk_wcwidth(uint32_t ucs) {

     

       993
       993
       +
         /* sorted list of non-overlapping intervals of non-spacing characters */

     

       994
       994
       +
         /* generated by "uniset +cat=Me +cat=Mn +cat=Cf -00AD +1160-11FF +200B c" */

     

       995
       995
       +
         static const struct interval combining[] = {

     

       996
       996
       +
           { 0x0300, 0x036F }, { 0x0483, 0x0486 }, { 0x0488, 0x0489 },

     

       997
       997
       +
           { 0x0591, 0x05BD }, { 0x05BF, 0x05BF }, { 0x05C1, 0x05C2 },

     

       998
       998
       +
           { 0x05C4, 0x05C5 }, { 0x05C7, 0x05C7 }, { 0x0600, 0x0603 },

     

       999
       999
       +
           { 0x0610, 0x0615 }, { 0x064B, 0x065E }, { 0x0670, 0x0670 },

     

       1000
       1000
       +
           { 0x06D6, 0x06E4 }, { 0x06E7, 0x06E8 }, { 0x06EA, 0x06ED },

     

       1001
       1001
       +
           { 0x070F, 0x070F }, { 0x0711, 0x0711 }, { 0x0730, 0x074A },

     

       1002
       1002
       +
           { 0x07A6, 0x07B0 }, { 0x07EB, 0x07F3 }, { 0x0901, 0x0902 },

     

       1003
       1003
       +
           { 0x093C, 0x093C }, { 0x0941, 0x0948 }, { 0x094D, 0x094D },

     

       1004
       1004
       +
           { 0x0951, 0x0954 }, { 0x0962, 0x0963 }, { 0x0981, 0x0981 },

     

       1005
       1005
       +
           { 0x09BC, 0x09BC }, { 0x09C1, 0x09C4 }, { 0x09CD, 0x09CD },

     

       1006
       1006
       +
           { 0x09E2, 0x09E3 }, { 0x0A01, 0x0A02 }, { 0x0A3C, 0x0A3C },

     

       1007
       1007
       +
           { 0x0A41, 0x0A42 }, { 0x0A47, 0x0A48 }, { 0x0A4B, 0x0A4D },

     

       1008
       1008
       +
           { 0x0A70, 0x0A71 }, { 0x0A81, 0x0A82 }, { 0x0ABC, 0x0ABC },

     

       1009
       1009
       +
           { 0x0AC1, 0x0AC5 }, { 0x0AC7, 0x0AC8 }, { 0x0ACD, 0x0ACD },

     

       1010
       1010
       +
           { 0x0AE2, 0x0AE3 }, { 0x0B01, 0x0B01 }, { 0x0B3C, 0x0B3C },

     

       1011
       1011
       +
           { 0x0B3F, 0x0B3F }, { 0x0B41, 0x0B43 }, { 0x0B4D, 0x0B4D },

     

       1012
       1012
       +
           { 0x0B56, 0x0B56 }, { 0x0B82, 0x0B82 }, { 0x0BC0, 0x0BC0 },

     

       1013
       1013
       +
           { 0x0BCD, 0x0BCD }, { 0x0C3E, 0x0C40 }, { 0x0C46, 0x0C48 },

     

       1014
       1014
       +
           { 0x0C4A, 0x0C4D }, { 0x0C55, 0x0C56 }, { 0x0CBC, 0x0CBC },

     

       1015
       1015
       +
           { 0x0CBF, 0x0CBF }, { 0x0CC6, 0x0CC6 }, { 0x0CCC, 0x0CCD },

     

       1016
       1016
       +
           { 0x0CE2, 0x0CE3 }, { 0x0D41, 0x0D43 }, { 0x0D4D, 0x0D4D },

     

       1017
       1017
       +
           { 0x0DCA, 0x0DCA }, { 0x0DD2, 0x0DD4 }, { 0x0DD6, 0x0DD6 },

     

       1018
       1018
       +
           { 0x0E31, 0x0E31 }, { 0x0E34, 0x0E3A }, { 0x0E47, 0x0E4E },

     

       1019
       1019
       +
           { 0x0EB1, 0x0EB1 }, { 0x0EB4, 0x0EB9 }, { 0x0EBB, 0x0EBC },

     

       1020
       1020
       +
           { 0x0EC8, 0x0ECD }, { 0x0F18, 0x0F19 }, { 0x0F35, 0x0F35 },

     

       1021
       1021
       +
           { 0x0F37, 0x0F37 }, { 0x0F39, 0x0F39 }, { 0x0F71, 0x0F7E },

     

       1022
       1022
       +
           { 0x0F80, 0x0F84 }, { 0x0F86, 0x0F87 }, { 0x0F90, 0x0F97 },

     

       1023
       1023
       +
           { 0x0F99, 0x0FBC }, { 0x0FC6, 0x0FC6 }, { 0x102D, 0x1030 },

     

       1024
       1024
       +
           { 0x1032, 0x1032 }, { 0x1036, 0x1037 }, { 0x1039, 0x1039 },

     

       1025
       1025
       +
           { 0x1058, 0x1059 }, { 0x1160, 0x11FF }, { 0x135F, 0x135F },

     

       1026
       1026
       +
           { 0x1712, 0x1714 }, { 0x1732, 0x1734 }, { 0x1752, 0x1753 },

     

       1027
       1027
       +
           { 0x1772, 0x1773 }, { 0x17B4, 0x17B5 }, { 0x17B7, 0x17BD },

     

       1028
       1028
       +
           { 0x17C6, 0x17C6 }, { 0x17C9, 0x17D3 }, { 0x17DD, 0x17DD },

     

       1029
       1029
       +
           { 0x180B, 0x180D }, { 0x18A9, 0x18A9 }, { 0x1920, 0x1922 },

     

       1030
       1030
       +
           { 0x1927, 0x1928 }, { 0x1932, 0x1932 }, { 0x1939, 0x193B },

     

       1031
       1031
       +
           { 0x1A17, 0x1A18 }, { 0x1B00, 0x1B03 }, { 0x1B34, 0x1B34 },

     

       1032
       1032
       +
           { 0x1B36, 0x1B3A }, { 0x1B3C, 0x1B3C }, { 0x1B42, 0x1B42 },

     

       1033
       1033
       +
           { 0x1B6B, 0x1B73 }, { 0x1DC0, 0x1DCA }, { 0x1DFE, 0x1DFF },

     

       1034
       1034
       +
           { 0x200B, 0x200F }, { 0x202A, 0x202E }, { 0x2060, 0x2063 },

     

       1035
       1035
       +
           { 0x206A, 0x206F }, { 0x20D0, 0x20EF }, { 0x302A, 0x302F },

     

       1036
       1036
       +
           { 0x3099, 0x309A }, { 0xA806, 0xA806 }, { 0xA80B, 0xA80B },

     

       1037
       1037
       +
           { 0xA825, 0xA826 }, { 0xFB1E, 0xFB1E }, { 0xFE00, 0xFE0F },

     

       1038
       1038
       +
           { 0xFE20, 0xFE23 }, { 0xFEFF, 0xFEFF }, { 0xFFF9, 0xFFFB },

     

       1039
       1039
       +
           { 0x10A01, 0x10A03 }, { 0x10A05, 0x10A06 }, { 0x10A0C, 0x10A0F },

     

       1040
       1040
       +
           { 0x10A38, 0x10A3A }, { 0x10A3F, 0x10A3F }, { 0x1D167, 0x1D169 },

     

       1041
       1041
       +
           { 0x1D173, 0x1D182 }, { 0x1D185, 0x1D18B }, { 0x1D1AA, 0x1D1AD },

     

       1042
       1042
       +
           { 0x1D242, 0x1D244 }, { 0xE0001, 0xE0001 }, { 0xE0020, 0xE007F },

     

       1043
       1043
       +
           { 0xE0100, 0xE01EF }

     

       1044
       1044
       +
         };

     

       1045
       1045
       +
       

     

       1046
       1046
       +
         /* test for 8-bit control characters */

     

       1047
       1047
       +
         if (ucs == 0)

     

       1048
       1048
       +
           return 0;

     

       1049
       1049
       +
         if (ucs < 32 || (ucs >= 0x7f && ucs < 0xa0))

     

       1050
       1050
       +
           return 1;

     

       1051
       1051
       +
       

     

       1052
       1052
       +
         /* binary search in table of non-spacing characters */

     

       1053
       1053
       +
         if (bisearch(ucs, combining,

     

       1054
       1054
       +
       	       sizeof(combining) / sizeof(struct interval) - 1))

     

       1055
       1055
       +
           return 0;

     

       1056
       1056
       +
       

     

       1057
       1057
       +
         /* if we arrive here, ucs is not a combining or C0/C1 control character */

     

       1058
       1058
       +
       

     

       1059
       1059
       +
         return 1 +

     

       1060
       1060
       +
           (ucs >= 0x1100 &&

     

       1061
       1061
       +
            (ucs <= 0x115f ||                    /* Hangul Jamo init. consonants */

     

       1062
       1062
       +
             ucs == 0x2329 || ucs == 0x232a ||

     

       1063
       1063
       +
             (ucs >= 0x2e80 && ucs <= 0xa4cf &&

     

       1064
       1064
       +
              ucs != 0x303f) ||                  /* CJK ... Yi */

     

       1065
       1065
       +
             (ucs >= 0xac00 && ucs <= 0xd7a3) || /* Hangul Syllables */

     

       1066
       1066
       +
             (ucs >= 0xf900 && ucs <= 0xfaff) || /* CJK Compatibility Ideographs */

     

       1067
       1067
       +
             (ucs >= 0xfe10 && ucs <= 0xfe19) || /* Vertical forms */

     

       1068
       1068
       +
             (ucs >= 0xfe30 && ucs <= 0xfe6f) || /* CJK Compatibility Forms */

     

       1069
       1069
       +
             (ucs >= 0xff00 && ucs <= 0xff60) || /* Fullwidth Forms */

     

       1070
       1070
       +
             (ucs >= 0xffe0 && ucs <= 0xffe6) ||

     

       1071
       1071
       +
             (ucs >= 0x20000 && ucs <= 0x2fffd) ||

     

       1072
       1072
       +
             (ucs >= 0x30000 && ucs <= 0x3fffd)));

     

       1073
       1073
       +
       }

     

       1074
       1074
       +
       

     

       1075
       1075
       +
       // End of https://www.cl.cam.ac.uk/~mgk25/ucs/wcwidth.c inherited code

     

       1076
       1076
       +
       

     

       1077
       1077
       +
       static int unicode_to_cp437(uint64_t code_point) {

     

       1078
       1078
       +
           switch (code_point) {

     

       1079
       1079
       +
               case 0x263a: return 1;

     

       1080
       1080
       +
               case 0x263b: return 2;

     

       1081
       1081
       +
               case 0x2665: return 3;

     

       1082
       1082
       +
               case 0x2666: return 4;

     

       1083
       1083
       +
               case 0x2663: return 5;

     

       1084
       1084
       +
               case 0x2660: return 6;

     

       1085
       1085
       +
               case 0x2022: return 7;

     

       1086
       1086
       +
               case 0x25d8: return 8;

     

       1087
       1087
       +
               case 0x25cb: return 9;

     

       1088
       1088
       +
               case 0x25d9: return 10;

     

       1089
       1089
       +
               case 0x2642: return 11;

     

       1090
       1090
       +
               case 0x2640: return 12;

     

       1091
       1091
       +
               case 0x266a: return 13;

     

       1092
       1092
       +
               case 0x266b: return 14;

     

       1093
       1093
       +
               case 0x263c: return 15;

     

       1094
       1094
       +
               case 0x25ba: return 16;

     

       1095
       1095
       +
               case 0x25c4: return 17;

     

       1096
       1096
       +
               case 0x2195: return 18;

     

       1097
       1097
       +
               case 0x203c: return 19;

     

       1098
       1098
       +
               case 0x00b6: return 20;

     

       1099
       1099
       +
               case 0x00a7: return 21;

     

       1100
       1100
       +
               case 0x25ac: return 22;

     

       1101
       1101
       +
               case 0x21a8: return 23;

     

       1102
       1102
       +
               case 0x2191: return 24;

     

       1103
       1103
       +
               case 0x2193: return 25;

     

       1104
       1104
       +
               case 0x2192: return 26;

     

       1105
       1105
       +
               case 0x2190: return 27;

     

       1106
       1106
       +
               case 0x221f: return 28;

     

       1107
       1107
       +
               case 0x2194: return 29;

     

       1108
       1108
       +
               case 0x25b2: return 30;

     

       1109
       1109
       +
               case 0x25bc: return 31;

     

       1110
       1110
       +
       

     

       1111
       1111
       +
               case 0x2302: return 127;

     

       1112
       1112
       +
               case 0x00c7: return 128;

     

       1113
       1113
       +
               case 0x00fc: return 129;

     

       1114
       1114
       +
               case 0x00e9: return 130;

     

       1115
       1115
       +
               case 0x00e2: return 131;

     

       1116
       1116
       +
               case 0x00e4: return 132;

     

       1117
       1117
       +
               case 0x00e0: return 133;

     

       1118
       1118
       +
               case 0x00e5: return 134;

     

       1119
       1119
       +
               case 0x00e7: return 135;

     

       1120
       1120
       +
               case 0x00ea: return 136;

     

       1121
       1121
       +
               case 0x00eb: return 137;

     

       1122
       1122
       +
               case 0x00e8: return 138;

     

       1123
       1123
       +
               case 0x00ef: return 139;

     

       1124
       1124
       +
               case 0x00ee: return 140;

     

       1125
       1125
       +
               case 0x00ec: return 141;

     

       1126
       1126
       +
               case 0x00c4: return 142;

     

       1127
       1127
       +
               case 0x00c5: return 143;

     

       1128
       1128
       +
               case 0x00c9: return 144;

     

       1129
       1129
       +
               case 0x00e6: return 145;

     

       1130
       1130
       +
               case 0x00c6: return 146;

     

       1131
       1131
       +
               case 0x00f4: return 147;

     

       1132
       1132
       +
               case 0x00f6: return 148;

     

       1133
       1133
       +
               case 0x00f2: return 149;

     

       1134
       1134
       +
               case 0x00fb: return 150;

     

       1135
       1135
       +
               case 0x00f9: return 151;

     

       1136
       1136
       +
               case 0x00ff: return 152;

     

       1137
       1137
       +
               case 0x00d6: return 153;

     

       1138
       1138
       +
               case 0x00dc: return 154;

     

       1139
       1139
       +
               case 0x00a2: return 155;

     

       1140
       1140
       +
               case 0x00a3: return 156;

     

       1141
       1141
       +
               case 0x00a5: return 157;

     

       1142
       1142
       +
               case 0x20a7: return 158;

     

       1143
       1143
       +
               case 0x0192: return 159;

     

       1144
       1144
       +
               case 0x00e1: return 160;

     

       1145
       1145
       +
               case 0x00ed: return 161;

     

       1146
       1146
       +
               case 0x00f3: return 162;

     

       1147
       1147
       +
               case 0x00fa: return 163;

     

       1148
       1148
       +
               case 0x00f1: return 164;

     

       1149
       1149
       +
               case 0x00d1: return 165;

     

       1150
       1150
       +
               case 0x00aa: return 166;

     

       1151
       1151
       +
               case 0x00ba: return 167;

     

       1152
       1152
       +
               case 0x00bf: return 168;

     

       1153
       1153
       +
               case 0x2310: return 169;

     

       1154
       1154
       +
               case 0x00ac: return 170;

     

       1155
       1155
       +
               case 0x00bd: return 171;

     

       1156
       1156
       +
               case 0x00bc: return 172;

     

       1157
       1157
       +
               case 0x00a1: return 173;

     

       1158
       1158
       +
               case 0x00ab: return 174;

     

       1159
       1159
       +
               case 0x00bb: return 175;

     

       1160
       1160
       +
               case 0x2591: return 176;

     

       1161
       1161
       +
               case 0x2592: return 177;

     

       1162
       1162
       +
               case 0x2593: return 178;

     

       1163
       1163
       +
               case 0x2502: return 179;

     

       1164
       1164
       +
               case 0x2524: return 180;

     

       1165
       1165
       +
               case 0x2561: return 181;

     

       1166
       1166
       +
               case 0x2562: return 182;

     

       1167
       1167
       +
               case 0x2556: return 183;

     

       1168
       1168
       +
               case 0x2555: return 184;

     

       1169
       1169
       +
               case 0x2563: return 185;

     

       1170
       1170
       +
               case 0x2551: return 186;

     

       1171
       1171
       +
               case 0x2557: return 187;

     

       1172
       1172
       +
               case 0x255d: return 188;

     

       1173
       1173
       +
               case 0x255c: return 189;

     

       1174
       1174
       +
               case 0x255b: return 190;

     

       1175
       1175
       +
               case 0x2510: return 191;

     

       1176
       1176
       +
               case 0x2514: return 192;

     

       1177
       1177
       +
               case 0x2534: return 193;

     

       1178
       1178
       +
               case 0x252c: return 194;

     

       1179
       1179
       +
               case 0x251c: return 195;

     

       1180
       1180
       +
               case 0x2500: return 196;

     

       1181
       1181
       +
               case 0x253c: return 197;

     

       1182
       1182
       +
               case 0x255e: return 198;

     

       1183
       1183
       +
               case 0x255f: return 199;

     

       1184
       1184
       +
               case 0x255a: return 200;

     

       1185
       1185
       +
               case 0x2554: return 201;

     

       1186
       1186
       +
               case 0x2569: return 202;

     

       1187
       1187
       +
               case 0x2566: return 203;

     

       1188
       1188
       +
               case 0x2560: return 204;

     

       1189
       1189
       +
               case 0x2550: return 205;

     

       1190
       1190
       +
               case 0x256c: return 206;

     

       1191
       1191
       +
               case 0x2567: return 207;

     

       1192
       1192
       +
               case 0x2568: return 208;

     

       1193
       1193
       +
               case 0x2564: return 209;

     

       1194
       1194
       +
               case 0x2565: return 210;

     

       1195
       1195
       +
               case 0x2559: return 211;

     

       1196
       1196
       +
               case 0x2558: return 212;

     

       1197
       1197
       +
               case 0x2552: return 213;

     

       1198
       1198
       +
               case 0x2553: return 214;

     

       1199
       1199
       +
               case 0x256b: return 215;

     

       1200
       1200
       +
               case 0x256a: return 216;

     

       1201
       1201
       +
               case 0x2518: return 217;

     

       1202
       1202
       +
               case 0x250c: return 218;

     

       1203
       1203
       +
               case 0x2588: return 219;

     

       1204
       1204
       +
               case 0x2584: return 220;

     

       1205
       1205
       +
               case 0x258c: return 221;

     

       1206
       1206
       +
               case 0x2590: return 222;

     

       1207
       1207
       +
               case 0x2580: return 223;

     

       1208
       1208
       +
               case 0x03b1: return 224;

     

       1209
       1209
       +
               case 0x00df: return 225;

     

       1210
       1210
       +
               case 0x0393: return 226;

     

       1211
       1211
       +
               case 0x03c0: return 227;

     

       1212
       1212
       +
               case 0x03a3: return 228;

     

       1213
       1213
       +
               case 0x03c3: return 229;

     

       1214
       1214
       +
               case 0x00b5: return 230;

     

       1215
       1215
       +
               case 0x03c4: return 231;

     

       1216
       1216
       +
               case 0x03a6: return 232;

     

       1217
       1217
       +
               case 0x0398: return 233;

     

       1218
       1218
       +
               case 0x03a9: return 234;

     

       1219
       1219
       +
               case 0x03b4: return 235;

     

       1220
       1220
       +
               case 0x221e: return 236;

     

       1221
       1221
       +
               case 0x03c6: return 237;

     

       1222
       1222
       +
               case 0x03b5: return 238;

     

       1223
       1223
       +
               case 0x2229: return 239;

     

       1224
       1224
       +
               case 0x2261: return 240;

     

       1225
       1225
       +
               case 0x00b1: return 241;

     

       1226
       1226
       +
               case 0x2265: return 242;

     

       1227
       1227
       +
               case 0x2264: return 243;

     

       1228
       1228
       +
               case 0x2320: return 244;

     

       1229
       1229
       +
               case 0x2321: return 245;

     

       1230
       1230
       +
               case 0x00f7: return 246;

     

       1231
       1231
       +
               case 0x2248: return 247;

     

       1232
       1232
       +
               case 0x00b0: return 248;

     

       1233
       1233
       +
               case 0x2219: return 249;

     

       1234
       1234
       +
               case 0x00b7: return 250;

     

       1235
       1235
       +
               case 0x221a: return 251;

     

       1236
       1236
       +
               case 0x207f: return 252;

     

       1237
       1237
       +
               case 0x00b2: return 253;

     

       1238
       1238
       +
               case 0x25a0: return 254;

     

       1239
       1239
       +
           }

     

       1240
       1240
       +
       

     

       1241
       1241
       +
           return -1;

     

       1242
       1242
       +
       }

     

       1243
       1243
       +
       

     

       1244
       1244
       +
       static void flanterm_putchar(struct flanterm_context *ctx, uint8_t c) {

     

       1245
       1245
       +
           if (ctx->discard_next || (c == 0x18 || c == 0x1a)) {

     

       1246
       1246
       +
               ctx->discard_next = false;

     

       1247
       1247
       +
               ctx->escape = false;

     

       1248
       1248
       +
               ctx->control_sequence = false;

     

       1249
       1249
       +
               ctx->unicode_remaining = 0;

     

       1250
       1250
       +
               ctx->osc = false;

     

       1251
       1251
       +
               ctx->osc_escape = false;

     

       1252
       1252
       +
               ctx->g_select = 0;

     

       1253
       1253
       +
               return;

     

       1254
       1254
       +
           }

     

       1255
       1255
       +
       

     

       1256
       1256
       +
           if (ctx->unicode_remaining != 0) {

     

       1257
       1257
       +
               if ((c & 0xc0) != 0x80) {

     

       1258
       1258
       +
                   ctx->unicode_remaining = 0;

     

       1259
       1259
       +
                   goto unicode_error;

     

       1260
       1260
       +
               }

     

       1261
       1261
       +
       

     

       1262
       1262
       +
               ctx->unicode_remaining--;

     

       1263
       1263
       +
               ctx->code_point |= (uint64_t)(c & 0x3f) << (6 * ctx->unicode_remaining);

     

       1264
       1264
       +
               if (ctx->unicode_remaining != 0) {

     

       1265
       1265
       +
                   return;

     

       1266
       1266
       +
               }

     

       1267
       1267
       +
       

     

       1268
       1268
       +
               int cc = unicode_to_cp437(ctx->code_point);

     

       1269
       1269
       +
       

     

       1270
       1270
       +
               if (cc == -1) {

     

       1271
       1271
       +
                   size_t replacement_width = (size_t)mk_wcwidth(ctx->code_point);

     

       1272
       1272
       +
                   if (replacement_width > 0) {

     

       1273
       1273
       +
                       ctx->raw_putchar(ctx, 0xfe);

     

       1274
       1274
       +
                   }

     

       1275
       1275
       +
                   for (size_t i = 1; i < replacement_width; i++) {

     

       1276
       1276
       +
                       ctx->raw_putchar(ctx, ' ');

     

       1277
       1277
       +
                   }

     

       1278
       1278
       +
               } else {

     

       1279
       1279
       +
                   ctx->raw_putchar(ctx, cc);

     

       1280
       1280
       +
               }

     

       1281
       1281
       +
               return;

     

       1282
       1282
       +
           }

     

       1283
       1283
       +
       

     

       1284
       1284
       +
       unicode_error:

     

       1285
       1285
       +
           if (c >= 0xc0 && c <= 0xf7) {

     

       1286
       1286
       +
               if (c >= 0xc0 && c <= 0xdf) {

     

       1287
       1287
       +
                   ctx->unicode_remaining = 1;

     

       1288
       1288
       +
                   ctx->code_point = (uint64_t)(c & 0x1f) << 6;

     

       1289
       1289
       +
               } else if (c >= 0xe0 && c <= 0xef) {

     

       1290
       1290
       +
                   ctx->unicode_remaining = 2;

     

       1291
       1291
       +
                   ctx->code_point = (uint64_t)(c & 0x0f) << (6 * 2);

     

       1292
       1292
       +
               } else if (c >= 0xf0 && c <= 0xf7) {

     

       1293
       1293
       +
                   ctx->unicode_remaining = 3;

     

       1294
       1294
       +
                   ctx->code_point = (uint64_t)(c & 0x07) << (6 * 3);

     

       1295
       1295
       +
               }

     

       1296
       1296
       +
               return;

     

       1297
       1297
       +
           }

     

       1298
       1298
       +
       

     

       1299
       1299
       +
           if (ctx->escape == true) {

     

       1300
       1300
       +
               escape_parse(ctx, c);

     

       1301
       1301
       +
               return;

     

       1302
       1302
       +
           }

     

       1303
       1303
       +
       

     

       1304
       1304
       +
           if (ctx->g_select) {

     

       1305
       1305
       +
               ctx->g_select--;

     

       1306
       1306
       +
               switch (c) {

     

       1307
       1307
       +
                   case 'B':

     

       1308
       1308
       +
                       ctx->charsets[ctx->g_select] = CHARSET_DEFAULT; break;

     

       1309
       1309
       +
                   case '0':

     

       1310
       1310
       +
                       ctx->charsets[ctx->g_select] = CHARSET_DEC_SPECIAL; break;

     

       1311
       1311
       +
               }

     

       1312
       1312
       +
               ctx->g_select = 0;

     

       1313
       1313
       +
               return;

     

       1314
       1314
       +
           }

     

       1315
       1315
       +
       

     

       1316
       1316
       +
           size_t x, y;

     

       1317
       1317
       +
           ctx->get_cursor_pos(ctx, &x, &y);

     

       1318
       1318
       +
       

     

       1319
       1319
       +
           switch (c) {

     

       1320
       1320
       +
               case 0x00:

     

       1321
       1321
       +
               case 0x7f:

     

       1322
       1322
       +
                   return;

     

       1323
       1323
       +
               case 0x1b:

     

       1324
       1324
       +
                   ctx->escape_offset = 0;

     

       1325
       1325
       +
                   ctx->escape = true;

     

       1326
       1326
       +
                   return;

     

       1327
       1327
       +
               case '\t':

     

       1328
       1328
       +
                   if ((x / ctx->tab_size + 1) >= ctx->cols) {

     

       1329
       1329
       +
                       ctx->set_cursor_pos(ctx, ctx->cols - 1, y);

     

       1330
       1330
       +
                       return;

     

       1331
       1331
       +
                   }

     

       1332
       1332
       +
                   ctx->set_cursor_pos(ctx, (x / ctx->tab_size + 1) * ctx->tab_size, y);

     

       1333
       1333
       +
                   return;

     

       1334
       1334
       +
               case 0x0b:

     

       1335
       1335
       +
               case 0x0c:

     

       1336
       1336
       +
               case '\n':

     

       1337
       1337
       +
                   if (y == ctx->scroll_bottom_margin - 1) {

     

       1338
       1338
       +
                       ctx->scroll(ctx);

     

       1339
       1339
       +
                       ctx->set_cursor_pos(ctx, (ctx->oob_output & FLANTERM_OOB_OUTPUT_ONLCR) ? 0 : x, y);

     

       1340
       1340
       +
                   } else {

     

       1341
       1341
       +
                       ctx->set_cursor_pos(ctx, (ctx->oob_output & FLANTERM_OOB_OUTPUT_ONLCR) ? 0 : x, y + 1);

     

       1342
       1342
       +
                   }

     

       1343
       1343
       +
                   return;

     

       1344
       1344
       +
               case '\b':

     

       1345
       1345
       +
                   ctx->set_cursor_pos(ctx, x - 1, y);

     

       1346
       1346
       +
                   return;

     

       1347
       1347
       +
               case '\r':

     

       1348
       1348
       +
                   ctx->set_cursor_pos(ctx, 0, y);

     

       1349
       1349
       +
                   return;

     

       1350
       1350
       +
               case '\a':

     

       1351
       1351
       +
                   // The bell is handled by the kernel

     

       1352
       1352
       +
                   if (ctx->callback != NULL) {

     

       1353
       1353
       +
                       ctx->callback(ctx, FLANTERM_CB_BELL, 0, 0, 0);

     

       1354
       1354
       +
                   }

     

       1355
       1355
       +
                   return;

     

       1356
       1356
       +
               case 14:

     

       1357
       1357
       +
                   // Move to G1 set

     

       1358
       1358
       +
                   ctx->current_charset = 1;

     

       1359
       1359
       +
                   return;

     

       1360
       1360
       +
               case 15:

     

       1361
       1361
       +
                   // Move to G0 set

     

       1362
       1362
       +
                   ctx->current_charset = 0;

     

       1363
       1363
       +
                   return;

     

       1364
       1364
       +
           }

     

       1365
       1365
       +
       

     

       1366
       1366
       +
           if (ctx->insert_mode == true) {

     

       1367
       1367
       +
               for (size_t i = ctx->cols - 1; ; i--) {

     

       1368
       1368
       +
                   ctx->move_character(ctx, i + 1, y, i, y);

     

       1369
       1369
       +
                   if (i == x) {

     

       1370
       1370
       +
                       break;

     

       1371
       1371
       +
                   }

     

       1372
       1372
       +
               }

     

       1373
       1373
       +
           }

     

       1374
       1374
       +
       

     

       1375
       1375
       +
           // Translate character set

     

       1376
       1376
       +
           switch (ctx->charsets[ctx->current_charset]) {

     

       1377
       1377
       +
               case CHARSET_DEFAULT:

     

       1378
       1378
       +
                   break;

     

       1379
       1379
       +
               case CHARSET_DEC_SPECIAL:

     

       1380
       1380
       +
                   if (dec_special_print(ctx, c)) {

     

       1381
       1381
       +
                       return;

     

       1382
       1382
       +
                   }

     

       1383
       1383
       +
                   break;

     

       1384
       1384
       +
           }

     

       1385
       1385
       +
       

     

       1386
       1386
       +
           if (c >= 0x20 && c <= 0x7e) {

     

       1387
       1387
       +
               ctx->raw_putchar(ctx, c);

     

       1388
       1388
       +
           } else {

     

       1389
       1389
       +
               ctx->raw_putchar(ctx, 0xfe);

     

       1390
       1390
       +
           }

     

       1391
       1391
       +
       }

     

       1392
       1392
       +
       

     

       1393
       1393
       +
       void flanterm_flush(struct flanterm_context *ctx) {

     

       1394
       1394
       +
           ctx->double_buffer_flush(ctx);

     

       1395
       1395
       +
       }

     

       1396
       1396
       +
       

     

       1397
       1397
       +
       void flanterm_full_refresh(struct flanterm_context *ctx) {

     

       1398
       1398
       +
           ctx->full_refresh(ctx);

     

       1399
       1399
       +
       }

     

       1400
       1400
       +
       

     

       1401
       1401
       +
       void flanterm_deinit(struct flanterm_context *ctx, void (*_free)(void *, size_t)) {

     

       1402
       1402
       +
           ctx->deinit(ctx, _free);

     

       1403
       1403
       +
       }

     

       1404
       1404
       +
       

     

       1405
       1405
       +
       void flanterm_get_dimensions(struct flanterm_context *ctx, size_t *cols, size_t *rows) {

     

       1406
       1406
       +
           *cols = ctx->cols;

     

       1407
       1407
       +
           *rows = ctx->rows;

     

       1408
       1408
       +
       }

     

       1409
       1409
       +
       

     

       1410
       1410
       +
       void flanterm_set_autoflush(struct flanterm_context *ctx, bool state) {

     

       1411
       1411
       +
           ctx->autoflush = state;

     

       1412
       1412
       +
       }

     

       1413
       1413
       +
       

     

       1414
       1414
       +
       void flanterm_set_callback(struct flanterm_context *ctx, void (*callback)(struct flanterm_context *, uint64_t, uint64_t, uint64_t, uint64_t)) {

     

       1415
       1415
       +
           ctx->callback = callback;

     

       1416
       1416
       +
       }

     

       1417
       1417
       +
       

     

       1418
       1418
       +
       uint64_t flanterm_get_oob_output(struct flanterm_context *ctx) {

     

       1419
       1419
       +
           return ctx->oob_output;

     

       1420
       1420
       +
       }

     

       1421
       1421
       +
       

     

       1422
       1422
       +
       void flanterm_set_oob_output(struct flanterm_context *ctx, uint64_t oob_output) {

     

       1423
       1423
       +
           ctx->oob_output = oob_output;

     

       1424
       1424
       +
       }

+80

src/flanterm.h

···

       1
       1
       +
       /* Copyright (C) 2022-2025 mintsuki and contributors.

     

       2
       2
       +
        *

     

       3
       3
       +
        * Redistribution and use in source and binary forms, with or without

     

       4
       4
       +
        * modification, are permitted provided that the following conditions are met:

     

       5
       5
       +
        *

     

       6
       6
       +
        * 1. Redistributions of source code must retain the above copyright notice,

     

       7
       7
       +
        *    this list of conditions and the following disclaimer.

     

       8
       8
       +
        *

     

       9
       9
       +
        * 2. Redistributions in binary form must reproduce the above copyright notice,

     

       10
       10
       +
        *    this list of conditions and the following disclaimer in the documentation

     

       11
       11
       +
        *    and/or other materials provided with the distribution.

     

       12
       12
       +
        *

     

       13
       13
       +
        * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

     

       14
       14
       +
        * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

     

       15
       15
       +
        * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

     

       16
       16
       +
        * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE

     

       17
       17
       +
        * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

     

       18
       18
       +
        * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

     

       19
       19
       +
        * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

     

       20
       20
       +
        * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

     

       21
       21
       +
        * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

     

       22
       22
       +
        * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

     

       23
       23
       +
        * POSSIBILITY OF SUCH DAMAGE.

     

       24
       24
       +
        */

     

       25
       25
       +
       

     

       26
       26
       +
       #ifndef FLANTERM_H

     

       27
       27
       +
       #define FLANTERM_H 1

     

       28
       28
       +
       

     

       29
       29
       +
       #include <stddef.h>

     

       30
       30
       +
       #include <stdint.h>

     

       31
       31
       +
       #include <stdbool.h>

     

       32
       32
       +
       

     

       33
       33
       +
       #ifdef __cplusplus

     

       34
       34
       +
       extern "C" {

     

       35
       35
       +
       #endif

     

       36
       36
       +
       

     

       37
       37
       +
       #define FLANTERM_CB_DEC 10

     

       38
       38
       +
       #define FLANTERM_CB_BELL 20

     

       39
       39
       +
       #define FLANTERM_CB_PRIVATE_ID 30

     

       40
       40
       +
       #define FLANTERM_CB_STATUS_REPORT 40

     

       41
       41
       +
       #define FLANTERM_CB_POS_REPORT 50

     

       42
       42
       +
       #define FLANTERM_CB_KBD_LEDS 60

     

       43
       43
       +
       #define FLANTERM_CB_MODE 70

     

       44
       44
       +
       #define FLANTERM_CB_LINUX 80

     

       45
       45
       +
       

     

       46
       46
       +
       #define FLANTERM_OOB_OUTPUT_OCRNL (1 << 0)

     

       47
       47
       +
       #define FLANTERM_OOB_OUTPUT_OFDEL (1 << 1)

     

       48
       48
       +
       #define FLANTERM_OOB_OUTPUT_OFILL (1 << 2)

     

       49
       49
       +
       #define FLANTERM_OOB_OUTPUT_OLCUC (1 << 3)

     

       50
       50
       +
       #define FLANTERM_OOB_OUTPUT_ONLCR (1 << 4)

     

       51
       51
       +
       #define FLANTERM_OOB_OUTPUT_ONLRET (1 << 5)

     

       52
       52
       +
       #define FLANTERM_OOB_OUTPUT_ONOCR (1 << 6)

     

       53
       53
       +
       #define FLANTERM_OOB_OUTPUT_OPOST (1 << 7)

     

       54
       54
       +
       

     

       55
       55
       +
       #ifdef FLANTERM_IN_FLANTERM

     

       56
       56
       +
       

     

       57
       57
       +
       #include "flanterm_private.h"

     

       58
       58
       +
       

     

       59
       59
       +
       #else

     

       60
       60
       +
       

     

       61
       61
       +
       struct flanterm_context;

     

       62
       62
       +
       

     

       63
       63
       +
       #endif

     

       64
       64
       +
       

     

       65
       65
       +
       void flanterm_write(struct flanterm_context *ctx, const char *buf, size_t count);

     

       66
       66
       +
       void flanterm_flush(struct flanterm_context *ctx);

     

       67
       67
       +
       void flanterm_full_refresh(struct flanterm_context *ctx);

     

       68
       68
       +
       void flanterm_deinit(struct flanterm_context *ctx, void (*_free)(void *ptr, size_t size));

     

       69
       69
       +
       

     

       70
       70
       +
       void flanterm_get_dimensions(struct flanterm_context *ctx, size_t *cols, size_t *rows);

     

       71
       71
       +
       void flanterm_set_autoflush(struct flanterm_context *ctx, bool state);

     

       72
       72
       +
       void flanterm_set_callback(struct flanterm_context *ctx, void (*callback)(struct flanterm_context *, uint64_t, uint64_t, uint64_t, uint64_t));

     

       73
       73
       +
       uint64_t flanterm_get_oob_output(struct flanterm_context *ctx);

     

       74
       74
       +
       void flanterm_set_oob_output(struct flanterm_context *ctx, uint64_t oob_output);

     

       75
       75
       +
       

     

       76
       76
       +
       #ifdef __cplusplus

     

       77
       77
       +
       }

     

       78
       78
       +
       #endif

     

       79
       79
       +
       

     

       80
       80
       +
       #endif

+1254

src/flanterm_backends/fb.c

···

       1
       1
       +
       /* Copyright (C) 2022-2025 mintsuki and contributors.

     

       2
       2
       +
        *

     

       3
       3
       +
        * Redistribution and use in source and binary forms, with or without

     

       4
       4
       +
        * modification, are permitted provided that the following conditions are met:

     

       5
       5
       +
        *

     

       6
       6
       +
        * 1. Redistributions of source code must retain the above copyright notice,

     

       7
       7
       +
        *    this list of conditions and the following disclaimer.

     

       8
       8
       +
        *

     

       9
       9
       +
        * 2. Redistributions in binary form must reproduce the above copyright notice,

     

       10
       10
       +
        *    this list of conditions and the following disclaimer in the documentation

     

       11
       11
       +
        *    and/or other materials provided with the distribution.

     

       12
       12
       +
        *

     

       13
       13
       +
        * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

     

       14
       14
       +
        * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

     

       15
       15
       +
        * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

     

       16
       16
       +
        * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE

     

       17
       17
       +
        * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

     

       18
       18
       +
        * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

     

       19
       19
       +
        * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

     

       20
       20
       +
        * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

     

       21
       21
       +
        * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

     

       22
       22
       +
        * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

     

       23
       23
       +
        * POSSIBILITY OF SUCH DAMAGE.

     

       24
       24
       +
        */

     

       25
       25
       +
       

     

       26
       26
       +
       #ifdef __cplusplus

     

       27
       27
       +
       #error "Please do not compile Flanterm as C++ code! Flanterm should be compiled as C99 or newer."

     

       28
       28
       +
       #endif

     

       29
       29
       +
       

     

       30
       30
       +
       #ifndef __STDC_VERSION__

     

       31
       31
       +
       #error "Flanterm must be compiled as C99 or newer."

     

       32
       32
       +
       #endif

     

       33
       33
       +
       

     

       34
       34
       +
       #if defined(_MSC_VER)

     

       35
       35
       +
       #define ALWAYS_INLINE __forceinline

     

       36
       36
       +
       #elif defined(__GNUC__) || defined(__clang__)

     

       37
       37
       +
       #define ALWAYS_INLINE __attribute__((always_inline)) inline

     

       38
       38
       +
       #else

     

       39
       39
       +
       #define ALWAYS_INLINE inline

     

       40
       40
       +
       #endif

     

       41
       41
       +
       

     

       42
       42
       +
       #include <stdint.h>

     

       43
       43
       +
       #include <stddef.h>

     

       44
       44
       +
       #include <stdbool.h>

     

       45
       45
       +
       

     

       46
       46
       +
       #ifndef FLANTERM_IN_FLANTERM

     

       47
       47
       +
       #define FLANTERM_IN_FLANTERM

     

       48
       48
       +
       #endif

     

       49
       49
       +
       

     

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

     

       51
       51
       +
       #include "fb.h"

     

       52
       52
       +
       

     

       53
       53
       +
       void *memset(void *, int, size_t);

     

       54
       54
       +
       void *memcpy(void *, const void *, size_t);

     

       55
       55
       +
       

     

       56
       56
       +
       #ifndef FLANTERM_FB_DISABLE_BUMP_ALLOC

     

       57
       57
       +
       

     

       58
       58
       +
       #ifndef FLANTERM_FB_BUMP_ALLOC_POOL_SIZE

     

       59
       59
       +
       #define FLANTERM_FB_BUMP_ALLOC_POOL_SIZE 873000

     

       60
       60
       +
       

     

       61
       61
       +
       #define FLANTERM_FB_WIDTH_LIMIT 1920

     

       62
       62
       +
       #define FLANTERM_FB_HEIGHT_LIMIT 1200

     

       63
       63
       +
       #endif

     

       64
       64
       +
       

     

       65
       65
       +
       static uint8_t bump_alloc_pool[FLANTERM_FB_BUMP_ALLOC_POOL_SIZE];

     

       66
       66
       +
       static size_t bump_alloc_ptr = 0;

     

       67
       67
       +
       

     

       68
       68
       +
       static void *bump_alloc(size_t s) {

     

       69
       69
       +
           static bool base_offset_added = false;

     

       70
       70
       +
           if (!base_offset_added) {

     

       71
       71
       +
               if ((uintptr_t)bump_alloc_pool & 0xf) {

     

       72
       72
       +
                   bump_alloc_ptr += 0x10 - ((uintptr_t)bump_alloc_pool & 0xf);

     

       73
       73
       +
               }

     

       74
       74
       +
               base_offset_added = true;

     

       75
       75
       +
           }

     

       76
       76
       +
       

     

       77
       77
       +
           if ((s & 0xf) != 0) {

     

       78
       78
       +
               s += 0x10;

     

       79
       79
       +
               s &= ~(size_t)0xf;

     

       80
       80
       +
           }

     

       81
       81
       +
       

     

       82
       82
       +
           size_t next_ptr = bump_alloc_ptr + s;

     

       83
       83
       +
           if (next_ptr > FLANTERM_FB_BUMP_ALLOC_POOL_SIZE) {

     

       84
       84
       +
               return NULL;

     

       85
       85
       +
           }

     

       86
       86
       +
           void *ret = &bump_alloc_pool[bump_alloc_ptr];

     

       87
       87
       +
           bump_alloc_ptr = next_ptr;

     

       88
       88
       +
           return ret;

     

       89
       89
       +
       }

     

       90
       90
       +
       

     

       91
       91
       +
       static bool bump_allocated_instance = false;

     

       92
       92
       +
       

     

       93
       93
       +
       #endif

     

       94
       94
       +
       

     

       95
       95
       +
       // Builtin font originally taken from:

     

       96
       96
       +
       // https://github.com/viler-int10h/vga-text-mode-fonts/raw/master/FONTS/PC-OTHER/TOSH-SAT.F16

     

       97
       97
       +
       static const uint8_t builtin_font[] = {

     

       98
       98
       +
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       99
       99
       +
         0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x42, 0x81, 0x81, 0xa5, 0xa5, 0x81,

     

       100
       100
       +
         0x81, 0xa5, 0x99, 0x81, 0x42, 0x3c, 0x00, 0x00, 0x00, 0x3c, 0x7e, 0xff,

     

       101
       101
       +
         0xff, 0xdb, 0xdb, 0xff, 0xff, 0xdb, 0xe7, 0xff, 0x7e, 0x3c, 0x00, 0x00,

     

       102
       102
       +
         0x00, 0x00, 0x00, 0x6c, 0xfe, 0xfe, 0xfe, 0x7c, 0x7c, 0x38, 0x38, 0x10,

     

       103
       103
       +
         0x10, 0x00, 0x00, 0x00, 0x00, 0x10, 0x10, 0x38, 0x38, 0x7c, 0x7c, 0xfe,

     

       104
       104
       +
         0x7c, 0x7c, 0x38, 0x38, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18,

     

       105
       105
       +
         0x3c, 0x3c, 0xdb, 0xff, 0xff, 0xdb, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00,

     

       106
       106
       +
         0x00, 0x00, 0x00, 0x18, 0x3c, 0x7e, 0xff, 0xff, 0xff, 0x66, 0x18, 0x18,

     

       107
       107
       +
         0x3c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x78,

     

       108
       108
       +
         0x78, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,

     

       109
       109
       +
         0xff, 0xff, 0xe7, 0xc3, 0xc3, 0xe7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,

     

       110
       110
       +
         0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0xcc, 0x84, 0x84, 0xcc, 0x78, 0x00,

     

       111
       111
       +
         0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc3, 0x99, 0xbd,

     

       112
       112
       +
         0xbd, 0x99, 0xc3, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x1e,

     

       113
       113
       +
         0x0e, 0x1e, 0x32, 0x78, 0xcc, 0xcc, 0xcc, 0x78, 0x00, 0x00, 0x00, 0x00,

     

       114
       114
       +
         0x00, 0x00, 0x00, 0x78, 0xcc, 0xcc, 0xcc, 0x78, 0x30, 0xfc, 0x30, 0x30,

     

       115
       115
       +
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x18, 0x1c, 0x1e, 0x16, 0x12,

     

       116
       116
       +
         0x10, 0x10, 0x70, 0xf0, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x30, 0x38, 0x2c,

     

       117
       117
       +
         0x26, 0x32, 0x3a, 0x2e, 0x26, 0x22, 0x62, 0xe2, 0xc6, 0x0e, 0x0c, 0x00,

     

       118
       118
       +
         0x00, 0x00, 0x00, 0x18, 0x18, 0xdb, 0x3c, 0xe7, 0x3c, 0xdb, 0x18, 0x18,

     

       119
       119
       +
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xc0, 0xe0, 0xf8, 0xfe,

     

       120
       120
       +
         0xf8, 0xe0, 0xc0, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,

     

       121
       121
       +
         0x06, 0x0e, 0x3e, 0xfe, 0x3e, 0x0e, 0x06, 0x02, 0x00, 0x00, 0x00, 0x00,

     

       122
       122
       +
         0x00, 0x00, 0x30, 0x78, 0xfc, 0x30, 0x30, 0x30, 0x30, 0x30, 0xfc, 0x78,

     

       123
       123
       +
         0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,

     

       124
       124
       +
         0xcc, 0xcc, 0x00, 0xcc, 0xcc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7f, 0xdb,

     

       125
       125
       +
         0xdb, 0xdb, 0xdb, 0x7b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x00, 0x00, 0x00,

     

       126
       126
       +
         0x00, 0x00, 0x7c, 0xc6, 0x60, 0x38, 0x6c, 0xc6, 0xc6, 0x6c, 0x38, 0x0c,

     

       127
       127
       +
         0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       128
       128
       +
         0x00, 0x00, 0xfe, 0xfe, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x78,

     

       129
       129
       +
         0xfc, 0x30, 0x30, 0x30, 0x30, 0x30, 0xfc, 0x78, 0x30, 0xfc, 0x00, 0x00,

     

       130
       130
       +
         0x00, 0x00, 0x30, 0x78, 0xfc, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,

     

       131
       131
       +
         0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,

     

       132
       132
       +
         0x30, 0x30, 0xfc, 0x78, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       133
       133
       +
         0x00, 0x18, 0x0c, 0xfe, 0xfe, 0x0c, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       134
       134
       +
         0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x60, 0xfe, 0xfe, 0x60, 0x30, 0x00,

     

       135
       135
       +
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0,

     

       136
       136
       +
         0xc0, 0xc0, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       137
       137
       +
         0x00, 0x24, 0x66, 0xff, 0xff, 0x66, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       138
       138
       +
         0x00, 0x00, 0x00, 0x00, 0x10, 0x10, 0x38, 0x38, 0x7c, 0x7c, 0xfe, 0xfe,

     

       139
       139
       +
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xfe, 0x7c, 0x7c,

     

       140
       140
       +
         0x38, 0x38, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       141
       141
       +
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       142
       142
       +
         0x00, 0x00, 0x30, 0x78, 0x78, 0x78, 0x78, 0x30, 0x30, 0x30, 0x00, 0x30,

     

       143
       143
       +
         0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0x00,

     

       144
       144
       +
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6c, 0x6c,

     

       145
       145
       +
         0x6c, 0xfe, 0x6c, 0x6c, 0x6c, 0xfe, 0x6c, 0x6c, 0x6c, 0x00, 0x00, 0x00,

     

       146
       146
       +
         0x00, 0x18, 0x18, 0x7c, 0xc6, 0xc0, 0xc0, 0x7c, 0x06, 0x06, 0xc6, 0x7c,

     

       147
       147
       +
         0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0xc6, 0xc6, 0x0c, 0x0c, 0x18, 0x38,

     

       148
       148
       +
         0x30, 0x60, 0x60, 0xc6, 0xc6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x6c,

     

       149
       149
       +
         0x6c, 0x38, 0x30, 0x76, 0xde, 0xcc, 0xcc, 0xde, 0x76, 0x00, 0x00, 0x00,

     

       150
       150
       +
         0x00, 0x00, 0x18, 0x18, 0x18, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       151
       151
       +
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x30, 0x60, 0x60, 0x60, 0x60,

     

       152
       152
       +
         0x60, 0x60, 0x60, 0x30, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x30,

     

       153
       153
       +
         0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x30, 0x60, 0x00, 0x00, 0x00,

     

       154
       154
       +
         0x00, 0x00, 0x00, 0x00, 0x00, 0x6c, 0x38, 0xfe, 0x38, 0x6c, 0x00, 0x00,

     

       155
       155
       +
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x7e,

     

       156
       156
       +
         0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       157
       157
       +
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x30, 0x00, 0x00,

     

       158
       158
       +
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x00, 0x00, 0x00, 0x00,

     

       159
       159
       +
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       160
       160
       +
         0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x06,

     

       161
       161
       +
         0x0c, 0x0c, 0x18, 0x38, 0x30, 0x60, 0x60, 0xc0, 0xc0, 0x00, 0x00, 0x00,

     

       162
       162
       +
         0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xd6, 0xd6, 0xd6, 0xc6, 0xc6, 0xc6,

     

       163
       163
       +
         0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x38, 0x78, 0x18, 0x18, 0x18,

     

       164
       164
       +
         0x18, 0x18, 0x18, 0x18, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6,

     

       165
       165
       +
         0x06, 0x06, 0x0c, 0x18, 0x30, 0x60, 0xc0, 0xc0, 0xfe, 0x00, 0x00, 0x00,

     

       166
       166
       +
         0x00, 0x00, 0x7c, 0xc6, 0x06, 0x06, 0x3c, 0x06, 0x06, 0x06, 0x06, 0xc6,

     

       167
       167
       +
         0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x0c, 0x1c, 0x3c, 0x6c, 0xcc,

     

       168
       168
       +
         0xfe, 0x0c, 0x0c, 0x0c, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xc0,

     

       169
       169
       +
         0xc0, 0xc0, 0xfc, 0x06, 0x06, 0x06, 0x06, 0xc6, 0x7c, 0x00, 0x00, 0x00,

     

       170
       170
       +
         0x00, 0x00, 0x3c, 0x60, 0xc0, 0xc0, 0xfc, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6,

     

       171
       171
       +
         0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xc6, 0x06, 0x06, 0x0c, 0x18,

     

       172
       172
       +
         0x30, 0x30, 0x30, 0x30, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6,

     

       173
       173
       +
         0xc6, 0xc6, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00,

     

       174
       174
       +
         0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0x7e, 0x06, 0x06, 0x06, 0x0c,

     

       175
       175
       +
         0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18,

     

       176
       176
       +
         0x18, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       177
       177
       +
         0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x18, 0x18, 0x30, 0x00, 0x00,

     

       178
       178
       +
         0x00, 0x00, 0x06, 0x0c, 0x18, 0x30, 0x60, 0xc0, 0x60, 0x30, 0x18, 0x0c,

     

       179
       179
       +
         0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x00,

     

       180
       180
       +
         0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x60,

     

       181
       181
       +
         0x30, 0x18, 0x0c, 0x06, 0x0c, 0x18, 0x30, 0x60, 0xc0, 0x00, 0x00, 0x00,

     

       182
       182
       +
         0x00, 0x00, 0x7c, 0xc6, 0xc6, 0x06, 0x0c, 0x18, 0x30, 0x30, 0x00, 0x30,

     

       183
       183
       +
         0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xde, 0xde,

     

       184
       184
       +
         0xde, 0xde, 0xc0, 0xc0, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x6c,

     

       185
       185
       +
         0xc6, 0xc6, 0xc6, 0xc6, 0xfe, 0xc6, 0xc6, 0xc6, 0xc6, 0x00, 0x00, 0x00,

     

       186
       186
       +
         0x00, 0x00, 0xfc, 0xc6, 0xc6, 0xc6, 0xfc, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6,

     

       187
       187
       +
         0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6, 0xc0, 0xc0, 0xc0, 0xc0,

     

       188
       188
       +
         0xc0, 0xc0, 0xc0, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xcc,

     

       189
       189
       +
         0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xcc, 0xf8, 0x00, 0x00, 0x00,

     

       190
       190
       +
         0x00, 0x00, 0xfe, 0xc0, 0xc0, 0xc0, 0xfc, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0,

     

       191
       191
       +
         0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xc0, 0xc0, 0xc0, 0xfc, 0xc0,

     

       192
       192
       +
         0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6,

     

       193
       193
       +
         0xc0, 0xc0, 0xc0, 0xde, 0xc6, 0xc6, 0xc6, 0xc6, 0x7e, 0x00, 0x00, 0x00,

     

       194
       194
       +
         0x00, 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xfe, 0xc6, 0xc6, 0xc6, 0xc6,

     

       195
       195
       +
         0xc6, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x30, 0x30, 0x30, 0x30, 0x30,

     

       196
       196
       +
         0x30, 0x30, 0x30, 0x30, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1e, 0x0c,

     

       197
       197
       +
         0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0xcc, 0xcc, 0x78, 0x00, 0x00, 0x00,

     

       198
       198
       +
         0x00, 0x00, 0xc6, 0xc6, 0xcc, 0xd8, 0xf0, 0xe0, 0xf0, 0xd8, 0xcc, 0xc6,

     

       199
       199
       +
         0xc6, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0,

     

       200
       200
       +
         0xc0, 0xc0, 0xc0, 0xc0, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc6, 0xc6,

     

       201
       201
       +
         0xee, 0xfe, 0xd6, 0xd6, 0xd6, 0xc6, 0xc6, 0xc6, 0xc6, 0x00, 0x00, 0x00,

     

       202
       202
       +
         0x00, 0x00, 0xc6, 0xc6, 0xe6, 0xe6, 0xf6, 0xde, 0xce, 0xce, 0xc6, 0xc6,

     

       203
       203
       +
         0xc6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6,

     

       204
       204
       +
         0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xc6,

     

       205
       205
       +
         0xc6, 0xc6, 0xc6, 0xfc, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0x00, 0x00, 0x00,

     

       206
       206
       +
         0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xf6, 0xda,

     

       207
       207
       +
         0x6c, 0x06, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xc6, 0xc6, 0xc6, 0xc6, 0xfc,

     

       208
       208
       +
         0xd8, 0xcc, 0xcc, 0xc6, 0xc6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6,

     

       209
       209
       +
         0xc0, 0x60, 0x30, 0x18, 0x0c, 0x06, 0x06, 0xc6, 0x7c, 0x00, 0x00, 0x00,

     

       210
       210
       +
         0x00, 0x00, 0xff, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,

     

       211
       211
       +
         0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6,

     

       212
       212
       +
         0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc6, 0xc6,

     

       213
       213
       +
         0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x6c, 0x38, 0x10, 0x00, 0x00, 0x00,

     

       214
       214
       +
         0x00, 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xd6, 0xd6, 0xd6, 0xd6, 0xfe, 0x6c,

     

       215
       215
       +
         0x6c, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc6, 0xc6, 0xc6, 0x6c, 0x38, 0x38,

     

       216
       216
       +
         0x38, 0x6c, 0xc6, 0xc6, 0xc6, 0x00, 0x00, 0x00, 0x00, 0x00, 0xcc, 0xcc,

     

       217
       217
       +
         0xcc, 0xcc, 0xcc, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x00, 0x00, 0x00,

     

       218
       218
       +
         0x00, 0x00, 0xfe, 0x06, 0x06, 0x0c, 0x18, 0x30, 0x60, 0xc0, 0xc0, 0xc0,

     

       219
       219
       +
         0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0x60, 0x60, 0x60, 0x60, 0x60,

     

       220
       220
       +
         0x60, 0x60, 0x60, 0x60, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xc0,

     

       221
       221
       +
         0x60, 0x60, 0x30, 0x38, 0x18, 0x0c, 0x0c, 0x06, 0x06, 0x00, 0x00, 0x00,

     

       222
       222
       +
         0x00, 0x00, 0x78, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,

     

       223
       223
       +
         0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x38, 0x6c, 0xc6, 0x00, 0x00,

     

       224
       224
       +
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       225
       225
       +
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00,

     

       226
       226
       +
         0x00, 0x00, 0x18, 0x18, 0x18, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       227
       227
       +
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0x06, 0x06,

     

       228
       228
       +
         0x7e, 0xc6, 0xc6, 0xc6, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xc0,

     

       229
       229
       +
         0xc0, 0xdc, 0xe6, 0xc6, 0xc6, 0xc6, 0xc6, 0xe6, 0xdc, 0x00, 0x00, 0x00,

     

       230
       230
       +
         0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6, 0xc0, 0xc0, 0xc0, 0xc0, 0xc6,

     

       231
       231
       +
         0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x06, 0x06, 0x76, 0xce, 0xc6,

     

       232
       232
       +
         0xc6, 0xc6, 0xc6, 0xce, 0x76, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       233
       233
       +
         0x00, 0x7c, 0xc6, 0xc6, 0xfe, 0xc0, 0xc0, 0xc0, 0x7e, 0x00, 0x00, 0x00,

     

       234
       234
       +
         0x00, 0x00, 0x1c, 0x36, 0x30, 0x30, 0xfc, 0x30, 0x30, 0x30, 0x30, 0x30,

     

       235
       235
       +
         0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x76, 0xce, 0xc6,

     

       236
       236
       +
         0xc6, 0xc6, 0xce, 0x76, 0x06, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0xc0, 0xc0,

     

       237
       237
       +
         0xc0, 0xdc, 0xe6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x00, 0x00, 0x00,

     

       238
       238
       +
         0x00, 0x00, 0x18, 0x00, 0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,

     

       239
       239
       +
         0x3c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x1e, 0x06, 0x06,

     

       240
       240
       +
         0x06, 0x06, 0x06, 0x06, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0xc0, 0xc0,

     

       241
       241
       +
         0xc0, 0xc6, 0xcc, 0xd8, 0xf0, 0xf0, 0xd8, 0xcc, 0xc6, 0x00, 0x00, 0x00,

     

       242
       242
       +
         0x00, 0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,

     

       243
       243
       +
         0x3c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xec, 0xfe, 0xd6,

     

       244
       244
       +
         0xd6, 0xd6, 0xd6, 0xc6, 0xc6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       245
       245
       +
         0x00, 0xdc, 0xe6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x00, 0x00, 0x00,

     

       246
       246
       +
         0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6,

     

       247
       247
       +
         0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xdc, 0xe6, 0xc6,

     

       248
       248
       +
         0xc6, 0xc6, 0xe6, 0xdc, 0xc0, 0xc0, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       249
       249
       +
         0x00, 0x76, 0xce, 0xc6, 0xc6, 0xc6, 0xce, 0x76, 0x06, 0x06, 0x06, 0x00,

     

       250
       250
       +
         0x00, 0x00, 0x00, 0x00, 0x00, 0xdc, 0xe6, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0,

     

       251
       251
       +
         0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6, 0xc0,

     

       252
       252
       +
         0x70, 0x1c, 0x06, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x30,

     

       253
       253
       +
         0x30, 0xfe, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x1c, 0x00, 0x00, 0x00,

     

       254
       254
       +
         0x00, 0x00, 0x00, 0x00, 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6,

     

       255
       255
       +
         0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc6, 0xc6, 0xc6,

     

       256
       256
       +
         0xc6, 0xc6, 0x6c, 0x38, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       257
       257
       +
         0x00, 0xc6, 0xc6, 0xd6, 0xd6, 0xd6, 0xd6, 0xfe, 0x6c, 0x00, 0x00, 0x00,

     

       258
       258
       +
         0x00, 0x00, 0x00, 0x00, 0x00, 0xc6, 0xc6, 0x6c, 0x38, 0x38, 0x6c, 0xc6,

     

       259
       259
       +
         0xc6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc6, 0xc6, 0xc6,

     

       260
       260
       +
         0xc6, 0xc6, 0xce, 0x76, 0x06, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       261
       261
       +
         0x00, 0xfe, 0x06, 0x0c, 0x18, 0x30, 0x60, 0xc0, 0xfe, 0x00, 0x00, 0x00,

     

       262
       262
       +
         0x00, 0x00, 0x1c, 0x30, 0x30, 0x30, 0x30, 0xe0, 0x30, 0x30, 0x30, 0x30,

     

       263
       263
       +
         0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x30, 0x30, 0x30, 0x30, 0x00,

     

       264
       264
       +
         0x30, 0x30, 0x30, 0x30, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x30,

     

       265
       265
       +
         0x30, 0x30, 0x30, 0x1c, 0x30, 0x30, 0x30, 0x30, 0xe0, 0x00, 0x00, 0x00,

     

       266
       266
       +
         0x00, 0x00, 0x00, 0x76, 0xdc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       267
       267
       +
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x10, 0x38, 0x38, 0x6c,

     

       268
       268
       +
         0x6c, 0xc6, 0xc6, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x66,

     

       269
       269
       +
         0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0x66, 0x3c, 0x18, 0xcc, 0x78, 0x00,

     

       270
       270
       +
         0x00, 0x00, 0x6c, 0x6c, 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6,

     

       271
       271
       +
         0x7c, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x18, 0x30, 0x00, 0x7c, 0xc6, 0xc6,

     

       272
       272
       +
         0xfe, 0xc0, 0xc0, 0xc0, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x10, 0x38, 0x6c,

     

       273
       273
       +
         0x00, 0x7c, 0x06, 0x06, 0x7e, 0xc6, 0xc6, 0xc6, 0x7e, 0x00, 0x00, 0x00,

     

       274
       274
       +
         0x00, 0x00, 0x6c, 0x6c, 0x00, 0x7c, 0x06, 0x06, 0x7e, 0xc6, 0xc6, 0xc6,

     

       275
       275
       +
         0x7e, 0x00, 0x00, 0x00, 0x00, 0x60, 0x30, 0x18, 0x00, 0x7c, 0x06, 0x06,

     

       276
       276
       +
         0x7e, 0xc6, 0xc6, 0xc6, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x38, 0x6c, 0x38,

     

       277
       277
       +
         0x00, 0x7c, 0x06, 0x06, 0x7e, 0xc6, 0xc6, 0xc6, 0x7e, 0x00, 0x00, 0x00,

     

       278
       278
       +
         0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6, 0xc0, 0xc0, 0xc0, 0xc0, 0xc6,

     

       279
       279
       +
         0x7c, 0x18, 0x0c, 0x38, 0x00, 0x10, 0x38, 0x6c, 0x00, 0x7c, 0xc6, 0xc6,

     

       280
       280
       +
         0xfe, 0xc0, 0xc0, 0xc0, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6c, 0x6c,

     

       281
       281
       +
         0x00, 0x7c, 0xc6, 0xc6, 0xfe, 0xc0, 0xc0, 0xc0, 0x7e, 0x00, 0x00, 0x00,

     

       282
       282
       +
         0x00, 0x60, 0x30, 0x18, 0x00, 0x7c, 0xc6, 0xc6, 0xfe, 0xc0, 0xc0, 0xc0,

     

       283
       283
       +
         0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6c, 0x6c, 0x00, 0x38, 0x18, 0x18,

     

       284
       284
       +
         0x18, 0x18, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00, 0x00, 0x10, 0x38, 0x6c,

     

       285
       285
       +
         0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00,

     

       286
       286
       +
         0x00, 0x60, 0x30, 0x18, 0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,

     

       287
       287
       +
         0x3c, 0x00, 0x00, 0x00, 0xc6, 0xc6, 0x10, 0x38, 0x6c, 0xc6, 0xc6, 0xc6,

     

       288
       288
       +
         0xfe, 0xc6, 0xc6, 0xc6, 0xc6, 0x00, 0x00, 0x00, 0x38, 0x6c, 0x38, 0x00,

     

       289
       289
       +
         0x38, 0x6c, 0xc6, 0xc6, 0xc6, 0xfe, 0xc6, 0xc6, 0xc6, 0x00, 0x00, 0x00,

     

       290
       290
       +
         0x18, 0x30, 0x60, 0x00, 0xfe, 0xc0, 0xc0, 0xfc, 0xc0, 0xc0, 0xc0, 0xc0,

     

       291
       291
       +
         0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xec, 0x36, 0x36,

     

       292
       292
       +
         0x76, 0xde, 0xd8, 0xd8, 0x6e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1e, 0x3c,

     

       293
       293
       +
         0x6c, 0xcc, 0xcc, 0xfe, 0xcc, 0xcc, 0xcc, 0xcc, 0xce, 0x00, 0x00, 0x00,

     

       294
       294
       +
         0x00, 0x10, 0x38, 0x6c, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6,

     

       295
       295
       +
         0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6c, 0x6c, 0x00, 0x7c, 0xc6, 0xc6,

     

       296
       296
       +
         0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x60, 0x30, 0x18,

     

       297
       297
       +
         0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00,

     

       298
       298
       +
         0x00, 0x10, 0x38, 0x6c, 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6,

     

       299
       299
       +
         0x7c, 0x00, 0x00, 0x00, 0x00, 0x60, 0x30, 0x18, 0x00, 0xc6, 0xc6, 0xc6,

     

       300
       300
       +
         0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6c, 0x6c,

     

       301
       301
       +
         0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xce, 0x76, 0x06, 0xc6, 0x7c, 0x00,

     

       302
       302
       +
         0x6c, 0x6c, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6,

     

       303
       303
       +
         0x7c, 0x00, 0x00, 0x00, 0x6c, 0x6c, 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6,

     

       304
       304
       +
         0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30,

     

       305
       305
       +
         0x30, 0x78, 0xcc, 0xc0, 0xc0, 0xcc, 0x78, 0x30, 0x30, 0x00, 0x00, 0x00,

     

       306
       306
       +
         0x00, 0x00, 0x38, 0x6c, 0x60, 0x60, 0x60, 0xf8, 0x60, 0x60, 0x60, 0xe6,

     

       307
       307
       +
         0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0xcc, 0xcc, 0xcc, 0x78, 0x30, 0xfc,

     

       308
       308
       +
         0x30, 0xfc, 0x30, 0x30, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xcc,

     

       309
       309
       +
         0xcc, 0xf8, 0xc4, 0xcc, 0xde, 0xcc, 0xcc, 0xcc, 0xc6, 0x00, 0x00, 0x00,

     

       310
       310
       +
         0x00, 0x00, 0x0e, 0x1b, 0x18, 0x18, 0x18, 0x7e, 0x18, 0x18, 0x18, 0x18,

     

       311
       311
       +
         0x18, 0xd8, 0x70, 0x00, 0x00, 0x0c, 0x18, 0x30, 0x00, 0x7c, 0x06, 0x06,

     

       312
       312
       +
         0x7e, 0xc6, 0xc6, 0xc6, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x18, 0x30,

     

       313
       313
       +
         0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00,

     

       314
       314
       +
         0x00, 0x0c, 0x18, 0x30, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6,

     

       315
       315
       +
         0x7c, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x18, 0x30, 0x00, 0xc6, 0xc6, 0xc6,

     

       316
       316
       +
         0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x76, 0xdc, 0x00,

     

       317
       317
       +
         0x00, 0xdc, 0xe6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x00, 0x00, 0x00,

     

       318
       318
       +
         0x76, 0xdc, 0x00, 0xc6, 0xc6, 0xe6, 0xf6, 0xfe, 0xde, 0xce, 0xc6, 0xc6,

     

       319
       319
       +
         0xc6, 0x00, 0x00, 0x00, 0x00, 0x78, 0xd8, 0xd8, 0x6c, 0x00, 0xfc, 0x00,

     

       320
       320
       +
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x6c, 0x6c,

     

       321
       321
       +
         0x38, 0x00, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       322
       322
       +
         0x00, 0x00, 0x18, 0x18, 0x00, 0x18, 0x18, 0x30, 0x60, 0xc0, 0xc6, 0xc6,

     

       323
       323
       +
         0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       324
       324
       +
         0xfe, 0xc0, 0xc0, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       325
       325
       +
         0x00, 0x00, 0x00, 0x00, 0xfe, 0x06, 0x06, 0x06, 0x00, 0x00, 0x00, 0x00,

     

       326
       326
       +
         0x00, 0x00, 0xc0, 0xc2, 0xc6, 0xcc, 0xd8, 0x30, 0x60, 0xdc, 0x86, 0x0c,

     

       327
       327
       +
         0x18, 0x3e, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xc2, 0xc6, 0xcc, 0xd8, 0x30,

     

       328
       328
       +
         0x66, 0xce, 0x9e, 0x3e, 0x06, 0x06, 0x00, 0x00, 0x00, 0x00, 0x30, 0x30,

     

       329
       329
       +
         0x00, 0x30, 0x30, 0x30, 0x78, 0x78, 0x78, 0x78, 0x30, 0x00, 0x00, 0x00,

     

       330
       330
       +
         0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0x6c, 0xd8, 0x6c, 0x36, 0x00, 0x00,

     

       331
       331
       +
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xd8, 0x6c, 0x36,

     

       332
       332
       +
         0x6c, 0xd8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x88, 0x22, 0x88,

     

       333
       333
       +
         0x22, 0x88, 0x22, 0x88, 0x22, 0x88, 0x22, 0x88, 0x22, 0x88, 0x22, 0x88,

     

       334
       334
       +
         0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa,

     

       335
       335
       +
         0x55, 0xaa, 0x55, 0xaa, 0xdd, 0x77, 0xdd, 0x77, 0xdd, 0x77, 0xdd, 0x77,

     

       336
       336
       +
         0xdd, 0x77, 0xdd, 0x77, 0xdd, 0x77, 0xdd, 0x77, 0x18, 0x18, 0x18, 0x18,

     

       337
       337
       +
         0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,

     

       338
       338
       +
         0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xf8, 0xf8, 0x18, 0x18, 0x18,

     

       339
       339
       +
         0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xf8, 0xf8, 0x18,

     

       340
       340
       +
         0x18, 0xf8, 0xf8, 0x18, 0x18, 0x18, 0x18, 0x18, 0x36, 0x36, 0x36, 0x36,

     

       341
       341
       +
         0x36, 0x36, 0x36, 0xf6, 0xf6, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,

     

       342
       342
       +
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xfe, 0x36, 0x36, 0x36,

     

       343
       343
       +
         0x36, 0x36, 0x36, 0x36, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xf8, 0x18,

     

       344
       344
       +
         0x18, 0xf8, 0xf8, 0x18, 0x18, 0x18, 0x18, 0x18, 0x36, 0x36, 0x36, 0x36,

     

       345
       345
       +
         0x36, 0xf6, 0xf6, 0x06, 0x06, 0xf6, 0xf6, 0x36, 0x36, 0x36, 0x36, 0x36,

     

       346
       346
       +
         0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,

     

       347
       347
       +
         0x36, 0x36, 0x36, 0x36, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xfe, 0x06,

     

       348
       348
       +
         0x06, 0xf6, 0xf6, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,

     

       349
       349
       +
         0x36, 0xf6, 0xf6, 0x06, 0x06, 0xfe, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       350
       350
       +
         0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0xfe, 0xfe, 0x00, 0x00, 0x00,

     

       351
       351
       +
         0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x18, 0x18, 0x18, 0xf8, 0xf8, 0x18,

     

       352
       352
       +
         0x18, 0xf8, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       353
       353
       +
         0x00, 0x00, 0x00, 0xf8, 0xf8, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,

     

       354
       354
       +
         0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x1f, 0x1f, 0x00, 0x00, 0x00,

     

       355
       355
       +
         0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xff,

     

       356
       356
       +
         0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       357
       357
       +
         0x00, 0x00, 0x00, 0xff, 0xff, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,

     

       358
       358
       +
         0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x1f, 0x1f, 0x18, 0x18, 0x18,

     

       359
       359
       +
         0x18, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff,

     

       360
       360
       +
         0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x18, 0x18,

     

       361
       361
       +
         0x18, 0x18, 0x18, 0xff, 0xff, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,

     

       362
       362
       +
         0x18, 0x18, 0x18, 0x18, 0x18, 0x1f, 0x1f, 0x18, 0x18, 0x1f, 0x1f, 0x18,

     

       363
       363
       +
         0x18, 0x18, 0x18, 0x18, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x37,

     

       364
       364
       +
         0x37, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,

     

       365
       365
       +
         0x36, 0x37, 0x37, 0x30, 0x30, 0x3f, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       366
       366
       +
         0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x3f, 0x30, 0x30, 0x37, 0x37, 0x36,

     

       367
       367
       +
         0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0xf7, 0xf7, 0x00,

     

       368
       368
       +
         0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       369
       369
       +
         0x00, 0xff, 0xff, 0x00, 0x00, 0xf7, 0xf7, 0x36, 0x36, 0x36, 0x36, 0x36,

     

       370
       370
       +
         0x36, 0x36, 0x36, 0x36, 0x36, 0x37, 0x37, 0x30, 0x30, 0x37, 0x37, 0x36,

     

       371
       371
       +
         0x36, 0x36, 0x36, 0x36, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00,

     

       372
       372
       +
         0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0x36, 0x36, 0x36,

     

       373
       373
       +
         0x36, 0xf7, 0xf7, 0x00, 0x00, 0xf7, 0xf7, 0x36, 0x36, 0x36, 0x36, 0x36,

     

       374
       374
       +
         0x18, 0x18, 0x18, 0x18, 0x18, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00,

     

       375
       375
       +
         0x00, 0x00, 0x00, 0x00, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0xff,

     

       376
       376
       +
         0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       377
       377
       +
         0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x18, 0x18, 0x18, 0x18, 0x18,

     

       378
       378
       +
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x36, 0x36, 0x36,

     

       379
       379
       +
         0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x3f,

     

       380
       380
       +
         0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x18, 0x18,

     

       381
       381
       +
         0x18, 0x1f, 0x1f, 0x18, 0x18, 0x1f, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       382
       382
       +
         0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x1f, 0x18, 0x18, 0x1f, 0x1f, 0x18,

     

       383
       383
       +
         0x18, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f,

     

       384
       384
       +
         0x3f, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,

     

       385
       385
       +
         0x36, 0x36, 0x36, 0xff, 0xff, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,

     

       386
       386
       +
         0x18, 0x18, 0x18, 0x18, 0x18, 0xff, 0xff, 0x18, 0x18, 0xff, 0xff, 0x18,

     

       387
       387
       +
         0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xf8,

     

       388
       388
       +
         0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       389
       389
       +
         0x00, 0x00, 0x00, 0x1f, 0x1f, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,

     

       390
       390
       +
         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,

     

       391
       391
       +
         0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       392
       392
       +
         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0xf0, 0xf0, 0xf0,

     

       393
       393
       +
         0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0,

     

       394
       394
       +
         0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,

     

       395
       395
       +
         0x0f, 0x0f, 0x0f, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,

     

       396
       396
       +
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       397
       397
       +
         0x00, 0x76, 0xd6, 0xdc, 0xc8, 0xc8, 0xdc, 0xd6, 0x76, 0x00, 0x00, 0x00,

     

       398
       398
       +
         0x00, 0x00, 0x78, 0xcc, 0xcc, 0xcc, 0xd8, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,

     

       399
       399
       +
         0xd8, 0xc0, 0xc0, 0x00, 0x00, 0x00, 0xfe, 0xc6, 0xc6, 0xc0, 0xc0, 0xc0,

     

       400
       400
       +
         0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       401
       401
       +
         0x00, 0x7e, 0xfe, 0x24, 0x24, 0x24, 0x24, 0x66, 0xc6, 0x00, 0x00, 0x00,

     

       402
       402
       +
         0x00, 0x00, 0xfe, 0xfe, 0xc2, 0x60, 0x30, 0x18, 0x30, 0x60, 0xc2, 0xfe,

     

       403
       403
       +
         0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7e, 0xc8, 0xcc,

     

       404
       404
       +
         0xcc, 0xcc, 0xcc, 0xcc, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       405
       405
       +
         0x00, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x76, 0x6c, 0x60, 0xc0, 0x00,

     

       406
       406
       +
         0x00, 0x00, 0x00, 0x00, 0x00, 0x66, 0xfc, 0x98, 0x18, 0x18, 0x18, 0x18,

     

       407
       407
       +
         0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x30, 0x30, 0x78, 0xcc, 0xcc,

     

       408
       408
       +
         0xcc, 0x78, 0x30, 0x30, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x6c,

     

       409
       409
       +
         0xc6, 0xc6, 0xc6, 0xfe, 0xc6, 0xc6, 0xc6, 0x6c, 0x38, 0x00, 0x00, 0x00,

     

       410
       410
       +
         0x00, 0x00, 0x38, 0x6c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x6c, 0x6c, 0x6c,

     

       411
       411
       +
         0xee, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0xcc, 0x60, 0x30, 0x78, 0xcc,

     

       412
       412
       +
         0xcc, 0xcc, 0xcc, 0xcc, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       413
       413
       +
         0x00, 0x76, 0xbb, 0x99, 0x99, 0xdd, 0x6e, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       414
       414
       +
         0x00, 0x00, 0x02, 0x06, 0x3c, 0x6c, 0xce, 0xd6, 0xd6, 0xe6, 0x6c, 0x78,

     

       415
       415
       +
         0xc0, 0x80, 0x00, 0x00, 0x00, 0x00, 0x1e, 0x30, 0x60, 0xc0, 0xc0, 0xfe,

     

       416
       416
       +
         0xc0, 0xc0, 0x60, 0x30, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x6c,

     

       417
       417
       +
         0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x00, 0x00, 0x00,

     

       418
       418
       +
         0x00, 0x00, 0x00, 0x00, 0xfe, 0x00, 0x00, 0xfe, 0x00, 0x00, 0xfe, 0x00,

     

       419
       419
       +
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x30, 0xfc,

     

       420
       420
       +
         0x30, 0x30, 0x00, 0x00, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       421
       421
       +
         0x60, 0x30, 0x18, 0x0c, 0x18, 0x30, 0x60, 0x00, 0xfc, 0x00, 0x00, 0x00,

     

       422
       422
       +
         0x00, 0x00, 0x00, 0x00, 0x18, 0x30, 0x60, 0xc0, 0x60, 0x30, 0x18, 0x00,

     

       423
       423
       +
         0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x36, 0x36, 0x30, 0x30, 0x30,

     

       424
       424
       +
         0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x18, 0x18, 0x18, 0x18,

     

       425
       425
       +
         0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xd8, 0xd8, 0x70, 0x00, 0x00, 0x00,

     

       426
       426
       +
         0x00, 0x00, 0x00, 0x00, 0x30, 0x30, 0x00, 0xfc, 0x00, 0x30, 0x30, 0x00,

     

       427
       427
       +
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x76, 0xdc, 0x00,

     

       428
       428
       +
         0x76, 0xdc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0xcc, 0xcc,

     

       429
       429
       +
         0xcc, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       430
       430
       +
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x30, 0x00, 0x00, 0x00,

     

       431
       431
       +
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30,

     

       432
       432
       +
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0c, 0x0c,

     

       433
       433
       +
         0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0xcc, 0x6c, 0x3c, 0x1c, 0x0c, 0x00, 0x00,

     

       434
       434
       +
         0x00, 0xd8, 0xec, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0x00, 0x00, 0x00, 0x00,

     

       435
       435
       +
         0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x6c, 0x0c, 0x18, 0x30, 0x60, 0x7c,

     

       436
       436
       +
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       437
       437
       +
         0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       438
       438
       +
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

     

       439
       439
       +
         0x00, 0x00, 0x00, 0x00

     

       440
       440
       +
       };

     

       441
       441
       +
       

     

       442
       442
       +
       static ALWAYS_INLINE uint32_t convert_colour(struct flanterm_context *_ctx, uint32_t colour) {

     

       443
       443
       +
           struct flanterm_fb_context *ctx = (void *)_ctx;

     

       444
       444
       +
           uint32_t r = (colour >> 16) & 0xff;

     

       445
       445
       +
           uint32_t g = (colour >> 8) & 0xff;

     

       446
       446
       +
           uint32_t b =  colour & 0xff;

     

       447
       447
       +
           return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);

     

       448
       448
       +
       }

     

       449
       449
       +
       

     

       450
       450
       +
       static void flanterm_fb_save_state(struct flanterm_context *_ctx) {

     

       451
       451
       +
           struct flanterm_fb_context *ctx = (void *)_ctx;

     

       452
       452
       +
           ctx->saved_state_text_fg = ctx->text_fg;

     

       453
       453
       +
           ctx->saved_state_text_bg = ctx->text_bg;

     

       454
       454
       +
           ctx->saved_state_cursor_x = ctx->cursor_x;

     

       455
       455
       +
           ctx->saved_state_cursor_y = ctx->cursor_y;

     

       456
       456
       +
       }

     

       457
       457
       +
       

     

       458
       458
       +
       static void flanterm_fb_restore_state(struct flanterm_context *_ctx) {

     

       459
       459
       +
           struct flanterm_fb_context *ctx = (void *)_ctx;

     

       460
       460
       +
           ctx->text_fg = ctx->saved_state_text_fg;

     

       461
       461
       +
           ctx->text_bg = ctx->saved_state_text_bg;

     

       462
       462
       +
           ctx->cursor_x = ctx->saved_state_cursor_x;

     

       463
       463
       +
           ctx->cursor_y = ctx->saved_state_cursor_y;

     

       464
       464
       +
       }

     

       465
       465
       +
       

     

       466
       466
       +
       static void flanterm_fb_swap_palette(struct flanterm_context *_ctx) {

     

       467
       467
       +
           struct flanterm_fb_context *ctx = (void *)_ctx;

     

       468
       468
       +
           uint32_t tmp = ctx->text_bg;

     

       469
       469
       +
           ctx->text_bg = ctx->text_fg;

     

       470
       470
       +
           ctx->text_fg = tmp;

     

       471
       471
       +
       }

     

       472
       472
       +
       

     

       473
       473
       +
       static void plot_char_scaled_canvas(struct flanterm_context *_ctx, struct flanterm_fb_char *c, size_t x, size_t y) {

     

       474
       474
       +
           struct flanterm_fb_context *ctx = (void *)_ctx;

     

       475
       475
       +
       

     

       476
       476
       +
           if (x >= _ctx->cols || y >= _ctx->rows) {

     

       477
       477
       +
               return;

     

       478
       478
       +
           }

     

       479
       479
       +
       

     

       480
       480
       +
           x = ctx->offset_x + x * ctx->glyph_width;

     

       481
       481
       +
           y = ctx->offset_y + y * ctx->glyph_height;

     

       482
       482
       +
       

     

       483
       483
       +
           bool *glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width];

     

       484
       484
       +
           // naming: fx,fy for font coordinates, gx,gy for glyph coordinates

     

       485
       485
       +
           for (size_t gy = 0; gy < ctx->glyph_height; gy++) {

     

       486
       486
       +
               uint8_t fy = gy / ctx->font_scale_y;

     

       487
       487
       +
               volatile uint32_t *fb_line = ctx->framebuffer + x + (y + gy) * (ctx->pitch / 4);

     

       488
       488
       +
               uint32_t *canvas_line = ctx->canvas + x + (y + gy) * ctx->width;

     

       489
       489
       +
               bool *glyph_pointer = glyph + (fy * ctx->font_width);

     

       490
       490
       +
               for (size_t fx = 0; fx < ctx->font_width; fx++) {

     

       491
       491
       +
                   for (size_t i = 0; i < ctx->font_scale_x; i++) {

     

       492
       492
       +
                       size_t gx = ctx->font_scale_x * fx + i;

     

       493
       493
       +
                       uint32_t bg = c->bg == 0xffffffff ? canvas_line[gx] : c->bg;

     

       494
       494
       +
                       uint32_t fg = c->fg == 0xffffffff ? canvas_line[gx] : c->fg;

     

       495
       495
       +
                       fb_line[gx] = *glyph_pointer ? fg : bg;

     

       496
       496
       +
                   }

     

       497
       497
       +
                   glyph_pointer++;

     

       498
       498
       +
               }

     

       499
       499
       +
           }

     

       500
       500
       +
       }

     

       501
       501
       +
       

     

       502
       502
       +
       static void plot_char_scaled_uncanvas(struct flanterm_context *_ctx, struct flanterm_fb_char *c, size_t x, size_t y) {

     

       503
       503
       +
           struct flanterm_fb_context *ctx = (void *)_ctx;

     

       504
       504
       +
       

     

       505
       505
       +
           if (x >= _ctx->cols || y >= _ctx->rows) {

     

       506
       506
       +
               return;

     

       507
       507
       +
           }

     

       508
       508
       +
       

     

       509
       509
       +
           uint32_t default_bg = ctx->default_bg;

     

       510
       510
       +
       

     

       511
       511
       +
           uint32_t bg = c->bg == 0xffffffff ? default_bg : c->bg;

     

       512
       512
       +
           uint32_t fg = c->fg == 0xffffffff ? default_bg : c->fg;

     

       513
       513
       +
       

     

       514
       514
       +
           x = ctx->offset_x + x * ctx->glyph_width;

     

       515
       515
       +
           y = ctx->offset_y + y * ctx->glyph_height;

     

       516
       516
       +
       

     

       517
       517
       +
           bool *glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width];

     

       518
       518
       +
           // naming: fx,fy for font coordinates, gx,gy for glyph coordinates

     

       519
       519
       +
           for (size_t gy = 0; gy < ctx->glyph_height; gy++) {

     

       520
       520
       +
               uint8_t fy = gy / ctx->font_scale_y;

     

       521
       521
       +
               volatile uint32_t *fb_line = ctx->framebuffer + x + (y + gy) * (ctx->pitch / 4);

     

       522
       522
       +
               bool *glyph_pointer = glyph + (fy * ctx->font_width);

     

       523
       523
       +
               for (size_t fx = 0; fx < ctx->font_width; fx++) {

     

       524
       524
       +
                   for (size_t i = 0; i < ctx->font_scale_x; i++) {

     

       525
       525
       +
                       size_t gx = ctx->font_scale_x * fx + i;

     

       526
       526
       +
                       fb_line[gx] = *glyph_pointer ? fg : bg;

     

       527
       527
       +
                   }

     

       528
       528
       +
                   glyph_pointer++;

     

       529
       529
       +
               }

     

       530
       530
       +
           }

     

       531
       531
       +
       }

     

       532
       532
       +
       

     

       533
       533
       +
       static void plot_char_unscaled_canvas(struct flanterm_context *_ctx, struct flanterm_fb_char *c, size_t x, size_t y) {

     

       534
       534
       +
           struct flanterm_fb_context *ctx = (void *)_ctx;

     

       535
       535
       +
       

     

       536
       536
       +
           if (x >= _ctx->cols || y >= _ctx->rows) {

     

       537
       537
       +
               return;

     

       538
       538
       +
           }

     

       539
       539
       +
       

     

       540
       540
       +
           x = ctx->offset_x + x * ctx->glyph_width;

     

       541
       541
       +
           y = ctx->offset_y + y * ctx->glyph_height;

     

       542
       542
       +
       

     

       543
       543
       +
           bool *glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width];

     

       544
       544
       +
           // naming: fx,fy for font coordinates, gx,gy for glyph coordinates

     

       545
       545
       +
           for (size_t gy = 0; gy < ctx->glyph_height; gy++) {

     

       546
       546
       +
               volatile uint32_t *fb_line = ctx->framebuffer + x + (y + gy) * (ctx->pitch / 4);

     

       547
       547
       +
               uint32_t *canvas_line = ctx->canvas + x + (y + gy) * ctx->width;

     

       548
       548
       +
               bool *glyph_pointer = glyph + (gy * ctx->font_width);

     

       549
       549
       +
               for (size_t fx = 0; fx < ctx->font_width; fx++) {

     

       550
       550
       +
                   uint32_t bg = c->bg == 0xffffffff ? canvas_line[fx] : c->bg;

     

       551
       551
       +
                   uint32_t fg = c->fg == 0xffffffff ? canvas_line[fx] : c->fg;

     

       552
       552
       +
                   fb_line[fx] = *(glyph_pointer++) ? fg : bg;

     

       553
       553
       +
               }

     

       554
       554
       +
           }

     

       555
       555
       +
       }

     

       556
       556
       +
       

     

       557
       557
       +
       static void plot_char_unscaled_uncanvas(struct flanterm_context *_ctx, struct flanterm_fb_char *c, size_t x, size_t y) {

     

       558
       558
       +
           struct flanterm_fb_context *ctx = (void *)_ctx;

     

       559
       559
       +
       

     

       560
       560
       +
           if (x >= _ctx->cols || y >= _ctx->rows) {

     

       561
       561
       +
               return;

     

       562
       562
       +
           }

     

       563
       563
       +
       

     

       564
       564
       +
           uint32_t default_bg = ctx->default_bg;

     

       565
       565
       +
       

     

       566
       566
       +
           uint32_t bg = c->bg == 0xffffffff ? default_bg : c->bg;

     

       567
       567
       +
           uint32_t fg = c->fg == 0xffffffff ? default_bg : c->fg;

     

       568
       568
       +
       

     

       569
       569
       +
           x = ctx->offset_x + x * ctx->glyph_width;

     

       570
       570
       +
           y = ctx->offset_y + y * ctx->glyph_height;

     

       571
       571
       +
       

     

       572
       572
       +
           bool *glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width];

     

       573
       573
       +
           // naming: fx,fy for font coordinates, gx,gy for glyph coordinates

     

       574
       574
       +
           for (size_t gy = 0; gy < ctx->glyph_height; gy++) {

     

       575
       575
       +
               volatile uint32_t *fb_line = ctx->framebuffer + x + (y + gy) * (ctx->pitch / 4);

     

       576
       576
       +
               bool *glyph_pointer = glyph + (gy * ctx->font_width);

     

       577
       577
       +
               for (size_t fx = 0; fx < ctx->font_width; fx++) {

     

       578
       578
       +
                   fb_line[fx] = *(glyph_pointer++) ? fg : bg;

     

       579
       579
       +
               }

     

       580
       580
       +
           }

     

       581
       581
       +
       }

     

       582
       582
       +
       

     

       583
       583
       +
       static inline bool compare_char(struct flanterm_fb_char *a, struct flanterm_fb_char *b) {

     

       584
       584
       +
           return !(a->c != b->c || a->bg != b->bg || a->fg != b->fg);

     

       585
       585
       +
       }

     

       586
       586
       +
       

     

       587
       587
       +
       static void push_to_queue(struct flanterm_context *_ctx, struct flanterm_fb_char *c, size_t x, size_t y) {

     

       588
       588
       +
           struct flanterm_fb_context *ctx = (void *)_ctx;

     

       589
       589
       +
       

     

       590
       590
       +
           if (x >= _ctx->cols || y >= _ctx->rows) {

     

       591
       591
       +
               return;

     

       592
       592
       +
           }

     

       593
       593
       +
       

     

       594
       594
       +
           size_t i = y * _ctx->cols + x;

     

       595
       595
       +
       

     

       596
       596
       +
           struct flanterm_fb_queue_item *q = ctx->map[i];

     

       597
       597
       +
       

     

       598
       598
       +
           if (q == NULL) {

     

       599
       599
       +
               if (compare_char(&ctx->grid[i], c)) {

     

       600
       600
       +
                   return;

     

       601
       601
       +
               }

     

       602
       602
       +
               q = &ctx->queue[ctx->queue_i++];

     

       603
       603
       +
               q->x = x;

     

       604
       604
       +
               q->y = y;

     

       605
       605
       +
               ctx->map[i] = q;

     

       606
       606
       +
           }

     

       607
       607
       +
       

     

       608
       608
       +
           q->c = *c;

     

       609
       609
       +
       }

     

       610
       610
       +
       

     

       611
       611
       +
       static void flanterm_fb_revscroll(struct flanterm_context *_ctx) {

     

       612
       612
       +
           struct flanterm_fb_context *ctx = (void *)_ctx;

     

       613
       613
       +
       

     

       614
       614
       +
           for (size_t i = (_ctx->scroll_bottom_margin - 1) * _ctx->cols - 1;

     

       615
       615
       +
                i >= _ctx->scroll_top_margin * _ctx->cols; i--) {

     

       616
       616
       +
               if (i == (size_t)-1) {

     

       617
       617
       +
                   break;

     

       618
       618
       +
               }

     

       619
       619
       +
               struct flanterm_fb_char *c;

     

       620
       620
       +
               struct flanterm_fb_queue_item *q = ctx->map[i];

     

       621
       621
       +
               if (q != NULL) {

     

       622
       622
       +
                   c = &q->c;

     

       623
       623
       +
               } else {

     

       624
       624
       +
                   c = &ctx->grid[i];

     

       625
       625
       +
               }

     

       626
       626
       +
               push_to_queue(_ctx, c, (i + _ctx->cols) % _ctx->cols, (i + _ctx->cols) / _ctx->cols);

     

       627
       627
       +
           }

     

       628
       628
       +
       

     

       629
       629
       +
           // Clear the first line of the screen.

     

       630
       630
       +
           struct flanterm_fb_char empty;

     

       631
       631
       +
           empty.c  = ' ';

     

       632
       632
       +
           empty.fg = ctx->text_fg;

     

       633
       633
       +
           empty.bg = ctx->text_bg;

     

       634
       634
       +
           for (size_t i = 0; i < _ctx->cols; i++) {

     

       635
       635
       +
               push_to_queue(_ctx, &empty, i, _ctx->scroll_top_margin);

     

       636
       636
       +
           }

     

       637
       637
       +
       }

     

       638
       638
       +
       

     

       639
       639
       +
       static void flanterm_fb_scroll(struct flanterm_context *_ctx) {

     

       640
       640
       +
           struct flanterm_fb_context *ctx = (void *)_ctx;

     

       641
       641
       +
       

     

       642
       642
       +
           for (size_t i = (_ctx->scroll_top_margin + 1) * _ctx->cols;

     

       643
       643
       +
                i < _ctx->scroll_bottom_margin * _ctx->cols; i++) {

     

       644
       644
       +
               struct flanterm_fb_char *c;

     

       645
       645
       +
               struct flanterm_fb_queue_item *q = ctx->map[i];

     

       646
       646
       +
               if (q != NULL) {

     

       647
       647
       +
                   c = &q->c;

     

       648
       648
       +
               } else {

     

       649
       649
       +
                   c = &ctx->grid[i];

     

       650
       650
       +
               }

     

       651
       651
       +
               push_to_queue(_ctx, c, (i - _ctx->cols) % _ctx->cols, (i - _ctx->cols) / _ctx->cols);

     

       652
       652
       +
           }

     

       653
       653
       +
       

     

       654
       654
       +
           // Clear the last line of the screen.

     

       655
       655
       +
           struct flanterm_fb_char empty;

     

       656
       656
       +
           empty.c  = ' ';

     

       657
       657
       +
           empty.fg = ctx->text_fg;

     

       658
       658
       +
           empty.bg = ctx->text_bg;

     

       659
       659
       +
           for (size_t i = 0; i < _ctx->cols; i++) {

     

       660
       660
       +
               push_to_queue(_ctx, &empty, i, _ctx->scroll_bottom_margin - 1);

     

       661
       661
       +
           }

     

       662
       662
       +
       }

     

       663
       663
       +
       

     

       664
       664
       +
       static void flanterm_fb_clear(struct flanterm_context *_ctx, bool move) {

     

       665
       665
       +
           struct flanterm_fb_context *ctx = (void *)_ctx;

     

       666
       666
       +
       

     

       667
       667
       +
           struct flanterm_fb_char empty;

     

       668
       668
       +
           empty.c  = ' ';

     

       669
       669
       +
           empty.fg = ctx->text_fg;

     

       670
       670
       +
           empty.bg = ctx->text_bg;

     

       671
       671
       +
           for (size_t i = 0; i < _ctx->rows * _ctx->cols; i++) {

     

       672
       672
       +
               push_to_queue(_ctx, &empty, i % _ctx->cols, i / _ctx->cols);

     

       673
       673
       +
           }

     

       674
       674
       +
       

     

       675
       675
       +
           if (move) {

     

       676
       676
       +
               ctx->cursor_x = 0;

     

       677
       677
       +
               ctx->cursor_y = 0;

     

       678
       678
       +
           }

     

       679
       679
       +
       }

     

       680
       680
       +
       

     

       681
       681
       +
       static void flanterm_fb_set_cursor_pos(struct flanterm_context *_ctx, size_t x, size_t y) {

     

       682
       682
       +
           struct flanterm_fb_context *ctx = (void *)_ctx;

     

       683
       683
       +
       

     

       684
       684
       +
           if (x >= _ctx->cols) {

     

       685
       685
       +
               if ((int)x < 0) {

     

       686
       686
       +
                   x = 0;

     

       687
       687
       +
               } else {

     

       688
       688
       +
                   x = _ctx->cols - 1;

     

       689
       689
       +
               }

     

       690
       690
       +
           }

     

       691
       691
       +
           if (y >= _ctx->rows) {

     

       692
       692
       +
               if ((int)y < 0) {

     

       693
       693
       +
                   y = 0;

     

       694
       694
       +
               } else {

     

       695
       695
       +
                   y = _ctx->rows - 1;

     

       696
       696
       +
               }

     

       697
       697
       +
           }

     

       698
       698
       +
           ctx->cursor_x = x;

     

       699
       699
       +
           ctx->cursor_y = y;

     

       700
       700
       +
       }

     

       701
       701
       +
       

     

       702
       702
       +
       static void flanterm_fb_get_cursor_pos(struct flanterm_context *_ctx, size_t *x, size_t *y) {

     

       703
       703
       +
           struct flanterm_fb_context *ctx = (void *)_ctx;

     

       704
       704
       +
       

     

       705
       705
       +
           *x = ctx->cursor_x >= _ctx->cols ? _ctx->cols - 1 : ctx->cursor_x;

     

       706
       706
       +
           *y = ctx->cursor_y >= _ctx->rows ? _ctx->rows - 1 : ctx->cursor_y;

     

       707
       707
       +
       }

     

       708
       708
       +
       

     

       709
       709
       +
       static void flanterm_fb_move_character(struct flanterm_context *_ctx, size_t new_x, size_t new_y, size_t old_x, size_t old_y) {

     

       710
       710
       +
           struct flanterm_fb_context *ctx = (void *)_ctx;

     

       711
       711
       +
       

     

       712
       712
       +
           if (old_x >= _ctx->cols || old_y >= _ctx->rows

     

       713
       713
       +
            || new_x >= _ctx->cols || new_y >= _ctx->rows) {

     

       714
       714
       +
               return;

     

       715
       715
       +
           }

     

       716
       716
       +
       

     

       717
       717
       +
           size_t i = old_x + old_y * _ctx->cols;

     

       718
       718
       +
       

     

       719
       719
       +
           struct flanterm_fb_char *c;

     

       720
       720
       +
           struct flanterm_fb_queue_item *q = ctx->map[i];

     

       721
       721
       +
           if (q != NULL) {

     

       722
       722
       +
               c = &q->c;

     

       723
       723
       +
           } else {

     

       724
       724
       +
               c = &ctx->grid[i];

     

       725
       725
       +
           }

     

       726
       726
       +
       

     

       727
       727
       +
           push_to_queue(_ctx, c, new_x, new_y);

     

       728
       728
       +
       }

     

       729
       729
       +
       

     

       730
       730
       +
       static void flanterm_fb_set_text_fg(struct flanterm_context *_ctx, size_t fg) {

     

       731
       731
       +
           struct flanterm_fb_context *ctx = (void *)_ctx;

     

       732
       732
       +
       

     

       733
       733
       +
           ctx->text_fg = ctx->ansi_colours[fg];

     

       734
       734
       +
       }

     

       735
       735
       +
       

     

       736
       736
       +
       static void flanterm_fb_set_text_bg(struct flanterm_context *_ctx, size_t bg) {

     

       737
       737
       +
           struct flanterm_fb_context *ctx = (void *)_ctx;

     

       738
       738
       +
       

     

       739
       739
       +
           ctx->text_bg = ctx->ansi_colours[bg];

     

       740
       740
       +
       }

     

       741
       741
       +
       

     

       742
       742
       +
       static void flanterm_fb_set_text_fg_bright(struct flanterm_context *_ctx, size_t fg) {

     

       743
       743
       +
           struct flanterm_fb_context *ctx = (void *)_ctx;

     

       744
       744
       +
       

     

       745
       745
       +
           ctx->text_fg = ctx->ansi_bright_colours[fg];

     

       746
       746
       +
       }

     

       747
       747
       +
       

     

       748
       748
       +
       static void flanterm_fb_set_text_bg_bright(struct flanterm_context *_ctx, size_t bg) {

     

       749
       749
       +
           struct flanterm_fb_context *ctx = (void *)_ctx;

     

       750
       750
       +
       

     

       751
       751
       +
           ctx->text_bg = ctx->ansi_bright_colours[bg];

     

       752
       752
       +
       }

     

       753
       753
       +
       

     

       754
       754
       +
       static void flanterm_fb_set_text_fg_rgb(struct flanterm_context *_ctx, uint32_t fg) {

     

       755
       755
       +
           struct flanterm_fb_context *ctx = (void *)_ctx;

     

       756
       756
       +
       

     

       757
       757
       +
           ctx->text_fg = convert_colour(_ctx, fg);

     

       758
       758
       +
       }

     

       759
       759
       +
       

     

       760
       760
       +
       static void flanterm_fb_set_text_bg_rgb(struct flanterm_context *_ctx, uint32_t bg) {

     

       761
       761
       +
           struct flanterm_fb_context *ctx = (void *)_ctx;

     

       762
       762
       +
       

     

       763
       763
       +
           ctx->text_bg = convert_colour(_ctx, bg);

     

       764
       764
       +
       }

     

       765
       765
       +
       

     

       766
       766
       +
       static void flanterm_fb_set_text_fg_default(struct flanterm_context *_ctx) {

     

       767
       767
       +
           struct flanterm_fb_context *ctx = (void *)_ctx;

     

       768
       768
       +
       

     

       769
       769
       +
           ctx->text_fg = ctx->default_fg;

     

       770
       770
       +
       }

     

       771
       771
       +
       

     

       772
       772
       +
       static void flanterm_fb_set_text_bg_default(struct flanterm_context *_ctx) {

     

       773
       773
       +
           struct flanterm_fb_context *ctx = (void *)_ctx;

     

       774
       774
       +
       

     

       775
       775
       +
           ctx->text_bg = 0xffffffff;

     

       776
       776
       +
       }

     

       777
       777
       +
       

     

       778
       778
       +
       static void flanterm_fb_set_text_fg_default_bright(struct flanterm_context *_ctx) {

     

       779
       779
       +
           struct flanterm_fb_context *ctx = (void *)_ctx;

     

       780
       780
       +
       

     

       781
       781
       +
           ctx->text_fg = ctx->default_fg_bright;

     

       782
       782
       +
       }

     

       783
       783
       +
       

     

       784
       784
       +
       static void flanterm_fb_set_text_bg_default_bright(struct flanterm_context *_ctx) {

     

       785
       785
       +
           struct flanterm_fb_context *ctx = (void *)_ctx;

     

       786
       786
       +
       

     

       787
       787
       +
           ctx->text_bg = ctx->default_bg_bright;

     

       788
       788
       +
       }

     

       789
       789
       +
       

     

       790
       790
       +
       static void draw_cursor(struct flanterm_context *_ctx) {

     

       791
       791
       +
           struct flanterm_fb_context *ctx = (void *)_ctx;

     

       792
       792
       +
       

     

       793
       793
       +
           if (ctx->cursor_x >= _ctx->cols || ctx->cursor_y >= _ctx->rows) {

     

       794
       794
       +
               return;

     

       795
       795
       +
           }

     

       796
       796
       +
       

     

       797
       797
       +
           size_t i = ctx->cursor_x + ctx->cursor_y * _ctx->cols;

     

       798
       798
       +
       

     

       799
       799
       +
           struct flanterm_fb_char c;

     

       800
       800
       +
           struct flanterm_fb_queue_item *q = ctx->map[i];

     

       801
       801
       +
           if (q != NULL) {

     

       802
       802
       +
               c = q->c;

     

       803
       803
       +
           } else {

     

       804
       804
       +
               c = ctx->grid[i];

     

       805
       805
       +
           }

     

       806
       806
       +
           uint32_t tmp = c.fg;

     

       807
       807
       +
           c.fg = c.bg;

     

       808
       808
       +
           c.bg = tmp;

     

       809
       809
       +
           ctx->plot_char(_ctx, &c, ctx->cursor_x, ctx->cursor_y);

     

       810
       810
       +
           if (q != NULL) {

     

       811
       811
       +
               ctx->grid[i] = q->c;

     

       812
       812
       +
               ctx->map[i] = NULL;

     

       813
       813
       +
           }

     

       814
       814
       +
       }

     

       815
       815
       +
       

     

       816
       816
       +
       static void flanterm_fb_double_buffer_flush(struct flanterm_context *_ctx) {

     

       817
       817
       +
           struct flanterm_fb_context *ctx = (void *)_ctx;

     

       818
       818
       +
       

     

       819
       819
       +
           if (_ctx->cursor_enabled) {

     

       820
       820
       +
               draw_cursor(_ctx);

     

       821
       821
       +
           }

     

       822
       822
       +
       

     

       823
       823
       +
           for (size_t i = 0; i < ctx->queue_i; i++) {

     

       824
       824
       +
               struct flanterm_fb_queue_item *q = &ctx->queue[i];

     

       825
       825
       +
               size_t offset = q->y * _ctx->cols + q->x;

     

       826
       826
       +
               if (ctx->map[offset] == NULL) {

     

       827
       827
       +
                   continue;

     

       828
       828
       +
               }

     

       829
       829
       +
               ctx->plot_char(_ctx, &q->c, q->x, q->y);

     

       830
       830
       +
               ctx->grid[offset] = q->c;

     

       831
       831
       +
               ctx->map[offset] = NULL;

     

       832
       832
       +
           }

     

       833
       833
       +
       

     

       834
       834
       +
           if ((ctx->old_cursor_x != ctx->cursor_x || ctx->old_cursor_y != ctx->cursor_y) || _ctx->cursor_enabled == false) {

     

       835
       835
       +
               if (ctx->old_cursor_x < _ctx->cols && ctx->old_cursor_y < _ctx->rows) {

     

       836
       836
       +
                   ctx->plot_char(_ctx, &ctx->grid[ctx->old_cursor_x + ctx->old_cursor_y * _ctx->cols], ctx->old_cursor_x, ctx->old_cursor_y);

     

       837
       837
       +
               }

     

       838
       838
       +
           }

     

       839
       839
       +
       

     

       840
       840
       +
           ctx->old_cursor_x = ctx->cursor_x;

     

       841
       841
       +
           ctx->old_cursor_y = ctx->cursor_y;

     

       842
       842
       +
       

     

       843
       843
       +
           ctx->queue_i = 0;

     

       844
       844
       +
       }

     

       845
       845
       +
       

     

       846
       846
       +
       static void flanterm_fb_raw_putchar(struct flanterm_context *_ctx, uint8_t c) {

     

       847
       847
       +
           struct flanterm_fb_context *ctx = (void *)_ctx;

     

       848
       848
       +
       

     

       849
       849
       +
           if (ctx->cursor_x >= _ctx->cols && (ctx->cursor_y < _ctx->scroll_bottom_margin - 1 || _ctx->scroll_enabled)) {

     

       850
       850
       +
               ctx->cursor_x = 0;

     

       851
       851
       +
               ctx->cursor_y++;

     

       852
       852
       +
               if (ctx->cursor_y == _ctx->scroll_bottom_margin) {

     

       853
       853
       +
                   ctx->cursor_y--;

     

       854
       854
       +
                   flanterm_fb_scroll(_ctx);

     

       855
       855
       +
               }

     

       856
       856
       +
               if (ctx->cursor_y >= _ctx->cols) {

     

       857
       857
       +
                   ctx->cursor_y = _ctx->cols - 1;

     

       858
       858
       +
               }

     

       859
       859
       +
           }

     

       860
       860
       +
       

     

       861
       861
       +
           struct flanterm_fb_char ch;

     

       862
       862
       +
           ch.c  = c;

     

       863
       863
       +
           ch.fg = ctx->text_fg;

     

       864
       864
       +
           ch.bg = ctx->text_bg;

     

       865
       865
       +
           push_to_queue(_ctx, &ch, ctx->cursor_x++, ctx->cursor_y);

     

       866
       866
       +
       }

     

       867
       867
       +
       

     

       868
       868
       +
       static void flanterm_fb_full_refresh(struct flanterm_context *_ctx) {

     

       869
       869
       +
           struct flanterm_fb_context *ctx = (void *)_ctx;

     

       870
       870
       +
       

     

       871
       871
       +
           uint32_t default_bg = ctx->default_bg;

     

       872
       872
       +
       

     

       873
       873
       +
           for (size_t y = 0; y < ctx->height; y++) {

     

       874
       874
       +
               for (size_t x = 0; x < ctx->width; x++) {

     

       875
       875
       +
                   if (ctx->canvas != NULL) {

     

       876
       876
       +
                       ctx->framebuffer[y * (ctx->pitch / sizeof(uint32_t)) + x] = ctx->canvas[y * ctx->width + x];

     

       877
       877
       +
                   } else {

     

       878
       878
       +
                       ctx->framebuffer[y * (ctx->pitch / sizeof(uint32_t)) + x] = default_bg;

     

       879
       879
       +
                   }

     

       880
       880
       +
               }

     

       881
       881
       +
           }

     

       882
       882
       +
       

     

       883
       883
       +
           for (size_t i = 0; i < (size_t)_ctx->rows * _ctx->cols; i++) {

     

       884
       884
       +
               size_t x = i % _ctx->cols;

     

       885
       885
       +
               size_t y = i / _ctx->cols;

     

       886
       886
       +
       

     

       887
       887
       +
               ctx->plot_char(_ctx, &ctx->grid[i], x, y);

     

       888
       888
       +
           }

     

       889
       889
       +
       

     

       890
       890
       +
           if (_ctx->cursor_enabled) {

     

       891
       891
       +
               draw_cursor(_ctx);

     

       892
       892
       +
           }

     

       893
       893
       +
       }

     

       894
       894
       +
       

     

       895
       895
       +
       static void flanterm_fb_deinit(struct flanterm_context *_ctx, void (*_free)(void *, size_t)) {

     

       896
       896
       +
           struct flanterm_fb_context *ctx = (void *)_ctx;

     

       897
       897
       +
       

     

       898
       898
       +
           if (_free == NULL) {

     

       899
       899
       +
       #ifndef FLANTERM_FB_DISABLE_BUMP_ALLOC

     

       900
       900
       +
               if (bump_allocated_instance == true) {

     

       901
       901
       +
                   bump_alloc_ptr = 0;

     

       902
       902
       +
                   bump_allocated_instance = false;

     

       903
       903
       +
               }

     

       904
       904
       +
       #endif

     

       905
       905
       +
               return;

     

       906
       906
       +
           }

     

       907
       907
       +
       

     

       908
       908
       +
           _free(ctx->font_bits, ctx->font_bits_size);

     

       909
       909
       +
           _free(ctx->font_bool, ctx->font_bool_size);

     

       910
       910
       +
           _free(ctx->grid, ctx->grid_size);

     

       911
       911
       +
           _free(ctx->queue, ctx->queue_size);

     

       912
       912
       +
           _free(ctx->map, ctx->map_size);

     

       913
       913
       +
       

     

       914
       914
       +
           if (ctx->canvas != NULL) {

     

       915
       915
       +
               _free(ctx->canvas, ctx->canvas_size);

     

       916
       916
       +
           }

     

       917
       917
       +
       

     

       918
       918
       +
           _free(ctx, sizeof(struct flanterm_fb_context));

     

       919
       919
       +
       }

     

       920
       920
       +
       

     

       921
       921
       +
       struct flanterm_context *flanterm_fb_init(

     

       922
       922
       +
           void *(*_malloc)(size_t),

     

       923
       923
       +
           void (*_free)(void *, size_t),

     

       924
       924
       +
           uint32_t *framebuffer, size_t width, size_t height, size_t pitch,

     

       925
       925
       +
           uint8_t red_mask_size, uint8_t red_mask_shift,

     

       926
       926
       +
           uint8_t green_mask_size, uint8_t green_mask_shift,

     

       927
       927
       +
           uint8_t blue_mask_size, uint8_t blue_mask_shift,

     

       928
       928
       +
           uint32_t *canvas,

     

       929
       929
       +
           uint32_t *ansi_colours, uint32_t *ansi_bright_colours,

     

       930
       930
       +
           uint32_t *default_bg, uint32_t *default_fg,

     

       931
       931
       +
           uint32_t *default_bg_bright, uint32_t *default_fg_bright,

     

       932
       932
       +
           void *font, size_t font_width, size_t font_height, size_t font_spacing,

     

       933
       933
       +
           size_t font_scale_x, size_t font_scale_y,

     

       934
       934
       +
           size_t margin

     

       935
       935
       +
       ) {

     

       936
       936
       +
           if (font_scale_x == 0 || font_scale_y == 0) {

     

       937
       937
       +
               font_scale_x = 1;

     

       938
       938
       +
               font_scale_y = 1;

     

       939
       939
       +
               if (width >= (1920 + 1920 / 3) && height >= (1080 + 1080 / 3)) {

     

       940
       940
       +
                   font_scale_x = 2;

     

       941
       941
       +
                   font_scale_y = 2;

     

       942
       942
       +
               }

     

       943
       943
       +
               if (width >= (3840 + 3840 / 3) && height >= (2160 + 2160 / 3)) {

     

       944
       944
       +
                   font_scale_x = 4;

     

       945
       945
       +
                   font_scale_y = 4;

     

       946
       946
       +
               }

     

       947
       947
       +
           }

     

       948
       948
       +
       

     

       949
       949
       +
           if (red_mask_size < 8 || red_mask_size != green_mask_size || red_mask_size != blue_mask_size) {

     

       950
       950
       +
               return NULL;

     

       951
       951
       +
           }

     

       952
       952
       +
       

     

       953
       953
       +
           if (_malloc == NULL) {

     

       954
       954
       +
       #ifndef FLANTERM_FB_DISABLE_BUMP_ALLOC

     

       955
       955
       +
               if (bump_allocated_instance == true) {

     

       956
       956
       +
                   return NULL;

     

       957
       957
       +
               }

     

       958
       958
       +
               _malloc = bump_alloc;

     

       959
       959
       +
               // Limit terminal size if needed

     

       960
       960
       +
               if (width > FLANTERM_FB_WIDTH_LIMIT || height > FLANTERM_FB_HEIGHT_LIMIT) {

     

       961
       961
       +
                   size_t width_limit = width > FLANTERM_FB_WIDTH_LIMIT ? FLANTERM_FB_WIDTH_LIMIT : width;

     

       962
       962
       +
                   size_t height_limit = height > FLANTERM_FB_HEIGHT_LIMIT ? FLANTERM_FB_HEIGHT_LIMIT : height;

     

       963
       963
       +
       

     

       964
       964
       +
                   framebuffer = (uint32_t *)((uintptr_t)framebuffer + ((((height / 2) - (height_limit / 2)) * pitch) + (((width / 2) - (width_limit / 2)) * 4)));

     

       965
       965
       +
       

     

       966
       966
       +
                   width = width_limit;

     

       967
       967
       +
                   height = height_limit;

     

       968
       968
       +
               }

     

       969
       969
       +
       

     

       970
       970
       +
               // Force disable canvas

     

       971
       971
       +
               canvas = NULL;

     

       972
       972
       +
       #else

     

       973
       973
       +
               return NULL;

     

       974
       974
       +
       #endif

     

       975
       975
       +
           }

     

       976
       976
       +
       

     

       977
       977
       +
           struct flanterm_fb_context *ctx = NULL;

     

       978
       978
       +
           ctx = _malloc(sizeof(struct flanterm_fb_context));

     

       979
       979
       +
           if (ctx == NULL) {

     

       980
       980
       +
               goto fail;

     

       981
       981
       +
           }

     

       982
       982
       +
       

     

       983
       983
       +
           struct flanterm_context *_ctx = (void *)ctx;

     

       984
       984
       +
           memset(ctx, 0, sizeof(struct flanterm_fb_context));

     

       985
       985
       +
       

     

       986
       986
       +
           ctx->red_mask_size = red_mask_size;

     

       987
       987
       +
           ctx->red_mask_shift = red_mask_shift + (red_mask_size - 8);

     

       988
       988
       +
           ctx->green_mask_size = green_mask_size;

     

       989
       989
       +
           ctx->green_mask_shift = green_mask_shift + (green_mask_size - 8);

     

       990
       990
       +
           ctx->blue_mask_size = blue_mask_size;

     

       991
       991
       +
           ctx->blue_mask_shift = blue_mask_shift + (blue_mask_size - 8);

     

       992
       992
       +
       

     

       993
       993
       +
           if (ansi_colours != NULL) {

     

       994
       994
       +
               for (size_t i = 0; i < 8; i++) {

     

       995
       995
       +
                   ctx->ansi_colours[i] = convert_colour(_ctx, ansi_colours[i]);

     

       996
       996
       +
               }

     

       997
       997
       +
           } else {

     

       998
       998
       +
               ctx->ansi_colours[0] = convert_colour(_ctx, 0x00000000); // black

     

       999
       999
       +
               ctx->ansi_colours[1] = convert_colour(_ctx, 0x00aa0000); // red

     

       1000
       1000
       +
               ctx->ansi_colours[2] = convert_colour(_ctx, 0x0000aa00); // green

     

       1001
       1001
       +
               ctx->ansi_colours[3] = convert_colour(_ctx, 0x00aa5500); // brown

     

       1002
       1002
       +
               ctx->ansi_colours[4] = convert_colour(_ctx, 0x000000aa); // blue

     

       1003
       1003
       +
               ctx->ansi_colours[5] = convert_colour(_ctx, 0x00aa00aa); // magenta

     

       1004
       1004
       +
               ctx->ansi_colours[6] = convert_colour(_ctx, 0x0000aaaa); // cyan

     

       1005
       1005
       +
               ctx->ansi_colours[7] = convert_colour(_ctx, 0x00aaaaaa); // grey

     

       1006
       1006
       +
           }

     

       1007
       1007
       +
       

     

       1008
       1008
       +
           if (ansi_bright_colours != NULL) {

     

       1009
       1009
       +
               for (size_t i = 0; i < 8; i++) {

     

       1010
       1010
       +
                   ctx->ansi_bright_colours[i] = convert_colour(_ctx, ansi_bright_colours[i]);

     

       1011
       1011
       +
               }

     

       1012
       1012
       +
           } else {

     

       1013
       1013
       +
               ctx->ansi_bright_colours[0] = convert_colour(_ctx, 0x00555555); // black

     

       1014
       1014
       +
               ctx->ansi_bright_colours[1] = convert_colour(_ctx, 0x00ff5555); // red

     

       1015
       1015
       +
               ctx->ansi_bright_colours[2] = convert_colour(_ctx, 0x0055ff55); // green

     

       1016
       1016
       +
               ctx->ansi_bright_colours[3] = convert_colour(_ctx, 0x00ffff55); // brown

     

       1017
       1017
       +
               ctx->ansi_bright_colours[4] = convert_colour(_ctx, 0x005555ff); // blue

     

       1018
       1018
       +
               ctx->ansi_bright_colours[5] = convert_colour(_ctx, 0x00ff55ff); // magenta

     

       1019
       1019
       +
               ctx->ansi_bright_colours[6] = convert_colour(_ctx, 0x0055ffff); // cyan

     

       1020
       1020
       +
               ctx->ansi_bright_colours[7] = convert_colour(_ctx, 0x00ffffff); // grey

     

       1021
       1021
       +
           }

     

       1022
       1022
       +
       

     

       1023
       1023
       +
           if (default_bg != NULL) {

     

       1024
       1024
       +
               ctx->default_bg = convert_colour(_ctx, *default_bg);

     

       1025
       1025
       +
           } else {

     

       1026
       1026
       +
               ctx->default_bg = 0x00000000; // background (black)

     

       1027
       1027
       +
           }

     

       1028
       1028
       +
       

     

       1029
       1029
       +
           if (default_fg != NULL) {

     

       1030
       1030
       +
               ctx->default_fg = convert_colour(_ctx, *default_fg);

     

       1031
       1031
       +
           } else {

     

       1032
       1032
       +
               ctx->default_fg = convert_colour(_ctx, 0x00aaaaaa); // foreground (grey)

     

       1033
       1033
       +
           }

     

       1034
       1034
       +
       

     

       1035
       1035
       +
           if (default_bg_bright != NULL) {

     

       1036
       1036
       +
               ctx->default_bg_bright = convert_colour(_ctx, *default_bg_bright);

     

       1037
       1037
       +
           } else {

     

       1038
       1038
       +
               ctx->default_bg_bright = convert_colour(_ctx, 0x00555555); // background (black)

     

       1039
       1039
       +
           }

     

       1040
       1040
       +
       

     

       1041
       1041
       +
           if (default_fg_bright != NULL) {

     

       1042
       1042
       +
               ctx->default_fg_bright = convert_colour(_ctx, *default_fg_bright);

     

       1043
       1043
       +
           } else {

     

       1044
       1044
       +
               ctx->default_fg_bright = convert_colour(_ctx, 0x00ffffff); // foreground (grey)

     

       1045
       1045
       +
           }

     

       1046
       1046
       +
       

     

       1047
       1047
       +
           ctx->text_fg = ctx->default_fg;

     

       1048
       1048
       +
           ctx->text_bg = 0xffffffff;

     

       1049
       1049
       +
       

     

       1050
       1050
       +
           ctx->framebuffer = (void *)framebuffer;

     

       1051
       1051
       +
           ctx->width = width;

     

       1052
       1052
       +
           ctx->height = height;

     

       1053
       1053
       +
           ctx->pitch = pitch;

     

       1054
       1054
       +
       

     

       1055
       1055
       +
       #define FONT_BYTES ((font_width * font_height * FLANTERM_FB_FONT_GLYPHS) / 8)

     

       1056
       1056
       +
       

     

       1057
       1057
       +
           if (font != NULL) {

     

       1058
       1058
       +
               ctx->font_width = font_width;

     

       1059
       1059
       +
               ctx->font_height = font_height;

     

       1060
       1060
       +
               ctx->font_bits_size = FONT_BYTES;

     

       1061
       1061
       +
               ctx->font_bits = _malloc(ctx->font_bits_size);

     

       1062
       1062
       +
               if (ctx->font_bits == NULL) {

     

       1063
       1063
       +
                   goto fail;

     

       1064
       1064
       +
               }

     

       1065
       1065
       +
               memcpy(ctx->font_bits, font, ctx->font_bits_size);

     

       1066
       1066
       +
           } else {

     

       1067
       1067
       +
               ctx->font_width = font_width = 8;

     

       1068
       1068
       +
               ctx->font_height = font_height = 16;

     

       1069
       1069
       +
               ctx->font_bits_size = FONT_BYTES;

     

       1070
       1070
       +
               font_spacing = 1;

     

       1071
       1071
       +
               ctx->font_bits = _malloc(ctx->font_bits_size);

     

       1072
       1072
       +
               if (ctx->font_bits == NULL) {

     

       1073
       1073
       +
                   goto fail;

     

       1074
       1074
       +
               }

     

       1075
       1075
       +
               memcpy(ctx->font_bits, builtin_font, ctx->font_bits_size);

     

       1076
       1076
       +
           }

     

       1077
       1077
       +
       

     

       1078
       1078
       +
       #undef FONT_BYTES

     

       1079
       1079
       +
       

     

       1080
       1080
       +
           ctx->font_width += font_spacing;

     

       1081
       1081
       +
       

     

       1082
       1082
       +
           ctx->font_bool_size = FLANTERM_FB_FONT_GLYPHS * font_height * ctx->font_width * sizeof(bool);

     

       1083
       1083
       +
           ctx->font_bool = _malloc(ctx->font_bool_size);

     

       1084
       1084
       +
           if (ctx->font_bool == NULL) {

     

       1085
       1085
       +
               goto fail;

     

       1086
       1086
       +
           }

     

       1087
       1087
       +
       

     

       1088
       1088
       +
           for (size_t i = 0; i < FLANTERM_FB_FONT_GLYPHS; i++) {

     

       1089
       1089
       +
               uint8_t *glyph = &ctx->font_bits[i * font_height];

     

       1090
       1090
       +
       

     

       1091
       1091
       +
               for (size_t y = 0; y < font_height; y++) {

     

       1092
       1092
       +
                   // NOTE: the characters in VGA fonts are always one byte wide.

     

       1093
       1093
       +
                   // 9 dot wide fonts have 8 dots and one empty column, except

     

       1094
       1094
       +
                   // characters 0xC0-0xDF replicate column 9.

     

       1095
       1095
       +
                   for (size_t x = 0; x < 8; x++) {

     

       1096
       1096
       +
                       size_t offset = i * font_height * ctx->font_width + y * ctx->font_width + x;

     

       1097
       1097
       +
       

     

       1098
       1098
       +
                       if ((glyph[y] & (0x80 >> x))) {

     

       1099
       1099
       +
                           ctx->font_bool[offset] = true;

     

       1100
       1100
       +
                       } else {

     

       1101
       1101
       +
                           ctx->font_bool[offset] = false;

     

       1102
       1102
       +
                       }

     

       1103
       1103
       +
                   }

     

       1104
       1104
       +
                   // fill columns above 8 like VGA Line Graphics Mode does

     

       1105
       1105
       +
                   for (size_t x = 8; x < ctx->font_width; x++) {

     

       1106
       1106
       +
                       size_t offset = i * font_height * ctx->font_width + y * ctx->font_width + x;

     

       1107
       1107
       +
       

     

       1108
       1108
       +
                       if (i >= 0xc0 && i <= 0xdf) {

     

       1109
       1109
       +
                           ctx->font_bool[offset] = (glyph[y] & 1);

     

       1110
       1110
       +
                       } else {

     

       1111
       1111
       +
                           ctx->font_bool[offset] = false;

     

       1112
       1112
       +
                       }

     

       1113
       1113
       +
                   }

     

       1114
       1114
       +
               }

     

       1115
       1115
       +
           }

     

       1116
       1116
       +
       

     

       1117
       1117
       +
           ctx->font_scale_x = font_scale_x;

     

       1118
       1118
       +
           ctx->font_scale_y = font_scale_y;

     

       1119
       1119
       +
       

     

       1120
       1120
       +
           ctx->glyph_width = ctx->font_width * font_scale_x;

     

       1121
       1121
       +
           ctx->glyph_height = font_height * font_scale_y;

     

       1122
       1122
       +
       

     

       1123
       1123
       +
           _ctx->cols = (ctx->width - margin * 2) / ctx->glyph_width;

     

       1124
       1124
       +
           _ctx->rows = (ctx->height - margin * 2) / ctx->glyph_height;

     

       1125
       1125
       +
       

     

       1126
       1126
       +
           ctx->offset_x = margin + ((ctx->width - margin * 2) % ctx->glyph_width) / 2;

     

       1127
       1127
       +
           ctx->offset_y = margin + ((ctx->height - margin * 2) % ctx->glyph_height) / 2;

     

       1128
       1128
       +
       

     

       1129
       1129
       +
           ctx->grid_size = _ctx->rows * _ctx->cols * sizeof(struct flanterm_fb_char);

     

       1130
       1130
       +
           ctx->grid = _malloc(ctx->grid_size);

     

       1131
       1131
       +
           if (ctx->grid == NULL) {

     

       1132
       1132
       +
               goto fail;

     

       1133
       1133
       +
           }

     

       1134
       1134
       +
           for (size_t i = 0; i < _ctx->rows * _ctx->cols; i++) {

     

       1135
       1135
       +
               ctx->grid[i].c = ' ';

     

       1136
       1136
       +
               ctx->grid[i].fg = ctx->text_fg;

     

       1137
       1137
       +
               ctx->grid[i].bg = ctx->text_bg;

     

       1138
       1138
       +
           }

     

       1139
       1139
       +
       

     

       1140
       1140
       +
           ctx->queue_size = _ctx->rows * _ctx->cols * sizeof(struct flanterm_fb_queue_item);

     

       1141
       1141
       +
           ctx->queue = _malloc(ctx->queue_size);

     

       1142
       1142
       +
           if (ctx->queue == NULL) {

     

       1143
       1143
       +
               goto fail;

     

       1144
       1144
       +
           }

     

       1145
       1145
       +
           ctx->queue_i = 0;

     

       1146
       1146
       +
           memset(ctx->queue, 0, ctx->queue_size);

     

       1147
       1147
       +
       

     

       1148
       1148
       +
           ctx->map_size = _ctx->rows * _ctx->cols * sizeof(struct flanterm_fb_queue_item *);

     

       1149
       1149
       +
           ctx->map = _malloc(ctx->map_size);

     

       1150
       1150
       +
           if (ctx->map == NULL) {

     

       1151
       1151
       +
               goto fail;

     

       1152
       1152
       +
           }

     

       1153
       1153
       +
           memset(ctx->map, 0, ctx->map_size);

     

       1154
       1154
       +
       

     

       1155
       1155
       +
           if (canvas != NULL) {

     

       1156
       1156
       +
               ctx->canvas_size = ctx->width * ctx->height * sizeof(uint32_t);

     

       1157
       1157
       +
               ctx->canvas = _malloc(ctx->canvas_size);

     

       1158
       1158
       +
               if (ctx->canvas == NULL) {

     

       1159
       1159
       +
                   goto fail;

     

       1160
       1160
       +
               }

     

       1161
       1161
       +
               for (size_t i = 0; i < ctx->width * ctx->height; i++) {

     

       1162
       1162
       +
                   ctx->canvas[i] = convert_colour(_ctx, canvas[i]);

     

       1163
       1163
       +
               }

     

       1164
       1164
       +
           }

     

       1165
       1165
       +
       

     

       1166
       1166
       +
           if (font_scale_x == 1 && font_scale_y == 1) {

     

       1167
       1167
       +
               if (canvas == NULL) {

     

       1168
       1168
       +
                   ctx->plot_char = plot_char_unscaled_uncanvas;

     

       1169
       1169
       +
               } else {

     

       1170
       1170
       +
                   ctx->plot_char = plot_char_unscaled_canvas;

     

       1171
       1171
       +
               }

     

       1172
       1172
       +
           } else {

     

       1173
       1173
       +
               if (canvas == NULL) {

     

       1174
       1174
       +
                   ctx->plot_char = plot_char_scaled_uncanvas;

     

       1175
       1175
       +
               } else {

     

       1176
       1176
       +
                   ctx->plot_char = plot_char_scaled_canvas;

     

       1177
       1177
       +
               }

     

       1178
       1178
       +
           }

     

       1179
       1179
       +
       

     

       1180
       1180
       +
           _ctx->raw_putchar = flanterm_fb_raw_putchar;

     

       1181
       1181
       +
           _ctx->clear = flanterm_fb_clear;

     

       1182
       1182
       +
           _ctx->set_cursor_pos = flanterm_fb_set_cursor_pos;

     

       1183
       1183
       +
           _ctx->get_cursor_pos = flanterm_fb_get_cursor_pos;

     

       1184
       1184
       +
           _ctx->set_text_fg = flanterm_fb_set_text_fg;

     

       1185
       1185
       +
           _ctx->set_text_bg = flanterm_fb_set_text_bg;

     

       1186
       1186
       +
           _ctx->set_text_fg_bright = flanterm_fb_set_text_fg_bright;

     

       1187
       1187
       +
           _ctx->set_text_bg_bright = flanterm_fb_set_text_bg_bright;

     

       1188
       1188
       +
           _ctx->set_text_fg_rgb = flanterm_fb_set_text_fg_rgb;

     

       1189
       1189
       +
           _ctx->set_text_bg_rgb = flanterm_fb_set_text_bg_rgb;

     

       1190
       1190
       +
           _ctx->set_text_fg_default = flanterm_fb_set_text_fg_default;

     

       1191
       1191
       +
           _ctx->set_text_bg_default = flanterm_fb_set_text_bg_default;

     

       1192
       1192
       +
           _ctx->set_text_fg_default_bright = flanterm_fb_set_text_fg_default_bright;

     

       1193
       1193
       +
           _ctx->set_text_bg_default_bright = flanterm_fb_set_text_bg_default_bright;

     

       1194
       1194
       +
           _ctx->move_character = flanterm_fb_move_character;

     

       1195
       1195
       +
           _ctx->scroll = flanterm_fb_scroll;

     

       1196
       1196
       +
           _ctx->revscroll = flanterm_fb_revscroll;

     

       1197
       1197
       +
           _ctx->swap_palette = flanterm_fb_swap_palette;

     

       1198
       1198
       +
           _ctx->save_state = flanterm_fb_save_state;

     

       1199
       1199
       +
           _ctx->restore_state = flanterm_fb_restore_state;

     

       1200
       1200
       +
           _ctx->double_buffer_flush = flanterm_fb_double_buffer_flush;

     

       1201
       1201
       +
           _ctx->full_refresh = flanterm_fb_full_refresh;

     

       1202
       1202
       +
           _ctx->deinit = flanterm_fb_deinit;

     

       1203
       1203
       +
       

     

       1204
       1204
       +
           flanterm_context_reinit(_ctx);

     

       1205
       1205
       +
           flanterm_fb_full_refresh(_ctx);

     

       1206
       1206
       +
       

     

       1207
       1207
       +
       #ifndef FLANTERM_FB_DISABLE_BUMP_ALLOC

     

       1208
       1208
       +
           if (_malloc == bump_alloc) {

     

       1209
       1209
       +
               bump_allocated_instance = true;

     

       1210
       1210
       +
           }

     

       1211
       1211
       +
       #endif

     

       1212
       1212
       +
       

     

       1213
       1213
       +
           return _ctx;

     

       1214
       1214
       +
       

     

       1215
       1215
       +
       fail:

     

       1216
       1216
       +
           if (ctx == NULL) {

     

       1217
       1217
       +
               return NULL;

     

       1218
       1218
       +
           }

     

       1219
       1219
       +
       

     

       1220
       1220
       +
       #ifndef FLANTERM_FB_DISABLE_BUMP_ALLOC

     

       1221
       1221
       +
           if (_malloc == bump_alloc) {

     

       1222
       1222
       +
               bump_alloc_ptr = 0;

     

       1223
       1223
       +
               return NULL;

     

       1224
       1224
       +
           }

     

       1225
       1225
       +
       #endif

     

       1226
       1226
       +
       

     

       1227
       1227
       +
           if (_free == NULL) {

     

       1228
       1228
       +
               return NULL;

     

       1229
       1229
       +
           }

     

       1230
       1230
       +
       

     

       1231
       1231
       +
           if (ctx->canvas != NULL) {

     

       1232
       1232
       +
               _free(ctx->canvas, ctx->canvas_size);

     

       1233
       1233
       +
           }

     

       1234
       1234
       +
           if (ctx->map != NULL) {

     

       1235
       1235
       +
               _free(ctx->map, ctx->map_size);

     

       1236
       1236
       +
           }

     

       1237
       1237
       +
           if (ctx->queue != NULL) {

     

       1238
       1238
       +
               _free(ctx->queue, ctx->queue_size);

     

       1239
       1239
       +
           }

     

       1240
       1240
       +
           if (ctx->grid != NULL) {

     

       1241
       1241
       +
               _free(ctx->grid, ctx->grid_size);

     

       1242
       1242
       +
           }

     

       1243
       1243
       +
           if (ctx->font_bool != NULL) {

     

       1244
       1244
       +
               _free(ctx->font_bool, ctx->font_bool_size);

     

       1245
       1245
       +
           }

     

       1246
       1246
       +
           if (ctx->font_bits != NULL) {

     

       1247
       1247
       +
               _free(ctx->font_bits, ctx->font_bits_size);

     

       1248
       1248
       +
           }

     

       1249
       1249
       +
           if (ctx != NULL) {

     

       1250
       1250
       +
               _free(ctx, sizeof(struct flanterm_fb_context));

     

       1251
       1251
       +
           }

     

       1252
       1252
       +
       

     

       1253
       1253
       +
           return NULL;

     

       1254
       1254
       +
       }

+68

src/flanterm_backends/fb.h

···

       1
       1
       +
       /* Copyright (C) 2022-2025 mintsuki and contributors.

     

       2
       2
       +
        *

     

       3
       3
       +
        * Redistribution and use in source and binary forms, with or without

     

       4
       4
       +
        * modification, are permitted provided that the following conditions are met:

     

       5
       5
       +
        *

     

       6
       6
       +
        * 1. Redistributions of source code must retain the above copyright notice,

     

       7
       7
       +
        *    this list of conditions and the following disclaimer.

     

       8
       8
       +
        *

     

       9
       9
       +
        * 2. Redistributions in binary form must reproduce the above copyright notice,

     

       10
       10
       +
        *    this list of conditions and the following disclaimer in the documentation

     

       11
       11
       +
        *    and/or other materials provided with the distribution.

     

       12
       12
       +
        *

     

       13
       13
       +
        * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

     

       14
       14
       +
        * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

     

       15
       15
       +
        * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

     

       16
       16
       +
        * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE

     

       17
       17
       +
        * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

     

       18
       18
       +
        * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

     

       19
       19
       +
        * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

     

       20
       20
       +
        * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

     

       21
       21
       +
        * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

     

       22
       22
       +
        * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

     

       23
       23
       +
        * POSSIBILITY OF SUCH DAMAGE.

     

       24
       24
       +
        */

     

       25
       25
       +
       

     

       26
       26
       +
       #ifndef FLANTERM_FB_H

     

       27
       27
       +
       #define FLANTERM_FB_H 1

     

       28
       28
       +
       

     

       29
       29
       +
       #include <stdint.h>

     

       30
       30
       +
       #include <stddef.h>

     

       31
       31
       +
       #include <stdbool.h>

     

       32
       32
       +
       

     

       33
       33
       +
       #ifdef __cplusplus

     

       34
       34
       +
       extern "C" {

     

       35
       35
       +
       #endif

     

       36
       36
       +
       

     

       37
       37
       +
       #include "../flanterm.h"

     

       38
       38
       +
       

     

       39
       39
       +
       #ifdef FLANTERM_IN_FLANTERM

     

       40
       40
       +
       

     

       41
       41
       +
       #include "fb_private.h"

     

       42
       42
       +
       

     

       43
       43
       +
       #endif

     

       44
       44
       +
       

     

       45
       45
       +
       struct flanterm_context *flanterm_fb_init(

     

       46
       46
       +
           /* If _malloc and _free are nulled, use the bump allocated instance (1 use only). */

     

       47
       47
       +
           void *(*_malloc)(size_t size),

     

       48
       48
       +
           void (*_free)(void *ptr, size_t size),

     

       49
       49
       +
           uint32_t *framebuffer, size_t width, size_t height, size_t pitch,

     

       50
       50
       +
           uint8_t red_mask_size, uint8_t red_mask_shift,

     

       51
       51
       +
           uint8_t green_mask_size, uint8_t green_mask_shift,

     

       52
       52
       +
           uint8_t blue_mask_size, uint8_t blue_mask_shift,

     

       53
       53
       +
           uint32_t *canvas, /* If nulled, no canvas. */

     

       54
       54
       +
           uint32_t *ansi_colours, uint32_t *ansi_bright_colours, /* If nulled, default. */

     

       55
       55
       +
           uint32_t *default_bg, uint32_t *default_fg, /* If nulled, default. */

     

       56
       56
       +
           uint32_t *default_bg_bright, uint32_t *default_fg_bright, /* If nulled, default. */

     

       57
       57
       +
           /* If font is null, use default font and font_width and font_height ignored. */

     

       58
       58
       +
           void *font, size_t font_width, size_t font_height, size_t font_spacing,

     

       59
       59
       +
           /* If scale_x and scale_y are 0, automatically scale font based on resolution. */

     

       60
       60
       +
           size_t font_scale_x, size_t font_scale_y,

     

       61
       61
       +
           size_t margin

     

       62
       62
       +
       );

     

       63
       63
       +
       

     

       64
       64
       +
       #ifdef __cplusplus

     

       65
       65
       +
       }

     

       66
       66
       +
       #endif

     

       67
       67
       +
       

     

       68
       68
       +
       #endif

+121

src/flanterm_backends/fb_private.h

···

       1
       1
       +
       /* Copyright (C) 2022-2025 mintsuki and contributors.

     

       2
       2
       +
        *

     

       3
       3
       +
        * Redistribution and use in source and binary forms, with or without

     

       4
       4
       +
        * modification, are permitted provided that the following conditions are met:

     

       5
       5
       +
        *

     

       6
       6
       +
        * 1. Redistributions of source code must retain the above copyright notice,

     

       7
       7
       +
        *    this list of conditions and the following disclaimer.

     

       8
       8
       +
        *

     

       9
       9
       +
        * 2. Redistributions in binary form must reproduce the above copyright notice,

     

       10
       10
       +
        *    this list of conditions and the following disclaimer in the documentation

     

       11
       11
       +
        *    and/or other materials provided with the distribution.

     

       12
       12
       +
        *

     

       13
       13
       +
        * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

     

       14
       14
       +
        * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

     

       15
       15
       +
        * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

     

       16
       16
       +
        * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE

     

       17
       17
       +
        * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

     

       18
       18
       +
        * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

     

       19
       19
       +
        * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

     

       20
       20
       +
        * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

     

       21
       21
       +
        * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

     

       22
       22
       +
        * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

     

       23
       23
       +
        * POSSIBILITY OF SUCH DAMAGE.

     

       24
       24
       +
        */

     

       25
       25
       +
       

     

       26
       26
       +
       #ifndef FLANTERM_FB_PRIVATE_H

     

       27
       27
       +
       #define FLANTERM_FB_PRIVATE_H 1

     

       28
       28
       +
       

     

       29
       29
       +
       #ifndef FLANTERM_IN_FLANTERM

     

       30
       30
       +
       #error "Do not use fb_private.h. Use interfaces defined in fb.h only."

     

       31
       31
       +
       #endif

     

       32
       32
       +
       

     

       33
       33
       +
       #include <stdint.h>

     

       34
       34
       +
       #include <stddef.h>

     

       35
       35
       +
       #include <stdbool.h>

     

       36
       36
       +
       

     

       37
       37
       +
       #ifdef __cplusplus

     

       38
       38
       +
       extern "C" {

     

       39
       39
       +
       #endif

     

       40
       40
       +
       

     

       41
       41
       +
       #define FLANTERM_FB_FONT_GLYPHS 256

     

       42
       42
       +
       

     

       43
       43
       +
       struct flanterm_fb_char {

     

       44
       44
       +
           uint32_t c;

     

       45
       45
       +
           uint32_t fg;

     

       46
       46
       +
           uint32_t bg;

     

       47
       47
       +
       };

     

       48
       48
       +
       

     

       49
       49
       +
       struct flanterm_fb_queue_item {

     

       50
       50
       +
           size_t x, y;

     

       51
       51
       +
           struct flanterm_fb_char c;

     

       52
       52
       +
       };

     

       53
       53
       +
       

     

       54
       54
       +
       struct flanterm_fb_context {

     

       55
       55
       +
           struct flanterm_context term;

     

       56
       56
       +
       

     

       57
       57
       +
           void (*plot_char)(struct flanterm_context *ctx, struct flanterm_fb_char *c, size_t x, size_t y);

     

       58
       58
       +
       

     

       59
       59
       +
           size_t font_width;

     

       60
       60
       +
           size_t font_height;

     

       61
       61
       +
           size_t glyph_width;

     

       62
       62
       +
           size_t glyph_height;

     

       63
       63
       +
       

     

       64
       64
       +
           size_t font_scale_x;

     

       65
       65
       +
           size_t font_scale_y;

     

       66
       66
       +
       

     

       67
       67
       +
           size_t offset_x, offset_y;

     

       68
       68
       +
       

     

       69
       69
       +
           volatile uint32_t *framebuffer;

     

       70
       70
       +
           size_t pitch;

     

       71
       71
       +
           size_t width;

     

       72
       72
       +
           size_t height;

     

       73
       73
       +
           size_t bpp;

     

       74
       74
       +
       

     

       75
       75
       +
           uint8_t red_mask_size, red_mask_shift;

     

       76
       76
       +
           uint8_t green_mask_size, green_mask_shift;

     

       77
       77
       +
           uint8_t blue_mask_size, blue_mask_shift;

     

       78
       78
       +
       

     

       79
       79
       +
           size_t font_bits_size;

     

       80
       80
       +
           uint8_t *font_bits;

     

       81
       81
       +
           size_t font_bool_size;

     

       82
       82
       +
           bool *font_bool;

     

       83
       83
       +
       

     

       84
       84
       +
           uint32_t ansi_colours[8];

     

       85
       85
       +
           uint32_t ansi_bright_colours[8];

     

       86
       86
       +
           uint32_t default_fg, default_bg;

     

       87
       87
       +
           uint32_t default_fg_bright, default_bg_bright;

     

       88
       88
       +
       

     

       89
       89
       +
           size_t canvas_size;

     

       90
       90
       +
           uint32_t *canvas;

     

       91
       91
       +
       

     

       92
       92
       +
           size_t grid_size;

     

       93
       93
       +
           size_t queue_size;

     

       94
       94
       +
           size_t map_size;

     

       95
       95
       +
       

     

       96
       96
       +
           struct flanterm_fb_char *grid;

     

       97
       97
       +
       

     

       98
       98
       +
           struct flanterm_fb_queue_item *queue;

     

       99
       99
       +
           size_t queue_i;

     

       100
       100
       +
       

     

       101
       101
       +
           struct flanterm_fb_queue_item **map;

     

       102
       102
       +
       

     

       103
       103
       +
           uint32_t text_fg;

     

       104
       104
       +
           uint32_t text_bg;

     

       105
       105
       +
           size_t cursor_x;

     

       106
       106
       +
           size_t cursor_y;

     

       107
       107
       +
       

     

       108
       108
       +
           uint32_t saved_state_text_fg;

     

       109
       109
       +
           uint32_t saved_state_text_bg;

     

       110
       110
       +
           size_t saved_state_cursor_x;

     

       111
       111
       +
           size_t saved_state_cursor_y;

     

       112
       112
       +
       

     

       113
       113
       +
           size_t old_cursor_x;

     

       114
       114
       +
           size_t old_cursor_y;

     

       115
       115
       +
       };

     

       116
       116
       +
       

     

       117
       117
       +
       #ifdef __cplusplus

     

       118
       118
       +
       }

     

       119
       119
       +
       #endif

     

       120
       120
       +
       

     

       121
       121
       +
       #endif

+123

src/flanterm_private.h

···

       1
       1
       +
       /* Copyright (C) 2022-2025 mintsuki and contributors.

     

       2
       2
       +
        *

     

       3
       3
       +
        * Redistribution and use in source and binary forms, with or without

     

       4
       4
       +
        * modification, are permitted provided that the following conditions are met:

     

       5
       5
       +
        *

     

       6
       6
       +
        * 1. Redistributions of source code must retain the above copyright notice,

     

       7
       7
       +
        *    this list of conditions and the following disclaimer.

     

       8
       8
       +
        *

     

       9
       9
       +
        * 2. Redistributions in binary form must reproduce the above copyright notice,

     

       10
       10
       +
        *    this list of conditions and the following disclaimer in the documentation

     

       11
       11
       +
        *    and/or other materials provided with the distribution.

     

       12
       12
       +
        *

     

       13
       13
       +
        * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

     

       14
       14
       +
        * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

     

       15
       15
       +
        * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

     

       16
       16
       +
        * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE

     

       17
       17
       +
        * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

     

       18
       18
       +
        * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

     

       19
       19
       +
        * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

     

       20
       20
       +
        * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

     

       21
       21
       +
        * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

     

       22
       22
       +
        * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

     

       23
       23
       +
        * POSSIBILITY OF SUCH DAMAGE.

     

       24
       24
       +
        */

     

       25
       25
       +
       

     

       26
       26
       +
       #ifndef FLANTERM_PRIVATE_H

     

       27
       27
       +
       #define FLANTERM_PRIVATE_H 1

     

       28
       28
       +
       

     

       29
       29
       +
       #ifndef FLANTERM_IN_FLANTERM

     

       30
       30
       +
       #error "Do not use flanterm_private.h. Use interfaces defined in flanterm.h only."

     

       31
       31
       +
       #endif

     

       32
       32
       +
       

     

       33
       33
       +
       #include <stddef.h>

     

       34
       34
       +
       #include <stdint.h>

     

       35
       35
       +
       #include <stdbool.h>

     

       36
       36
       +
       

     

       37
       37
       +
       #ifdef __cplusplus

     

       38
       38
       +
       extern "C" {

     

       39
       39
       +
       #endif

     

       40
       40
       +
       

     

       41
       41
       +
       #define FLANTERM_MAX_ESC_VALUES 16

     

       42
       42
       +
       

     

       43
       43
       +
       struct flanterm_context {

     

       44
       44
       +
           /* internal use */

     

       45
       45
       +
       

     

       46
       46
       +
           size_t tab_size;

     

       47
       47
       +
           bool autoflush;

     

       48
       48
       +
           bool cursor_enabled;

     

       49
       49
       +
           bool scroll_enabled;

     

       50
       50
       +
           bool control_sequence;

     

       51
       51
       +
           bool escape;

     

       52
       52
       +
           bool osc;

     

       53
       53
       +
           bool osc_escape;

     

       54
       54
       +
           bool rrr;

     

       55
       55
       +
           bool discard_next;

     

       56
       56
       +
           bool bold;

     

       57
       57
       +
           bool bg_bold;

     

       58
       58
       +
           bool reverse_video;

     

       59
       59
       +
           bool dec_private;

     

       60
       60
       +
           bool insert_mode;

     

       61
       61
       +
           bool csi_unhandled;

     

       62
       62
       +
           uint64_t code_point;

     

       63
       63
       +
           size_t unicode_remaining;

     

       64
       64
       +
           uint8_t g_select;

     

       65
       65
       +
           uint8_t charsets[2];

     

       66
       66
       +
           size_t current_charset;

     

       67
       67
       +
           size_t escape_offset;

     

       68
       68
       +
           size_t esc_values_i;

     

       69
       69
       +
           size_t saved_cursor_x;

     

       70
       70
       +
           size_t saved_cursor_y;

     

       71
       71
       +
           size_t current_primary;

     

       72
       72
       +
           size_t current_bg;

     

       73
       73
       +
           size_t scroll_top_margin;

     

       74
       74
       +
           size_t scroll_bottom_margin;

     

       75
       75
       +
           uint32_t esc_values[FLANTERM_MAX_ESC_VALUES];

     

       76
       76
       +
           uint64_t oob_output;

     

       77
       77
       +
           bool saved_state_bold;

     

       78
       78
       +
           bool saved_state_bg_bold;

     

       79
       79
       +
           bool saved_state_reverse_video;

     

       80
       80
       +
           size_t saved_state_current_charset;

     

       81
       81
       +
           size_t saved_state_current_primary;

     

       82
       82
       +
           size_t saved_state_current_bg;

     

       83
       83
       +
       

     

       84
       84
       +
           /* to be set by backend */

     

       85
       85
       +
       

     

       86
       86
       +
           size_t rows, cols;

     

       87
       87
       +
       

     

       88
       88
       +
           void (*raw_putchar)(struct flanterm_context *, uint8_t c);

     

       89
       89
       +
           void (*clear)(struct flanterm_context *, bool move);

     

       90
       90
       +
           void (*set_cursor_pos)(struct flanterm_context *, size_t x, size_t y);

     

       91
       91
       +
           void (*get_cursor_pos)(struct flanterm_context *, size_t *x, size_t *y);

     

       92
       92
       +
           void (*set_text_fg)(struct flanterm_context *, size_t fg);

     

       93
       93
       +
           void (*set_text_bg)(struct flanterm_context *, size_t bg);

     

       94
       94
       +
           void (*set_text_fg_bright)(struct flanterm_context *, size_t fg);

     

       95
       95
       +
           void (*set_text_bg_bright)(struct flanterm_context *, size_t bg);

     

       96
       96
       +
           void (*set_text_fg_rgb)(struct flanterm_context *, uint32_t fg);

     

       97
       97
       +
           void (*set_text_bg_rgb)(struct flanterm_context *, uint32_t bg);

     

       98
       98
       +
           void (*set_text_fg_default)(struct flanterm_context *);

     

       99
       99
       +
           void (*set_text_bg_default)(struct flanterm_context *);

     

       100
       100
       +
           void (*set_text_fg_default_bright)(struct flanterm_context *);

     

       101
       101
       +
           void (*set_text_bg_default_bright)(struct flanterm_context *);

     

       102
       102
       +
           void (*move_character)(struct flanterm_context *, size_t new_x, size_t new_y, size_t old_x, size_t old_y);

     

       103
       103
       +
           void (*scroll)(struct flanterm_context *);

     

       104
       104
       +
           void (*revscroll)(struct flanterm_context *);

     

       105
       105
       +
           void (*swap_palette)(struct flanterm_context *);

     

       106
       106
       +
           void (*save_state)(struct flanterm_context *);

     

       107
       107
       +
           void (*restore_state)(struct flanterm_context *);

     

       108
       108
       +
           void (*double_buffer_flush)(struct flanterm_context *);

     

       109
       109
       +
           void (*full_refresh)(struct flanterm_context *);

     

       110
       110
       +
           void (*deinit)(struct flanterm_context *, void (*)(void *, size_t));

     

       111
       111
       +
       

     

       112
       112
       +
           /* to be set by client */

     

       113
       113
       +
       

     

       114
       114
       +
           void (*callback)(struct flanterm_context *, uint64_t, uint64_t, uint64_t, uint64_t);

     

       115
       115
       +
       };

     

       116
       116
       +
       

     

       117
       117
       +
       void flanterm_context_reinit(struct flanterm_context *ctx);

     

       118
       118
       +
       

     

       119
       119
       +
       #ifdef __cplusplus

     

       120
       120
       +
       }

     

       121
       121
       +
       #endif

     

       122
       122
       +
       

     

       123
       123
       +
       #endif

+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