nxtOSEK/lejos_nxj/src/nxtvm/platform/unix/nativeemul.c

   1 /**
   2  * nativeemul.c
   3  * Native method handling for unix_impl (emulation).
   4  */
   5 #include <stdio.h>
   6 #include <stdlib.h>
   7 #include <strings.h>
   8 #include "types.h"
   9 #include "trace.h"
  10 #include "constants.h"
  11 #include "specialsignatures.h"
  12 #include "specialclasses.h"
  13 #include "stack.h"
  14 #include "memory.h"
  15 #include "threads.h"
  16 #include "classes.h"
  17 #include "language.h"
  18 #include "configure.h"
  19 #include "interpreter.h"
  20 #include "exceptions.h"
  21 #include "platform_config.h"
  22 #include "sensors.h"
  23 #include "poll.h"
  24
  25 static TWOBYTES gSensorValue = 0;
  26
  27 static char* sensorReadTypes[3] = {
  28   "RAW",
  29   "CANONICAL",
  30   "BOOLEAN"
  31 };
  32
  33 static char *sensorSetTypes[5] = {
  34   "RAW",
  35   "TOUCH",
  36   "TEMP",
  37   "LIGHT",
  38   "ROT"
  39 };
  40
  41 static char *getSensorMode(byte code)
  42 {
  43   static char smBuffer[256];
  44
  45   strcpy(smBuffer, "mode = ");
  46   switch (code & 0xF0)
  47   {
  48     case 0x00: strcat(smBuffer, "RAW"); break;
  49     case 0x20: strcat(smBuffer, "BOOLEAN"); break;
  50     case 0x40: strcat(smBuffer, "EDGE"); break;
  51     case 0x60: strcat(smBuffer, "PULSE"); break;
  52     case 0x80: strcat(smBuffer, "PERCENT"); break;
  53     case 0xA0: strcat(smBuffer, "DEGC"); break;
  54     case 0xC0: strcat(smBuffer, "DEGF"); break;
  55     case 0xE0: strcat(smBuffer, "ANGLE"); break;
  56     default: sprintf(smBuffer, "mode = INVALID (0x%1X)", code & 0xF0); break;
  57   }
  58
  59   sprintf(&smBuffer[strlen(smBuffer)], ", slope = %d", code & 0x0F);
  60   return smBuffer;
  61 }
  62
  63 extern int      verbose;        /* If non-zero, generates verbose output. */
  64 extern byte *region;
  65
  66 char *get_meaning(STACKWORD *);
  67
  68 void dump_flag(Object *obj)
  69 {
  70   if (is_allocated(obj))
  71   {
  72     if (is_gc(obj))
  73     {
  74       printf("Ready for the garbage\n");
  75     }
  76     else if (is_array(obj))
  77     {
  78       printf("Array, type=%d, length=%d\n", get_element_type(obj), get_array_length(obj));
  79     }
  80     else
  81     {
  82       printf("Class index = %d\n", get_na_class_index(obj));
  83     }
  84   }
  85   else
  86   {
  87     printf ("Free block, length=%d\n", get_free_length(obj));
  88   }
  89
  90   /**
  91    * Object/block flags.
  92    * Free block:
  93    *  -- bits 0-14: Size of free block in words.
  94    *  -- bit 15   : Zero (not allocated).
  95    * Objects:
  96    *  -- bits 0-7 : Class index.
  97    *  -- bits 8-12: Unused.
  98    *  -- bit 13   : Garbage collection mark.
  99    *  -- bit 14   : Zero (not an array).
 100    *  -- bit 15   : One (allocated).
 101    * Arrays:
 102    *  -- bits 0-8 : Array length (0-527).
 103    *  -- bits 9-12: Element type.
 104    *  -- bit 13   : Garbage collection mark.
 105    *  -- bit 14   : One (is an array).
 106    *  -- bit 15   : One (allocated).
 107    */
 108
 109 }
 110 char* string2chp(String* s)
 111 {
 112   char *ret = "null";
 113   if (s->characters)
 114   {
 115     int i;
 116     Object *obj;
 117     JCHAR *pA;
 118     int length;
 119     obj = word2obj(get_word((byte*)(&(s->characters)), 4));
 120     pA = jchar_array(obj);
 121     length = get_array_length(obj);
 122     ret = malloc(length+1);
 123     for (i=0; i<length; i++)
 124     {
 125       ret[i] = pA[i];
 126     }
 127     ret[i] = 0;
 128   }
 129
 130   return ret;
 131 }
 132
 133 /**
 134  * NOTE: The technique is not the same as that used in TinyVM.
 135  */
 136 void dispatch_native (TWOBYTES signature, STACKWORD *paramBase)
 137 {
 138         ClassRecord     *classRecord;
 139
 140   switch (signature)
 141   {
 142     case wait_4_5V:
 143       monitor_wait((Object*) word2ptr(paramBase[0]), 0);
 144       return;
 145     case wait_4J_5V:
 146       monitor_wait((Object*) word2ptr(paramBase[0]), paramBase[2]);
 147       return;
 148     case notify_4_5V:
 149       monitor_notify((Object*) word2ptr(paramBase[0]), false);
 150       return;
 151     case notifyAll_4_5V:
 152       monitor_notify((Object*) word2ptr(paramBase[0]), true);
 153       return;
 154     case start_4_5V:
 155       init_thread ((Thread *) word2ptr(paramBase[0]));
 156       return;
 157     case yield_4_5V:
 158       schedule_request( REQUEST_SWITCH_THREAD);
 159       return;
 160     case sleep_4J_5V:
 161       sleep_thread (paramBase[1]);
 162       schedule_request( REQUEST_SWITCH_THREAD);
 163       return;
 164     case getPriority_4_5I:
 165       push_word (get_thread_priority ((Thread*)word2ptr(paramBase[0])));
 166       return;
 167     case setPriority_4I_5V:
 168       {
 169         STACKWORD p = (STACKWORD)paramBase[1];
 170         if (p > MAX_PRIORITY || p < MIN_PRIORITY)
 171           throw_exception(illegalArgumentException);
 172         else
 173           set_thread_priority ((Thread*)word2ptr(paramBase[0]), p);
 174       }
 175       return;
 176     case currentThread_4_5Ljava_3lang_3Thread_2:
 177       push_ref(ptr2ref(currentThread));
 178       return;
 179     case interrupt_4_5V:
 180       interrupt_thread((Thread*)word2ptr(paramBase[0]));
 181       return;
 182     case interrupted_4_5Z:
 183       {
 184         JBYTE i = currentThread->interruptState != INTERRUPT_CLEARED;
 185         currentThread->interruptState = INTERRUPT_CLEARED;
 186         push_word(i);
 187       }
 188       return;
 189     case isInterrupted_4_5Z:
 190       push_word(((Thread*)word2ptr(paramBase[0]))->interruptState
 191                 != INTERRUPT_CLEARED);
 192       return;
 193     case setDaemon_4Z_5V:
 194       ((Thread*)word2ptr(paramBase[0]))->daemon = (JBYTE)paramBase[1];
 195       return;
 196     case isDaemon_4_5Z:
 197       push_word(((Thread*)word2ptr(paramBase[0]))->daemon);
 198       return;
 199     case join_4_5V:
 200       join_thread((Thread*)word2ptr(paramBase[0]));
 201       return;
 202     case join_4J_5V:
 203       join_thread((Thread*)word2obj(paramBase[0]));
 204       return;
 205     case exit_4I_5V:
 206       schedule_request(REQUEST_EXIT);
 207       return;
 208     case currentTimeMillis_4_5J:
 209       push_word (0);
 210       push_word (get_sys_time());
 211       return;
 212     case setPoller_4_5V:
 213       set_poller(word2ptr(paramBase[0]));
 214       return;
 215     case readSensorValue_4I_5I:
 216       // Parameters: int portId
 217       if (verbose)
 218          printf("> ");
 219       else
 220          printf("& ");
 221       printf("Reading sensor %ld, returned value %d\n",sensors[paramBase[0]].value);
 222       push_word (sensors[paramBase[0]].value);
 223       return;
 224     case setADTypeById_4II_5V:
 225       if (verbose)
 226          printf("> ");
 227       else
 228          printf("& ");
 229       printf("Setting sensor %d to AD type %d\n",paramBase[0], paramBase[1]);
 230       return;
 231     case setPowerTypeById_4II_5V:
 232        if (verbose)
 233          printf("> ");
 234       else
 235          printf("& ");
 236       printf("Setting sensor %d to power type %d\n",paramBase[0], paramBase[1]);
 237     return;
 238     case freeMemory_4_5J:
 239       push_word (0);
 240       push_word (getHeapFree());
 241       return;
 242     case totalMemory_4_5J:
 243       push_word (0);
 244       push_word (getHeapSize());
 245       return;
 246     case test_4Ljava_3lang_3String_2Z_5V:
 247       if (!paramBase[1])
 248       {
 249         printf("%s\n",string2chp((String*)word2ptr(paramBase[0])));
 250         throw_exception(error);
 251       }
 252       return;
 253     case testEQ_4Ljava_3lang_3String_2II_5V:
 254       if (paramBase[1] != paramBase[2])
 255       {
 256         printf("%s: expected %ld, got %ld\n",string2chp((String*)word2ptr(paramBase[0])), paramBase[1], paramBase[2]);
 257         throw_exception(error);
 258       }
 259       return;
 260     case floatToIntBits_4F_5I: // Fall through
 261     case intBitsToFloat_4I_5F:
 262       push_word (paramBase[0]);
 263       return;
 264     case drawString_4Ljava_3lang_3String_2II_5V:
 265       {
 266         byte *p = word2ptr(paramBase[0]);
 267         int len, i;
 268         //printf("displayString: pointer is %x\n",p);
 269         //printf("Object size is %d\n",sizeof(Object));
 270         Object *charArray = (Object *) word2ptr(get_word(p + HEADER_SIZE, 4));
 271         //printf("Chars is %x\n",charArray);
 272         len = charArray->flags.arrays.length;
 273         //printf("length is %d\n",len);
 274         {
 275          char buff[len+1];
 276          char *chars = ((char *) charArray) + HEADER_SIZE;
 277          //printf("chars is %x\n",chars);
 278          for(i=0;i<len;i++) buff[i] = chars[i+i];
 279          buff[len] = 0;
 280          if (verbose)
 281            printf("> ");
 282          else
 283            printf("& ");
 284          printf("drawString called with parameters %s,%d,%d\n",buff,paramBase[1],paramBase[2]);
 285         }
 286       }
 287       return;
 288     case drawInt_4III_5V:
 289       if (verbose)
 290          printf("> ");
 291       else
 292          printf("& ");
 293       printf("drawInt called with parameters %d, %d, %d\n",paramBase[0],paramBase[1],paramBase[2]);
 294       return;
 295     case drawInt_4IIII_5V:
 296       if (verbose)
 297          printf("> ");
 298       else
 299          printf("& ");
 300       printf("drawInt called with parameters %d, %d, %d, %d\n",paramBase[0],paramBase[1],paramBase[2],paramBase[3]);
 301     return;
 302     case controlMotorById_4III_5V:
 303       if (verbose)
 304          printf("> ");
 305       else
 306          printf("& ");
 307       printf("controlMotor called with parameters %d,%d,%d\n",paramBase[0],paramBase[1],paramBase[2]);
 308       return;
 309     case refresh_4_5V:
 310       if (verbose)
 311          printf("> ");
 312       else
 313          printf("& ");
 314       printf("Displayed Refreshed\n");
 315       return;
 316     case clear_4_5V:
 317       if (verbose)
 318          printf("> ");
 319       else
 320          printf("& ");
 321       printf("Display cleared\n");
 322       return;
 323     case setDisplay_4_1I_5V:
 324        if (verbose)
 325          printf("> ");
 326       else
 327          printf("& ");
 328       printf("Display set\n");
 329       return;
 330     case getVoltageMilliVolt_4_5I:
 331       if (verbose)
 332          printf("> ");
 333       else
 334          printf("& ");
 335       printf("getVoltageMillivolts returning 9999\n");
 336       push_word(9999);
 337       return;
 338     case readButtons_4_5I:
 339       if (verbose)
 340          printf("> ");
 341       else
 342          printf("& ");
 343       printf("readButtons returning 0\n");
 344       push_word(0);
 345       return;
 346     case getTachoCountById_4I_5I:
 347       if (verbose)
 348          printf("> ");
 349       else
 350          printf("& ");
 351       printf("getTachoCount on Motor %d returning 0\n", paramBase[0]);
 352       push_word(0);
 353       return;
 354     case resetTachoCountById_4I_5V:
 355       if (verbose)
 356          printf("> ");
 357       else
 358          printf("& ");
 359       printf("resetTachoCount on Motor %d \n", paramBase[0]);
 360       return;
 361     case i2cEnableById_4I_5V:
 362       if (verbose)
 363          printf("> ");
 364       else
 365          printf("& ");
 366       printf("i2cEnableById\n");
 367       return;
 368     case i2cDisableById_4I_5V:
 369       if (verbose)
 370          printf("> ");
 371       else
 372          printf("& ");
 373       printf("i2cDisableById\n");
 374       return;
 375     case i2cBusyById_4I_5I:
 376       if (verbose)
 377          printf("> ");
 378       else
 379          printf("& ");
 380       printf("i2cBusyById\n");
 381       push_word(0);
 382       return;
 383     case i2cStartById_4IIII_1BII_5I:
 384       {
 385         Object *p = word2ptr(paramBase[4]);
 386         byte *byteArray = (((byte *) p) + HEADER_SIZE);
 387        if (verbose)
 388          printf("> ");
 389       else
 390          printf("& ");
 391       printf("i2cStart called with parameters %d, %d, %d, %d %x, %d, %d\n",
 392                                         paramBase[0],
 393                                         paramBase[1],
 394                                         paramBase[2],
 395                                         paramBase[3],
 396                                         byteArray,
 397                                         paramBase[5],
 398                                         paramBase[6]);
 399       }
 400       push_word(0);
 401       return;
 402     case playTone_4II_5V:
 403       if (verbose)
 404          printf("> ");
 405       else
 406          printf("& ");
 407       printf("playTone with tone = %d, duration = %d\n", paramBase[0], paramBase[1]);
 408       return;
 409     case btSend_4_1BI_5V:
 410       {
 411         Object *p = word2ptr(paramBase[0]);
 412         byte *byteArray = (((byte *) p) + HEADER_SIZE);
 413         if (verbose)
 414           printf("> ");
 415         else
 416           printf("& ");
 417           printf("btSend with parameter &d\n", byteArray);
 418       }
 419       return;
 420     case btReceive_4_1B_5V:
 421       {
 422         Object *p = word2ptr(paramBase[0]);
 423         byte *byteArray = (((byte *) p) + HEADER_SIZE);
 424         if (verbose)
 425         {
 426           printf("> ");
 427           printf("btReceive called with parameter %x\n", byteArray);
 428         }
 429       }
 430       return;
 431     case btGetCmdMode_4_5I:
 432       if (verbose)
 433          printf("> ");
 434       else
 435          printf("& ");
 436          printf("btGetCmdMode returning 1\n");
 437       push_word(1);
 438       break;
 439     case btSetCmdMode_4I_5V:
 440       if (verbose)
 441          printf("> ");
 442       else
 443          printf("& ");
 444       printf("btSetCmdMode\n");
 445       break;
 446     case btStartADConverter_4_5V:
 447       break;
 448     case usbRead_4_1BI_5I:
 449       {
 450         Object *p = word2ptr(paramBase[0]);
 451         byte *byteArray = (((byte *) p) + HEADER_SIZE);
 452         if (verbose)
 453         {
 454           printf("> ");
 455           printf("usbReceive called with parameters %x, %d\n", byteArray, paramBase[1]);
 456         }
 457         push_word(0);
 458       }
 459       break;
 460     case usbWrite_4_1BI_5V:
 461       {
 462         Object *p = word2ptr(paramBase[0]);
 463         byte *byteArray = (((byte *) p) + HEADER_SIZE);
 464         if (verbose)
 465         {
 466           printf("> ");
 467           printf("usbWrite called with parameters %x, %d\n", byteArray, paramBase[1]);
 468         }
 469       }
 470       break;
 471     case writePage_4_1BI_5V:
 472       {
 473         Object *p = word2ptr(paramBase[0]);
 474         unsigned long *intArray = (unsigned long *) (((byte *) p) + HEADER_SIZE);
 475         if (verbose)
 476         {
 477           printf("> ");
 478           printf("writePage called with parameters %x, %d\n", intArray, paramBase[1]);
 479         }
 480       }
 481       break;
 482     case readPage_4_1BI_5V:
 483       {
 484         int i;
 485         Object *p = word2ptr(paramBase[0]);
 486         unsigned long *intArray = (unsigned long *) (((byte *) p) + HEADER_SIZE);
 487         if (verbose)
 488         {
 489           printf("> ");
 490           printf("readPage called with parameters %x, %d\n", intArray, paramBase[1]);
 491         }
 492       }
 493       break;
 494     case exec_4II_5V:
 495       if (verbose)
 496       {
 497         printf("> ");
 498         printf("exec called\n");
 499       }
 500       break;
 501     case usbReset_4_5V :
 502       if (verbose)
 503       {
 504         printf("> ");
 505         printf("udpReset called\n");
 506       }
 507       break;
 508     case playSample_4IIII_5V:
 509      if (verbose)
 510          printf("> ");
 511       else
 512          printf("& ");
 513       printf("Playing sound sample\n");
 514     break;
 515     default:
 516 #ifdef DEBUG_METHODS
 517       printf("Received bad native method code: %d\n", signature);
 518 #endif
 519       throw_exception (noSuchMethodError);
 520   }
 521 }