lib/pnacl.nit

   1 # This file is part of NIT ( http://www.nitlanguage.org ).
   2 #
   3 # Copyright 2014 Johan Kayser <kayser.johan@gmail.com>
   4 #
   5 # Licensed under the Apache License, Version 2.0 (the "License");
   6 # you may not use this file except in compliance with the License.
   7 # You may obtain a copy of the License at
   8 #
   9 #     http://www.apache.org/licenses/LICENSE-2.0
  10 #
  11 # Unless required by applicable law or agreed to in writing, software
  12 # distributed under the License is distributed on an "AS IS" BASIS,
  13 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 # See the License for the specific language governing permissions and
  15 # limitations under the License.
  16 #
  17 # Targets the PNaCl platform
  18 #
  19 # To use this module and compile for PNaCl, you must install the
  20 # NaCl SDK (This file is based on Pepper 33).
  21 # If NACL_SDK_ROOT is not set in your PATH, you have to work in
  22 # 'nacl_sdk/pepper_your_pepper_version/getting_started/your_project_folder'.
  23 #
  24 # Provides PNaCl support for Nit.
  25 module pnacl is platform
  26 `{
  27         #include <unistd.h>
  28         #include <stddef.h>
  29         #include <stdio.h>
  30         #include <string.h>
  31         #include <stdlib.h>
  32         #include <pthread.h>
  33         #include "ppapi/c/pp_errors.h"
  34         #include "ppapi/c/ppp.h"
  35         #include "ppapi/c/ppp_instance.h"
  36         #include "ppapi/c/pp_bool.h"
  37         #include "ppapi/c/ppb_var.h"
  38         #include "ppapi/c/ppb_messaging.h"
  39         #include "ppapi/c/ppp_messaging.h"
  40         #include "ppapi/c/ppb_var_dictionary.h"
  41         #include "ppapi/c/ppb_var_array.h"
  42
  43         #define MAX_DICTIONARY_QUEUE_SIZE 200
  44         #define MAX_MESSAGE_QUEUE_SIZE 10
  45
  46         extern int nit_main(int, char**);
  47
  48         /* A working thread for Nit. */
  49         static pthread_t g_nit_thread;
  50
  51         /* Mutex that guards the queues. */
  52         static pthread_mutex_t g_dictionary_queue_mutex;
  53         static pthread_mutex_t g_message_queue_mutex;
  54
  55         /* Condition variables that are signalled when the queues are not empty. */
  56         static pthread_cond_t g_dictionary_queue_not_empty_cond;
  57         static pthread_cond_t g_message_queue_not_empty_cond;
  58
  59         /** Circular queues of dictionaries and messages from JavaScript to be handled.
  60          *
  61          * If g_queue_start < g_queue_end:
  62          *   all elements in the range [g_queue_start, g_queue_end) are valid.
  63          * If g_queue_start > g_queue_end:
  64          *   all elements in the ranges [0, g_queue_end) and
  65          *   [g_queue_start, MAX_QUEUE_SIZE) are valid.
  66          * If g_queue_start == g_queue_end, and g_queue_size > 0:
  67          *   all elements in the g_queue are valid.
  68          * If g_queue_start == g_queue_end, and g_queue_size == 0:
  69          *   No elements are valid. */
  70         static struct PP_Var g_dictionary_queue[MAX_DICTIONARY_QUEUE_SIZE];
  71         static char* g_message_queue[MAX_MESSAGE_QUEUE_SIZE];
  72
  73         /* The index of the head of the queues. */
  74         static int g_dictionary_queue_start = 0;
  75         static int g_message_queue_start = 0;
  76
  77         /* The index of the tail of the queues, non-inclusive. */
  78         static int g_dictionary_queue_end = 0;
  79         static int g_message_queue_end = 0;
  80
  81         /* The size of the queues. */
  82         static int g_dictionary_queue_size = 0;
  83         static int g_message_queue_size = 0;
  84
  85         /* PNaCl interfaces. */
  86         const PPB_Messaging* g_varMessagingInterface;
  87         const PPB_Var* g_varInterface;
  88         const PPB_VarDictionary* g_varDictionaryInterface;
  89         const PPB_VarArray* g_varArrayInterface;
  90
  91         PP_Instance g_instance;
  92         PnaclApp app;
  93
  94         /* A wrapper to launch the Nit main on a new thread. */
  95         void* WrapperNitMain(void* arg) {
  96                 nit_main(0, NULL);
  97                 return NULL;
  98         }
  99
 100         /** Return whether the queues are empty.
 101          *
 102          * NOTE: this function assumes g_queue_mutex lock is held.
 103          * @return non-zero if the queue is empty. */
 104         static int IsDictionaryQueueEmpty() { return g_dictionary_queue_size == 0; }
 105         static int IsMessageQueueEmpty() { return g_message_queue_size == 0; }
 106
 107         /** Return whether the queues are full.
 108          *
 109          * NOTE: this function assumes g_queue_mutex lock is held.
 110          * @return non-zero if the queue is full. */
 111         static int IsDictionaryQueueFull() { return g_dictionary_queue_size == MAX_DICTIONARY_QUEUE_SIZE; }
 112         static int IsMessageQueueFull() { return g_message_queue_size == MAX_MESSAGE_QUEUE_SIZE; }
 113
 114         /* Initialize the queues. */
 115         void InitializeQueues() {
 116             pthread_mutex_init(&g_dictionary_queue_mutex, NULL);
 117             pthread_cond_init(&g_dictionary_queue_not_empty_cond, NULL);
 118             pthread_mutex_init(&g_message_queue_mutex, NULL);
 119             pthread_cond_init(&g_message_queue_not_empty_cond, NULL);
 120         }
 121
 122         /** Enqueue a dictionary (i.e. add to the end)
 123          *
 124          * If the queue is full, the dictionary will be dropped.
 125          *
 126          * NOTE: this function assumes g_dictionary_queue_mutex is _NOT_ held.
 127          * @param[in] dictionary, the dictionary to enqueue.
 128          * @return non-zero if the dictionary was added to the queue. */
 129         int EnqueueDictionary(struct PP_Var dictionary) {
 130             pthread_mutex_lock(&g_dictionary_queue_mutex);
 131
 132           /* We shouldn't block the main thread waiting for the queue to not be full,
 133            * so just drop the dictionary. */
 134             if (IsDictionaryQueueFull()) {
 135                 pthread_mutex_unlock(&g_dictionary_queue_mutex);
 136                 return 0;
 137             }
 138
 139             g_dictionary_queue[g_dictionary_queue_end] = dictionary;
 140             g_dictionary_queue_end = (g_dictionary_queue_end + 1) % MAX_DICTIONARY_QUEUE_SIZE;
 141             g_dictionary_queue_size++;
 142
 143             pthread_cond_signal(&g_dictionary_queue_not_empty_cond);
 144
 145             pthread_mutex_unlock(&g_dictionary_queue_mutex);
 146
 147             return 1;
 148         }
 149
 150         /** Enqueue a message (i.e. add to the end)
 151          *
 152          * If the queue is full, the message will be dropped.
 153          *
 154          * NOTE: this function assumes g_message_queue_mutex is _NOT_ held.
 155          * @param[in] message The message to enqueue.
 156          * @return non-zero if the message was added to the queue. */
 157         int EnqueueMessage(char* message) {
 158             pthread_mutex_lock(&g_message_queue_mutex);
 159
 160           /* We shouldn't block the main thread waiting for the queue to not be full,
 161            * so just drop the message. */
 162             if (IsMessageQueueFull()) {
 163                 pthread_mutex_unlock(&g_message_queue_mutex);
 164                 return 0;
 165             }
 166
 167             g_message_queue[g_message_queue_end] = message;
 168             g_message_queue_end = (g_message_queue_end + 1) % MAX_MESSAGE_QUEUE_SIZE;
 169             g_message_queue_size++;
 170
 171             pthread_cond_signal(&g_message_queue_not_empty_cond);
 172
 173             pthread_mutex_unlock(&g_message_queue_mutex);
 174
 175             return 1;
 176         }
 177
 178         /** Dequeue a dictionary and return it.
 179          *
 180          * This function blocks until a dictionary is available. It should not be called
 181          * on the main thread.
 182          *
 183          * NOTE: this function assumes g_dictionary_queue_mutex is _NOT_ held.
 184          * @return The dictionary at the head of the queue. */
 185         struct PP_Var DequeueDictionary() {
 186             struct PP_Var dictionary = g_varDictionaryInterface->Create();
 187
 188             pthread_mutex_lock(&g_dictionary_queue_mutex);
 189
 190             while (IsDictionaryQueueEmpty()) {
 191                 pthread_cond_wait(&g_dictionary_queue_not_empty_cond, &g_dictionary_queue_mutex);
 192             }
 193
 194             dictionary = g_dictionary_queue[g_dictionary_queue_start];
 195             g_dictionary_queue_start = (g_dictionary_queue_start + 1) % MAX_DICTIONARY_QUEUE_SIZE;
 196             g_dictionary_queue_size--;
 197
 198             pthread_mutex_unlock(&g_dictionary_queue_mutex);
 199
 200             return dictionary;
 201         }
 202
 203         /** Dequeue a message and return it.
 204          *
 205          * This function blocks until a message is available. It should not be called
 206          * on the main thread.
 207          *
 208          * NOTE: this function assumes g_queue_mutex is _NOT_ held.
 209          * @return The message at the head of the queue. */
 210         char* DequeueMessage() {
 211             char* message = NULL;
 212
 213             pthread_mutex_lock(&g_message_queue_mutex);
 214
 215             while (IsMessageQueueEmpty()) {
 216                 pthread_cond_wait(&g_message_queue_not_empty_cond, &g_message_queue_mutex);
 217             }
 218
 219             message = g_message_queue[g_message_queue_start];
 220             g_message_queue_start = (g_message_queue_start + 1) % MAX_MESSAGE_QUEUE_SIZE;
 221             g_message_queue_size--;
 222
 223             pthread_mutex_unlock(&g_message_queue_mutex);
 224
 225             return message;
 226         }
 227
 228         /* Posts a string message to JS. */
 229         void PostMessage(char* message) {
 230             /* Create PP_Var containing the message body. */
 231             struct PP_Var varString = g_varInterface->VarFromUtf8(message, strlen(message));
 232
 233             /* Post message to the JavaScript layer. */
 234             g_varMessagingInterface->PostMessage(g_instance, varString);
 235         }
 236
 237         /* Posts a Dictionary (JS like object) to JS. */
 238         void PostDictionary(struct PP_Var dictionary) {
 239             g_varMessagingInterface->PostMessage(g_instance, dictionary);
 240         }
 241
 242         /* Posts a Variable (aka PepperVar) to JS.
 243            Should only be used for testing, conventional conversation is made
 244            with Strings or Dictionaries. */
 245         void PostVar(struct PP_Var v) {
 246             g_varMessagingInterface->PostMessage(g_instance, v);
 247         }
 248
 249         /* char* to PP_Var. */
 250         static struct PP_Var CStrToVar(const char* str) {
 251             if (g_varInterface != NULL) {
 252                 return g_varInterface->VarFromUtf8(str, strlen(str));
 253             }
 254             return PP_MakeUndefined();
 255         }
 256
 257         static PP_Bool Instance_DidCreate(PP_Instance instance, uint32_t argc, const char* argn[], const char* argv[]) {
 258             g_instance = instance;
 259
 260             /* Initialization of the queues and creation of the thread for Nit. */
 261             InitializeQueues();
 262             pthread_create(&g_nit_thread, NULL, &WrapperNitMain, NULL);
 263
 264             return PP_TRUE;
 265         }
 266
 267         static void Instance_DidDestroy(PP_Instance instance) {
 268                 // TODO
 269         }
 270
 271         static void Instance_DidChangeView(PP_Instance pp_instance, PP_Resource view) {
 272                 // TODO
 273         }
 274
 275         static void Instance_DidChangeFocus(PP_Instance pp_instance, PP_Bool has_focus) {
 276                 // TODO
 277         }
 278
 279         static PP_Bool Instance_HandleDocumentLoad(PP_Instance pp_instance, PP_Resource pp_url_loader) {
 280                 // TODO
 281                 return PP_FALSE;
 282         }
 283
 284         /* Called when JS sends something, is set to accept Strings or Dictionaries,
 285            returns an error if received object is not a String or Dictionary. */
 286         void Messaging_HandleMessage(PP_Instance instance, struct PP_Var varMessage) {
 287             if(varMessage.type == PP_VARTYPE_DICTIONARY) {
 288                 if(!EnqueueDictionary(varMessage)) {
 289                         struct PP_Var errorMessage = CStrToVar("QueueFull : dropped dictionary because the queue was full.");
 290                         g_varMessagingInterface->PostMessage(g_instance, errorMessage);
 291                 }
 292             }
 293             else if(varMessage.type == PP_VARTYPE_STRING) {
 294                 uint32_t len;
 295                 char* message = (char*)g_varInterface->VarToUtf8(varMessage, &len);
 296                 if(!EnqueueMessage(message)) {
 297                         struct PP_Var errorMessage = CStrToVar("QueueFull : dropped message because the queue was full.");
 298                         g_varMessagingInterface->PostMessage(g_instance, errorMessage);
 299                 }
 300             }
 301             else {
 302                 struct PP_Var errorMessage = CStrToVar("TypeError : only accepts JS objects or Strings");
 303                 g_varMessagingInterface->PostMessage(g_instance, errorMessage);
 304             }
 305         }
 306
 307         /* This function is called by Nit when using check_dictionary,
 308         returns the dictionary at the head of the queue. */
 309         void* NitHandleDictionary() {
 310                 while(1) {
 311                         struct PP_Var dictionary = DequeueDictionary();
 312                         PnaclApp_handle_dictionary(app, &dictionary);
 313                 }
 314         }
 315
 316         /* This function is called By Nit when waiting for a user input. */
 317         char* NitHandleMessage() {
 318                 while(1) {
 319                         return DequeueMessage();
 320                 }
 321         }
 322
 323         /* Entry point */
 324         PP_EXPORT int32_t PPP_InitializeModule(PP_Module module_id, PPB_GetInterface get_browser_interface) {
 325             /* Initializing global pointers. */
 326             g_varMessagingInterface = (const PPB_Messaging*) get_browser_interface(PPB_MESSAGING_INTERFACE);
 327             g_varInterface = (const PPB_Var*) get_browser_interface(PPB_VAR_INTERFACE);
 328             g_varDictionaryInterface = (const PPB_VarDictionary*) get_browser_interface(PPB_VAR_DICTIONARY_INTERFACE);
 329             g_varArrayInterface = (const PPB_VarArray*) get_browser_interface(PPB_VAR_ARRAY_INTERFACE);
 330             return PP_OK;
 331         }
 332
 333         PP_EXPORT void PPP_ShutdownModule() {
 334                 // TODO
 335         }
 336
 337         PP_EXPORT const void* PPP_GetInterface(const char* interface_name) {
 338             if (strcmp(interface_name, PPP_INSTANCE_INTERFACE) == 0)
 339             {
 340                 static PPP_Instance instance_interface = {
 341                     &Instance_DidCreate,
 342                     &Instance_DidDestroy,
 343                     &Instance_DidChangeView,
 344                     &Instance_DidChangeFocus,
 345                     &Instance_HandleDocumentLoad
 346                 };
 347                 return &instance_interface;
 348             }
 349             else if (strcmp(interface_name, PPP_MESSAGING_INTERFACE) == 0) {
 350                 static PPP_Messaging messaging_interface = {
 351                         &Messaging_HandleMessage
 352                 };
 353                 return &messaging_interface;
 354             }
 355             return NULL;
 356         }
 357
 358         /* Hack in order to avoid the problem with file. */
 359         int poll(void *fds, int nfds, int timeout) { return 0; }
 360 `}
 361
 362 # Nit class representing a Pepper C API PP_Var typed as a Dictionary.
 363 extern class PepperDictionary `{ struct PP_Var* `}
 364
 365         new `{
 366                 struct PP_Var* recv = malloc( sizeof( struct PP_Var ) );
 367                 *recv = g_varDictionaryInterface->Create();
 368                 return recv;
 369         `}
 370
 371         # Get fonction using PepperVars.
 372         #
 373         # Returns the value that is associated with 'key'.
 374         # If 'key' is not a String typed PepperVar, or doesn't exist in the Dictionary, an undefined PepperVar is returned.
 375         fun native_get(key: PepperVar): PepperVar `{
 376                 struct PP_Var* value = malloc( sizeof ( struct PP_Var ) );
 377                 *value = g_varDictionaryInterface->Get(*recv, *key);
 378                 return value;
 379         `}
 380
 381         # Returns the value associated with 'key'.
 382         #
 383         # 'key' must be a String.
 384         # If 'key' is not a String or doesn't exist in the Dictionary, 'null' is returned.
 385         fun [](key: nullable Pepperable): nullable Pepperable
 386         do
 387                 var native_key = key.to_pepper
 388                 var native_value = native_get(native_key)
 389                 return native_value.to_nit
 390         end
 391
 392         # Set function using PepperVars.
 393         #
 394         # Sets the value associated with the specified key.
 395         # 'key' must be a String typed PepperVar.
 396         # If 'key' hasn't existed in the Dictionary, it is added and associated with 'value'.
 397         # Otherwise, the previous value is replaced with 'value'.
 398         # Returns a Boolean indicating whether the operation succeeds.
 399         fun native_set(key: PepperVar, value: PepperVar): Bool `{
 400                 PP_Bool b;
 401                 b = g_varDictionaryInterface->Set(*recv, *key, *value);
 402                 return b;
 403         `}
 404
 405         # Sets the value associated with the specified key.
 406         #
 407         # 'key' must be a String.
 408         # If 'key' hasn't existed in the Dictionary, it is added and associated with 'value'.
 409         # Otherwise, the previous value is replaced with 'value'.
 410         # Returns a Boolean indicating whether the operation succeeds.
 411         fun []=(key: nullable Pepperable, value: nullable Pepperable): Bool
 412         do
 413                 var native_key = key.to_pepper
 414                 var native_value = value.to_pepper
 415                 return native_set(native_key, native_value)
 416         end
 417
 418         # Deletes the specified key and its associated value, if the key exists.
 419         #
 420         # Takes a String typed PepperVar.
 421         fun native_delete(key: PepperVar) `{
 422                 g_varDictionaryInterface->Delete(*recv, *key);
 423         `}
 424
 425         # Deletes the specified key and its associated value, if the key exists.
 426         #
 427         # Takes a String.
 428         fun delete(key: String)
 429         do
 430                 var native_key = key.to_pepper
 431                 native_delete native_key
 432         end
 433
 434         # Checks whether a key exists.
 435         #
 436         # Takes a String typed PepperVar.
 437         fun native_has_key(key: PepperVar): Bool `{
 438                 PP_Bool b;
 439                 b = g_varDictionaryInterface->HasKey(*recv, *key);
 440                 return b;
 441         `}
 442
 443         # Checks whether a key exists.
 444         #
 445         # Takes a String.
 446         fun has_key(key: String): Bool
 447         do
 448                 var native_key = key.to_pepper
 449                 return native_has_key(native_key)
 450         end
 451
 452         # Gets all the keys in a dictionary.
 453         #
 454         # Returns a PepperArray which contains all the keys of the Dictionary. The elements are string vars.
 455         fun get_keys: PepperArray `{
 456                 struct PP_Var* array = malloc( sizeof( struct PP_Var ) );
 457                 *array = g_varDictionaryInterface->GetKeys(*recv);
 458                 return array;
 459         `}
 460
 461         # Use this function to copy a dictionary.
 462         fun copy: PepperDictionary `{
 463                 struct PP_Var* varDictionary = malloc( sizeof( struct PP_Var ) );
 464                 *varDictionary = g_varDictionaryInterface->Create();
 465                 *varDictionary = *recv;
 466                 return varDictionary;
 467         `}
 468 end
 469
 470 # Nit class representing a Pepper C API PP_Var typed as an Array.
 471 extern class PepperArray `{ struct PP_Var* `}
 472
 473         new `{
 474                 struct PP_Var* recv = malloc( sizeof( struct PP_Var ) );
 475                 *recv = g_varArrayInterface->Create();
 476                 return recv;
 477         `}
 478
 479         # Returns the element at the specified position as a PepperVar.
 480         #
 481         # If 'index' is larger than or equal to the array length, an undefined PepperVar is returned.
 482         fun native_get(index: Int): PepperVar `{
 483                 struct PP_Var* value = malloc( sizeof( struct PP_Var ) );
 484                 *value = g_varArrayInterface->Get(*recv, index);
 485                 return value;
 486         `}
 487
 488         # Returns the element at the specified position.
 489         #
 490         # If 'index' is larger than or equal to the array length, 'null' is returned.
 491         fun [](index: Int): nullable Pepperable
 492         do
 493                 var native_value = native_get(index)
 494                 return native_value.to_nit
 495         end
 496
 497         # Returns an int containing the length of the PepperArray.
 498         fun length: Int `{
 499                 int length = g_varArrayInterface->GetLength(*recv);
 500                 return length;
 501         `}
 502
 503         # Takes a PepperVar for the 'value' param.
 504         #
 505         # Sets the value of an element in the array at indicated index.
 506         # If 'index' is larger than or equal to the array length, the length is updated to be 'index' + 1.
 507         # Any position in the array that hasn't been set before is set to undefined, i.e., PepperVar of C type PP_VARTYPE_UNDEFINED.
 508         # Returns a Boolean indicating whether the operation succeeds.
 509         fun native_set(index: Int, value: PepperVar): Bool `{
 510                 PP_Bool b;
 511                 b = g_varArrayInterface->Set(*recv, index, *value);
 512                 return b;
 513         `}
 514
 515         # Sets the value of an element in the array at indicated index.
 516         #
 517         # If 'index' is larger than or equal to the array length, the length is updated to be 'index' + 1.
 518         # Any position in the array that hasn't been set before is set to undefined, i.e., PepperVar of C type PP_VARTYPE_UNDEFINED.
 519         # Returns a Boolean indicating whether the operation succeeds.
 520         fun []=(index: Int, value: nullable Pepperable): Bool
 521         do
 522                 var native_value = value.to_pepper
 523                 return native_set(index, native_value)
 524         end
 525
 526         # Sets the array length.
 527         #
 528         # If 'length' is smaller than its current value, the array is truncated to the new length.
 529         # Any elements that no longer fit are removed and the references to them will be released.
 530         # If 'length' is larger than its current value, undefined PepperVars are appended to increase the array to the specified length.
 531         # Returns a Boolean indicating whether the operation succeeds.
 532         fun length=(length: Int): Bool `{
 533                 PP_Bool b;
 534                 b = g_varArrayInterface->SetLength(*recv, length);
 535                 return b;
 536         `}
 537 end
 538
 539 # Nit class representing a Pepper C API PP_Var.
 540 extern class PepperVar `{ struct PP_Var* `}
 541
 542         new `{
 543                 return malloc( sizeof( struct PP_Var ) );
 544         `}
 545
 546         # Converts PepperVar to standard types.
 547         #
 548         # Actually supports bools, ints, floats, strings. To be used with 'isa'.
 549         fun to_nit: nullable Pepperable
 550         do
 551                 if isa_null then return null
 552                 if isa_bool then return as_bool
 553                 if isa_int then return as_int
 554                 if isa_float then return as_float
 555                 if isa_string then return as_string
 556                 if is_undefined then return null
 557
 558                 return null
 559         end
 560
 561         private fun isa_null: Bool `{ return recv->type == PP_VARTYPE_NULL; `}
 562         private fun isa_bool: Bool `{ return recv->type == PP_VARTYPE_BOOL; `}
 563         private fun isa_int: Bool `{ return recv->type == PP_VARTYPE_INT32; `}
 564         private fun isa_float: Bool `{ return recv->type == PP_VARTYPE_DOUBLE; `}
 565         private fun isa_string: Bool `{ return recv->type == PP_VARTYPE_STRING; `}
 566         private fun is_undefined: Bool `{ return recv->type == PP_VARTYPE_UNDEFINED; `}
 567
 568         private fun as_bool: Bool `{ return recv->value.as_bool; `}
 569         private fun as_int: Int `{ return recv->value.as_int; `}
 570         private fun as_float: Float `{ return recv->value.as_double; `}
 571         private fun as_string: String import NativeString.to_s_with_length `{
 572                 uint32_t len;
 573                 char* str = (char*)g_varInterface->VarToUtf8(*recv, &len);
 574                 return NativeString_to_s_with_length(str, len);
 575         `}
 576 end
 577
 578 # Provides a method to convert in PepperVars.
 579 interface Pepperable
 580         fun to_pepper: PepperVar is abstract
 581 end
 582
 583 redef class Int
 584         super Pepperable
 585
 586         # Converts a Int into a PepperVar with Int type.
 587         redef fun to_pepper `{
 588                 struct PP_Var* var = malloc( sizeof( struct PP_Var ) );
 589                 *var = PP_MakeInt32(recv);
 590                 return var;
 591         `}
 592 end
 593
 594 redef class Float
 595         super Pepperable
 596
 597         # Converts a Float into a PepperVar with Float type.
 598         redef fun to_pepper `{
 599                 struct PP_Var* var = malloc( sizeof( struct PP_Var ) );
 600                 *var = PP_MakeDouble(recv);
 601                 return var;
 602         `}
 603 end
 604
 605 redef class Bool
 606         super Pepperable
 607
 608         # Converts a Bool into a PepperVar with Bool type.
 609         redef fun to_pepper `{
 610                 struct PP_Var* var = malloc( sizeof( struct PP_Var ) );
 611                 *var = PP_MakeBool(recv);
 612                 return var;
 613         `}
 614 end
 615
 616 redef class String
 617         super Pepperable
 618
 619         # Converts a String into a PepperVar with String type.
 620         redef fun to_pepper: PepperVar import String.to_cstring, String.length `{
 621                 char *str = String_to_cstring(recv);
 622                 struct PP_Var* var = malloc( sizeof( struct PP_Var ) );
 623                 *var = g_varInterface->VarFromUtf8(str, String_length(recv));
 624                 return var;
 625         `}
 626 end
 627
 628 # A stream for PNaCl, redefines basic input and output methods.
 629 class PnaclStream
 630         super PollableIStream
 631         super OStream
 632         super BufferedIStream
 633
 634         init do prepare_buffer(10)
 635
 636         redef var end_reached: Bool = false
 637
 638         redef fun eof do return end_reached
 639
 640         # write method sends now a message to JS.
 641         redef fun write(s: Text)
 642         do
 643                 app.post_message s.to_s
 644         end
 645
 646         redef fun is_writable: Bool do return true
 647
 648         # Checks if there is a message in the queue, and if so the message is handled automatically.
 649         fun check_message: NativeString `{
 650                 return NitHandleMessage();
 651         `}
 652
 653         # fill_buffer now checks for a message in the message queue which is filled by user inputs.
 654         redef fun fill_buffer
 655         do
 656                 _buffer.clear
 657                 _buffer_pos = 0
 658                 _buffer.append check_message.to_s
 659         end
 660 end
 661
 662 # For a PNaCl app, Sys uses PnaclStreams.
 663 redef class Sys
 664         fun pnacl_stdstr: PnaclStream do return once new PnaclStream
 665
 666         # NaCl input.
 667         redef fun stdin do return pnacl_stdstr
 668
 669         # NaCl output.
 670         redef fun stdout do return pnacl_stdstr
 671
 672         # NaCl output for errors.
 673         redef fun stderr do return pnacl_stdstr
 674 end
 675
 676 # Class that provides the tools to interact with PNaCl.
 677 class PnaclApp
 678
 679         # Sets everything up to work, need to be called at first.
 680         fun initialize import PnaclApp.handle_message, PnaclApp.handle_dictionary, NativeString.to_s_with_length `{
 681                 app = recv;
 682         `}
 683
 684         # Posts a message to JS.
 685         fun post_message(message: String) import String.to_cstring `{
 686                 char* str = String_to_cstring(message);
 687                 PostMessage(str);
 688         `}
 689
 690         # Posts a dictionary to JS.
 691         fun post_dictionary(dictionary: PepperDictionary) `{
 692                 PostDictionary(*dictionary);
 693         `}
 694
 695         # Posts a PepperVar to JS.
 696         #
 697         # Should be used for testing, not recommanded for conventional conversation.
 698         private fun post_var(v: PepperVar) `{
 699                 PostVar(*v);
 700         `}
 701
 702         # Is called when a message is received from JS.
 703         #
 704         # Is set to be redefined in your application to handle like you want.
 705         fun handle_message(message: String)
 706         do
 707                 # To be Implemented by user.
 708         end
 709
 710         # Is called when a Dictionary is received from JS.
 711         #
 712         # Is set to be redefined in your application to handle like you want.
 713         # The dictionary is freed after this method returns.
 714         fun handle_dictionary(dictionary: PepperDictionary)
 715         do
 716                 # To be Implemented by user.
 717         end
 718
 719         # Checks if there is a dictionary in the queue, and if so the dictionary is handled automatically.
 720         fun check_dictionary `{
 721                 while(1) {
 722                         NitHandleDictionary();
 723                 }
 724         `}
 725 end
 726 fun app: PnaclApp do return once new PnaclApp