hokusai-zero 0.1.1

data/grammar/src/scanner.c

@@ -0,0 +1,258 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include "tree_sitter/parser.h"
+#include <unistd.h>
+#include <string.h>
+enum TokenType
+{
+  INDENT,
+  DEDENT,
+  NEWLINE,
+  ERROR_SENTINEL,
+};
+
+struct HmlScanList
+{
+  long int col;
+  struct HmlScanList* next;
+};
+
+struct HmlScanner
+{
+  struct HmlScanList* list;
+};
+
+/**
+  prepends an item to the stack
+*/
+static void scanner_push(struct HmlScanList** scanner, long int col)
+{
+  struct HmlScanList* first = malloc(sizeof(struct HmlScanList));
+  first->col = col;
+  first->next = *scanner;
+  *scanner = first;
+}
+
+/**
+  removes a item from the stack
+*/
+static bool scanner_pop(struct HmlScanList** scanner)
+{
+  if ((*scanner)->next == NULL)
+  {
+    return false;
+  }
+  else
+  {
+    struct HmlScanList* head = *scanner;
+    struct HmlScanList* next = head->next;
+    free(head);
+    *scanner = next;
+    return true;
+    
+  }
+}
+
+/**
+  serialize the stack
+  8 -> 6 -> 4 -> 2 -> 0
+
+  "0:2:4:6:8"
+*/
+static void scanner_serialize(struct HmlScanList** scanner, char* buffer)
+{
+  int i = 0; 
+  struct HmlScanList* head = *scanner;
+  i = sprintf(buffer, "%ld", head->col);
+  head = head->next;
+  while (head != NULL && head->col != 0)
+  {
+    char tmp[200];
+    sprintf(tmp, "%ld:%s", head->col, buffer);
+    strcpy(buffer, tmp);
+    head = head->next;
+  }
+  // printf("buffer is %s (%d) it(%d)\n", buffer, strlen(buffer), i);
+}
+
+/**
+  deserialize the stack
+*/
+static void scanner_deserialize(struct HmlScanner* scanner, const char* buffer, unsigned len)
+{
+  // printf("stack serial: %s, len: %u\n", buffer,len);
+  if (len <= 0)
+  {
+    return;
+  }
+  while (scanner_pop(&scanner->list));
+
+  char* scan_ep;
+  char scan_buffer[32];
+  bool scanned_indent = false;
+  int track = 0;
+  int done = 0;
+
+  for (int i = 0; i < len; i++)
+  {
+    char letter = buffer[i];
+    if (buffer[i] == ':')
+    {
+      // parse indents and clear buffer
+      scan_buffer[i] = '\0';
+      long int col = strtol(scan_buffer, &scan_ep, 0);
+      scanner_push(&scanner->list, col);
+
+      for (int ii=0;ii<i;ii++)
+      {
+        scan_buffer[ii] = '\0';
+      }
+
+      track = i;
+    }
+    else
+    {
+      scan_buffer[done] = letter;
+    }
+    done = i - track;
+  }
+
+  scan_buffer[done + 1] = '\0';
+  long int col = strtol(scan_buffer, &scan_ep, 0);
+  scanner_push(&scanner->list, col);
+}
+
+void* tree_sitter_hml_external_scanner_create()
+{
+  // printf("create scanner\n");
+  struct HmlScanner* scanner = malloc(sizeof(struct HmlScanner));
+  scanner->list = malloc(sizeof(struct HmlScanList));
+  scanner->list->col = 0;
+  scanner->list->next = NULL;
+  return scanner;
+}
+
+void tree_sitter_hml_external_scanner_destroy(void* payload)
+{
+  // printf("destroy scanner\n");
+  struct HmlScanner* scanner = (struct HmlScanner*) payload;
+  while(scanner_pop(&scanner->list));
+  free(scanner->list);
+  free(scanner);
+}
+
+unsigned tree_sitter_hml_external_scanner_serialize(void* payload, char* buffer)
+{
+  struct HmlScanner* scanner = (struct HmlScanner*) payload;
+  // printf("serizliae %ld\n", scanner->list->col);
+  scanner_serialize(&scanner->list, buffer);
+  return (unsigned) strlen(buffer);
+}
+
+void tree_sitter_hml_external_scanner_deserialize(void* payload, const char* buffer, unsigned len)
+{
+  struct HmlScanner* scanner = (struct HmlScanner*) payload;
+  scanner_deserialize(scanner, buffer, len);
+  // printf("deserialized, %ld\n", scanner->list->col);
+}
+
+bool tree_sitter_hml_external_scanner_scan(void* payload, TSLexer* lexer, const bool* valid_symbols)
+{
+  struct HmlScanner* scanner = (struct HmlScanner*) payload;
+
+  if (valid_symbols[ERROR_SENTINEL]) {
+    return false;
+  }
+
+  uint32_t current_column;
+
+  if (lexer->eof(lexer) || (lexer->lookahead == '[' && lexer->get_column(lexer) == 0))
+  {
+    // printf("COLUMN: %ld\n", scanner->list->col);
+    if (scanner->list->col != 0)
+    {
+      scanner_pop(&scanner->list);
+      lexer->result_symbol = DEDENT;
+      return true;
+    }
+  }
+
+  // find column position of next non whitespace char.
+  if (valid_symbols[INDENT] || valid_symbols[NEWLINE] || valid_symbols[DEDENT])
+  {    
+    // {
+
+    //   return false;
+    // }
+
+    while (true)
+    {
+      if (lexer->lookahead != ' ' && lexer->lookahead != '\f' && lexer->lookahead != '\n' && lexer->lookahead != '\t' && lexer->lookahead != '\0')
+      {
+        if (lexer->lookahead == '#' || lexer->lookahead == '{' || lexer->lookahead == '.') return false;
+        
+        current_column = (long int) lexer->get_column(lexer) + 1;
+        long int a = -1;
+        if (scanner->list->next) a = scanner->list->next->col;
+        // printf("'%c' CURRENT %ld | SCANNED %ld | NEXT %ld\n", lexer->lookahead, current_column, scanner->list->col, a);
+
+        if (current_column == scanner->list->col)
+        {
+          lexer->result_symbol = NEWLINE;
+          return true;
+        }
+        else if (valid_symbols[INDENT] && current_column > scanner->list->col)
+        {
+          scanner_push(&scanner->list, current_column);
+          lexer->result_symbol = INDENT;
+          return true;
+        }
+        else if (scanner->list->next && scanner->list->next->col >= current_column)
+        {
+          // printf("Scanner pop\n");
+          scanner_pop(&scanner->list);
+          lexer->result_symbol = DEDENT;
+          return true;
+        }
+        else if (scanner->list->next && current_column < scanner->list->next->col)
+        {
+          // unreachable
+          // printf("POPPING '%c' CURRENT %ld | SCANNED %ld | NEXT %ld\n", lexer->lookahead, current_column, scanner->list->col, a);
+
+          while (scanner_pop(&scanner->list))
+          {
+            if (current_column > scanner->list->next->col)
+            {
+              return false;
+            }
+
+            if (current_column == scanner->list->next->col)
+            {
+              break;
+            }
+          }
+          lexer->result_symbol = DEDENT;
+          return true;
+        }
+        else
+        {
+          // printf("ERROR '%c' CURRENT %ld | SCANNED %ld | NEXT %ld\n", lexer->lookahead, current_column, scanner->list->col, a);
+          return false;
+        }
+      }
+      else if (lexer->lookahead == '\0')
+      {
+        if (scanner->list->col != 0)
+        {
+          return false;
+        }
+        return true;
+      }
+      else {
+        lexer->advance(lexer, false);
+      }
+    }
+  }
+
+  return false;
+}

data/grammar/src/tree_sitter/parser.h

@@ -0,0 +1,230 @@
+#ifndef TREE_SITTER_PARSER_H_
+#define TREE_SITTER_PARSER_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#define ts_builtin_sym_error ((TSSymbol)-1)
+#define ts_builtin_sym_end 0
+#define TREE_SITTER_SERIALIZATION_BUFFER_SIZE 1024
+
+#ifndef TREE_SITTER_API_H_
+typedef uint16_t TSStateId;
+typedef uint16_t TSSymbol;
+typedef uint16_t TSFieldId;
+typedef struct TSLanguage TSLanguage;
+#endif
+
+typedef struct {
+  TSFieldId field_id;
+  uint8_t child_index;
+  bool inherited;
+} TSFieldMapEntry;
+
+typedef struct {
+  uint16_t index;
+  uint16_t length;
+} TSFieldMapSlice;
+
+typedef struct {
+  bool visible;
+  bool named;
+  bool supertype;
+} TSSymbolMetadata;
+
+typedef struct TSLexer TSLexer;
+
+struct TSLexer {
+  int32_t lookahead;
+  TSSymbol result_symbol;
+  void (*advance)(TSLexer *, bool);
+  void (*mark_end)(TSLexer *);
+  uint32_t (*get_column)(TSLexer *);
+  bool (*is_at_included_range_start)(const TSLexer *);
+  bool (*eof)(const TSLexer *);
+};
+
+typedef enum {
+  TSParseActionTypeShift,
+  TSParseActionTypeReduce,
+  TSParseActionTypeAccept,
+  TSParseActionTypeRecover,
+} TSParseActionType;
+
+typedef union {
+  struct {
+    uint8_t type;
+    TSStateId state;
+    bool extra;
+    bool repetition;
+  } shift;
+  struct {
+    uint8_t type;
+    uint8_t child_count;
+    TSSymbol symbol;
+    int16_t dynamic_precedence;
+    uint16_t production_id;
+  } reduce;
+  uint8_t type;
+} TSParseAction;
+
+typedef struct {
+  uint16_t lex_state;
+  uint16_t external_lex_state;
+} TSLexMode;
+
+typedef union {
+  TSParseAction action;
+  struct {
+    uint8_t count;
+    bool reusable;
+  } entry;
+} TSParseActionEntry;
+
+struct TSLanguage {
+  uint32_t version;
+  uint32_t symbol_count;
+  uint32_t alias_count;
+  uint32_t token_count;
+  uint32_t external_token_count;
+  uint32_t state_count;
+  uint32_t large_state_count;
+  uint32_t production_id_count;
+  uint32_t field_count;
+  uint16_t max_alias_sequence_length;
+  const uint16_t *parse_table;
+  const uint16_t *small_parse_table;
+  const uint32_t *small_parse_table_map;
+  const TSParseActionEntry *parse_actions;
+  const char * const *symbol_names;
+  const char * const *field_names;
+  const TSFieldMapSlice *field_map_slices;
+  const TSFieldMapEntry *field_map_entries;
+  const TSSymbolMetadata *symbol_metadata;
+  const TSSymbol *public_symbol_map;
+  const uint16_t *alias_map;
+  const TSSymbol *alias_sequences;
+  const TSLexMode *lex_modes;
+  bool (*lex_fn)(TSLexer *, TSStateId);
+  bool (*keyword_lex_fn)(TSLexer *, TSStateId);
+  TSSymbol keyword_capture_token;
+  struct {
+    const bool *states;
+    const TSSymbol *symbol_map;
+    void *(*create)(void);
+    void (*destroy)(void *);
+    bool (*scan)(void *, TSLexer *, const bool *symbol_whitelist);
+    unsigned (*serialize)(void *, char *);
+    void (*deserialize)(void *, const char *, unsigned);
+  } external_scanner;
+  const TSStateId *primary_state_ids;
+};
+
+/*
+ *  Lexer Macros
+ */
+
+#ifdef _MSC_VER
+#define UNUSED __pragma(warning(suppress : 4101))
+#else
+#define UNUSED __attribute__((unused))
+#endif
+
+#define START_LEXER()           \
+  bool result = false;          \
+  bool skip = false;            \
+  UNUSED                        \
+  bool eof = false;             \
+  int32_t lookahead;            \
+  goto start;                   \
+  next_state:                   \
+  lexer->advance(lexer, skip);  \
+  start:                        \
+  skip = false;                 \
+  lookahead = lexer->lookahead;
+
+#define ADVANCE(state_value) \
+  {                          \
+    state = state_value;     \
+    goto next_state;         \
+  }
+
+#define SKIP(state_value) \
+  {                       \
+    skip = true;          \
+    state = state_value;  \
+    goto next_state;      \
+  }
+
+#define ACCEPT_TOKEN(symbol_value)     \
+  result = true;                       \
+  lexer->result_symbol = symbol_value; \
+  lexer->mark_end(lexer);
+
+#define END_STATE() return result;
+
+/*
+ *  Parse Table Macros
+ */
+
+#define SMALL_STATE(id) ((id) - LARGE_STATE_COUNT)
+
+#define STATE(id) id
+
+#define ACTIONS(id) id
+
+#define SHIFT(state_value)            \
+  {{                                  \
+    .shift = {                        \
+      .type = TSParseActionTypeShift, \
+      .state = (state_value)          \
+    }                                 \
+  }}
+
+#define SHIFT_REPEAT(state_value)     \
+  {{                                  \
+    .shift = {                        \
+      .type = TSParseActionTypeShift, \
+      .state = (state_value),         \
+      .repetition = true              \
+    }                                 \
+  }}
+
+#define SHIFT_EXTRA()                 \
+  {{                                  \
+    .shift = {                        \
+      .type = TSParseActionTypeShift, \
+      .extra = true                   \
+    }                                 \
+  }}
+
+#define REDUCE(symbol_val, child_count_val, ...) \
+  {{                                             \
+    .reduce = {                                  \
+      .type = TSParseActionTypeReduce,           \
+      .symbol = symbol_val,                      \
+      .child_count = child_count_val,            \
+      __VA_ARGS__                                \
+    },                                           \
+  }}
+
+#define RECOVER()                    \
+  {{                                 \
+    .type = TSParseActionTypeRecover \
+  }}
+
+#define ACCEPT_INPUT()              \
+  {{                                \
+    .type = TSParseActionTypeAccept \
+  }}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TREE_SITTER_PARSER_H_

data/grammar/src/tree_sitter/scanner.h

@@ -0,0 +1,12 @@
+#ifndef TREE_SITTER_SCANNER_H_
+#define TREE_SITTER_SCANNER_H_
+#include "parser.h"
+
+extern const TSLanguage *tree_sitter_hml(void);
+void *tree_sitter_hml_external_scanner_create(void);
+void tree_sitter_hml_external_scanner_destroy(void *);
+bool tree_sitter_hml_external_scanner_scan(void *, TSLexer *, const bool *);
+unsigned tree_sitter_hml_external_scanner_serialize(void *, char *);
+void tree_sitter_hml_external_scanner_deserialize(void *, const char *, unsigned);
+
+#endif

data/grammar/test.nml

@@ -0,0 +1,10 @@
+[template]
+  vblock {
+    ...styleSpread
+  }
+
+[style]
+styleSpread {
+  background: rgb(86, 116, 25);
+  outline_color: rgba(191, 112, 112, 0.67);
+}

data/hokusai.gemspec

@@ -0,0 +1,19 @@
+Gem::Specification.new do |s|
+  s.name        = 'hokusai-zero'
+  s.version     = '0.1.1'
+  s.licenses    = ['MIT']
+  s.summary     = "A Ruby library for writing GUI applications"
+  s.authors     = ["skinnyjames"]
+  s.email       = 'zero@skinnyjames.net'
+  s.extensions << "ext/extconf.rb"
+  s.require_paths = ['ui/src']
+
+  s.files = `git ls-files -z`.split("\x0").reject do |f|
+    f =~ /^(\.|spec)/
+  end
+
+  s.homepage    = 'https://codeberg.org/skinnyjames/hokusai'
+  s.metadata    = { "source_code_uri" => "https://codeberg.org/skinnyjames/hokusai" }
+  
+  s.add_dependency "ffi", "~> 1.16"
+end

data/ui/examples/buddy.rb

@@ -0,0 +1,31 @@
+require_relative "../src/hokusai"
+require_relative "../src/hokusai/backends/sdl2"
+require_relative "../src/hokusai/backends/raylib"
+
+module Buddy
+  class App < Hokusai::Block
+    template <<~EOF
+    [template]
+      buddy {
+        width="400"
+        height="400"
+        :source="buddy_img"
+      }
+    EOF
+
+    uses(buddy: Hokusai::Blocks::Image)
+
+    def buddy_img
+      "#{__dir__}/assets/science-troll.png"
+    end
+  end
+end
+
+Hokusai::Backends::RaylibBackend.run(Buddy::App) do |config|
+  config.width = 500
+  config.height = 500
+  config.title = "Buddy"
+  config.config_flags = Raylib::FLAG_WINDOW_RESIZABLE | Raylib::FLAG_VSYNC_HINT | Raylib::FLAG_WINDOW_TRANSPARENT
+  config.window_state_flags = Raylib::FLAG_WINDOW_RESIZABLE | Raylib::FLAG_WINDOW_UNDECORATED | Raylib::FLAG_WINDOW_TRANSPARENT
+  config.background = Raylib::BLANK
+end

data/ui/examples/clock.rb

@@ -0,0 +1,58 @@
+require_relative "../src/hokusai"
+require_relative "../src/hokusai/backends/sdl2"
+require_relative "../src/hokusai/backends/raylib"
+require_relative "./tic_tac_toe"
+require_relative "./counter"
+require "date"
+
+class Clock < Hokusai::Block
+  template <<~EOF
+    [template]
+      vblock { background="22,22,22" height="50"}
+        label { :content="time" size="30" color="233,233,233" }
+      hblock
+        game { @width="set_width"}
+        [if="fullscreen"]
+          stock
+  EOF
+
+  uses(
+    vblock: Hokusai::Blocks::Vblock,
+    hblock: Hokusai::Blocks::Hblock,
+    empty: Hokusai::Blocks::Empty,
+    label: Hokusai::Blocks::Label,
+    game: TicTacToe::App,
+    stock: Counter
+  )
+
+  attr_accessor :width
+
+  provide :clock_time, :time
+
+  def time
+    time = DateTime.now
+    "#{time.hour}:#{time.minute} #{time.second}"
+  end
+
+  def set_width(width)
+    @width = width
+  end
+
+  def fullscreen
+    (width || 0) > 500
+  end
+end
+
+Hokusai::Backends::SDLBackend.run(Clock) do |config|
+  config.after_load do
+    # Note: how to load a font...
+    # Thank you to Vladimir Nikolic - https://www.1001fonts.com/users/vladimirnikolic/
+    font = Hokusai::Backends::SDLBackend::Font.from_ext("#{__dir__}/assets/DigitalDisplay.ttf", 132)
+    Hokusai.fonts.register "DigitalDisplay", font
+    # Hokusai.fonts.activate "DigitalDisplay"
+  end
+
+  config.width = 500
+  config.height = 500
+  config.title = "Counter application"
+end