on_token()

ParseState fl::anonymous_namespace{json.cpp.hpp}::JsonBuilder::on_token ( JsonToken token, const fl::span< const char > & value )

inlineoverridevirtual

Implements fl::anonymous_namespace{json.cpp.hpp}::JsonVisitor.

Definition at line 931 of file json.cpp.hpp.

                                                                                   {
        // Recursion depth check
        if (mDepth > MAX_JSON_DEPTH) {
            FL_ERROR("JSON parser: FATAL - recursion depth exceeded %s", MAX_JSON_DEPTH);
            return ParseState::ERROR;
        }
 
        switch (token) {
            // Specialized array tokens - parse directly into typed vectors.
            // Gated on Low-memory per #3224 Tier 2D: these packed-array tokens
            // only fire when the tokenizer's `scan_array_lookahead` decides an
            // array is uniformly-typed and small. LowMemory targets don't use
            // the array-packing optimization (the integer-only RPC contract on
            // LPC8xx never sends packed vectors), so dropping these cases
            // collapses 3 large make_shared<json_value>(vector<T>) variant
            // emplace instantiations + parse_int_array + parse_float_array.
#if FL_PLATFORM_HAS_LARGE_MEMORY
            case JsonToken::ARRAY_UINT8: {
                fl::vector<u8> vec;
                if (!parse_int_array(value, vec)) return ParseState::ERROR;
                auto arr_val = fl::make_shared<json_value>(fl::move(vec));
                push_value(arr_val);
                return ParseState::KEEP_GOING;
            }
 
            case JsonToken::ARRAY_INT16: {
                fl::vector<i16> vec;
                if (!parse_int_array(value, vec)) return ParseState::ERROR;
                auto arr_val = fl::make_shared<json_value>(fl::move(vec));
                push_value(arr_val);
                return ParseState::KEEP_GOING;
            }
 
            case JsonToken::ARRAY_FLOAT: {
                fl::vector<float> vec;
                if (!parse_float_array(value, vec)) return ParseState::ERROR;
                auto arr_val = fl::make_shared<json_value>(fl::move(vec));
                push_value(arr_val);
                return ParseState::KEEP_GOING;
            }
#endif
 
            case JsonToken::LBRACE: {
                auto obj_val = fl::make_shared<json_value>(json_object{});
                // Don't push to parent yet - will push in RBRACE
                mStack.push_back({StackFrame::OBJECT, obj_val, ""});
                mDepth++;
                return ParseState::KEEP_GOING;
            }
 
            case JsonToken::RBRACE: {
                if (!mStack.empty() && mStack.back().type == StackFrame::OBJECT) {
                    auto obj_val = mStack.back().value;
                    mStack.pop_back();
                    mDepth--;
                    // Push to parent after object is complete
                    push_value(obj_val);
                }
                return ParseState::KEEP_GOING;
            }
 
            case JsonToken::LBRACKET: {
                auto arr_val = fl::make_shared<json_value>(json_array{});
                // Don't push to parent yet - will push in RBRACKET after optimization
                mStack.push_back({StackFrame::ARRAY, arr_val, ""});
                mDepth++;
                return ParseState::KEEP_GOING;
            }
 
            case JsonToken::RBRACKET: {
                if (!mStack.empty() && mStack.back().type == StackFrame::ARRAY) {
                    // Optimize array before pushing to parent (Milestone 9)
                    auto arr_val = optimize_array(mStack.back().value);
                    mStack.pop_back();
                    mDepth--;
                    // Push optimized array to parent
                    push_value(arr_val);
                }
                return ParseState::KEEP_GOING;
            }
 
            case JsonToken::STRING: {
                // Check if this is an object key (next token should be COLON)
                if (!mStack.empty() && mStack.back().type == StackFrame::OBJECT &&
                    mStack.back().pending_key.empty()) {
                    // Key: handle escape sequences, then intern (StringInterner handles SSO internally)
                    if (has_escape_sequences(value)) {
                        mStack.back().pending_key = mInterner.intern(unescape_string(value));
                    } else {
                        mStack.back().pending_key = mInterner.intern(value);
                    }
                } else {
                    // Value: handle escape sequences, then intern (StringInterner handles SSO internally)
                    fl::string str;
                    if (has_escape_sequences(value)) {
                        str = mInterner.intern(unescape_string(value));
                    } else {
                        str = mInterner.intern(value);
                    }
                    auto str_val = fl::make_shared<json_value>(str);
                    push_value(str_val);
                }
 
                return ParseState::KEEP_GOING;
            }
 
            case JsonToken::NUMBER: {
                // Determine if int or float by checking for decimal/exponent
                bool is_float = false;
                for (size_t i = 0; i < value.size(); i++) {
                    if (value[i] == '.' || value[i] == 'e' || value[i] == 'E') {
                        is_float = true;
                        break;
                    }
                }
 
                fl::shared_ptr<json_value> num_val;
#if FL_PLATFORM_HAS_LARGE_MEMORY
                if (is_float) {
                    // Bit-twiddling parse -> IEEE 754 bits -> store as float in the
                    // variant. The `bit_cast<float>` is a `memcpy` -- no libgcc
                    // soft-FP helper is reached on the parser hot path
                    // (FastLED #3022 phase 2).
                    const u32 bits = fl::ieee754_parse_decimal(value.data(), value.size());
                    num_val = fl::make_shared<json_value>(fl::bit_cast<float>(bits));
                } else {
                    int i = fl::parseInt(value.data(), value.size());
                    i64 i64_val = static_cast<i64>(i);
                    num_val = fl::make_shared<json_value>(i64_val);
                }
#else
                // Low-memory gate per FastLED #3224 Tier 2D: drop the float
                // store entirely. JSON float literals on LowMemory parse to
                // i64(0), avoiding the variant `float` emplace instantiation
                // that #3082's `0.0f` store used to anchor. Combined with
                // the ARRAY_FLOAT case gate above, LowMemory's JsonBuilder
                // never instantiates a `make_shared<json_value>(float)` or
                // `make_shared<json_value>(vector<float>)` path.
                (void)is_float;
                int i = fl::parseInt(value.data(), value.size());
                i64 i64_val = static_cast<i64>(i);
                num_val = fl::make_shared<json_value>(i64_val);
#endif
 
                push_value(num_val);
                return ParseState::KEEP_GOING;
            }
 
            case JsonToken::TRUE:
                push_value(fl::make_shared<json_value>(true));
                return ParseState::KEEP_GOING;
 
            case JsonToken::FALSE:
                push_value(fl::make_shared<json_value>(false));
                return ParseState::KEEP_GOING;
 
            case JsonToken::NULL_VALUE:
                push_value(fl::make_shared<json_value>(nullptr));
                return ParseState::KEEP_GOING;
 
            case JsonToken::COLON:
            case JsonToken::COMMA:
                // Structural tokens - no action needed
                return ParseState::KEEP_GOING;
 
            case JsonToken::END_OF_INPUT:
                return ParseState::KEEP_GOING;
 
            default:
                return ParseState::ERROR;
        }
    }

References fl::anonymous_namespace{json.cpp.hpp}::JsonBuilder::StackFrame::ARRAY, fl::anonymous_namespace{json.cpp.hpp}::ARRAY_FLOAT, fl::anonymous_namespace{json.cpp.hpp}::ARRAY_INT16, fl::anonymous_namespace{json.cpp.hpp}::ARRAY_UINT8, fl::bit_cast(), fl::anonymous_namespace{json.cpp.hpp}::COLON, fl::anonymous_namespace{json.cpp.hpp}::COMMA, fl::anonymous_namespace{json.cpp.hpp}::END_OF_INPUT, fl::anonymous_namespace{json.cpp.hpp}::ERROR, fl::anonymous_namespace{json.cpp.hpp}::FALSE, FL_ERROR, fl::anonymous_namespace{json.cpp.hpp}::has_escape_sequences(), fl::ieee754_parse_decimal(), fl::anonymous_namespace{json.cpp.hpp}::KEEP_GOING, fl::anonymous_namespace{json.cpp.hpp}::LBRACE, fl::anonymous_namespace{json.cpp.hpp}::LBRACKET, fl::make_shared(), fl::anonymous_namespace{json.cpp.hpp}::MAX_JSON_DEPTH, mDepth, mInterner, fl::move(), mStack, fl::anonymous_namespace{json.cpp.hpp}::NULL_VALUE, fl::anonymous_namespace{json.cpp.hpp}::NUMBER, fl::anonymous_namespace{json.cpp.hpp}::JsonBuilder::StackFrame::OBJECT, fl::anonymous_namespace{json.cpp.hpp}::optimize_array(), parse_float_array(), parse_int_array(), fl::parseInt(), push_value(), fl::anonymous_namespace{json.cpp.hpp}::RBRACE, fl::anonymous_namespace{json.cpp.hpp}::RBRACKET, fl::anonymous_namespace{json.cpp.hpp}::STRING, fl::anonymous_namespace{json.cpp.hpp}::TRUE, fl::type_rank< T >::value, and fl::anonymous_namespace{json.cpp.hpp}::unescape_string().

Here is the call graph for this function: