/*

 * Copyright (C) 2004-2012 David Anderson

 *

 * This file is part of SourcePawn.

 *

 * SourcePawn is free software: you can redistribute it and/or modify it under

 * the terms of the GNU General Public License as published by the Free

 * Software Foundation, either version 3 of the License, or (at your option)

 * any later version.

 * 

 * SourcePawn is distributed in the hope that it will be useful, but WITHOUT ANY

 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

 * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License along with

 * SourcePawn. If not, see http://www.gnu.org/licenses/.

 */

#ifndef _include_sourcepawn3_api_h_

#define _include_sourcepawn3_api_h_

#include <stddef.h>

#include "../include/keima_util.h"

namespace ke {

class Zone;

class Object;

class HandleScope;

class HeapRoot;

}

namespace Ke {

class Function;

/*

 * A Handle is a safe pointer that holds an object reference, such that it

 * can be scanned and potentially moved by the garbage collector.

 */

template <typename T>

class Handle

{

  protected:

    template <typename S> void typeCheck() {

        while (false) {

            T *v1 = NULL;

            S *v2 = NULL;

            v1 = v2;

            (void)v1;

        }

    }

  public:

    Handle()

      : obj_(NULL)

    {

    }

    template <typename S> Handle(Handle<S> other)

      : obj_(reinterpret_cast<S *>(*other))

    {

        typeCheck<S>();

    }

    explicit Handle(T *obj)

      : obj_(obj)

    {

    }

    T *operator ->() const {

        return obj_;

    }

    T *operator *() const {

        return obj_;

    }

    operator bool () const {

        return !!obj_;

    }

  private:

    T *obj_;

};

/*

 * A local variable that roots an object. Locals are owned by the nearest

 * HandleScope, and as soon as that HandleScope dies, all its Locals are

 * no longer available.

 */

template <typename T>

class Local : public Handle<T>

{

  public:

    Local()

      : Handle<T>()

    {

    }

    template <typename S> Local(Local<S> other)

      : Handle<T>(reinterpret_cast<T *>(*other))

    {

        typeCheck<S>();

    }

    template <typename S> Local(S *other)

      : Handle<T>(other)

    {

    }

};

/*

 * A non-local variable that outlives HandleScopes. A Root is reference-

 * counted. When its reference count reaches 0, the Root is removed.

 */

template <typename T>

class Root : public Handle<T>

{

  public:

    Root()

      : Handle<T>()

    {

    }

    template <typename S> Root(const Root<S> &other)

      : Handle<T>(reinterpret_cast<T *>(*other))

    {

        typeCheck<S>();

        incref();

    }

    explicit Root(ke::HeapRoot *obj)

      : Handle<T>(reinterpret_cast<T *>(obj))

    {

        incref();

    }

    static inline Root<T> New(Handle<T> other);

    ~Root() {

        decref();

    }

    template <typename S>

    Root<T> &operator =(Root<S> other) {

        decref();

        new (this) Root<T>(other);

        return *this;

    }

  private:

    void incref();

    void decref();

};

/*

 * A HandleScope is where Local roots are allcoated. When the HandleScope

 * is destroyed, all Handles created under it are also destroyed. HandleScopes

 * may only be allocated on the stack, in LIFO order.

 */

class HandleScope

{

  protected:

    ke::Zone *zone_;

    ke::Object **position_;

    HandleScope *prev_;

    HandleScope(ke::Zone *zone, ke::Object **position, HandleScope *prev)

      : zone_(zone),

        position_(position),

        prev_(prev)

    {

    }

  public:

    HandleScope();

    ~HandleScope();

    static ke::Object **CreateHandle(ke::Object *obj);

  private:

    // Disallow silly stuff.

    HandleScope(const HandleScope &);

    void operator =(const HandleScope &);

    void *operator new (size_t size);

    void operator delete(void *, size_t);

};

// A string is an immutable UTF8 buffer.

class KE_EXPORT String

{

  public:

    // Returns the length of the string, in bytes.

    unsigned length();

    // Returns the character buffer of the string, or NULL on failure. If the

    // string is interned, chars() is guaranteed to succeed.

    const char *chars();

};

// A function is an executable unit of code.

class KE_EXPORT Function

{

  public:

    // Returns the name of a function, which may be NULL. If not NULL, the

    // string is guaranteed to be interned/

    Local<String> name();

};

// A module represents a single compiled file, and contains functions and

// global variables for that file (as well as exported types).

class KE_EXPORT Module

{

  public:

    // Returns publics that are based on forwards.

    unsigned numPublics();

    Local<Function> getPublic(unsigned index);

};

class Keima

{

  public:

    /*

     * Initializes the Keima engine. This must be called exactly once before any

     * other Keima functions are called. After this, it is safe to use Keima

     * on the calling thread.

     */

    static bool Initialize();

    /*

     * Shuts down the Keima engine and frees data structures on all threads.

     */

    static void Shutdown();

    /*

     * Searches the call stack and returns true if the given module has any

     * active code running. This is an O(n) algorithm.

     */

    static bool IsInCallStack(Handle<Module> module);

    /*

     * Reclaim as much memory as possible. This pauses the calling thread

     * until garbage collection completes.

     */

    static void CollectGarbage();

    /*

     * Clear any pending exception.

     */

    static void ClearPendingException();

};

/*

 * Suppresses exceptions. This is useful for calling API functions. When this

 * in scope, errors will be reported, but the exception will be cleared after.

 */

class AutoClearExceptions

{

  public:

    ~AutoClearExceptions()

    {

        Keima::ClearPendingException();

    }

};

/*

 * Compiles a file and returns a Module.

 */

extern Local<Module> Compile(const char *path);

class Internals

{

    template <typename T> friend class Root;

  private:

    static ke::HeapRoot *NewHeapRoot(ke::Object **objp);

    static void IncRef(ke::HeapRoot *root);

    static void DecRef(ke::HeapRoot *root);

};

template <typename T> Root<T>

Root<T>::New(Handle<T> other)

{

    if (!other)

        return Root<T>(NULL);

    ke::Object **ptr = reinterpret_cast<ke::Object **>(*other);

    return Root<T>(Internals::NewHeapRoot(ptr));

}

template <typename T> void

Root<T>::incref()

{

    if (!*this)

        return;

    ke::HeapRoot *ptr = reinterpret_cast<ke::HeapRoot *>(**this);

    Internals::IncRef(ptr);

}

template <typename T> void

Root<T>::decref()

{

    if (!*this)

        return;

    ke::HeapRoot *ptr = reinterpret_cast<ke::HeapRoot *>(**this);

    Internals::DecRef(ptr);

}

}

#endif // _include_sourcepawn3_api_h_