Initial import of htcd system 1.0

Signed-off-by: Henrik Rydberg <rydberg@euromail.se>

1 files changed, 230 insertions, 0 deletions

diff --git a/src/lang/token.h b/src/lang/token.h
new file mode 100644
index 0000000..bf32820
--- /dev/null
+++ b/src/lang/token.h
@@ -0,0 +1,230 @@
+/*************************************************************************
+ *
+ * HTCd - Copyright (C) 1998-2006 Henrik Rydberg
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifndef TOKENH
+#define TOKENH
+
+#include <ops/express.h>
+#include <hdb/db.h>
+
+#define TOK_ARGS (mstream& out,Env& env)
+#define TOK_IMPL(func) static void impl_##func TOK_ARGS throw(merror_t)
+#define TOK_ADD(func,a,mod,help) \
+T.add(new binary_t(uscore2dot(#func),sref(help),mod,sref(a),impl_##func),0,1)
+
+mstring uscore2dot(const char* s);
+
+class Env;
+typedef void (*s_func_t)TOK_ARGS;
+
+class tok_t {
+public:
+  static const unsigned CONSTANT,RESTRICT,NORMAL,SYSONLY,INIT;
+  static const unsigned RUNNABLE,FUNCTION,BINARY;
+  static const unsigned REFERENCE,DBREF,CRON;
+  static const unsigned PRIVATE,PUBLIC,XMODES;
+
+  static inline unsigned tight(unsigned xmod) {
+    // INIT is ignored here simply because no mode can
+    // read variables in INIT mode... defaults to public.
+    return (xmod&SYSONLY)?SYSONLY:(xmod&NORMAL)?PRIVATE:PUBLIC;
+  }
+  
+  mstring name,body;
+  unsigned mod;
+  
+  int is_clear(int xmod) const { return (mod&xmod)!=0; }
+  int is_replaceable(const tok_t& t) const { return (mod&t.mod)==t.mod; }
+  
+  int is_const() const { return (mod&CONSTANT)!=0; }
+  int is_runnable() const { return (mod&RUNNABLE)!=0; }
+  int is_func() const { return (mod&FUNCTION)!=0; }
+  int is_cron() const { return (mod&CRON)!=0; }
+  int is_binary() const { return (mod&BINARY)!=0; }
+  int is_reference() const { return (mod&REFERENCE)!=0; }
+  int is_dbref() const { return (mod&DBREF)!=0; }
+  
+  tok_t(const sref& s,const sref& b,unsigned m) : name(s),body(b),mod(m) {}
+  virtual ~tok_t();
+
+  static void* operator new(size_t n);
+  static void operator delete(void* p);
+private:
+  static uniheap<32> tree;
+};
+
+///////////////////////////////////////////////////////////////////
+
+class reference_t : public tok_t {
+public:
+  mstring data;
+  reference_t(const sref& s,const sref& b,unsigned m):
+    tok_t(s,b,m|REFERENCE|CONSTANT) {}
+  
+  static void* operator new(size_t n);
+  static void operator delete(void* p);
+private:
+  static uniheap<44> tree;
+};
+
+///////////////////////////////////////////////////////////////////
+
+class dbref_t : public tok_t {
+public:
+  dbmap db;
+  dbref_t(const sref& s,const sref& b,unsigned m):
+    tok_t(s,b,m|DBREF|CONSTANT) {}
+  
+  static void* operator new(size_t n);
+  static void operator delete(void* p);
+private:
+  static uniheap<96> tree;
+};
+
+///////////////////////////////////////////////////////////////////
+
+class runnable_t : public tok_t {
+public:
+  mstring arg;
+  runnable_t(const sref& s,const sref& b,unsigned m,const sref& a):
+    tok_t(s,b,m|RUNNABLE|CONSTANT),arg(a) {}
+  
+  static void* operator new(size_t n);
+  static void operator delete(void* p);
+private:
+  static uniheap<44> tree;
+};
+
+///////////////////////////////////////////////////////////////////
+
+class func_t : public runnable_t {
+public:
+  expr_t x;
+  func_t(const sref& s,const sref& b,unsigned m,const sref& a):
+    runnable_t(s,b,m|FUNCTION,a) { x=body; }
+  
+  static void* operator new(size_t n);
+  static void operator delete(void* p);
+private:
+  static uniheap<80> tree;
+};
+
+///////////////////////////////////////////////////////////////////
+
+class cron_t : public func_t {
+public:
+  int last,interval;
+  cron_t(const sref& s,const sref& b,unsigned m,int i):
+    func_t(s,b,m|CRON,ms_empty),last(0),interval(i) {}
+  
+  static void* operator new(size_t n);
+  static void operator delete(void* p);
+private:
+  static uniheap<88> tree;
+};
+
+///////////////////////////////////////////////////////////////////
+
+class binary_t : public runnable_t {
+public:
+  s_func_t func;
+  binary_t(const sref& s,const sref& b,unsigned m,const sref& a,s_func_t f):
+    runnable_t(s,b,m|BINARY,a),func(f) {}
+  
+  static void* operator new(size_t n);
+  static void operator delete(void* p);
+private:
+  static uniheap<48> tree;
+};
+
+///////////////////////////////////////////////////////////////////
+
+mstream& operator<<(mstream&,const runnable_t& ftok);
+mstring Mode(const tok_t& tok);
+mstring Desc(const tok_t& tok);
+
+///////////////////////////////////////////////////////////////////
+
+struct tokmap {
+  typedef tok_t* val_t;
+  typedef mrvec<val_t> map_t;
+  typedef map_t::iterator iterator;
+  typedef map_t::const_iterator const_iterator;
+
+  struct comp_t {
+    sref key;
+    comp_t(const sref& skey) : key(skey) {}
+    bool operator()(val_t a,val_t b) const {
+      return (a?((const sref&)a->name):key)<(b?((const sref&)b->name):key);
+    }
+  };
+  
+  tokmap* up;
+  map_t list;
+  
+  tokmap() : up(0),list() {}
+  tokmap(tokmap& p) : up(&p),list() {}
+  ~tokmap() { clear(); }
+
+  iterator begin() { return list.begin(); }
+  const_iterator begin() const { return list.begin(); }
+
+  iterator end() { return list.end(); }
+  const_iterator end() const { return list.end(); }
+  
+  void clear();
+  iterator erase(iterator p) { delete *p; return list.erase(p); }
+  
+  tok_t* get_this(const sref& t);
+  const tok_t* get_this(const sref& t) const;
+  const tok_t* get(const sref& t) const;
+  tok_t* get(const sref& t);
+  
+  tok_t* set(tok_t* tok,int replace,int force) throw(merror_t);
+  tok_t* add(tok_t* tok,int replace,int force) throw(merror_t);
+};
+
+///////////////////////////////////////////////////////////////////
+
+int is_tokname(const sref& s);
+int is_arglist(const sref& s);
+
+tok_t* Cond(tokmap& map,const sref& s,const sref& b,unsigned m) throw(merror_t);
+tok_t* Global(tokmap& map,const sref& s,const sref& b,unsigned m,int rpl=0) throw(merror_t);
+tok_t* Const(tokmap& map,const sref& s,const sref& b,unsigned m,int rpl=0) throw(merror_t);
+func_t* Func(tokmap& map,const sref& s,const sref& b,
+             unsigned m,const sref& a,int rpl=0) throw(merror_t);
+cron_t* Cron(tokmap& map,const sref& s,const sref& b,
+             unsigned m,int i,int rpl=0) throw(merror_t);
+binary_t* Binary(tokmap& map,const sref& s,const sref& b,
+                 unsigned m,const sref& a,s_func_t f,int rpl=0) throw(merror_t);
+reference_t* Reference(tokmap& map,const sref& s,const sref& b,
+                       unsigned m,int rpl=0) throw(merror_t);
+dbref_t* DBRef(tokmap& map,const sref& s,
+               const sref& b,unsigned m,int rpl=0) throw(merror_t);
+void ClearToken(tokmap& map,const sref& s) throw(merror_t);
+
+///////////////////////////////////////////////////////////////////
+
+const int XPUBLIC=tok_t::RESTRICT;
+const int XPRIVATE=XPUBLIC|tok_t::NORMAL;
+const int XSYSTEM=XPRIVATE|tok_t::SYSONLY;
+const int XINIT=tok_t::INIT;
+
+#endif