src/declarative/qml/qdeclarativeparser_p.h

   1 /****************************************************************************
   2 **
   3 ** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
   4 ** All rights reserved.
   5 ** Contact: Nokia Corporation (qt-info@nokia.com)
   6 **
   7 ** This file is part of the QtDeclarative module of the Qt Toolkit.
   8 **
   9 ** $QT_BEGIN_LICENSE:LGPL$
  10 ** GNU Lesser General Public License Usage
  11 ** This file may be used under the terms of the GNU Lesser General Public
  12 ** License version 2.1 as published by the Free Software Foundation and
  13 ** appearing in the file LICENSE.LGPL included in the packaging of this
  14 ** file. Please review the following information to ensure the GNU Lesser
  15 ** General Public License version 2.1 requirements will be met:
  16 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
  17 **
  18 ** In addition, as a special exception, Nokia gives you certain additional
  19 ** rights. These rights are described in the Nokia Qt LGPL Exception
  20 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
  21 **
  22 ** GNU General Public License Usage
  23 ** Alternatively, this file may be used under the terms of the GNU General
  24 ** Public License version 3.0 as published by the Free Software Foundation
  25 ** and appearing in the file LICENSE.GPL included in the packaging of this
  26 ** file. Please review the following information to ensure the GNU General
  27 ** Public License version 3.0 requirements will be met:
  28 ** http://www.gnu.org/copyleft/gpl.html.
  29 **
  30 ** Other Usage
  31 ** Alternatively, this file may be used in accordance with the terms and
  32 ** conditions contained in a signed written agreement between you and Nokia.
  33 **
  34 **
  35 **
  36 **
  37 **
  38 ** $QT_END_LICENSE$
  39 **
  40 ****************************************************************************/
  41
  42 #ifndef QDECLARATIVEPARSER_P_H
  43 #define QDECLARATIVEPARSER_P_H
  44
  45 //
  46 //  W A R N I N G
  47 //  -------------
  48 //
  49 // This file is not part of the Qt API.  It exists purely as an
  50 // implementation detail.  This header file may change from version to
  51 // version without notice, or even be removed.
  52 //
  53 // We mean it.
  54 //
  55
  56 #include "qdeclarative.h"
  57
  58 #include <QtCore/qbytearray.h>
  59 #include <QtCore/qlist.h>
  60 #include <QtCore/qurl.h>
  61 #include <QtCore/qstring.h>
  62 #include <QtCore/qstringlist.h>
  63
  64 #include <private/qobject_p.h>
  65 #include <private/qdeclarativerefcount_p.h>
  66 #include <private/qdeclarativeglobal_p.h>
  67
  68 QT_BEGIN_HEADER
  69
  70 QT_BEGIN_NAMESPACE
  71
  72 QT_MODULE(Declarative)
  73
  74 class QDeclarativePropertyCache;
  75 namespace QDeclarativeJS { namespace AST { class Node; } }
  76
  77 /*
  78     XXX
  79
  80     These types are created (and owned) by the QDeclarativeScriptParser and consumed by the
  81     QDeclarativeCompiler.  During the compilation phase the compiler will update some of
  82     the fields for its own use.
  83
  84     The types are part of the generic sounding "QDeclarativeParser" namespace for legacy
  85     reasons (there used to be more in this namespace) and will be cleaned up and
  86     migrated into a more appropriate location eventually.
  87 */
  88 namespace QDeclarativeParser
  89 {
  90     struct Location
  91     {
  92         Location() : line(-1), column(-1) {}
  93         int line;
  94         int column;
  95     };
  96
  97     struct LocationRange
  98     {
  99         LocationRange() : offset(0), length(0) {}
 100         quint32 offset;
 101         quint32 length;
 102     };
 103
 104     struct LocationSpan
 105     {
 106         Location start;
 107         Location end;
 108         LocationRange range;
 109
 110         bool operator<(LocationSpan &o) const {
 111             return (start.line < o.start.line) ||
 112                    (start.line == o.start.line && start.column < o.start.column);
 113         }
 114     };
 115
 116     class Property;
 117     class Object : public QDeclarativeRefCount
 118     {
 119     public:
 120         Object();
 121         virtual ~Object();
 122
 123         // Type of the object.  The integer is an index into the
 124         // QDeclarativeCompiledData::types array, or -1 if the object is a property
 125         // group.
 126         int type;
 127
 128         // The fully-qualified name of this type
 129         QByteArray typeName;
 130         // The id assigned to the object (if any).  Set by the QDeclarativeCompiler
 131         QString id;
 132         // The id index assigned to the object (if any).  Set by the QDeclarativeCompiler
 133         int idIndex;
 134         // Custom parsed data
 135         QByteArray custom;
 136         // Bit mask of the properties assigned bindings
 137         QByteArray bindingBitmask;
 138         void setBindingBit(int);
 139         // Returns the metaobject for this type, or 0 if not available.
 140         // Internally selectd between the metatype and extObject variables
 141         const QMetaObject *metaObject() const;
 142
 143         // The compile time metaobject for this type
 144         const QMetaObject *metatype;
 145         // The synthesized metaobject, if QML added signals or properties to
 146         // this type.  Otherwise null
 147         QAbstractDynamicMetaObject extObject;
 148         QByteArray metadata; // Generated by compiler
 149         QByteArray synthdata; // Generated by compiler
 150         QDeclarativePropertyCache *synthCache; // Generated by compiler
 151
 152         Property *getDefaultProperty();
 153         Property *getProperty(const QString &name, bool create=true);
 154
 155         Property *defaultProperty;
 156         QHash<QString, Property *> properties;
 157
 158         // Output of the compilation phase (these properties continue to exist
 159         // in either the defaultProperty or properties members too)
 160         void addValueProperty(Property *);
 161         void addSignalProperty(Property *);
 162         void addAttachedProperty(Property *);
 163         void addGroupedProperty(Property *);
 164         void addValueTypeProperty(Property *);
 165         void addScriptStringProperty(Property *, int = 0);
 166         QList<Property *> valueProperties;
 167         QList<Property *> signalProperties;
 168         QList<Property *> attachedProperties;
 169         QList<Property *> groupedProperties;
 170         QList<Property *> valueTypeProperties;
 171         QList<QPair<Property *, int> > scriptStringProperties;
 172
 173         // Script blocks that were nested under this object
 174         struct ScriptBlock {
 175             enum Pragma {
 176                 None   = 0x00000000,
 177                 Shared = 0x00000001
 178             };
 179             Q_DECLARE_FLAGS(Pragmas, Pragma)
 180
 181             QString code;
 182             QString file;
 183             Pragmas pragmas;
 184         };
 185
 186         // The bytes to cast instances by to get to the QDeclarativeParserStatus
 187         // interface.  -1 indicates the type doesn't support this interface.
 188         // Set by the QDeclarativeCompiler.
 189         int parserStatusCast;
 190
 191         LocationSpan location;
 192
 193         struct DynamicProperty {
 194             DynamicProperty();
 195             DynamicProperty(const DynamicProperty &);
 196
 197             enum Type { Variant, Int, Bool, Real, String, Url, Color, Time, Date, DateTime, Alias, Custom, CustomList };
 198
 199             bool isDefaultProperty;
 200             Type type;
 201             QByteArray customType;
 202             QByteArray name;
 203             QDeclarativeParser::Property *defaultValue;
 204             LocationSpan location;
 205         };
 206         struct DynamicSignal {
 207             DynamicSignal();
 208             DynamicSignal(const DynamicSignal &);
 209
 210             QByteArray name;
 211             QList<QByteArray> parameterTypes;
 212             QList<QByteArray> parameterNames;
 213             LocationSpan location;
 214         };
 215         struct DynamicSlot {
 216             DynamicSlot();
 217             DynamicSlot(const DynamicSlot &);
 218
 219             QByteArray name;
 220             QString body;
 221             QList<QByteArray> parameterNames;
 222             LocationSpan location;
 223         };
 224
 225         // The list of dynamic properties
 226         QList<DynamicProperty> dynamicProperties;
 227         // The list of dynamic signals
 228         QList<DynamicSignal> dynamicSignals;
 229         // The list of dynamic slots
 230         QList<DynamicSlot> dynamicSlots;
 231     };
 232
 233     class Q_DECLARATIVE_EXPORT Variant
 234     {
 235     public:
 236         enum Type {
 237             Invalid,
 238             Boolean,
 239             Number,
 240             String,
 241             Script
 242         };
 243
 244         Variant();
 245         Variant(const Variant &);
 246         Variant(bool);
 247         Variant(double, const QString &asWritten=QString());
 248         Variant(const QString &);
 249         Variant(const QString &, QDeclarativeJS::AST::Node *);
 250         Variant &operator=(const Variant &);
 251
 252         Type type() const;
 253
 254         bool isBoolean() const { return type() == Boolean; }
 255         bool isNumber() const { return type() == Number; }
 256         bool isString() const { return type() == String; }
 257         bool isScript() const { return type() == Script; }
 258         bool isStringList() const;
 259
 260         bool asBoolean() const;
 261         QString asString() const;
 262         double asNumber() const;
 263         QString asScript() const;
 264         QDeclarativeJS::AST::Node *asAST() const;
 265         QStringList asStringList() const;
 266
 267     private:
 268         Type t;
 269         union {
 270             bool b;
 271             double d;
 272             QDeclarativeJS::AST::Node *n;
 273         };
 274         QString s;
 275     };
 276
 277     class Value : public QDeclarativeRefCount
 278     {
 279     public:
 280         Value();
 281         virtual ~Value();
 282
 283         enum Type {
 284             // The type of this value assignment is not yet known
 285             Unknown,
 286             // This is used as a literal property assignment
 287             Literal,
 288             // This is used as a property binding assignment
 289             PropertyBinding,
 290             // This is used as a QDeclarativePropertyValueSource assignment
 291             ValueSource,
 292             // This is used as a QDeclarativePropertyValueInterceptor assignment
 293             ValueInterceptor,
 294             // This is used as a property QObject assignment
 295             CreatedObject,
 296             // This is used as a signal object assignment
 297             SignalObject,
 298             // This is used as a signal expression assignment
 299             SignalExpression,
 300             // This is used as an id assignment only
 301             Id
 302         };
 303         Type type;
 304
 305         // ### Temporary (for id only)
 306         QString primitive() const { return value.isString() ? value.asString() : value.asScript(); }
 307
 308         // Primitive value
 309         Variant value;
 310         // Object value
 311         Object *object;
 312
 313         LocationSpan location;
 314     };
 315
 316     class Property : public QDeclarativeRefCount
 317     {
 318     public:
 319         Property();
 320         Property(const QString &n);
 321         virtual ~Property();
 322
 323         // The Object to which this property is attached
 324         Object *parent;
 325
 326         Object *getValue(const LocationSpan &);
 327         void addValue(Value *v);
 328         void addOnValue(Value *v);
 329
 330         // The QVariant::Type of the property, or 0 (QVariant::Invalid) if
 331         // unknown.
 332         int type;
 333         // The metaobject index of this property, or -1 if unknown.
 334         int index;
 335
 336         // Returns true if this is an empty property - both value and values
 337         // are unset.
 338         bool isEmpty() const;
 339         // The list of values assigned to this property.  Content in values
 340         // and value are mutually exclusive
 341         QList<Value *> values;
 342         // The list of values assigned to this property using the "on" syntax
 343         QList<Value *> onValues;
 344         // The accessed property.  This is used to represent dot properties.
 345         // Content in value and values are mutually exclusive.
 346         Object *value;
 347         // The property name
 348         QString name;
 349         // True if this property was accessed as the default property.
 350         bool isDefault;
 351         // True if the setting of this property will be deferred.  Set by the
 352         // QDeclarativeCompiler
 353         bool isDeferred;
 354         // True if this property is a value-type pseudo-property
 355         bool isValueTypeSubProperty;
 356         // True if this property is a property alias.  Set by the
 357         // QDeclarativeCompiler
 358         bool isAlias;
 359
 360         LocationSpan location;
 361         LocationRange listValueRange;
 362     };
 363 }
 364
 365 Q_DECLARE_OPERATORS_FOR_FLAGS(QDeclarativeParser::Object::ScriptBlock::Pragmas);
 366
 367 QT_END_NAMESPACE
 368
 369 Q_DECLARE_METATYPE(QDeclarativeParser::Variant)
 370
 371 QT_END_HEADER
 372
 373 #endif // QDECLARATIVEPARSER_P_H