include/qore/QoreProgram.h (4311)

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

  Program Object Definition

  Qore Programming Language

  Copyright 2003 - 2011 David Nichols

  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_QOREPROGRAM_H

#define _QORE_QOREPROGRAM_H

#include <qore/AbstractPrivateData.h>
#include <qore/Restrictions.h>

// warnings - must correspond with the string order in QoreProgram.cpp
// new warnings must also be added as constants
#define QP_WARN_NONE                     0
#define QP_WARN_WARNING_MASK_UNCHANGED   (1 << 0)   //!< when the warning mask is attempted to be changed but it's locked
#define QP_WARN_DUPLICATE_LOCAL_VARS     (1 << 1)   //!< duplicate local variable name reachable in the same scope
#define QP_WARN_UNKNOWN_WARNING          (1 << 2)   //!< when an unknown warning is encountered
#define QP_WARN_UNDECLARED_VAR           (1 << 3)   //!< when a variable is not declared
#define QP_WARN_DUPLICATE_GLOBAL_VARS    (1 << 4)   //!< when a global variable is declared more than once
#define QP_WARN_UNREACHABLE_CODE         (1 << 5)   //!< when unreachable code is encountered
#define QP_WARN_NONEXISTENT_METHOD_CALL  (1 << 6)   //!< when a non-existent method call is encountered
#define QP_WARN_INVALID_OPERATION        (1 << 7)   //!< when an expression always returns NOTHING, for example
#define QP_WARN_CALL_WITH_TYPE_ERRORS    (1 << 8)   //!< when a function or method call always returns a fixed value due to type errors
#define QP_WARN_RETURN_VALUE_IGNORED     (1 << 9)   //!< when a function or method call has no side effects and the return value is ignored
#define QP_WARN_DEPRECATED               (1 << 10)  //!< when depcrecated functionality is accessed
#define QP_WARN_EXCESS_ARGS              (1 << 11)  //!< when excess arguments are given to a function that does not access them
#define QP_WARN_DUPLICATE_HASH_KEY       (1 << 12)  //!< when a hash key has been defined more than once in a literal hash
#define QP_WARN_UNREFERENCED_VARIABLE    (1 << 13)  //!< when a variable is declared but not referenced
#define QP_WARN_DUPLICATE_BLOCK_VARS     (1 << 14)  //!< when a variable is declared more than once in the same block; this would normally be an error, but for backwards-compatibility it's just a warning unless parse option 'assume-local' is set, in which case it's an error
#define QP_WARN_ALL                      -1         //!< for all possible warnings

#define QP_WARN_DEFAULT (QP_WARN_UNKNOWN_WARNING|QP_WARN_UNREACHABLE_CODE|QP_WARN_NONEXISTENT_METHOD_CALL|QP_WARN_INVALID_OPERATION|QP_WARN_CALL_WITH_TYPE_ERRORS|QP_WARN_RETURN_VALUE_IGNORED|QP_WARN_DEPRECATED|QP_WARN_DUPLICATE_HASH_KEY|QP_WARN_DUPLICATE_BLOCK_VARS)

DLLEXPORT extern const char **qore_warnings;

DLLEXPORT extern unsigned qore_num_warnings;

DLLEXPORT int get_warning_code(const char *str);

class AbstractCallReferenceNode;
class LocalVar;
class ExceptionSink;
class QoreListNode;
class QoreNamespace;
class RootQoreNamespace;
class QoreStringNode;
class QoreHashNode;
class FunctionCallNode;
class AbstractStatement;
class UnresolvedProgramCallReferenceNode;
class Var;
class LVList;
class UserFunction;
class UserFunctionVariant;
class QoreTypeInfo;
class QoreParseTypeInfo;
class ParamList;
class AbstractQoreFunction;
class AbstractQoreZoneInfo;
class qore_program_private;


class QoreProgram : public AbstractPrivateData {
   friend class qore_program_private_base;
   friend class qore_program_private;
private:
   qore_program_private *priv;

   DLLLOCAL QoreProgram(const QoreProgram&);

   DLLLOCAL QoreProgram& operator=(const QoreProgram&);
      
protected:

   DLLLOCAL virtual ~QoreProgram();

public:
   DLLEXPORT QoreProgram();


   DLLEXPORT QoreProgram(int64 parse_options);


   DLLEXPORT AbstractQoreNode *callFunction(const char *name, const QoreListNode *args, ExceptionSink *xsink);


   DLLEXPORT AbstractQoreNode *run(ExceptionSink *xsink);


   DLLEXPORT AbstractQoreNode *runTopLevel(ExceptionSink *xsink);


   DLLEXPORT void parseFileAndRun(const char *filename);


   DLLEXPORT void parseAndRun(FILE *fp, const char *name);


   DLLEXPORT void parseAndRun(const char *str, const char *name);


   DLLEXPORT void runClass(const char *classname, ExceptionSink *xsink);


   DLLEXPORT void parseFileAndRunClass(const char *filename, const char *classname);


   DLLEXPORT void parseAndRunClass(FILE *fp, const char *name, const char *classname);


   DLLEXPORT void parseAndRunClass(const char *str, const char *name, const char *classname);      


   DLLEXPORT void parse(FILE *fp, const char *name, ExceptionSink *xsink, ExceptionSink *warn_sink = 0, int warn_mask = QP_WARN_ALL);


   DLLEXPORT void parse(const QoreString *str, const QoreString *lstr, ExceptionSink *xsink, ExceptionSink *warn_sink = 0, int warn_mask = QP_WARN_ALL);


   DLLEXPORT void parse(const char *str, const char *lstr, ExceptionSink *xsink, ExceptionSink *warn_sink = 0, int warn_mask = QP_WARN_ALL);


   DLLEXPORT void parseFile(const char *filename, ExceptionSink *xsink, ExceptionSink *warn_sink = 0, int warn_mask = QP_WARN_ALL, bool only_first_except = false);


   DLLEXPORT void parsePending(const char *code, const char *label, ExceptionSink *xsink, ExceptionSink *warn_sink = 0, int warn_mask = QP_WARN_ALL);


   DLLEXPORT void parsePending(const QoreString *str, const QoreString *lstr, ExceptionSink *xsink, ExceptionSink *warn_sink = 0, int warn_mask = QP_WARN_ALL);


   DLLEXPORT void parseCommit(ExceptionSink *xsink, ExceptionSink *warn_sink = 0, int warn_mask = QP_WARN_ALL);


   DLLEXPORT void parseRollback();

   DLLEXPORT bool existsFunction(const char *name);


   using AbstractPrivateData::deref;
   DLLEXPORT virtual void deref(ExceptionSink *xsink);

   DLLEXPORT void lockOptions();
      

   DLLEXPORT void setExecClass(const char *ecn = 0);

   DLLEXPORT void parseSetParseOptions(int po);

   DLLEXPORT void parseSetParseOptions(int64 po);

   DLLEXPORT void waitForTermination();


   DLLEXPORT void waitForTerminationAndDeref(ExceptionSink *xsink);

   DLLEXPORT QoreNamespace *getQoreNS() const;

   DLLEXPORT RootQoreNamespace *getRootNS() const;


   DLLEXPORT int setWarningMask(int wm);


   DLLEXPORT int enableWarning(int code);


   DLLEXPORT int disableWarning(int code);

   DLLEXPORT int getParseOptions() const;

   DLLEXPORT int64 getParseOptions64() const;


   DLLEXPORT void setParseOptions(int po, ExceptionSink *xsink);


   DLLEXPORT void setParseOptions(int64 po, ExceptionSink *xsink);


   DLLEXPORT void disableParseOptions(int po, ExceptionSink *xsink);
   

   DLLEXPORT void disableParseOptions(int64 po, ExceptionSink *xsink);


   DLLEXPORT void replaceParseOptions(int64 po, ExceptionSink *xsink);


   DLLEXPORT QoreListNode *getUserFunctionList();

   DLLEXPORT bool checkWarning(int code) const;

   DLLEXPORT int getWarningMask() const;

   DLLEXPORT bool checkFeature(const char *f) const;

   DLLEXPORT QoreListNode *getFeatureList() const;


   DLLEXPORT QoreStringNode *getScriptName() const;
      

   DLLEXPORT QoreStringNode *getScriptPath() const;
      

   DLLEXPORT QoreStringNode *getScriptDir() const;


   DLLEXPORT void setScriptPath(const char *path);


   DLLEXPORT AbstractQoreNode *getGlobalVariableValue(const char *var, bool &found) const;

   // retrieves the time zone setting for the program
   DLLEXPORT const AbstractQoreZoneInfo *currentTZ() const;

   // sets the program's time zone
   DLLEXPORT void setTZ(const AbstractQoreZoneInfo *n_TZ);


   DLLEXPORT void addFeature(const char *name);


   DLLEXPORT void parseSetTimeZone(const char *zone);


   DLLEXPORT void parseDefine(const char *str, AbstractQoreNode *val);


   DLLEXPORT void parseDefine(const char *str, const char *val);   

   DLLLOCAL UserFunction *findUserFunction(const char *name);
      
   DLLLOCAL QoreProgram(QoreProgram *pgm, int64 po, bool ec = false, const char *ecn = 0);

   DLLLOCAL LocalVar *createLocalVar(const char *name, const QoreTypeInfo *typeInfo);
   
   DLLLOCAL void registerUserFunctionVariant(char *name, UserFunctionVariant *variant);

   // raises a parse exception if the function cannot be found
   DLLLOCAL const AbstractQoreFunction *resolveFunction(const char *name, QoreProgram *&pgm);

   DLLLOCAL AbstractCallReferenceNode *resolveCallReference(UnresolvedProgramCallReferenceNode *fr);      
   DLLLOCAL Var *addGlobalVarDef(const char *name, QoreParseTypeInfo *typeInfo);
   DLLLOCAL Var *addResolvedGlobalVarDef(const char *name, const QoreTypeInfo *typeInfo);
   DLLLOCAL void addStatement(AbstractStatement *s);
   DLLLOCAL Var *findGlobalVar(const char *name);
   DLLLOCAL const Var *findGlobalVar(const char *name) const;
   DLLLOCAL Var *checkGlobalVar(const char *name, const QoreTypeInfo *typeInfo);
   DLLLOCAL void importGlobalVariable(Var *var, ExceptionSink *xsink, bool readonly);

   // takes over ownership of the xsink arg (and deletes it)
   DLLLOCAL void addParseException(ExceptionSink *xsink);
   // clears xsink arg
   DLLLOCAL void addParseException(ExceptionSink &xsink);
   // returns 0 if a "requires" exception has already occurred
   DLLLOCAL ExceptionSink *getParseExceptionSink();
   DLLLOCAL void makeParseWarning(int sline, int eline, const char *file, int code, const char *warn, const char *fmt, ...);
   DLLLOCAL void makeParseWarning(int code, const char *warn, const char *fmt, ...);
   // takes over ownership of "desc"
   DLLLOCAL void makeParseWarning(int code, const char *warn, QoreStringNode *desc);
   DLLLOCAL void addParseWarning(int code, ExceptionSink *xsink);

   DLLLOCAL void cannotProvideFeature(QoreStringNode *desc);
   DLLLOCAL void exportUserFunction(const char *name, QoreProgram *p, ExceptionSink *xsink);
   DLLLOCAL void exportUserFunction(const char *name, const char *new_name, QoreProgram *p, ExceptionSink *xsink);
   DLLLOCAL void startThread();
   DLLLOCAL QoreHashNode *getThreadData();
   DLLLOCAL void depRef();
   DLLLOCAL void depDeref(ExceptionSink *xsink);
   DLLLOCAL void addFile(char *f);
   DLLLOCAL QoreListNode *getVarList();
   DLLLOCAL void parseSetIncludePath(const char *path);
   DLLLOCAL const char *parseGetIncludePath() const;

   // increment atomic thread counter
   DLLLOCAL void tc_inc();

   // decrement atomic thread counter
   DLLLOCAL void tc_dec();

   /* for run-time module loading; the parse lock must be grabbed
      before loading new modules - note this should only be assigned
      to a AutoLock or SafeLocker object!
   */
   DLLLOCAL QoreThreadLock *getParseLock();
   DLLLOCAL QoreHashNode *clearThreadData(ExceptionSink *xsink);
   DLLLOCAL const LVList *getTopLevelLVList() const;


   DLLLOCAL const char *parseGetScriptDir() const;

   // can only be called while parsing from the same thread doing the parsing
   DLLLOCAL bool parseExceptionRaised() const;
};

class QoreProgramHelper {
private:
   QoreProgram *pgm;
   ExceptionSink &xsink;

public:
   DLLLOCAL QoreProgramHelper(ExceptionSink &xs) : pgm(new QoreProgram), xsink(xs) {
   }

   DLLLOCAL QoreProgramHelper(int64 parse_options, ExceptionSink &xs) : pgm(new QoreProgram(parse_options)), xsink(xs) {
   }


   DLLLOCAL ~QoreProgramHelper() {
      pgm->waitForTerminationAndDeref(&xsink);
   }

   DLLLOCAL QoreProgram* operator->() { return pgm; }

   DLLLOCAL QoreProgram* operator*() { return pgm; }    
};

#endif  // _QORE_QOREPROGRAM_H