1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2010 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 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include "private/qdeclarativejsengine_p.h"

    43 

    44 #include "private/qdeclarativejsglobal_p.h"

    45 #include "private/qdeclarativejsnodepool_p.h"

    46 

    47 #include <qnumeric.h>

    48 #include <QHash>

    49 

    50 QT_QML_BEGIN_NAMESPACE

    51 

    52 namespace QDeclarativeJS {

    53 

    54 uint qHash(const QDeclarativeJS::NameId &id)

    55 { return qHash(id.asString()); }

    56 

    57 QString numberToString(double value)

    58 { return QString::number(value); }

    59 

    60 int Ecma::RegExp::flagFromChar(const QChar &ch)

    61 {

    62     static QHash<QChar, int> flagsHash;

    63     if (flagsHash.isEmpty()) {

    64         flagsHash[QLatin1Char('g')] = Global;

    65         flagsHash[QLatin1Char('i')] = IgnoreCase;

    66         flagsHash[QLatin1Char('m')] = Multiline;

    67     }

    68     QHash<QChar, int>::const_iterator it;

    69     it = flagsHash.constFind(ch);

    70     if (it == flagsHash.constEnd())

    71         return 0;

    72     return it.value();

    73 }

    74 

    75 QString Ecma::RegExp::flagsToString(int flags)

    76 {

    77     QString result;

    78     if (flags & Global)

    79         result += QLatin1Char('g');

    80     if (flags & IgnoreCase)

    81         result += QLatin1Char('i');

    82     if (flags & Multiline)

    83         result += QLatin1Char('m');

    84     return result;

    85 }

    86 

    87 NodePool::NodePool(const QString &fileName, Engine *engine)

    88     : m_fileName(fileName), m_engine(engine)

    89 {

    90     m_engine->setNodePool(this);

    91 }

    92 

    93 NodePool::~NodePool()

    94 {

    95 }

    96 

    97 Code *NodePool::createCompiledCode(AST::Node *, CompilationUnit &)

    98 {

    99     Q_ASSERT(0);

   100     return 0;

   101 }

   102 

   103 static int toDigit(char c)

   104 {

   105     if ((c >= '0') && (c <= '9'))

   106         return c - '0';

   107     else if ((c >= 'a') && (c <= 'z'))

   108         return 10 + c - 'a';

   109     else if ((c >= 'A') && (c <= 'Z'))

   110         return 10 + c - 'A';

   111     return -1;

   112 }

   113 

   114 double integerFromString(const char *buf, int size, int radix)

   115 {

   116     if (size == 0)

   117         return qSNaN();

   118 

   119     double sign = 1.0;

   120     int i = 0;

   121     if (buf[0] == '+') {

   122         ++i;

   123     } else if (buf[0] == '-') {

   124         sign = -1.0;

   125         ++i;

   126     }

   127 

   128     if (((size-i) >= 2) && (buf[i] == '0')) {

   129         if (((buf[i+1] == 'x') || (buf[i+1] == 'X'))

   130             && (radix < 34)) {

   131             if ((radix != 0) && (radix != 16))

   132                 return 0;

   133             radix = 16;

   134             i += 2;

   135         } else {

   136             if (radix == 0) {

   137                 radix = 8;

   138                 ++i;

   139             }

   140         }

   141     } else if (radix == 0) {

   142         radix = 10;

   143     }

   144 

   145     int j = i;

   146     for ( ; i < size; ++i) {

   147         int d = toDigit(buf[i]);

   148         if ((d == -1) || (d >= radix))

   149             break;

   150     }

   151     double result;

   152     if (j == i) {

   153         if (!qstrcmp(buf, "Infinity"))

   154             result = qInf();

   155         else

   156             result = qSNaN();

   157     } else {

   158         result = 0;

   159         double multiplier = 1;

   160         for (--i ; i >= j; --i, multiplier *= radix)

   161             result += toDigit(buf[i]) * multiplier;

   162     }

   163     result *= sign;

   164     return result;

   165 }

   166 

   167 double integerFromString(const QString &str, int radix)

   168 {

   169     QByteArray ba = str.trimmed().toLatin1();

   170     return integerFromString(ba.constData(), ba.size(), radix);

   171 }

   172 

   173 

   174 Engine::Engine()

   175     : _lexer(0), _nodePool(0)

   176 { }

   177 

   178 Engine::~Engine()

   179 { }

   180 

   181 QSet<NameId> Engine::literals() const

   182 { return _literals; }

   183 

   184 void Engine::addComment(int pos, int len, int line, int col)

   185 { if (len > 0) _comments.append(QDeclarativeJS::AST::SourceLocation(pos, len, line, col)); }

   186 

   187 QList<QDeclarativeJS::AST::SourceLocation> Engine::comments() const

   188 { return _comments; }

   189 

   190 NameId *Engine::intern(const QChar *u, int s)

   191 { return const_cast<NameId *>(&*_literals.insert(NameId(u, s))); }

   192 

   193 QString Engine::toString(NameId *id)

   194 { return id->asString(); }

   195 

   196 Lexer *Engine::lexer() const

   197 { return _lexer; }

   198 

   199 void Engine::setLexer(Lexer *lexer)

   200 { _lexer = lexer; }

   201 

   202 NodePool *Engine::nodePool() const

   203 { return _nodePool; }

   204 

   205 void Engine::setNodePool(NodePool *nodePool)

   206 { _nodePool = nodePool; }

   207 

   208 

   209 

   210 } // end of namespace QDeclarativeJS

   211 

   212 QT_QML_END_NAMESPACE