src/qsa/src/engine/qsobject.h

Ir a la documentación de este archivo.

/****************************************************************************
** $Id: qsobject.h  1.1.5   edited 2006-02-23T15:39:57$
**
** Copyright (C) 2001-2006 Trolltech AS.  All rights reserved.
**
** This file is part of the Qt Script for Applications framework (QSA).
**
** This file may be distributed and/or modified under the terms of the
** GNU General Public License version 2 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file.
**
** Licensees holding a valid Qt Script for Applications license may use
** this file in accordance with the Qt Script for Applications License
** Agreement provided with the Software.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
**   information about QSA Commercial License Agreements.
** See http://www.trolltech.com/gpl/ for GPL licensing information.
**
** Contact info@trolltech.com if any conditions of this licensing are
** not clear to you.
**
*****************************************************************************/

#ifndef QSOBJECT_H
#define QSOBJECT_H

#include "qsglobal.h"
#include "../kernel/dlldefs.h"
#include <qstring.h>
#include <qvariant.h>

class QSList;
class QSClass;
class QSBooleanClass;
class QSForInNode;
class QSEngine;
class QSEnv;

enum ErrorType { NoError = 0,
                 GeneralError,
                 EvalError,
                 RangeError,
                 ReferenceError,
                 SyntaxError,
                 TypeError,
                 URIError,
                 ThrowError
               };

enum ValueType {
  TypeValue,
  TypeShared,
  TypeClass,
  TypeOther
};

// Reggie: This is a really ugly hack to get QSA link on windows
double QUICKCORE_EXPORT NaN();
double QUICKCORE_EXPORT Inf();
#define NaN NaN()
#define Inf Inf()

// forward declarations
class Imp;
class QSShared;
struct QSProperty;
typedef QMap<QString, QSProperty> QSPropertyMap;
class PropList;
class QSMember;

union QUICKCORE_EXPORT Value {
  int i;
  double d;
  bool b;
  QStringData *str;
  QSShared *sh;
  QSClass *cl;
  void *other;
};

class QSElementNode;
class QSObject;

struct QSFakeQString {
  QStringData *d;
};
inline QStringData *qsStringData(const QString &s)
{
  return ((QSFakeQString *)&s)->d;
}

class QUICKCORE_EXPORT QSObject
{
  friend class QSStringClass;
  friend class QSEnv;
public:
  QSObject();
  QSObject(const QSClass *c);
  QSObject(const QSClass *c, QSShared *s);
  QSObject(const QSObject &);

  /*
   * Assignment operator
   */
  QSObject &operator=(const QSObject &);

  bool operator==(const QSObject &a) const;

  ~QSObject();
  bool isValid() const {
    return !!clss;
  }
  void invalidate() {
    clss = 0;
  }
  bool isDefined() const;
  QString typeName() const;

  ValueType valueType() const;

  inline const QSClass *objectType() const;
  void setType(QSClass *c);

  bool isA(const QSClass *c) const;
  bool isA(const char *s) const;

  bool isObject() const;
  bool isNull() const;
  bool isUndefined() const;
  bool isNumber() const;
  bool isString() const;
  bool isBoolean() const;
  bool isFunction() const;
  bool isPrimitive() const;

  bool equals(const QSObject &other) const;
  bool strictEquals(const QSObject &other) const;
  QSCompareResult compareTo(const QSObject &other) const;

  QSEnv *env() const;
  //     bool derivedFrom(const char *s) const;

  QSObject toPrimitive(const QSClass *preferred = 0) const; // ECMA 9.1
  bool toBoolean() const; // ECMA 9.2
  double toNumber() const; // ECMA 9.3
  QVariant toVariant(QVariant::Type t) const;
  double round() const;
  int toInteger() const; // ECMA 9.4
  int toInt32() const; // ECMA 9.5
  unsigned int toUInt32() const; // ECMA 9.6
  unsigned short toUInt16() const; // ECMA 9.7
  QString toString() const; // ECMA 9.8

  /*
    Gets a qualified name in this object. E.g. if name is
    a.b.c, c is returned based on this.a.b.c
  */
  QSObject getQualified(const QString &name) const;

  // Properties
  QSObject get(const QString &p) const;
  bool hasProperty(const QString &p) const;
  void put(const QString &p, const QSObject &v);
  bool deleteProperty(const QString &p);
  void put(const QString &p, double d);
  void put(const QString &p, int i);
  void put(const QString &p, unsigned int u);
  bool isExecutable() const;
  QSObject executeCall(QSObject *thisV,
                       const QSList *args);

  QSObject execute(const QSList &args);

  QSObject invoke(const QSMember &mem, const QSList &args);

  QSObject fetchValue(const QSMember &mem);
  void write(const QSMember &mem, const QSObject &val);

  void mark();

  const QSClass *resolveMember(const QString &name, QSMember *mem, const QSClass *owner = 0, int *offset = 0) const;

#if QS_DEBUG_MEM == 1

  static int count;
#endif
  int iVal() const {
    return val.i;
  }
  void setVal(int v) {
    val.i = v;
  }

  double dVal() const {
    return val.d;
  }
  void setVal(double v) {
    val.d = v;
  }

  bool bVal() const {
    return val.b;
  }
  void setVal(bool v) {
    val.b = v;
  }

  QString sVal() const;
  void setVal(const QString &v) {
    val.str = qsStringData(v);
    val.str->ref();
  }

  void *oVal() const {
    return val.other;
  }
  void setVal(void *v) {
    val.other = v;
  }

  QSShared *shVal() const {
    return val.sh;
  }
  void setVal(QSShared *s);

  QString debugString() const;
protected:
  const QSClass *clss;

private:
#if QS_DEBUG_MEM == 1
  void checkShared() const;
#endif

  Value val;
}; // end of QSObject

inline QString QSObject::sVal() const
{
  return *(QString *)(&val.str);
}

inline void QSObject::setVal(QSShared *s)
{
  val.sh = s;
#if QS_DEBUG_MEM == 1
  if (s)
    checkShared();
#endif
}

class QUICKCORE_EXPORT QSShared : public QShared
{
  friend class QSEnv;
public:
  QSShared() : next(0), prev(0) { }
  virtual ~QSShared() { }
  virtual void invalidate() { }
  bool isConnected() const {
    return next != 0 || prev != 0;
  }

private:
  QSShared *next;
  QSShared *prev;
};

class QUICKCORE_EXPORT QSWritable : public QSShared
{
public:
  QSWritable();
  ~QSWritable();

  void setProperty(const QString &n, const QSProperty &p);
  QSProperty *reference(const QString &n) const;
  bool hasProperty(const QString &n) const;
  QSPropertyMap *properties() const {
    return props;
  }

  void invalidate();

private:
  QSPropertyMap *props;
};

struct QSProperty {
  QSProperty() { }
  QSProperty(const QSObject &o) : object(o) { }
  void invalidate() {
    object.invalidate();
  }
  QSObject object;
};

class QSEngineImp;
class QUICKCORE_EXPORT Global : public QSObject
{
  friend class QSEngineImp;
public:
private:
  Global(QSEngine *e);
  void init();
  void clear();
  QSEngine *eng;
};

inline const QSClass *QSObject::objectType() const
{
  Q_ASSERT(clss);
  return clss;
}

#endif