开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > 手机WAP编程 > 查看源码
wsasm.c
资源名称：gateway-1.2.1　[点击查看]
上传用户：gzpyjq
上传日期：2013-01-31
资源大小：1852k
文件大小：27k
源码类别：

手机WAP编程

开发平台：

WINDOWS

wsasm.c：源码内容
  1. /*
  2.  *
  3.  * wsasm.c
  4.  *
  5.  * Author: Markku Rossi <mtr@iki.fi>
  6.  *
  7.  * Copyright (c) 1999-2000 WAPIT OY LTD.
  8.  *  All rights reserved.
  9.  *
  10.  * Byte-code assembler.
  11.  *
  12.  */
  14. #include "wsint.h"
  15. #include "wsasm.h"
  16. #include "wsstdlib.h"
  18. /********************* Macros to fetch items from BC operands ***********/
  20. #define WS_OPNAME(op) (operands[(op)].name)
  21. #define WS_OPSIZE(op) (operands[(op)].size)
  23. /********************* Byte-code operands *******************************/
  25. static struct
  26. {
  27.     char *name;
  28.     int size;
  29. } operands[256] = {
  30. #include "wsopcodes.h"
  31. };
  33. /********************* Symbolic assembler instructions ******************/
  35. /* General helpers. */
  37. void ws_asm_link(WsCompiler *compiler, WsAsmIns *ins)
  38. {
  39.     if (compiler->asm_tail) {
  40.         compiler->asm_tail->next = ins;
  41.         ins->prev = compiler->asm_tail;
  43.         compiler->asm_tail = ins;
  44.     } else
  45.         compiler->asm_tail = compiler->asm_head = ins;
  46. }
  49. void ws_asm_print(WsCompiler *compiler)
  50. {
  51.     WsAsmIns *ins;
  53.     for (ins = compiler->asm_head; ins; ins = ins->next) {
  54.         if (ins->type > 0xff) {
  55.             /* A symbolic operand. */
  56.             switch (ins->type) {
  57.             case WS_ASM_P_LABEL:
  58.                 ws_fprintf(WS_STDOUT, ".L%d:tttt/* refcount=%d */n",
  59.                            ins->ws_label_idx, ins->ws_label_refcount);
  60.                 break;
  62.             case WS_ASM_P_JUMP:
  63.                 ws_fprintf(WS_STDOUT, "tjump*ttL%dn",
  64.                            ins->ws_label->ws_label_idx);
  65.                 break;
  67.             case WS_ASM_P_TJUMP:
  68.                 ws_fprintf(WS_STDOUT, "ttjump*ttL%dn",
  69.                            ins->ws_label->ws_label_idx);
  70.                 break;
  72.             case WS_ASM_P_CALL:
  73.                 ws_fprintf(WS_STDOUT, "tcall*tt%sn",
  74.                            compiler->functions[ins->ws_findex].name);
  75.                 break;
  77.             case WS_ASM_P_CALL_LIB:
  78.                 {
  79.                     const char *lib;
  80.                     const char *func;
  82.                     ws_stdlib_function_name(ins->ws_lindex,
  83.                                             ins->ws_findex,
  84.                                             &lib, &func);
  85.                     ws_fprintf(WS_STDOUT, "tcall_lib*t%s.%sn",
  86.                                lib ? lib : "???",
  87.                                func ? func : "???");
  88.                 }
  89.                 break;
  91.             case WS_ASM_P_CALL_URL:
  92.                 ws_fprintf(WS_STDOUT, "tcall_url*t%u %u %un",
  93.                            ins->ws_lindex, ins->ws_findex, ins->ws_args);
  94.                 break;
  96.             case WS_ASM_P_LOAD_VAR:
  97.                 ws_fprintf(WS_STDOUT, "tload_var*t%un", ins->ws_vindex);
  98.                 break;
  100.             case WS_ASM_P_STORE_VAR:
  101.                 ws_fprintf(WS_STDOUT, "tstore_var*t%un", ins->ws_vindex);
  102.                 break;
  104.             case WS_ASM_P_INCR_VAR:
  105.                 ws_fprintf(WS_STDOUT, "tincr_var*t%un", ins->ws_vindex);
  106.                 break;
  108.             case WS_ASM_P_LOAD_CONST:
  109.                 ws_fprintf(WS_STDOUT, "tload_const*t%un", ins->ws_cindex);
  110.                 break;
  111.             }
  112.         } else {
  113.             WsUInt8 op = WS_ASM_OP(ins->type);
  115.             if (operands[op].name) {
  116.                 /* Operands add_asg and sub_asg are special. */
  117.                 if (op == WS_ASM_ADD_ASG || op == WS_ASM_SUB_ASG)
  118.                     ws_fprintf(WS_STDOUT, "t%stt%un", operands[ins->type].name,
  119.                                ins->ws_vindex);
  120.                 else
  121.                     ws_fprintf(WS_STDOUT, "t%sn", operands[ins->type].name);
  122.             } else
  123.                 ws_fatal("ws_asm_print(): unknown operand 0x%x", op);
  124.         }
  125.     }
  126. }
  129. void ws_asm_dasm(WsCompilerPtr compiler, const unsigned char *code, size_t len)
  130. {
  131.     size_t i = 0;
  133.     while (i < len) {
  134.         WsUInt8 byt = code[i];
  135.         WsUInt8 op;
  136.         WsUInt8 arg;
  137.         WsUInt8 i8, j8, k8;
  138.         WsUInt16 i16, j16;
  140.         op = WS_ASM_OP(byt);
  141.         arg = WS_ASM_ARG(byt);
  143.         ws_fprintf(WS_STDOUT, "%4x:t%-16s", i, WS_OPNAME(op));
  145.         switch (op) {
  146.             /* The `short jumps'. */
  147.         case WS_ASM_JUMP_FW_S:
  148.         case WS_ASM_TJUMP_FW_S:
  149.             ws_fprintf(WS_STDOUT, "%xn", i + WS_OPSIZE(op) + arg);
  150.             break;
  152.         case WS_ASM_JUMP_BW_S:
  153.             ws_fprintf(WS_STDOUT, "%xn", i - arg);
  154.             break;
  156.             /* Jumps with WsUInt8 argument. */
  157.         case WS_ASM_JUMP_FW:
  158.         case WS_ASM_TJUMP_FW:
  159.             WS_GET_UINT8(code + i + 1, i8);
  160.             ws_fprintf(WS_STDOUT, "%xn", i + WS_OPSIZE(op) + i8);
  161.             break;
  163.         case WS_ASM_JUMP_BW:
  164.         case WS_ASM_TJUMP_BW:
  165.             WS_GET_UINT8(code + i + 1, i8);
  166.             ws_fprintf(WS_STDOUT, "%xn", i - i8);
  167.             break;
  169.             /* Jumps with wide argument. */
  170.         case WS_ASM_JUMP_FW_W:
  171.         case WS_ASM_TJUMP_FW_W:
  172.             WS_GET_UINT16(code + i + 1, i16);
  173.             ws_fprintf(WS_STDOUT, "%xn", i + WS_OPSIZE(op) + i16);
  174.             break;
  176.         case WS_ASM_JUMP_BW_W:
  177.         case WS_ASM_TJUMP_BW_W:
  178.             WS_GET_UINT16(code + i + 1, i16);
  179.             ws_fprintf(WS_STDOUT, "%xn", i - i16);
  180.             break;
  182.             /* The `short' opcodes. */
  183.         case WS_ASM_LOAD_VAR_S:
  184.         case WS_ASM_STORE_VAR_S:
  185.         case WS_ASM_INCR_VAR_S:
  186.             ws_fprintf(WS_STDOUT, "%dn", arg);
  187.             break;
  189.             /* Local script function calls. */
  190.         case WS_ASM_CALL_S:
  191.             ws_fprintf(WS_STDOUT, "%dn", arg);
  192.             break;
  194.         case WS_ASM_CALL:
  195.             WS_GET_UINT8(code + i + 1, i8);
  196.             ws_fprintf(WS_STDOUT, "%dn", i8);
  197.             break;
  199.             /* Library calls. */
  200.         case WS_ASM_CALL_LIB_S:
  201.         case WS_ASM_CALL_LIB:
  202.         case WS_ASM_CALL_LIB_W:
  203.             {
  204.                 WsUInt8 findex;
  205.                 WsUInt16 lindex;
  206.                 char lnamebuf[64];
  207.                 char fnamebuf[64];
  208.                 const char *lname;
  209.                 const char *fname;
  211.                 if (op == WS_ASM_CALL_LIB_S) {
  212.                     WS_GET_UINT8(code + i + 1, lindex);
  213.                     findex = arg;
  214.                 } else if (op == WS_ASM_CALL_LIB) {
  215.                     WS_GET_UINT8(code + i + 1, findex);
  216.                     WS_GET_UINT8(code + i + 2, lindex);
  217.                 } else {
  218.                     WS_GET_UINT8(code + i + 1, findex);
  219.                     WS_GET_UINT16(code + i + 2, lindex);
  220.                 }
  222.                 if (!ws_stdlib_function_name(lindex, findex, &lname, &fname)) {
  223.                     snprintf(lnamebuf, sizeof(lnamebuf), "%d", lindex);
  224.                     snprintf(fnamebuf, sizeof(lnamebuf), "%d", findex);
  225.                     lname = lnamebuf;
  226.                     fname = fnamebuf;
  227.                 }
  228.                 ws_fprintf(WS_STDOUT, "%s.%sn", lname, fname);
  229.             }
  230.             break;
  232.             /* URL calls. */
  233.         case WS_ASM_CALL_URL:
  234.             WS_GET_UINT8(code + i + 1, i8);
  235.             WS_GET_UINT8(code + i + 2, j8);
  236.             WS_GET_UINT8(code + i + 3, k8);
  237.             ws_fprintf(WS_STDOUT, "%d.%d %dn", i8, j8, k8);
  238.             break;
  240.         case WS_ASM_CALL_URL_W:
  241.             WS_GET_UINT16(code + i + 1, i16);
  242.             WS_GET_UINT16(code + i + 3, j16);
  243.             WS_GET_UINT8(code + i + 5, i8);
  244.             ws_fprintf(WS_STDOUT, "%d.%d %dn", i16, j16, i8);
  245.             break;
  247.             /* Constant access. */
  248.         case WS_ASM_LOAD_CONST_S:
  249.         case WS_ASM_LOAD_CONST:
  250.         case WS_ASM_LOAD_CONST_W:
  251.             if (op == WS_ASM_LOAD_CONST_S)
  252.                 i16 = arg;
  253.             else if (op == WS_ASM_LOAD_CONST) {
  254.                 WS_GET_UINT8(code + i + 1, i8);
  255.                 i16 = i8;
  256.             } else
  257.                 WS_GET_UINT16(code + i + 1, i16);
  259.             ws_fprintf(WS_STDOUT, "%dn", i16);
  260.             break;
  262.             /* Operands with WsUInt8 argument. */
  263.         case WS_ASM_LOAD_VAR:
  264.         case WS_ASM_STORE_VAR:
  265.         case WS_ASM_INCR_VAR:
  266.         case WS_ASM_DECR_VAR:
  267.         case WS_ASM_ADD_ASG:
  268.         case WS_ASM_SUB_ASG:
  269.             WS_GET_UINT8(code + i + 1, i8);
  270.             ws_fprintf(WS_STDOUT, "%dn", i8);
  271.             break;
  273.             /* The trivial cases. */
  274.         default:
  275.             ws_fprintf(WS_STDOUT, "n");
  276.             break;
  277.         }
  279.         i += WS_OPSIZE(op);
  280.     }
  281. }
  284. void
  285. ws_asm_linearize(WsCompiler *compiler)
  286. {
  287.     WsAsmIns *ins;
  288.     WsBool process_again = WS_TRUE;
  290.     /* Calculate all offsets and select real assembler instructions for
  291.        our internal pseudo instructions.  This is continued as long as
  292.        the code changes. */
  293.     while (process_again) {
  294.         WsUInt32 offset = 1;
  296.         process_again = WS_FALSE;
  298.         for (ins = compiler->asm_head; ins; ins = ins->next) {
  299.             ins->offset = offset;
  301.             switch (ins->type) {
  302.             case WS_ASM_JUMP_FW_S:
  303.                 ins->ws_offset = (ins->ws_label->offset
  304.                                   - (offset + WS_OPSIZE(ins->type)));
  305.                 break;
  307.             case WS_ASM_JUMP_FW:
  308.                 ins->ws_offset = (ins->ws_label->offset
  309.                                   - (offset + WS_OPSIZE(ins->type)));
  311.                 if (ins->ws_offset <= 31) {
  312.                     ins->type = WS_ASM_JUMP_FW_S;
  313.                     process_again = WS_TRUE;
  314.                 }
  315.                 break;
  317.             case WS_ASM_JUMP_FW_W:
  318.                 ins->ws_offset = (ins->ws_label->offset
  319.                                   - (offset + WS_OPSIZE(ins->type)));
  321.                 if (ins->ws_offset <= 31) {
  322.                     ins->type = WS_ASM_JUMP_FW_S;
  323.                     process_again = WS_TRUE;
  324.                 } else if (ins->ws_offset <= 255) {
  325.                     ins->type = WS_ASM_JUMP_FW;
  326.                     process_again = WS_TRUE;
  327.                 }
  328.                 break;
  330.             case WS_ASM_JUMP_BW_S:
  331.                 ins->ws_offset = offset - ins->ws_label->offset;
  332.                 break;
  334.             case WS_ASM_JUMP_BW:
  335.                 ins->ws_offset = offset - ins->ws_label->offset;
  337.                 if (ins->ws_offset <= 31) {
  338.                     ins->type = WS_ASM_JUMP_BW_S;
  339.                     process_again = WS_TRUE;
  340.                 }
  341.                 break;
  343.             case WS_ASM_JUMP_BW_W:
  344.                 ins->ws_offset = offset - ins->ws_label->offset;
  346.                 if (ins->ws_offset <= 31) {
  347.                     ins->type = WS_ASM_JUMP_BW_S;
  348.                     process_again = WS_TRUE;
  349.                 } else if (ins->ws_offset <= 255) {
  350.                     ins->type = WS_ASM_JUMP_BW;
  351.                     process_again = WS_TRUE;
  352.                 }
  353.                 break;
  355.             case WS_ASM_TJUMP_FW_S:
  356.                 ins->ws_offset = (ins->ws_label->offset
  357.                                   - (offset + WS_OPSIZE(ins->type)));
  358.                 break;
  360.             case WS_ASM_TJUMP_FW:
  361.                 ins->ws_offset = (ins->ws_label->offset
  362.                                   - (offset + WS_OPSIZE(ins->type)));
  364.                 if (ins->ws_offset <= 31) {
  365.                     ins->type = WS_ASM_TJUMP_FW_S;
  366.                     process_again = WS_TRUE;
  367.                 }
  368.                 break;
  370.             case WS_ASM_TJUMP_FW_W:
  371.                 ins->ws_offset = (ins->ws_label->offset
  372.                                   - (offset + WS_OPSIZE(ins->type)));
  374.                 if (ins->ws_offset <= 31) {
  375.                     ins->type = WS_ASM_TJUMP_FW_S;
  376.                     process_again = WS_TRUE;
  377.                 } else if (ins->ws_offset <= 255) {
  378.                     ins->type = WS_ASM_TJUMP_FW;
  379.                     process_again = WS_TRUE;
  380.                 }
  381.                 break;
  383.             case WS_ASM_TJUMP_BW:
  384.                  ins->ws_offset = offset - ins->ws_label->offset;
  385.                  break;
  387.             case WS_ASM_TJUMP_BW_W:
  388.                 ins->ws_offset = offset - ins->ws_label->offset;
  390.                 if (ins->ws_offset <= 255) {
  391.                     ins->type = WS_ASM_TJUMP_BW;
  392.                     process_again = WS_TRUE;
  393.                 }
  394.                 break;
  396.                 /*
  397.                  * The pseudo instructions.
  398.                  */
  400.             case WS_ASM_P_LABEL:
  401.                 /* Nothing here. */
  402.                 break;
  404.             case WS_ASM_P_JUMP:
  405.                 if (ins->ws_label->offset == 0) {
  406.                     /* A forward jump.  Let's assume the widest form. */
  407.                     ins->type = WS_ASM_JUMP_FW_W;
  408.                 } else {
  409.                     ins->ws_offset = offset - ins->ws_label->offset;
  411.                     /* Jump backwards. */
  412.                     if (ins->ws_offset <= 31) {
  413.                         ins->type = WS_ASM_JUMP_BW_S;
  414.                     } else if (ins->ws_offset <= 255) {
  415.                         ins->type = WS_ASM_JUMP_BW;
  416.                     } else {
  417.                         ins->type = WS_ASM_JUMP_BW_W;
  418.                     }
  419.                 }
  420.                 break;
  422.             case WS_ASM_P_TJUMP:
  423.                 if (ins->ws_label->offset == 0) {
  424.                     /* A forward jump.  Let's assume the widest form. */
  425.                     ins->type = WS_ASM_TJUMP_FW_W;
  426.                     process_again = WS_TRUE;
  427.                 } else {
  428.                     ins->ws_offset = offset - ins->ws_label->offset;
  430.                     /* Jump backwards. */
  431.                     if (ins->ws_offset <= 255) {
  432.                         ins->type = WS_ASM_TJUMP_BW;
  433.                     } else {
  434.                         ins->type = WS_ASM_TJUMP_BW_W;
  435.                     }
  436.                 }
  437.                 break;
  439.             case WS_ASM_P_CALL:
  440.                 if (ins->ws_findex <= 7) {
  441.                     /* The most compact form. */
  442.                     ins->type = WS_ASM_CALL_S;
  443.                 } else {
  444.                     /* The wider form. */
  445.                     ins->type = WS_ASM_CALL;
  446.                 }
  447.                 break;
  449.             case WS_ASM_P_CALL_LIB:
  450.                 if (ins->ws_findex <= 7 && ins->ws_lindex <= 255) {
  451.                     /* The most compact form. */
  452.                     ins->type = WS_ASM_CALL_LIB_S;
  453.                 } else if (ins->ws_findex <= 255 && ins->ws_lindex <= 255) {
  454.                     /* The quite compact form. */
  455.                     ins->type = WS_ASM_CALL_LIB;
  456.                 } else {
  457.                     /* The most liberal form. */
  458.                     ins->type = WS_ASM_CALL_LIB_W;
  459.                 }
  460.                 break;
  462.             case WS_ASM_P_CALL_URL:
  463.                 if (ins->ws_findex <= 255 && ins->ws_lindex <= 255)
  464.                     /* The compact form. */
  465.                     ins->type = WS_ASM_CALL_URL;
  466.                 else
  467.                     ins->type = WS_ASM_CALL_URL_W;
  468.                 break;
  470.             case WS_ASM_P_LOAD_VAR:
  471.                 if (ins->ws_vindex <= 31)
  472.                     /* The compact form. */
  473.                     ins->type = WS_ASM_LOAD_VAR_S;
  474.                 else
  475.                     ins->type = WS_ASM_LOAD_VAR;
  476.                 break;
  478.             case WS_ASM_P_STORE_VAR:
  479.                 if (ins->ws_vindex <= 15)
  480.                     ins->type = WS_ASM_STORE_VAR_S;
  481.                 else
  482.                     ins->type = WS_ASM_STORE_VAR;
  483.                 break;
  485.             case WS_ASM_P_INCR_VAR:
  486.                 if (ins->ws_vindex <= 7)
  487.                     ins->type = WS_ASM_INCR_VAR_S;
  488.                 else
  489.                     ins->type = WS_ASM_INCR_VAR;
  490.                 break;
  492.             case WS_ASM_P_LOAD_CONST:
  493.                 if (ins->ws_cindex <= 15)
  494.                     ins->type = WS_ASM_LOAD_CONST_S;
  495.                 else if (ins->ws_cindex <= 255)
  496.                     ins->type = WS_ASM_LOAD_CONST;
  497.                 else
  498.                     ins->type = WS_ASM_LOAD_CONST_W;
  499.                 break;
  500.             }
  502.             gw_assert(ins->type == WS_ASM_P_LABEL || ins->type < 0x100);
  504.             if (ins->type != WS_ASM_P_LABEL) {
  505.                 gw_assert(operands[ins->type].name != NULL);
  506.                 offset += operands[ins->type].size;
  507.             }
  508.         }
  509.     }
  511.     /* Ok, ready to linearize the byte-code. */
  512.     for (ins = compiler->asm_head; ins; ins = ins->next) {
  513.         if (ins->type == WS_ASM_P_LABEL)
  514.             continue;
  516.         gw_assert(ins->type <= 0xff);
  518.         switch (ins->type) {
  519.         case WS_ASM_JUMP_FW_S:
  520.         case WS_ASM_JUMP_BW_S:
  521.         case WS_ASM_TJUMP_FW_S:
  522.             if (!ws_encode_buffer(&compiler->byte_code,
  523.                                   WS_ENC_BYTE,
  524.                                   WS_ASM_GLUE(ins->type, ins->ws_offset),
  525.                                   WS_ENC_END))
  526.                 goto error;
  527.             break;
  529.         case WS_ASM_JUMP_FW:
  530.         case WS_ASM_JUMP_BW:
  531.         case WS_ASM_TJUMP_FW:
  532.         case WS_ASM_TJUMP_BW:
  533.             if (!ws_encode_buffer(&compiler->byte_code,
  534.                                   WS_ENC_BYTE, ins->type,
  535.                                   WS_ENC_UINT8, (WsUInt8) ins->ws_offset,
  536.                                   WS_ENC_END))
  537.                 goto error;
  538.             break;
  540.         case WS_ASM_JUMP_FW_W:
  541.         case WS_ASM_JUMP_BW_W:
  542.         case WS_ASM_TJUMP_FW_W:
  543.         case WS_ASM_TJUMP_BW_W:
  544.             if (!ws_encode_buffer(&compiler->byte_code,
  545.                                   WS_ENC_BYTE, ins->type,
  546.                                   WS_ENC_UINT16, (WsUInt16) ins->ws_offset,
  547.                                   WS_ENC_END))
  548.                 goto error;
  549.             break;
  551.         case WS_ASM_CALL_S:
  552.             if (!ws_encode_buffer(&compiler->byte_code,
  553.                                   WS_ENC_BYTE,
  554.                                   WS_ASM_GLUE(ins->type, ins->ws_findex),
  555.                                   WS_ENC_END))
  556.                 goto error;
  557.             break;
  559.         case WS_ASM_CALL:
  560.             if (!ws_encode_buffer(&compiler->byte_code,
  561.                                   WS_ENC_BYTE, (WsByte) ins->type,
  562.                                   WS_ENC_UINT8, (WsUInt8) ins->ws_findex,
  563.                                   WS_ENC_END))
  564.                 goto error;
  565.             break;
  567.         case WS_ASM_CALL_LIB_S:
  568.             if (!ws_encode_buffer(&compiler->byte_code,
  569.                                   WS_ENC_BYTE,
  570.                                   WS_ASM_GLUE(ins->type, ins->ws_findex),
  571.                                   WS_ENC_UINT8, (WsUInt8) ins->ws_lindex,
  572.                                   WS_ENC_END))
  573.                 goto error;
  574.             break;
  576.         case WS_ASM_CALL_LIB:
  577.             if (!ws_encode_buffer(&compiler->byte_code,
  578.                                   WS_ENC_BYTE, (WsByte) ins->type,
  579.                                   WS_ENC_UINT8, (WsUInt8) ins->ws_findex,
  580.                                   WS_ENC_UINT8, (WsUInt8) ins->ws_lindex,
  581.                                   WS_ENC_END))
  582.                 goto error;
  583.             break;
  585.         case WS_ASM_CALL_LIB_W:
  586.             if (!ws_encode_buffer(&compiler->byte_code,
  587.                                   WS_ENC_BYTE, (WsByte) ins->type,
  588.                                   WS_ENC_UINT8, (WsUInt8) ins->ws_findex,
  589.                                   WS_ENC_UINT16, (WsUInt16) ins->ws_lindex,
  590.                                   WS_ENC_END))
  591.                 goto error;
  592.             break;
  594.         case WS_ASM_CALL_URL:
  595.             if (!ws_encode_buffer(&compiler->byte_code,
  596.                                   WS_ENC_BYTE, (WsByte) ins->type,
  597.                                   WS_ENC_UINT8, (WsUInt8) ins->ws_lindex,
  598.                                   WS_ENC_UINT8, (WsUInt8) ins->ws_findex,
  599.                                   WS_ENC_UINT8, (WsUInt8) ins->ws_args,
  600.                                   WS_ENC_END))
  601.                 goto error;
  602.             break;
  604.         case WS_ASM_CALL_URL_W:
  605.             if (!ws_encode_buffer(&compiler->byte_code,
  606.                                   WS_ENC_BYTE, (WsByte) ins->type,
  607.                                   WS_ENC_UINT16, (WsUInt16) ins->ws_lindex,
  608.                                   WS_ENC_UINT16, (WsUInt16) ins->ws_findex,
  609.                                   WS_ENC_UINT8, (WsUInt8) ins->ws_args,
  610.                                   WS_ENC_END))
  611.                 goto error;
  612.             break;
  614.         case WS_ASM_LOAD_VAR_S:
  615.         case WS_ASM_STORE_VAR_S:
  616.             if (!ws_encode_buffer(&compiler->byte_code,
  617.                                   WS_ENC_BYTE,
  618.                                   WS_ASM_GLUE(ins->type, ins->ws_vindex),
  619.                                   WS_ENC_END))
  620.                 goto error;
  621.             break;
  623.         case WS_ASM_LOAD_VAR:
  624.         case WS_ASM_STORE_VAR:
  625.             if (!ws_encode_buffer(&compiler->byte_code,
  626.                                   WS_ENC_BYTE, (WsByte) ins->type,
  627.                                   WS_ENC_UINT8, (WsUInt8) ins->ws_vindex,
  628.                                   WS_ENC_END))
  629.                 goto error;
  630.             break;
  632.         case WS_ASM_INCR_VAR_S:
  633.             if (!ws_encode_buffer(&compiler->byte_code,
  634.                                   WS_ENC_BYTE,
  635.                                   WS_ASM_GLUE(ins->type, ins->ws_vindex),
  636.                                   WS_ENC_END))
  637.                 goto error;
  638.             break;
  640.         case WS_ASM_INCR_VAR:
  641.         case WS_ASM_DECR_VAR:
  642.             if (!ws_encode_buffer(&compiler->byte_code,
  643.                                   WS_ENC_BYTE, (WsByte) ins->type,
  644.                                   WS_ENC_UINT8, (WsUInt8) ins->ws_vindex,
  645.                                   WS_ENC_END))
  646.                 goto error;
  647.             break;
  649.         case WS_ASM_LOAD_CONST_S:
  650.             if (!ws_encode_buffer(&compiler->byte_code,
  651.                                   WS_ENC_BYTE,
  652.                                   WS_ASM_GLUE(ins->type, ins->ws_cindex),
  653.                                   WS_ENC_END))
  654.                 goto error;
  655.             break;
  657.         case WS_ASM_LOAD_CONST:
  658.             if (!ws_encode_buffer(&compiler->byte_code,
  659.                                   WS_ENC_BYTE, (WsByte) ins->type,
  660.                                   WS_ENC_UINT8, (WsUInt8) ins->ws_cindex,
  661.                                   WS_ENC_END))
  662.                 goto error;
  663.             break;
  665.         case WS_ASM_LOAD_CONST_W:
  666.             if (!ws_encode_buffer(&compiler->byte_code,
  667.                                   WS_ENC_BYTE, (WsByte) ins->type,
  668.                                   WS_ENC_UINT16, (WsUInt16) ins->ws_cindex,
  669.                                   WS_ENC_END))
  670.                 goto error;
  671.             break;
  673.         case WS_ASM_ADD_ASG:
  674.         case WS_ASM_SUB_ASG:
  675.             if (!ws_encode_buffer(&compiler->byte_code,
  676.                                   WS_ENC_BYTE, (WsByte) ins->type,
  677.                                   WS_ENC_UINT8, (WsUInt8) ins->ws_vindex,
  678.                                   WS_ENC_END))
  679.                 goto error;
  680.             break;
  682.         case WS_ASM_CONST_0:
  683.         case WS_ASM_CONST_1:
  684.         case WS_ASM_CONST_M1:
  685.         case WS_ASM_CONST_ES:
  686.         case WS_ASM_CONST_INVALID:
  687.         case WS_ASM_CONST_TRUE:
  688.         case WS_ASM_CONST_FALSE:
  689.         case WS_ASM_INCR:
  690.         case WS_ASM_DECR:
  691.         case WS_ASM_UMINUS:
  692.         case WS_ASM_ADD:
  693.         case WS_ASM_SUB:
  694.         case WS_ASM_MUL:
  695.         case WS_ASM_DIV:
  696.         case WS_ASM_IDIV:
  697.         case WS_ASM_REM:
  698.         case WS_ASM_B_AND:
  699.         case WS_ASM_B_OR:
  700.         case WS_ASM_B_XOR:
  701.         case WS_ASM_B_NOT:
  702.         case WS_ASM_B_LSHIFT:
  703.         case WS_ASM_B_RSSHIFT:
  704.         case WS_ASM_B_RSZSHIFT:
  705.         case WS_ASM_EQ:
  706.         case WS_ASM_LE:
  707.         case WS_ASM_LT:
  708.         case WS_ASM_GE:
  709.         case WS_ASM_GT:
  710.         case WS_ASM_NE:
  711.         case WS_ASM_NOT:
  712.         case WS_ASM_SCAND:
  713.         case WS_ASM_SCOR:
  714.         case WS_ASM_TOBOOL:
  715.         case WS_ASM_POP:
  716.         case WS_ASM_TYPEOF:
  717.         case WS_ASM_ISVALID:
  718.         case WS_ASM_RETURN:
  719.         case WS_ASM_RETURN_ES:
  720.         case WS_ASM_DEBUG:
  721.             if (!ws_encode_buffer(&compiler->byte_code,
  722.                                   WS_ENC_BYTE, (WsByte) ins->type,
  723.                                   WS_ENC_END))
  724.                 goto error;
  725.             break;
  727.         default:
  728.             ws_fatal("ws_asm_linearize(): unknown instruction 0x%02x",
  729.                      ins->type);
  730.             break;
  731.         }
  732.     }
  734.     /*
  735.      * Avoid generating 0-length functions, because not all clients
  736.      * handle them correctly.
  737.      */
  738.     if (ws_buffer_len(&compiler->byte_code) == 0) {
  739. if (!ws_encode_buffer(&compiler->byte_code,
  740.           WS_ENC_BYTE, (WsByte) WS_ASM_RETURN_ES,
  741.       WS_ENC_END))
  742.     goto error;
  743.     }
  745.     return;
  747.     /*
  748.      * Error handling.
  749.      */
  751. error:
  753.     ws_error_memory(compiler);
  754.     return;
  755. }
  758. /* Contructors for assembler instructions. */
  760. static WsAsmIns *asm_alloc(WsCompiler *compiler, WsUInt16 type, WsUInt32 line)
  761. {
  762.     WsAsmIns *ins = ws_f_calloc(compiler->pool_asm, 1, sizeof(*ins));
  764.     if (ins == NULL)
  765.         ws_error_memory(compiler);
  766.     else {
  767.         ins->type = type;
  768.         ins->line = line;
  769.     }
  771.     return ins;
  772. }
  775. WsAsmIns *ws_asm_label(WsCompiler *compiler, WsUInt32 line)
  776. {
  777.     WsAsmIns *ins = asm_alloc(compiler, WS_ASM_P_LABEL, line);
  779.     if (ins)
  780.         ins->ws_label_idx = compiler->next_label++;
  782.     return ins;
  783. }
  786. WsAsmIns *ws_asm_branch(WsCompiler *compiler, WsUInt32 line, WsUInt16 inst,
  787.                         WsAsmIns *label)
  788. {
  789.     WsAsmIns *ins = asm_alloc(compiler, inst, line);
  791.     if (ins) {
  792.         ins->ws_label = label;
  793.         label->ws_label_refcount++;
  794.     }
  796.     return ins;
  797. }
  800. WsAsmIns *ws_asm_call(WsCompiler *compiler, WsUInt32 line, WsUInt8 findex)
  801. {
  802.     WsAsmIns *ins = asm_alloc(compiler, WS_ASM_P_CALL, line);
  804.     if (ins)
  805.         ins->ws_findex = findex;
  807.     return ins;
  808. }
  811. WsAsmIns *ws_asm_call_lib(WsCompiler *compiler, WsUInt32 line, WsUInt8 findex,
  812.                 WsUInt16 lindex)
  813. {
  814.     WsAsmIns *ins = asm_alloc(compiler, WS_ASM_P_CALL_LIB, line);
  816.     if (ins) {
  817.         ins->ws_findex = findex;
  818.         ins->ws_lindex = lindex;
  819.     }
  821.     return ins;
  822. }
  825. WsAsmIns *ws_asm_call_url(WsCompiler *compiler, WsUInt32 line, WsUInt16 findex,
  826.                           WsUInt16 urlindex, WsUInt8 args)
  827. {
  828.     WsAsmIns *ins = asm_alloc(compiler, WS_ASM_P_CALL_URL, line);
  830.     if (ins) {
  831.         ins->ws_findex = findex;
  832.         ins->ws_lindex = urlindex;
  833.         ins->ws_args = args;
  834.     }
  836.     return ins;
  837. }
  840. WsAsmIns *ws_asm_variable(WsCompiler *compiler, WsUInt32 line, WsUInt16 inst,
  841.                           WsUInt8 vindex)
  842. {
  843.     WsAsmIns *ins = asm_alloc(compiler, inst, line);
  845.     if (ins)
  846.         ins->ws_vindex = vindex;
  848.     return ins;
  849. }
  852. WsAsmIns *ws_asm_load_const(WsCompiler *compiler, WsUInt32 line,
  853.                             WsUInt16 cindex)
  854. {
  855.     WsAsmIns *ins = asm_alloc(compiler, WS_ASM_P_LOAD_CONST, line);
  857.     if (ins)
  858.         ins->ws_cindex = cindex;
  860.     return ins;
  861. }
  864. WsAsmIns *ws_asm_ins(WsCompiler *compiler, WsUInt32 line, WsUInt8 opcode)
  865. {
  866.     return asm_alloc(compiler, opcode, line);
  867. }