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 class name
 131         QByteArray className;
 132         // The id assigned to the object (if any).  Set by the QDeclarativeCompiler
 133         QString id;
 134         // The id index assigned to the object (if any).  Set by the QDeclarativeCompiler
 135         int idIndex;
 136         // Custom parsed data
 137         QByteArray custom;
 138         // Bit mask of the properties assigned bindings
 139         QByteArray bindingBitmask;
 140         void setBindingBit(int);
 141         // Returns the metaobject for this type, or 0 if not available.
 142         // Internally selectd between the metatype and extObject variables
 143         const QMetaObject *metaObject() const;
 144
 145         // The compile time metaobject for this type
 146         const QMetaObject *metatype;
 147         // The synthesized metaobject, if QML added signals or properties to
 148         // this type.  Otherwise null
 149         QAbstractDynamicMetaObject extObject;
 150         QByteArray metadata; // Generated by compiler
 151         QByteArray synthdata; // Generated by compiler
 152         QDeclarativePropertyCache *synthCache; // Generated by compiler
 153
 154         Property *getDefaultProperty();
 155         Property *getProperty(const QByteArray &name, bool create=true);
 156
 157         Property *defaultProperty;
 158         QHash<QByteArray, Property *> properties;
 159
 160         // Output of the compilation phase (these properties continue to exist
 161         // in either the defaultProperty or properties members too)
 162         void addValueProperty(Property *);
 163         void addSignalProperty(Property *);
 164         void addAttachedProperty(Property *);
 165         void addGroupedProperty(Property *);
 166         void addValueTypeProperty(Property *);
 167         void addScriptStringProperty(Property *, int = 0);
 168         QList<Property *> valueProperties;
 169         QList<Property *> signalProperties;
 170         QList<Property *> attachedProperties;
 171         QList<Property *> groupedProperties;
 172         QList<Property *> valueTypeProperties;
 173         QList<QPair<Property *, int> > scriptStringProperties;
 174
 175         // Script blocks that were nested under this object
 176         struct ScriptBlock {
 177             enum Pragma {
 178                 None   = 0x00000000,
 179                 Shared = 0x00000001
 180             };
 181             Q_DECLARE_FLAGS(Pragmas, Pragma)
 182
 183             QString code;
 184             QString file;
 185             Pragmas pragmas;
 186         };
 187
 188         // The bytes to cast instances by to get to the QDeclarativeParserStatus
 189         // interface.  -1 indicates the type doesn't support this interface.
 190         // Set by the QDeclarativeCompiler.
 191         int parserStatusCast;
 192
 193         LocationSpan location;
 194
 195         struct DynamicProperty {
 196             DynamicProperty();
 197             DynamicProperty(const DynamicProperty &);
 198
 199             enum Type { Variant, Int, Bool, Real, String, Url, Color, Time, Date, DateTime, Alias, Custom, CustomList };
 200
 201             bool isDefaultProperty;
 202             Type type;
 203             QByteArray customType;
 204             QByteArray name;
 205             QDeclarativeParser::Property *defaultValue;
 206             LocationSpan location;
 207         };
 208         struct DynamicSignal {
 209             DynamicSignal();
 210             DynamicSignal(const DynamicSignal &);
 211
 212             QByteArray name;
 213             QList<QByteArray> parameterTypes;
 214             QList<QByteArray> parameterNames;
 215         };
 216         struct DynamicSlot {
 217             DynamicSlot();
 218             DynamicSlot(const DynamicSlot &);
 219
 220             QByteArray name;
 221             QString body;
 222             QList<QByteArray> parameterNames;
 223             LocationSpan location;
 224         };
 225
 226         // The list of dynamic properties
 227         QList<DynamicProperty> dynamicProperties;
 228         // The list of dynamic signals
 229         QList<DynamicSignal> dynamicSignals;
 230         // The list of dynamic slots
 231         QList<DynamicSlot> dynamicSlots;
 232     };
 233
 234     class Q_DECLARATIVE_EXPORT Variant
 235     {
 236     public:
 237         enum Type {
 238             Invalid,
 239             Boolean,
 240             Number,
 241             String,
 242             Script
 243         };
 244
 245         Variant();
 246         Variant(const Variant &);
 247         Variant(bool);
 248         Variant(double, const QString &asWritten=QString());
 249         Variant(const QString &);
 250         Variant(const QString &, QDeclarativeJS::AST::Node *);
 251         Variant &operator=(const Variant &);
 252
 253         Type type() const;
 254
 255         bool isBoolean() const { return type() == Boolean; }
 256         bool isNumber() const { return type() == Number; }
 257         bool isString() const { return type() == String; }
 258         bool isScript() const { return type() == Script; }
 259         bool isStringList() const;
 260
 261         bool asBoolean() const;
 262         QString asString() const;
 263         double asNumber() const;
 264         QString asScript() const;
 265         QDeclarativeJS::AST::Node *asAST() const;
 266         QStringList asStringList() const;
 267
 268     private:
 269         Type t;
 270         union {
 271             bool b;
 272             double d;
 273             QDeclarativeJS::AST::Node *n;
 274         };
 275         QString s;
 276     };
 277
 278     class Value : public QDeclarativeRefCount
 279     {
 280     public:
 281         Value();
 282         virtual ~Value();
 283
 284         enum Type {
 285             // The type of this value assignment is not yet known
 286             Unknown,
 287             // This is used as a literal property assignment
 288             Literal,
 289             // This is used as a property binding assignment
 290             PropertyBinding,
 291             // This is used as a QDeclarativePropertyValueSource assignment
 292             ValueSource,
 293             // This is used as a QDeclarativePropertyValueInterceptor assignment
 294             ValueInterceptor,
 295             // This is used as a property QObject assignment
 296             CreatedObject,
 297             // This is used as a signal object assignment
 298             SignalObject,
 299             // This is used as a signal expression assignment
 300             SignalExpression,
 301             // This is used as an id assignment only
 302             Id
 303         };
 304         Type type;
 305
 306         // ### Temporary (for id only)
 307         QString primitive() const { return value.isString() ? value.asString() : value.asScript(); }
 308
 309         // Primitive value
 310         Variant value;
 311         // Object value
 312         Object *object;
 313
 314         LocationSpan location;
 315     };
 316
 317     class Property : public QDeclarativeRefCount
 318     {
 319     public:
 320         Property();
 321         Property(const QByteArray &n);
 322         virtual ~Property();
 323
 324         // The Object to which this property is attached
 325         Object *parent;
 326
 327         Object *getValue(const LocationSpan &);
 328         void addValue(Value *v);
 329         void addOnValue(Value *v);
 330
 331         // The QVariant::Type of the property, or 0 (QVariant::Invalid) if
 332         // unknown.
 333         int type;
 334         // The metaobject index of this property, or -1 if unknown.
 335         int index;
 336
 337         // Returns true if this is an empty property - both value and values
 338         // are unset.
 339         bool isEmpty() const;
 340         // The list of values assigned to this property.  Content in values
 341         // and value are mutually exclusive
 342         QList<Value *> values;
 343         // The list of values assigned to this property using the "on" syntax
 344         QList<Value *> onValues;
 345         // The accessed property.  This is used to represent dot properties.
 346         // Content in value and values are mutually exclusive.
 347         Object *value;
 348         // The property name
 349         QByteArray name;
 350         // True if this property was accessed as the default property.
 351         bool isDefault;
 352         // True if the setting of this property will be deferred.  Set by the
 353         // QDeclarativeCompiler
 354         bool isDeferred;
 355         // True if this property is a value-type pseudo-property
 356         bool isValueTypeSubProperty;
 357         // True if this property is a property alias.  Set by the
 358         // QDeclarativeCompiler
 359         bool isAlias;
 360
 361         LocationSpan location;
 362         LocationRange listValueRange;
 363     };
 364 }
 365
 366 Q_DECLARE_OPERATORS_FOR_FLAGS(QDeclarativeParser::Object::ScriptBlock::Pragmas);
 367
 368 QT_END_NAMESPACE
 369
 370 Q_DECLARE_METATYPE(QDeclarativeParser::Variant)
 371
 372 QT_END_HEADER
 373
 374 #endif // QDECLARATIVEPARSER_P_H