8000 Implement Singularity Architecture v8.3 by google-labs-jules[bot] · Pull Request #19 · wilkolbrzym-coder/Tachyon.JSON · GitHub
[go: up one dir, main page]
Skip to content

Implement Singularity Architecture v8.3 #19

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Draft
google-labs-jules wants to merge 1 commit into
base: licensing-branding-update-3974880859464695194
Choose a base branch
from
Draft

Implement Singularity Architecture v8.3 #19

Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
225 changes: 186 additions & 39 deletions tachyon.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -109,9 +109,19 @@ struct TachyonString {
const char* ptr;
uint32_t len;

#if __cplusplus >= 201703L
operator std::string_view() const { return std::string_view(ptr, len); }
#endif

std::string to_std() const { return std::string(ptr, len); }
bool operator==(const char* rhs) const { return strncmp(ptr, rhs, len) == 0 && rhs[len] == 0; }
bool operator==(const std::string& rhs) const { return len == rhs.size() && memcmp(ptr, rhs.data(), len) == 0; }

// For sorting
bool operator<(const TachyonString& rhs) const {
int cmp = memcmp(ptr, rhs.ptr, std::min(len, rhs.len));
return cmp < 0 || (cmp == 0 && len < rhs.len);
}
};

struct TachyonObject {
Expand Down Expand Up @@ -210,6 +220,7 @@ class json {
template<typename T> T get() const;

operator int() const { return (int)m_value.number_integer; }
operator int64_t() const { return m_value.number_integer; }
operator double() const { return m_value.number_float; }
operator bool() const { return m_value.boolean; }
operator std::string() const { return m_value.string.to_std(); }
Expand Down Expand Up @@ -265,10 +276,35 @@ inline json& json::operator[](const char* key) {
if (m_type != value_t::object) throw std::runtime_error("Not object");

TachyonObjectEntry* entries = (TachyonObjectEntry*)m_value.object.entries;
for(size_t i=0; i<m_value.object.len; ++i) {
if (entries[i].key == key) return entries[i].val_;

// Small Object Optimization & Lazy Sorting
if (m_value.object.len >= 16) {
if (!m_value.object.sorted) {
std::sort(entries, entries + m_value.object.len,
[](const TachyonObjectEntry& a, const TachyonObjectEntry& b) {
return a.key < b.key;
});
m_value.object.sorted = true;
}

TachyonString target_key = {key, (uint32_t)strlen(key)};
TachyonObjectEntry* it = std::lower_bound(entries, entries + m_value.object.len, target_key,
[](const TachyonObjectEntry& entry, const TachyonString& k) {
return entry.key < k;
});

if (it != entries + m_value.object.len && it->key == key) {
return it->val_;
}
} else {
// Linear Scan
for(size_t i=0; i<m_value.object.len; ++i) {
if (entries[i].key == key) return entries[i].val_;
}
}

// Insert new
m_value.object.sorted = false;
size_t new_len = m_value.object.len + 1;
TachyonObjectEntry* new_entries = (TachyonObjectEntry*)PagedArena::tls_instance().allocate(new_len * sizeof(TachyonObjectEntry));
if (m_value.object.len > 0) std::memcpy(new_entries, entries, m_value.object.len * sizeof(TachyonObjectEntry));
Expand All @@ -289,8 +325,20 @@ inline json& json::operator[](const char* key) {
inline const json& json::operator[](const char* key) const {
if (m_type != value_t::object) throw std::runtime_error("Not object");
TachyonObjectEntry* entries = (TachyonObjectEntry*)m_value.object.entries;
for(size_t i=0; i<m_value.object.len; ++i) {
if (entries[i].key == key) return entries[i].val_;

if (m_value.object.len >= 16 && m_value.object.sorted) {
TachyonString target_key = {key, (uint32_t)strlen(key)};
auto it = std::lower_bound(entries, entries + m_value.object.len, target_key,
[](const TachyonObjectEntry& entry, const TachyonString& k) {
return entry.key < k;
});
if (it != entries + m_value.object.len && it->key == key) {
return it->val_;
}
} else {
for(size_t i=0; i<m_value.object.len; ++i) {
if (entries[i].key == key) return entries[i].val_;
}
}
throw std::out_of_range("Key not found");
}
Expand Down Expand Up @@ -429,40 +477,92 @@ TACHYON_FORCE_INLINE const char* scan_string(const char* curr, const char* end)
return curr;
}

TACHYON_FORCE_INLINE json parse_number(const char*& curr) {
TACHYON_FORCE_INLINE json parse_number(const char*& curr, const char* end) {
const char* start = curr;
bool neg = false;
if (*curr == '-') { neg=true; curr++; }

bool floating = false;
while(true) {
char c = *curr;
if (c >= '0' && c <= '9') { curr++; continue; }
if (c == '.' || c == 'e' || c == 'E') { floating=true; curr++; continue; }
if (c == '+' || c == '-') { curr++; continue; }
if (curr < end && *curr == '-') { neg=true; curr++; }

// Scan integer part first (manual loop for speed)
uint64_t v = 0;
while (curr < end) {
char c1 = *curr;
if (c1 < '0' || c1 > '9') break;

if (curr + 1 < end) {
char c2 = *(curr+1);
if (c2 >= '0' && c2 <= '9') {
v = v * 100 + (c1 - '0') * 10 + (c2 - '0');
curr += 2;
continue;
}
}

v = v * 10 + (c1 - '0');
curr++;
break;
}

if (floating) {
#if __cplusplus >= 201703L
double d;
std::from_chars(start, curr, d);
return json(d);
#else
return json(std::strtod(start, nullptr));
#endif
} else {
uint64_t v = 0;
// Check for float
if (curr < end && (*curr == '.' || *curr == 'e' || *curr == 'E')) {
// Scan end of float
const char* p = curr;
while(p < end) {
char c = *p;
if ((c >= '0' && c <= '9') || c == '.' || c == 'e' || c == 'E' || c == '+' || c == '-') { p++; }
else break;
}

// Fast Path Float
bool simple = true;
double frac = 0.0;
double div = 1.0;
const char* fscan = curr;

if (fscan < end && *fscan == '.') {
fscan++;
while (fscan < p) {
if (*fscan >= '0' && *fscan <= '9') {
frac = frac * 10.0 + (*fscan - '0');
div *= 10.0;
fscan++;
} else if (*fscan == 'e' || *fscan == 'E') {
simple = false; break;
} else {
break;
}
}
} else {
simple = false;
}

if (simple && div > 1.0) {
double d = (double)v + (frac / div);
if (neg) d = -d;
curr = p;
return json(d);
}

// Fallback
#if __cplusplus >= 201703L
std::from_chars(start, curr, v);
double d;
std::from_chars(start, p, d);
curr = p;
return json(d);
#else
const char* p = start;
if (neg) p++;
while(p < curr) { v = v*10 + (*p - '0'); p++; }
char buf[64];
size_t len = p - start;
if (len < 63) {
memcpy(buf, start, len); buf[len] = 0;
curr = p;
return json(std::strtod(buf, nullptr));
}
curr = p;
return json(0.0);
#endif
if (neg) return json(-(int64_t)v);
return json(v);
}

if (neg) return json(-(int64_t)v);
return json(v);
}

inline json parse(const char* ptr, size_t len) {
Expand All @@ -484,10 +584,24 @@ inline json parse(const char* ptr, size_t len) {
} else {
if (c == '"') {
curr++; const char* s=curr; curr=scan_string(curr, end);
TachyonString ts={s, (uint32_t)(curr-s)}; if (*curr=='\\') { while(*curr!='"' || *(curr-1)=='\\') curr++; } curr++;
if (curr < end && *curr == '\\') {
// Fallback for escapes
while (curr < end) {
if (*curr == '"') {
// Check backslashes
const char* b = curr - 1;
int bcount = 0;
while (b >= s && *b == '\\') { bcount++; b--; }
if (bcount % 2 == 0) break; // Even backslashes -> quote is unescaped
}
curr++;
}
}
TachyonString ts={s, (uint32_t)(curr-s)};
if (curr < end) curr++; // Skip closing quote
return json(std::string(ts.ptr, ts.len));
}
return parse_number(curr);
return parse_number(curr, end);
}

while (!call_stack.empty()) {
Expand Down Expand Up @@ -538,12 +652,23 @@ inline json parse(const char* ptr, size_t len) {
json val;
if (c == '"') {
curr++; const char* s=curr; curr=scan_string(curr, end);
if (*curr == '\\') { while(*curr!='"' || *(curr-1)=='\\') curr++; }
val.set_string(s, curr-s); curr++;
if (curr < end && *curr == '\\') {
while (curr < end) {
if (*curr == '"') {
const char* b = curr - 1;
int bcount = 0;
while (b >= s && *b == '\\') { bcount++; b--; }
if (bcount % 2 == 0) break;
}
curr++;
}
}
val.set_string(s, curr-s);
if (curr < end) curr++;
} else if (c == 't') { curr+=4; val=json(true); }
else if (c == 'f') { curr+=5; val=json(false); }
else if (c == 'n') { curr+=4; val=json(nullptr); }
else { val = parse_number(curr); }
else { val = parse_number(curr, end); }

array_stack.push_back(val);

Expand Down Expand Up @@ -582,9 +707,20 @@ inline json parse(const char* ptr, size_t len) {

if (*curr != '"') throw std::runtime_error("Key exp");
curr++; const char* s=curr; curr=scan_string(curr, end);

if (curr < end && *curr == '\\') {
while (curr < end) {
if (*curr == '"') {
const char* b = curr - 1;
int bcount = 0;
while (b >= s && *b == '\\') { bcount++; b--; }
if (bcount % 2 == 0) break;
}
curr++;
}
}
TachyonString key = {s, (uint32_t)(curr-s)};
if (*curr == '\\') { while(*curr!='"' || *(curr-1)=='\\') curr++; key.len=curr-s; }
curr++;
if (curr < end) curr++;

while (curr < end && (unsigned char)*curr <= 32) curr++;
if (*curr != ':') throw std::runtime_error("Col");
Expand All @@ -608,12 +744,23 @@ inline json parse(const char* ptr, size_t len) {
json val;
if (c == '"') {
curr++; const char* vs=curr; curr=scan_string(curr, end);
if (*curr == '\\') { while(*curr!='"' || *(curr-1)=='\\') curr++; }
val.set_string(vs, curr-vs); curr++;
if (curr < end && *curr == '\\') {
while (curr < end) {
if (*curr == '"') {
const char* b = curr - 1;
int bcount = 0;
while (b >= vs && *b == '\\') { bcount++; b--; }
if (bcount % 2 == 0) break;
}
curr++;
}
}
val.set_string(vs, curr-vs);
if (curr < end) curr++;
} else if (c == 't') { curr+=4; val=json(true); }
else if (c == 'f') { curr+=5; val=json(false); }
else if (c == 'n') { curr+=4; val=json(nullptr); }
else { val = parse_number(curr); }
else { val = parse_number(curr, end); }

object_stack.back().val_ = val;

Expand Down
0