mobile/src/bin/embryo_cc_sc7.scp

   1 /*  Small compiler - Peephole optimizer "sequences" strings (plain
   2  *                   and compressed formats)
   3  *
   4  *  Copyright (c) ITB CompuPhase, 2000-2003
   5  *
   6  *  This software is provided "as-is", without any express or implied warranty.
   7  *  In no event will the authors be held liable for any damages arising from
   8  *  the use of this software.
   9  *
  10  *  Permission is granted to anyone to use this software for any purpose,
  11  *  including commercial applications, and to alter it and redistribute it
  12  *  freely, subject to the following restrictions:
  13  *
  14  *  1.  The origin of this software must not be misrepresented; you must not
  15  *      claim that you wrote the original software. If you use this software in
  16  *      a product, an acknowledgment in the product documentation would be
  17  *      appreciated but is not required.
  18  *  2.  Altered source versions must be plainly marked as such, and must not be
  19  *      misrepresented as being the original software.
  20  *  3.  This notice may not be removed or altered from any source distribution.
  21  *
  22  *  Version: $Id$
  23  */
  24
  25 int         strexpand(char *dest, unsigned char *source, int maxlen,
  26                               unsigned char pairtable[128][2]);
  27
  28 #define SCPACK_TERMINATOR ,     /* end each section with a comma */
  29
  30 #define SCPACK_TABLE sequences_table
  31 /*-*SCPACK start of pair table, do not change or remove this line */
  32 unsigned char       sequences_table[][2] = {
  33    {32, 37}, {114, 105}, {112, 129}, {46, 130}, {49, 33}, {128, 132}, {97, 100},
  34       {46, 97}, {135, 108}, {136, 116}, {111, 134}, {108, 138}, {50, 33}, {115,
  35                                                                            104},
  36       {128, 140}, {137, 33},
  37    {46, 115}, {117, 141}, {112, 145}, {131, 133}, {139, 144}, {112, 143}, {131,
  38                                                                            142},
  39       {115, 116}, {111, 149}, {112, 152}, {131, 33}, {134, 100}, {110, 151},
  40       {111, 156}, {99, 157}, {59, 36},
  41    {146, 154}, {148, 150}, {112, 33}, {120, 162}, {101, 163}, {159, 164}, {137,
  42                                                                            133},
  43       {46, 99}, {122, 101}, {110, 100}, {155, 114}, {101, 113}, {168, 114},
  44       {147, 160}, {51, 33}, {128, 174},
  45    {103, 33}, {133, 165}, {104, 176}, {99, 178}, {120, 179}, {171, 33}, {106,
  46                                                                          172},
  47       {173, 161}, {155, 33}, {108, 167}, {117, 169}, {115, 175}, {186, 187},
  48       {153, 184}, {141, 185}, {111, 188},
  49    {98, 191}, {105, 100}, {115, 103}, {115, 108}, {193, 120}, {182, 133}, {114,
  50                                                                            33},
  51       {166, 161}, {190, 131}, {137, 142}, {169, 33}, {97, 202}, {139, 147},
  52       {172, 111}, {158, 147}, {139, 150},
  53    {105, 33}, {101, 115}, {209, 115}, {114, 116}, {148, 147}, {171, 133}, {189,
  54                                                                            139},
  55       {32, 140}, {146, 167}, {196, 170}, {158, 183}, {170, 183}, {199, 192},
  56       {108, 196}, {97, 198}, {194, 211},
  57    {46, 208}, {195, 210}, {200, 215}, {112, 222}, {159, 227}, {46, 98}, {118,
  58                                                                          101},
  59       {111, 230}, {109, 231}, {146, 143}, {99, 144}, {158, 150}, {97, 149},
  60       {203, 153}, {52, 33}, {225, 33},
  61    {158, 166}, {194, 181}, {195, 181}, {201, 180}, {223, 198}, {153, 203}, {214,
  62                                                                             224},
  63       {100, 101}, {128, 238}, {119, 236}, {249, 237}, {105, 110}, {115, 250},
  64       {232, 143}, {205, 154}
  65 };
  66 /*-*SCPACK end of pair table, do not change or remove this line */
  67
  68 #define seqsize(o,p)    (opcodes(o)+opargs(p))
  69 typedef struct
  70 {
  71    char               *find;
  72    char               *replace;
  73    int                 savesize;        /* number of bytes saved (in bytecode) */
  74 } SEQUENCE;
  75 static SEQUENCE     sequences_cmp[] = {
  76    /* A very common sequence in four varieties
  77     *    load.s.pri n1           load.s.pri n2
  78     *    push.pri                load.s.alt n1
  79     *    load.s.pri n2           -
  80     *    pop.alt                 -
  81     *    --------------------------------------
  82     *    load.pri n1             load.s.pri n2
  83     *    push.pri                load.alt n1
  84     *    load.s.pri n2           -
  85     *    pop.alt                 -
  86     *    --------------------------------------
  87     *    load.s.pri n1           load.pri n2
  88     *    push.pri                load.s.alt n1
  89     *    load.pri n2             -
  90     *    pop.alt                 -
  91     *    --------------------------------------
  92     *    load.pri n1             load.pri n2
  93     *    push.pri                load.alt n1
  94     *    load.pri n2             -
  95     *    pop.alt                 -
  96     */
  97    {
  98 #ifdef SCPACK
  99     "load.s.pri %1!push.pri!load.s.pri %2!pop.alt!",
 100     "load.s.pri %2!load.s.alt %1!",
 101 #else
 102     "\224\267\231",
 103     "\241\224\246",
 104 #endif
 105     seqsize(4, 2) - seqsize(2, 2)},
 106    {
 107 #ifdef SCPACK
 108     "load.pri %1!push.pri!load.s.pri %2!pop.alt!",
 109     "load.s.pri %2!load.alt %1!",
 110 #else
 111     "\213\267\231",
 112     "\241\213\246",
 113 #endif
 114     seqsize(4, 2) - seqsize(2, 2)},
 115    {
 116 #ifdef SCPACK
 117     "load.s.pri %1!push.pri!load.pri %2!pop.alt!",
 118     "load.pri %2!load.s.alt %1!",
 119 #else
 120     "\224\255\317\231",
 121     "\317\224\246",
 122 #endif
 123     seqsize(4, 2) - seqsize(2, 2)},
 124    {
 125 #ifdef SCPACK
 126     "load.pri %1!push.pri!load.pri %2!pop.alt!",
 127     "load.pri %2!load.alt %1!",
 128 #else
 129     "\213\255\317\231",
 130     "\317\213\246",
 131 #endif
 132     seqsize(4, 2) - seqsize(2, 2)},
 133    /* (#1#) The above also occurs with "addr.pri" (array
 134     * indexing) as the first line; so that adds 2 cases.
 135     */
 136    {
 137 #ifdef SCPACK
 138     "addr.pri %1!push.pri!load.s.pri %2!pop.alt!",
 139     "addr.alt %1!load.s.pri %2!",
 140 #else
 141     "\333\231",
 142     "\252\307",
 143 #endif
 144     seqsize(4, 2) - seqsize(2, 2)},
 145    {
 146 #ifdef SCPACK
 147     "addr.pri %1!push.pri!load.pri %2!pop.alt!",
 148     "addr.alt %1!load.pri %2!",
 149 #else
 150     "\252\255\317\231",
 151     "\252\246\317",
 152 #endif
 153     seqsize(4, 2) - seqsize(2, 2)},
 154    /* And the same sequence with const.pri as either the first
 155     * or the second load instruction: four more cases.
 156     */
 157    {
 158 #ifdef SCPACK
 159     "const.pri %1!push.pri!load.s.pri %2!pop.alt!",
 160     "load.s.pri %2!const.alt %1!",
 161 #else
 162     "\332\231",
 163     "\241\360",
 164 #endif
 165     seqsize(4, 2) - seqsize(2, 2)},
 166    {
 167 #ifdef SCPACK
 168     "const.pri %1!push.pri!load.pri %2!pop.alt!",
 169     "load.pri %2!const.alt %1!",
 170 #else
 171     "\236\255\317\231",
 172     "\317\360",
 173 #endif
 174     seqsize(4, 2) - seqsize(2, 2)},
 175    {
 176 #ifdef SCPACK
 177     "load.s.pri %1!push.pri!const.pri %2!pop.alt!",
 178     "const.pri %2!load.s.alt %1!",
 179 #else
 180     "\224\255\353\231",
 181     "\353\224\246",
 182 #endif
 183     seqsize(4, 2) - seqsize(2, 2)},
 184    {
 185 #ifdef SCPACK
 186     "load.pri %1!push.pri!const.pri %2!pop.alt!",
 187     "const.pri %2!load.alt %1!",
 188 #else
 189     "\213\255\353\231",
 190     "\353\213\246",
 191 #endif
 192     seqsize(4, 2) - seqsize(2, 2)},
 193    /* The same as above, but now with "addr.pri" (array
 194     * indexing) on the first line and const.pri on
 195     * the second.
 196     */
 197    {
 198 #ifdef SCPACK
 199     "addr.pri %1!push.pri!const.pri %2!pop.alt!",
 200     "addr.alt %1!const.pri %2!",
 201 #else
 202     "\252\255\353\231",
 203     "\252\246\353",
 204 #endif
 205     seqsize(4, 2) - seqsize(2, 2)},
 206    /* ??? add references */
 207    /* Chained relational operators can contain sequences like:
 208     *    move.pri                load.s.pri n1
 209     *    push.pri                -
 210     *    load.s.pri n1           -
 211     *    pop.alt                 -
 212     * The above also accurs for "load.pri" and for "const.pri",
 213     * so add another two cases.
 214     */
 215    {
 216 #ifdef SCPACK
 217     "move.pri!push.pri!load.s.pri %1!pop.alt!",
 218     "load.s.pri %1!",
 219 #else
 220     "\350\232\240\324\231",
 221     "\324",
 222 #endif
 223     seqsize(4, 1) - seqsize(1, 1)},
 224    {
 225 #ifdef SCPACK
 226     "move.pri!push.pri!load.pri %1!pop.alt!",
 227     "load.pri %1!",
 228 #else
 229     "\350\232\240\314\231",
 230     "\314",
 231 #endif
 232     seqsize(4, 1) - seqsize(1, 1)},
 233    {
 234 #ifdef SCPACK
 235     "move.pri!push.pri!const.pri %1!pop.alt!",
 236     "const.pri %1!",
 237 #else
 238     "\350\232\240\316\231",
 239     "\316",
 240 #endif
 241     seqsize(4, 1) - seqsize(1, 1)},
 242    /* More optimizations for chained relational operators; the
 243     * continuation sequences can be simplified if they turn out
 244     * to be termination sequences:
 245     *    xchg                    sless       also for sless, sgeq and sleq
 246     *    sgrtr                   pop.alt
 247     *    swap.alt                and
 248     *    and                     ;$exp
 249     *    pop.alt                 -
 250     *    ;$exp                   -
 251     *    --------------------------------------
 252     *    xchg                    sless       also for sless, sgeq and sleq
 253     *    sgrtr                   pop.alt
 254     *    swap.alt                and
 255     *    and                     jzer n1
 256     *    pop.alt                 -
 257     *    jzer n1                 -
 258     *    --------------------------------------
 259     *    xchg                    jsgeq  n1   also for sless, sgeq and sleq
 260     *    sgrtr                   ;$exp       (occurs for non-chained comparisons)
 261     *    jzer n1                 -
 262     *    ;$exp                   -
 263     *    --------------------------------------
 264     *    xchg                    sless       also for sless, sgeq and sleq
 265     *    sgrtr                   ;$exp       (occurs for non-chained comparisons)
 266     *    ;$exp                   -
 267     */
 268    {
 269 #ifdef SCPACK
 270     "xchg!sgrtr!swap.alt!and!pop.alt!;$exp!",
 271     "sless!pop.alt!and!;$exp!",
 272 #else
 273     "\264\364\374\245",
 274     "\357\365\245",
 275 #endif
 276     seqsize(5, 0) - seqsize(3, 0)},
 277    {
 278 #ifdef SCPACK
 279     "xchg!sless!swap.alt!and!pop.alt!;$exp!",
 280     "sgrtr!pop.alt!and!;$exp!",
 281 #else
 282     "\264\357\374\245",
 283     "\364\365\245",
 284 #endif
 285     seqsize(5, 0) - seqsize(3, 0)},
 286    {
 287 #ifdef SCPACK
 288     "xchg!sgeq!swap.alt!and!pop.alt!;$exp!",
 289     "sleq!pop.alt!and!;$exp!",
 290 #else
 291     "\264\361\374\245",
 292     "\362\365\245",
 293 #endif
 294     seqsize(5, 0) - seqsize(3, 0)},
 295    {
 296 #ifdef SCPACK
 297     "xchg!sleq!swap.alt!and!pop.alt!;$exp!",
 298     "sgeq!pop.alt!and!;$exp!",
 299 #else
 300     "\264\362\374\245",
 301     "\361\365\245",
 302 #endif
 303     seqsize(5, 0) - seqsize(3, 0)},
 304    {
 305 #ifdef SCPACK
 306     "xchg!sgrtr!swap.alt!and!pop.alt!jzer %1!",
 307     "sless!pop.alt!and!jzer %1!",
 308 #else
 309     "\264\364\374\305",
 310     "\357\365\305",
 311 #endif
 312     seqsize(5, 0) - seqsize(3, 0)},
 313    {
 314 #ifdef SCPACK
 315     "xchg!sless!swap.alt!and!pop.alt!jzer %1!",
 316     "sgrtr!pop.alt!and!jzer %1!",
 317 #else
 318     "\264\357\374\305",
 319     "\364\365\305",
 320 #endif
 321     seqsize(5, 0) - seqsize(3, 0)},
 322    {
 323 #ifdef SCPACK
 324     "xchg!sgeq!swap.alt!and!pop.alt!jzer %1!",
 325     "sleq!pop.alt!and!jzer %1!",
 326 #else
 327     "\264\361\374\305",
 328     "\362\365\305",
 329 #endif
 330     seqsize(5, 0) - seqsize(3, 0)},
 331    {
 332 #ifdef SCPACK
 333     "xchg!sleq!swap.alt!and!pop.alt!jzer %1!",
 334     "sgeq!pop.alt!and!jzer %1!",
 335 #else
 336     "\264\362\374\305",
 337     "\361\365\305",
 338 #endif
 339     seqsize(5, 0) - seqsize(3, 0)},
 340    {
 341 #ifdef SCPACK
 342     "xchg!sgrtr!jzer %1!;$exp!",
 343     "jsgeq %1!;$exp!",
 344 #else
 345     "\264\364\266\261",
 346     "j\302\253\261",
 347 #endif
 348     seqsize(3, 1) - seqsize(1, 1)},
 349    {
 350 #ifdef SCPACK
 351     "xchg!sless!jzer %1!;$exp!",
 352     "jsleq %1!;$exp!",
 353 #else
 354     "\264\357\266\261",
 355     "j\303\253\261",
 356 #endif
 357     seqsize(3, 1) - seqsize(1, 1)},
 358    {
 359 #ifdef SCPACK
 360     "xchg!sgeq!jzer %1!;$exp!",
 361     "jsgrtr %1!;$exp!",
 362 #else
 363     "\264\361\266\261",
 364     "j\337r\261",
 365 #endif
 366     seqsize(3, 1) - seqsize(1, 1)},
 367    {
 368 #ifdef SCPACK
 369     "xchg!sleq!jzer %1!;$exp!",
 370     "jsless %1!;$exp!",
 371 #else
 372     "\264\362\266\261",
 373     "j\341\261",
 374 #endif
 375     seqsize(3, 1) - seqsize(1, 1)},
 376    {
 377 #ifdef SCPACK
 378     "xchg!sgrtr!;$exp!",
 379     "sless!;$exp!",
 380 #else
 381     "\264\364\245",
 382     "\357\245",
 383 #endif
 384     seqsize(2, 0) - seqsize(1, 0)},
 385    {
 386 #ifdef SCPACK
 387     "xchg!sless!;$exp!",
 388     "sgrtr!;$exp!",
 389 #else
 390     "\264\357\245",
 391     "\364\245",
 392 #endif
 393     seqsize(2, 0) - seqsize(1, 0)},
 394    {
 395 #ifdef SCPACK
 396     "xchg!sgeq!;$exp!",
 397     "sleq!;$exp!",
 398 #else
 399     "\264\361\245",
 400     "\362\245",
 401 #endif
 402     seqsize(2, 0) - seqsize(1, 0)},
 403    {
 404 #ifdef SCPACK
 405     "xchg!sleq!;$exp!",
 406     "sgeq!;$exp!",
 407 #else
 408     "\264\362\245",
 409     "\361\245",
 410 #endif
 411     seqsize(2, 0) - seqsize(1, 0)},
 412    /* The entry to chained operators is also opt to optimization
 413     *    load.s.pri n1           load.s.pri n2
 414     *    load.s.alt n2           load.s.alt n1
 415     *    xchg                    -
 416     *    --------------------------------------
 417     *    load.s.pri n1           load.pri n2
 418     *    load.alt n2             load.s.alt n1
 419     *    xchg                    -
 420     *    --------------------------------------
 421     *    load.s.pri n1           const.pri n2
 422     *    const.alt n2            load.s.alt n1
 423     *    xchg                    -
 424     *    --------------------------------------
 425     * and all permutations...
 426     */
 427    {
 428 #ifdef SCPACK
 429     "load.s.pri %1!load.s.alt %2!xchg!",
 430     "load.s.pri %2!load.s.alt %1!",
 431 #else
 432     "\324\224\363",
 433     "\241\224\246",
 434 #endif
 435     seqsize(3, 2) - seqsize(2, 2)},
 436    {
 437 #ifdef SCPACK
 438     "load.s.pri %1!load.alt %2!xchg!",
 439     "load.pri %2!load.s.alt %1!",
 440 #else
 441     "\324\213\363",
 442     "\317\224\246",
 443 #endif
 444     seqsize(3, 2) - seqsize(2, 2)},
 445    {
 446 #ifdef SCPACK
 447     "load.s.pri %1!const.alt %2!xchg!",
 448     "const.pri %2!load.s.alt %1!",
 449 #else
 450     "\324\236\363",
 451     "\353\224\246",
 452 #endif
 453     seqsize(3, 2) - seqsize(2, 2)},
 454    {
 455 #ifdef SCPACK
 456     "load.pri %1!load.s.alt %2!xchg!",
 457     "load.s.pri %2!load.alt %1!",
 458 #else
 459     "\314\224\363",
 460     "\241\213\246",
 461 #endif
 462     seqsize(3, 2) - seqsize(2, 2)},
 463    {
 464 #ifdef SCPACK
 465     "load.pri %1!load.alt %2!xchg!",
 466     "load.pri %2!load.alt %1!",
 467 #else
 468     "\314\213\363",
 469     "\317\213\246",
 470 #endif
 471     seqsize(3, 2) - seqsize(2, 2)},
 472    {
 473 #ifdef SCPACK
 474     "load.pri %1!const.alt %2!xchg!",
 475     "const.pri %2!load.alt %1!",
 476 #else
 477     "\314\236\363",
 478     "\353\213\246",
 479 #endif
 480     seqsize(3, 2) - seqsize(2, 2)},
 481    {
 482 #ifdef SCPACK
 483     "const.pri %1!load.s.alt %2!xchg!",
 484     "load.s.pri %2!const.alt %1!",
 485 #else
 486     "\316\224\363",
 487     "\241\360",
 488 #endif
 489     seqsize(3, 2) - seqsize(2, 2)},
 490    {
 491 #ifdef SCPACK
 492     "const.pri %1!load.alt %2!xchg!",
 493     "load.pri %2!const.alt %1!",
 494 #else
 495     "\316\213\363",
 496     "\317\360",
 497 #endif
 498     seqsize(3, 2) - seqsize(2, 2)},
 499    /* Array indexing can merit from special instructions.
 500     * Simple indexed array lookup can be optimized quite
 501     * a bit.
 502     *    addr.pri n1             addr.alt n1
 503     *    push.pri                load.s.pri n2
 504     *    load.s.pri n2           bounds n3
 505     *    bounds n3               lidx.b n4
 506     *    shl.c.pri n4            -
 507     *    pop.alt                 -
 508     *    add                     -
 509     *    load.i                  -
 510     *
 511     * And to prepare for storing a value in an array
 512     *    addr.pri n1             addr.alt n1
 513     *    push.pri                load.s.pri n2
 514     *    load.s.pri n2           bounds n3
 515     *    bounds n3               idxaddr.b n4
 516     *    shl.c.pri n4            -
 517     *    pop.alt                 -
 518     *    add                     -
 519     *
 520     * Notes (additional cases):
 521     * 1. instruction addr.pri can also be const.pri (for
 522     *    global arrays)
 523     * 2. the bounds instruction can be absent
 524     * 3. when "n4" (the shift value) is the 2 (with 32-bit cels), use the
 525     *    even more optimal instructions LIDX and IDDXADDR
 526     *
 527     * If the array index is more complex, one can only optimize
 528     * the last four instructions:
 529     *    shl.c.pri n1            pop.alt
 530     *    pop.alt                 lidx.b n1
 531     *    add                     -
 532     *    loadi                   -
 533     *    --------------------------------------
 534     *    shl.c.pri n1            pop.alt
 535     *    pop.alt                 idxaddr.b n1
 536     *    add                     -
 537     */
 538 #if !defined BIT16
 539    /* loading from array, "cell" shifted */
 540    {
 541 #ifdef SCPACK
 542     "addr.pri %1!push.pri!load.s.pri %2!bounds %3!shl.c.pri 2!pop.alt!add!load.i!",
 543     "addr.alt %1!load.s.pri %2!bounds %3!lidx!",
 544 #else
 545     "\333\300\342\366",
 546     "\252\334\335!",
 547 #endif
 548     seqsize(8, 4) - seqsize(4, 3)},
 549    {
 550 #ifdef SCPACK
 551     "const.pri %1!push.pri!load.s.pri %2!bounds %3!shl.c.pri 2!pop.alt!add!load.i!",
 552     "const.alt %1!load.s.pri %2!bounds %3!lidx!",
 553 #else
 554     "\332\300\342\366",
 555     "\236\334\335!",
 556 #endif
 557     seqsize(8, 4) - seqsize(4, 3)},
 558    {
 559 #ifdef SCPACK
 560     "addr.pri %1!push.pri!load.s.pri %2!shl.c.pri 2!pop.alt!add!load.i!",
 561     "addr.alt %1!load.s.pri %2!lidx!",
 562 #else
 563     "\333\342\366",
 564     "\252\307\335!",
 565 #endif
 566     seqsize(7, 3) - seqsize(3, 2)},
 567    {
 568 #ifdef SCPACK
 569     "const.pri %1!push.pri!load.s.pri %2!shl.c.pri 2!pop.alt!add!load.i!",
 570     "const.alt %1!load.s.pri %2!lidx!",
 571 #else
 572     "\332\342\366",
 573     "\236\307\335!",
 574 #endif
 575     seqsize(7, 3) - seqsize(3, 2)},
 576 #endif
 577    /* loading from array, not "cell" shifted */
 578    {
 579 #ifdef SCPACK
 580     "addr.pri %1!push.pri!load.s.pri %2!bounds %3!shl.c.pri %4!pop.alt!add!load.i!",
 581     "addr.alt %1!load.s.pri %2!bounds %3!lidx.b %4!",
 582 #else
 583     "\333\300\310\370\366",
 584     "\252\334\335\345\370",
 585 #endif
 586     seqsize(8, 4) - seqsize(4, 4)},
 587    {
 588 #ifdef SCPACK
 589     "const.pri %1!push.pri!load.s.pri %2!bounds %3!shl.c.pri %4!pop.alt!add!load.i!",
 590     "const.alt %1!load.s.pri %2!bounds %3!lidx.b %4!",
 591 #else
 592     "\332\300\310\370\366",
 593     "\236\334\335\345\370",
 594 #endif
 595     seqsize(8, 4) - seqsize(4, 4)},
 596    {
 597 #ifdef SCPACK
 598     "addr.pri %1!push.pri!load.s.pri %2!shl.c.pri %3!pop.alt!add!load.i!",
 599     "addr.alt %1!load.s.pri %2!lidx.b %3!",
 600 #else
 601     "\333\310\257\366",
 602     "\252\307\335\345\257",
 603 #endif
 604     seqsize(7, 3) - seqsize(3, 3)},
 605    {
 606 #ifdef SCPACK
 607     "const.pri %1!push.pri!load.s.pri %2!shl.c.pri %3!pop.alt!add!load.i!",
 608     "const.alt %1!load.s.pri %2!lidx.b %3!",
 609 #else
 610     "\332\310\257\366",
 611     "\236\307\335\345\257",
 612 #endif
 613     seqsize(7, 3) - seqsize(3, 3)},
 614 #if !defined BIT16
 615    /* array index calculation for storing a value, "cell" aligned */
 616    {
 617 #ifdef SCPACK
 618     "addr.pri %1!push.pri!load.s.pri %2!bounds %3!shl.c.pri 2!pop.alt!add!",
 619     "addr.alt %1!load.s.pri %2!bounds %3!idxaddr!",
 620 #else
 621     "\333\300\342\275",
 622     "\252\334\331!",
 623 #endif
 624     seqsize(7, 4) - seqsize(4, 3)},
 625    {
 626 #ifdef SCPACK
 627     "const.pri %1!push.pri!load.s.pri %2!bounds %3!shl.c.pri 2!pop.alt!add!",
 628     "const.alt %1!load.s.pri %2!bounds %3!idxaddr!",
 629 #else
 630     "\332\300\342\275",
 631     "\236\334\331!",
 632 #endif
 633     seqsize(7, 4) - seqsize(4, 3)},
 634    {
 635 #ifdef SCPACK
 636     "addr.pri %1!push.pri!load.s.pri %2!shl.c.pri 2!pop.alt!add!",
 637     "addr.alt %1!load.s.pri %2!idxaddr!",
 638 #else
 639     "\333\342\275",
 640     "\252\307\331!",
 641 #endif
 642     seqsize(6, 3) - seqsize(3, 2)},
 643    {
 644 #ifdef SCPACK
 645     "const.pri %1!push.pri!load.s.pri %2!shl.c.pri 2!pop.alt!add!",
 646     "const.alt %1!load.s.pri %2!idxaddr!",
 647 #else
 648     "\332\342\275",
 649     "\236\307\331!",
 650 #endif
 651     seqsize(6, 3) - seqsize(3, 2)},
 652 #endif
 653    /* array index calculation for storing a value, not "cell" packed */
 654    {
 655 #ifdef SCPACK
 656     "addr.pri %1!push.pri!load.s.pri %2!bounds %3!shl.c.pri %4!pop.alt!add!",
 657     "addr.alt %1!load.s.pri %2!bounds %3!idxaddr.b %4!",
 658 #else
 659     "\333\300\310\370\275",
 660     "\252\334\331\345\370",
 661 #endif
 662     seqsize(7, 4) - seqsize(4, 4)},
 663    {
 664 #ifdef SCPACK
 665     "const.pri %1!push.pri!load.s.pri %2!bounds %3!shl.c.pri %4!pop.alt!add!",
 666     "const.alt %1!load.s.pri %2!bounds %3!idxaddr.b %4!",
 667 #else
 668     "\332\300\310\370\275",
 669     "\236\334\331\345\370",
 670 #endif
 671     seqsize(7, 4) - seqsize(4, 4)},
 672    {
 673 #ifdef SCPACK
 674     "addr.pri %1!push.pri!load.s.pri %2!shl.c.pri %3!pop.alt!add!",
 675     "addr.alt %1!load.s.pri %2!idxaddr.b %3!",
 676 #else
 677     "\333\310\257\275",
 678     "\252\307\331\345\257",
 679 #endif
 680     seqsize(6, 3) - seqsize(3, 3)},
 681    {
 682 #ifdef SCPACK
 683     "const.pri %1!push.pri!load.s.pri %2!shl.c.pri %3!pop.alt!add!",
 684     "const.alt %1!load.s.pri %2!idxaddr.b %3!",
 685 #else
 686     "\332\310\257\275",
 687     "\236\307\331\345\257",
 688 #endif
 689     seqsize(6, 3) - seqsize(3, 3)},
 690 #if !defined BIT16
 691    /* the shorter array indexing sequences, see above for comments */
 692    {
 693 #ifdef SCPACK
 694     "shl.c.pri 2!pop.alt!add!loadi!",
 695     "pop.alt!lidx!",
 696 #else
 697     "\342\326\320",
 698     "\231\335!",
 699 #endif
 700     seqsize(4, 1) - seqsize(2, 0)},
 701    {
 702 #ifdef SCPACK
 703     "shl.c.pri 2!pop.alt!add!",
 704     "pop.alt!idxaddr!",
 705 #else
 706     "\342\275",
 707     "\231\331!",
 708 #endif
 709     seqsize(3, 1) - seqsize(2, 0)},
 710 #endif
 711    {
 712 #ifdef SCPACK
 713     "shl.c.pri %1!pop.alt!add!loadi!",
 714     "pop.alt!lidx.b %1!",
 715 #else
 716     "\276\223\326\320",
 717     "\231\335\345\205",
 718 #endif
 719     seqsize(4, 1) - seqsize(2, 1)},
 720    {
 721 #ifdef SCPACK
 722     "shl.c.pri %1!pop.alt!add!",
 723     "pop.alt!idxaddr.b %1!",
 724 #else
 725     "\276\223\275",
 726     "\231\331\345\205",
 727 #endif
 728     seqsize(3, 1) - seqsize(2, 1)},
 729    /* For packed arrays, there is another case (packed arrays
 730     * do not take advantage of the LIDX or IDXADDR instructions).
 731     *    addr.pri n1             addr.alt n1
 732     *    push.pri                load.s.pri n2
 733     *    load.s.pri n2           bounds n3
 734     *    bounds n3               -
 735     *    pop.alt                 -
 736     *
 737     * Notes (additional cases):
 738     * 1. instruction addr.pri can also be const.pri (for
 739     *    global arrays)
 740     * 2. the bounds instruction can be absent, but that
 741     *    case is already handled (see #1#)
 742     */
 743    {
 744 #ifdef SCPACK
 745     "addr.pri %1!push.pri!load.s.pri %2!bounds %3!pop.alt!",
 746     "addr.alt %1!load.s.pri %2!bounds %3!",
 747 #else
 748     "\333\300\231",
 749     "\252\334",
 750 #endif
 751     seqsize(5, 3) - seqsize(3, 3)},
 752    {
 753 #ifdef SCPACK
 754     "const.pri %1!push.pri!load.s.pri %2!bounds %3!pop.alt!",
 755     "const.alt %1!load.s.pri %2!bounds %3!",
 756 #else
 757     "\332\300\231",
 758     "\236\334",
 759 #endif
 760     seqsize(5, 3) - seqsize(3, 3)},
 761    /* During a calculation, the intermediate result must sometimes
 762     * be moved from PRI to ALT, like in:
 763     *    push.pri                move.alt
 764     *    load.s.pri n1           load.s.pri n1
 765     *    pop.alt                 -
 766     *
 767     * The above also accurs for "load.pri" and for "const.pri",
 768     * so add another two cases.
 769     */
 770    {
 771 #ifdef SCPACK
 772     "push.pri!load.s.pri %1!pop.alt!",
 773     "move.alt!load.s.pri %1!",
 774 #else
 775     "\240\324\231",
 776     "\375\324",
 777 #endif
 778     seqsize(3, 1) - seqsize(2, 1)},
 779    {
 780 #ifdef SCPACK
 781     "push.pri!load.pri %1!pop.alt!",
 782     "move.alt!load.pri %1!",
 783 #else
 784     "\240\314\231",
 785     "\375\314",
 786 #endif
 787     seqsize(3, 1) - seqsize(2, 1)},
 788    {
 789 #ifdef SCPACK
 790     "push.pri!const.pri %1!pop.alt!",
 791     "move.alt!const.pri %1!",
 792 #else
 793     "\240\316\231",
 794     "\375\316",
 795 #endif
 796     seqsize(3, 1) - seqsize(2, 1)},
 797    {
 798 #ifdef SCPACK
 799     "push.pri!zero.pri!pop.alt!",
 800     "move.alt!zero.pri!",
 801 #else
 802     "\240\376\231",
 803     "\375\376",
 804 #endif
 805     seqsize(3, 0) - seqsize(2, 0)},
 806    /* saving PRI and then loading from its address
 807     * occurs when indexing a multi-dimensional array
 808     */
 809    {
 810 #ifdef SCPACK
 811     "push.pri!load.i!pop.alt!",
 812     "move.alt!load.i!",
 813 #else
 814     "\240\213\340\231",
 815     "\375\213\340",
 816 #endif
 817     seqsize(3, 0) - seqsize(2, 0)},
 818    /* An even simpler PUSH/POP optimization (occurs in
 819     * switch statements):
 820     *    push.pri                move.alt
 821     *    pop.alt                 -
 822     */
 823    {
 824 #ifdef SCPACK
 825     "push.pri!pop.alt!",
 826     "move.alt!",
 827 #else
 828     "\240\231",
 829     "\375",
 830 #endif
 831     seqsize(2, 0) - seqsize(1, 0)},
 832    /* And what to think of this PUSH/POP sequence, which occurs
 833     * due to the support for user-defined assignment operator):
 834     *    push.alt                -
 835     *    pop.alt                 -
 836     */
 837 //???
 838 //{
 839 //  #ifdef SCPACK
 840 //    "push.alt!pop.alt!",
 841 //    ";$",     /* SCPACK cannot handle empty strings */
 842 //  #else
 843 //    "\225\237",
 844 //    "\353",
 845 //  #endif
 846 //  seqsize(2,0) - seqsize(0,0)
 847 //},
 848    /* Functions with many parameters with the same default
 849     * value have sequences like:
 850     *    push.c n1               const.pri n1
 851     *    ;$par                   push.r.pri n2   ; where n2 is the number of pushes
 852     *    push.c n1               ;$par
 853     *    ;$par                   -
 854     *    push.c n1               -
 855     *    ;$par                   -
 856     *    etc.                    etc.
 857     * The shortest matched sequence is 3, because a sequence of two can also be
 858     * optimized as two "push.c n1" instructions.
 859     * => this optimization does not work, because the argument re-ordering in
 860     *    a function call causes each argument to be optimized individually
 861     */
 862 //{
 863 //  #ifdef SCPACK
 864 //    "const.pri %1!push.pri!;$par!const.pri %1!push.pri!;$par!const.pri %1!push.pri!;$par!const.pri %1!push.pri!;$par!const.pri %1!push.pri!;$par!",
 865 //    "const.pri %1!push.r.pri 5!;$par!",
 866 //  #else
 867 //    "\327\327\254",
 868 //    "\352\221.r\2745!",
 869 //  #endif
 870 //  seqsize(10,5) - seqsize(2,2)
 871 //},
 872 //{
 873 //  #ifdef SCPACK
 874 //    "const.pri %1!push.pri!;$par!const.pri %1!push.pri!;$par!const.pri %1!push.pri!;$par!const.pri %1!push.pri!;$par!",
 875 //    "const.pri %1!push.r.pri 4!;$par!",
 876 //  #else
 877 //    "\327\327",
 878 //    "\352\221.r\274\326",
 879 //  #endif
 880 //  seqsize(8,4) - seqsize(2,2)
 881 //},
 882 //{
 883 //  #ifdef SCPACK
 884 //    "const.pri %1!push.pri!;$par!const.pri %1!push.pri!;$par!const.pri %1!push.pri!;$par!",
 885 //    "const.pri %1!push.r.pri 3!;$par!",
 886 //  #else
 887 //    "\327\254",
 888 //    "\352\221.r\274\247",
 889 //  #endif
 890 //  seqsize(6,3) - seqsize(2,2)
 891 //},
 892    /* User-defined operators first load the operands into registers and
 893     * then have them pushed onto the stack. This can give rise to sequences
 894     * like:
 895     *    const.pri n1            push.c n1
 896     *    const.alt n2            push.c n2
 897     *    push.pri                -
 898     *    push.alt                -
 899     * A similar sequence occurs with the two PUSH.pri/alt instructions inverted.
 900     * The first, second, or both CONST.pri/alt instructions can also be
 901     * LOAD.pri/alt.
 902     * This gives 2 x 4 cases.
 903     */
 904    {
 905 #ifdef SCPACK
 906     "const.pri %1!const.alt %2!push.pri!push.alt!",
 907     "push.c %1!push.c %2!",
 908 #else
 909     "\316\236\311\240\351",
 910     "\330\205\330\216",
 911 #endif
 912     seqsize(4, 2) - seqsize(2, 2)},
 913    {
 914 #ifdef SCPACK
 915     "const.pri %1!const.alt %2!push.alt!push.pri!",
 916     "push.c %2!push.c %1!",
 917 #else
 918     "\316\236\311\351\240",
 919     "\330\216\330\205",
 920 #endif
 921     seqsize(4, 2) - seqsize(2, 2)},
 922    {
 923 #ifdef SCPACK
 924     "const.pri %1!load.alt %2!push.pri!push.alt!",
 925     "push.c %1!push %2!",
 926 #else
 927     "\316\213\311\240\351",
 928     "\330\205\222\216",
 929 #endif
 930     seqsize(4, 2) - seqsize(2, 2)},
 931    {
 932 #ifdef SCPACK
 933     "const.pri %1!load.alt %2!push.alt!push.pri!",
 934     "push %2!push.c %1!",
 935 #else
 936     "\316\213\311\351\240",
 937     "\222\216\330\205",
 938 #endif
 939     seqsize(4, 2) - seqsize(2, 2)},
 940    {
 941 #ifdef SCPACK
 942     "load.pri %1!const.alt %2!push.pri!push.alt!",
 943     "push %1!push.c %2!",
 944 #else
 945     "\314\236\311\240\351",
 946     "\222\205\330\216",
 947 #endif
 948     seqsize(4, 2) - seqsize(2, 2)},
 949    {
 950 #ifdef SCPACK
 951     "load.pri %1!const.alt %2!push.alt!push.pri!",
 952     "push.c %2!push %1!",
 953 #else
 954     "\314\236\311\351\240",
 955     "\330\216\222\205",
 956 #endif
 957     seqsize(4, 2) - seqsize(2, 2)},
 958    {
 959 #ifdef SCPACK
 960     "load.pri %1!load.alt %2!push.pri!push.alt!",
 961     "push %1!push %2!",
 962 #else
 963     "\314\213\311\240\351",
 964     "\222\205\222\216",
 965 #endif
 966     seqsize(4, 2) - seqsize(2, 2)},
 967    {
 968 #ifdef SCPACK
 969     "load.pri %1!load.alt %2!push.alt!push.pri!",
 970     "push %2!push %1!",
 971 #else
 972     "\314\213\311\351\240",
 973     "\222\216\222\205",
 974 #endif
 975     seqsize(4, 2) - seqsize(2, 2)},
 976    /* Function calls (parameters are passed on the stack)
 977     *    load.s.pri n1           push.s n1
 978     *    push.pri                -
 979     *    --------------------------------------
 980     *    load.pri n1             push n1
 981     *    push.pri                -
 982     *    --------------------------------------
 983     *    const.pri n1            push.c n1
 984     *    push.pri                -
 985     *    --------------------------------------
 986     *    zero.pri                push.c 0
 987     *    push.pri                -
 988     *    --------------------------------------
 989     *    addr.pri n1             pushaddr n1
 990     *    push.pri                -
 991     *
 992     * However, PRI must not be needed after this instruction
 993     * if this shortcut is used. Check for the ;$par comment.
 994     */
 995    {
 996 #ifdef SCPACK
 997     "load.s.pri %1!push.pri!;$par!",
 998     "push.s %1!;$par!",
 999 #else
1000     "\224\255\344",
1001     "\222\220\205\344",
1002 #endif
1003     seqsize(2, 1) - seqsize(1, 1)},
1004    {
1005 #ifdef SCPACK
1006     "load.pri %1!push.pri!;$par!",
1007     "push %1!;$par!",
1008 #else
1009     "\213\255\344",
1010     "\222\205\344",
1011 #endif
1012     seqsize(2, 1) - seqsize(1, 1)},
1013    {
1014 #ifdef SCPACK
1015     "const.pri %1!push.pri!;$par!",
1016     "push.c %1!;$par!",
1017 #else
1018     "\236\255\344",
1019     "\330\205\344",
1020 #endif
1021     seqsize(2, 1) - seqsize(1, 1)},
1022    {
1023 #ifdef SCPACK
1024     "zero.pri!push.pri!;$par!",
1025     "push.c 0!;$par!",
1026 #else
1027     "\376\240\344",
1028     "\330 0!\344",
1029 #endif
1030     seqsize(2, 0) - seqsize(1, 1)},
1031    {
1032 #ifdef SCPACK
1033     "addr.pri %1!push.pri!;$par!",
1034     "pushaddr %1!;$par!",
1035 #else
1036     "\252\255\344",
1037     "\222\252\205\344",
1038 #endif
1039     seqsize(2, 1) - seqsize(1, 1)},
1040    /* References with a default value generate new cells on the heap
1041     * dynamically. That code often ends with:
1042     *    move.pri                push.alt
1043     *    push.pri                -
1044     */
1045    {
1046 #ifdef SCPACK
1047     "move.pri!push.pri!",
1048     "push.alt!",
1049 #else
1050     "\350\232\240",
1051     "\351",
1052 #endif
1053     seqsize(2, 0) - seqsize(1, 0)},
1054    /* Simple arithmetic operations on constants. Noteworthy is the
1055     * subtraction of a constant, since it is converted to the addition
1056     * of the inverse value.
1057     *    const.alt n1            add.c n1
1058     *    add                     -
1059     *    --------------------------------------
1060     *    const.alt n1            add.c -n1
1061     *    sub                     -
1062     *    --------------------------------------
1063     *    const.alt n1            smul.c n1
1064     *    smul                    -
1065     *    --------------------------------------
1066     *    const.alt n1            eq.c.pri n1
1067     *    eq                      -
1068     */
1069    {
1070 #ifdef SCPACK
1071     "const.alt %1!add!",
1072     "add.c %1!",
1073 #else
1074     "\360\270",
1075     "\233\247\205",
1076 #endif
1077     seqsize(2, 1) - seqsize(1, 1)},
1078    {
1079 #ifdef SCPACK
1080     "const.alt %1!sub!",
1081     "add.c -%1!",
1082 #else
1083     "\360sub!",
1084     "\233\247 -%\204",
1085 #endif
1086     seqsize(2, 1) - seqsize(1, 1)},
1087    {
1088 #ifdef SCPACK
1089     "const.alt %1!smul!",
1090     "smul.c %1!",
1091 #else
1092     "\360smul!",
1093     "smu\271\205",
1094 #endif
1095     seqsize(2, 1) - seqsize(1, 1)},
1096    {
1097 #ifdef SCPACK
1098     "const.alt %1!eq!",
1099     "eq.c.pri %1!",
1100 #else
1101     "\360\265",
1102     "\253\247\223",
1103 #endif
1104     seqsize(2, 1) - seqsize(1, 1)},
1105    /* Some operations use the alternative subtraction operation --these
1106     * can also be optimized.
1107     *    const.pri n1            load.s.pri n2
1108     *    load.s.alt n2           add.c -n1
1109     *    sub.alt                 -
1110     *    --------------------------------------
1111     *    const.pri n1            load.pri n2
1112     *    load.alt n2             add.c -n1
1113     *    sub.alt                 -
1114     */
1115    {
1116 #ifdef SCPACK
1117     "const.pri %1!load.s.alt %2!sub.alt!",
1118     "load.s.pri %2!add.c -%1!",
1119 #else
1120     "\316\224\311sub\217",
1121     "\241\233\247 -%\204",
1122 #endif
1123     seqsize(3, 2) - seqsize(2, 2)},
1124    {
1125 #ifdef SCPACK
1126     "const.pri %1!load.alt %2!sub.alt!",
1127     "load.pri %2!add.c -%1!",
1128 #else
1129     "\316\213\311sub\217",
1130     "\317\233\247 -%\204",
1131 #endif
1132     seqsize(3, 2) - seqsize(2, 2)},
1133    /* Compare and jump
1134     *    eq                      jneq n1
1135     *    jzer n1                 -
1136     *    --------------------------------------
1137     *    eq                      jeq n1
1138     *    jnz n1                  -
1139     *    --------------------------------------
1140     *    neq                     jeq n1
1141     *    jzer n1                 -
1142     *    --------------------------------------
1143     *    neq                     jneq n1
1144     *    jnz n1                  -
1145     * Compares followed by jzer occur much more
1146     * often than compares followed with jnz. So we
1147     * take the easy route here.
1148     *    less                    jgeq n1
1149     *    jzer n1                 -
1150     *    --------------------------------------
1151     *    leq                     jgrtr n1
1152     *    jzer n1                 -
1153     *    --------------------------------------
1154     *    grtr                    jleq n1
1155     *    jzer n1                 -
1156     *    --------------------------------------
1157     *    geq                     jless n1
1158     *    jzer n1                 -
1159     *    --------------------------------------
1160     *    sless                   jsgeq n1
1161     *    jzer n1                 -
1162     *    --------------------------------------
1163     *    sleq                    jsgrtr n1
1164     *    jzer n1                 -
1165     *    --------------------------------------
1166     *    sgrtr                   jsleq n1
1167     *    jzer n1                 -
1168     *    --------------------------------------
1169     *    sgeq                    jsless n1
1170     *    jzer n1                 -
1171     */
1172    {
1173 #ifdef SCPACK
1174     "eq!jzer %1!",
1175     "jneq %1!",
1176 #else
1177     "\265\305",
1178     "jn\325",
1179 #endif
1180     seqsize(2, 1) - seqsize(1, 1)},
1181    {
1182 #ifdef SCPACK
1183     "eq!jnz %1!",
1184     "jeq %1!",
1185 #else
1186     "\265jnz\205",
1187     "j\325",
1188 #endif
1189     seqsize(2, 1) - seqsize(1, 1)},
1190    {
1191 #ifdef SCPACK
1192     "neq!jzer %1!",
1193     "jeq %1!",
1194 #else
1195     "n\265\305",
1196     "j\325",
1197 #endif
1198     seqsize(2, 1) - seqsize(1, 1)},
1199    {
1200 #ifdef SCPACK
1201     "neq!jnz %1!",
1202     "jneq %1!",
1203 #else
1204     "n\265jnz\205",
1205     "jn\325",
1206 #endif
1207     seqsize(2, 1) - seqsize(1, 1)},
1208    {
1209 #ifdef SCPACK
1210     "less!jzer %1!",
1211     "jgeq %1!",
1212 #else
1213     "l\322!\305",
1214     "jg\325",
1215 #endif
1216     seqsize(2, 1) - seqsize(1, 1)},
1217    {
1218 #ifdef SCPACK
1219     "leq!jzer %1!",
1220     "jgrtr %1!",
1221 #else
1222     "l\265\305",
1223     "jg\323r\205",
1224 #endif
1225     seqsize(2, 1) - seqsize(1, 1)},
1226    {
1227 #ifdef SCPACK
1228     "grtr!jzer %1!",
1229     "jleq %1!",
1230 #else
1231     "g\323\306\305",
1232     "jl\325",
1233 #endif
1234     seqsize(2, 1) - seqsize(1, 1)},
1235    {
1236 #ifdef SCPACK
1237     "geq!jzer %1!",
1238     "jless %1!",
1239 #else
1240     "g\265\305",
1241     "jl\322\205",
1242 #endif
1243     seqsize(2, 1) - seqsize(1, 1)},
1244    {
1245 #ifdef SCPACK
1246     "sless!jzer %1!",
1247     "jsgeq %1!",
1248 #else
1249     "\357\305",
1250     "j\302\325",
1251 #endif
1252     seqsize(2, 1) - seqsize(1, 1)},
1253    {
1254 #ifdef SCPACK
1255     "sleq!jzer %1!",
1256     "jsgrtr %1!",
1257 #else
1258     "\362\305",
1259     "j\337r\205",
1260 #endif
1261     seqsize(2, 1) - seqsize(1, 1)},
1262    {
1263 #ifdef SCPACK
1264     "sgrtr!jzer %1!",
1265     "jsleq %1!",
1266 #else
1267     "\364\305",
1268     "j\303\325",
1269 #endif
1270     seqsize(2, 1) - seqsize(1, 1)},
1271    {
1272 #ifdef SCPACK
1273     "sgeq!jzer %1!",
1274     "jsless %1!",
1275 #else
1276     "\361\305",
1277     "j\341\205",
1278 #endif
1279     seqsize(2, 1) - seqsize(1, 1)},
1280    /* Test for zero (common case, especially for strings)
1281     * E.g. the test expression of: "for (i=0; str{i}!=0; ++i)"
1282     *
1283     *    zero.alt                jzer n1
1284     *    jeq n1                  -
1285     *    --------------------------------------
1286     *    zero.alt                jnz n1
1287     *    jneq n1                 -
1288     */
1289    {
1290 #ifdef SCPACK
1291     "zero.alt!jeq %1!",
1292     "jzer %1!",
1293 #else
1294     "\315\217j\325",
1295     "\305",
1296 #endif
1297     seqsize(2, 1) - seqsize(1, 1)},
1298    {
1299 #ifdef SCPACK
1300     "zero.alt!jneq %1!",
1301     "jnz %1!",
1302 #else
1303     "\315\217jn\325",
1304     "jnz\205",
1305 #endif
1306     seqsize(2, 1) - seqsize(1, 1)},
1307    /* Incrementing and decrementing leaves a value in
1308     * in PRI which may not be used (for example, as the
1309     * third expression in a "for" loop).
1310     *    inc n1                  inc n1  ; ++n
1311     *    load.pri n1             ;$exp
1312     *    ;$exp                   -
1313     *    --------------------------------------
1314     *    load.pri n1             inc n1  ; n++, e.g. "for (n=0; n<10; n++)"
1315     *    inc n1                  ;$exp
1316     *    ;$exp                   -
1317     * Plus the varieties for stack relative increments
1318     * and decrements.
1319     */
1320    {
1321 #ifdef SCPACK
1322     "inc %1!load.pri %1!;$exp!",
1323     "inc %1!;$exp!",
1324 #else
1325     "\373c\205\314\245",
1326     "\373c\261",
1327 #endif
1328     seqsize(2, 2) - seqsize(1, 1)},
1329    {
1330 #ifdef SCPACK
1331     "load.pri %1!inc %1!;$exp!",
1332     "inc %1!;$exp!",
1333 #else
1334     "\314\373c\261",
1335     "\373c\261",
1336 #endif
1337     seqsize(2, 2) - seqsize(1, 1)},
1338    {
1339 #ifdef SCPACK
1340     "inc.s %1!load.s.pri %1!;$exp!",
1341     "inc.s %1!;$exp!",
1342 #else
1343     "\373\352\205\324\245",
1344     "\373\352\261",
1345 #endif
1346     seqsize(2, 2) - seqsize(1, 1)},
1347    {
1348 #ifdef SCPACK
1349     "load.s.pri %1!inc.s %1!;$exp!",
1350     "inc.s %1!;$exp!",
1351 #else
1352     "\324\373\352\261",
1353     "\373\352\261",
1354 #endif
1355     seqsize(2, 2) - seqsize(1, 1)},
1356    {
1357 #ifdef SCPACK
1358     "dec %1!load.pri %1!;$exp!",
1359     "dec %1!;$exp!",
1360 #else
1361     "\367c\205\314\245",
1362     "\367c\261",
1363 #endif
1364     seqsize(2, 2) - seqsize(1, 1)},
1365    {
1366 #ifdef SCPACK
1367     "load.pri %1!dec %1!;$exp!",
1368     "dec %1!;$exp!",
1369 #else
1370     "\314\367c\261",
1371     "\367c\261",
1372 #endif
1373     seqsize(2, 2) - seqsize(1, 1)},
1374    {
1375 #ifdef SCPACK
1376     "dec.s %1!load.s.pri %1!;$exp!",
1377     "dec.s %1!;$exp!",
1378 #else
1379     "\367\352\205\324\245",
1380     "\367\352\261",
1381 #endif
1382     seqsize(2, 2) - seqsize(1, 1)},
1383    {
1384 #ifdef SCPACK
1385     "load.s.pri %1!dec.s %1!;$exp!",
1386     "dec.s %1!;$exp!",
1387 #else
1388     "\324\367\352\261",
1389     "\367\352\261",
1390 #endif
1391     seqsize(2, 2) - seqsize(1, 1)},
1392    /* ??? the same (increments and decrements) for references */
1393    /* Loading the constant zero has a special opcode.
1394     * When storing zero in memory, the value of PRI must not be later on.
1395     *    const.pri 0             zero n1
1396     *    stor.pri n1             ;$exp
1397     *    ;$exp                   -
1398     *    --------------------------------------
1399     *    const.pri 0             zero.s n1
1400     *    stor.s.pri n1           ;$exp
1401     *    ;$exp                   -
1402     *    --------------------------------------
1403     *    zero.pri                zero n1
1404     *    stor.pri n1             ;$exp
1405     *    ;$exp                   -
1406     *    --------------------------------------
1407     *    zero.pri                zero.s n1
1408     *    stor.s.pri n1           ;$exp
1409     *    ;$exp                   -
1410     *    --------------------------------------
1411     *    const.pri 0             zero.pri
1412     *    --------------------------------------
1413     *    const.alt 0             zero.alt
1414     * The last two alternatives save more memory than they save
1415     * time, but anyway...
1416     */
1417    {
1418 #ifdef SCPACK
1419     "const.pri 0!stor.pri %1!;$exp!",
1420     "zero %1!;$exp!",
1421 #else
1422     "\236\203 0!\227or\223\245",
1423     "\315\261",
1424 #endif
1425     seqsize(2, 2) - seqsize(1, 1)},
1426    {
1427 #ifdef SCPACK
1428     "const.pri 0!stor.s.pri %1!;$exp!",
1429     "zero.s %1!;$exp!",
1430 #else
1431     "\236\203 0!\227or\220\223\245",
1432     "\315\220\261",
1433 #endif
1434     seqsize(2, 2) - seqsize(1, 1)},
1435    {
1436 #ifdef SCPACK
1437     "zero.pri!stor.pri %1!;$exp!",
1438     "zero %1!;$exp!",
1439 #else
1440     "\376\227or\223\245",
1441     "\315\261",
1442 #endif
1443     seqsize(2, 1) - seqsize(1, 1)},
1444    {
1445 #ifdef SCPACK
1446     "zero.pri!stor.s.pri %1!;$exp!",
1447     "zero.s %1!;$exp!",
1448 #else
1449     "\376\227or\220\223\245",
1450     "\315\220\261",
1451 #endif
1452     seqsize(2, 1) - seqsize(1, 1)},
1453    {
1454 #ifdef SCPACK
1455     "const.pri 0!",
1456     "zero.pri!",
1457 #else
1458     "\236\203 0!",
1459     "\376",
1460 #endif
1461     seqsize(1, 1) - seqsize(1, 0)},
1462    {
1463 #ifdef SCPACK
1464     "const.alt 0!",
1465     "zero.alt!",
1466 #else
1467     "\236\211 0!",
1468     "\315\217",
1469 #endif
1470     seqsize(1, 1) - seqsize(1, 0)},
1471    /* ----- */
1472    {NULL, NULL, 0}
1473 };