add oversampler

oversampling/WDL/eel2/eel_pproc.h

@@ -0,0 +1,469 @@
+#ifndef _EEL2_PREPROC_H_
+#define _EEL2_PREPROC_H_
+#include "ns-eel-int.h"
+#include "../win32_utf8.h"
+
+#define EEL2_PREPROCESS_OPEN_TOKEN "<?"
+
+class EEL2_PreProcessor
+{
+  enum { LITERAL_BASE = 100000 };
+public:
+  EEL2_PreProcessor(int max_sz = 64<<20, int max_include_depth=20)
+  {
+    m_max_sz = max_sz;
+    m_fsout = NULL;
+    m_vm = NSEEL_VM_alloc();
+    m_max_include_depth = max_include_depth;
+    m_output_linecnt = 0;
+    m_cur_depth = 0;
+    NSEEL_VM_SetCustomFuncThis(m_vm, this);
+    NSEEL_VM_SetStringFunc(m_vm, addStringCallback, NULL);
+    if (!m_ftab.list_size)
+    {
+      NSEEL_addfunc_varparm_ex("printf",1,0,NSEEL_PProc_THIS,&pp_printf,&m_ftab);
+      NSEEL_addfunc_varparm_ex("include",1,1,NSEEL_PProc_THIS,&pp_include,&m_ftab);
+    }
+    NSEEL_VM_SetFunctionTable(m_vm, &m_ftab);
+    m_suppress = NSEEL_VM_regvar(m_vm, "_suppress");
+  }
+
+  void define(const char *name, double val)
+  {
+    EEL_F *v = NSEEL_VM_regvar(m_vm,name);
+    if (v) *v = val;
+  }
+
+  ~EEL2_PreProcessor()
+  {
+    for (int x = 0; x < m_code_handles.GetSize(); x ++)
+      NSEEL_code_free((NSEEL_CODEHANDLE) m_code_handles.Get(x));
+    m_literal_strings.Empty(true,free);
+    if (m_vm) NSEEL_VM_free(m_vm);
+    m_suppress = NULL;
+  }
+
+  void clear_line_info()
+  {
+    m_line_tab.Resize(0);
+  }
+  const char *preprocess(const char *str, WDL_FastString *fs)
+  {
+    if (!m_vm || !m_suppress)
+      return "preprocessor: memory error";
+    if (!m_cur_depth)
+    {
+      m_line_tab.Resize(0);
+      m_output_linecnt = 0;
+      *m_suppress = 0.0;
+    }
+    int input_linecnt = 0;
+    for (;;)
+    {
+      const bool suppress = m_suppress && *m_suppress > 0.0;
+
+      int lc = 0;
+      const char *tag = str;
+      while (*tag && strncmp(tag,EEL2_PREPROCESS_OPEN_TOKEN,2)) if (*tag++ == '\n') lc++;
+
+      if (lc)
+      {
+        input_linecnt += lc;
+        if (suppress)
+          add_line_inf(m_output_linecnt,lc);
+        else
+          m_output_linecnt += lc;
+      }
+
+      if (!*tag)
+      {
+        if (!suppress) fs->Append(str);
+        return NULL;
+      }
+      if (!suppress && tag > str) fs->Append(str,(int)(tag-str));
+
+      tag += 2;
+      while (*tag == ' ' || *tag == '\t') tag++;
+      str = tag;
+      lc = 0;
+      while (*str && strncmp(str,"?>",2)) if (*str++ == '\n') lc++;
+
+      if (!*str)
+      {
+        m_tmp.SetFormatted(512, "%d: unterminated preprocessor " EEL2_PREPROCESS_OPEN_TOKEN " block", input_linecnt+1);
+        return m_tmp.Get();
+      }
+
+      if (lc)
+      {
+        input_linecnt += lc;
+        add_line_inf(m_output_linecnt,lc);
+      }
+      if (str > tag)
+      {
+        m_tmp.Set(tag,(int)(str-tag));
+        NSEEL_CODEHANDLE ch = NSEEL_code_compile_ex(m_vm, m_tmp.Get(), 0, NSEEL_CODE_COMPILE_FLAG_COMMONFUNCS);
+        if (!ch)
+        {
+          const char *err = NSEEL_code_getcodeerror(m_vm);
+          if (err)
+          {
+            const int line_ref = atoi(err);
+            while (*err >= '0' && *err <= '9') err++;
+            m_tmp.SetFormatted(512,"%d: preprocessor%s%s",input_linecnt+line_ref,*err && *err != ':' ? ": ":"",err);
+            return m_tmp.Get();
+          }
+        }
+        else
+        {
+          lc = 0;
+          const int oldlen = fs->GetLength();
+          m_fsout = fs;
+          NSEEL_code_execute(ch);
+          m_fsout = NULL;
+          m_code_handles.Add(ch);
+          for (int x = oldlen; x < fs->GetLength(); x ++) if (fs->Get()[x] == '\n') lc++;
+          if (lc)
+          {
+            add_line_inf(m_output_linecnt,-lc);
+            m_output_linecnt += lc;
+          }
+        }
+      }
+      str += 2;
+    }
+  }
+
+  const char *translate_error_line(const char *err_line)
+  {
+    if (m_line_tab.GetSize()<2) return err_line;
+    int l = atoi(err_line)-1;
+    if (l<0) return err_line;
+
+    // tab is a list of pairs
+    // [<output position>, delta]
+    // delta>0 if input lines were skipped
+    // delta<0 if output lines were added
+
+    int nl = l;
+    for (int x = m_line_tab.GetSize()-2; x >= 0; x -= 2)
+    {
+      int p = m_line_tab.Get()[x];
+      if (nl > p)
+      {
+        int delta = m_line_tab.Get()[x+1];
+        nl += delta;
+        if (nl < p) nl = p;
+      }
+    }
+
+    if (l == nl) return err_line;
+
+    while (*err_line >= '0' && *err_line <= '9') err_line++;
+    if (*err_line == ':') err_line++;
+    m_tmp.SetFormatted(512,"%d:%s",1 + nl,err_line);
+    return m_tmp.Get();
+  }
+
+  NSEEL_VMCTX m_vm;
+  WDL_PtrList<char> m_literal_strings;
+  WDL_FastString m_tmp, *m_fsout;
+  WDL_TypedBuf<int> m_line_tab; // expose this in case the caller wants to keep copies around
+  EEL_F *m_suppress;
+  int m_max_sz;
+  int m_cur_depth, m_max_include_depth;
+  int m_output_linecnt;
+  static eel_function_table m_ftab;
+  WDL_PtrList<void> m_code_handles;
+  WDL_PtrList<const char> m_include_paths;
+
+  void add_line_inf(int output_linecnt, int lc)
+  {
+    if (!m_cur_depth)
+    {
+      m_line_tab.Add(output_linecnt); // log lc lines of input skipped
+      m_line_tab.Add(lc);
+    }
+  }
+
+  static EEL_F addStringCallback(void *opaque, struct eelStringSegmentRec *list)
+  {
+    EEL2_PreProcessor *_this = (EEL2_PreProcessor*)opaque;
+    if (!_this) return -1.0;
+
+    const int sz = nseel_stringsegments_tobuf(NULL,0,list);
+    char *ns = (char *)malloc(sz+1);
+    if (WDL_NOT_NORMALLY(!ns)) return -1.0;
+    nseel_stringsegments_tobuf(ns,sz,list);
+
+    const int nstr = _this->m_literal_strings.GetSize();
+    for (int x=0;x<nstr;x++)
+    {
+      char *s = _this->m_literal_strings.Get(x);
+      if (!strcmp(s,ns))
+      {
+        free(ns);
+        return x + LITERAL_BASE;
+      }
+    }
+    _this->m_literal_strings.Add(ns);
+    return nstr + LITERAL_BASE;
+  }
+
+  const char *GetString(EEL_F v)
+  {
+    if (v >= LITERAL_BASE && v < LITERAL_BASE + m_literal_strings.GetSize())
+      return m_literal_strings.Get((int) (v - LITERAL_BASE));
+    return NULL;
+  }
+
+  static int eel_validate_format_specifier(const char *fmt_in, char *typeOut,
+                                           char *fmtOut, int fmtOut_sz,
+                                           char *varOut, int varOut_sz,
+                                           int *varOut_used
+                                          )
+  {
+    const char *fmt = fmt_in+1;
+    int state=0;
+    if (fmt_in[0] != '%') return 0; // ugh passed a non-specifier
+
+    *varOut_used = 0;
+    *varOut = 0;
+
+    if (fmtOut_sz-- < 2) return 0;
+    *fmtOut++ = '%';
+
+    while (*fmt)
+    {
+      const char c = *fmt++;
+      if (fmtOut_sz < 2) return 0;
+
+      if (c == 'f'|| c=='e' || c=='E' || c=='g' || c=='G' || c == 'd' || c == 'u' ||
+          c == 'x' || c == 'X' || c == 'c' || c == 'C' || c =='s' || c=='S' || c=='i')
+      {
+        *typeOut = c;
+        fmtOut[0] = c;
+        fmtOut[1] = 0;
+        return (int) (fmt - fmt_in);
+      }
+      else if (c == '.')
+      {
+        *fmtOut++ = c; fmtOut_sz--;
+        if (state&(2)) break;
+        state |= 2;
+      }
+      else if (c == '+')
+      {
+        *fmtOut++ = c; fmtOut_sz--;
+        if (state&(32|16|8|4)) break;
+        state |= 8;
+      }
+      else if (c == '-' || c == ' ')
+      {
+        *fmtOut++ = c; fmtOut_sz--;
+        if (state&(32|16|8|4)) break;
+        state |= 16;
+      }
+      else if (c >= '0' && c <= '9')
+      {
+        *fmtOut++ = c; fmtOut_sz--;
+        state|=4;
+      }
+      else if (c == '{')
+      {
+        if (state & 64) break;
+        state|=64;
+        if (*fmt == '.' || (*fmt >= '0' && *fmt <= '9')) return 0; // symbol name can't start with 0-9 or .
+
+        while (*fmt != '}')
+        {
+          if ((*fmt >= 'a' && *fmt <= 'z') ||
+              (*fmt >= 'A' && *fmt <= 'Z') ||
+              (*fmt >= '0' && *fmt <= '9') ||
+              *fmt == '_' || *fmt == '.' || *fmt == '#')
+          {
+            if (varOut_sz < 2) return 0;
+            *varOut++ = *fmt++;
+            varOut_sz -- ;
+          }
+          else
+          {
+            return 0; // bad character in variable name
+          }
+        }
+        fmt++;
+        *varOut = 0;
+        *varOut_used=1;
+      }
+      else
+      {
+        break;
+      }
+    }
+    return 0;
+  }
+
+  static int eel_format_strings(void *opaque, const char *fmt, const char *fmt_end, char *buf, int buf_sz, int num_fmt_parms, EEL_F **fmt_parms)
+  {
+    EEL2_PreProcessor *_this = (EEL2_PreProcessor*)opaque;
+    int fmt_parmpos = 0;
+    char *op = buf;
+    while ((fmt_end ? fmt < fmt_end : *fmt) && op < buf+buf_sz-128)
+    {
+      if (fmt[0] == '%' && fmt[1] == '%')
+      {
+        *op++ = '%';
+        fmt+=2;
+      }
+      else if (fmt[0] == '%')
+      {
+        char ct=0;
+        char fs[128];
+        char varname[128];
+        int varname_used=0;
+        const int l=eel_validate_format_specifier(fmt,&ct,fs,sizeof(fs),varname,sizeof(varname),&varname_used);
+        if (!l || !ct)
+        {
+          *op=0;
+          return -1;
+        }
+
+        const EEL_F *varptr = NULL;
+        if (!varname_used)
+        {
+          if (fmt_parmpos < num_fmt_parms) varptr = fmt_parms[fmt_parmpos];
+          fmt_parmpos++;
+        }
+        double v = varptr ? (double)*varptr : 0.0;
+
+        if (ct == 's' || ct=='S')
+        {
+          const char *str = _this->GetString(v);
+          const int maxl=(int) (buf+buf_sz - 2 - op);
+          snprintf(op,maxl,fs,str ? str : "");
+        }
+        else
+        {
+          if (ct == 'x' || ct == 'X' || ct == 'd' || ct == 'u' || ct=='i')
+          {
+            snprintf(op,64,fs,(int) (v));
+          }
+          else if (ct == 'c')
+          {
+            *op++=(char) (int)v;
+            *op=0;
+          }
+          else if (ct == 'C')
+          {
+            const unsigned int iv = (unsigned int) v;
+            int bs = 0;
+            if (iv &      0xff000000) bs=24;
+            else if (iv & 0x00ff0000) bs=16;
+            else if (iv & 0x0000ff00) bs=8;
+            while (bs>=0)
+            {
+              const char c=(char) (iv>>bs);
+              *op++=c?c:' ';
+              bs-=8;
+            }
+            *op=0;
+          }
+          else
+          {
+            snprintf(op,64,fs,v);
+          }
+        }
+
+        while (*op) op++;
+
+        fmt += l;
+      }
+      else
+      {
+        *op++ = *fmt++;
+      }
+
+    }
+    *op=0;
+    return (int) (op - buf);
+  }
+
+  static EEL_F NSEEL_CGEN_CALL pp_printf(void *opaque, INT_PTR num_param, EEL_F **parms)
+  {
+    if (num_param>0 && opaque)
+    {
+      EEL2_PreProcessor *_this = (EEL2_PreProcessor*)opaque;
+      const char *fmt = _this->GetString(parms[0][0]);
+      if (fmt)
+      {
+        char buf[16384];
+        const int len = eel_format_strings(opaque,fmt,NULL,buf,(int)sizeof(buf), (int)num_param-1, parms+1);
+
+        if (len >= 0)
+        {
+          if (_this->m_fsout && _this->m_fsout->GetLength() < _this->m_max_sz)
+          {
+            _this->m_fsout->Append(buf,len);
+          }
+          return 1.0;
+        }
+      }
+    }
+    return 0.0;
+  }
+
+  static EEL_F NSEEL_CGEN_CALL pp_include(void *opaque, INT_PTR num_param, EEL_F **parms)
+  {
+    if (num_param>0 && opaque)
+    {
+      EEL2_PreProcessor *_this = (EEL2_PreProcessor*)opaque;
+      if (_this->m_cur_depth >= _this->m_max_include_depth) return -1.0;
+
+      const char *fn = _this->GetString(parms[0][0]);
+      if (!fn || !*fn) return -2.0;
+
+      WDL_FastString fullfn;
+      for (int x = _this->m_include_paths.GetSize()-1; x >= 0; x--)
+      {
+        const char *p = _this->m_include_paths.Get(x);
+        if (p && *p)
+        {
+          fullfn.Set(p);
+          fullfn.Append(WDL_DIRCHAR_STR);
+          fullfn.Append(fn);
+          FILE *fp = fopenUTF8(fullfn.Get(),"rb");
+          if (fp)
+          {
+            double rv = 0.0;
+            _this->m_cur_depth++;
+            fullfn.Set("");
+            while (fullfn.GetLength() < (4<<20))
+            {
+              char buf[512];
+              if (!fgets(buf,sizeof(buf),fp)) break;
+              fullfn.Append(buf);
+            }
+            fclose(fp);
+
+            WDL_FastString *outp = _this->m_fsout;
+            if (_this->preprocess(fullfn.Get(),outp))
+            {
+              rv = -3.0;
+            }
+            _this->m_fsout = outp;
+
+            _this->m_cur_depth--;
+            return rv;
+          }
+        }
+      }
+      return -4.0;
+    }
+    return 0.0;
+  }
+
+};
+
+eel_function_table EEL2_PreProcessor::m_ftab;
+
+#endif