/hphp/runtime/base/zend-pack.cpp
C++ | 967 lines | 772 code | 145 blank | 50 comment | 187 complexity | c57e556ed7acdfd87e7c473439161dfb MD5 | raw file
Possible License(s): LGPL-2.1, BSD-2-Clause, BSD-3-Clause, MPL-2.0-no-copyleft-exception, MIT, LGPL-2.0, Apache-2.0
- /*
- +----------------------------------------------------------------------+
- | HipHop for PHP |
- +----------------------------------------------------------------------+
- | Copyright (c) 2010-present Facebook, Inc. (http://www.facebook.com) |
- | Copyright (c) 1998-2010 Zend Technologies Ltd. (http://www.zend.com) |
- +----------------------------------------------------------------------+
- | This source file is subject to version 2.00 of the Zend license, |
- | that is bundled with this package in the file LICENSE, and is |
- | available through the world-wide-web at the following url: |
- | http://www.zend.com/license/2_00.txt. |
- | If you did not receive a copy of the Zend license and are unable to |
- | obtain it through the world-wide-web, please send a note to |
- | license@zend.com so we can mail you a copy immediately. |
- +----------------------------------------------------------------------+
- */
- #include "hphp/runtime/base/zend-pack.h"
- #include "hphp/runtime/base/builtin-functions.h"
- #include "hphp/runtime/base/req-tiny-vector.h"
- #include <algorithm>
- namespace HPHP {
- #define INC_OUTPUTPOS(a,b) \
- if ((a) < 0 || ((INT_MAX - outputpos)/((int)b)) < (a)) { \
- raise_invalid_argument_warning \
- ("Type %c: integer overflow in format string", code); \
- return false; \
- } \
- outputpos += (a)*(b);
- ///////////////////////////////////////////////////////////////////////////////
- ZendPack::ZendPack() {
- int machine_endian_check = 1;
- int64_t i;
- machine_little_endian = ((char *)&machine_endian_check)[0];
- if (machine_little_endian) {
- /* Where to get lo to hi bytes from */
- byte_map[0] = 0;
- for (i = 0; i < (int)sizeof(int); i++) {
- int_map[i] = i;
- }
- machine_endian_short_map[0] = 0;
- machine_endian_short_map[1] = 1;
- big_endian_short_map[0] = 1;
- big_endian_short_map[1] = 0;
- little_endian_short_map[0] = 0;
- little_endian_short_map[1] = 1;
- machine_endian_int32_map[0] = 0;
- machine_endian_int32_map[1] = 1;
- machine_endian_int32_map[2] = 2;
- machine_endian_int32_map[3] = 3;
- big_endian_int32_map[0] = 3;
- big_endian_int32_map[1] = 2;
- big_endian_int32_map[2] = 1;
- big_endian_int32_map[3] = 0;
- little_endian_int32_map[0] = 0;
- little_endian_int32_map[1] = 1;
- little_endian_int32_map[2] = 2;
- little_endian_int32_map[3] = 3;
- machine_endian_int64_map[0] = 0;
- machine_endian_int64_map[1] = 1;
- machine_endian_int64_map[2] = 2;
- machine_endian_int64_map[3] = 3;
- machine_endian_int64_map[4] = 4;
- machine_endian_int64_map[5] = 5;
- machine_endian_int64_map[6] = 6;
- machine_endian_int64_map[7] = 7;
- big_endian_int64_map[0] = 7;
- big_endian_int64_map[1] = 6;
- big_endian_int64_map[2] = 5;
- big_endian_int64_map[3] = 4;
- big_endian_int64_map[4] = 3;
- big_endian_int64_map[5] = 2;
- big_endian_int64_map[6] = 1;
- big_endian_int64_map[7] = 0;
- little_endian_int64_map[0] = 0;
- little_endian_int64_map[1] = 1;
- little_endian_int64_map[2] = 2;
- little_endian_int64_map[3] = 3;
- little_endian_int64_map[4] = 4;
- little_endian_int64_map[5] = 5;
- little_endian_int64_map[6] = 6;
- little_endian_int64_map[7] = 7;
- } else {
- int64_t size = sizeof(int64_t);
- /* Where to get hi to lo bytes from */
- byte_map[0] = size - 1;
- for (i = 0; i < (int)sizeof(int); i++) {
- int_map[i] = size - (sizeof(int64_t) - i);
- }
- machine_endian_short_map[0] = size - 2;
- machine_endian_short_map[1] = size - 1;
- big_endian_short_map[0] = size - 2;
- big_endian_short_map[1] = size - 1;
- little_endian_short_map[0] = size - 1;
- little_endian_short_map[1] = size - 2;
- machine_endian_int32_map[0] = size - 4;
- machine_endian_int32_map[1] = size - 3;
- machine_endian_int32_map[2] = size - 2;
- machine_endian_int32_map[3] = size - 1;
- big_endian_int32_map[0] = size - 4;
- big_endian_int32_map[1] = size - 3;
- big_endian_int32_map[2] = size - 2;
- big_endian_int32_map[3] = size - 1;
- little_endian_int32_map[0] = size - 1;
- little_endian_int32_map[1] = size - 2;
- little_endian_int32_map[2] = size - 3;
- little_endian_int32_map[3] = size - 4;
- machine_endian_int64_map[0] = size - 8;
- machine_endian_int64_map[1] = size - 7;
- machine_endian_int64_map[2] = size - 6;
- machine_endian_int64_map[3] = size - 5;
- machine_endian_int64_map[4] = size - 4;
- machine_endian_int64_map[5] = size - 3;
- machine_endian_int64_map[6] = size - 2;
- machine_endian_int64_map[7] = size - 1;
- big_endian_int64_map[0] = size - 8;
- big_endian_int64_map[1] = size - 7;
- big_endian_int64_map[2] = size - 6;
- big_endian_int64_map[3] = size - 5;
- big_endian_int64_map[4] = size - 4;
- big_endian_int64_map[5] = size - 3;
- big_endian_int64_map[6] = size - 2;
- big_endian_int64_map[7] = size - 1;
- little_endian_int64_map[0] = size - 1;
- little_endian_int64_map[1] = size - 2;
- little_endian_int64_map[2] = size - 3;
- little_endian_int64_map[3] = size - 4;
- little_endian_int64_map[4] = size - 5;
- little_endian_int64_map[5] = size - 6;
- little_endian_int64_map[6] = size - 7;
- little_endian_int64_map[7] = size - 8;
- }
- }
- void ZendPack::pack(const Variant& val, int64_t size, int64_t *map,
- char *output) {
- int64_t n = val.toInt64();
- char *v = (char*)&n;
- for (int64_t i = 0; i < size; i++) {
- *output++ = v[map[i]];
- }
- }
- Variant ZendPack::pack(const String& fmt, const Array& argv) {
- /* Preprocess format into formatcodes and formatargs */
- req::TinyVector<char, 64> formatcodes; // up to 64 codes on the stack
- req::TinyVector<int, 64> formatargs;
- int argc = argv.size();
- const char *format = fmt.c_str();
- int formatlen = fmt.size();
- int currentarg = 0;
- for (int i = 0; i < formatlen; ) {
- char code = format[i++];
- int arg = 1;
- /* Handle format arguments if any */
- if (i < formatlen) {
- char c = format[i];
- if (c == '*') {
- arg = -1;
- i++;
- }
- else if (c >= '0' && c <= '9') {
- arg = atoi(&format[i]);
- while (format[i] >= '0' && format[i] <= '9' && i < formatlen) {
- i++;
- }
- }
- }
- /* Handle special arg '*' for all codes and check argv overflows */
- switch ((int) code) {
- /* Never uses any args */
- case 'x':
- case 'X':
- case '@':
- if (arg < 0) {
- raise_invalid_argument_warning("Type %c: '*' ignored", code);
- arg = 1;
- }
- break;
- /* Always uses one arg */
- case 'a':
- case 'A':
- case 'h':
- case 'H':
- case 'Z':
- if (currentarg >= argc) {
- raise_invalid_argument_warning("Type %c: not enough arguments", code);
- return false;
- }
- if (arg < 0) {
- arg = argv[currentarg].toString().size();
- //add one, because Z is always NUL-terminated
- if (code == 'Z') {
- arg++;
- }
- }
- currentarg++;
- break;
- /* Use as many args as specified */
- case 'q':
- case 'Q':
- case 'J':
- case 'P':
- case 'c':
- case 'C':
- case 's':
- case 'S':
- case 'i':
- case 'I':
- case 'l':
- case 'L':
- case 'n':
- case 'N':
- case 'v':
- case 'V':
- case 'f':
- case 'd':
- if (arg < 0) {
- arg = argc - currentarg;
- }
- currentarg += arg;
- if (currentarg > argc) {
- raise_invalid_argument_warning("Type %c: too few arguments", code);
- return false;
- }
- break;
- default:
- raise_invalid_argument_warning("Type %c: unknown format code", code);
- return false;
- }
- formatcodes.push_back(code);
- formatargs.push_back(arg);
- }
- if (currentarg < argc) {
- raise_invalid_argument_warning("%d arguments unused", (argc - currentarg));
- }
- int outputpos = 0, outputsize = 0;
- /* Calculate output length and upper bound while processing*/
- for (int i = 0; i < (int)formatcodes.size(); i++) {
- int code = (int) formatcodes[i];
- int arg = formatargs[i];
- switch ((int) code) {
- case 'h':
- case 'H':
- INC_OUTPUTPOS((arg + (arg % 2)) / 2,1); /* 4 bit per arg */
- break;
- case 'a':
- case 'A':
- case 'c':
- case 'C':
- case 'x':
- case 'Z':
- INC_OUTPUTPOS(arg,1); /* 8 bit per arg */
- break;
- case 's':
- case 'S':
- case 'n':
- case 'v':
- INC_OUTPUTPOS(arg,2); /* 16 bit per arg */
- break;
- case 'i':
- case 'I':
- INC_OUTPUTPOS(arg,sizeof(int));
- break;
- case 'l':
- case 'L':
- case 'N':
- case 'V':
- INC_OUTPUTPOS(arg,4); /* 32 bit per arg */
- break;
- case 'q':
- case 'Q':
- case 'J':
- case 'P':
- INC_OUTPUTPOS(arg,8); /* 64 bit per arg */
- break;
- case 'f':
- INC_OUTPUTPOS(arg,sizeof(float));
- break;
- case 'd':
- INC_OUTPUTPOS(arg,sizeof(double));
- break;
- case 'X':
- outputpos -= arg;
- if (outputpos < 0) {
- raise_invalid_argument_warning("Type %c: outside of string", code);
- outputpos = 0;
- }
- break;
- case '@':
- outputpos = arg;
- break;
- }
- if (outputsize < outputpos) {
- outputsize = outputpos;
- }
- }
- String str = String(outputsize, ReserveString);
- char *output = str.mutableData();
- outputpos = 0;
- currentarg = 0;
- /* Do actual packing */
- for (int i = 0; i < (int)formatcodes.size(); i++) {
- int code = (int) formatcodes[i];
- int arg = formatargs[i];
- String val;
- const char *s;
- int slen;
- switch ((int) code) {
- case 'a':
- case 'A':
- case 'Z': {
- int arg_cp = (code != 'Z') ? arg : std::max(0, arg - 1);
- memset(&output[outputpos], (code != 'A') ? '\0' : ' ', arg);
- val = argv[currentarg++].toString();
- s = val.c_str();
- slen = val.size();
- memcpy(&output[outputpos], s, (slen < arg_cp) ? slen : arg_cp);
- outputpos += arg;
- }
- break;
- case 'h':
- case 'H': {
- int nibbleshift = (code == 'h') ? 0 : 4;
- int first = 1;
- const char *v;
- val = argv[currentarg++].toString();
- v = val.data();
- slen = val.size();
- outputpos--;
- if (arg > slen) {
- raise_invalid_argument_warning
- ("Type %c: not enough characters in string", code);
- arg = slen;
- }
- while (arg-- > 0) {
- char n = *v++;
- if (n >= '0' && n <= '9') {
- n -= '0';
- } else if (n >= 'A' && n <= 'F') {
- n -= ('A' - 10);
- } else if (n >= 'a' && n <= 'f') {
- n -= ('a' - 10);
- } else {
- raise_invalid_argument_warning("Type %c: illegal hex digit %c", code, n);
- n = 0;
- }
- if (first--) {
- output[++outputpos] = 0;
- } else {
- first = 1;
- }
- output[outputpos] |= (n << nibbleshift);
- nibbleshift = (nibbleshift + 4) & 7;
- }
- outputpos++;
- break;
- }
- case 'c':
- case 'C':
- while (arg-- > 0) {
- pack(argv[currentarg++], 1, byte_map, &output[outputpos]);
- outputpos++;
- }
- break;
- case 's':
- case 'S':
- case 'n':
- case 'v': {
- int64_t *map = machine_endian_short_map;
- if (code == 'n') {
- map = big_endian_short_map;
- } else if (code == 'v') {
- map = little_endian_short_map;
- }
- while (arg-- > 0) {
- pack(argv[currentarg++], 2, map, &output[outputpos]);
- outputpos += 2;
- }
- break;
- }
- case 'i':
- case 'I':
- while (arg-- > 0) {
- pack(argv[currentarg++], sizeof(int), int_map, &output[outputpos]);
- outputpos += sizeof(int);
- }
- break;
- case 'l':
- case 'L':
- case 'N':
- case 'V': {
- int64_t *map = machine_endian_int32_map;
- if (code == 'N') {
- map = big_endian_int32_map;
- } else if (code == 'V') {
- map = little_endian_int32_map;
- }
- while (arg-- > 0) {
- pack(argv[currentarg++], 4, map, &output[outputpos]);
- outputpos += 4;
- }
- break;
- }
- case 'q':
- case 'Q':
- case 'J':
- case 'P': {
- int64_t *map = machine_endian_int64_map;
- if (code == 'J') {
- map = big_endian_int64_map;
- } else if (code == 'P') {
- map = little_endian_int64_map;
- }
- while (arg-- > 0) {
- pack(argv[currentarg++], 8, map, &output[outputpos]);
- outputpos += 8;
- }
- break;
- }
- case 'f': {
- float v;
- while (arg-- > 0) {
- v = argv[currentarg++].toDouble();
- memcpy(&output[outputpos], &v, sizeof(v));
- outputpos += sizeof(v);
- }
- break;
- }
- case 'd': {
- double v;
- while (arg-- > 0) {
- v = argv[currentarg++].toDouble();
- memcpy(&output[outputpos], &v, sizeof(v));
- outputpos += sizeof(v);
- }
- break;
- }
- case 'x':
- memset(&output[outputpos], '\0', arg);
- outputpos += arg;
- break;
- case 'X':
- outputpos -= arg;
- if (outputpos < 0) {
- outputpos = 0;
- }
- break;
- case '@':
- if (arg > outputpos) {
- memset(&output[outputpos], '\0', arg - outputpos);
- }
- outputpos = arg;
- break;
- }
- }
- str.setSize(outputpos);
- return str;
- }
- int64_t ZendPack::unpack(const char *data, int64_t size, int issigned,
- int64_t *map) {
- int64_t result;
- char *cresult = (char *) &result;
- int i;
- result = issigned ? -1 : 0;
- for (i = 0; i < size; i++) {
- cresult[map[i]] = *data++;
- }
- return result;
- }
- Variant ZendPack::unpack(const String& fmt, const String& data) {
- const char *format = fmt.c_str();
- int formatlen = fmt.size();
- const char *input = data.c_str();
- int inputlen = data.size();
- int inputpos = 0;
- Array ret = Array::Create();
- while (formatlen-- > 0) {
- char type = *(format++);
- int arg = 1, argb;
- const char *name;
- int namelen;
- int size=0;
- /* Handle format arguments if any */
- if (formatlen > 0) {
- char c = *format;
- if (c >= '0' && c <= '9') {
- arg = atoi(format);
- while (formatlen > 0 && *format >= '0' && *format <= '9') {
- format++;
- formatlen--;
- }
- } else if (c == '*') {
- arg = -1;
- format++;
- formatlen--;
- }
- }
- /* Get of new value in array */
- name = format;
- argb = arg;
- while (formatlen > 0 && *format != '/') {
- formatlen--;
- format++;
- }
- namelen = format - name;
- if (namelen > 200)
- namelen = 200;
- switch ((int) type) {
- /* Never use any input */
- case 'X':
- size = -1;
- if (arg < 0) {
- raise_invalid_argument_warning("Type %c: '*' ignored", type);
- arg = 1;
- }
- break;
- case '@':
- size = 0;
- break;
- case 'a':
- case 'A':
- case 'Z':
- size = arg;
- arg = 1;
- break;
- case 'h':
- case 'H':
- size = (arg > 0) ? (arg + (arg % 2)) / 2 : arg;
- arg = 1;
- break;
- /* Use 1 byte of input */
- case 'c':
- case 'C':
- case 'x':
- size = 1;
- break;
- /* Use 2 bytes of input */
- case 's':
- case 'S':
- case 'n':
- case 'v':
- size = 2;
- break;
- /* Use machine dependent bytes of input */
- case 'i':
- case 'I':
- size = sizeof(int);
- break;
- /* Use 4 bytes of input */
- case 'l':
- case 'L':
- case 'N':
- case 'V':
- size = 4;
- break;
- /* Use 8 bytes of input */
- case 'q':
- case 'Q':
- case 'J':
- case 'P':
- size = 8;
- break;
- /* Use sizeof(float) bytes of input */
- case 'f':
- size = sizeof(float);
- break;
- /* Use sizeof(double) bytes of input */
- case 'd':
- size = sizeof(double);
- break;
- default:
- raise_invalid_argument_warning("Invalid format type %c", type);
- return false;
- }
- /* Do actual unpacking */
- for (int i = 0; i != arg; i++ ) {
- /* Space for name + number, safe as namelen is ensured <= 200 */
- char n[256];
- if (arg != 1 || namelen == 0) {
- /* Need to add element number to name */
- snprintf(n, sizeof(n), "%.*s%d", namelen, name, i + 1);
- } else {
- /* Truncate name to next format code or end of string */
- snprintf(n, sizeof(n), "%.*s", namelen, name);
- }
- const auto n_str = String(n, CopyString);
- int64_t n_int;
- const auto n_key = n_str.get()->isStrictlyInteger(n_int)
- ? Variant(n_int)
- : Variant(n_str);
- if (size != 0 && size != -1 && INT_MAX - size + 1 < inputpos) {
- raise_invalid_argument_warning("Type %c: integer overflow", type);
- inputpos = 0;
- }
- if ((inputpos + size) <= inputlen) {
- switch ((int) type) {
- case 'a':
- case 'A':
- case 'Z': {
- int len = inputlen - inputpos; /* Remaining string */
- /* If size was given take minimum of len and size */
- if ((size >= 0) && (len > size)) {
- len = size;
- }
- size = len;
- /* A will strip any trailing whitespace */
- if (type == 'A')
- {
- char padn = '\0'; char pads = ' '; char padt = '\t';
- char padc = '\r'; char padl = '\n';
- while (--len >= 0) {
- if (input[inputpos + len] != padn
- && input[inputpos + len] != pads
- && input[inputpos + len] != padt
- && input[inputpos + len] != padc
- && input[inputpos + len] != padl
- )
- break;
- }
- }
- /* Remove everything after the first null */
- if (type=='Z') {
- int s;
- for (s=0 ; s < len ; s++) {
- if (input[inputpos + s] == '\0')
- break;
- }
- len = s;
- }
- /*only A is \0 terminated*/
- if (type=='A')
- len++;
- ret.set(n_key, String(input + inputpos, len, CopyString));
- break;
- }
- case 'h':
- case 'H': {
- int len = (inputlen - inputpos) * 2; /* Remaining */
- int nibbleshift = (type == 'h') ? 0 : 4;
- int first = 1;
- char *buf;
- int ipos, opos;
- /* If size was given take minimum of len and size */
- if (size >= 0 && len > (size * 2)) {
- len = size * 2;
- }
- if (argb > 0) {
- len -= argb % 2;
- }
- String s = String(len, ReserveString);
- buf = s.mutableData();
- for (ipos = opos = 0; opos < len; opos++) {
- char c = (input[inputpos + ipos] >> nibbleshift) & 0xf;
- if (c < 10) {
- c += '0';
- } else {
- c += 'a' - 10;
- }
- buf[opos] = c;
- nibbleshift = (nibbleshift + 4) & 7;
- if (first-- == 0) {
- ipos++;
- first = 1;
- }
- }
- s.setSize(len);
- ret.set(n_key, s);
- break;
- }
- case 'c':
- case 'C': {
- int issigned = (type == 'c') ? (input[inputpos] & 0x80) : 0;
- ret.set(n_key, unpack(&input[inputpos], 1, issigned, byte_map));
- break;
- }
- case 's':
- case 'S':
- case 'n':
- case 'v': {
- int issigned = 0;
- int64_t *map = machine_endian_short_map;
- if (type == 's') {
- issigned = input[inputpos + (machine_little_endian ? 1 : 0)] &
- 0x80;
- } else if (type == 'n') {
- map = big_endian_short_map;
- } else if (type == 'v') {
- map = little_endian_short_map;
- }
- ret.set(n_key, unpack(&input[inputpos], 2, issigned, map));
- break;
- }
- case 'i':
- case 'I': {
- int32_t v = 0;
- int issigned = 0;
- if (type == 'i') {
- issigned = input[inputpos + (machine_little_endian ?
- (sizeof(int) - 1) : 0)] & 0x80;
- } else if (sizeof(int32_t) > 4 &&
- (input[inputpos + machine_endian_int32_map[3]]
- & 0x80) == 0x80) {
- v = ~INT_MAX;
- }
- v |= unpack(&input[inputpos], sizeof(int), issigned, int_map);
- if (type == 'i') {
- ret.set(n_key, v);
- } else {
- uint64_t u64 = uint32_t(v);
- ret.set(n_key, u64);
- }
- break;
- }
- case 'l':
- case 'L':
- case 'N':
- case 'V': {
- int issigned = 0;
- int64_t *map = machine_endian_int32_map;
- int64_t v = 0;
- if (type == 'l' || type == 'L') {
- issigned = input[inputpos + (machine_little_endian ? 3 : 0)]
- & 0x80;
- } else if (type == 'N') {
- issigned = input[inputpos] & 0x80;
- map = big_endian_int32_map;
- } else if (type == 'V') {
- issigned = input[inputpos + 3] & 0x80;
- map = little_endian_int32_map;
- }
- if (sizeof(int32_t) > 4 && issigned) {
- v = ~INT_MAX;
- }
- v |= unpack(&input[inputpos], 4, issigned, map);
- if (type == 'l') {
- ret.set(n_key, v);
- } else {
- uint64_t u64 = uint32_t(v);
- ret.set(n_key, u64);
- }
- break;
- }
- case 'q':
- case 'Q':
- case 'J':
- case 'P': {
- int issigned = 0;
- int64_t *map = machine_endian_int64_map;
- int64_t v = 0;
- if (type == 'q' || type == 'Q') {
- issigned = input[inputpos + (machine_little_endian ? 7 : 0)] & 0x80;
- } else if (type == 'J') {
- issigned = input[inputpos] & 0x80;
- map = big_endian_int64_map;
- } else if (type == 'P') {
- issigned = input[inputpos + 7] & 0x80;
- map = little_endian_int64_map;
- }
- v = unpack(&input[inputpos], 8, issigned, map);
- if (type == 'q') {
- ret.set(n_key, v);
- } else {
- uint64_t u64 = uint64_t(v);
- ret.set(n_key, u64);
- }
- break;
- }
- case 'f': {
- float v;
- memcpy(&v, &input[inputpos], sizeof(float));
- ret.set(n_key, (double)v);
- break;
- }
- case 'd': {
- double v;
- memcpy(&v, &input[inputpos], sizeof(double));
- ret.set(n_key, v);
- break;
- }
- case 'x':
- /* Do nothing with input, just skip it */
- break;
- case 'X':
- if (inputpos < size) {
- inputpos = -size;
- i = arg - 1; /* Break out of for loop */
- if (arg >= 0) {
- raise_invalid_argument_warning("Type %c: outside of string", type);
- }
- }
- break;
- case '@':
- if (arg <= inputlen) {
- inputpos = arg;
- } else {
- raise_invalid_argument_warning("Type %c: outside of string", type);
- }
- i = arg - 1; /* Done, break out of for loop */
- break;
- }
- inputpos += size;
- if (inputpos < 0) {
- if (size != -1) { /* only print warning if not working with * */
- raise_invalid_argument_warning("Type %c: outside of string", type);
- }
- inputpos = 0;
- }
- } else if (arg < 0) {
- /* Reached end of input for '*' repeater */
- break;
- } else {
- raise_invalid_argument_warning
- ("Type %c: not enough input, need %d, have %d",
- type, size, inputlen - inputpos);
- return false;
- }
- }
- formatlen--; /* Skip '/' separator, does no harm if inputlen == 0 */
- format++;
- }
- return ret;
- }
- ///////////////////////////////////////////////////////////////////////////////
- }