hokusai-zero 0.1.1

data/ast/src/core/input.c

@@ -0,0 +1,458 @@
+#ifndef HOKU_CORE_INPUT
+#define HOKU_CORE_INPUT
+
+#include "input.h"
+#include <stdio.h>
+
+static int hoku_keycodes[HOKU_KEY_MAX] = { 
+  0,39,44,45,46,47,48,49,50,51,52,53,54,55,56,57,59,61,65,66,67,68,69,
+  70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,
+  93,96,32,256,257,258,259,260,261,262,263,264,265,266,267,268,269,280,
+  281,282,283,284,290,291,292,293,294,295,296,297,298,299,300,301,340,341,
+  342,343,344,345,346,347,348,320,321,322,323,324,325,326,327,328,329,330,
+  331,332,333,334,335,336,4,5,24,25
+};
+
+void hoku_input_mouse_free(hoku_input_mouse* mouse)
+{
+  free(mouse);
+}
+
+int hoku_input_mouse_init(hoku_input_mouse** mouse)
+{
+  hoku_input_mouse* init = malloc(sizeof(hoku_input_mouse));
+  if (init == NULL) return -1;
+
+  hoku_vec2 zero = (hoku_vec2){ 0.0f, 0.0f };
+  hoku_dvec2 zerod = (hoku_dvec2){ 0.0f, 0.0f };
+  hoku_rect zero_rect = (hoku_rect){ .x=-1.0f, .y=-1.0f, .w=-1.0f, .h=-1.0f };
+  hoku_input_mouse_button zero_button = (hoku_input_mouse_button){ .up=0, .down=0, .clicked=0, .released=0 };
+
+  init->pos = malloc(sizeof(hoku_vec2));
+  if (init->pos == NULL) return -1;
+  init->pos->x = 0.0f;
+  init->pos->y = 0.0f;
+
+  init->delta = zerod;
+  init->scroll = 0.0f;
+  init->scroll_delta = 0.0f;
+  init->selection = zero_rect;
+  init->selection_type = HOKU_SELECT_NONE;
+  init->left = malloc(sizeof(hoku_input_mouse_button));
+  if (init->left == NULL) return -1;
+  init->left->up = 0;
+  init->left->down = 0;
+  init->left->clicked = 0;
+  init->left->released = 0;
+
+  init->middle = malloc(sizeof(hoku_input_mouse_button));
+  if (init->middle == NULL) return -1;
+  init->middle->up = 0;
+  init->middle->down = 0;
+  init->middle->clicked = 0;
+  init->middle->released = 0;
+
+  init->right = malloc(sizeof(hoku_input_mouse_button));
+  if (init->right == NULL) return -1;
+  init->right->up = 0;
+  init->right->down = 0;
+  init->right->clicked = 0;
+  init->right->released = 0;
+
+  *mouse = init;
+  return 0;
+}
+
+int hoku_input_keyboard_populate_keys(hoku_input_keyboard* keyboard)
+{
+  hoku_input_keyboard_key* keys = malloc(sizeof(hoku_input_keyboard_key) * HOKU_KEY_MAX);
+  if (keys == NULL) return -1;
+
+  for (int i=0; i<HOKU_KEY_MAX; i++)
+  {
+    keys[i] = (hoku_input_keyboard_key){.code=hoku_keycodes[i], .key=((hoku_input_key) i), .up=true, .down=false, .released=false, .pressed=false};
+  }
+
+  keyboard->keys = keys;
+  return 0;
+}
+
+void hoku_input_keyboard_free(hoku_input_keyboard* keyboard)
+{
+  free(keyboard->keys);
+  free(keyboard->pressed);
+  free(keyboard->released);
+  free(keyboard);
+}
+
+int hoku_input_keyboard_init(hoku_input_keyboard** keyboard)
+{
+  hoku_input_keyboard* init = malloc(sizeof(hoku_input_keyboard));
+  if (init == NULL) return -1;
+
+  init->pressed = malloc(sizeof(hoku_input_keyboard_key_with_char) * 20);
+  if (init->pressed == NULL)
+  {
+    free(init);
+    return -1;
+  }
+  init->released = malloc(sizeof(hoku_input_keyboard_key_with_char) * 20);
+  if (init->released == NULL)
+  {
+    free(init->pressed);
+    free(init);
+    return -1;
+  }
+
+  if (hoku_input_keyboard_populate_keys(init) == -1)
+  {
+    free(init->pressed);
+    free(init->released);
+    free(init);
+    return -1;
+  }
+
+  init->allocated_len = 20;
+  init->pressed_len = 0;
+  init->released_len = 0;
+  init->shift = false;
+  init->ctrl = false;
+  init->alt = false;
+  init->super = false;
+  init->collecting = false;
+
+  *keyboard = init;
+  return 0;
+}
+
+void hoku_input_keyboard_start(hoku_input* input)
+{
+  input->keyboard->collecting = true;
+  // reset any pressed or released keys
+  input->keyboard->pressed_len = 0;
+  input->keyboard->released_len = 0;
+  // reset modifiers
+  input->keyboard->shift = false;
+  input->keyboard->ctrl = false;
+  input->keyboard->alt = false;
+  input->keyboard->super = false;
+}
+
+void hoku_input_keyboard_stop(hoku_input* input)
+{
+  input->keyboard->collecting = false;
+}
+
+bool hoku_input_key_is_letter(hoku_input_key key)
+{
+  return (
+    key == HOKU_KEY_A ||
+    key == HOKU_KEY_B ||
+    key == HOKU_KEY_C || 
+    key == HOKU_KEY_D ||
+    key == HOKU_KEY_E ||
+    key == HOKU_KEY_F ||
+    key == HOKU_KEY_G ||
+    key == HOKU_KEY_H ||
+    key == HOKU_KEY_I ||
+    key == HOKU_KEY_J ||
+    key == HOKU_KEY_K ||
+    key == HOKU_KEY_L ||
+    key == HOKU_KEY_M ||
+    key == HOKU_KEY_N ||
+    key == HOKU_KEY_O ||
+    key == HOKU_KEY_P ||
+    key == HOKU_KEY_Q ||
+    key == HOKU_KEY_R ||
+    key == HOKU_KEY_S ||
+    key == HOKU_KEY_T ||
+    key == HOKU_KEY_U ||
+    key == HOKU_KEY_V ||
+    key == HOKU_KEY_W ||
+    key == HOKU_KEY_X ||
+    key == HOKU_KEY_Y ||
+    key == HOKU_KEY_Z
+  );
+}
+
+int hoku_get_code_from_key(hoku_input_key key, int source, bool shift)
+{
+  int code = source;
+  if (!shift && hoku_input_key_is_letter(key)) { code = source + 32; }
+  else if (shift && key == HOKU_KEY_APOSTROPHE) { code = 34; }
+  else if (shift && key == HOKU_KEY_COMMA) { code = 60; }
+  else if (shift && key == HOKU_KEY_MINUS) { code = 95; }
+  else if (shift && key == HOKU_KEY_PERIOD) { code = 62; }
+  else if (shift && key == HOKU_KEY_SLASH) { code = 63; }
+  else if (shift && key == HOKU_KEY_ZERO) { code = 41; }
+  else if (shift && key == HOKU_KEY_ONE) { code = 33; }
+  else if (shift && key == HOKU_KEY_TWO) { code = 64; }
+  else if (shift && key == HOKU_KEY_THREE) { code = 35; }
+  else if (shift && key == HOKU_KEY_FOUR) { code = 36; }
+  else if (shift && key == HOKU_KEY_FIVE) { code = 37; }
+  else if (shift && key == HOKU_KEY_SIX) { code = 94; }
+  else if (shift && key == HOKU_KEY_SEVEN) { code = 38; }
+  else if (shift && key == HOKU_KEY_EIGHT) { code = 42; }
+  else if (shift && key == HOKU_KEY_NINE) { code = 40; }
+  else if (shift && key == HOKU_KEY_SEMICOLON) { code = 58; }
+  else if (shift && key == HOKU_KEY_EQUAL) { code = 43; }
+  else if (shift && key == HOKU_KEY_LEFT_BRACKET) { code = 123;}
+  else if (shift && key == HOKU_KEY_BACKSLASH) { code = 124; }
+  else if (shift && key == HOKU_KEY_RIGHT_BRACKET) { code = 125; }
+  else if (shift && key == HOKU_KEY_GRAVE) { code = 126; }
+  return code;
+}
+
+bool hoku_input_key_is_modifier(hoku_input_key key)
+{
+  return (
+    key == HOKU_KEY_LEFT_SHIFT ||
+    key == HOKU_KEY_LEFT_CONTROL ||
+    key == HOKU_KEY_LEFT_ALT ||
+    key == HOKU_KEY_LEFT_SUPER || 
+    key == HOKU_KEY_RIGHT_SHIFT || 
+    key == HOKU_KEY_RIGHT_CONTROL ||
+    key == HOKU_KEY_RIGHT_ALT ||
+    key == HOKU_KEY_RIGHT_SUPER
+  );
+}
+
+void hoku_input_keyboard_set_key(hoku_input* input, hoku_input_key key, bool down)
+{
+  if (hoku_input_key_is_modifier(key) && down && (key == HOKU_KEY_LEFT_SHIFT || key == HOKU_KEY_RIGHT_SHIFT)) input->keyboard->shift = true;
+  if (hoku_input_key_is_modifier(key) && down && (key == HOKU_KEY_LEFT_CONTROL || key == HOKU_KEY_RIGHT_CONTROL)) input->keyboard->ctrl = true;
+  if (hoku_input_key_is_modifier(key) && down && (key == HOKU_KEY_LEFT_ALT || key == HOKU_KEY_RIGHT_ALT)) input->keyboard->alt = true;
+  if (hoku_input_key_is_modifier(key) && down && (key == HOKU_KEY_LEFT_SUPER || key == HOKU_KEY_RIGHT_SUPER)) input->keyboard->super = true;
+
+  bool shift = input->keyboard->shift;
+  hoku_input_keyboard_key keyboard_key = hoku_input_keyboard_get_key(input, key);
+
+  if (down && input->keyboard->keys[key].up)
+  {
+    // pressed condition
+    input->keyboard->keys[key].pressed = true;
+    input->keyboard->keys[key].released = false;
+
+    if (input->keyboard->pressed_len < 20 && !hoku_input_key_is_modifier(key))
+    {
+      int code = hoku_get_code_from_key(key, keyboard_key.code, shift);
+      input->keyboard->pressed[input->keyboard->pressed_len] = (hoku_input_keyboard_key_with_char) {.key=keyboard_key, .char_code=code};
+      input->keyboard->pressed_len++;
+    }
+  }
+  else if (!down && input->keyboard->keys[key].down)
+  {
+    // released condition
+    input->keyboard->keys[key].pressed = false;
+    input->keyboard->keys[key].released = true;
+
+    if (input->keyboard->released_len < 20 && !hoku_input_key_is_modifier(key))
+    {
+      int code = hoku_get_code_from_key(key, keyboard_key.code, shift);
+      input->keyboard->released[input->keyboard->released_len] = (hoku_input_keyboard_key_with_char) {.key=keyboard_key, .char_code=code};
+      input->keyboard->released_len++;
+    }
+  }
+  else
+  {
+    input->keyboard->keys[key].pressed = false;
+    input->keyboard->keys[key].released = false;
+  }
+
+  input->keyboard->keys[key].down = down;
+  input->keyboard->keys[key].up = !down;
+
+}
+
+hoku_input_keyboard_key hoku_input_keyboard_get_key(hoku_input* input, hoku_input_key key)
+{
+  return input->keyboard->keys[key];
+}
+
+void hoku_input_free(hoku_input* input)
+{
+  hoku_input_keyboard_free(input->keyboard);
+  hoku_input_mouse_free(input->mouse);
+  free(input);
+}
+
+int hoku_input_init(hoku_input** input)
+{
+
+  hoku_input* init = malloc(sizeof(hoku_input));
+  if (init == NULL) return -1;
+
+  hoku_input_mouse* mouse;
+  if (hoku_input_mouse_init(&mouse) == -1)
+  {
+    free(init);
+    return -1;
+  }
+  init->mouse = mouse;
+
+  hoku_input_keyboard* keyboard;
+  if (hoku_input_keyboard_init(&keyboard) == -1)
+  {
+    free(init->mouse);
+    free(init);
+    return -1;
+  }
+  init->keyboard = keyboard;
+
+  *input = init;
+  return 0;
+}
+
+void hoku_input_set_mouse_position(hoku_input* head, hoku_vec2* pos)
+{
+  hoku_vec2* last = head->mouse->pos;
+
+  double new_x = (double) (pos->x - last->x);
+  double new_y = (double) (pos->y - last->y);
+
+  head->mouse->delta = (hoku_dvec2){ new_x, new_y };
+  head->mouse->pos->x = pos->x;
+  head->mouse->pos->y = pos->y;
+}
+
+void hoku_input_mouse_set_scroll(hoku_input* head, float scroll_y)
+{
+  float last = head->mouse->scroll;
+
+  float new_y = (last >= scroll_y) ? last - scroll_y : scroll_y - last;
+  head->mouse->scroll_delta = new_y;
+  head->mouse->scroll = scroll_y;
+}
+
+void hoku_input_mouse_set_selection(hoku_input** input, hoku_input_mouse_button current)
+{
+  /** select logic
+  * if prev up && current click
+  *   set selection.x && selection.y
+  * if prev->selection.x && prev->selection.y && current mousedown
+  *   set selection.w && selection.y
+  * if selection filled && click
+  *   unset selection
+  */
+
+  // printf("current down? %d\n", current.down);
+  hoku_input* head = *input;
+  hoku_input_mouse* mouse = head->mouse;
+  
+  // freeze
+  if(mouse->left->up && mouse->selection_type & (HOKU_SELECT_ACTIVE))
+  {
+    mouse->selection_type = HOKU_SELECT_FROZEN;
+  }
+  // unfreeze select -> populate sx and sy but not ex/ey (sets cursor); set to selecting
+  else if (current.down && mouse->selection_type & (HOKU_SELECT_NONE | HOKU_SELECT_FROZEN))
+  {
+    mouse->selection.x = mouse->pos->x;
+    mouse->selection.y = mouse->pos->y;
+    mouse->selection.w = -1.0f;
+    mouse->selection.h = -1.0f;
+    mouse->selection_type = HOKU_SELECT_ACTIVE;
+  }
+  // start updating w/h
+  else if(current.down && mouse->left->down && mouse->selection_type & (HOKU_SELECT_ACTIVE))
+  {
+    mouse->selection.w = mouse->pos->x;
+    mouse->selection.h = mouse->pos->y;
+  }
+
+  *input = head;
+}
+
+void hoku_input_mouse_set_button(hoku_input* head, hoku_input_mouse_button* button, int type)
+{
+  switch(type)
+  {
+    case 0:
+    {
+      head->mouse->left->down = button->down;
+      head->mouse->left->up = button->up;
+      head->mouse->left->clicked = button->clicked;
+      head->mouse->left->released = button->released;
+
+      break;
+    }
+    case 1:
+    {
+      head->mouse->middle->down = button->down;
+      head->mouse->middle->up = button->up;
+      head->mouse->middle->clicked = button->clicked;
+      head->mouse->middle->released = button->released;
+      break;
+    }
+    case 2:
+    {
+      head->mouse->right->down = button->down;
+      head->mouse->right->up = button->up;
+      head->mouse->right->clicked = button->clicked;
+      head->mouse->right->released = button->released;
+      break;
+    }
+    default:
+    {
+      break;
+    }
+  }
+}
+
+void hoku_input_mouse_set_left_button(hoku_input* input, hoku_input_mouse_button* button)
+{
+  hoku_input_mouse_set_button(input, button, 0);
+}
+
+void hoku_input_mouse_set_middle_button(hoku_input* input, hoku_input_mouse_button* button)
+{
+  hoku_input_mouse_set_button(input, button, 1);
+}
+
+void hoku_input_mouse_set_right_button(hoku_input* input, hoku_input_mouse_button* button)
+{
+  hoku_input_mouse_set_button(input, button, 2);
+}
+
+bool hoku_input_is_hovered(hoku_input* input, hoku_rect* rect)
+{
+  hoku_vec2* pos = input->mouse->pos;
+  return pos->x >= rect->x && pos->x <= rect->x + rect->w && pos->y >= rect->y && pos->y <= rect->y + rect->h;
+}
+
+
+bool hoku_input_is_any_clicked(hoku_input* input, hoku_rect* rect, int which)
+{
+
+  bool clicked = false;
+  switch(which)
+  {
+    case 0:
+    {
+      clicked = input->mouse->left->clicked;
+      break;
+    }
+    case 1:
+    {
+      clicked = input->mouse->middle->clicked;
+      break;
+    }
+    case 2:
+    {
+      clicked = input->mouse->right->clicked;
+      break;
+    }
+    default:
+    {
+      break;
+    }
+  }
+
+  return clicked && hoku_input_is_hovered(input, rect);
+}
+
+bool hoku_input_is_clicked(hoku_input* input, hoku_rect* rect)
+{
+    return hoku_input_is_any_clicked(input, rect, 0);
+}
+#endif

data/ast/src/core/input.h

@@ -0,0 +1,118 @@
+#ifndef HOKU_CORE_INPUT_H
+#define HOKU_CORE_INPUT_H
+
+#include "common.h"
+#include <stdbool.h>
+#include <stdlib.h>
+
+typedef struct HmlInputMouseButton
+{
+  bool down;
+  bool up;
+  bool clicked;
+  bool released;
+} hoku_input_mouse_button;
+
+typedef enum HmlInputSelectType {
+  HOKU_SELECT_ACTIVE = 1 << 1,
+  HOKU_SELECT_FROZEN = 1 << 2,
+  HOKU_SELECT_NONE = 1 << 3
+} hoku_input_select_type;
+
+typedef struct HmlInputMouse
+{
+  hoku_vec2* pos;
+  hoku_dvec2 delta;
+  float scroll;
+  float scroll_delta;
+  hoku_rect selection;
+  hoku_input_select_type selection_type;
+  hoku_input_mouse_button* left;
+  hoku_input_mouse_button* middle;
+  hoku_input_mouse_button* right;
+} hoku_input_mouse;
+
+
+typedef enum HmlInputKey
+{
+  HOKU_KEY_NULL, HOKU_KEY_APOSTROPHE, HOKU_KEY_COMMA, HOKU_KEY_MINUS, HOKU_KEY_PERIOD,
+  HOKU_KEY_SLASH, HOKU_KEY_ZERO, HOKU_KEY_ONE, HOKU_KEY_TWO, HOKU_KEY_THREE, HOKU_KEY_FOUR, HOKU_KEY_FIVE,
+  HOKU_KEY_SIX, HOKU_KEY_SEVEN, HOKU_KEY_EIGHT, HOKU_KEY_NINE, HOKU_KEY_SEMICOLON,
+  HOKU_KEY_EQUAL, HOKU_KEY_A, HOKU_KEY_B, HOKU_KEY_C, HOKU_KEY_D, HOKU_KEY_E, HOKU_KEY_F,
+  HOKU_KEY_G, HOKU_KEY_H, HOKU_KEY_I, HOKU_KEY_J, HOKU_KEY_K, HOKU_KEY_L,
+  HOKU_KEY_M, HOKU_KEY_N, HOKU_KEY_O, HOKU_KEY_P, HOKU_KEY_Q, HOKU_KEY_R, HOKU_KEY_S,
+  HOKU_KEY_T, HOKU_KEY_U, HOKU_KEY_V, HOKU_KEY_W, HOKU_KEY_X,
+  HOKU_KEY_Y, HOKU_KEY_Z, HOKU_KEY_LEFT_BRACKET, HOKU_KEY_BACKSLASH,
+  HOKU_KEY_RIGHT_BRACKET, HOKU_KEY_GRAVE, HOKU_KEY_SPACE, HOKU_KEY_ESCAPE,
+  HOKU_KEY_ENTER, HOKU_KEY_TAB, HOKU_KEY_BACKSPACE, HOKU_KEY_INSERT, HOKU_KEY_DELETE, HOKU_KEY_RIGHT,
+  HOKU_KEY_LEFT, HOKU_KEY_DOWN, HOKU_KEY_UP, HOKU_KEY_PAGE_UP, HOKU_KEY_PAGE_DOWN, HOKU_KEY_HOME,
+  HOKU_KEY_END,  HOKU_KEY_CAPS_LOCK, HOKU_KEY_SCROLL_LOCK, HOKU_KEY_NUM_LOCK, HOKU_KEY_PRINT_SCREEN, HOKU_KEY_PAUSE,
+  HOKU_KEY_F1, HOKU_KEY_F2, HOKU_KEY_F3, HOKU_KEY_F4,
+  HOKU_KEY_F5, HOKU_KEY_F6, HOKU_KEY_F7, HOKU_KEY_F8, HOKU_KEY_F9, HOKU_KEY_F10, HOKU_KEY_F11, HOKU_KEY_F12,
+  HOKU_KEY_LEFT_SHIFT, HOKU_KEY_LEFT_CONTROL, HOKU_KEY_LEFT_ALT, HOKU_KEY_LEFT_SUPER, HOKU_KEY_RIGHT_SHIFT,
+  HOKU_KEY_RIGHT_CONTROL, HOKU_KEY_RIGHT_ALT, HOKU_KEY_RIGHT_SUPER, HOKU_KEY_KB_MENU, HOKU_KEY_KP_0, HOKU_KEY_KP_1, HOKU_KEY_KP_2,
+  HOKU_KEY_KP_3, HOKU_KEY_KP_4, HOKU_KEY_KP_5, HOKU_KEY_KP_6, HOKU_KEY_KP_7, HOKU_KEY_KP_8, HOKU_KEY_KP_9,
+  HOKU_KEY_KP_DECIMAL, HOKU_KEY_KP_DIVIDE, HOKU_KEY_KP_MULTIPLY, HOKU_KEY_KP_SUBTRACT, HOKU_KEY_KP_ADD, HOKU_KEY_KP_ENTER, HOKU_KEY_KP_EQUAL,
+  HOKU_KEY_BACK, HOKU_KEY_MENU, HOKU_KEY_VOLUME_UP, HOKU_KEY_VOLUME_DOWN, HOKU_KEY_MAX
+} hoku_input_key;
+
+typedef struct HmlInputKeyboardKey
+{
+  int code;         // some code, not super useful...
+  bool down;        // is key down
+  bool up;          // is key up
+  bool released;    // was key down and now up
+  bool pressed;     // was key up and now down
+  hoku_input_key key;
+} hoku_input_keyboard_key;
+
+typedef struct HmlInputKeyboardKeyWithChar
+{
+  hoku_input_keyboard_key key; // the keyboard key
+  int char_code;  // the resolved character
+} hoku_input_keyboard_key_with_char;
+
+typedef struct HmlInputKeyboard
+{
+  int allocated_len;
+  hoku_input_keyboard_key_with_char* pressed;
+  int pressed_len;
+  hoku_input_keyboard_key_with_char* released;
+  int released_len;
+  bool shift;
+  bool super;
+  bool ctrl;
+  bool alt;
+  hoku_input_keyboard_key* keys;
+  bool collecting;
+} hoku_input_keyboard;
+
+typedef struct HmlInput
+{
+  hoku_input_keyboard* keyboard;
+  hoku_input_mouse* mouse;
+} hoku_input;
+
+
+int hoku_input_keyboard_init(hoku_input_keyboard** keyboard);
+int hoku_input_mouse_init(hoku_input_mouse** mouse);
+int hoku_input_init(hoku_input** input);
+void hoku_input_free(hoku_input* input);
+void hoku_input_set_mouse_position(hoku_input* input, hoku_vec2* pos);
+void hoku_input_mouse_set_button(hoku_input* input, hoku_input_mouse_button* button, int type);
+void hoku_input_mouse_set_left_button(hoku_input* input, hoku_input_mouse_button* button);
+void hoku_input_mouse_set_middle_button(hoku_input* input, hoku_input_mouse_button* button);
+void hoku_input_mouse_set_right_button(hoku_input* input, hoku_input_mouse_button* button);
+void hoku_input_mouse_set_selection(hoku_input** input, hoku_input_mouse_button current);
+
+void hoku_input_mouse_set_scroll(hoku_input* input, float scroll_y);
+
+void hoku_input_keyboard_start(hoku_input* input);
+void hoku_input_keyboard_set_key(hoku_input* input, hoku_input_key key, bool down);
+hoku_input_keyboard_key hoku_input_keyboard_get_key(hoku_input* input, hoku_input_key key);
+void hoku_input_keyboard_stop(hoku_input* input);
+
+bool hoku_input_is_clicked(hoku_input* input, hoku_rect* rect);
+bool hoku_input_is_any_clicked(hoku_input* input, hoku_rect* rect, int which);
+bool hoku_input_is_hovered(hoku_input* input, hoku_rect* rect);
+#endif

data/ast/src/core/style.c

@@ -0,0 +1,101 @@
+#ifndef HOKU_CORE_STYLE
+#define HOKU_CORE_STYLE
+
+#include "style.h"
+
+int hoku_style_attribute_init(hoku_style_attribute** attribute, char* name, char* value, enum HOKU_STYLE_TYPE type)
+{
+  hoku_style_attribute* init = malloc(sizeof(hoku_style_attribute));
+  if (init == NULL) return -1;
+
+  init->name = strdup(name);
+  if (init->name == NULL) return -1;
+
+  init->value = strdup(value);
+  if (init->value == NULL) return -1;
+
+  init->type = type;
+  init->function_name = NULL;
+  init->next = NULL;
+
+  *attribute = init;
+
+  return 0;
+}
+
+int hoku_style_init(hoku_style** style, char* name)
+{
+  hoku_style* init = malloc(sizeof(hoku_style));
+  if (init == NULL) return -1;
+
+  init->name = strdup(name);
+  if (init->name == NULL) return -1;
+
+  init->attributes = NULL;
+  init->next = NULL;
+
+  *style = init;
+
+  return 0;
+}
+
+
+void hoku_style_append(hoku_style* style, hoku_style* next)
+{
+  hoku_style* head = style;
+
+  while (head->next)
+  {
+    head = head->next;
+  }
+
+  head->next = next;
+}
+
+void hoku_style_attribute_append(hoku_style_attribute* attribute, hoku_style_attribute* next)
+{
+  hoku_style_attribute* head = attribute;
+
+  while (head->next)
+  {
+    head = head->next;
+  }
+
+  head->next = next;
+  head->next->next = NULL;
+}
+
+void hoku_style_attribute_free(hoku_style_attribute* attribute)
+{
+  hoku_style_attribute* head = attribute;
+  hoku_style_attribute* current = NULL;
+
+  while (head)
+  {
+    current = head;
+    head = head->next;
+
+    free(current->name);
+    free(current->value);
+    if (current->function_name) free(current->function_name);
+    free(current);
+  }
+}
+
+void hoku_style_free(hoku_style* style)
+{
+  hoku_style* head = style;
+  hoku_style* current = NULL;
+
+  while (head)
+  {
+    current = head;
+    head = head->next;
+
+    free(current->name);
+    hoku_style_attribute_free(current->attributes);
+    free(current);
+  }
+}
+
+#endif

data/ast/src/core/style.h

@@ -0,0 +1,41 @@
+#ifndef HOKU_CORE_STYLE_H
+#define HOKU_CORE_STYLE_H
+
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+enum HOKU_STYLE_TYPE
+{
+  HOKU_STYLE_TYPE_INT,
+  HOKU_STYLE_TYPE_FLOAT,
+  HOKU_STYLE_TYPE_BOOL,
+  HOKU_STYLE_TYPE_STRING,
+  HOKU_STYLE_TYPE_FUNC
+};
+
+typedef struct HmlStyleAttribute
+{
+  char* name;
+  char* function_name;
+  char* value;
+  enum HOKU_STYLE_TYPE type;
+  struct HmlStyleAttribute* next;
+
+} hoku_style_attribute;
+
+typedef struct HmlStyle
+{
+  char* name;
+  struct HmlStyleAttribute* attributes;
+  struct HmlStyle* next;
+} hoku_style;
+
+int hoku_style_init(hoku_style** style, char* name);
+int hoku_style_attribute_init(hoku_style_attribute** attribute, char* name, char* value, enum HOKU_STYLE_TYPE type);
+void hoku_style_append(hoku_style* style, hoku_style* next);
+void hoku_style_attribute_append(hoku_style_attribute* attribute, hoku_style_attribute* next);
+void hoku_style_attribute_free(hoku_style_attribute* attribute);
+void hoku_style_free(hoku_style* style);
+
+#endif