mathematical 1.1.1 → 1.2.0

data/ext/mathematical/mtex2MML/src/mtex2MML.h

@@ -54,6 +54,7 @@ extern int    mtex2MML_lineno;
 
 extern int    mtex2MML_rowposn;
 extern int    mtex2MML_displaymode;
+extern int    display_style;
 
 #ifdef __cplusplus
 }

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

@@ -7,29 +7,46 @@
 
 void env_replacements(UT_array **environment_data_stack, encaseType * encase, const char *environment)
 {
+  const char *from = "\\begin", *until = "\\end",
+              *begin_svg = "begin{svg}";
+
+  // if not an environment, don't bother going on
+  if ((strstr(environment, from) == NULL && strstr(environment, until) == NULL) || strstr(environment, begin_svg)) {
+    return;
+  }
+
   UT_array *array_stack;
   UT_array *row_spacing_stack;
   UT_array *rowlines_stack;
 
-  char *tok = NULL, *at_top = NULL;
+  char *tok = NULL, *at_top = NULL,
+        *temp = "", **last_stack_item,
+         *a, *em_str;
+
+  envType environmentType = OTHER;
+  if (strstr(environment, "\\end{smallmatrix}") != NULL) {
+    environmentType = ENV_SMALLMATRIX;
+  } else if (strstr(environment, "\\end{gathered}") != NULL) {
+    environmentType = ENV_GATHERED;
+  } else if (strstr(environment, "\\end{eqnarray") != NULL) {
+    environmentType = ENV_EQNARRAY;
+  } else if (strstr(environment, "\\end{multline") != NULL) {
+    environmentType = ENV_MULTLINE;
+  } else if (strstr(environment, "\\end{alignat") != NULL) {
+    environmentType = ENV_ALIGNAT;
+  }else if (strstr(environment, "\\end{aligned}") != NULL) {
+    environmentType = ENV_ALIGNED;
+  }
 
-  char *temp = "", **last_stack_item;
-  char *a, *em_str;
-  const char *from = "\\begin", *until = "\\end", *hline = "\\hline", *hdashline = "\\hdashline",
+  const char *hline = "\\hline", *hdashline = "\\hdashline",
               *line_separator = "\\\\",
-              *cr_separator = "\\cr",
-              *newline_separator = "\\newline",
-               *em_pattern_begin = "\\[", *em_pattern_end = "]",
-                *is_smallmatrix = NULL, *is_gathered = NULL;
+               *cr_separator = "\\cr",
+                *newline_separator = "\\newline",
+                 *em_pattern_begin = "\\[", *em_pattern_end = "]";
 
   int rowlines_stack_len = 0, em_offset = 0;
 
-  // if not an environment, don't bother going on
-  if ( ((strstr(environment, from) == NULL && strstr(environment, until) == NULL)) || strstr(environment, "begin{svg}")) {
-    return;
-  }
-
-  char *dupe_environment = dupe_string(environment);
+  char *dupe_environment = strdup(environment);
   char *line = strtok(dupe_environment, "\n");
 
   // set up the array stack
@@ -49,8 +66,8 @@ void env_replacements(UT_array **environment_data_stack, encaseType * encase, co
 
         // we've reached the top, but there looks like there might be some data
         if (at_top != NULL && strstr(*last_stack_item, line_separator) == NULL && \
-           strstr(*last_stack_item, cr_separator) == NULL && \
-           strstr(*last_stack_item, newline_separator) == NULL) {
+            strstr(*last_stack_item, cr_separator) == NULL && \
+            strstr(*last_stack_item, newline_separator) == NULL) {
           if (strstr(*last_stack_item, hline) != NULL || strstr(*last_stack_item, hdashline) != NULL) {
             *encase = TOPENCLOSE;
           }
@@ -78,24 +95,28 @@ void env_replacements(UT_array **environment_data_stack, encaseType * encase, co
 
         // if there's a line break...
         if (strstr(*last_stack_item, line_separator) != NULL || \
-           strstr(*last_stack_item, cr_separator) != NULL || \
-           strstr(*last_stack_item, newline_separator) != NULL) {
+            strstr(*last_stack_item, cr_separator) != NULL || \
+            strstr(*last_stack_item, newline_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) {
               em_offset = (int)(tok - temp);
-              char *s = dupe_string_n(temp, em_offset);
+              char *s = strndup(temp, em_offset);
               utarray_push_back(row_spacing_stack, &s);
               free(s);
             }
           }
           // otherwise, use the default
           else {
-            if (strstr(*last_stack_item, "\\begin{smallmatrix}") != NULL) {
+            if (environmentType == ENV_SMALLMATRIX) {
               em_str = "0.2em";
-            } else if (strstr(*last_stack_item, "\\begin{gathered}") != NULL) {
+            } else if (environmentType == ENV_GATHERED) {
               em_str = "1.0ex";
+            } else if (environmentType == ENV_EQNARRAY || environmentType == ENV_ALIGNAT || environmentType  == ENV_ALIGNED) {
+              em_str = "3pt";
+            } else if (environmentType == ENV_MULTLINE) {
+              em_str = "0.5em";
             } else {
               em_str = "0.5ex";
             }
@@ -111,13 +132,9 @@ void env_replacements(UT_array **environment_data_stack, encaseType * encase, co
           break;
         }
       }
-      if (at_top != NULL) {
-        is_smallmatrix = strstr(at_top, "\\begin{smallmatrix}");
-        is_gathered = strstr(at_top, "\\begin{gathered}");
-      }
 
       if ((rowlines_stack_len != 0 || utarray_len(row_spacing_stack))) {
-        perform_replacement(environment_data_stack, rowlines_stack, is_smallmatrix, is_gathered, row_spacing_stack);
+        perform_replacement(environment_data_stack, rowlines_stack, environmentType, row_spacing_stack);
       }
 
       utarray_clear(row_spacing_stack);
@@ -134,16 +151,18 @@ void env_replacements(UT_array **environment_data_stack, encaseType * encase, co
   free(dupe_environment);
 }
 
-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)
+void perform_replacement(UT_array **environment_data_stack, UT_array *rowlines_stack, envType environmentType, UT_array *row_spacing_stack)
 {
   char *a, *attr_rowlines, *attr_rowspacing;
-  envdata_t row_data;
+  envdata_t env_data;
 
   // we cut the last char because we can always skip the first row
   utarray_pop_back(rowlines_stack);
 
+  int line_count = utarray_len(rowlines_stack);
+
   // empty rowlines should be reset
-  if (utarray_len(rowlines_stack) == 0) {
+  if (line_count == 0) {
     a = "none";
     utarray_push_back(rowlines_stack, &a);
   }
@@ -168,9 +187,9 @@ void perform_replacement(UT_array **environment_data_stack, UT_array *rowlines_s
   utstring_new(s);
   char **p=NULL;
   while ( (p=(char**)utarray_prev(row_spacing_stack,p))) {
-    if (is_smallmatrix && strcmp(*p, "0.5ex") == 0) {
+    if (environmentType == ENV_SMALLMATRIX && strcmp(*p, "0.5ex") == 0) {
       utstring_printf(s, "%s ", "0.2em");
-    } else if (is_gathered && strcmp(*p, "0.5ex") == 0) {
+    } else if (environmentType == ENV_GATHERED && strcmp(*p, "0.5ex") == 0) {
       utstring_printf(s, "%s ", "1.0ex");
     } else {
       utstring_printf(s, "%s ", *p);
@@ -181,26 +200,29 @@ void perform_replacement(UT_array **environment_data_stack, UT_array *rowlines_s
   if (strlen(attr_rowspacing) > 0) {
     remove_last_char(attr_rowspacing); // remove the final space
   } else {
-    if (is_smallmatrix != NULL) {
+    if (environmentType == ENV_SMALLMATRIX) {
       attr_rowspacing = "0.2em";
-    } else if (is_gathered != NULL) {
+    } else if (environmentType == ENV_GATHERED) {
       attr_rowspacing = "1.0ex";
     } else {
       attr_rowspacing = "0.5ex";
     }
   }
 
-  row_data.rowspacing = attr_rowspacing;
-  row_data.rowlines = attr_rowlines;
+  // store pertinent metadata
+  env_data.rowspacing = attr_rowspacing;
+  env_data.rowlines = attr_rowlines;
+  env_data.environmentType = environmentType;
+  env_data.line_count = line_count;
 
-  utarray_push_back(*environment_data_stack, &row_data);
+  utarray_push_back(*environment_data_stack, &env_data);
   utstring_free(l);
   utstring_free(s);
 }
 
 const char *vertical_pipe_extract(const char *string)
 {
-  char *dupe = dupe_string(string);
+  char *dupe = strdup(string);
   UT_string *columnlines, *border;
   char *previous_column = "", *attr_columnlines, *attr_border;
   int i = 0;
@@ -253,9 +275,10 @@ const char *vertical_pipe_extract(const char *string)
     utstring_printf(columnlines, "%s", "none");
   }
 
-  attr_columnlines = utstring_body(columnlines);
+  attr_columnlines = strdup(utstring_body(columnlines));
   free(dupe);
   utstring_free(border);
+  utstring_free(columnlines);
 
   return attr_columnlines;
 }
@@ -265,7 +288,7 @@ const char *remove_excess_pipe_chars(const char *string)
   UT_string *columnalign;
   utstring_new(columnalign);
 
-  char *dupe = dupe_string(string);
+  char *dupe = strdup(string);
   char *token = strtok(dupe, " ");
   char *attr_columnalign;
 
@@ -276,8 +299,9 @@ const char *remove_excess_pipe_chars(const char *string)
     token = strtok(NULL, " ");
   }
 
-  attr_columnalign = utstring_body(columnalign);
+  attr_columnalign = strdup(utstring_body(columnalign));
   free(dupe);
+  utstring_free(columnalign);
 
   if (strlen(attr_columnalign) > 0) {
     remove_last_char(attr_columnalign); // remove the final space
@@ -307,8 +331,119 @@ const char *combine_row_data(UT_array **environment_data_stack)
   // combine the row spacing and row lines data
   utstring_printf(row_attr_data, "%s%s\" %s\"", "rowspacing=\"", row_spacing_data, row_lines_data);
 
-  row_attr = dupe_string(utstring_body(row_attr_data));
+  row_attr = strdup(utstring_body(row_attr_data));
   utarray_erase(*environment_data_stack, 0, 1);
 
+  utstring_free(row_attr_data);
+
   return row_attr;
 }
+
+const float extract_number_from_pxstring(const char * str)
+{
+  float dbl;
+  int match = 0;
+
+  match = sscanf (str, "%*[^-0123456789]%f", &dbl);
+  if (match == 1) {
+    return dbl;
+  }
+
+  // must not be a float.
+  sscanf (str, "%d", &match);
+  return (float) match;
+}
+
+const char *extract_string_from_pxstring(const char * str)
+{
+  char *pixel;
+  float dbl;
+  pixel = malloc(3*sizeof(char));
+  sscanf (str, "%f%s", &dbl, pixel);
+  return pixel;
+}
+
+const char * dbl2em(const char *str)
+{
+  UT_string *em;
+  utstring_new(em);
+
+  float dbl = extract_number_from_pxstring(str);
+  dbl *= 0.056;
+
+  utstring_printf(em, "%.3fem", dbl);
+  char * em_str = strdup(utstring_body(em));
+
+  utstring_free(em);
+
+  return em_str;
+}
+
+const char * double_pixel(float f, char *pixel)
+{
+  UT_string *em;
+  utstring_new(em);
+
+  float dbl = f * 2;
+  utstring_printf(em, "%.3f%s", dbl, pixel);
+  char * em_str = strdup(utstring_body(em));
+
+  utstring_free(em);
+
+  return em_str;
+}
+
+const char * implement_skew(char *base_str, char *em_skew, char *pattern)
+{
+  UT_string *skew_mathml;
+  utstring_new(skew_mathml);
+
+  utstring_printf(skew_mathml, "%s%s%s", "<mrow><mrow><mrow><mover><mrow>", base_str, "<mspace width=\"");
+  utstring_printf(skew_mathml, "%s%s%s", em_skew, "\" /></mrow>", "<mo stretchy=\"false\">");
+  utstring_printf(skew_mathml, "%s%s%s", pattern, "</mo></mover></mrow><mspace width=\"-", em_skew);
+  utstring_printf(skew_mathml, "%s", "\" /></mrow><mrow></mrow></mrow>");
+
+  char * skew_mathml_str = strdup(utstring_body(skew_mathml));
+
+  utstring_free(skew_mathml);
+
+  return skew_mathml_str;
+}
+
+const char * root_pos_to_em(const char * str)
+{
+  UT_string *em;
+  utstring_new(em);
+
+  float dbl = extract_number_from_pxstring(str);
+  dbl /= 15;
+
+  utstring_printf(em, "%.3fem", dbl);
+  char * em_str = strdup(utstring_body(em));
+
+  utstring_free(em);
+
+  return em_str;
+}
+
+envType current_env_type(UT_array **environment_data_stack)
+{
+  if (utarray_len(*environment_data_stack) == 0) {
+    return -1;
+  }
+
+  envdata_t *row_data_elem = (envdata_t*) utarray_front(*environment_data_stack);
+
+  return row_data_elem->environmentType;
+}
+
+int current_env_line_count(UT_array **environment_data_stack)
+{
+  if (utarray_len(*environment_data_stack) == 0) {
+    return -1;
+  }
+
+  envdata_t *row_data_elem = (envdata_t*) utarray_front(*environment_data_stack);
+
+  return row_data_elem->line_count;
+}

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

@@ -9,18 +9,15 @@ extern "C" {
 #endif
 
 typedef enum {NONE = 0, TOPENCLOSE} encaseType;
+typedef enum {OTHER = 0, ENV_ALIGNAT, ENV_ALIGNED, ENV_GATHERED, ENV_EQNARRAY, ENV_MULTLINE, ENV_SMALLMATRIX} envType;
 
 typedef struct {
   char *rowspacing;
   char *rowlines;
-  int empty;
+  envType environmentType;
+  int line_count;
 } envdata_t;
 
-typedef struct {
-  char *attribute;
-  int  offset_pos;
-} symbolData;
-
 struct css_colors {
   char name[22];             /* key */
   char color[10];
@@ -58,11 +55,11 @@ struct css_colors {
 //
 // The env_replacements function will push every line onto a stack. When an \end
 // is detected, it starts popping off the stack until it reaches the corresponding
-// \begin. It then modifies that stack with attribute strings, an arrangement of the
+// \begin. It then modifies that stack with attribute strings, an arrangement of
 // the symbols encountered while popping lines off.
 extern void env_replacements(UT_array **environment_data_stack, encaseType *encase, const char *environment);
 
-extern 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);
+extern void perform_replacement(UT_array **environment_data_stack, UT_array *rowlines_stack, envType environmentType, UT_array *row_spacing_stack);
 
 // determines the column border arrangement from the array environment definition (c|cc|c...)
 extern const char *vertical_pipe_extract(const char *string);
@@ -74,6 +71,31 @@ extern const char *remove_excess_pipe_chars(const char *string);
 // return the proper rowlines information
 extern const char *combine_row_data(UT_array **environment_data_stack);
 
+// given a pixel string, retrieve the numeric portion from it
+extern const float extract_number_from_pxstring(const char * str);
+
+// given a pixel string, retrieve the pixel type portion from it
+extern const char *extract_string_from_pxstring(const char * str);
+
+// given a number, return it as an em
+extern const char * dbl2em(const char *str);
+
+// given a number, return it as a root position
+// taken straight from MathJax
+extern const char * root_pos_to_em(const char * str);
+
+// given a number and a pixel string, return the doubled number
+extern const char * double_pixel(float f, char *pixel);
+
+// construct a skew sequence
+extern const char * implement_skew(char *base_str, char *em_skew, char *pattern);
+
+// get the environment type of the top-most item
+extern envType current_env_type(UT_array **environment_data_stack);
+
+// get the line count of the top-most item
+extern int current_env_line_count(UT_array **environment_data_stack);
+
 #ifdef __cplusplus
 }
 #endif

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

@@ -15,24 +15,6 @@ void remove_first_char(char* str)
   memmove(str, str + 1, len);
 }
 
-char *dupe_string(const char * str)
-{
-  int len = strlen(str) + 1;
-  char *buf = malloc(len);
-  if (buf) { memcpy(buf, str, len); }
-  return buf;
-}
-
-char *dupe_string_n(const char *s, size_t n)
-{
-  char* buf = malloc(n + 1);
-  if (buf) {
-    strncpy(buf, s, n);
-    buf[n] = '\0';
-  }
-  return buf;
-}
-
 char * str_replace (char *string, const char *substr, const char *replacement)
 {
   char *tok = NULL;
@@ -41,22 +23,19 @@ char * str_replace (char *string, const char *substr, const char *replacement)
 
   /* if either substr or replacement is NULL, duplicate string a let caller handle it */
 
-  if ( substr == NULL || replacement == NULL )
-  {
-    return dupe_string (string);
+  if ( substr == NULL || replacement == NULL ) {
+    return strdup(string);
   }
 
-  newstr = dupe_string (string);
+  newstr = strdup(string);
 
-  while ( ( tok = strstr( newstr, substr ) ) )
-  {
+  while ( ( tok = strstr( newstr, substr ) ) ) {
 
     oldstr = newstr;
     newstr = malloc ( strlen ( oldstr ) - strlen ( substr ) + strlen ( replacement ) + 1 );
 
     /* If failed to alloc mem, free old string and return NULL */
-    if ( newstr == NULL )
-    {
+    if ( newstr == NULL ) {
       free (oldstr);
       return NULL;
     }