function.c

   1 #include "osecpu.h"
   2
   3 extern unsigned char fontdata[];    // @fontdata.c
   4
   5 const char *searchArg(int argc, const char **argv, const char *tag, int i)
   6 {
   7         int j, l;
   8         const char *r = NULL;
   9         if (tag != NULL) {
  10                 l = (int)strlen(tag);
  11                 for (j = 1; j < argc; j++) {
  12                         if (strncmp(argv[j], tag, l) == 0) {
  13                                 r = argv[j] + l;
  14                                 if (i == 0){
  15                     break;
  16                 }
  17                                 i--;
  18                         }
  19                 }
  20         }
  21         else {
  22                 for (j = 1; j < argc; j++) {
  23                         if (strchr(argv[j], ':') == NULL) {
  24                                 r = argv[j];
  25                                 if (i == 0){
  26                     break;
  27                 }
  28                                 i--;
  29                         }
  30                 }
  31         }
  32         if (i != 0){
  33         r = NULL;
  34     }
  35         return r;
  36 }
  37
  38 void devFunc0001(int len, unsigned char *puc, HOSECPU_RuntimeEnvironment *r)
  39 {
  40         while (len > 0) {
  41                 putOsaskChar(*puc++, r);
  42                 len--;
  43         }
  44         return;
  45 }
  46
  47 void devFunc0006(int mod, int sx, int sy, int x, int y, int c, int len, unsigned char *puc, HOSECPU_RuntimeEnvironment *r)
  48 {
  49     int xx;
  50     int yy;
  51     int i, ddx, ddy, j, ch, dx, dy;
  52
  53         if (sy == 0){
  54         sy = sx;
  55     }
  56         xx = x + sx * 8;
  57         yy = y + sy * 16;
  58         if (xx <= 0 || xx > mainWindow.xsize || yy <= 0 || yy > mainWindow.ysize){
  59                 (*(r->errHndl))(r);
  60     }
  61         if (x < 0 || x >= mainWindow.xsize || y < 0 || y >= mainWindow.ysize){
  62                 (*(r->errHndl))(r);
  63     }
  64
  65
  66         if ((mod & 3) == 0 && sx == 1 && sy == 1) {
  67                 // メジャーケースを高速化.
  68                 for (i = 0; i < len; i++) {
  69                         ch = puc[i];
  70                         if (0x10 <= ch && ch <= 0x1f)
  71                                 ch = "0123456789ABCDEF"[ch & 0x0f];
  72                         for (dy = 0; dy < 16; dy++) {
  73                                 j = fontdata[(ch - ' ') * 16 + dy];
  74                                 for (dx = 0; dx < 8; dx++) {
  75                                         if ((j & (0x80 >> dx)) != 0){
  76                         mainWindow.vram[(x + dx) + (y + dy) * mainWindow.xsize] = c;
  77                     }
  78                                 }
  79                         }
  80                         x += 8;
  81                 }
  82                 return;
  83         }
  84         for (i = 0; i < len; i++) {
  85                 ch = puc[i];
  86                 if (0x10 <= ch && ch <= 0x1f)
  87                         ch = "0123456789ABCDEF"[ch & 0x0f];
  88                 for (dy = 0; dy < 16; dy++) {
  89                         j = fontdata[(ch - ' ') * 16 + dy];
  90                         for (ddy = 0; ddy < sy; ddy++) {
  91                                 for (dx = 0; dx < 8; dx++) {
  92                                         if ((j & (0x80 >> dx)) != 0) {
  93                                                 for (ddx = 0; ddx < sx; ddx++) {
  94                             switch (mod & 3) {
  95                                 case 0:
  96                                     mainWindow.vram[x + y * mainWindow.xsize] = c;
  97                                     break;
  98                                 case 1:
  99                                     mainWindow.vram[x + y * mainWindow.xsize] |= c;
 100                                     break;
 101                                 case 2:
 102                                     mainWindow.vram[x + y * mainWindow.xsize] ^= c;
 103                                     break;
 104                                 case 3:
 105                                     mainWindow.vram[x + y * mainWindow.xsize] &= c;
 106                                     break;
 107                             }
 108                                                         x++;
 109                                                 }
 110                                         } else{
 111                                                 x += sx;
 112                     }
 113                                 }
 114                                 x -= sx * 8;
 115                                 y++;
 116                         }
 117                 }
 118                 x += sx * 8;
 119                 y -= sy * 16;
 120         }
 121         return;
 122 }
 123
 124 void devFunc0004(int mod, int x0, int y0, int x1, int y1, int c)
 125 {
 126         int x, y;
 127         if (mod == 0) {
 128                 for (y = y0; y <= y1; y++) {
 129                         for (x = x0; x <= x1; x++) {
 130                                 mainWindow.vram[x + y * mainWindow.xsize] = c;
 131                         }
 132                 }
 133         }
 134         else {
 135                 for (y = y0; y <= y1; y++) {
 136                         for (x = x0; x <= x1; x++) {
 137                 switch (mod) {
 138                     case 1:
 139                         mainWindow.vram[x + y * mainWindow.xsize] |= c;
 140                         break;
 141                     case 2:
 142                         mainWindow.vram[x + y * mainWindow.xsize] ^= c;
 143                         break;
 144                     case 3:
 145                         mainWindow.vram[x + y * mainWindow.xsize] &= c;
 146                         break;
 147                 }
 148             }
 149                 }
 150         }
 151         return;
 152 }
 153
 154 int devFunc0016(int buflen, unsigned char *buf, int plen, unsigned char *p, int qlen, int *q, HOSECPU_RuntimeEnvironment *r)
 155 {
 156         int i = 0, base, j, k;
 157         char sign;
 158
 159         while (plen > 0) {
 160                 if (i >= buflen){
 161                         (*(r->errHndl))(r);
 162         }
 163                 if (*p != 0x01) {
 164                         buf[i++] = *p++;
 165                         plen--;
 166                         continue;
 167                 }
 168                 p++;
 169                 plen--;
 170                 if (qlen < 4){
 171                         (*(r->errHndl))(r);
 172         }
 173                 base = q[0];
 174                 sign = 0;
 175                 if (base == 0){
 176             base = 16;
 177         }
 178 #if (REVISION == 1)
 179                 if (base == -3){
 180             base = 10;
 181         }
 182 #endif
 183                 if (base == -1){
 184             base = 10;
 185         }
 186                 if (base < 0 || base > 16){
 187                         (*(r->errHndl))(r);
 188         }
 189                 if (q[1] + i > buflen){
 190                         (*(r->errHndl))(r);
 191         }
 192                 j = q[3];
 193                 if ((q[2] & 4) == 0) {
 194                         // jは符号付き整数.
 195                         if ((q[2] & 8) != 0 && j > 0){
 196                 sign = '+';
 197             }
 198                         if (j < 0) {
 199                 sign = '-'; j *= -1;
 200             }
 201                 } else{
 202                         // jは符号無し整数.
 203                         if ((q[2] & 8) != 0 && j != 0){
 204                 sign = '+';
 205             }
 206                 }
 207                 for (k = q[1] - 1; k >= 0; k--) {
 208                         buf[i + k] = (j % base) + 0x10;
 209                         j = ((unsigned)j) / base;
 210                 }
 211                 k = 0;
 212                 if ((q[2] & 2) == 0 && j == 0) {
 213                         for (k = 0; k < q[1] - 1; k++) {
 214                                 if (buf[i + k] != 0x10){
 215                     break;
 216                 }
 217                                 buf[i + k] = ' ';
 218                         }
 219                 }
 220                 if (sign != 0) {
 221                         if (k > 0){
 222                 k--;
 223             }
 224                         buf[i + k] = sign;
 225                 }
 226                 if ((q[2] & 1) != 0 && buf[i] == ' ') {
 227                         for (j = 0; k < q[1]; k++, j++){
 228                                 buf[i + j] = buf[i + k];
 229             }
 230                         i += j;
 231                 } else{
 232                         i += q[1];
 233         }
 234                 qlen -= 4;
 235                 q += 4;
 236         }
 237         return i;
 238 }
 239
 240 void devFunc(HOSECPU_RuntimeEnvironment *r)
 241 {
 242         FILE *fp;
 243     int i, c;
 244         int x, y, len, dx, dy;
 245         unsigned char *puc;
 246         unsigned char pucbuf[256];
 247
 248     //サイズを節約するためにEBPを128バイトずらしているのを元に戻す
 249         r = (HOSECPU_RuntimeEnvironment *) (((char *)r) - 128);
 250
 251         if (r->winClosed != 0){
 252                 longjmp(*(r->setjmpEnv), 1);
 253     }
 254         if (0xff44 <= r->ireg[0x30] && r->ireg[0x30] <= 0xff48) {
 255                 if (mainWindow.vram == NULL) {
 256                         mainWindow.xsize = 640;
 257                         mainWindow.ysize = 480;
 258                         mainWindow.vram = malloc(640 * 480 * 4);
 259                         drv_openWin(640, 480, (void *)mainWindow.vram, &r->winClosed);
 260                         r->autoSleep = 1;
 261                         for (i = 640 * 480 - 1; i >= 0; i--){
 262                                 mainWindow.vram[i] = 0;
 263             }
 264                 }
 265         }
 266
 267         switch (r->ireg[0x30]){
 268         case 0xff00:
 269             printf("R31=%d(dec)\n", r->ireg[0x31]);
 270             break;
 271
 272         case 0xff01:
 273             /* return: R30, P31 */
 274             if (r->buf0 == NULL){
 275                 r->buf0 = malloc(1024 * 1024);
 276             }
 277             if (r->mainArgc <= r->ireg[0x31]) {
 278                 fprintf(stderr, "devFunc: error: R30=ff01: argc error: R31=%08X\n", r->ireg[0x31]);
 279                 exit(1);
 280             }
 281             fp = fopen(r->mainArgv[r->ireg[0x31]], "rb");
 282             if (fp == NULL) {
 283                 fprintf(stderr, "devFunc: error: R30=ff01: fopen error: '%s'\n", r->mainArgv[r->ireg[0x31]]);
 284                 exit(1);
 285             }
 286             i = (int)fread(r->buf0, 1, 1024 * 1024 - 4, fp);
 287             if (i >= 1024 * 1024 - 4 || i < 0) {
 288                 fprintf(stderr, "devFunc: error: R30=ff01: fread error: '%s'\n", r->mainArgv[r->ireg[0x31]]);
 289                 exit(1);
 290             }
 291             fclose(fp);
 292             r->preg[0x31].p = r->buf0;
 293             r->preg[0x31].p0 = r->buf0;
 294             r->preg[0x31].p1 = r->buf0 + i;
 295             r->preg[0x31].typ = 3; // T_UINT8
 296             r->ireg[0x30] = i;
 297             break;
 298
 299         case 0xff02:
 300             /* return: none */
 301             if (r->mainArgc <= r->ireg[0x31]) {
 302                 fprintf(stderr, "devFunc: error: R30=ff02: argc error: R31=%08X\n", r->ireg[0x31]);
 303                 exit(1);
 304             }
 305             fp = fopen(r->mainArgv[r->ireg[0x31]], "wb");
 306             if (fp == NULL) {
 307                 fprintf(stderr, "devFunc: error: R30=ff02: fopen error: '%s'\n", r->mainArgv[r->ireg[0x31]]);
 308                 exit(1);
 309             }
 310             if (r->ireg[0x32] >= 1024 * 1024 || r->ireg[0x32] < 0){
 311                 fprintf(stderr, "devFunc: error: R30=ff02: fwrite error: R02=%08X\n", r->ireg[0x32]);
 312                 exit(1);
 313             }
 314             fwrite(r->preg[0x31].p, 1, r->ireg[0x32], fp);
 315             fclose(fp);
 316             break;
 317
 318         case 0xff03:
 319             /* return: P31 */
 320             if (r->buf1 == NULL){
 321                 r->buf1 = malloc(1024 * 1024);
 322             }
 323             r->preg[0x31].p = r->buf1;
 324             r->preg[0x31].p0 = r->buf1;
 325             r->preg[0x31].p1 = r->buf1 + 1024 * 1024;
 326             break;
 327
 328         case 0xff04:
 329             printf("P31.(p-p0)=%d(dec)\n", (int)(r->preg[0x31].p - r->preg[0x31].p0));
 330             break;
 331
 332         case 0xff05:
 333             fwrite(r->preg[0x31].p, 1, r->ireg[0x31], stdout);
 334             break;
 335
 336         case 0xff06:
 337             // R31はリターンコード.
 338             // これを反映すべきだが、現状は手抜きでいつも正常終了.
 339             longjmp(*(r->setjmpEnv), 1);
 340             break;
 341
 342         case 0xff07:
 343             // マシになった文字列表示.OSASK文字列に対応.offにすれば通常の文字列処理もできる.現状はonのみサポート.
 344             checkString(r, 0x31, 0x31);
 345             devFunc0001(r->ireg[0x31], r->preg[0x31].p, r);
 346             break;
 347
 348         case 0xff08:
 349             // JITC on JITC
 350             // R31: 言語(back-end, front-end, ...
 351             // R32: level
 352             // R33: debugInfo1
 353             checkString(r, 0x34, 0x31);
 354             if (r->ireg[0x33] < 0 || r->ireg[0x33] > 15 || r->debugInfo1 > 15){
 355                 (*(r->errHndl))(r);
 356             }
 357             for (i = 0; i < r->maxLabels; i++){
 358                 r->label[i].opt = 0;
 359             }
 360             puc = r->preg[0x31].p;
 361             i = jitCompiler(r->jitbuf, r->jitbuf1, puc, puc + r->ireg[0x34], puc, r->label, r->maxLabels, r->ireg[0x32], di1_serial, JITC_NOSTARTUP + 0);
 362             if (i == 0) {
 363                 i = jitCompiler(r->jitbuf, r->jitbuf1, puc, puc + r->ireg[0x34], puc, r->label, r->maxLabels, r->ireg[0x32], di1_serial, JITC_NOSTARTUP + JITC_PHASE1 + 0);
 364                 if (i >= 0) {
 365                     r->mapDi1s[r->debugInfo1][r->ireg[0x33]] = di1_serial;
 366                     di1_serial++;
 367                     r->ireg[0x30] = 0;
 368                     r->preg[0x31].p = r->jitbuf;
 369                     r->preg[0x31].typ = 0; // TYP_CODE
 370                     r->preg[0x31].p0 = r->jitbuf;
 371                     r->preg[0x31].p1 = r->jitbuf + 1;
 372                     //int j; for (j = 0; j < i; j++) printf("%02X ", r->jitbuf[j]); putchar('\n');
 373                     r->jitbuf += i;
 374                     static unsigned char ff08_ret[3] = { 0x1e, 0x3f, 0x30 };
 375                     i = jitCompiler(r->jitbuf, r->jitbuf1, ff08_ret, ff08_ret + 3, puc, r->label, r->maxLabels, r->ireg[0x32], -1, JITC_NOSTARTUP + JITC_PHASE1 + 0);
 376                     r->jitbuf += i;
 377                     break;
 378                 }
 379             }
 380             r->ireg[0x30] = -1;
 381             break;
 382
 383         case 0xff09:
 384             // たぶんbit7を使ったテキストはうまく処理できない（これはもはや仕様にしても問題ないかも）.
 385             checkString(r, 0x31, 0x31);
 386             len = devFunc0016(sizeof pucbuf, pucbuf, r->ireg[0x31], r->preg[0x31].p, r->ireg[0x32], (int *)r->preg[0x32].p, r);
 387             devFunc0001(len, pucbuf, r);
 388             break;
 389
 390         case 0xff40:
 391             /* R31とR32でサイズを指定 */
 392             mainWindow.xsize = r->ireg[0x31];
 393             mainWindow.ysize = r->ireg[0x32];
 394             if (mainWindow.xsize <= 0 || mainWindow.ysize <= 0){
 395                 (*(r->errHndl))(r);
 396             }
 397             r->preg[0x31].p = (void *)(mainWindow.vram = malloc(mainWindow.xsize * mainWindow.ysize * 4));
 398             r->preg[0x31].p0 = r->preg[0x31].p;
 399             r->preg[0x31].p1 = r->preg[0x31].p + mainWindow.xsize * mainWindow.ysize * 4;
 400             drv_openWin(r->ireg[0x31], r->ireg[0x32], r->preg[0x31].p, &r->winClosed);
 401             //  drv_flshWin(r->ireg[1], r->ireg[2], 0, 0);
 402             r->autoSleep = 1;
 403             for (i = mainWindow.xsize * mainWindow.ysize - 1; i >= 0; i--){
 404                 mainWindow.vram[i] = 0;
 405             }
 406             break;
 407
 408         case 0xff41:
 409             /* R31とR32でサイズを指定、R33とR34でx0,y0指定 */
 410             if (r->ireg[0x31] == -1) {
 411                 r->ireg[0x31] = mainWindow.xsize; r->ireg[0x33] &= 0;
 412             }
 413             if (r->ireg[0x32] == -1) {
 414                 r->ireg[0x32] = mainWindow.ysize; r->ireg[0x34] &= 0;
 415             }
 416             checkRect(r, 0x31);
 417             drv_flshWin(r->ireg[0x31], r->ireg[0x32], r->ireg[0x33], r->ireg[0x34]);
 418             break;
 419
 420         case 0xff42:
 421             if (r->ireg[0x32] == -1) {
 422                 r->autoSleep = 1;
 423                 longjmp(*(r->setjmpEnv), 1);
 424             }
 425             if (r->ireg[0x32] < 0){
 426                 (*(r->errHndl))(r);
 427             }
 428             r->autoSleep = 0;
 429             if ((r->ireg[0x31] & 1) == 0 && mainWindow.vram != NULL){
 430                 drv_flshWin(mainWindow.xsize, mainWindow.ysize, 0, 0);
 431             }
 432             for (;;) {
 433                 if (r->winClosed != 0){
 434                     longjmp(*(r->setjmpEnv), 1);
 435                 }
 436                 drv_sleep(r->ireg[0x32]);
 437                 if ((r->ireg[0x31] & 2) != 0 && keybuf_c <= 0){
 438                     continue;
 439                 }
 440                 break;
 441             }
 442             break;
 443
 444         case 0xff43:
 445             //  1:peek
 446             //  2:stdin
 447             //  4,8: ソース指定.
 448             //  16: shift, lock系を有効化.
 449             //  32: 左右のshift系を区別する.
 450             if (r->ireg[0x31] == 2) {   // なぜ3にしなかったのか...
 451                 r->ireg[0x30] = fgetc(stdin);
 452                 if (r->ireg[0x30] == EOF){
 453                     r->ireg[0x30] = -1;
 454                 }
 455                 break;
 456             }
 457             r->ireg[0x30] |= -1;
 458             if (keybuf_c > 0) {
 459                 r->ireg[0x30] = keybuf[keybuf_r];
 460                 if ((r->ireg[0x31] & 16) == 0){
 461                     r->ireg[0x30] &= 0x3e3effff;
 462                 }
 463                 if ((r->ireg[0x31] & 32) == 0){
 464                     r->ireg[0x30] |= (r->ireg[0x30] >> 8) & 0xff0000;
 465                 }
 466                 if ((r->ireg[0x31] & 1) != 0) {
 467                     keybuf_c--;
 468                     keybuf_r = (keybuf_r + 1) & (KEYBUFSIZ - 1);
 469                 }
 470             }
 471             r->ireg[0x32] = r->ireg[0x33] = 0;
 472             if (r->ireg[0x30] == 4132) r->ireg[0x32]--;
 473             if (r->ireg[0x30] == 4133) r->ireg[0x33]--;
 474             if (r->ireg[0x30] == 4134) r->ireg[0x32]++;
 475             if (r->ireg[0x30] == 4135) r->ireg[0x33]++;
 476             break;
 477
 478         case 0xff44:
 479             c = loadColor(r, 0x34);
 480             if (r->ireg[0x32] < 0 || r->ireg[0x32] >= mainWindow.xsize ||
 481                 r->ireg[0x33] < 0 || r->ireg[0x33] >= mainWindow.ysize){
 482                 (*(r->errHndl))(r);
 483             }
 484
 485             switch ((r->ireg[0x31] & 3)) {
 486                 case 0:
 487                     mainWindow.vram[r->ireg[0x32] + r->ireg[0x33] * mainWindow.xsize] = c;
 488                     break;
 489                 case 1:
 490                     mainWindow.vram[r->ireg[0x32] + r->ireg[0x33] * mainWindow.xsize] |= c;
 491                     break;
 492                 case 2:
 493                     mainWindow.vram[r->ireg[0x32] + r->ireg[0x33] * mainWindow.xsize] ^= c;
 494                     break;
 495                 case 3:
 496                     mainWindow.vram[r->ireg[0x32] + r->ireg[0x33] * mainWindow.xsize] &= c;
 497                     break;
 498             }
 499             break;
 500
 501         case 0xff45:
 502             //drawLine
 503             c = loadColor(r, 0x36);
 504             if (r->ireg[0x32] < 0 || r->ireg[0x32] >= mainWindow.xsize ||
 505                 r->ireg[0x33] < 0 || r->ireg[0x33] >= mainWindow.ysize){
 506                 (*(r->errHndl))(r);
 507             }
 508             if (r->ireg[0x34] < 0 || r->ireg[0x34] >= mainWindow.xsize ||
 509                 r->ireg[0x35] < 0 || r->ireg[0x35] >= mainWindow.ysize){
 510                 (*(r->errHndl))(r);
 511             }
 512             dx = r->ireg[0x34] - r->ireg[0x32];
 513             dy = r->ireg[0x35] - r->ireg[0x33];
 514             x = r->ireg[0x32] << 10;
 515             y = r->ireg[0x33] << 10;
 516             if (dx < 0){
 517                 dx = -dx;
 518             }
 519             if (dy < 0){
 520                 dy = -dy;
 521             }
 522             if (dx >= dy) {
 523                 len = dx + 1; dx = 1024;
 524                 if (r->ireg[0x32] > r->ireg[0x34]){
 525                     dx *= -1;
 526                 }
 527                 if (r->ireg[0x33] > r->ireg[0x35]){
 528                     dy *= -1;
 529                 }
 530                 dy = (dy << 10) / len;
 531             } else {
 532                 len = dy + 1; dy = 1024;
 533                 if (r->ireg[0x33] > r->ireg[0x35]){
 534                     dy *= -1;
 535                 }
 536                 if (r->ireg[0x32] > r->ireg[0x34]){
 537                     dx *= -1;
 538                 }
 539                 dx = (dx << 10) / len;
 540             }
 541             if ((r->ireg[0x31] & 3) == 0) {
 542                 for (i = 0; i < len; i++) {
 543                     mainWindow.vram[(x >> 10) + (y >> 10) * mainWindow.xsize] = c;
 544                     x += dx;
 545                     y += dy;
 546                 }
 547                 break;
 548             }
 549             for (i = 0; i < len; i++) {
 550                 //      if ((r->ireg[0x31] & 3) == 0) vram[(x >> 10) + (y >> 10) * v_xsiz] =  c;
 551                 switch ((r->ireg[0x31] & 3)) {
 552                     case 1:
 553                         mainWindow.vram[(x >> 10) + (y >> 10) * mainWindow.xsize] |= c;
 554                         break;
 555                     case 2:
 556                         mainWindow.vram[(x >> 10) + (y >> 10) * mainWindow.xsize] ^= c;
 557                         break;
 558                     case 3:
 559                         mainWindow.vram[(x >> 10) + (y >> 10) * mainWindow.xsize] &= c;
 560                         break;
 561                     default:
 562                         break;
 563                 }
 564                 x += dx;
 565                 y += dy;
 566             }
 567             break;
 568
 569         case 0xff46:    // fillRect(opt:R31, xsiz:R32, ysiz:R33, x0:R34, y0:R35, c:R36)
 570             c = loadColor(r, 0x36);
 571             if (r->ireg[0x32] == -1) { r->ireg[0x32] = mainWindow.xsize; r->ireg[0x34] &= 0; }
 572             if (r->ireg[0x33] == -1) { r->ireg[0x33] = mainWindow.ysize; r->ireg[0x35] &= 0; }
 573             checkRect(r, 0x32);
 574             int mod3 = r->ireg[0x31] & 3, x0 = r->ireg[0x34], y0 = r->ireg[0x35], x1 = r->ireg[0x34] + r->ireg[0x32] - 1, y1 = r->ireg[0x35] + r->ireg[0x33] - 1;
 575             if ((r->ireg[0x31] & 0x20) == 0) {
 576                 devFunc0004(mod3, x0, y0, x1, y1, c);
 577             } else {    // drawRect
 578                 devFunc0004(mod3, x0, y0, x1, y0, c);
 579                 devFunc0004(mod3, x0, y1, x1, y1, c);
 580                 devFunc0004(mod3, x0, y0, x0, y1, c);
 581                 devFunc0004(mod3, x1, y0, x1, y1, c);
 582             }
 583             break;
 584
 585         case 0xff47:    // fillOval(opt:R31, xsiz:R32, ysiz:R33, x0:R34, y0:R35, c:R36)
 586             // これの計算精度はアーキテクチャに依存する.
 587             c = loadColor(r, 0x36);
 588             if (r->ireg[0x32] == -1) {
 589                 r->ireg[0x32] = mainWindow.xsize; r->ireg[0x34] &= 0;
 590             }
 591             if (r->ireg[0x33] == -1) {
 592                 r->ireg[0x33] = mainWindow.ysize; r->ireg[0x35] &= 0;
 593             }
 594             checkRect(r, 0x32);
 595             double dcx = 0.5 * (r->ireg[0x32] - 1);
 596             double dcy = 0.5 * (r->ireg[0x33] - 1);
 597             double dcxy = (dcx + 0.5) * (dcy + 0.5) - 0.1;
 598             dcxy *= dcxy;
 599             mod3 = r->ireg[0x31] & 3;
 600             x1 = r->ireg[0x32];
 601             y1 = r->ireg[0x33];
 602             if (mod3 == 0 && (r->ireg[0x31] & 0x20) == 0) {
 603                 for (y = 0; y < y1; y++) {
 604                     double dty = (y - dcy) * dcx;
 605                     for (x = 0; x < x1; x++) {
 606                         double dtx = (x - dcx) * dcy;
 607                         if (dtx * dtx + dty * dty > dcxy){
 608                             continue;
 609                         }
 610                         mainWindow.vram[(x + r->ireg[0x34]) + (y + r->ireg[0x35]) * mainWindow.xsize] = c;
 611                     }
 612                 }
 613             } else {
 614 #define DRAWOVALPARAM   1
 615                 double dcx1 = 0.5 * (r->ireg[0x32] - (1 + DRAWOVALPARAM * 2));
 616                 double dcy1 = 0.5 * (r->ireg[0x33] - (1 + DRAWOVALPARAM * 2));
 617                 double dcxy1 = (dcx1 + 0.5) * (dcy1 + 0.5) - 0.1;
 618                 dcxy1 *= dcxy1;
 619                 for (y = 0; y < y1; y++) {
 620                     double dty = (y - dcy) * dcx;
 621                     double dty1 = (y - dcy) * dcx1;
 622                     for (x = 0; x < x1; x++) {
 623                         double dtx = (x - dcx) * dcy;
 624                         double dtx1 = (x - dcx) * dcy1;
 625                         if (dtx * dtx + dty * dty > dcxy){
 626                             continue;
 627                         }
 628                         if (DRAWOVALPARAM <= x && x < x1 - DRAWOVALPARAM && DRAWOVALPARAM <= y && y < y1 - DRAWOVALPARAM) {
 629                             if (dtx1 * dtx1 + dty1 * dty1 < dcxy1){
 630                                 continue;
 631                             }
 632                         }
 633                         switch (mod3) {
 634                             case 0:
 635                                 mainWindow.vram[(x + r->ireg[0x34]) + (y + r->ireg[0x35]) * mainWindow.xsize] = c;
 636                                 break;
 637                             case 1:
 638                                 mainWindow.vram[(x + r->ireg[0x34]) + (y + r->ireg[0x35]) * mainWindow.xsize] |= c;
 639                                 break;
 640                             case 2:
 641                                 mainWindow.vram[(x + r->ireg[0x34]) + (y + r->ireg[0x35]) * mainWindow.xsize] ^= c;
 642                                 break;
 643                             case 3:
 644                                 mainWindow.vram[(x + r->ireg[0x34]) + (y + r->ireg[0x35]) * mainWindow.xsize] &= c;
 645                                 break;
 646                         }
 647                     }
 648                 }
 649             }
 650             break;
 651
 652         case 0xff48:    // drawString(opt:R31, xsiz:R32, ysiz:R33, x0:R34, y0:R35, c:R36, s.len:R37, s.p:P31)
 653             checkString(r, 0x37, 0x31);
 654             devFunc0006(r->ireg[0x31], r->ireg[0x32], r->ireg[0x33], r->ireg[0x34], r->ireg[0x35], loadColor(r, 0x36), r->ireg[0x37], r->preg[0x31].p, r);
 655             break;
 656
 657         case 0xff49:
 658             // **** junkApi_rand(i, max) ****
 659             // 0 <= i <= maxとなるiを返す。
 660             // max==0のとき、iはSINT32全体を範囲とする乱数となる。
 661             r->ireg[0x30] = randGetNextUInt32();
 662             if (r->ireg[0x31] > 0){
 663                 r->ireg[0x30] = (r->ireg[0x30] & 0x7fffffff) % (r->ireg[0x31] + 1);
 664             }
 665             break;
 666
 667         case 0xff4a:    /* seedの指定 */
 668             randStatInit(r->ireg[0x31]);
 669             break;
 670
 671         case 0xff4b:    /* 適当なseedを提供 */
 672             r->ireg[0x30] = (int)(time(NULL) ^ (long)0x55555555);
 673             break;
 674
 675         case 0xff4c:
 676             checkString(r, 0x37, 0x31);
 677             len = devFunc0016(sizeof pucbuf, pucbuf, r->ireg[0x37], r->preg[0x31].p, r->ireg[0x38], (int *)r->preg[0x32].p, r);
 678             devFunc0006(r->ireg[0x31], r->ireg[0x32], r->ireg[0x33], r->ireg[0x34], r->ireg[0x35], loadColor(r, 0x36), len, pucbuf, r);
 679             break;
 680
 681         case 0xff4d:
 682             // bitblt(mod, xsiz, ysiz, xscale, yscale, x0, y0, lineskip, inv, p_buf, typ0, p_table, typ1);
 683             // mod: 0x20:use_table, 0x40:inv_is_visible & typ1_is_color
 684             puc = r->preg[0x31].p;
 685             mod3 = r->ireg[0x31] & 3;
 686             dx = r->ireg[0x34];
 687             dy = r->ireg[0x35];
 688             if (dy == 0){
 689                 dy = dx;
 690             }
 691             if (r->ireg[0x32] == -1) {
 692                 r->ireg[0x32] = mainWindow.xsize / dx; r->ireg[0x36] &= 0;
 693             }
 694             if (r->ireg[0x33] == -1) {
 695                 r->ireg[0x33] = mainWindow.ysize / dy; r->ireg[0x37] &= 0;
 696             }
 697             for (y = 0; y < r->ireg[0x33]; y++) {
 698                 y0 = y * dy + r->ireg[0x37];
 699                 for (x = 0; x < r->ireg[0x32]; x++) {
 700                     x0 = x * dx + r->ireg[0x36];
 701                     c = iColor1[*puc++];
 702                     devFunc0004(mod3, x0, y0, x0 + dx, y0 + dy, c);
 703                 }
 704                 puc += r->ireg[0x38];
 705             }
 706             break;
 707
 708         default:
 709             printf("devFunc: error: R30=%08X\n", r->ireg[0x30]);
 710             exit(EXIT_FAILURE);
 711
 712         }
 713         return;
 714 }
 715
 716
 717