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

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

手机WAP编程

开发平台：

WINDOWS

wsbc.c：源码内容
  1. /*
  2.  *
  3.  * wsbc.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 handling functions.
  11.  *
  12.  */
  14. #include "wsint.h"
  15. #include "wsbc.h"
  17. /********************* Prototypes for static functions ******************/
  19. /* Add a new pragma of type `type' to the byte-code `bc'.  The
  20.  * function returns a pointer to an internal pragma structure that
  21.  * must not be freed by the caller.  It is freed when the byte-code
  22.  * `bc' is freed.  The function returns NULL if the pragma structure
  23.  * could not be allocated. */
  24. static WsBcPragma *add_pragma(WsBc *bc, WsBcPragmaType type);
  26. /********************* Manipulating byte-code structure *****************/
  28. WsBc *ws_bc_alloc(WsBcStringEncoding string_encoding)
  29. {
  30.     WsBc *bc = ws_calloc(1, sizeof(WsBc));
  32.     if (bc == NULL)
  33.         return NULL;
  35.     bc->string_encoding = string_encoding;
  37.     return bc;
  38. }
  41. void ws_bc_free(WsBc *bc)
  42. {
  43.     WsUInt16 i;
  44.     WsUInt8 j;
  46.     if (bc == NULL)
  47.         return;
  49.     /* Free constants. */
  50.     for (i = 0; i < bc->num_constants; i++) {
  51.         WsBcConstant *c = &bc->constants[i];
  53.         if (c->type == WS_BC_CONST_TYPE_UTF8_STRING)
  54.             ws_free(c->u.v_string.data);
  55.     }
  56.     ws_free(bc->constants);
  58.     /* Free pragmas. */
  59.     ws_free(bc->pragmas);
  61.     /* Free function names. */
  62.     for (j = 0; j < bc->num_function_names; j++)
  63.         ws_free(bc->function_names[j].name);
  64.     ws_free(bc->function_names);
  66.     /* Free functions. */
  67.     for (j = 0; j < bc->num_functions; j++)
  68.         ws_free(bc->functions[j].code);
  69.     ws_free(bc->functions);
  71.     /* Free the byte-code structure. */
  72.     ws_free(bc);
  73. }
  76. WsBool ws_bc_encode(WsBc *bc, unsigned char **data_return,
  77.                     size_t *data_len_return)
  78. {
  79.     WsBuffer buffer;
  80.     WsUInt32 ui;
  81.     unsigned char data[64];
  82.     unsigned char *p, *mb;
  83.     size_t len;
  85.     ws_buffer_init(&buffer);
  87.     /* Append space for the header.  We do not know yet the size of the
  88.        resulting byte-code. */
  89.     if (!ws_buffer_append_space(&buffer, NULL, WS_BC_MAX_HEADER_LEN))
  90.         goto error;
  93.     /* Constants. */
  95.     if (!ws_encode_buffer(&buffer,
  96.                           WS_ENC_MB_UINT16, bc->num_constants,
  97.                           WS_ENC_MB_UINT16, (WsUInt16) bc->string_encoding,
  98.                           WS_ENC_END))
  99.         goto error;
  101.     for (ui = 0 ; ui < bc->num_constants; ui++) {
  102.         switch (bc->constants[ui].type) {
  103.         case WS_BC_CONST_TYPE_INT:
  104.             if (WS_INT8_MIN <= bc->constants[ui].u.v_int
  105.                 && bc->constants[ui].u.v_int <= WS_INT8_MAX) {
  106.                 if (!ws_encode_buffer(&buffer,
  107.                                       WS_ENC_UINT8, (WsUInt8) WS_BC_CONST_INT8,
  108.                                       WS_ENC_INT8,
  109.                                       (WsInt8) bc->constants[ui].u.v_int,
  110.                                       WS_ENC_END))
  111.                     goto error;
  112.             } else if (WS_INT16_MIN <= bc->constants[ui].u.v_int
  113.                        && bc->constants[ui].u.v_int <= WS_INT16_MAX) {
  114.                 if (!ws_encode_buffer(&buffer,
  115.                                       WS_ENC_UINT8, (WsUInt8) WS_BC_CONST_INT16,
  116.                                       WS_ENC_INT16,
  117.                                       (WsInt16) bc->constants[ui].u.v_int,
  118.                                       WS_ENC_END))
  119.                     goto error;
  120.             } else {
  121.                 if (!ws_encode_buffer(&buffer,
  122.                                       WS_ENC_UINT8, (WsUInt8) WS_BC_CONST_INT32,
  123.                                       WS_ENC_INT32, bc->constants[ui].u.v_int,
  124.                                       WS_ENC_END))
  125.                     goto error;
  126.             }
  127.             break;
  129.         case WS_BC_CONST_TYPE_FLOAT32:
  130.         case WS_BC_CONST_TYPE_FLOAT32_NAN:
  131.         case WS_BC_CONST_TYPE_FLOAT32_POSITIVE_INF:
  132.         case WS_BC_CONST_TYPE_FLOAT32_NEGATIVE_INF:
  133.             switch (bc->constants[ui].type) {
  134.             case WS_BC_CONST_TYPE_FLOAT32:
  135.                 ws_ieee754_encode_single(bc->constants[ui].u.v_float, data);
  136.                 p = data;
  137.                 break;
  139.             case WS_BC_CONST_TYPE_FLOAT32_NAN:
  140.                 p = ws_ieee754_nan;
  141.                 break;
  143.             case WS_BC_CONST_TYPE_FLOAT32_POSITIVE_INF:
  144.                 p = ws_ieee754_positive_inf;
  145.                 break;
  147.             case WS_BC_CONST_TYPE_FLOAT32_NEGATIVE_INF:
  148.                 p = ws_ieee754_negative_inf;
  149.                 break;
  151.             default:
  152.                 ws_fatal("ws_bc_encode(): internal inconsistency");
  153.                 /* NOTREACHED */
  154.                 p = NULL;  /* Initialized to keep compiler quiet. */
  155.                 break;
  156.             }
  158.             if (!ws_encode_buffer(&buffer,
  159.                                   WS_ENC_UINT8, (WsUInt8) WS_BC_CONST_FLOAT32,
  160.                                   WS_ENC_DATA, p, 4,
  161.                                   WS_ENC_END))
  162.                 goto error;
  163.             break;
  165.             break;
  167.         case WS_BC_CONST_TYPE_UTF8_STRING:
  168.             /* Encode the strings as requested. */
  169.             switch (bc->string_encoding) {
  170.             case WS_BC_STRING_ENC_ISO_8859_1:
  171.                 {
  172.                     WsUtf8String *string = ws_utf8_alloc();
  173.                     unsigned char *latin1;
  174.                     size_t latin1_len;
  175.                     WsBool success;
  177.                     if (string == NULL)
  178.                         goto error;
  180.                     /* Create an UTF-8 string. */
  181.                     if (!ws_utf8_set_data(string,
  182.                                           bc->constants[ui].u.v_string.data,
  183.                                           bc->constants[ui].u.v_string.len)) {
  184.                         ws_utf8_free(string);
  185.                         goto error;
  186.                     }
  188.                     /* Convert it to latin1. */
  189.                     latin1 = ws_utf8_to_latin1(string, '?', &latin1_len);
  191.                     /* We'r done with the UTF-8 string. */
  192.                     ws_utf8_free(string);
  194.                     if (latin1 == NULL)
  195.                         goto error;
  197.                     /* Encode it. */
  198.                     success = ws_encode_buffer(
  199.                                   &buffer,
  200.                                   WS_ENC_UINT8,
  201.                                   (WsUInt8) WS_BC_CONST_EXT_ENC_STRING,
  203.                                   WS_ENC_MB_UINT32, (WsUInt32) latin1_len,
  204.                                   WS_ENC_DATA, latin1, latin1_len,
  206.                                   WS_ENC_END);
  207.                     ws_utf8_free_data(latin1);
  209.                     if (!success)
  210.                         goto error;
  211.                 }
  212.                 break;
  214.             case WS_BC_STRING_ENC_UTF8:
  215.                 if (!ws_encode_buffer(
  216.                         &buffer,
  217.                         WS_ENC_UINT8,
  218.                         (WsUInt8) WS_BC_CONST_UTF8_STRING,
  220.                         WS_ENC_MB_UINT32,
  221.                         (WsUInt32) bc->constants[ui].u.v_string.len,
  223.                         WS_ENC_DATA,
  224.                         bc->constants[ui].u.v_string.data,
  225.                         bc->constants[ui].u.v_string.len,
  227.                         WS_ENC_END))
  228.                     goto error;
  229.                 break;
  230.             }
  231.             break;
  233.         case WS_BC_CONST_TYPE_EMPTY_STRING:
  234.             if (!ws_encode_buffer(&buffer,
  235.                                   WS_ENC_UINT8,
  236.                                   (WsUInt8) WS_BC_CONST_EMPTY_STRING,
  237.                                   WS_ENC_END))
  238.                 goto error;
  239.             break;
  240.         }
  241.     }
  244.     /* Pragmas. */
  246.     if (!ws_encode_buffer(&buffer,
  247.                           WS_ENC_MB_UINT16, bc->num_pragmas,
  248.                           WS_ENC_END))
  249.         goto error;
  251.     for (ui = 0; ui < bc->num_pragmas; ui++) {
  252.         switch (bc->pragmas[ui].type) {
  253.         case WS_BC_PRAGMA_TYPE_ACCESS_DOMAIN:
  254.             if (!ws_encode_buffer(&buffer,
  255.                                   WS_ENC_UINT8,
  256.                                   (WsUInt8) WS_BC_PRAGMA_ACCESS_DOMAIN,
  258.                                   WS_ENC_MB_UINT16, bc->pragmas[ui].index_1,
  259.                                   WS_ENC_END))
  260.                 goto error;
  261.             break;
  263.         case WS_BC_PRAGMA_TYPE_ACCESS_PATH:
  264.             if (!ws_encode_buffer(&buffer,
  265.                                   WS_ENC_UINT8,
  266.                                   (WsUInt8) WS_BC_PRAGMA_ACCESS_PATH,
  267.                                   WS_ENC_MB_UINT16, bc->pragmas[ui].index_1,
  268.                                   WS_ENC_END))
  269.                 goto error;
  270.             break;
  272.         case WS_BC_PRAGMA_TYPE_USER_AGENT_PROPERTY:
  273.             if (!ws_encode_buffer(&buffer,
  274.                                   WS_ENC_UINT8,
  275.                                   (WsUInt8) WS_BC_PRAGMA_USER_AGENT_PROPERTY,
  276.                                   WS_ENC_MB_UINT16, bc->pragmas[ui].index_1,
  277.                                   WS_ENC_MB_UINT16, bc->pragmas[ui].index_2,
  278.                                   WS_ENC_END))
  279.                 goto error;
  280.             break;
  282.         case WS_BC_PRAGMA_TYPE_USER_AGENT_PROPERTY_AND_SCHEME:
  283.             if (!ws_encode_buffer(
  284.                     &buffer,
  285.                     WS_ENC_UINT8,
  286.                     (WsUInt8) WS_BC_PRAGMA_USER_AGENT_PROPERTY_AND_SCHEME,
  287.                     WS_ENC_MB_UINT16, bc->pragmas[ui].index_1,
  288.                     WS_ENC_MB_UINT16, bc->pragmas[ui].index_2,
  289.                     WS_ENC_MB_UINT16, bc->pragmas[ui].index_3,
  290.                     WS_ENC_END))
  291.                 goto error;
  292.             break;
  293.         }
  294.     }
  297.     /* Function pool. */
  299.     if (!ws_encode_buffer(&buffer,
  300.                           WS_ENC_UINT8, bc->num_functions,
  301.                           WS_ENC_END))
  302.         goto error;
  304.     /* Function names. */
  306.     if (!ws_encode_buffer(&buffer,
  307.                           WS_ENC_UINT8, bc->num_function_names,
  308.                           WS_ENC_END))
  309.         goto error;
  311.     for (ui = 0; ui < bc->num_function_names; ui++) {
  312.         size_t name_len = strlen(bc->function_names[ui].name);
  314.         if (!ws_encode_buffer(&buffer,
  315.                               WS_ENC_UINT8, bc->function_names[ui].index,
  316.                               WS_ENC_UINT8, (WsUInt8) name_len,
  317.                               WS_ENC_DATA, bc->function_names[ui].name, name_len,
  318.                               WS_ENC_END))
  319.             goto error;
  320.     }
  322.     /* Functions. */
  324.     for (ui = 0; ui < bc->num_functions; ui++) {
  325.         if (!ws_encode_buffer(&buffer,
  326.                               WS_ENC_UINT8, bc->functions[ui].num_arguments,
  327.                               WS_ENC_UINT8, bc->functions[ui].num_locals,
  328.                               WS_ENC_MB_UINT32, bc->functions[ui].code_size,
  329.                               WS_ENC_DATA, bc->functions[ui].code,
  330.                               (size_t) bc->functions[ui].code_size,
  331.                               WS_ENC_END))
  332.             goto error;
  333.     }
  336.     /* Fix the byte-code header. */
  338.     p = ws_buffer_ptr(&buffer);
  340.     /* Encode the size of the byte-code excluding the byte-code header. */
  341.     mb = ws_encode_mb_uint32(ws_buffer_len(&buffer) - WS_BC_MAX_HEADER_LEN,
  342.                              data, &len);
  343.     memcpy(p + WS_BC_MAX_HEADER_LEN - len, mb, len);
  345.     /* Set the byte-code file version information. */
  346.     WS_PUT_UINT8(p + WS_BC_MAX_HEADER_LEN - len - 1, WS_BC_VERSION);
  348.     /* Calculate the beginning of the bc-array and its size. */
  349.     *data_return = p + WS_BC_MAX_HEADER_LEN - len - 1;
  350.     *data_len_return = ws_buffer_len(&buffer) - WS_BC_MAX_HEADER_LEN + len + 1;
  352.     /* All done. */
  353.     return WS_TRUE;
  356.     /*
  357.      * Error handling.
  358.      */
  360. error:
  362.     ws_buffer_uninit(&buffer);
  363.     *data_return = NULL;
  364.     *data_len_return = 0;
  366.     return WS_FALSE;
  367. }
  370. void ws_bc_data_free(unsigned char *data)
  371. {
  372.     size_t len = WS_MB_UINT32_MAX_ENCODED_LEN;
  374.     if (data == NULL)
  375.         return;
  377.     /* Decode the mb-encoded length so we know how much space it uses. */
  378.     (void) ws_decode_mb_uint32(data + 1, &len);
  380.     /* Now we can compute the beginning of the array `data'. */
  381.     ws_free(data - (WS_MB_UINT32_MAX_ENCODED_LEN - len));
  382. }
  385. /* A helper macro to update the data pointers during the decoding of
  386.    byte-code data. */
  387. #define WS_UPDATE_DATA
  388.     data += decoded;
  389.     data_len -= decoded
  391. /* A helper macro to check the validity of the constant string index
  392.    `idx'. */
  393. #define WS_CHECK_STRING(idx)
  394.     if ((idx) >= bc->num_constants
  395.         || ((bc->constants[(idx)].type
  396.              != WS_BC_CONST_TYPE_UTF8_STRING)
  397.             && (bc->constants[(idx)].type
  398.                 != WS_BC_CONST_TYPE_EMPTY_STRING)))
  399.         goto error;
  401. WsBc *ws_bc_decode(const unsigned char *data, size_t data_len)
  402. {
  403.     WsBc *bc = ws_bc_alloc(WS_BC_STRING_ENC_ISO_8859_1);
  404.     WsByte b;
  405.     WsUInt32 ui32;
  406.     WsUInt16 ui16, j;
  407.     WsUInt16 ui16b;
  408.     WsUInt8 ui8, num_functions, k, l;
  409.     WsInt8 i8;
  410.     WsInt16 i16;
  411.     WsInt32 i32;
  412.     WsIeee754Result ieee754;
  413.     unsigned char *ucp;
  414.     size_t decoded;
  416.     /* Decode the byte-code header. */
  417.     decoded = ws_decode_buffer(data, data_len,
  418.                                WS_ENC_BYTE, &b,
  419.                                WS_ENC_MB_UINT32, &ui32,
  420.                                WS_ENC_END);
  422.     if (!decoded
  423.         || b != WS_BC_VERSION
  424.         || ui32 != data_len - decoded)
  425.         /* This is not a valid (or supported) byte-code header. */
  426.         goto error;
  428.     WS_UPDATE_DATA;
  430.     /* Constant pool. */
  432.     decoded = ws_decode_buffer(data, data_len,
  433.                                WS_ENC_MB_UINT16, &ui16,
  434.                                WS_ENC_MB_UINT16, &ui16b,
  435.                                WS_ENC_END);
  436.     if (!decoded)
  437.         goto error;
  439.     bc->string_encoding = ui16b;
  441.     bc->constants = ws_calloc(ui16, sizeof(WsBcConstant));
  442.     if (bc->constants == NULL)
  443.         goto error;
  444.     bc->num_constants = ui16;
  446.     WS_UPDATE_DATA;
  448.     for (j = 0; j < bc->num_constants; j++) {
  449.         WsBcConstant *c = &bc->constants[j];
  451.         decoded = ws_decode_buffer(data, data_len,
  452.                                    WS_ENC_UINT8, &ui8,
  453.                                    WS_ENC_END);
  454.         if (decoded != 1)
  455.             goto error;
  457.         WS_UPDATE_DATA;
  459.         switch (ui8) {
  460.         case WS_BC_CONST_INT8:
  461.             decoded = ws_decode_buffer(data, data_len,
  462.                                        WS_ENC_INT8, &i8,
  463.                                        WS_ENC_END);
  464.             if (decoded != 1)
  465.                 goto error;
  467.             WS_UPDATE_DATA;
  469.             c->type = WS_BC_CONST_TYPE_INT;
  470.             c->u.v_int = i8;
  471.             break;
  473.         case WS_BC_CONST_INT16:
  474.             decoded = ws_decode_buffer(data, data_len,
  475.                                        WS_ENC_INT16, &i16,
  476.                                        WS_ENC_END);
  477.             if (decoded != 2)
  478.                 goto error;
  480.             WS_UPDATE_DATA;
  482.             c->type = WS_BC_CONST_TYPE_INT;
  483.             c->u.v_int = i16;
  484.             break;
  486.         case WS_BC_CONST_INT32:
  487.             decoded = ws_decode_buffer(data, data_len,
  488.                                        WS_ENC_INT32, &i32,
  489.                                        WS_ENC_END);
  490.             if (decoded != 4)
  491.                 goto error;
  493.             WS_UPDATE_DATA;
  495.             c->type = WS_BC_CONST_TYPE_INT;
  496.             c->u.v_int = i32;
  497.             break;
  499.         case WS_BC_CONST_FLOAT32:
  500.             decoded = ws_decode_buffer(data, data_len,
  501.                                        WS_ENC_DATA, &ucp, (size_t) 4,
  502.                                        WS_ENC_END);
  503.             if (decoded != 4)
  504.                 goto error;
  506.             WS_UPDATE_DATA;
  508.             ieee754 = ws_ieee754_decode_single(ucp, &c->u.v_float);
  510.             switch (ieee754) {
  511.             case WS_IEEE754_OK:
  512.                 c->type = WS_BC_CONST_TYPE_FLOAT32;
  513.                 break;
  515.             case WS_IEEE754_NAN:
  516.                 c->type = WS_BC_CONST_TYPE_FLOAT32_NAN;
  517.                 break;
  519.             case WS_IEEE754_POSITIVE_INF:
  520.                 c->type = WS_BC_CONST_TYPE_FLOAT32_POSITIVE_INF;
  521.                 break;
  523.             case WS_IEEE754_NEGATIVE_INF:
  524.                 c->type = WS_BC_CONST_TYPE_FLOAT32_NEGATIVE_INF;
  525.                 break;
  526.             }
  528.             break;
  530.         case WS_BC_CONST_UTF8_STRING:
  531.             decoded = ws_decode_buffer(data, data_len,
  532.                                        WS_ENC_MB_UINT32, &ui32,
  533.                                        WS_ENC_END);
  534.             if (decoded == 0)
  535.                 goto error;
  537.             WS_UPDATE_DATA;
  539.             c->type = WS_BC_CONST_TYPE_UTF8_STRING;
  540.             c->u.v_string.len = ui32;
  542.             decoded = ws_decode_buffer(data, data_len,
  543.                                        WS_ENC_DATA, &ucp, c->u.v_string.len,
  544.                                        WS_ENC_END);
  545.             if (decoded != ui32)
  546.                 goto error;
  548.             WS_UPDATE_DATA;
  550.             c->u.v_string.data = ws_memdup(ucp, ui32);
  551.             if (c->u.v_string.data == NULL)
  552.                 goto error;
  554.             /* Check the validity of the data. */
  555.             if (!ws_utf8_verify(c->u.v_string.data, c->u.v_string.len,
  556.                                 &c->u.v_string.num_chars))
  557.                 goto error;
  558.             break;
  560.         case WS_BC_CONST_EMPTY_STRING:
  561.             c->type = WS_BC_CONST_TYPE_EMPTY_STRING;
  562.             break;
  564.         case WS_BC_CONST_EXT_ENC_STRING:
  565.             ws_fatal("external character encoding not implemented yet");
  566.             break;
  568.         default:
  569.             /* Reserved. */
  570.             goto error;
  571.             break;
  572.         }
  573.     }
  575.     /* Pragma pool. */
  577.     decoded = ws_decode_buffer(data, data_len,
  578.                                WS_ENC_MB_UINT16, &ui16,
  579.                                WS_ENC_END);
  580.     if (!decoded)
  581.         goto error;
  583.     bc->pragmas = ws_calloc(ui16, sizeof(WsBcPragma));
  584.     if (bc->pragmas == NULL)
  585.         goto error;
  586.     bc->num_pragmas = ui16;
  588.     WS_UPDATE_DATA;
  590.     for (j = 0; j < bc->num_pragmas; j++) {
  591.         WsBcPragma *p = &bc->pragmas[j];
  593.         decoded = ws_decode_buffer(data, data_len,
  594.                                    WS_ENC_UINT8, &ui8,
  595.                                    WS_ENC_END);
  596.         if (decoded != 1)
  597.             goto error;
  599.         WS_UPDATE_DATA;
  601.         p->type = ui8;
  603.         switch (ui8) {
  604.         case WS_BC_PRAGMA_ACCESS_DOMAIN:
  605.             decoded = ws_decode_buffer(data, data_len,
  606.                                        WS_ENC_MB_UINT16, &p->index_1,
  607.                                        WS_ENC_END);
  608.             if (!decoded)
  609.                 goto error;
  611.             WS_CHECK_STRING(p->index_1);
  612.             break;
  614.         case WS_BC_PRAGMA_ACCESS_PATH:
  615.             decoded = ws_decode_buffer(data, data_len,
  616.                                        WS_ENC_MB_UINT16, &p->index_1,
  617.                                        WS_ENC_END);
  618.             if (!decoded)
  619.                 goto error;
  621.             WS_CHECK_STRING(p->index_1);
  622.             break;
  624.         case WS_BC_PRAGMA_USER_AGENT_PROPERTY:
  625.             decoded = ws_decode_buffer(data, data_len,
  626.                                        WS_ENC_MB_UINT16, &p->index_1,
  627.                                        WS_ENC_MB_UINT16, &p->index_2,
  628.                                        WS_ENC_END);
  629.             if (!decoded)
  630.                 goto error;
  632.             WS_CHECK_STRING(p->index_1);
  633.             WS_CHECK_STRING(p->index_2);
  634.             break;
  636.         case WS_BC_PRAGMA_USER_AGENT_PROPERTY_AND_SCHEME:
  637.             decoded = ws_decode_buffer(data, data_len,
  638.                                        WS_ENC_MB_UINT16, &p->index_1,
  639.                                        WS_ENC_MB_UINT16, &p->index_2,
  640.                                        WS_ENC_MB_UINT16, &p->index_3,
  641.                                        WS_ENC_END);
  642.             if (!decoded)
  643.                 goto error;
  645.             WS_CHECK_STRING(p->index_1);
  646.             WS_CHECK_STRING(p->index_2);
  647.             WS_CHECK_STRING(p->index_3);
  648.             break;
  650.         default:
  651.             goto error;
  652.             break;
  653.         }
  655.         WS_UPDATE_DATA;
  656.     }
  658.     /* Function pool. */
  660.     decoded = ws_decode_buffer(data, data_len,
  661.                                WS_ENC_UINT8, &num_functions,
  662.                                WS_ENC_END);
  663.     if (decoded != 1)
  664.         goto error;
  666.     WS_UPDATE_DATA;
  668.     /* Function names. */
  670.     decoded = ws_decode_buffer(data, data_len,
  671.                                WS_ENC_UINT8, &ui8,
  672.                                WS_ENC_END);
  673.     if (decoded != 1)
  674.         goto error;
  676.     WS_UPDATE_DATA;
  678.     if (ui8) {
  679.         /* We have function names. */
  680.         bc->function_names = ws_calloc(ui8, sizeof(WsBcFunctionName));
  681.         if (bc->function_names == NULL)
  682.             goto error;
  683.         bc->num_function_names = ui8;
  685.         for (k = 0; k < bc->num_function_names; k++) {
  686.             WsBcFunctionName *n = &bc->function_names[k];
  688.             decoded = ws_decode_buffer(data, data_len,
  689.                                        WS_ENC_UINT8, &n->index,
  690.                                        WS_ENC_UINT8, &ui8,
  691.                                        WS_ENC_END);
  692.             if (decoded != 2)
  693.                 goto error;
  695.             WS_UPDATE_DATA;
  697.             decoded = ws_decode_buffer(data, data_len,
  698.                                        WS_ENC_DATA, &ucp, (size_t) ui8,
  699.                                        WS_ENC_END);
  700.             if (decoded != ui8)
  701.                 goto error;
  703.             WS_UPDATE_DATA;
  705.             n->name = ws_memdup(ucp, ui8);
  706.             if (n->name == NULL)
  707.                 goto error;
  709.             /* Check the validity of the name. */
  711.             if (!ws_utf8_verify((unsigned char *) n->name, ui8, NULL))
  712.                 goto error;
  714.             /* Just check that the data contains only valid characters. */
  715.             for (l = 0; l < ui8; l++) {
  716.                 unsigned int ch = (unsigned char) n->name[l];
  718.                 if (('a' <= ch && ch <= 'z')
  719.                     || ('A' <= ch && ch <= 'Z')
  720.                     || ch == '_'
  721.                     || (l > 0 && ('0' <= ch && ch <= '9')))
  722.                     /* Ok. */
  723.                     continue;
  725.                 /* Invalid character in the function name. */
  726.                 goto error;
  727.             }
  729.             /* Is the index valid? */
  730.             if (n->index >= num_functions)
  731.                 goto error;
  732.         }
  733.     }
  735.     /* Functions. */
  737.     if (num_functions) {
  738.         /* We have functions. */
  739.         bc->functions = ws_calloc(num_functions, sizeof(WsBcFunction));
  740.         if (bc->functions == NULL)
  741.             goto error;
  742.         bc->num_functions = num_functions;
  744.         for (k = 0; k < bc->num_functions; k++) {
  745.             WsBcFunction *f = &bc->functions[k];
  747.             decoded = ws_decode_buffer(data, data_len,
  748.                                        WS_ENC_UINT8, &f->num_arguments,
  749.                                        WS_ENC_UINT8, &f->num_locals,
  750.                                        WS_ENC_MB_UINT32, &f->code_size,
  751.                                        WS_ENC_END);
  752.             if (!decoded)
  753.                 goto error;
  755.             WS_UPDATE_DATA;
  757.             decoded = ws_decode_buffer(data, data_len,
  758.                                        WS_ENC_DATA, &ucp, f->code_size,
  759.                                        WS_ENC_END);
  760.             if (decoded != f->code_size)
  761.                 goto error;
  763.             WS_UPDATE_DATA;
  765.             if (f->code_size) {
  766.                 /* It is not an empty function. */
  767.                 f->code = ws_memdup(ucp, f->code_size);
  768.                 if (f->code == NULL)
  769.                     goto error;
  770.             }
  771.         }
  772.     }
  774.     /* Did we process it all? */
  775.     if (data_len != 0)
  776.         goto error;
  778.     /* All done. */
  779.     return bc;
  781.     /*
  782.      * Error handling.
  783.      */
  785. error:
  787.     ws_bc_free(bc);
  789.     return NULL;
  790. }
  792. /********************* Adding constant elements *************************/
  794. WsBool ws_bc_add_const_int(WsBc *bc, WsUInt16 *index_return, WsInt32 value)
  795. {
  796.     WsUInt16 i;
  797.     WsBcConstant *nc;
  799.     /* Do we already have a suitable integer constant? */
  800.     for (i = 0; i < bc->num_constants; i++) {
  801.         if (bc->constants[i].type == WS_BC_CONST_TYPE_INT
  802.             && bc->constants[i].u.v_int == value) {
  803.             *index_return = i;
  804.             return WS_TRUE;
  805.         }
  806.     }
  808.     /* Must add a new constant. */
  810.     nc = ws_realloc(bc->constants,
  811.                     (bc->num_constants + 1) * sizeof(WsBcConstant));
  812.     if (nc == NULL)
  813.         return WS_FALSE;
  815.     bc->constants = nc;
  816.     bc->constants[bc->num_constants].type = WS_BC_CONST_TYPE_INT;
  817.     bc->constants[bc->num_constants].u.v_int = value;
  819.     *index_return = bc->num_constants++;
  821.     return WS_TRUE;
  822. }
  825. WsBool ws_bc_add_const_float(WsBc *bc, WsUInt16 *index_return, WsFloat value)
  826. {
  827.     WsUInt16 i;
  828.     WsBcConstant *nc;
  830.     /* Do we already have a suitable float32 constant? */
  831.     for (i = 0; i < bc->num_constants; i++) {
  832.         if (bc->constants[i].type == WS_BC_CONST_TYPE_FLOAT32
  833.             && bc->constants[i].u.v_float == value) {
  834.             *index_return = i;
  835.             return WS_TRUE;
  836.         }
  837.     }
  839.     /* Must add a new constant. */
  841.     nc = ws_realloc(bc->constants,
  842.                     (bc->num_constants + 1) * sizeof(WsBcConstant));
  843.     if (nc == NULL)
  844.         return WS_FALSE;
  846.     bc->constants = nc;
  847.     bc->constants[bc->num_constants].type = WS_BC_CONST_TYPE_FLOAT32;
  848.     bc->constants[bc->num_constants].u.v_float = value;
  850.     *index_return = bc->num_constants++;
  852.     return WS_TRUE;
  853. }
  856. WsBool ws_bc_add_const_utf8_string(WsBc *bc, WsUInt16 *index_return,
  857.                                    const unsigned char *data, size_t len)
  858. {
  859.     WsUInt16 i;
  860.     WsBcConstant *nc;
  862.     /* Do we already have a suitable utf8 constant? */
  863.     for (i = 0; i < bc->num_constants; i++) {
  864.         if (bc->constants[i].type == WS_BC_CONST_TYPE_UTF8_STRING
  865.             && bc->constants[i].u.v_string.len == len
  866.             && memcmp(bc->constants[i].u.v_string.data,
  867.                       data, len) == 0) {
  868.             *index_return = i;
  869.             return WS_TRUE;
  870.         }
  871.     }
  873.     /* Must add a new constant. */
  875.     nc = ws_realloc(bc->constants,
  876.                     (bc->num_constants + 1) * sizeof(WsBcConstant));
  877.     if (nc == NULL)
  878.         return WS_FALSE;
  880.     bc->constants = nc;
  881.     bc->constants[bc->num_constants].type = WS_BC_CONST_TYPE_UTF8_STRING;
  882.     bc->constants[bc->num_constants].u.v_string.len = len;
  883.     bc->constants[bc->num_constants].u.v_string.data
  884.     = ws_memdup(data, len);
  885.     if (bc->constants[bc->num_constants].u.v_string.data == NULL)
  886.         return WS_FALSE;
  888.     *index_return = bc->num_constants++;
  890.     return WS_TRUE;
  891. }
  895. WsBool ws_bc_add_const_empty_string(WsBc *bc, WsUInt16 *index_return)
  896. {
  897.     WsUInt16 i;
  898.     WsBcConstant *nc;
  900.     /* Do we already have a suitable empty string constant? */
  901.     for (i = 0; i < bc->num_constants; i++) {
  902.         if (bc->constants[i].type == WS_BC_CONST_TYPE_EMPTY_STRING) {
  903.             *index_return = i;
  904.             return WS_TRUE;
  905.         }
  906.     }
  908.     /* Must add a new constant. */
  910.     nc = ws_realloc(bc->constants,
  911.                     (bc->num_constants + 1) * sizeof(WsBcConstant));
  912.     if (nc == NULL)
  913.         return WS_FALSE;
  915.     bc->constants = nc;
  916.     bc->constants[bc->num_constants].type = WS_BC_CONST_TYPE_EMPTY_STRING;
  918.     *index_return = bc->num_constants++;
  920.     return WS_TRUE;
  921. }
  923. /********************* Adding pragmas ***********************************/
  925. WsBool ws_bc_add_pragma_access_domain(WsBc *bc, const unsigned char *domain,
  926.                                       size_t domain_len)
  927. {
  928.     WsBcPragma *p = add_pragma(bc, WS_BC_PRAGMA_TYPE_ACCESS_DOMAIN);
  930.     if (p == NULL)
  931.         return WS_FALSE;
  933.     if (!ws_bc_add_const_utf8_string(bc, &p->index_1, domain, domain_len))
  934.         return WS_FALSE;
  936.     return WS_TRUE;
  937. }
  940. WsBool ws_bc_add_pragma_access_path(WsBc *bc, const unsigned char *path,
  941.                                     size_t path_len)
  942. {
  943.     WsBcPragma *p = add_pragma(bc, WS_BC_PRAGMA_TYPE_ACCESS_PATH);
  945.     if (p == NULL)
  946.         return WS_FALSE;
  948.     if (!ws_bc_add_const_utf8_string(bc, &p->index_1, path, path_len))
  949.         return WS_FALSE;
  951.     return WS_TRUE;
  952. }
  955. WsBool ws_bc_add_pragma_user_agent_property(WsBc *bc,
  956.                                             const unsigned char *name,
  957.                                             size_t name_len,
  958.                                             const unsigned char *property,
  959.                                             size_t property_len)
  960. {
  961.     WsBcPragma *p = add_pragma(bc, WS_BC_PRAGMA_TYPE_USER_AGENT_PROPERTY);
  963.     if (p == NULL)
  964.         return WS_FALSE;
  966.     if (!ws_bc_add_const_utf8_string(bc, &p->index_1, name, name_len)
  967.         || !ws_bc_add_const_utf8_string(bc, &p->index_2, property, property_len))
  968.         return WS_FALSE;
  970.     return WS_TRUE;
  971. }
  974. WsBool ws_bc_add_pragma_user_agent_property_and_scheme(
  975.     WsBc *bc,
  976.     const unsigned char *name,
  977.     size_t name_len,
  978.     const unsigned char *property,
  979.     size_t property_len,
  980.     const unsigned char *scheme,
  981.     size_t scheme_len)
  982. {
  983.     WsBcPragma *p;
  985.     p = add_pragma(bc, WS_BC_PRAGMA_TYPE_USER_AGENT_PROPERTY_AND_SCHEME);
  987.     if (p == NULL)
  988.         return WS_FALSE;
  990.     if (!ws_bc_add_const_utf8_string(bc, &p->index_1, name, name_len)
  991.         || !ws_bc_add_const_utf8_string(bc, &p->index_2, property, property_len)
  992.         || !ws_bc_add_const_utf8_string(bc, &p->index_3, scheme, scheme_len))
  993.         return WS_FALSE;
  995.     return WS_TRUE;
  996. }
  998. /********************* Adding functions *********************************/
  1000. WsBool ws_bc_add_function(WsBc *bc, WsUInt8 *index_return, char *name,
  1001.                           WsUInt8 num_arguments, WsUInt8 num_locals,
  1002.                           WsUInt32 code_size, unsigned char *code)
  1003. {
  1004.     WsBcFunction *nf;
  1006.     /* First, add the function to the function pool. */
  1008.     nf = ws_realloc(bc->functions,
  1009.                     (bc->num_functions + 1) * sizeof(WsBcFunction));
  1010.     if (nf == NULL)
  1011.         return WS_FALSE;
  1013.     bc->functions = nf;
  1014.     bc->functions[bc->num_functions].num_arguments = num_arguments;
  1015.     bc->functions[bc->num_functions].num_locals = num_locals;
  1016.     bc->functions[bc->num_functions].code_size = code_size;
  1017.     bc->functions[bc->num_functions].code = ws_memdup(code, code_size);
  1019.     if (bc->functions[bc->num_functions].code == NULL)
  1020.         return WS_FALSE;
  1022.     /* Save the index of the function. */
  1023.     *index_return = bc->num_functions++;
  1025.     /* For external functions (which have name), add a name entry to the
  1026.        function name pool. */
  1027.     if (name) {
  1028.         WsBcFunctionName *nfn;
  1030.         nfn = ws_realloc(bc->function_names,
  1031.                          ((bc->num_function_names + 1)
  1032.                           * sizeof(WsBcFunctionName)));
  1033.         if (nfn == NULL)
  1034.             return WS_FALSE;
  1036.         bc->function_names = nfn;
  1037.         bc->function_names[bc->num_function_names].index = *index_return;
  1038.         bc->function_names[bc->num_function_names].name = ws_strdup(name);
  1040.         if (bc->function_names[bc->num_function_names].name == NULL)
  1041.             return WS_FALSE;
  1043.         bc->num_function_names++;
  1044.     }
  1046.     /* All done. */
  1047.     return WS_TRUE;
  1048. }
  1050. /********************* Static functions *********************************/
  1052. static WsBcPragma *add_pragma(WsBc *bc, WsBcPragmaType type)
  1053. {
  1054.     WsBcPragma *np;
  1056.     /* Add a new pragma slot. */
  1057.     np = ws_realloc(bc->pragmas, (bc->num_pragmas + 1) * sizeof(WsBcPragma));
  1058.     if (np == NULL)
  1059.         return NULL;
  1061.     bc->pragmas = np;
  1062.     bc->pragmas[bc->num_pragmas].type = type;
  1064.     return &bc->pragmas[bc->num_pragmas++];
  1065. }