/****************************************************************************

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the QtScript module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL-ONLY$

** GNU Lesser General Public License Usage

** This file may be used under the terms of the GNU Lesser

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

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

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

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

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

**

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

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

** $QT_END_LICENSE$

**

****************************************************************************/

#include "config.h"

#include "qscriptcontextinfo.h"

#include "qscriptcontext_p.h"

#include "qscriptengine.h"

#include "qscriptengine_p.h"

#include "../bridge/qscriptqobject_p.h"

#include <QtCore/qdatastream.h>

#include <QtCore/qmetaobject.h>

#include "CodeBlock.h"

#include "JSFunction.h"

#if ENABLE(JIT)

#include "MacroAssemblerCodeRef.h"

#endif

QT_BEGIN_NAMESPACE

/*!

  \since 4.4

  \class QScriptContextInfo

  \brief The QScriptContextInfo class provides additional information about a QScriptContext.

  \ingroup script

  QScriptContextInfo is typically used for debugging purposes. It can

  provide information about the code being executed, such as the type

  of the called function, and the original source code location of the

  current statement.

  If the called function is executing Qt Script code, you can obtain

  the script location with the functions fileName(), lineNumber() and

  columnNumber().

  You can obtain the starting line number and ending line number of a

  Qt Script function definition with functionStartLineNumber() and

  functionEndLineNumber(), respectively.

  For Qt Script functions and Qt methods (e.g. slots), you can call

  functionParameterNames() to get the names of the formal parameters of the

  function.

  For Qt methods and Qt property accessors, you can obtain the index

  of the underlying QMetaMethod or QMetaProperty by calling

  functionMetaIndex().

  \sa QScriptContext, QScriptEngineAgent

*/

/*!

    \enum QScriptContextInfo::FunctionType

    This enum specifies the type of function being called.

    \value ScriptFunction The function is a Qt Script function, i.e. it was defined through a call to QScriptEngine::evaluate().

    \value QtFunction The function is a Qt function (a signal, slot or method).

    \value QtPropertyFunction The function is a Qt property getter or setter.

    \value NativeFunction The function is a built-in Qt Script function, or it was defined through a call to QScriptEngine::newFunction().

*/

class QScriptContextInfoPrivate

{

    Q_DECLARE_PUBLIC(QScriptContextInfo)

public:

    QScriptContextInfoPrivate();

    QScriptContextInfoPrivate(const QScriptContext *context);

    ~QScriptContextInfoPrivate();

    qint64 scriptId;

    int lineNumber;

    int columnNumber;

    QString fileName;

    QString functionName;

    QScriptContextInfo::FunctionType functionType;

    int functionStartLineNumber;

    int functionEndLineNumber;

    int functionMetaIndex;

    QStringList parameterNames;

    QBasicAtomicInt ref;

    QScriptContextInfo *q_ptr;

};

/*!

  \internal

*/

QScriptContextInfoPrivate::QScriptContextInfoPrivate()

{

    ref = 0;

    functionType = QScriptContextInfo::NativeFunction;

    functionMetaIndex = -1;

    functionStartLineNumber = -1;

    functionEndLineNumber = -1;

    scriptId = -1;

    lineNumber = -1;

    columnNumber = -1;

}

/*!

  \internal

*/

QScriptContextInfoPrivate::QScriptContextInfoPrivate(const QScriptContext *context)

{

    Q_ASSERT(context);

    ref = 0;

    functionType = QScriptContextInfo::NativeFunction;

    functionMetaIndex = -1;

    functionStartLineNumber = -1;

    functionEndLineNumber = -1;

    scriptId = -1;

    lineNumber = -1;

    columnNumber = -1;

    JSC::CallFrame *frame = const_cast<JSC::CallFrame *>(QScriptEnginePrivate::frameForContext(context));

    // Get the line number:

    //We need to know the context directly up in the backtrace, in order to get the line number, and adjust the global context

    JSC::CallFrame *rewindContext = QScriptEnginePrivate::get(context->engine())->currentFrame;

    if (QScriptEnginePrivate::contextForFrame(rewindContext) == context) {  //top context

        frame = rewindContext; //for retreiving the global context's "fake" frame

        // An agent might have provided the line number.

        lineNumber = QScript::scriptEngineFromExec(frame)->agentLineNumber;

    } else {

        // rewind the stack from the top in order to find the frame from the caller where the returnPC is stored

        while (rewindContext && QScriptEnginePrivate::contextForFrame(rewindContext->callerFrame()->removeHostCallFrameFlag()) != context)

            rewindContext = rewindContext->callerFrame()->removeHostCallFrameFlag();

        if (rewindContext) {

            frame = rewindContext->callerFrame()->removeHostCallFrameFlag(); //for retreiving the global context's "fake" frame

            JSC::Instruction *returnPC = rewindContext->returnPC();

            JSC::CodeBlock *codeBlock = frame->codeBlock();

            if (returnPC && codeBlock) {

#if ENABLE(JIT)

                unsigned bytecodeOffset = codeBlock->getBytecodeIndex(frame, JSC::ReturnAddressPtr(returnPC));

#else

                unsigned bytecodeOffset = returnPC - codeBlock->instructions().begin();

#endif

                bytecodeOffset--; //because returnPC is on the next instruction. We want the current one

                lineNumber = codeBlock->lineNumberForBytecodeOffset(const_cast<JSC::ExecState *>(frame), bytecodeOffset);

            }

        }

    }

    // Get the filename and the scriptId:

    JSC::CodeBlock *codeBlock = frame->codeBlock();

    if (codeBlock) {

           JSC::SourceProvider *source = codeBlock->source();

           scriptId = source->asID();

           fileName = source->url();

    }

    // Get the others informations:

    JSC::JSObject *callee = frame->callee();

    if (callee && callee->inherits(&JSC::InternalFunction::info))

        functionName = JSC::asInternalFunction(callee)->name(&frame->globalData());

    if (callee && callee->inherits(&JSC::JSFunction::info)) {

        functionType = QScriptContextInfo::ScriptFunction;

        JSC::FunctionExecutable *body = JSC::asFunction(callee)->jsExecutable();

        functionStartLineNumber = body->lineNo();

        functionEndLineNumber = body->lastLine();

        for (size_t i = 0; i < body->parameterCount(); ++i)

            parameterNames.append(body->parameterName(i));

        // ### get the function name from the AST

    } else if (callee && callee->inherits(&QScript::QtFunction::info)) {

        functionType = QScriptContextInfo::QtFunction;

        // ### the slot can be overloaded -- need to get the particular overload from the context

        functionMetaIndex = static_cast<QScript::QtFunction*>(callee)->initialIndex();

        const QMetaObject *meta = static_cast<QScript::QtFunction*>(callee)->metaObject();

        if (meta != 0) {

            QMetaMethod method = meta->method(functionMetaIndex);

            QList<QByteArray> formals = method.parameterNames();

            for (int i = 0; i < formals.count(); ++i)

                parameterNames.append(QLatin1String(formals.at(i)));

        }

    }

    else if (callee && callee->inherits(&QScript::QtPropertyFunction::info)) {

        functionType = QScriptContextInfo::QtPropertyFunction;

        functionMetaIndex = static_cast<QScript::QtPropertyFunction*>(callee)->propertyIndex();

    }

}

/*!

  \internal

*/

QScriptContextInfoPrivate::~QScriptContextInfoPrivate()

{

}

/*!

  Constructs a new QScriptContextInfo from the given \a context.

  The relevant information is extracted from the \a context at

  construction time; i.e. if you continue script execution in the \a

  context, the new state of the context will not be reflected in a

  previously created QScriptContextInfo.

*/

QScriptContextInfo::QScriptContextInfo(const QScriptContext *context)

    : d_ptr(0)

{

    if (context) {

        d_ptr = new QScriptContextInfoPrivate(context);

        d_ptr->q_ptr = this;

    }

}

/*!

  Constructs a new QScriptContextInfo from the \a other info.

*/

QScriptContextInfo::QScriptContextInfo(const QScriptContextInfo &other)

    : d_ptr(other.d_ptr)

{

}

/*!

  Constructs a null QScriptContextInfo.

  \sa isNull()

*/

QScriptContextInfo::QScriptContextInfo()

    : d_ptr(0)

{

}

/*!

  Destroys the QScriptContextInfo.

*/

QScriptContextInfo::~QScriptContextInfo()

{

}

/*!

  Assigns the \a other info to this QScriptContextInfo,

  and returns a reference to this QScriptContextInfo.

*/

QScriptContextInfo &QScriptContextInfo::operator=(const QScriptContextInfo &other)

{

    d_ptr = other.d_ptr;

    return *this;

}

/*!

  Returns the ID of the script where the code being executed was

  defined, or -1 if the ID is not available (i.e. a native function is

  being executed).

  \sa QScriptEngineAgent::scriptLoad()

*/

qint64 QScriptContextInfo::scriptId() const

{

    Q_D(const QScriptContextInfo);

    if (!d)

        return -1;

    return d->scriptId;

}

/*!

  Returns the name of the file where the code being executed was

  defined, if available; otherwise returns an empty string.

  For Qt Script code, this function returns the fileName argument

  that was passed to QScriptEngine::evaluate().

  \sa lineNumber(), functionName()

*/

QString QScriptContextInfo::fileName() const

{

    Q_D(const QScriptContextInfo);

    if (!d)

        return QString();

    return d->fileName;

}

/*!

  Returns the line number corresponding to the statement being

  executed, or -1 if the line number is not available.

  The line number is only available if Qt Script code is being

  executed.

  \sa columnNumber(), fileName()

*/

int QScriptContextInfo::lineNumber() const

{

    Q_D(const QScriptContextInfo);

    if (!d)

        return -1;

    return d->lineNumber;

}

/*!

  Returns the column number corresponding to the statement being

  executed, or -1 if the column number is not available.

  The column number is only available if Qt Script code is being

  executed.

  \sa lineNumber(), fileName()

*/

int QScriptContextInfo::columnNumber() const

{

    Q_D(const QScriptContextInfo);

    if (!d)

        return -1;

    return d->columnNumber;

}

/*!

  Returns the name of the called function, or an empty string if

  the name is not available.

  For script functions of type QtPropertyFunction, this function

  always returns the name of the property; you can use

  QScriptContext::argumentCount() to differentiate between reads and

  writes.

  \sa fileName(), functionType()

*/

QString QScriptContextInfo::functionName() const

{

    Q_D(const QScriptContextInfo);

    if (!d)

        return QString();

    return d->functionName;

}

/*!

  Returns the type of the called function.

  \sa functionName(), QScriptContext::callee()

*/

QScriptContextInfo::FunctionType QScriptContextInfo::functionType() const

{

    Q_D(const QScriptContextInfo);

    if (!d)

        return NativeFunction;

    return d->functionType;

}

/*!

  Returns the line number where the definition of the called function

  starts, or -1 if the line number is not available.

  The starting line number is only available if the functionType() is

  ScriptFunction.

  \sa functionEndLineNumber(), fileName()

*/

int QScriptContextInfo::functionStartLineNumber() const

{

    Q_D(const QScriptContextInfo);

    if (!d)

        return -1;

    return d->functionStartLineNumber;

}

/*!

  Returns the line number where the definition of the called function

  ends, or -1 if the line number is not available.

  The ending line number is only available if the functionType() is

  ScriptFunction.

  \sa functionStartLineNumber()

*/

int QScriptContextInfo::functionEndLineNumber() const

{

    Q_D(const QScriptContextInfo);

    if (!d)

        return -1;

    return d->functionEndLineNumber;

}

/*!

  Returns the names of the formal parameters of the called function,

  or an empty QStringList if the parameter names are not available.

  \sa QScriptContext::argument()

*/

QStringList QScriptContextInfo::functionParameterNames() const

{

    Q_D(const QScriptContextInfo);

    if (!d)

        return QStringList();

    return d->parameterNames;

}

/*!

  Returns the meta index of the called function, or -1 if the meta

  index is not available.

  The meta index is only available if the functionType() is QtFunction

  or QtPropertyFunction. For QtFunction, the meta index can be passed

  to QMetaObject::method() to obtain the corresponding method

  definition; for QtPropertyFunction, the meta index can be passed to

  QMetaObject::property() to obtain the corresponding property

  definition.

  \sa QScriptContext::thisObject()

*/

int QScriptContextInfo::functionMetaIndex() const

{

    Q_D(const QScriptContextInfo);

    if (!d)

        return -1;

    return d->functionMetaIndex;

}

/*!

  Returns true if this QScriptContextInfo is null, i.e. does not

  contain any information.

*/

bool QScriptContextInfo::isNull() const

{

    Q_D(const QScriptContextInfo);

    return (d == 0);

}

/*!

  Returns true if this QScriptContextInfo is equal to the \a other

  info, otherwise returns false.

*/

bool QScriptContextInfo::operator==(const QScriptContextInfo &other) const

{

    Q_D(const QScriptContextInfo);

    const QScriptContextInfoPrivate *od = other.d_func();

    if (d == od)

        return true;

    if (!d || !od)

        return false;

    return ((d->scriptId == od->scriptId)

            && (d->lineNumber == od->lineNumber)

            && (d->columnNumber == od->columnNumber)

            && (d->fileName == od->fileName)

            && (d->functionName == od->functionName)

            && (d->functionType == od->functionType)

            && (d->functionStartLineNumber == od->functionStartLineNumber)

            && (d->functionEndLineNumber == od->functionEndLineNumber)

            && (d->functionMetaIndex == od->functionMetaIndex)

            && (d->parameterNames == od->parameterNames));

}

/*!

  Returns true if this QScriptContextInfo is not equal to the \a other

  info, otherwise returns false.

*/

bool QScriptContextInfo::operator!=(const QScriptContextInfo &other) const

{

    return !(*this == other);

}

#ifndef QT_NO_DATASTREAM

/*!

  \fn QDataStream &operator<<(QDataStream &stream, const QScriptContextInfo &info)

  \since 4.4

  \relates QScriptContextInfo

  Writes the given \a info to the specified \a stream.

*/

QDataStream &operator<<(QDataStream &out, const QScriptContextInfo &info)

{

    out << info.scriptId();

    out << (qint32)info.lineNumber();

    out << (qint32)info.columnNumber();

    out << (quint32)info.functionType();

    out << (qint32)info.functionStartLineNumber();

    out << (qint32)info.functionEndLineNumber();

    out << (qint32)info.functionMetaIndex();

    out << info.fileName();

    out << info.functionName();

    out << info.functionParameterNames();

    return out;

}

/*!

  \fn QDataStream &operator>>(QDataStream &stream, QScriptContextInfo &info)

  \since 4.4

  \relates QScriptContextInfo

  Reads a QScriptContextInfo from the specified \a stream into the

  given \a info.

*/

Q_SCRIPT_EXPORT QDataStream &operator>>(QDataStream &in, QScriptContextInfo &info)

{

    if (!info.d_ptr) {

        info.d_ptr = new QScriptContextInfoPrivate();

    }

    in >> info.d_ptr->scriptId;

    qint32 line;

    in >> line;

    info.d_ptr->lineNumber = line;

    qint32 column;

    in >> column;

    info.d_ptr->columnNumber = column;