Sinfolke
commented
1 month ago i may send entire code
#include <string.h>
#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>
#ifdef _WIN32
#define EXPORT __declspec(dllexport)
#else
#define EXPORT __attribute__((visibility("default")))
#endif
/**e
* @brief If the size we allocated differs too much with the actual size of the string it calls realloc to decrease at the actual size
* For now it is defined to be 32 (16 utf16 characters, or 32 ascii characters)
*/
#define MIN_REALLOC_REQUEST_SIZE 32
enum {
AllocError,
RangeError
};
struct cst_string {
size_t len;
const char* str;
int err;
// err can be removed out, errors can be still handled into those to variables for optimization
// but choose it as it makes easer to understand what's going on
};
EXPORT void* ___cadd_pointer(void* ptr, int val) {
return ptr + val;
}
// *** String class methods ***
EXPORT struct cst_string ___cfromCharCode(const uint16_t* numN, const long long count) {
printf("cfromCodePoint is executed (beginning)\n");
printf("numN = %p\ncount = %lld\n", numN, count);
struct cst_string r = {0, NULL};
if (count <= 0) return r;
printf("Doing allocation\n");
r.len = count * sizeof(uint16_t);
r.str = malloc(r.len);
if (!r.str) return r;
printf("Doing memcpy\n");
memcpy(r.str, numN, r.len - 1);
return r;
}
// code produced by charGpt (bits management in the loop)
// however seems it processes well
EXPORT struct cst_string ___cfromCodePoint(const uint32_t* numN, size_t count) {
// assume maximum length
struct cst_string r = {count*4, NULL, 0};
r.str = malloc(r.len);
if (!r.str) {
r.err = AllocError;
return r;
}
// iterate through string and codePoint
char* ptr = r.str;
size_t offset = 0; // variable defines how many bytes may be deallocated
for (size_t i = 0; i < count; ++i) {
uint32_t codePoint = numN[i];
if (codePoint <= 0xFFFF) {
// BMP character
// it consumes 2 bytes
// so we're adding to offset other 2 bytes
offset += 2;
*ptr++ = (codePoint >> 8) & 0xFF; // High byte
*ptr++ = codePoint & 0xFF; // Low byte
// remove from the size unnecessary bytes
} else if (codePoint <= 0x10FFFF) {
// Supplementary character
// it consumes 4 bytes
codePoint -= 0x10000;
uint16_t highSurrogate = (codePoint >> 10) + 0xD800;
uint16_t lowSurrogate = (codePoint & 0x3FF) + 0xDC00;
*ptr++ = (highSurrogate >> 8) & 0xFF; // High surrogate high byte
*ptr++ = highSurrogate & 0xFF; // High surrogate low byte
*ptr++ = (lowSurrogate >> 8) & 0xFF; // Low surrogate high byte
*ptr++ = lowSurrogate & 0xFF; // Low surrogate low byte
} else {
// interact with the TS to throw RangeError
// len is set to the codePoint (which must be in error message)
// err is set to their error code
// for str is called free. Therefore no need to worry for deallocation
r.len = codePoint;
r.err = RangeError;
free(r.str);
return r;
}
}
r.len-=offset;
// if the offset it too big we request realloc to reduce the size
// if not we remain some extra bytes allocated.
// They'll be automatically removed out when realloc or free is called
if (offset >= MIN_REALLOC_REQUEST_SIZE) {
char* newstr = realloc(r.str, r.len);
if (!newstr)
// unhandled realloc failure
return r;
r.str = newstr;
}
return r;
}
// declare type Reference<T> = T;
// declare function ReferenceOf(obj: any): any;
// declare function LoadReference<T>(obj: T) : T;
// a type used in C code to represent string in efficient way
// err variable often used to handle errors when allocating etc.
declare type cst_string = {
len: u64;
str: Reference<char>;
err: int;
};
// memory management functions
// declare function malloc(size: long): Reference<char>;
// declare function free<T>(pointer: Reference<T>): void;
// declare function exit(code: int): void;
// Internal functions from native.c
declare function __cfromCharCode(numN: Reference<u16>, count: i64): cst_string;
declare function __cfromCodePoint(numN: Reference<u32>, count: u64): cst_string;
declare function __cadd_pointer(pointer: Reference<char>, value: int): Reference<char>;
// should convert the cst_string (which is used by the internal modules) into a string class
function cst_string_to_string(str: cst_string): string {
// for now very unoptimized convertion. But the only way i found out
let s: string = "";
for (let i: int = 0; i < str.len; ++i) {
str.str = __cadd_pointer(str.str, 1);
s += LoadReference(str.str);
}
return s;
}
class String {
static fromCharCode(...numN: u16[]): string {
log("fromCharsCode executed");
log(numN.length);
let res: cst_string = __cfromCharCode(ReferenceOf(numN), numN.length);
log("__cfromCharsCode executed");
// call convertion to a regular string
return cst_string_to_string(res);
}
static fromCodePoint(...numN: u32[]): string {
let res: cst_string = __cfromCodePoint(ReferenceOf(numN), numN.length);
if (res.err == 1) {
// we do not have error class for now
// use just output
// throw Error("Allocation error");
print("Allocation Error");
} else if (res.err == 2) {
// res.len represents the character value
// res.str has been deallocated automatically once the error cocured in the internal function
// throw RangeError(`Invalid code point ${res.len}`); // error message from the original js function
print(`Invalid code point ${res.len}`);
}
// call convertion to a regular string
return cst_string_to_string(res);
}
// fully written by the chatGpt
static raw(strings: TemplateStringsArray, ...values: any[]): string {
let result = '';
for (let i = 0; i < strings.length; i++) {
result += strings[i];
if (i < values.length) {
result += values[i];
}
}
return result;
}
}
function main() {
log(String.fromCharCode(189, 293, 239, 901));
}
ASDAlexander77
I'm sorry that there is already so much issues. There's another one that the compiler adds one more '_' to the functions it searches in static .lib library. I did write a bit some String class static properties on C and test them in ts. When it links it adds one more '_' (i understood it by the error message):
as you may see there're two '__'. then compile: