mathematical 0.5.0 → 0.6.0

data/ext/mathematical/mtex2MML/src/parse_extras.c

@@ -1,281 +1,229 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+
 #include "parse_extras.h"
 #include "string_extras.h"
-#include "stack.h"
-
-#ifdef FLIP_OFFSET_VAL
-#define OFFSET_VAL 0
-#else
-#define OFFSET_VAL 1
-#endif
-
-void initSymbolDataArray(symbolDataArray *a, size_t initialSize)
-{
-  // Allocate initial space
-  a->array = (symbolData *)malloc(initialSize * sizeof(symbolData));
-
-  a->used = 0;           // no elements used
-  a->size = initialSize; // available number of elements
-
-  // Initialize all elements of the array at once: they are contiguous
-  memset(&a->array[0], 0, sizeof(symbolData) * initialSize);
-}
 
-void insertSymbolDataArray(symbolDataArray *a, symbolData element)
+void env_replacements(UT_array **environment_data_stack, const char *environment)
 {
-  if (a->used == a->size) {
-      a->size *= 2;
-      a->array = (symbolData *)realloc(a->array, a->size * sizeof(symbolData));
-      // Initialize the last/new elements of the reallocated array
-      memset(&a->array[a->used],0, sizeof(symbolData) * (a->size - a->used));
-  }
-
-  a->array[a->used].attribute = (char*)malloc(strlen(element.attribute) + 1);
-  strcpy(a->array[a->used].attribute, element.attribute);
-
-  a->array[a->used].offset_pos = element.offset_pos;
-
-  a->used++;
-}
-
-void sortSymbolDataArray(symbolDataArray *a) {
-  int i, j, n = a->used;
-
-  for(i = 1; i < n; i++) {
-    for(j = 0; j < n - i; j++) {
-      if(a->array[j].offset_pos < a->array[j+1].offset_pos) {
-          symbolData temp = a->array[j];
-          a->array[j] = a->array[j+1];
-          a->array[j+1] = temp;
-      }
-    }
-  }
-}
-
-void deleteSymbolDataArray(symbolDataArray *a)
-{
-  int i;
-
-  // Free all name variables of each array element first
-  for(i = 0; i <a->used; i++)
-  {
-    free(a->array[i].attribute);
-    a->array[i].attribute = NULL;
-  }
-
-  // Now free the array
-  free(a->array);
-  a->array = NULL;
-
-  a->used = 0;
-  a->size = 0;
-}
-
-char * env_replacements(const char *string) {
-  stackT array_stack;
-  stackElementT stack_item, last_stack_item;
+  UT_array *array_stack;
+  UT_array *row_spacing_stack;
+  UT_array *rowlines_stack;
 
   char *tok = NULL, *at_top = NULL;
-  char *new_environment = dupe_string(string), *dupe_str = dupe_string(string);
-  char *line = strtok(dupe_str, "\n");
-  char *attr_rowlines = "", *attr_rowspacing = "", *em_str, *temp = "";
 
+  char *temp = "", **last_stack_item;
+  char *a, *em_str;
   const char *from = "\\begin", *until = "\\end", *hline = "\\hline", *hdashline = "\\hdashline",
-             *line_separator = "\\\\",
-             *em_pattern_begin = "\\[", *em_pattern_end = "]";
+              *line_separator = "\\\\",
+               *em_pattern_begin = "\\[", *em_pattern_end = "]",
+                *is_smallmatrix = NULL, *is_gathered = NULL;
 
-  int start = 0, offset = 0, attr_rowlines_len = 0, str_len = 0, i = 0;
-  symbolDataArray hline_data_array;
-  symbolData hline_data;
-
-  symbolDataArray row_spacing_data_array;
-  symbolData row_spacing_data;
-
-  // set up the array stack
-  StackInit(&array_stack, strlen(new_environment));
-  initSymbolDataArray(&hline_data_array, 5);
-  initSymbolDataArray(&row_spacing_data_array, 1);
+  int rowlines_stack_len = 0, em_offset = 0;
 
   // if not an environment, don't bother going on
-  if ((strstr(string, from) == NULL && strstr(string, until) == NULL)) {
-    StackDestroy(&array_stack);
-    deleteSymbolDataArray(&hline_data_array);
-    deleteSymbolDataArray(&row_spacing_data_array);
-    free(dupe_str);
-
-    return string;
+  if ( ((strstr(environment, from) == NULL && strstr(environment, until) == NULL)) || strstr(environment, "begin{svg}")) {
+    return;
   }
 
-  while (line != NULL) {
-    str_len = strlen(line) + 1;
-
-    stack_item.line = line;
-    stack_item.line_pos = start + 1;
+  char *dupe_environment = dupe_string(environment);
+  char *line = strtok(dupe_environment, "\n");
 
-    start += str_len;
+  // set up the array stack
+  utarray_new(array_stack, &ut_str_icd);
+  utarray_new(row_spacing_stack, &ut_str_icd);
+  utarray_new(rowlines_stack, &ut_str_icd);
 
-    StackPush(&array_stack, stack_item);
+  while (line != NULL) {
+    utarray_push_back(array_stack, &line);
 
     if (strstr(line, until) != NULL) {
-      while (!StackIsEmpty(&array_stack)) {
-        last_stack_item = StackPop(&array_stack);
-        attr_rowlines_len = strlen(attr_rowlines);
-        at_top = strstr(last_stack_item.line, from);
+      while (utarray_len(array_stack) > 0) {
+        last_stack_item = (char **)utarray_back(array_stack);
+
+        rowlines_stack_len = utarray_len(rowlines_stack);
+        at_top = strstr(*last_stack_item, from);
 
         // we've reached the top, but there looks like there might be some data
-        if (at_top != NULL && strstr(last_stack_item.line, line_separator) == NULL) {
+        if (at_top != NULL && strstr(*last_stack_item, line_separator) == NULL) {
           break;
         }
 
-        // looking for a line match
-        if (strstr(last_stack_item.line, hline) != NULL) {
-          if (attr_rowlines_len > 0)
-            remove_last_char(attr_rowlines);
-          attr_rowlines = join(attr_rowlines, "s");
-        }
-        else if (strstr(last_stack_item.line, hdashline) != NULL) {
-          if (attr_rowlines_len > 0)
-            remove_last_char(attr_rowlines);
-          attr_rowlines = join(attr_rowlines, "d");
-        }
-        else {
-          attr_rowlines = join(attr_rowlines, "0");
+        // looking for a hline/hdashline match
+        if (strstr(*last_stack_item, hline) != NULL) {
+          if (rowlines_stack_len > 0) {
+            utarray_pop_back(rowlines_stack);
+          }
+          a = "solid";
+          utarray_push_back(rowlines_stack, &a);
+        } else if (strstr(*last_stack_item, hdashline) != NULL) {
+          if (rowlines_stack_len > 0) {
+            utarray_pop_back(rowlines_stack);
+          }
+          a = "dashed";
+          utarray_push_back(rowlines_stack, &a);
+        } else {
+          a = "none";
+          utarray_push_back(rowlines_stack, &a);
         }
 
-        if (strstr(last_stack_item.line, line_separator) != NULL) {
-          if ( (tok = strstr(last_stack_item.line, em_pattern_begin)) != NULL) {
-            temp = tok + 2;
+        // if there's a line break...
+        if (strstr(*last_stack_item, line_separator) != NULL) {
+          // when an emphasis match, add it...
+          if ( (tok = strstr(*last_stack_item, em_pattern_begin)) != NULL) {
+            temp = tok + 2; // skip the first part ("\[")
             if ( (tok = strstr(temp, em_pattern_end)) != NULL) {
-              offset = (int)(tok - temp);
-              em_str = malloc(offset);
-              if (strlen(em_str) != 0) {
-                em_str = dupe_string_n(temp, offset);
-                // MathML always expectes "em" points
-                convertToEm(em_str);
-                row_spacing_data.attribute = em_str;
-                row_spacing_data.offset_pos = -1; // this value is not really important
-                insertSymbolDataArray(&row_spacing_data_array, row_spacing_data);
-                free(em_str);
-              }
+              em_offset = (int)(tok - temp);
+              char *s = dupe_string_n(temp, em_offset);
+              utarray_push_back(row_spacing_stack, &s);
+              free(s);
             }
           }
+          // otherwise, use the default
           else {
-            row_spacing_data.attribute = "0em";
-            row_spacing_data.offset_pos = -1; // this value is not really important
-            insertSymbolDataArray(&row_spacing_data_array, row_spacing_data);
+            if (strstr(*last_stack_item, "\\begin{smallmatrix}") != NULL) {
+              em_str = "0.2em";
+            } else if (strstr(*last_stack_item, "\\begin{gathered}") != NULL) {
+              em_str = "1.0ex";
+            } else {
+              em_str = "0.5ex";
+            }
+            utarray_push_back(row_spacing_stack, &em_str);
           }
         }
 
+        // make sure to pop at the end here; it messes with some references in Travis/Ubuntu for some reason
+        utarray_pop_back(array_stack);
+
         // we've reached the top, so stop.
-        if (at_top != NULL)
+        if (at_top != NULL) {
           break;
+        }
+      }
+      if (at_top != NULL) {
+        is_smallmatrix = strstr(at_top, "\\begin{smallmatrix}");
+        is_gathered = strstr(at_top, "\\begin{gathered}");
       }
 
-      if (attr_rowlines_len != 0) {
-        // array is form of \begin{array}[t]{cc..c}
-        tok = strstr(last_stack_item.line, "]{");
-        if (tok == NULL) {
-          // array is form of \begin{array}{cc..c}
-          tok = strstr(last_stack_item.line, "}{");
-        }
-        if (tok == NULL) {
-          // not an array, but rather, some env, like \begin{cases}
-          tok = strstr(last_stack_item.line, "}");
-        }
+      // TODO: we are skipping equation environments
+      if ((rowlines_stack_len != 0 || utarray_len(row_spacing_stack)) && strstr(*last_stack_item, "\\begin{equation}") == NULL) {
+        perform_replacement(environment_data_stack, rowlines_stack, is_smallmatrix, is_gathered, row_spacing_stack);
+      }
 
-        offset = last_stack_item.line_pos + (tok - last_stack_item.line);
-        // we cut the last char because we can skip the first row
-        remove_last_char(attr_rowlines);
+      utarray_clear(row_spacing_stack);
+      utarray_clear(rowlines_stack);
+      rowlines_stack_len = 0;
+    }
 
-        // we reverse the string, because we're going backwards
-        strrev(attr_rowlines);
+    line = strtok(NULL, "\n");
+  }
 
-        // empty rowlines should be reset
-        if (strlen(attr_rowlines) == 0)
-          attr_rowlines = join(attr_rowlines, "0");
+  utarray_free(array_stack);
+  utarray_free(row_spacing_stack);
+  utarray_free(rowlines_stack);
+  free(dupe_environment);
+}
 
-        attr_rowlines = join(join("(", attr_rowlines), ")");
+void perform_replacement(UT_array **environment_data_stack, UT_array *rowlines_stack, const char *is_smallmatrix, const char *is_gathered, UT_array *row_spacing_stack)
+{
+  char *a, *attr_rowlines, *attr_rowspacing;
+  envdata_t row_data;
 
-        for (i = row_spacing_data_array.used - 1; i >= 0; i--) {
-          attr_rowspacing = join(join(attr_rowspacing, row_spacing_data_array.array[i].attribute), "|");
-        }
+  // we cut the last char because we can always skip the first row
+  utarray_pop_back(rowlines_stack);
 
-        if (strlen(attr_rowspacing) > 0) {
-          if (empty_row_spacings(attr_rowspacing) == 1) {
-            attr_rowspacing = "0.5ex";
-          }
-          else {
-            // last char is a pipe (|)
-            remove_last_char(attr_rowspacing);
-          }
+  // empty rowlines should be reset
+  if (utarray_len(rowlines_stack) == 0) {
+    a = "none";
+    utarray_push_back(rowlines_stack, &a);
+  }
 
-          attr_rowspacing = join(join("<", attr_rowspacing), ">");
-        }
+  // given the row_attribute values, construct an attribute list (separated by spaces)
+  UT_string *l;
+  utstring_new(l);
+  char **o=NULL;
+  a = "rowlines=\"";
+  utstring_printf(l, "%s", a);
+  while ( (o=(char**)utarray_prev(rowlines_stack,o))) {
+    utstring_printf(l, "%s ", *o);
+  }
 
-        hline_data.attribute = join(attr_rowspacing, attr_rowlines);
-        hline_data.offset_pos = offset + OFFSET_VAL;
-        insertSymbolDataArray(&hline_data_array, hline_data);
-      }
+  attr_rowlines = utstring_body(l);
+  if (strlen(attr_rowlines) > 0) {
+    remove_last_char(attr_rowlines); // remove the final space
+  }
 
-      attr_rowlines = "";
-      attr_rowspacing = "";
-      attr_rowlines_len = 0;
+  // given the row_spacing values, construct an attribute list (separated by spaces)
+  UT_string *s;
+  utstring_new(s);
+  char **p=NULL;
+  while ( (p=(char**)utarray_prev(row_spacing_stack,p))) {
+    if (is_smallmatrix && strcmp(*p, "0.5ex") == 0) {
+      utstring_printf(s, "%s ", "0.2em");
+    } else if (is_gathered && strcmp(*p, "0.5ex") == 0) {
+      utstring_printf(s, "%s ", "1.0ex");
+    } else {
+      utstring_printf(s, "%s ", *p);
     }
-
-    line = strtok(NULL, "\n");
   }
 
-  // sort array by highest values first, so that we can insert to new_environment from
-  // the bottom to the top (ensuring line numbers don't shift)
-  sortSymbolDataArray(&hline_data_array);
-
-  for (i = 0; i < hline_data_array.used; i++) {
-    insert_substring(&new_environment, hline_data_array.array[i].attribute, hline_data_array.array[i].offset_pos);
+  attr_rowspacing = utstring_body(s);
+  if (strlen(attr_rowspacing) > 0) {
+    remove_last_char(attr_rowspacing); // remove the final space
+  } else {
+    if (is_smallmatrix != NULL) {
+      attr_rowspacing = "0.2em";
+    } else if (is_gathered != NULL) {
+      attr_rowspacing = "1.0ex";
+    } else {
+      attr_rowspacing = "0.5ex";
+    }
   }
 
-  StackDestroy(&array_stack);
-  deleteSymbolDataArray(&hline_data_array);
-  deleteSymbolDataArray(&row_spacing_data_array);
-  free(dupe_str);
+  row_data.rowspacing = attr_rowspacing;
+  row_data.rowlines = attr_rowlines;
 
-  return new_environment;
+  utarray_push_back(*environment_data_stack, &row_data);
+  utstring_free(l);
+  utstring_free(s);
 }
 
-const char *vertical_pipe_extract(const char *string) {
-  char *orig = dupe_string(string);
-  char *columnlines = "", *previous_column = "";
+const char *vertical_pipe_extract(const char *string)
+{
+  char *dupe = dupe_string(string);
+  UT_string *columnlines, *border;
+  char *previous_column = "", *attr_columnlines, *attr_border;
   int i = 0;
 
-  if (strncmp(orig, "s", 1) == 0) {
-    columnlines = "frame=\"solid\" columnlines=\"";
-    remove_first_char(orig);
-  }
-  else if (strncmp(orig, "d", 1) == 0) {
-    columnlines = "frame=\"dashed\" columnlines=\"";
-    remove_first_char(orig);
-  }
-  else {
-    columnlines = "columnlines=\"";
+  utstring_new(columnlines);
+  utstring_new(border);
+
+  // the first character (if it exists) determines the frame border
+  if (strncmp(dupe, "s", 1) == 0) {
+    utstring_printf(columnlines, "%s", "frame=\"solid\" columnlines=\"");
+    remove_first_char(dupe);
+  } else if (strncmp(dupe, "d", 1) == 0) {
+    utstring_printf(columnlines, "%s", "frame=\"dashed\" columnlines=\"");
+    remove_first_char(dupe);
+  } else {
+    utstring_printf(columnlines, "%s", "columnlines=\"");
   }
 
-  char *token = strtok(orig, " ");
+  char *token = strtok(dupe, " ");
 
   while (token != NULL) {
     if (strncmp(token, "s", 1) == 0) {
       previous_column = "s";
-      columnlines = join(columnlines, "solid ");
-    }
-    else if (strncmp(token, "d", 1) == 0) {
+      utstring_printf(border, "%s ", "solid");
+    } else if (strncmp(token, "d", 1) == 0) {
       previous_column = "d";
-      columnlines = join(columnlines, "dashed ");
-    }
-    else {
+      utstring_printf(border, "%s ", "dashed");
+    } else {
       if (i >= 1) { // we must skip the first blank col
         // only if there is no previous border should a border be considered, eg. "cc", not "c|c"
         if (strncmp(previous_column, "s", 1) != 0 && strncmp(previous_column, "d", 1) != 0) {
-          columnlines = join(columnlines, "none ");
+          utstring_printf(border, "%s ", "none");
         }
         previous_column = "0";
       }
@@ -285,22 +233,73 @@ const char *vertical_pipe_extract(const char *string) {
     token = strtok(NULL, " ");
   }
 
-  // an empty string here angers Lasem
-  if (strncmp(columnlines, "columnlines=\"\0", 14) == 0)
-    columnlines = "columnlines=\"none";
-  // an empty space also angers Lasem
-  else
-    remove_last_char(columnlines);
+  attr_border = utstring_body(border);
+  if (strlen(attr_border) > 0) {
+    remove_last_char(attr_border); // remove the final space
+  }
+  utstring_printf(columnlines, "%s", attr_border);
+
+  // an empty string here angers Lasem, so let's remember to add 'none'
+  if (utstring_len(border) == 0) {
+    utstring_printf(columnlines, "%s", "none");
+  }
+
+  attr_columnlines = utstring_body(columnlines);
+  free(dupe);
+  utstring_free(border);
+
+  return attr_columnlines;
+}
+
+const char *remove_excess_pipe_chars(const char *string)
+{
+  UT_string *columnalign;
+  utstring_new(columnalign);
+
+  char *dupe = dupe_string(string);
+  char *token = strtok(dupe, " ");
+  char *attr_columnalign;
+
+  while (token != NULL) {
+    if (strncmp(token, "s", 1) != 0 && strncmp(token, "d", 1) != 0) {
+      utstring_printf(columnalign, "%s ", token);
+    }
+    token = strtok(NULL, " ");
+  }
+
+  attr_columnalign = utstring_body(columnalign);
+  free(dupe);
+
+  if (strlen(attr_columnalign) > 0) {
+    remove_last_char(attr_columnalign); // remove the final space
+  }
 
-  free(orig);
-  return columnlines;
+  return attr_columnalign;
 }
 
-const char *remove_excess_pipe_chars(const char *string) {
-  char *dup = dupe_string(string);
+const char *combine_row_data(UT_array **environment_data_stack)
+{
+  // if no information was provided, give a standard sizing
+  if (utarray_len(*environment_data_stack) == 0) {
+    const char* s = "rowspacing=\"0.5ex\" rowlines=\"none\"";
+    char* c = (char*)malloc(strlen(s) + 1);
+    strcpy(c, s);
+    return c;
+  }
+  envdata_t *row_data_elem = (envdata_t*) utarray_front(*environment_data_stack);
+
+  char *row_spacing_data = row_data_elem->rowspacing,
+        *row_lines_data = row_data_elem->rowlines,
+         *row_attr;
+
+  UT_string *row_attr_data;
+  utstring_new(row_attr_data);
+
+  // combine the row spacing and row lines data
+  utstring_printf(row_attr_data, "%s%s\" %s\"", "rowspacing=\"", row_spacing_data, row_lines_data);
 
-  dup = replace_str(dup, "s", "");
-  dup = replace_str(dup, "d", "");
+  row_attr = dupe_string(utstring_body(row_attr_data));
+  utarray_erase(*environment_data_stack, 0, 1);
 
-  return dup;
+  return row_attr;
 }