hokusai-zero 0.1.1

data/ast/src/core/text.c

@@ -0,0 +1,784 @@
+#ifndef HOKU_TEXT
+#define HOKU_TEXT
+
+#include "text.h"
+
+int hoku_text_char_init(hoku_char** character, int offset, int width)
+{
+  hoku_char* init = malloc(sizeof(hoku_char));
+  if (init == NULL) return -1;
+
+  init->offset = offset;
+  init->width = width;
+  init->next_char = NULL;
+
+  *character = init;
+
+  return 0;
+}
+
+int hoku_text_segment_init(hoku_segment** segment, int offset)
+{
+  hoku_segment* init = malloc(sizeof(hoku_segment));
+  if (init == NULL) return -1;
+
+  init->offset = offset;
+  init->chars = NULL;
+  init->groups = NULL;
+  init->size = 0;
+  init->select_begin = 0;
+  init->select_end = 0;
+  init->next_segment = NULL;
+
+  *segment = init;
+
+  return 0;
+}
+
+int hoku_text_clamping_init(hoku_clamping** clamping, char* text, float width)
+{
+  hoku_clamping* init = malloc(sizeof(hoku_clamping));
+  if (init == NULL) return -1;
+  init->text = strdup(text);
+  if (init->text == NULL) return -1;
+  init->width = width;
+  init->segments = NULL;
+
+  *clamping = init;
+
+  return 0;
+}
+
+hoku_char* hoku_text_segment_split(hoku_segment* segment, int at)
+{
+  hoku_segment* head = segment;
+  hoku_char* current_char = head->chars;
+  if (at > head->size) return NULL;
+
+  printf("at: %d\n", at);
+  int i = 0;
+  for (i = 1; i < at; i++)
+  {
+    printf("%d- %d\n", i, head->size);
+    if (current_char == NULL) printf("BADDD\n");
+    current_char = current_char->next_char;
+  }
+
+  hoku_segment* insert;
+  if (hoku_text_segment_init(&insert, head->offset + at) != 0) return NULL;
+
+  if (current_char) insert->chars = current_char->next_char;
+  insert->size = head->size - at;
+  insert->select_begin = 0;
+  insert->select_end = 0;
+  insert->next_segment = head->next_segment;
+  head->next_segment = insert;
+  head->size = at;
+  if (current_char) current_char->next_char = NULL;
+
+  printf("split ret\n");
+  return current_char;
+//  return insert;
+}
+
+void hoku_text_char_free(hoku_char* chars)
+{
+  hoku_char* head;
+
+  while (chars)
+  {
+    head = chars;
+    chars = chars->next_char;
+    free(head);
+  }
+}
+
+void hoku_text_group_free(hoku_group* group)
+{
+  hoku_group* head;
+  while (group)
+  {
+    hoku_text_char_free(group->chars);
+
+//    if (group->payload != NULL) free(group->payload);
+
+    head = group;
+    group = group->next_group;
+    free(head);
+  }
+}
+
+void hoku_text_segment_free(hoku_segment* segment)
+{
+  hoku_segment* head;
+  while (segment)
+  {
+    hoku_text_group_free(segment->groups);
+    hoku_text_char_free(segment->chars);
+    head = segment;
+    segment = segment->next_segment;
+    free(head);
+  }
+}
+
+void hoku_text_clamping_free(hoku_clamping* clamping)
+{
+  hoku_text_segment_free(clamping->segments);
+  free(clamping->text);
+  free(clamping);
+}
+
+int hoku_text_select(hoku_clamping* clamping, int begin, int end)
+{
+  return 0;
+}
+
+float hoku_text_char_sum(hoku_char* character)
+{
+  float width = 0.0;
+
+  while (character != NULL)
+  {
+    width += character->width;
+    character = character->next_char;
+  }
+
+  return width;
+}
+
+void hoku_text_clamp_debug(hoku_clamping* clamp)
+{
+  printf("clamping:\n");
+  hoku_segment* seg = clamp->segments;
+  while (seg)
+  {
+    printf("\tseg: %d %d\n", seg->offset, seg->size);
+
+    hoku_group* g = seg->groups;
+    while (g)
+    {
+      printf("\t\tgroup: (%d..%d)", g->offset, g->size);
+      
+   
+      if (g->type & HOKU_GROUP_NORMAL) printf(" NORMAL");
+      if (g->type & HOKU_GROUP_BOLD) printf(" BOLD");
+      if (g->type & HOKU_GROUP_ITALICS) printf(" ITALICS");
+      if (g->type & HOKU_GROUP_LINK) printf(" LINK (%s)", (char*) g->payload);
+      
+      printf("\n");
+      hoku_char* c = g->chars;
+
+      while (c)
+      {
+        printf("\t\t\tchar (%c): %d %d\n", clamp->text[c->offset], c->offset, c->width);
+        c = c->next_char;
+      }
+      
+      g = g->next_group;
+    }
+
+    hoku_char* c = seg->chars;
+
+    while (c)
+    {
+      printf("\t\tchar (%c): %d %d\n", clamp->text[c->offset], c->offset, c->width);
+      c = c->next_char;
+    }
+
+    seg = seg->next_segment;
+  }
+}
+
+typedef struct HokuMdState
+{
+  float width;
+  int total_offset;
+  float line_width;
+  void* char_width_payload;
+  hoku_char_width_cb char_width_callback;
+  hoku_segment* root_segment;
+  enum HOKU_GROUP_TYPE current_group_type;
+  hoku_segment* current_segment;
+  hoku_group* current_group;
+  hoku_char* current_char;
+  void* current_group_payload;
+  char* parsed;
+  int parsed_len;
+  int parsed_counter;
+} hoku_md_state;
+
+
+int hoku_text_md_append(hoku_md_state* userdata, const char* text, int size)
+{
+  if (userdata->parsed_counter + size >= userdata->parsed_len)
+  {
+    int plen = size + 200 + userdata->parsed_len;
+    char* tmp = realloc(userdata->parsed, sizeof(char) * plen);
+    if (tmp == NULL) return -1;
+    userdata->parsed = tmp;
+    userdata->parsed_len += size + 200;
+  }
+
+  strncat(userdata->parsed, text, size);
+  userdata->parsed_counter += size;
+  return 0;
+}
+
+int hoku_text_md_enter_block(MD_BLOCKTYPE type, void* detail, void* data)
+{
+//  printf("enter block\n");
+  return 0;
+
+}
+
+int hoku_text_md_leave_block(MD_BLOCKTYPE type, void* detail, void* data)
+{
+  hoku_md_state* userdata = (hoku_md_state*) data;
+
+  if (userdata->current_group == NULL) return 0;
+
+  for (int i=0; i < 2; i++)
+  {
+    // make a new segment
+    hoku_segment* next;
+    if (hoku_text_segment_init(&next, userdata->total_offset + 1) != 0) return -1;
+
+    // make a new group
+    hoku_group* group;
+    if (hoku_text_group_init(&group, userdata->total_offset + 1, HOKU_GROUP_NORMAL, NULL) != 0) return -1;
+
+    next->groups = group;
+
+    // init a char
+    hoku_char* insert;
+    if (hoku_text_char_init(&insert, userdata->total_offset, 0) != 0) return -1;
+
+    hoku_text_group_append_char(group, insert);
+    next->size += 1;
+    group->size += 1;
+    userdata->total_offset += 1;
+
+    userdata->current_segment->next_segment = next;
+    userdata->current_segment = next;
+  }
+
+  userdata->current_group = NULL;
+  if (hoku_text_md_append(userdata, "\n\n", 2) != 0) return -1;
+//  printf("parsed: %s\n", userdata->parsed);
+//  printf("leave block\n");
+  return 0;
+}
+
+int hoku_text_md_enter_span(MD_SPANTYPE type, void* detail, void* data)
+{
+  hoku_md_state* userdata = (hoku_md_state*) data;
+
+//  printf("enter span\n");
+  switch(type)
+  {
+    case MD_SPAN_EM:
+    {
+      userdata->current_group_type = userdata->current_group_type | HOKU_GROUP_ITALICS;
+      break;
+    }
+    case MD_SPAN_STRONG:
+    {
+      userdata->current_group_type = userdata->current_group_type | HOKU_GROUP_BOLD;
+      break;
+    }
+    case MD_SPAN_U:
+    {
+
+    }
+    case MD_SPAN_A:
+    {
+      userdata->current_group_type = userdata->current_group_type | HOKU_GROUP_LINK;
+
+      MD_ATTRIBUTE href = ((MD_SPAN_A_DETAIL*) detail)->href;
+      char* link = strndup(href.text, href.size);
+      userdata->current_group_payload = link;
+
+      break;
+    }
+    case MD_SPAN_IMG:
+    {
+      userdata->current_group_type = userdata->current_group_type | HOKU_GROUP_IMAGE;
+      break;
+    }
+    case MD_SPAN_CODE:
+    {
+      userdata->current_group_type = userdata->current_group_type | HOKU_GROUP_CODE;
+      break;
+    }
+  }
+  return 0;
+}
+
+int hoku_text_md_leave_span(MD_SPANTYPE type, void* detail, void* data)
+{
+  hoku_md_state* userdata = (hoku_md_state*) data;
+
+//  printf("leave span\n");
+  switch(type)
+  {
+    case MD_SPAN_EM:
+    {
+      userdata->current_group_type = userdata->current_group_type & ~HOKU_GROUP_ITALICS;
+      break;
+    }
+    case MD_SPAN_STRONG:
+    {
+      userdata->current_group_type = userdata->current_group_type & ~HOKU_GROUP_BOLD;
+      break;
+    }
+    case MD_SPAN_U:
+    {
+
+    }
+    case MD_SPAN_A:
+    {
+      userdata->current_group_type = userdata->current_group_type & ~HOKU_GROUP_LINK;
+      userdata->current_group_payload = NULL;
+      break;
+    }
+    case MD_SPAN_IMG:
+    {
+      userdata->current_group_type = userdata->current_group_type & ~HOKU_GROUP_IMAGE;
+      break;
+    }
+    case MD_SPAN_CODE:
+    {
+      userdata->current_group_type = userdata->current_group_type & ~HOKU_GROUP_CODE;
+      break;
+    }
+  }
+  return 0;
+}
+int hoku_text_group_init(hoku_group** group, int offset, enum HOKU_GROUP_TYPE type, void* payload)
+{
+  hoku_group* init = malloc(sizeof(hoku_group));
+  if (init == NULL) return -1;
+
+  init->offset = offset;
+  init->size = 0;
+  init->type = type;
+  init->chars = NULL;
+  init->next_group = NULL;
+  init->payload = payload;
+
+  *group = init;
+
+  return 0;
+}
+
+void hoku_text_group_append_char(hoku_group* group, hoku_char* character)
+{
+  hoku_char* head = group->chars;
+
+  if (head == NULL)
+  {
+    group->chars = character;
+  }
+  else
+  {
+    while (head->next_char != NULL)
+    {
+      head = head->next_char;
+    }
+
+    head->next_char = character;
+  }
+}
+
+int hoku_text_md_text(MD_TEXTTYPE type, const MD_CHAR* text, MD_SIZE size, void* data)
+{
+  hoku_md_state* userdata = (hoku_md_state*) data;
+  // we always cut a new group / char here...
+  hoku_group* new_group;
+  if (hoku_text_group_init(&new_group, userdata->total_offset, userdata->current_group_type, userdata->current_group_payload) != 0) return -1;
+
+  if (userdata->current_group == NULL)
+  {
+    userdata->current_group = new_group;
+    userdata->current_segment->groups = userdata->current_group;
+  }
+  else
+  {
+    userdata->current_group->next_group = new_group;
+    userdata->current_group = userdata->current_group->next_group;
+  }
+
+  hoku_char* current_char = NULL;
+
+  int i = 0;
+
+  while (i < size)
+  {
+    char letter = text[i];
+    int letter_width = (int) userdata->char_width_callback(letter, userdata->char_width_payload);
+//    printf("callback complete\n");
+    /*
+      Part 1, clamp new segment if the total_width is greater than boundary
+    */
+    if ((userdata->line_width + letter_width) > userdata->width)
+    {
+//      printf("part 1: '%c'\n", letter);
+      userdata->line_width = 0.0;
+      // make a new segment
+      hoku_segment* segment;
+      if (hoku_text_segment_init(&segment, userdata->total_offset) != 0) return -1;
+
+      // make a new group
+      hoku_group* group;
+      if (hoku_text_group_init(&group, userdata->total_offset, userdata->current_group_type, userdata->current_group_payload) != 0) return -1;
+
+      // init a char
+      hoku_char* ichar;
+      if (hoku_text_char_init(&ichar, userdata->total_offset, letter_width) != 0) return -1;
+
+      group->chars = ichar;
+      segment->groups = group;
+      group->size += 1;
+      segment->size += 1;
+
+      // append to the segment list and reset current
+      userdata->current_segment->next_segment = segment;
+      userdata->current_segment = segment;
+//      printf("set current segment %p\n", userdata->current_segment);
+
+      userdata->current_group = group;
+
+      current_char = ichar;
+
+      userdata->line_width = (float) letter_width;
+      userdata->total_offset += 1;
+      i += 1;
+      continue;
+    }
+
+    /*
+      Part 2, clamp new segment on newline
+    */
+    switch(letter)
+    {
+      case '\n':
+      {
+//        printf("part 2, new line\n");
+        // make a new segment
+        hoku_segment* next;
+        if (hoku_text_segment_init(&next, userdata->total_offset + 1) != 0) return -1;
+
+        // make a new group
+        hoku_group* group;
+        if (hoku_text_group_init(&group, userdata->total_offset + 1, userdata->current_group_type, userdata->current_group_payload) != 0) return -1;
+
+        next->groups = group;
+
+        // init a char
+        hoku_char* insert;
+        if (hoku_text_char_init(&insert, userdata->total_offset, letter_width) != 0) return -1;
+        
+        if (current_char == NULL)
+        {
+          hoku_text_group_append_char(userdata->current_group, insert);
+          userdata->current_segment->size += 1;
+          userdata->current_group->size += 1;
+        }
+        else
+        {
+          current_char->next_char = insert;
+          userdata->current_segment->size += 1;
+          userdata->current_group->size += 1;
+        }
+
+        // the current group already has a reference to the current_char, so we can set it to NULL here.
+        userdata->current_segment->next_segment = next;
+        userdata->current_segment = next;
+//        printf("set current segment %p\n", userdata->current_segment);
+
+
+        userdata->current_group = group;
+        current_char = NULL;
+
+        userdata->line_width = 0.0;
+        userdata->total_offset += 1;
+        i += 1;
+        continue;
+      }
+    }
+
+//    printf("part 3: add char '%c' %d %d\n", letter, userdata->total_offset, letter_width);
+    /*
+      Part 3, add the next character.
+    */
+    hoku_char* ichar;
+    if (hoku_text_char_init(&ichar, userdata->total_offset, letter_width) != 0) return -1;
+
+//    printf("after init char\n");
+    if (current_char == NULL)
+    {
+      userdata->current_group->chars = ichar;
+      current_char = userdata->current_group->chars;
+    }
+    else
+    {
+      current_char->next_char = ichar;
+      current_char = current_char->next_char;
+    }
+
+    userdata->current_segment->size += 1;
+    userdata->current_group->size += 1;
+    userdata->total_offset += 1;
+    i += 1;
+//    printf("line width: %f %d\n", userdata->line_width, letter_width);
+    userdata->line_width += (float) letter_width;
+  }
+
+  if (hoku_text_md_append(userdata, text, size) != 0) return -1;
+
+//  printf("appending text: %d\n", size);
+  return 0;
+}
+
+void hoku_text_md_debug(const char* message, void* userdata)
+{
+  printf("debug: %s\n", message);
+}
+
+int hoku_text_md_clamp(hoku_clamping** out, char* text, float width, float initial, void* payload, hoku_char_width_cb cb)
+{
+  MD_PARSER parser = {
+    .abi_version      = 0,
+    .flags            = MD_FLAG_NOHTML | MD_FLAG_PERMISSIVEAUTOLINKS | MD_FLAG_HARD_SOFT_BREAKS,
+    .enter_block      = hoku_text_md_enter_block,
+    .leave_block      = hoku_text_md_leave_block,
+    .enter_span       = hoku_text_md_enter_span,
+    .leave_span       = hoku_text_md_leave_span,
+    .text             = hoku_text_md_text,
+    .debug_log        = hoku_text_md_debug,
+    .syntax = NULL
+  };
+
+  hoku_segment* current_segment;
+  if (hoku_text_segment_init(&current_segment, 0) != 0) return -1;
+
+  hoku_group* current_group;
+  if (hoku_text_group_init(&current_group, 0, HOKU_GROUP_NORMAL, NULL) != 0) return -1;
+
+  char* parsed = (char*) calloc(101, sizeof(char));
+  if (parsed == NULL) return -1;
+
+//  hoku_md_state* state = malloc(sizeof(hoku_md_state));
+//  if (state == NULL) return -1;
+//
+//  state->width = width;
+//  state->total_offset = 0;
+//  state->line_width = initial;
+//  state->char_width_callback = cb;
+//  state->char_width_payload = payload;
+//  state->root_segment = current_segment;
+//  state->current_segment = current_segment;
+//  state->current_group = NULL;
+//  state->current_char = NULL;
+//  state->current_group_payload = NULL;
+//  state->parsed = parsed;
+//  state->parsed_len = 100;
+//  state->parsed_counter = 0;
+
+  hoku_md_state state = {
+    .width = width,
+    .total_offset = 0,
+    .line_width = initial,
+    .char_width_payload = payload,
+    .char_width_callback = cb,
+    .root_segment = current_segment,
+    .current_group_type = HOKU_GROUP_NORMAL,
+    .current_segment = current_segment,
+    .current_group = NULL,
+    .current_char = NULL,
+    .current_group_payload = NULL,
+    .parsed = parsed,
+    .parsed_len = 100,
+    .parsed_counter = 0
+  };
+
+//  printf("start parse! %s\n", text);
+  int md_ret = md_parse(text, strlen(text), &parser, &state);
+//  printf("done parse!\n");
+  if (md_ret != 0) return -1;
+
+  hoku_clamping* clamping;
+  hoku_text_clamping_init(&clamping, state.parsed, width);
+
+  if (clamping == NULL) return -1;
+
+  clamping->segments = state.root_segment;
+//  hoku_text_clamp_debug(clamping);
+
+  *out = clamping;
+  return 0;
+}
+
+int hoku_text_clamp(hoku_clamping** out, char* text, float width, float initial, void* payload, hoku_char_width_cb cb)
+{
+  hoku_clamping* clamping;
+  hoku_text_clamping_init(&clamping, text, width);
+
+  int l = 0;
+  int len = strlen(clamping->text);
+
+  int total_offset = 0;                 // the sum of the offsets, used to mark the total chars before the start of current line
+  float line_width = initial;           // the aggregate width of the current line
+  int last = 0;                         // the last known space or newline
+
+  hoku_segment* current;
+  hoku_text_segment_init(&current, 0);
+  clamping->segments = current;
+
+  hoku_char* character = NULL;
+
+  // iterate through the whole string
+  while (total_offset < len)
+  {
+//    printf("t: %d - %d (%f) %c\n", total_offset, len, line_width, clamping->text[total_offset]);
+    char letter = clamping->text[total_offset];
+    int letter_width = (int) cb(letter, payload);
+//    printf("lw %c, %d\n", clamping->text[total_offset], letter_width);
+
+    if ((line_width + letter_width) > width)
+    {
+//      printf("last: %d > %d (%d)\n", last, current->offset, total_offset);
+      if ((last > current->offset) && ((last - current->offset) > ((total_offset - current->offset) / 2.0)))
+      {
+//        hoku_text_clamp_debug(clamping);
+
+//        printf("split branch %d\n", last - current->offset);
+        int split_index = last - current->offset;
+
+//                printf("current size: %d\n", current->size);
+
+        hoku_text_segment_split(current, split_index);
+        current = current->next_segment;
+
+
+        hoku_char* cn;
+        if (hoku_text_char_init(&cn, total_offset, letter_width) != 0) return -1;
+        if (current->chars != NULL)
+        {
+//        printf("Oky\n");
+          current->chars->next_char = cn;
+          character = cn;
+        }
+        else
+        {
+//        printf("wha\n");
+          current->chars = cn;
+          character = cn;
+        }
+
+//        printf("af\n");
+
+        hoku_text_clamp_debug(clamping);
+
+        float split_width = 0.0;
+
+        // sum the last split characters
+        line_width = hoku_text_char_sum(current->chars);
+        current->size += 1;
+
+        total_offset += 1;
+        continue;
+      }
+      // hard break on line
+      else
+      {
+       printf("easy branch %d\n", total_offset);
+
+        // make a new segment
+        hoku_segment* segment;
+        if (hoku_text_segment_init(&segment, total_offset) != 0) return -1;
+
+        // init a char
+        hoku_char* ichar;
+        if (hoku_text_char_init(&ichar, total_offset, letter_width) != 0) return -1;
+
+        segment->chars = ichar;
+        segment->size += 1;
+
+
+        // append to the segment list and reset current
+        current->next_segment = segment;
+        current = current->next_segment;
+
+        character = current->chars;
+
+        line_width = letter_width;
+        total_offset += 1;
+//        printf("eadsy done\n");
+        continue;
+      }
+    }
+
+//    printf("Switch\n");
+    switch(clamping->text[total_offset])
+    {
+      case '\n':
+      {
+        hoku_segment* next;
+        if (hoku_text_segment_init(&next, total_offset + 1) != 0) return -1;
+
+        hoku_char* insert;
+        if (hoku_text_char_init(&insert, total_offset, letter_width) != 0) return -1;
+
+        if (character == NULL)
+        {
+          character = insert;
+          current->size += 1;
+        }
+        else
+        {
+          character->next_char = insert;
+          current->size += 1;
+        }
+
+        current->next_segment = next;
+        current = current->next_segment;
+        character = NULL;
+
+        line_width = 0.0;
+        total_offset += 1;
+        continue;
+      }
+    }
+
+//    printf("okay %d %d %p\n", total_offset, letter_width, current);
+    hoku_char* ichar;
+    if (hoku_text_char_init(&ichar, total_offset, letter_width) != 0) return -1;
+
+    if (character == NULL)
+    {
+//      printf("whoa\n");
+      current->chars = ichar;
+      character = current->chars;
+//      printf("okay\n");
+    }
+    else
+    {
+//      printf("shouldn't happen\n");
+      character->next_char = ichar;
+      character = character->next_char;
+//      printf("done\n");
+    }
+
+
+    current->size += 1;
+    total_offset += 1;
+    line_width += letter_width;
+  }
+
+//  printf("out\n");
+  *out = clamping;
+  return 0;
+}
+
+#endif