#include #include #include #include #define max(a,b) (((a)>(b)) ? (a) : (b)) #define blockSize 256 napi_ref StringBuilderRef, ReadStreamRef, ReadFileStreamRef, RegExpSearchRef; // TODO -----Creators----- napi_value createFalse(napi_env env){ napi_value result; napi_get_boolean(env, false, &result); return result; } napi_value createTrue(napi_env env){ napi_value result; napi_get_boolean(env, true, &result); return result; } napi_value createEmptyArray(napi_env env){ napi_value result; napi_create_array_with_length(env, 0, &result); return result; } // TODO -----Functions----- napi_value boyerMooreMagicLen(napi_env env, char16_t* source, int64_t sourceLength, char16_t* pattern, int64_t patternLength, int64_t offset, int64_t limit){ if (patternLength == 0 || offset < 0 || sourceLength - offset < patternLength) { return createEmptyArray(env); } if(limit <= 0) { limit = 1000; } uint32_t* buffer; napi_value arrayBuffer; napi_create_arraybuffer(env, limit * 4, (void**)(&buffer), &arrayBuffer); int64_t sourceLength_dec = sourceLength - 1; int64_t patternLength_dec = patternLength - 1; napi_value resultList; uint32_t resultListLength = 0; int64_t badCharShiftMap[65536] = { patternLength }; int64_t i; for (i = 0; i < patternLength_dec; ++i) { char16_t index = pattern[i]; badCharShiftMap[index] = patternLength_dec - i; } char16_t specialChar = pattern[patternLength_dec]; int64_t specialShift = badCharShiftMap[specialChar]; badCharShiftMap[specialChar] = 0; int64_t sourcePointer = offset + patternLength_dec; int64_t patternPointer; while (sourcePointer < sourceLength) { patternPointer = patternLength_dec; while (patternPointer >= 0) { if (source[sourcePointer] != pattern[patternPointer]) { break; } --sourcePointer; --patternPointer; } int64_t starePointer = sourcePointer; int64_t goodSuffixLength_inc = patternLength - patternPointer; sourcePointer += goodSuffixLength_inc; if (patternPointer < 0) { buffer[resultListLength++] = starePointer + 1; if (sourcePointer > sourceLength_dec || resultListLength == limit) { break; } else { sourcePointer += badCharShiftMap[source[sourcePointer]]; continue; } } int64_t shift1 = (sourcePointer <= sourceLength_dec) ? badCharShiftMap[source[sourcePointer]] : 0; if (shift1 >= patternLength_dec) { sourcePointer += shift1; } else { int64_t shift2 = ((source[starePointer] == specialChar) ? specialShift : badCharShiftMap[source[starePointer]]) - goodSuffixLength_inc; sourcePointer += (shift1 >= shift2) ? shift1 : shift2; } } napi_create_typedarray(env, napi_uint32_array, resultListLength, arrayBuffer, 0, &resultList); return resultList; } napi_value boyerMooreMagicLenSkip(napi_env env, char16_t* source, int64_t sourceLength, char16_t* pattern, int64_t patternLength, int64_t offset, int64_t limit){ if (patternLength == 0 || offset < 0 || sourceLength - offset < patternLength) { return createEmptyArray(env); } if(limit <= 0) { limit = 1000; } uint32_t* buffer; napi_value arrayBuffer; napi_create_arraybuffer(env, limit * 4, (void**)(&buffer), &arrayBuffer); int64_t sourceLength_dec = sourceLength - 1; int64_t patternLength_dec = patternLength - 1; napi_value resultList; uint32_t resultListLength = 0; int64_t badCharShiftMap[65536] = { patternLength }; int64_t i; for (i = 0; i < patternLength_dec; ++i) { char16_t index = pattern[i]; badCharShiftMap[index] = patternLength_dec - i; } char16_t specialChar = pattern[patternLength_dec]; int64_t specialShift = badCharShiftMap[specialChar]; badCharShiftMap[specialChar] = 0; int64_t sourcePointer = offset + patternLength_dec; int64_t patternPointer; while (sourcePointer < sourceLength) { patternPointer = patternLength_dec; while (patternPointer >= 0) { if (source[sourcePointer] != pattern[patternPointer]) { break; } --sourcePointer; --patternPointer; } int64_t starePointer = sourcePointer; int64_t goodSuffixLength_inc = patternLength - patternPointer; sourcePointer += goodSuffixLength_inc; if (patternPointer < 0) { buffer[resultListLength++] = starePointer + 1; if (sourcePointer > sourceLength_dec || resultListLength == limit) { break; } else { sourcePointer += patternLength_dec; continue; } } int64_t shift1 = (sourcePointer <= sourceLength_dec) ? badCharShiftMap[source[sourcePointer]] : 0; if (shift1 >= patternLength_dec) { sourcePointer += shift1; } else { int64_t shift2 = ((source[starePointer] == specialChar) ? specialShift : badCharShiftMap[source[starePointer]]) - goodSuffixLength_inc; sourcePointer += (shift1 >= shift2) ? shift1 : shift2; } } napi_create_typedarray(env, napi_uint32_array, resultListLength, arrayBuffer, 0, &resultList); return resultList; } void boyerMooreMagicLenSkipPure(char16_t* source, int64_t sourceLength, char16_t* pattern, int64_t patternLength, int64_t offset, int64_t limit, int64_t** resultList, int64_t* resultListLength){ if (patternLength == 0 || offset < 0 || sourceLength - offset < patternLength) { *resultListLength = -1; return; } if(limit <= 0) { limit = sourceLength / patternLength; } *resultList = (int64_t*)malloc(sizeof(int64_t) * limit); *resultListLength = 0; int64_t sourceLength_dec = sourceLength - 1; int64_t patternLength_dec = patternLength - 1; int64_t badCharShiftMap[65536] = { patternLength }; int64_t i; for (i = 0; i < patternLength_dec; ++i) { char16_t index = pattern[i]; badCharShiftMap[index] = patternLength_dec - i; } char16_t specialChar = pattern[patternLength_dec]; int64_t specialShift = badCharShiftMap[specialChar]; badCharShiftMap[specialChar] = 0; int64_t sourcePointer = offset + patternLength_dec; int64_t patternPointer; while (sourcePointer < sourceLength) { patternPointer = patternLength_dec; while (patternPointer >= 0) { if (source[sourcePointer] != pattern[patternPointer]) { break; } --sourcePointer; --patternPointer; } int64_t starePointer = sourcePointer; int64_t goodSuffixLength_inc = patternLength - patternPointer; sourcePointer += goodSuffixLength_inc; if (patternPointer < 0) { (*resultList)[(*resultListLength)++] = starePointer + 1; if (sourcePointer > sourceLength_dec || *resultListLength == limit) { break; } else { sourcePointer += patternLength_dec; continue; } } int64_t shift1 = (sourcePointer <= sourceLength_dec) ? badCharShiftMap[source[sourcePointer]] : 0; if (shift1 >= patternLength_dec) { sourcePointer += shift1; } else { int64_t shift2 = ((source[starePointer] == specialChar) ? specialShift : badCharShiftMap[source[starePointer]]) - goodSuffixLength_inc; sourcePointer += (shift1 >= shift2) ? shift1 : shift2; } } } napi_value boyerMooreMagicLenRev(napi_env env, char16_t* source, int64_t sourceLength, char16_t* pattern, int64_t patternLength, int64_t offset, int64_t limit){ if (patternLength == 0 || offset < 0 || sourceLength - offset < patternLength) { return createEmptyArray(env); } if(limit <= 0) { limit = 1000; } uint32_t* buffer; napi_value arrayBuffer; napi_create_arraybuffer(env, limit * 4, (void**)(&buffer), &arrayBuffer); int64_t sourceLength_dec = sourceLength - 1; int64_t patternLength_dec = patternLength - 1; napi_value resultList; napi_create_array(env, &resultList); int64_t resultListLength = 0; int64_t badCharShiftMap[65536] = { patternLength }; int64_t i; for (i = patternLength_dec; i > 0; --i) { char16_t index = pattern[i]; badCharShiftMap[index] = i; } char16_t specialChar = pattern[patternLength_dec]; int64_t specialShift = badCharShiftMap[specialChar]; badCharShiftMap[specialChar] = 0; int64_t sourcePointer = sourceLength_dec - patternLength_dec - offset; int64_t patternPointer; while (sourcePointer >= 0) { patternPointer = 0; while (patternPointer < patternLength) { if (source[sourcePointer] != pattern[patternPointer]) { break; } ++sourcePointer; ++patternPointer; } int64_t starePointer = sourcePointer; int64_t goodSuffixLength_inc = patternPointer + 1; sourcePointer -= goodSuffixLength_inc; if (patternPointer >= patternLength) { buffer[resultListLength++] = sourcePointer + 1; if (sourcePointer < 0 || resultListLength == limit) { break; } else { sourcePointer -= badCharShiftMap[source[sourcePointer]]; continue; } } int64_t shift1 = (sourcePointer >= 0) ? badCharShiftMap[source[sourcePointer]] : 0; if (shift1 >= patternLength_dec) { sourcePointer -= shift1; } else { int64_t shift2 = ((source[starePointer] == specialChar) ? specialShift : badCharShiftMap[source[starePointer]]) - goodSuffixLength_inc; sourcePointer -= (shift1 >= shift2) ? shift1 : shift2; } } napi_create_typedarray(env, napi_uint32_array, resultListLength, arrayBuffer, 0, &resultList); return resultList; } void getRawData(napi_env env, napi_value me, uint8_t** raw, uint64_t* rawLength){ napi_value _raw; napi_get_element(env, me, 0, &_raw); napi_get_buffer_info(env, _raw, (void**)raw, rawLength); } void getBufferAndMetaData(napi_env env, napi_value me, uint16_t** buffer, int64_t** metadata){ napi_value _raw; uint8_t* raw; uint64_t rawLength; napi_get_element(env, me, 0, &_raw); napi_get_buffer_info(env, _raw, (void**)(&raw), &rawLength); *buffer = (uint16_t*)(raw + 16); *metadata = (int64_t*)raw; } void getMetaData(napi_env env, napi_value me, int64_t** metadata){ napi_value _raw; uint8_t* raw; napi_get_element(env, me, 0, &_raw); napi_get_buffer_info(env, _raw, (void**)(&raw), 0); *metadata = (int64_t*)raw; } void reAlloc(napi_env env, napi_value me, uint16_t** buffer, int64_t** metadata, int64_t newSize) { int64_t capacity = (*metadata)[0]; if (capacity < newSize) { int64_t length = (*metadata)[1]; int64_t count = (newSize - capacity + blockSize - 1) / blockSize; int64_t sizeToAdd = count * blockSize; uint16_t* oldBuffer = *buffer; napi_value _raw; uint8_t* raw; int64_t newCapacity = capacity + sizeToAdd; napi_create_buffer(env, 16 + newCapacity, (void**)(&raw), &_raw); *buffer = (uint16_t*)(raw + 16); memcpy(*buffer, oldBuffer, length); *metadata = (int64_t*)raw; (*metadata)[0] = newCapacity; (*metadata)[1] = length; napi_set_element(env, me, 0, _raw); // TODO Need to free old data? } } napi_value appendUTF16FromOutside(napi_env env, napi_value me, napi_value source, uint16_t** buffer, int64_t** metadata) { int64_t contentBufferLength; int64_t length = (*metadata)[1]; int64_t concatLength; napi_valuetype type; napi_typeof(env, source, &type); if (type == napi_string) { napi_get_value_string_utf16(env, source, NULL, 0, (uint64_t*)(&contentBufferLength)); contentBufferLength *= 2; concatLength = length + contentBufferLength; reAlloc(env, me, buffer, metadata, concatLength + 2); napi_get_value_string_utf16(env, source, *buffer + (length / 2), contentBufferLength + 2, 0); (*metadata)[1] = concatLength; return me; }else if(type == napi_object) { bool isStringBuilder; napi_value StringBuilder; napi_get_reference_value(env, StringBuilderRef, &StringBuilder); napi_instanceof(env, source, StringBuilder, &isStringBuilder); if(isStringBuilder) { uint16_t* t_buffer; int64_t* t_metadata; getBufferAndMetaData(env, source, &t_buffer, &t_metadata); concatLength = length + t_metadata[1]; reAlloc(env, me, buffer, metadata, concatLength); memcpy(*buffer + (length / 2), t_buffer, t_metadata[1]); (*metadata)[1] = concatLength; return me; } bool isBuffer; napi_is_buffer(env, source, &isBuffer); if(isBuffer) { char* utf8Data; size_t utf8DataLength; napi_get_buffer_info(env, source, (void**)(&utf8Data), &utf8DataLength); napi_value tempString; napi_create_string_utf8(env, utf8Data, utf8DataLength, &tempString); napi_get_value_string_utf16(env, tempString, NULL, 0, (uint64_t*)&contentBufferLength); contentBufferLength *= 2; concatLength = length + contentBufferLength; reAlloc(env, me, buffer, metadata, concatLength + 2); napi_get_value_string_utf16(env, tempString, *buffer + (length / 2), contentBufferLength + 2, 0); (*metadata)[1] = concatLength; return me; } bool isReadStream; napi_value ReadStream; napi_get_reference_value(env, ReadStreamRef, &ReadStream); napi_instanceof(env, source, ReadStream, &isReadStream); if(isReadStream) { napi_value ReadFileStream; napi_get_reference_value(env, ReadFileStreamRef, &ReadFileStream); napi_value result; uint64_t* contentBuffer; napi_value args[1]; args[0] = source; napi_call_function(env, source, ReadFileStream, 1, args, &result); napi_get_buffer_info(env, result, (void**)(&contentBuffer), (uint64_t*)&contentBufferLength); concatLength = length + contentBufferLength; reAlloc(env, me, buffer, metadata, concatLength); memcpy(*buffer + (length / 2), contentBuffer, contentBufferLength); (*metadata)[1] = concatLength; return me; } type = napi_boolean; } if(type == napi_boolean || type == napi_number) { napi_value tempString; napi_coerce_to_string(env, source, &tempString); napi_get_value_string_utf16(env, tempString, NULL, 0, (uint64_t*)&contentBufferLength); contentBufferLength *= 2; concatLength = length + contentBufferLength; reAlloc(env, me, buffer, metadata, concatLength + 2); napi_get_value_string_utf16(env, tempString, *buffer + (length / 2), contentBufferLength + 2, 0); (*metadata)[1] = concatLength; } return me; } void getUTF16FromOutside(napi_env env, napi_value source, uint16_t** sourceData, int64_t* sourceDataLength, bool* freeAble) { napi_valuetype type; napi_typeof(env, source, &type); if (type == napi_string) { size_t sourceDataSize; napi_get_value_string_utf16(env, source, NULL, 0, &sourceDataSize); ++sourceDataSize; *sourceData = (uint16_t*)malloc(sourceDataSize * 2); *freeAble = true; napi_get_value_string_utf16(env, source, *sourceData, sourceDataSize, &sourceDataSize); *sourceDataLength = sourceDataSize * 2; }else if(type == napi_object) { bool isStringBuilder; napi_value StringBuilder; napi_get_reference_value(env, StringBuilderRef, &StringBuilder); napi_instanceof(env, source, StringBuilder, &isStringBuilder); if(isStringBuilder) { int64_t* metadata; getBufferAndMetaData(env, source, sourceData, &metadata); *sourceDataLength = metadata[1]; *freeAble = false; return; } bool isBuffer; napi_is_buffer(env, source, &isBuffer); if(isBuffer) { char* utf8Data; size_t utf8DataLength; napi_get_buffer_info(env, source, (void**)(&utf8Data), &utf8DataLength); napi_value tempString; napi_create_string_utf8(env, utf8Data, utf8DataLength, &tempString); size_t sourceDataSize; napi_get_value_string_utf16(env, tempString, NULL, 0, &sourceDataSize); ++sourceDataSize; *sourceData = (uint16_t*)malloc(sourceDataSize * 2); *freeAble = true; napi_get_value_string_utf16(env, tempString, *sourceData, sourceDataSize, &sourceDataSize); *sourceDataLength = sourceDataSize * 2; return; } bool isReadStream; napi_value ReadStream; napi_get_reference_value(env, ReadStreamRef, &ReadStream); napi_instanceof(env, source, ReadStream, &isReadStream); if(isReadStream) { napi_value ReadFileStream; napi_get_reference_value(env, ReadFileStreamRef, &ReadFileStream); napi_value args[1]; args[0] = source; napi_value result; napi_call_function(env, source, ReadFileStream, 1, args, &result); napi_get_buffer_info(env, result, (void**)sourceData, (uint64_t*)sourceDataLength); *freeAble = false; return; } type = napi_boolean; }else if(type == napi_boolean || type == napi_number) { napi_value tempString; napi_coerce_to_string(env, source, &tempString); size_t sourceDataSize; napi_get_value_string_utf16(env, tempString, NULL, 0, &sourceDataSize); ++sourceDataSize; *sourceData = (uint16_t*)malloc(sourceDataSize * 2); *freeAble = true; napi_get_value_string_utf16(env, tempString, *sourceData, sourceDataSize, &sourceDataSize); *sourceDataLength = sourceDataSize * 2; }else{ *sourceDataLength = 0; *freeAble = false; } } void getRealIndex (napi_env env, int64_t* metadata, napi_value source, int64_t* realIndex) { int64_t length = metadata[1]; int64_t index; napi_get_value_int64(env, source, &index); int64_t halfLength = length / 2; if (index < 0) { index += halfLength; } if (index < 0) { index = 0; } else if (index > halfLength) { index = length; } else { index *= 2; } *realIndex = index; }; bool isTrimmable(uint16_t characterCode) { return characterCode <= 32 || characterCode == 12288; } int64_t log2Floor(int64_t n) { return (int64_t)floor(log2(n)); } // TODO -----Getters----- napi_value Length(napi_env env, napi_callback_info info){ napi_value me; napi_get_cb_info(env, info, 0, 0, &me, 0); int64_t* metadata; getMetaData(env, me, &metadata); napi_value result; napi_create_int64(env, metadata[1] / 2, &result); return result; }; napi_value Capacity(napi_env env, napi_callback_info info){ napi_value me; napi_get_cb_info(env, info, 0, 0, &me, 0); int64_t* metadata; getMetaData(env, me, &metadata); napi_value result; napi_create_int64(env, metadata[0] / 2, &result); return result; }; // TODO -----Changers----- napi_value Replace(napi_env env, napi_callback_info info){ napi_value me; size_t argsLength = 3; napi_value args[3]; napi_get_cb_info(env, info, &argsLength, args, &me, 0); if(argsLength == 0) { return me; } uint16_t* buffer; int64_t* metadata; getBufferAndMetaData(env, me, &buffer, &metadata); int64_t start, end, length = metadata[1]; napi_value content; switch(argsLength) { case 1: start = 0; end = length; content = args[0]; break; case 2: getRealIndex(env, metadata, args[0], &start); end = length; content = args[1]; break; default: getRealIndex(env, metadata, args[0], &start); getRealIndex(env, metadata, args[1], &end); content = args[2]; } uint16_t* contentBuffer; int64_t contentBufferLength; bool freeAble; getUTF16FromOutside(env, content, &contentBuffer, &contentBufferLength, &freeAble); int64_t replaceLength = end - start; int64_t concatLength = length + contentBufferLength - replaceLength; reAlloc(env, me, &buffer, &metadata, concatLength); if (end == length || contentBufferLength == replaceLength) { memcpy(buffer + (start / 2), contentBuffer, contentBufferLength); }else{ memmove(buffer + ((start + contentBufferLength) / 2), buffer + (end / 2), length - end); memcpy(buffer + (start / 2), contentBuffer, contentBufferLength); } metadata[1] = concatLength; if(freeAble) { free(contentBuffer); } return me; } napi_value Insert(napi_env env, napi_callback_info info){ napi_value me; size_t argsLength = 3; napi_value args[3]; napi_get_cb_info(env, info, &argsLength, args, &me, 0); if(argsLength == 0) { return me; } uint16_t* buffer; int64_t* metadata; getBufferAndMetaData(env, me, &buffer, &metadata); int64_t offset, length = metadata[1]; napi_value content; switch(argsLength) { case 1: offset = 0; content = args[0]; break; default: getRealIndex(env, metadata, args[0], &offset); content = args[1]; } uint16_t* contentBuffer; int64_t contentBufferLength; bool freeAble; getUTF16FromOutside(env, content, &contentBuffer, &contentBufferLength, &freeAble); int64_t concatLength = length + contentBufferLength; reAlloc(env, me, &buffer, &metadata, concatLength); if (offset == length) { memcpy(buffer + (offset / 2), contentBuffer, contentBufferLength); }else{ memmove(buffer + ((offset + contentBufferLength) / 2), buffer + (offset / 2), length - offset); memcpy(buffer + (offset / 2), contentBuffer, contentBufferLength); } metadata[1] = concatLength; if(freeAble) { free(contentBuffer); } return me; } napi_value Clear(napi_env env, napi_callback_info info){ napi_value me; napi_get_cb_info(env, info, 0, 0, &me, 0); int64_t* metadata; getMetaData(env, me, &metadata); metadata[1] = 0; return me; } napi_value Delete(napi_env env, napi_callback_info info){ napi_value me; size_t argsLength = 2; napi_value args[2]; napi_get_cb_info(env, info, &argsLength, args, &me, 0); if(argsLength == 0) { return me; } uint16_t* buffer; int64_t* metadata; getBufferAndMetaData(env, me, &buffer, &metadata); int64_t start, end, length = metadata[1]; switch(argsLength) { case 1: getRealIndex(env, metadata, args[0], &start); end = length; break; default: getRealIndex(env, metadata, args[0], &start); getRealIndex(env, metadata, args[1], &end); } if (start >= end) { return me; } if (end == length) { metadata[1] = start; } else { memmove(buffer + (start / 2), buffer + (end / 2), length - end); metadata[1] = length - (end - start); } return me; } napi_value DeleteCharAt(napi_env env, napi_callback_info info){ napi_value me; size_t argsLength = 1; napi_value args[1]; napi_get_cb_info(env, info, &argsLength, args, &me, 0); if(argsLength == 0) { return me; } uint16_t* buffer; int64_t* metadata; getBufferAndMetaData(env, me, &buffer, &metadata); int64_t index, length = metadata[1]; getRealIndex(env, metadata, args[0], &index); if (index == length) { return me; } metadata[1] -= 2; if (index != length - 1) { memmove(buffer + (index / 2), buffer + ((index + 2) / 2), length - index - 1); } return me; } napi_value Substring(napi_env env, napi_callback_info info){ size_t argsLength = 2; napi_value args[2]; napi_value me; napi_get_cb_info(env, info, &argsLength, args, &me, 0); uint16_t* buffer; int64_t* metadata; getBufferAndMetaData(env, me, &buffer, &metadata); int64_t start, end; switch(argsLength) { case 0: start = 0; end = metadata[1]; break; case 1: { getRealIndex(env, metadata, args[0], &start); end = metadata[1]; break; } default: { getRealIndex(env, metadata, args[0], &start); getRealIndex(env, metadata, args[1], &end); break; } } if (start >= end) { metadata[1] = 0; return me; } if (start == 0) { metadata[1] = end; } else { metadata[1] = end - start; memmove(buffer, buffer + (start / 2), metadata[1]); } return me; } napi_value Substr(napi_env env, napi_callback_info info){ size_t argsLength = 2; napi_value args[2]; napi_value me; napi_get_cb_info(env, info, &argsLength, args, &me, 0); uint16_t* buffer; int64_t* metadata; getBufferAndMetaData(env, me, &buffer, &metadata); int64_t start, length; switch(argsLength) { case 0: start = 0; length = metadata[1]; break; case 1: { getRealIndex(env, metadata, args[0], &start); length = metadata[1] - start; break; } default: { getRealIndex(env, metadata, args[0], &start); getRealIndex(env, metadata, args[1], &length); break; } } if (length <= 0) { metadata[1] = 0; return me; }else if(start + length > metadata[1]) { length = metadata[1] - start; } metadata[1] = length; if (start > 0) { memmove(buffer, buffer + (start / 2), length); } return me; } napi_value Append(napi_env env, napi_callback_info info){ napi_value me; size_t argsLength = 1; napi_value args[1]; napi_get_cb_info(env, info, &argsLength, args, &me, 0); if(argsLength == 0) { return me; } uint16_t* buffer; int64_t* metadata; getBufferAndMetaData(env, me, &buffer, &metadata); return appendUTF16FromOutside(env, me, args[0], &buffer, &metadata); } napi_value AppendRepeat(napi_env env, napi_callback_info info){ napi_value me; size_t argsLength = 2; napi_value args[2]; napi_get_cb_info(env, info, &argsLength, args, &me, 0); if(argsLength == 0) { return me; } uint16_t* buffer; int64_t* metadata; getBufferAndMetaData(env, me, &buffer, &metadata); int64_t repeatCount; switch(argsLength) { case 1: repeatCount = 1; break; default: napi_get_value_int64(env, args[1], &repeatCount); if (repeatCount < 1) { repeatCount = 1; } break; } uint16_t* contentBuffer; int64_t contentBufferLength; bool freeAble; getUTF16FromOutside(env, args[0], &contentBuffer, &contentBufferLength, &freeAble); int64_t length = metadata[1]; int64_t concatLength = length + (contentBufferLength * repeatCount); reAlloc(env, me, &buffer, &metadata, concatLength); // log2 copy int64_t log2Count = log2Floor(repeatCount); memcpy(buffer + (length / 2), contentBuffer, contentBufferLength); int64_t i; for (i = 1; i <= log2Count; ++i) { int64_t addedLength = pow(2, i - 1) * contentBufferLength; memcpy(buffer + ((length + addedLength) / 2), buffer + (length / 2), addedLength); } int64_t realAddedCount = pow(2, log2Count); length += contentBufferLength * realAddedCount; // normal copy int64_t remainCount = repeatCount - realAddedCount; for (i = 0; i < remainCount; ++i) { memcpy(buffer + (length / 2), contentBuffer, contentBufferLength); length += contentBufferLength; } metadata[1] = length; if(freeAble) { free(contentBuffer); } return me; } napi_value AppendLine(napi_env env, napi_callback_info info){ napi_value me; size_t argsLength = 1; napi_value args[1]; napi_get_cb_info(env, info, &argsLength, args, &me, 0); uint16_t* buffer; int64_t* metadata; getBufferAndMetaData(env, me, &buffer, &metadata); if(argsLength > 0) { appendUTF16FromOutside(env, me, args[0], &buffer, &metadata); } if(metadata[0] == metadata[1]) { reAlloc(env, me, &buffer, &metadata, metadata[0] + 2); } buffer[metadata[1] / 2] = 10; metadata[1] += 2; return me; } napi_value Reverse(napi_env env, napi_callback_info info){ napi_value me; napi_get_cb_info(env, info, 0, 0, &me, 0); uint16_t* buffer; int64_t* metadata; getBufferAndMetaData(env, me, &buffer, &metadata); reAlloc(env, me, &buffer, &metadata, metadata[1] * 2); int64_t length_div_2 = metadata[1] / 2; int64_t i, capacity_dec_2_div_2 = (metadata[0] - 2) / 2; for (i = 0; i < length_div_2; ++i) { memmove(buffer + capacity_dec_2_div_2 - i, buffer + i, 2); } memmove(buffer, buffer + ((metadata[0] - metadata[1]) / 2), metadata[1]); return me; } napi_value UpperCase(napi_env env, napi_callback_info info){ napi_value me; napi_get_cb_info(env, info, 0, 0, &me, 0); uint16_t* buffer; int64_t* metadata; getBufferAndMetaData(env, me, &buffer, &metadata); int64_t i, length = metadata[1] / 2; for (i = 0; i < length; i++) { uint16_t v = buffer[i]; if (v >= 97 && v <= 122) { buffer[i] -= 32; } } return me; } napi_value LowerCase(napi_env env, napi_callback_info info){ napi_value me; napi_get_cb_info(env, info, 0, 0, &me, 0); uint16_t* buffer; int64_t* metadata; getBufferAndMetaData(env, me, &buffer, &metadata); int64_t i, length = metadata[1] / 2; for (i = 0; i < length; i++) { uint16_t v = buffer[i]; if (v >= 65 && v <= 90) { buffer[i] += 32; } } return me; } napi_value ReplacePattern(napi_env env, napi_callback_info info){ size_t argsLength = 4; napi_value args[4]; napi_value me; napi_get_cb_info(env, info, &argsLength, args, &me, 0); if(argsLength < 2) { return me; } uint16_t* buffer; int64_t* metadata; getBufferAndMetaData(env, me, &buffer, &metadata); uint16_t* pattern; int64_t patternLength; bool patternFreeAble; int64_t offset, limit; switch(argsLength) { case 2: { offset = 0; limit = 1; break; } case 3: { getRealIndex(env, metadata, args[2], &offset); limit = 1; break; } default: { getRealIndex(env, metadata, args[2], &offset); getRealIndex(env, metadata, args[3], &limit); break; } } getUTF16FromOutside(env, args[0], &pattern, &patternLength, &patternFreeAble); int64_t* resultList; int64_t resultListLength; boyerMooreMagicLenSkipPure(buffer, metadata[1] / 2, pattern, patternLength / 2, offset, limit, &resultList, &resultListLength); if (resultListLength <= 0) { if(resultListLength == 0) { free(resultList); } if(patternFreeAble) { free(pattern); } return me; } uint16_t* content; int64_t contentLength; bool contentFreeAble; getUTF16FromOutside(env, args[1], &content, &contentLength, &contentFreeAble); int64_t i, diffLength = contentLength - patternLength; int64_t length = metadata[1]; int64_t concatLength = length + (diffLength * resultListLength); reAlloc(env, me, &buffer, &metadata, concatLength); if (contentLength == patternLength) { for (i = resultListLength - 1; i >= 0; --i) { memcpy(buffer + resultList[i], content, contentLength); } } else { if(resultListLength == 1) { reAlloc(env, me, &buffer, &metadata, concatLength); int64_t start = resultList[0] * 2; int64_t end = start + patternLength; memmove(buffer + ((start + contentLength) / 2), buffer + (end / 2), length - end); memcpy(buffer + (start / 2), content, contentLength); }else{ int64_t biggerLength = max(contentLength, length); reAlloc(env, me, &buffer, &metadata, biggerLength * 2); int64_t originalIndex = 0, index, concatIndex = biggerLength / 2, l, pl = patternLength / 2, cl = contentLength / 2; for (i = 0; i < resultListLength; ++i) { index = resultList[i]; l = index - originalIndex; memmove(buffer + concatIndex, buffer + originalIndex, l * 2); concatIndex += l; memcpy(buffer + concatIndex, content, contentLength); concatIndex += cl; originalIndex = index + pl; } memmove(buffer + concatIndex, buffer + originalIndex, length - (originalIndex * 2)); memmove(buffer, buffer + (biggerLength / 2), concatLength); } } metadata[1] = concatLength; free(resultList); if(patternFreeAble) { free(pattern); } return me; } napi_value ReplaceAll(napi_env env, napi_callback_info info){ size_t argsLength = 2; napi_value args[2]; napi_value me; napi_get_cb_info(env, info, &argsLength, args, &me, 0); if(argsLength < 2) { return me; } uint16_t* buffer; int64_t* metadata; getBufferAndMetaData(env, me, &buffer, &metadata); uint16_t* pattern; int64_t patternLength; bool patternFreeAble; getUTF16FromOutside(env, args[0], &pattern, &patternLength, &patternFreeAble); int64_t* resultList; int64_t resultListLength; boyerMooreMagicLenSkipPure(buffer, metadata[1] / 2, pattern, patternLength / 2, 0, 0, &resultList, &resultListLength); if (resultListLength <= 0) { if(resultListLength == 0) { free(resultList); } if(patternFreeAble) { free(pattern); } return me; } uint16_t* content; int64_t contentLength; bool contentFreeAble; getUTF16FromOutside(env, args[1], &content, &contentLength, &contentFreeAble); int64_t i, diffLength = contentLength - patternLength; int64_t length = metadata[1]; int64_t concatLength = length + (diffLength * resultListLength); if (contentLength == patternLength) { reAlloc(env, me, &buffer, &metadata, concatLength); for (i = resultListLength - 1; i >= 0; --i) { memcpy(buffer + resultList[i], content, contentLength); } } else { if(resultListLength == 1) { reAlloc(env, me, &buffer, &metadata, concatLength); int64_t start = resultList[0] * 2; int64_t end = start + patternLength; memmove(buffer + ((start + contentLength) / 2), buffer + (end / 2), length - end); memcpy(buffer + (start / 2), content, contentLength); }else{ int64_t biggerLength = max(contentLength, length); reAlloc(env, me, &buffer, &metadata, biggerLength * 2); int64_t originalIndex = 0, index, concatIndex = biggerLength / 2, l, pl = patternLength / 2, cl = contentLength / 2; for (i = 0; i < resultListLength; ++i) { index = resultList[i]; l = index - originalIndex; memmove(buffer + concatIndex, buffer + originalIndex, l * 2); concatIndex += l; memcpy(buffer + concatIndex, content, contentLength); concatIndex += cl; originalIndex = index + pl; } memmove(buffer + concatIndex, buffer + originalIndex, length - (originalIndex * 2)); memmove(buffer, buffer + (biggerLength / 2), concatLength); } } metadata[1] = concatLength; free(resultList); if(patternFreeAble) { free(pattern); } return me; } napi_value Trim(napi_env env, napi_callback_info info){ napi_value me; napi_get_cb_info(env, info, 0, 0, &me, 0); uint16_t* buffer; int64_t* metadata; getBufferAndMetaData(env, me, &buffer, &metadata); int64_t length = metadata[1] / 2; int64_t start = 0, end = length - 1; for (; start < length; ++start) { uint16_t v = buffer[start]; if (isTrimmable(v)) { continue; } break; } for (; end > start; --end) { uint16_t v = buffer[end]; if (isTrimmable(v)) { continue; } break; } start *= 2; end = end * 2 + 2; if (start >= end) { metadata[1] = 0; return me; } if (start == 0) { metadata[1] = end; } else { metadata[1] = end - start; memmove(buffer, buffer + (start / 2), metadata[1]); } return me; } napi_value Repeat(napi_env env, napi_callback_info info){ napi_value me; size_t argsLength = 1; napi_value args[1]; napi_get_cb_info(env, info, &argsLength, args, &me, 0); uint16_t* buffer; int64_t* metadata; getBufferAndMetaData(env, me, &buffer, &metadata); int64_t repeatCount; if(argsLength < 1) { repeatCount = 1; }else{ napi_get_value_int64(env, args[0], &repeatCount); if(repeatCount < 1) { return me; } } int64_t length = metadata[1]; int64_t finalLength = length * (repeatCount + 1); int64_t originalLength = length; reAlloc(env, me, &buffer, &metadata, finalLength); // log2 copy int64_t log2Count = log2Floor(repeatCount); memcpy(buffer + (originalLength / 2), buffer, originalLength); int64_t i; for (i = 1; i <= log2Count; ++i) { int64_t addedLength = pow(2, i - 1) * originalLength; memcpy(buffer + ((originalLength + addedLength) / 2), buffer + (originalLength / 2), addedLength); } int64_t realAddedCount = pow(2, log2Count); length += originalLength * realAddedCount; // normal copy int64_t remainCount = repeatCount - realAddedCount; for (i = 0; i < remainCount; ++i) { memcpy(buffer + (length / 2), buffer, originalLength); length += originalLength; } metadata[1] = finalLength; return me; } napi_value ExpandCapacity(napi_env env, napi_callback_info info){ napi_value me; size_t argsLength = 2; napi_value args[2]; napi_get_cb_info(env, info, &argsLength, args, &me, 0); uint16_t* buffer; int64_t* metadata; getBufferAndMetaData(env, me, &buffer, &metadata); int64_t newCapacity; bool returnUpdatedCapacity; switch(argsLength) { case 0: newCapacity = metadata[0]; returnUpdatedCapacity = false; break; case 1: napi_get_value_int64(env, args[0], &newCapacity); returnUpdatedCapacity = false; break; default: napi_get_value_int64(env, args[0], &newCapacity); napi_get_value_bool(env, args[1], &returnUpdatedCapacity); break; } reAlloc(env, me, &buffer, &metadata, newCapacity * 2); if (returnUpdatedCapacity) { napi_value result; napi_create_int64(env, metadata[0] / 2, &result); return result; } return me; } napi_value ShrinkCapacity(napi_env env, napi_callback_info info){ napi_value me; size_t argsLength = 1; napi_value args[1]; napi_get_cb_info(env, info, &argsLength, args, &me, 0); uint16_t* buffer; int64_t* metadata; getBufferAndMetaData(env, me, &buffer, &metadata); bool returnUpdatedCapacity; if(argsLength == 0) { returnUpdatedCapacity = false; }else{ napi_get_value_bool(env, args[0], &returnUpdatedCapacity); } int64_t count = (metadata[1] + blockSize - 1) / blockSize; if (count == 0) { count = 1; } int64_t newCapacity = count * blockSize; if (newCapacity < metadata[0]) { napi_value _new_raw; uint8_t* newRaw; napi_create_buffer_copy(env, 16 + newCapacity, (void*)metadata, (void**)(&newRaw), &_new_raw); metadata = (int64_t*)newRaw; metadata[0] = newCapacity; napi_set_element(env, me, 0, _new_raw); } if (returnUpdatedCapacity) { napi_value result; napi_create_int64(env, metadata[0] / 2, &result); return result; } return me; } // TODO -----Unchangers----- napi_value ToBuffer(napi_env env, napi_callback_info info){ size_t argsLength = 2; napi_value args[2]; napi_value me; napi_get_cb_info(env, info, &argsLength, args, &me, 0); uint16_t* buffer; int64_t* metadata; getBufferAndMetaData(env, me, &buffer, &metadata); int64_t start, end; switch(argsLength) { case 0: start = 0; end = metadata[1]; break; case 1: { getRealIndex(env, metadata, args[0], &start); end = metadata[1]; break; } case 2: { getRealIndex(env, metadata, args[0], &start); getRealIndex(env, metadata, args[1], &end); break; } } napi_value tempString; napi_create_string_utf16(env, buffer + (start / 2), (end - start) / 2, &tempString); size_t sourceDataSize; napi_get_value_string_utf8(env, tempString, NULL, 0, &sourceDataSize); ++sourceDataSize; char* utf8Data = (char*)malloc(sizeof(char) * sourceDataSize); napi_get_value_string_utf8(env, tempString, utf8Data, sourceDataSize, &sourceDataSize); napi_value result; char* data; napi_create_buffer_copy(env, sourceDataSize, utf8Data, (void**)(&data), &result); free(utf8Data); return result; } napi_value ToString(napi_env env, napi_callback_info info){ size_t argsLength = 2; napi_value args[2]; napi_value me; napi_get_cb_info(env, info, &argsLength, args, &me, 0); uint16_t* buffer; int64_t* metadata; getBufferAndMetaData(env, me, &buffer, &metadata); int64_t start, end; switch(argsLength) { case 0: start = 0; end = metadata[1]; break; case 1: { getRealIndex(env, metadata, args[0], &start); end = metadata[1]; break; } case 2: { getRealIndex(env, metadata, args[0], &start); getRealIndex(env, metadata, args[1], &end); break; } } napi_value result; napi_create_string_utf16(env, buffer + (start / 2), (end - start) / 2, &result); return result; } napi_value Inspect(napi_env env, napi_callback_info info){ napi_value me; napi_get_cb_info(env, info, 0, 0, &me, 0); uint16_t* buffer; int64_t* metadata; getBufferAndMetaData(env, me, &buffer, &metadata); napi_value result; napi_create_string_utf16(env, buffer, metadata[1] / 2, &result); return result; } napi_value Clone(napi_env env, napi_callback_info info){ napi_value me; napi_get_cb_info(env, info, 0, 0, &me, 0); uint8_t* raw; uint64_t rawLength; getRawData(env, me, &raw, &rawLength); napi_value _new_raw; uint8_t* newRaw; napi_create_buffer_copy(env, rawLength, raw, (void**)(&newRaw), &_new_raw); napi_value newMe; napi_value StringBuilder; napi_get_reference_value(env, StringBuilderRef, &StringBuilder); napi_value vFalse = createFalse(env); napi_value args[3]; args[0] = vFalse; args[1] = vFalse; args[2] = vFalse; napi_new_instance(env, StringBuilder, 3, args, &newMe); napi_set_element(env, newMe, 0, _new_raw); return newMe; } napi_value Count(napi_env env, napi_callback_info info){ napi_value me; napi_get_cb_info(env, info, 0, 0, &me, 0); uint16_t* buffer; int64_t* metadata; getBufferAndMetaData(env, me, &buffer, &metadata); uint8_t mode = 0; //0: nornal, 1: appending, 2: integer, 3: prefloat, 4: float int64_t sum = 0, i, length = metadata[1] / 2; for (i = 0; i < length; ++i) { int64_t v = buffer[i]; if (v >= 48 && v <= 57) { switch (mode) { case 0: mode = 2; break; case 3: mode = 4; break; default: break; } } else if ((v >= 65 && v <= 90) || (v >= 97 && v <= 122)) { switch (mode) { case 0: mode = 1; break; case 2: mode = 1; break; case 3: case 4: ++sum; mode = 1; break; default: break; } } else if (v > 127) { switch (mode) { case 0: ++sum; break; default: sum += 2; mode = 0; break; } } else { switch (mode) { case 0: break; case 2: if (v == 46) { mode = 3; } else { ++sum; mode = 0; } break; default: ++sum; mode = 0; break; } } } if (mode != 0) { ++sum; } napi_value result; napi_create_int64(env, sum, &result); return result; } napi_value EqualsIgnoreCase(napi_env env, napi_callback_info info){ napi_value me; size_t argsLength = 1; napi_value args[1]; napi_get_cb_info(env, info, &argsLength, args, &me, 0); if(argsLength == 0) { return createFalse(env); } uint16_t* buffer; int64_t* metadata; getBufferAndMetaData(env, me, &buffer, &metadata); uint16_t* dataBuffer; int64_t dataLength; bool freeAble; getUTF16FromOutside(env, args[0], &dataBuffer, &dataLength, &freeAble); if (dataLength != metadata[1]) { if(freeAble) { free(dataBuffer); } return createFalse(env); } int64_t i, length = metadata[1] / 2; for (i = 0; i < length; ++i) { uint16_t v1 = buffer[i]; uint16_t v2 = dataBuffer[i]; if (v1 >= 97 && v1 <= 122) { v1 -= 32; } if (v2 >= 97 && v2 <= 122) { v2 -= 32; } if (v1 != v2) { if(freeAble) { free(dataBuffer); } return createFalse(env); } } if(freeAble) { free(dataBuffer); } return createTrue(env); } napi_value Equals(napi_env env, napi_callback_info info){ napi_value me; size_t argsLength = 1; napi_value args[1]; napi_get_cb_info(env, info, &argsLength, args, &me, 0); if(argsLength == 0) { return createFalse(env); } uint16_t* buffer; int64_t* metadata; getBufferAndMetaData(env, me, &buffer, &metadata); uint16_t* dataBuffer; int64_t dataLength; bool freeAble; getUTF16FromOutside(env, args[0], &dataBuffer, &dataLength, &freeAble); if (dataLength != metadata[1]) { if(freeAble) { free(dataBuffer); } return createFalse(env); } int64_t c = memcmp(dataBuffer, buffer, dataLength); if(freeAble) { free(dataBuffer); } if(c == 0) { return createTrue(env); } return createFalse(env); } napi_value StartsWith(napi_env env, napi_callback_info info){ napi_value me; size_t argsLength = 1; napi_value args[1]; napi_get_cb_info(env, info, &argsLength, args, &me, 0); if(argsLength == 0) { return createFalse(env); } uint16_t* buffer; int64_t* metadata; getBufferAndMetaData(env, me, &buffer, &metadata); uint16_t* dataBuffer; int64_t dataLength; bool freeAble; getUTF16FromOutside(env, args[0], &dataBuffer, &dataLength, &freeAble); if (dataLength > metadata[1]) { if(freeAble) { free(dataBuffer); } return createFalse(env); } int64_t c = memcmp(dataBuffer, buffer, dataLength); if(freeAble) { free(dataBuffer); } if(c == 0) { return createTrue(env); } return createFalse(env); } napi_value EndsWith(napi_env env, napi_callback_info info){ napi_value me; size_t argsLength = 1; napi_value args[1]; napi_get_cb_info(env, info, &argsLength, args, &me, 0); if(argsLength == 0) { return createFalse(env); } uint16_t* buffer; int64_t* metadata; getBufferAndMetaData(env, me, &buffer, &metadata); uint16_t* dataBuffer; int64_t dataLength; bool freeAble; getUTF16FromOutside(env, args[0], &dataBuffer, &dataLength, &freeAble); if (dataLength > metadata[1]) { if(freeAble) { free(dataBuffer); } return createFalse(env); } int64_t c = memcmp(dataBuffer, buffer + ((metadata[1] - dataLength) / 2), dataLength); if(freeAble) { free(dataBuffer); } if(c == 0) { return createTrue(env); } return createFalse(env); } napi_value IndexOf(napi_env env, napi_callback_info info){ napi_value me; size_t argsLength = 3; napi_value args[3]; napi_get_cb_info(env, info, &argsLength, args, &me, 0); if(argsLength == 0) { return createEmptyArray(env); } uint16_t* buffer; int64_t* metadata; getBufferAndMetaData(env, me, &buffer, &metadata); int64_t offset, limit; switch(argsLength) { case 1: offset = 0; limit = 0; break; case 2: getRealIndex(env, metadata, args[1], &offset); limit = 0; break; default: getRealIndex(env, metadata, args[1], &offset); napi_get_value_int64(env, args[2], &limit); } uint16_t* dataBuffer; int64_t dataLength; bool freeAble; getUTF16FromOutside(env, args[0], &dataBuffer, &dataLength, &freeAble); napi_value result; result = boyerMooreMagicLen(env, buffer, metadata[1] / 2, dataBuffer, dataLength / 2, offset / 2, limit); if(freeAble) { free(dataBuffer); } return result; } napi_value IndexOfRegExp(napi_env env, napi_callback_info info){ napi_value me; size_t argsLength = 3; napi_value args[3]; napi_get_cb_info(env, info, &argsLength, args, &me, 0); if(argsLength == 0) { return createEmptyArray(env); } uint16_t* buffer; int64_t* metadata; getBufferAndMetaData(env, me, &buffer, &metadata); int64_t offset, limit; switch(argsLength) { case 1: offset = 0; limit = 0; break; case 2: getRealIndex(env, metadata, args[1], &offset); limit = 0; break; default: getRealIndex(env, metadata, args[1], &offset); napi_get_value_int64(env, args[2], &limit); } napi_value result; napi_value RegExpSearch; napi_get_reference_value(env, RegExpSearchRef,&RegExpSearch); napi_value r, s, o,l; r = args[0]; napi_create_string_utf16(env, buffer + (offset / 2), (metadata[1] - offset) / 2, &s); napi_create_int64(env, offset / 2, &o); napi_create_int64(env, limit, &l); napi_value t_args[4]; t_args[0] = r; t_args[1] = s; t_args[2] = o; t_args[3] = l; napi_call_function(env, me, RegExpSearch, 4, t_args, &result); return result; } napi_value IndexOfSkip(napi_env env, napi_callback_info info){ napi_value me; size_t argsLength = 3; napi_value args[3]; napi_get_cb_info(env, info, &argsLength, args, &me, 0); if(argsLength == 0) { return createEmptyArray(env); } uint16_t* buffer; int64_t* metadata; getBufferAndMetaData(env, me, &buffer, &metadata); int64_t offset, limit; switch(argsLength) { case 1: offset = 0; limit = 0; break; case 2: getRealIndex(env, metadata, args[1], &offset); limit = 0; break; default: getRealIndex(env, metadata, args[1], &offset); napi_get_value_int64(env, args[2], &limit); } uint16_t* dataBuffer; int64_t dataLength; bool freeAble; getUTF16FromOutside(env, args[0], &dataBuffer, &dataLength, &freeAble); napi_value result; result = boyerMooreMagicLenSkip(env, buffer, metadata[1] / 2, dataBuffer, dataLength / 2, offset / 2, limit); if(freeAble) { free(dataBuffer); } return result; } napi_value LastIndexOf(napi_env env, napi_callback_info info){ napi_value me; size_t argsLength = 3; napi_value args[3]; napi_get_cb_info(env, info, &argsLength, args, &me, 0); if(argsLength == 0) { return createEmptyArray(env); } uint16_t* buffer; int64_t* metadata; getBufferAndMetaData(env, me, &buffer, &metadata); int64_t offset, limit; switch(argsLength) { case 1: offset = 0; limit = 0; break; case 2: getRealIndex(env, metadata, args[1], &offset); limit = 0; break; default: getRealIndex(env, metadata, args[1], &offset); napi_get_value_int64(env, args[2], &limit); } uint16_t* dataBuffer; int64_t dataLength; bool freeAble; getUTF16FromOutside(env, args[0], &dataBuffer, &dataLength, &freeAble); napi_value result; result = boyerMooreMagicLenRev(env, buffer, metadata[1] / 2, dataBuffer, dataLength / 2, offset / 2, limit); if(freeAble) { free(dataBuffer); } return result; } napi_value CharAt(napi_env env, napi_callback_info info){ napi_value me; size_t argsLength = 1; napi_value args[1]; napi_get_cb_info(env, info, &argsLength, args, &me, 0); uint16_t* buffer; int64_t* metadata; getBufferAndMetaData(env, me, &buffer, &metadata); int64_t index; getRealIndex(env, metadata, args[0], &index); napi_value result; napi_create_string_utf16(env, buffer + index, 1, &result); return result; }; // TODO -----Static----- napi_value from(napi_env env, napi_callback_info info){ napi_value me, newMe; size_t argsLength = 2; napi_value args[2]; napi_get_cb_info(env, info, &argsLength, args, &me, 0); napi_value StringBuilder; napi_get_reference_value(env, StringBuilderRef, &StringBuilder); napi_new_instance(env, StringBuilder, argsLength, args, &newMe); return newMe; } napi_value initialize(napi_env env, napi_callback_info info){ size_t argsLength = 3; napi_value args[3]; napi_get_cb_info(env, info, &argsLength, args, 0, 0); if(argsLength < 3) { return createFalse(env); } napi_value ReadStream = args[0]; napi_create_reference(env, ReadStream, 1, &ReadStreamRef); napi_value ReadFileStream = args[1]; napi_create_reference(env, ReadFileStream, 1, &ReadFileStreamRef); napi_value RegExpSearch = args[2]; napi_create_reference(env, RegExpSearch, 1, &RegExpSearchRef); return createTrue(env); } // TODO -----Constructor----- napi_value constructor(napi_env env, napi_callback_info info){ napi_value me; size_t argsLength = 3; napi_value args[3]; napi_get_cb_info(env, info, &argsLength, args, &me, 0); int64_t initialCapacity; uint16_t* contentBuffer; int64_t contentLength; bool freeAble; switch(argsLength) { case 0: contentLength = 0; initialCapacity = blockSize / 2; freeAble = false; break; case 1: getUTF16FromOutside(env, args[0], &contentBuffer, &contentLength, &freeAble); initialCapacity = blockSize / 2; break; case 2: getUTF16FromOutside(env, args[0], &contentBuffer, &contentLength, &freeAble); napi_get_value_int64(env, args[1], &initialCapacity); break; default: return me; } int64_t capacityLength = max(initialCapacity * 2, contentLength); int64_t count = (capacityLength + blockSize - 1) / blockSize; if(count == 0) { count = 1; } int64_t capacity = count * blockSize; napi_value _raw; uint8_t* raw; napi_create_buffer(env, 16 + capacity, (void**)(&raw), &_raw); int64_t* metadata = (int64_t*)raw; metadata[0] = capacity; metadata[1] = contentLength; napi_set_element(env, me, 0, _raw); memcpy(raw + 16, contentBuffer, contentLength); if(freeAble) { free(contentBuffer); } return me; } napi_value Init (napi_env env, napi_value exports) { napi_property_descriptor allDesc[] = { {"from", 0, from, 0, 0, 0, napi_default, 0}, {"_initialize", 0, initialize, 0, 0, 0, napi_default, 0} }; napi_define_properties(env, exports, 2, allDesc); napi_property_descriptor stringBuilderAllDesc[] = { {"from", 0, from, 0, 0, 0, napi_static, 0}, {"inspect", 0, Inspect, 0, 0, 0, napi_default, 0}, {"toString", 0, ToString, 0, 0, 0, napi_default, 0}, {"toBuffer", 0, ToBuffer, 0, 0, 0, napi_default, 0}, {"clone", 0, Clone, 0, 0, 0, napi_default, 0}, {"count", 0, Count, 0, 0, 0, napi_default, 0}, {"equalsIgnoreCase", 0, EqualsIgnoreCase, 0, 0, 0, napi_default, 0}, {"equals", 0, Equals, 0, 0, 0, napi_default, 0}, {"startsWith", 0, StartsWith, 0, 0, 0, napi_default, 0}, {"endsWith", 0, EndsWith, 0, 0, 0, napi_default, 0}, {"indexOf", 0, IndexOf, 0, 0, 0, napi_default, 0}, {"indexOfSkip", 0, IndexOfSkip, 0, 0, 0, napi_default, 0}, {"indexOfRegExp", 0, IndexOfRegExp, 0, 0, 0, napi_default, 0}, {"lastIndexOf", 0, LastIndexOf, 0, 0, 0, napi_default, 0}, {"charAt", 0, CharAt, 0, 0, 0, napi_default, 0}, {"length", 0, Length, 0, 0, 0, napi_default, 0}, {"capacity", 0, Capacity, 0, 0, 0, napi_default, 0}, {"replace", 0, Replace, 0, 0, 0, napi_default, 0}, {"insert", 0, Insert, 0, 0, 0, napi_default, 0}, {"clear", 0, Clear, 0, 0, 0, napi_default, 0}, {"delete", 0, Delete, 0, 0, 0, napi_default, 0}, {"deleteCharAt", 0, DeleteCharAt, 0, 0, 0, napi_default, 0}, {"substring", 0, Substring, 0, 0, 0, napi_default, 0}, {"slice", 0, Substring, 0, 0, 0, napi_default, 0}, {"substr", 0, Substr, 0, 0, 0, napi_default, 0}, {"append", 0, Append, 0, 0, 0, napi_default, 0}, {"appendRepeat", 0, AppendRepeat, 0, 0, 0, napi_default, 0}, {"appendLine", 0, AppendLine, 0, 0, 0, napi_default, 0}, {"reverse", 0, Reverse, 0, 0, 0, napi_default, 0}, {"upperCase", 0, UpperCase, 0, 0, 0, napi_default, 0}, {"toUpperCase", 0, UpperCase, 0, 0, 0, napi_default, 0}, {"lowerCase", 0, LowerCase, 0, 0, 0, napi_default, 0}, {"toLowerCase", 0, LowerCase, 0, 0, 0, napi_default, 0}, {"replacePattern", 0, ReplacePattern, 0, 0, 0, napi_default, 0}, {"replaceAll", 0, ReplaceAll, 0, 0, 0, napi_default, 0}, {"trim", 0, Trim, 0, 0, 0, napi_default, 0}, {"repeat", 0, Repeat, 0, 0, 0, napi_default, 0}, {"expandCapacity", 0, ExpandCapacity, 0, 0, 0, napi_default, 0}, {"shrinkCapacity", 0, ShrinkCapacity, 0, 0, 0, napi_default, 0} }; napi_value cons; napi_define_class(env, "StringBuilder", -1, constructor, 0, 39, stringBuilderAllDesc, &cons); napi_set_named_property(env, exports, "StringBuilder", cons); napi_create_reference(env, cons, 1, &StringBuilderRef); return exports; } NAPI_MODULE(node_stringbuilder, Init);