added refptr into tmpl/parser.h, added Node and Token classes to be generated

tmpl/parser.cc

@@ -121,6 +121,20 @@ bool I_CLASSNAME::parse(istream & i)
     }
 }
 
+refptr<Node> Node::operator[](int index)
+{
+    return (0 <= index && index < m_indexed_children.size())
+        ? m_indexed_children[index]
+        : NULL;
+}
+
+refptr<Node> Node::operator[](const std::string & index)
+{
+    return (m_named_children.find(index) != m_named_children.end())
+        ? m_named_children[index]
+        : NULL;
+}
+
 #ifdef I_NAMESPACE
 };
 #endif

tmpl/parser.h

@@ -3,11 +3,113 @@
 #define IMBECILE_PARSER_HEADER
 
 #include <iostream>
+#include <map>
+#include <vector>
 
 #ifdef I_NAMESPACE
 namespace I_NAMESPACE {
 #endif
 
+#ifndef REFPTR_H
+#define REFPTR_H REFPTR_H
+
+/* Author: Josh Holtrop
+ * Purpose: Provide a reference-counting pointer-like first order
+ *   C++ object that will free the object it is pointing to when
+ *   all references to it have been destroyed.
+ * This implementation does not solve the circular reference problem.
+ * I was not concerned with that when developing this class.
+ */
+#include <stdlib.h>             /* NULL */
+
+template <typename T>
+class refptr
+{
+    public:
+        refptr<T>();
+        refptr<T>(T * ptr);
+        refptr<T>(const refptr<T> & orig);
+        refptr<T> & operator=(const refptr<T> & orig);
+        refptr<T> & operator=(T * ptr);
+        ~refptr<T>();
+        T & operator*() const { return *m_ptr; }
+        T * operator->() const { return m_ptr; }
+        bool isNull() const { return m_ptr == NULL; }
+
+    private:
+        void cloneFrom(const refptr<T> & orig);
+        void destroy();
+
+        T * m_ptr;
+        int * m_refCount;
+};
+
+template <typename T> refptr<T>::refptr()
+{
+    m_ptr = NULL;
+    m_refCount = NULL;
+}
+
+template <typename T> refptr<T>::refptr(T * ptr)
+{
+    m_ptr = ptr;
+    m_refCount = new int;
+    *m_refCount = 1;
+}
+
+template <typename T> refptr<T>::refptr(const refptr<T> & orig)
+{
+    cloneFrom(orig);
+}
+
+template <typename T> refptr<T> & refptr<T>::operator=(const refptr<T> & orig)
+{
+    destroy();
+    cloneFrom(orig);
+    return *this;
+}
+
+template <typename T> refptr<T> & refptr<T>::operator=(T * ptr)
+{
+    destroy();
+    m_ptr = ptr;
+    m_refCount = new int;
+    *m_refCount = 1;
+    return *this;
+}
+
+template <typename T> void refptr<T>::cloneFrom(const refptr<T> & orig)
+{
+    this->m_ptr = orig.m_ptr;
+    this->m_refCount = orig.m_refCount;
+    if (m_refCount != NULL)
+        (*m_refCount)++;
+}
+
+template <typename T> refptr<T>::~refptr()
+{
+    destroy();
+}
+
+template <typename T> void refptr<T>::destroy()
+{
+    if (m_refCount != NULL)
+    {
+        if (*m_refCount <= 1)
+        {
+            delete m_ptr;
+            delete m_refCount;
+        }
+        else
+        {
+            (*m_refCount)--;
+        }
+    }
+}
+
+#endif
+
+
 class I_CLASSNAME
 {
     public:
@@ -19,6 +121,25 @@ class I_CLASSNAME
         const char * m_errstr;
 };
 
+class Node
+{
+    public:
+        refptr<Node> operator[](int index);
+        refptr<Node> operator[](const std::string & index);
+
+    protected:
+        std::map< std::string, refptr<Node> > m_named_children;
+        std::vector< refptr<Node> > m_indexed_children;
+};
+
+typedef refptr<Node> NodeRef;
+
+class Token : public Node
+{
+    public:
+    protected:
+};
+
 #ifdef I_NAMESPACE
 };
 #endif