mathematical 1.6.17 → 1.6.20

data/ext/mathematical/mtex2MML/deps/uthash/utringbuffer.h

@@ -0,0 +1,108 @@
+/*
+Copyright (c) 2008-2016, Troy D. Hanson   http://troydhanson.github.com/uthash/
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+/* a ring-buffer implementation using macros
+ */
+#ifndef UTRINGBUFFER_H
+#define UTRINGBUFFER_H
+
+#define UTRINGBUFFER_VERSION 2.0.1
+ 
+#include <stdlib.h>
+#include <string.h>
+#include "utarray.h"  // for "UT_icd"
+ 
+typedef struct {
+    unsigned i;       /* index of next available slot; wraps at n */
+    unsigned n;       /* capacity */
+    unsigned char f;  /* full */
+    UT_icd icd;       /* initializer, copy and destructor functions */
+    char *d;          /* n slots of size icd->sz */
+} UT_ringbuffer;
+ 
+#define utringbuffer_init(a, _n, _icd) do {                               \
+  memset(a, 0, sizeof(UT_ringbuffer));                                    \
+  (a)->icd = *(_icd);                                                     \
+  (a)->n = (_n);                                                          \
+  if ((a)->n) { (a)->d = (char*)malloc((a)->n * (_icd)->sz); }            \
+} while(0)
+ 
+#define utringbuffer_clear(a) do {                                        \
+  if ((a)->icd.dtor) {                                                    \
+    if ((a)->f) {                                                         \
+      unsigned _ut_i;                                                     \
+      for (_ut_i = 0; _ut_i < (a)->n; ++_ut_i) {                          \
+        (a)->icd.dtor(utringbuffer_eltptr(a, _ut_i));                     \
+      }                                                                   \
+    } else {                                                              \
+      unsigned _ut_i;                                                     \
+      for (_ut_i = 0; _ut_i < (a)->i; ++_ut_i) {                          \
+        (a)->icd.dtor(utringbuffer_eltptr(a, _ut_i));                     \
+      }                                                                   \
+    }                                                                     \
+  }                                                                       \
+  (a)->i = 0;                                                             \
+  (a)->f = 0;                                                             \
+} while(0)
+ 
+#define utringbuffer_done(a) do {                                         \
+  utringbuffer_clear(a);                                                  \
+  free((a)->d); (a)->d = NULL;                                            \
+  (a)->n = 0;                                                             \
+} while(0)
+ 
+#define utringbuffer_new(a,n,_icd) do {                                   \
+  a = (UT_ringbuffer*)malloc(sizeof(UT_ringbuffer));                      \
+  utringbuffer_init(a, n, _icd);                                          \
+} while(0)
+ 
+#define utringbuffer_free(a) do {                                         \
+  utringbuffer_done(a);                                                   \
+  free(a);                                                                \
+} while(0)
+ 
+#define utringbuffer_push_back(a,p) do {                                                \
+  if ((a)->icd.dtor && (a)->f) { (a)->icd.dtor(_utringbuffer_internalptr(a,(a)->i)); }  \
+  if ((a)->icd.copy) { (a)->icd.copy( _utringbuffer_internalptr(a,(a)->i), p); }        \
+  else { memcpy(_utringbuffer_internalptr(a,(a)->i), p, (a)->icd.sz); };                \
+  if (++(a)->i == (a)->n) { (a)->i = 0; (a)->f = 1; }                                   \
+} while(0)
+ 
+#define utringbuffer_len(a) ((a)->f ? (a)->n : (a)->i)
+#define utringbuffer_empty(a) ((a)->i == 0 && !(a)->f)
+#define utringbuffer_full(a) ((a)->f != 0)
+ 
+#define _utringbuffer_real_idx(a,j) ((a)->f ? ((j) + (a)->i) % (a)->n : (j))
+#define _utringbuffer_internalptr(a,j) ((void*)((a)->d + ((a)->icd.sz * (j))))
+#define utringbuffer_eltptr(a,j) ((0 <= (j) && (j) < utringbuffer_len(a)) ? _utringbuffer_internalptr(a,_utringbuffer_real_idx(a,j)) : NULL)
+ 
+#define _utringbuffer_fake_idx(a,j) ((a)->f ? ((j) + (a)->n - (a)->i) % (a)->n : (j))
+#define _utringbuffer_internalidx(a,e) (((char*)(e) >= (a)->d) ? (((char*)(e) - (a)->d)/(a)->icd.sz) : -1)
+#define utringbuffer_eltidx(a,e) _utringbuffer_fake_idx(a, _utringbuffer_internalidx(a,e))
+ 
+#define utringbuffer_front(a) utringbuffer_eltptr(a,0)
+#define utringbuffer_next(a,e) ((e)==NULL ? utringbuffer_front(a) : utringbuffer_eltptr(a, utringbuffer_eltidx(a,e)+1))
+#define utringbuffer_prev(a,e) ((e)==NULL ? utringbuffer_back(a) : utringbuffer_eltptr(a, utringbuffer_eltidx(a,e)-1))
+#define utringbuffer_back(a) (utringbuffer_empty(a) ? NULL : utringbuffer_eltptr(a, utringbuffer_len(a) - 1))
+
+#endif /* UTRINGBUFFER_H */

data/ext/mathematical/mtex2MML/deps/uthash/utstring.h

@@ -0,0 +1,398 @@
+/*
+Copyright (c) 2008-2016, Troy D. Hanson   http://troydhanson.github.com/uthash/
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+/* a dynamic string implementation using macros
+ */
+#ifndef UTSTRING_H
+#define UTSTRING_H
+
+#define UTSTRING_VERSION 2.0.1
+
+#ifdef __GNUC__
+#define _UNUSED_ __attribute__ ((__unused__))
+#else
+#define _UNUSED_
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+
+#ifndef oom
+#define oom() exit(-1)
+#endif
+
+typedef struct {
+    char *d;
+    size_t n; /* allocd size */
+    size_t i; /* index of first unused byte */
+} UT_string;
+
+#define utstring_reserve(s,amt)                            \
+do {                                                       \
+  if (((s)->n - (s)->i) < (size_t)(amt)) {                 \
+    char *utstring_tmp = (char*)realloc(                   \
+      (s)->d, (s)->n + (amt));                             \
+    if (utstring_tmp == NULL) oom();                       \
+    (s)->d = utstring_tmp;                                 \
+    (s)->n += (amt);                                       \
+  }                                                        \
+} while(0)
+
+#define utstring_init(s)                                   \
+do {                                                       \
+  (s)->n = 0; (s)->i = 0; (s)->d = NULL;                   \
+  utstring_reserve(s,100);                                 \
+  (s)->d[0] = '\0';                                        \
+} while(0)
+
+#define utstring_done(s)                                   \
+do {                                                       \
+  if ((s)->d != NULL) free((s)->d);                        \
+  (s)->n = 0;                                              \
+} while(0)
+
+#define utstring_free(s)                                   \
+do {                                                       \
+  utstring_done(s);                                        \
+  free(s);                                                 \
+} while(0)
+
+#define utstring_new(s)                                    \
+do {                                                       \
+   s = (UT_string*)calloc(sizeof(UT_string),1);            \
+   if (!s) oom();                                          \
+   utstring_init(s);                                       \
+} while(0)
+
+#define utstring_renew(s)                                  \
+do {                                                       \
+   if (s) {                                                \
+     utstring_clear(s);                                    \
+   } else {                                                \
+     utstring_new(s);                                      \
+   }                                                       \
+} while(0)
+
+#define utstring_clear(s)                                  \
+do {                                                       \
+  (s)->i = 0;                                              \
+  (s)->d[0] = '\0';                                        \
+} while(0)
+
+#define utstring_bincpy(s,b,l)                             \
+do {                                                       \
+  utstring_reserve((s),(l)+1);                             \
+  if (l) memcpy(&(s)->d[(s)->i], b, l);                    \
+  (s)->i += (l);                                           \
+  (s)->d[(s)->i]='\0';                                     \
+} while(0)
+
+#define utstring_concat(dst,src)                                 \
+do {                                                             \
+  utstring_reserve((dst),((src)->i)+1);                          \
+  if ((src)->i) memcpy(&(dst)->d[(dst)->i], (src)->d, (src)->i); \
+  (dst)->i += (src)->i;                                          \
+  (dst)->d[(dst)->i]='\0';                                       \
+} while(0)
+
+#define utstring_len(s) ((unsigned)((s)->i))
+
+#define utstring_body(s) ((s)->d)
+
+_UNUSED_ static void utstring_printf_va(UT_string *s, const char *fmt, va_list ap) {
+   int n;
+   va_list cp;
+   for (;;) {
+#ifdef _WIN32
+      cp = ap;
+#else
+      va_copy(cp, ap);
+#endif
+      n = vsnprintf (&s->d[s->i], s->n-s->i, fmt, cp);
+      va_end(cp);
+
+      if ((n > -1) && ((size_t) n < (s->n-s->i))) {
+        s->i += n;
+        return;
+      }
+
+      /* Else try again with more space. */
+      if (n > -1) utstring_reserve(s,n+1); /* exact */
+      else utstring_reserve(s,(s->n)*2);   /* 2x */
+   }
+}
+#ifdef __GNUC__
+/* support printf format checking (2=the format string, 3=start of varargs) */
+static void utstring_printf(UT_string *s, const char *fmt, ...)
+  __attribute__ (( format( printf, 2, 3) ));
+#endif
+_UNUSED_ static void utstring_printf(UT_string *s, const char *fmt, ...) {
+   va_list ap;
+   va_start(ap,fmt);
+   utstring_printf_va(s,fmt,ap);
+   va_end(ap);
+}
+
+/*******************************************************************************
+ * begin substring search functions                                            *
+ ******************************************************************************/
+/* Build KMP table from left to right. */
+_UNUSED_ static void _utstring_BuildTable(
+    const char *P_Needle,
+    size_t P_NeedleLen,
+    long *P_KMP_Table)
+{
+    long i, j;
+
+    i = 0;
+    j = i - 1;
+    P_KMP_Table[i] = j;
+    while (i < (long) P_NeedleLen)
+    {
+        while ( (j > -1) && (P_Needle[i] != P_Needle[j]) )
+        {
+           j = P_KMP_Table[j];
+        }
+        i++;
+        j++;
+        if (i < (long) P_NeedleLen)
+        {
+            if (P_Needle[i] == P_Needle[j])
+            {
+                P_KMP_Table[i] = P_KMP_Table[j];
+            }
+            else
+            {
+                P_KMP_Table[i] = j;
+            }
+        }
+        else
+        {
+            P_KMP_Table[i] = j;
+        }
+    }
+
+    return;
+}
+
+
+/* Build KMP table from right to left. */
+_UNUSED_ static void _utstring_BuildTableR(
+    const char *P_Needle,
+    size_t P_NeedleLen,
+    long *P_KMP_Table)
+{
+    long i, j;
+
+    i = P_NeedleLen - 1;
+    j = i + 1;
+    P_KMP_Table[i + 1] = j;
+    while (i >= 0)
+    {
+        while ( (j < (long) P_NeedleLen) && (P_Needle[i] != P_Needle[j]) )
+        {
+           j = P_KMP_Table[j + 1];
+        }
+        i--;
+        j--;
+        if (i >= 0)
+        {
+            if (P_Needle[i] == P_Needle[j])
+            {
+                P_KMP_Table[i + 1] = P_KMP_Table[j + 1];
+            }
+            else
+            {
+                P_KMP_Table[i + 1] = j;
+            }
+        }
+        else
+        {
+            P_KMP_Table[i + 1] = j;
+        }
+    }
+
+    return;
+}
+
+
+/* Search data from left to right. ( Multiple search mode. ) */
+_UNUSED_ static long _utstring_find(
+    const char *P_Haystack,
+    size_t P_HaystackLen,
+    const char *P_Needle,
+    size_t P_NeedleLen,
+    long *P_KMP_Table)
+{
+    long i, j;
+    long V_FindPosition = -1;
+
+    /* Search from left to right. */
+    i = j = 0;
+    while ( (j < (int)P_HaystackLen) && (((P_HaystackLen - j) + i) >= P_NeedleLen) )
+    {
+        while ( (i > -1) && (P_Needle[i] != P_Haystack[j]) )
+        {
+            i = P_KMP_Table[i];
+        }
+        i++;
+        j++;
+        if (i >= (int)P_NeedleLen)
+        {
+            /* Found. */
+            V_FindPosition = j - i;
+            break;
+        }
+    }
+
+    return V_FindPosition;
+}
+
+
+/* Search data from right to left. ( Multiple search mode. ) */
+_UNUSED_ static long _utstring_findR(
+    const char *P_Haystack,
+    size_t P_HaystackLen,
+    const char *P_Needle,
+    size_t P_NeedleLen,
+    long *P_KMP_Table)
+{
+    long i, j;
+    long V_FindPosition = -1;
+
+    /* Search from right to left. */
+    j = (P_HaystackLen - 1);
+    i = (P_NeedleLen - 1);
+    while ( (j >= 0) && (j >= i) )
+    {
+        while ( (i < (int)P_NeedleLen) && (P_Needle[i] != P_Haystack[j]) )
+        {
+            i = P_KMP_Table[i + 1];
+        }
+        i--;
+        j--;
+        if (i < 0)
+        {
+            /* Found. */
+            V_FindPosition = j + 1;
+            break;
+        }
+    }
+
+    return V_FindPosition;
+}
+
+
+/* Search data from left to right. ( One time search mode. ) */
+_UNUSED_ static long utstring_find(
+    UT_string *s,
+    long P_StartPosition,   /* Start from 0. -1 means last position. */
+    const char *P_Needle,
+    size_t P_NeedleLen)
+{
+    long V_StartPosition;
+    long V_HaystackLen;
+    long *V_KMP_Table;
+    long V_FindPosition = -1;
+
+    if (P_StartPosition < 0)
+    {
+        V_StartPosition = s->i + P_StartPosition;
+    }
+    else
+    {
+        V_StartPosition = P_StartPosition;
+    }
+    V_HaystackLen = s->i - V_StartPosition;
+    if ( (V_HaystackLen >= (long) P_NeedleLen) && (P_NeedleLen > 0) )
+    {
+        V_KMP_Table = (long *)malloc(sizeof(long) * (P_NeedleLen + 1));
+        if (V_KMP_Table != NULL)
+        {
+            _utstring_BuildTable(P_Needle, P_NeedleLen, V_KMP_Table);
+
+            V_FindPosition = _utstring_find(s->d + V_StartPosition,
+                                            V_HaystackLen,
+                                            P_Needle,
+                                            P_NeedleLen,
+                                            V_KMP_Table);
+            if (V_FindPosition >= 0)
+            {
+                V_FindPosition += V_StartPosition;
+            }
+
+            free(V_KMP_Table);
+        }
+    }
+
+    return V_FindPosition;
+}
+
+
+/* Search data from right to left. ( One time search mode. ) */
+_UNUSED_ static long utstring_findR(
+    UT_string *s,
+    long P_StartPosition,   /* Start from 0. -1 means last position. */
+    const char *P_Needle,
+    size_t P_NeedleLen)
+{
+    long V_StartPosition;
+    long V_HaystackLen;
+    long *V_KMP_Table;
+    long V_FindPosition = -1;
+
+    if (P_StartPosition < 0)
+    {
+        V_StartPosition = s->i + P_StartPosition;
+    }
+    else
+    {
+        V_StartPosition = P_StartPosition;
+    }
+    V_HaystackLen = V_StartPosition + 1;
+    if ( (V_HaystackLen >= (long) P_NeedleLen) && (P_NeedleLen > 0) )
+    {
+        V_KMP_Table = (long *)malloc(sizeof(long) * (P_NeedleLen + 1));
+        if (V_KMP_Table != NULL)
+        {
+            _utstring_BuildTableR(P_Needle, P_NeedleLen, V_KMP_Table);
+
+            V_FindPosition = _utstring_findR(s->d,
+                                             V_HaystackLen,
+                                             P_Needle,
+                                             P_NeedleLen,
+                                             V_KMP_Table);
+
+            free(V_KMP_Table);
+        }
+    }
+
+    return V_FindPosition;
+}
+/*******************************************************************************
+ * end substring search functions                                              *
+ ******************************************************************************/
+
+#endif /* UTSTRING_H */

data/ext/mathematical/mtex2MML/script/bootstrap

@@ -0,0 +1,39 @@
+#!/bin/bash
+
+set -e
+
+echo "==> Installing required libraries…"
+
+if [ "$(uname)" == "Darwin" ]; then
+  for pkg in flex bison cmake valgrind; do
+    if hash port 2>/dev/null; then
+      if port installed $pkg | grep active | awk '{print $1};'; then
+        echo "Package '$pkg' is installed"
+      else
+        echo "Package '$pkg' is not installed"
+        port install $pkg
+      fi
+    else
+      if brew list -1 | grep -q "^${pkg}\$"; then
+          echo "Package '$pkg' is installed"
+      else
+          echo "Package '$pkg' is not installed"
+          if [ "$pkg" != "valgrind" ]; then
+            brew install $pkg
+          fi
+      fi
+    fi
+  done
+elif [ "$(expr substr $(uname -s) 1 5)" == "Linux" ]; then
+  if [ -f "/etc/arch-release" ]; then
+    sudo pacman --needed -S flex bison cmake valgrind
+  else
+    if [ -z "$TRAVIS" ]; then
+      sudo apt-get -qq -y install flex bison cmake valgrind
+    else
+      echo "Packages already installed on Travis CI."
+    fi
+  fi
+fi
+
+mkdir -p build

data/ext/mathematical/mtex2MML/script/cibuild

@@ -0,0 +1,58 @@
+#!/bin/sh
+
+mkdir -p build
+cd build
+cmake ..
+make
+ctest -V
+
+echo 'inline'
+echo '\sin y'     | ./mtex2MML --inline | grep "display='inline'" || exit 1
+echo ''
+
+echo 'display'
+echo '\sin y'     | ./mtex2MML --display | grep "display='block'" || exit 1
+echo ''
+
+echo 'inline print-mtex'
+echo '\sin y'     | ./mtex2MML --inline --print-mtex | grep '$\\sin y\$'|| exit 1
+echo ''
+
+echo 'display print-mtex'
+echo '\sin y'     | ./mtex2MML --display --print-mtex | grep '$$\\sin y\$\$' || exit 1
+echo ''
+
+echo 'dollar'
+echo '$\sin y$'   | ./mtex2MML | grep "display='inline'" || exit 1
+
+echo 'double dollar'
+echo '$$\sin y$$' | ./mtex2MML | grep "display='block'" || exit 1
+
+echo 'parens'
+echo '\(\sin y\)' | ./mtex2MML | grep "display='inline'" || exit 1
+
+echo 'brackets'
+echo '\[\sin y\]' | ./mtex2MML | grep "display='block'" || exit 1
+
+echo 'dollar use-dollar'
+echo '$\sin y$'   | ./mtex2MML --use-dollar | grep "display='inline'" || exit 1
+
+echo 'double dollar use-double'
+echo '$$\sin y$$' | ./mtex2MML --use-double | grep "display='block'" || exit 1
+
+echo 'parens use-parens'
+echo '\(\sin y\)' | ./mtex2MML --use-parens | grep "display='inline'" || exit 1
+
+echo 'brackets use-brackets'
+echo '\[\sin y\]' | ./mtex2MML --use-brackets | grep "display='block'" || exit 1
+
+echo 'env use-env'
+echo '\\begin{align}3x + 9y &=  -12\\end{align}' | ./mtex2MML --use-env | grep "display='block'" || exit 1
+
+echo 'DONE with command check'
+
+if [ -n "$CI" ]; then
+  if [ "$(expr substr $(uname -s) 1 5)" == "Linux" ]; then
+    make memcheck
+  fi
+fi

data/ext/mathematical/mtex2MML/script/tag

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "octokit"
+
+%x(git push origin)
+
+%x(rm -rf build)
+%x(mkdir build)
+
+Dir.chdir("build") do
+  %x(cmake ..)
+  %x(make)
+end
+
+MTEX2MML_HEADER = File.read(File.join("src", "mtex2MML.h"))
+VERSION = MTEX2MML_HEADER.match(/MTEX2MML_VERSION\s*"(.+?)"/)[1]
+TAG_NAME = "v#{VERSION}"
+
+puts "Creating tag #{TAG_NAME}..."
+%x(git tag #{TAG_NAME})
+
+puts "Creating release..."
+client = Octokit::Client.new(access_token: ENV["GITHUB_TOKEN"])
+_release_response = client.create_release("gjtorikian/mtex2MML", TAG_NAME, \
+  name: VERSION)
+
+puts "Done!"

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

@@ -0,0 +1,44 @@
+#include "colors.h"
+
+void mtex2MML_create_css_colors(struct css_colors **colors)
+{
+  const char **n, **h,
+        *names[] = { "\"Apricot\"","\"Aquamarine\"","\"Bittersweet\"",
+                     "\"Black\"","\"Blue\"","\"BlueGreen\"","\"BlueViolet\"","\"BrickRed\"",
+                     "\"Brown\"","\"BurntOrange\"","\"CadetBlue\"","\"CarnationPink\"","\"Cerulean\"",
+                     "\"CornflowerBlue\"","\"Cyan\"","\"Dandelion\"","\"DarkOrchid\"","\"Emerald\"",
+                     "\"ForestGreen\"","\"Fuchsia\"","\"Goldenrod\"","\"Gray\"","\"Green\"",
+                     "\"GreenYellow\"","\"JungleGreen\"","\"Lavender\"","\"LimeGreen\"","\"Magenta\"",
+                     "\"Mahogany\"","\"Maroon\"","\"Melon\"","\"MidnightBlue\"","\"Mulberry\"",
+                     "\"NavyBlue\"","\"OliveGreen\"","\"Orange\"","\"OrangeRed\"","\"Orchid\"",
+                     "\"Peach\"","\"Periwinkle\"","\"PineGreen\"","\"Plum\"","\"ProcessBlue\"",
+                     "\"Purple\"","\"RawSienna\"","\"Red\"","\"RedOrange\"","\"RedViolet\"",
+                     "\"Rhodamine\"","\"RoyalBlue\"","\"RoyalPurple\"","\"RubineRed\"","\"Salmon\"",
+                     "\"SeaGreen\"","\"Sepia\"","\"SkyBlue\"","\"SpringGreen\"","\"Tan\"","\"TealBlue\"",
+                     "\"Thistle\"","\"Turquoise\"","\"Violet\"","\"VioletRed\"","\"White\"",
+                     "\"WildStrawberry\"","\"Yellow\"","\"YellowGreen\"", "\"YellowOrange\"", NULL
+                   },
+
+                   *hex_code[] = { "\"#FBB982\"","\"#00B5BE\"","\"#C04F17\"","\"#221E1F\"","\"#2D2F92\"",
+                                   "\"#00B3B8\"","\"#473992\"","\"#B6321C\"","\"#792500\"","\"#F7921D\"","\"#74729A\"",
+                                   "\"#F282B4\"","\"#00A2E3\"","\"#41B0E4\"","\"#00AEEF\"","\"#FDBC42\"","\"#A4538A\"",
+                                   "\"#00A99D\"","\"#009B55\"","\"#8C368C\"","\"#FFDF42\"","\"#949698\"","\"#00A64F\"",
+                                   "\"#DFE674\"","\"#00A99A\"","\"#F49EC4\"","\"#8DC73E\"","\"#EC008C\"","\"#A9341F\"",
+                                   "\"#AF3235\"","\"#F89E7B\"","\"#006795\"","\"#A93C93\"","\"#006EB8\"","\"#3C8031\"",
+                                   "\"#F58137\"","\"#ED135A\"","\"#AF72B0\"","\"#F7965A\"","\"#7977B8\"","\"#008B72\"",
+                                   "\"#92268F\"","\"#00B0F0\"","\"#99479B\"","\"#974006\"","\"#ED1B23\"","\"#F26035\"",
+                                   "\"#A1246B\"","\"#EF559F\"","\"#0071BC\"","\"#613F99\"","\"#ED017D\"","\"#F69289\"",
+                                   "\"#3FBC9D\"","\"#671800\"","\"#46C5DD\"","\"#C6DC67\"","\"#DA9D76\"","\"#00AEB3\"",
+                                   "\"#D883B7\"","\"#00B4CE\"","\"#58429B\"","\"#EF58A0\"","\"#FFFFFF\"","\"#EE2967\"",
+                                   "\"#FFF200\"","\"#98CC70\"","\"#FAA21A\"", NULL
+                                 };
+
+  struct css_colors *c = NULL;
+
+  for (n = names, h = hex_code; *n != NULL; n++, h++) {
+    c = malloc(sizeof(struct css_colors));
+    strncpy(c->name, *n, 22);
+    strncpy(c->color, *h, 10);
+    HASH_ADD_STR(*colors, name, c );
+  }
+}