/*

 * 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>

namespace ke {

class Zone;

class Object;

class HandleScope;

class HeapRoot;

}

namespace Ke {

/*

 * 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);

};

class Module;

/*

 * 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.

 */

extern bool Initialize();

/*

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

 */

extern void Shutdown();

/*

 * 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_