JSRootingGuide: main.cpp

#include <fstream>
#include <iostream>
#include <memory>

#include "SpiderMonkeyInclude.h"

using namespace std;

class CTestClassBase
{
public:
    CTestClassBase(JSRuntime* rt, JSContext* cx) : m_rt(rt), m_cx(cx) {}

protected:

    JSObject* InitObjectInternal()
    {
        //objStack.set(JS_NewObject(m_cx, nullptr, JS::NullPtr(), JS::NullPtr()));
        JS::RootedObject obj(m_cx, JS_NewObject(m_cx, nullptr, JS::NullPtr(), JS::NullPtr()));
        JS::RootedValue intVal(m_cx, JS::Int32Value(0));
        JS_SetProperty(m_cx, obj, "useCounter", intVal);
        return obj.get();
    }

    void PrintUsecountBase(JS::HandleObject objStack)
    {
        int32_t tmpCounter;
        JS::RootedValue counterValStack(m_cx);

        if (!JS_GetProperty(m_cx, objStack, "useCounter", &counterValStack))
            cerr << "Error: JS_GetProperty on m_HeapValue for property useCounter failed!" << endl;

        if (!JS::ToInt32(m_cx, counterValStack, &tmpCounter))
            cerr << "Error in JS::ToInt32!" << endl;

        cout << "function has alread been called " << tmpCounter++ << " times." << endl;

        JS::RootedValue tmpCounterVal(m_cx, JS::Int32Value(tmpCounter));
        JS_SetProperty(m_cx, objStack, "useCounter", tmpCounterVal);
    }

    JSRuntime* m_rt;
    JSContext* m_cx;
};

#include "HeapRootingTest.h"

JSRuntime *rt = NULL;
std::shared_ptr<CHeapRootingTest> g_HeapRootingTest;

/* The class of the global object. */
static JSClass global_class = { "global", JSCLASS_GLOBAL_FLAGS,
JS_PropertyStub, JS_DeletePropertyStub,
JS_PropertyStub, JS_StrictPropertyStub,
JS_EnumerateStub, JS_ResolveStub, JS_ConvertStub,
nullptr, nullptr, nullptr, nullptr,
JS_GlobalObjectTraceHook };

void reportError(JSContext *cx, const char *message, JSErrorReport *report) {
     fprintf(stderr, "%s:%u:%s\n",
             report->filename ? report->filename : "<no filename="">",
             (unsigned int) report->lineno,
             message);
}

const char* readFile(const char*);
void loadScript(JSContext* cx, JS::HandleObject global);
bool myjs_print(JSContext *cx, uint32_t argc, jsval *vp);
bool myjs_heapExample(JSContext *cx, uint32_t argc, jsval *vp);

static JSClass test_class = { "testclass", 0,
JS_PropertyStub, JS_DeletePropertyStub,
JS_PropertyStub, JS_StrictPropertyStub,
JS_EnumerateStub, JS_ResolveStub,
JS_ConvertStub,
JSCLASS_NO_OPTIONAL_MEMBERS };

JSFunctionSpec myjs_global_functions[] = {
    JS_FS("print",   &(myjs_print),   1, 0),
    JS_FS("heapExample", &(myjs_heapExample), 0, 0),
    JS_FS_END
};

void bar(JS::Value val)
{
}

void foo(JSContext* cx, JS::HandleValue handleVal, JS::MutableHandleValue mutableHandleVal)
{
    JS::RootedValue val(cx);
    bar(val);
    bar(handleVal);
    bar(mutableHandleVal);
}

int run(JSContext *cx) {
    /* Enter a request before running anything in the context */
    JSAutoRequest ar(cx);

    /* Create the global object in a new compartment. */
    JS::RootedObject global(cx, JS_NewGlobalObject(cx, &global_class, nullptr, JS::FireOnNewGlobalHook));
    if (!global)
    return 1;

    /* Set the context's global */
    JSAutoCompartment ac(cx, global);

    /* Populate the global object with the standard globals, like Object and Array. */
    if (!JS_InitStandardClasses(cx, global))
    return 1;

    /* Your application code here. This may include JSAPI calls to create your own custom JS objects and run scripts. */
    JS_DefineFunctions(cx, global, myjs_global_functions);
    g_HeapRootingTest.reset(new CHeapRootingTest(rt, cx));

    loadScript(cx, global);

    /* Application code end */

    return 0;
}

int main(int argc, const char *argv[]) {
    /* Initialize the JS engine -- new/required as of SpiderMonkey 31. */
    if (!JS_Init())
    return 1;

    /* Create a JS runtime. */
    rt = JS_NewRuntime(8L * 1024L * 1024L, JS_NO_HELPER_THREADS);
    if (!rt)
    return 1;

    /* Create a context. */
    JSContext *cx = JS_NewContext(rt, 8192);
    if (!cx)
    return 1;

    JS_SetErrorReporter(cx, reportError);

    int status = run(cx);

    JS_GC(rt);
    g_HeapRootingTest.reset();
    JS_DestroyContext(cx);
    JS_DestroyRuntime(rt);

    /* Shut down the JS engine. */
    JS_ShutDown();

    int x=0;
    cin >> x;
}

void loadScript(JSContext* cx, JS::HandleObject global)
{
    const char* script = readFile("../../test.js");
    bool ok;
    const char *filename = "test.js";
    unsigned lineno = 0;

    JSAutoRequest rq(cx);
    ok = JS_EvaluateScript(cx, global, script, strlen(script), filename, lineno);
}

const char* readFile(const char* scriptFile)
{
    ifstream file;
    char* content;
    int length;

    file.open(scriptFile, ifstream::in);

    // get length of file:
    file.seekg (0, ios::end);
    length = file.tellg();
    file.seekg (0, ios::beg);

    // allocate memory (+1 for null-termination)
    content = new char[length+1];
    file.read(content, length);
    file.close();
    content[length] = '\0';

    return content;
}

/**
 * The function prints a counter how often it has been called already.
 * This counter gets stored as a JS value on the heap.
 * It's used to test some assumptions about rooting on the heap because the documentation lacks a bit.
 */

bool myjs_heapExample(JSContext *cx, uint32_t argc, jsval *vp)
{
    g_HeapRootingTest->PrintUsecount();
    return true;
}

bool myjs_print(JSContext *cx, uint32_t argc, jsval *vp)
{
    JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
    JS::CallReceiver rec = JS::CallReceiverFromVp(vp);

    JS::RootedString str(cx, args[0].toString());
    char* text = JS_EncodeString(cx, str);

    cout << text << endl;

    rec.rval().set(JSVAL_VOID);  // return undefined

    return true;
}