include/qore/QoreNamespace.h (4311)

/* -*- mode: c++; indent-tabs-mode: nil -*- */
/*
  QoreNamespace.h

  Qore Programming Language

  Copyright 2003 - 2011 David Nichols

  namespaces are children of a program object.  there is a parse
  lock per program object to ensure that objects are added (or backed out)
  atomically per program object.  All the objects referenced here should 
  be safe to read & copied at all times.  They will only be deleted when the
  program object is deleted (except the pending structures, which will be
  deleted any time there is a parse error, together with all other
  pending structures)

  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.

  This library 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
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef _QORE_QORENAMESPACE_H

#define _QORE_QORENAMESPACE_H

#include <string.h>
#include <stdlib.h>

#include <string>

class RootQoreNamespace;
class ConstantList;
class QoreNamespaceList;
class QoreClassList;
class NamedScope;
class MethodVariantBase;


typedef QoreClass *(*q_ns_class_handler_t)(QoreNamespace *ns, const char *cname);

class QoreNamespace {
   friend class QoreNamespaceList;
   friend class RootQoreNamespace;
   friend class qore_ns_private;

protected:
   struct qore_ns_private *priv; // private implementation

   DLLLOCAL AbstractQoreNode *parseMatchScopedConstantValue(const NamedScope *name, unsigned *matched, const QoreTypeInfo *&typeInfo) const;
   DLLLOCAL QoreClass *parseMatchScopedClass(const NamedScope *name, unsigned *matched);
   DLLLOCAL QoreClass *parseMatchScopedClassWithMethod(const NamedScope *nscope, unsigned *matched);
   DLLLOCAL QoreNamespace *parseMatchNamespace(const NamedScope *nscope, unsigned *matched) const;
   DLLLOCAL void assimilate(QoreNamespace *ns);
   DLLLOCAL QoreClass *parseFindLocalClass(const char *name) const;
   DLLLOCAL QoreNamespace *resolveNameScope(const NamedScope *name) const;
   DLLLOCAL AbstractQoreNode *getConstantValue(const char *name, const QoreTypeInfo *&typeInfo) const;
   DLLLOCAL QoreNamespace(const char *n, QoreClassList *ocl, ConstantList *cl, QoreNamespaceList *nnsl);

   DLLLOCAL QoreNamespace(const QoreNamespace&);

   DLLLOCAL QoreNamespace& operator=(const QoreNamespace&);

   DLLLOCAL QoreNamespace(const QoreNamespace &old, int64 po);

public:

   DLLEXPORT QoreNamespace(const char *n);

   DLLEXPORT ~QoreNamespace();


   DLLEXPORT void addConstant(const char *name, AbstractQoreNode *value);


   DLLEXPORT void addConstant(const char *name, AbstractQoreNode *value, const QoreTypeInfo *typeInfo);


   DLLEXPORT void addSystemClass(QoreClass *oc);


   DLLEXPORT void addInitialNamespace(QoreNamespace *ns);


   DLLEXPORT QoreNamespace *copy(int po) const;


   DLLEXPORT QoreNamespace *copy(int64 po = PO_DEFAULT) const;


   DLLEXPORT QoreHashNode *getClassInfo() const;


   DLLEXPORT QoreHashNode *getConstantInfo() const;


   DLLEXPORT QoreHashNode *getInfo() const;


   DLLEXPORT const char *getName() const;


   DLLEXPORT void addNamespace(QoreNamespace *ns);


   DLLEXPORT QoreNamespace *findCreateNamespacePath(const char *nspath);


   DLLEXPORT QoreClass *findLocalClass(const char *cname) const;


   DLLEXPORT QoreNamespace *findLocalNamespace(const char *nsname) const;


   DLLEXPORT void setClassHandler(q_ns_class_handler_t class_handler);


   DLLEXPORT const QoreNamespace *getParent() const;

   DLLEXPORT void deleteData(ExceptionSink *xsink);

   // parse-only interfaces are not exported
   DLLLOCAL QoreNamespace();
   DLLLOCAL void addClass(const NamedScope *n, QoreClass *oc);

   DLLLOCAL void parseAddConstant(const NamedScope &name, AbstractQoreNode *value);

   DLLLOCAL void addClass(QoreClass *oc);
   DLLLOCAL void parseAddNamespace(QoreNamespace *ns);
   DLLLOCAL void parseInit();
   DLLLOCAL void parseInitConstants();
   DLLLOCAL void parseRollback();
   DLLLOCAL void parseCommit();
   DLLLOCAL void setName(const char *nme);

   DLLLOCAL void purge();
};


class RootQoreNamespace : public QoreNamespace {
protected:
   QoreNamespace *qoreNS;

   DLLLOCAL QoreNamespace *rootResolveNamespace(const NamedScope *nscope);
   DLLLOCAL void addQoreNamespace(QoreNamespace *qns);
   // private constructor
   DLLLOCAL RootQoreNamespace(QoreClassList *ocl, ConstantList *cl, QoreNamespaceList *nnsl);
   // private constructor
   DLLLOCAL RootQoreNamespace();
   DLLLOCAL QoreClass *rootFindScopedClass(const NamedScope *name, unsigned *matched);
   DLLLOCAL QoreClass *rootFindChangeClass(const char *name);
   DLLLOCAL AbstractQoreNode *rootFindScopedConstantValue(const NamedScope *name, unsigned *matched, const QoreTypeInfo *&typeInfo) const;

public:

   DLLEXPORT QoreNamespace *rootGetQoreNamespace() const;

   DLLLOCAL RootQoreNamespace(QoreNamespace *&QoreNS, int64 po = PO_DEFAULT);
   DLLLOCAL ~RootQoreNamespace();
   DLLLOCAL RootQoreNamespace *copy(int64 po = PO_DEFAULT) const;
   DLLLOCAL QoreClass *rootFindClass(const char *name) const;
   DLLLOCAL void rootAddClass(const NamedScope *name, QoreClass *oc);
   DLLLOCAL void rootAddConstant(const NamedScope &name, AbstractQoreNode *value);
   DLLLOCAL AbstractQoreNode *findConstantValue(const NamedScope *name, const QoreTypeInfo *&typeInfo) const;
   DLLLOCAL AbstractQoreNode *findConstantValue(const char *name, const QoreTypeInfo *&typeInfo) const;
   DLLLOCAL QoreClass *parseFindClass(const char *name) const;
   DLLLOCAL QoreClass *parseFindScopedClass(const NamedScope *name);
   DLLLOCAL QoreClass *parseFindScopedClassWithMethod(const NamedScope *name);
   // returns 0 for success, non-zero for error
   DLLLOCAL int resolveBareword(AbstractQoreNode **, const QoreTypeInfo *&) const;
   // returns 0 for success, non-zero for error (parse exception thrown)
   DLLLOCAL int resolveScopedReference(AbstractQoreNode **, const QoreTypeInfo *&) const;
   // does not throw parse exceptions
   DLLLOCAL AbstractQoreNode *resolveScopedReference(const NamedScope &ns, unsigned &m, const QoreTypeInfo *&typeInfo) const;
   // returns 0 for success, non-zero for error
   DLLLOCAL int addMethodToClass(const NamedScope *name, MethodVariantBase *qcmethod, bool static_flag);
   DLLLOCAL QoreClass *rootFindScopedClassWithMethod(const NamedScope *nscope, unsigned *matched);
   DLLLOCAL AbstractQoreNode *rootFindConstantValue(const char *name, const QoreTypeInfo *&typeInfo) const;
};

#endif // QORE_NAMESPACE_H