/* * Copyright (C) 2025 Linux Studio Plugins Project * (C) 2025 Vladimir Sadovnikov * * This file is part of lsp-runtime-lib * Created on: 29 мая 2019 г. * * lsp-runtime-lib is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published by * the Free Software Foundation, either version 3 of the License, or * any later version. * * lsp-runtime-lib is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License * along with lsp-runtime-lib. If not, see . */ #define __LSP_PROTOCOL_OSC_IMPL #include #include #include #include #include #include #include #include namespace lsp { namespace osc { bool parse_check_child(parse_frame_t *child, parse_frame_t *ref) { if ((ref == NULL) || (child == NULL)) return false; for ( ; ref != NULL; ref = ref->parent) if (ref == child) return false; return true; } status_t parse_begin(parse_frame_t *ref, parser_t *parser, const void *data, size_t size) { if ((ref == NULL) || (parser == NULL) || (data == NULL)) return STATUS_BAD_ARGUMENTS; if ((size < sizeof(uint32_t)) || ((size % sizeof(uint32_t)) != 0)) return STATUS_BAD_ARGUMENTS; ref->parser = parser; ref->parent = NULL; ref->child = NULL; ref->type = FRT_ROOT; ref->limit = size; parser->data = reinterpret_cast(data); parser->offset = 0; parser->size = size; parser->refs = 1; parser->args = NULL; return STATUS_OK; } status_t parse_token(parse_frame_t *ref, parse_token_t *token) { if (ref == NULL) return STATUS_BAD_ARGUMENTS; if ((ref->child != NULL) || (ref->parser == NULL)) return STATUS_BAD_STATE; parser_t *buf = ref->parser; int tok = -1; ssize_t left = ref->limit - buf->offset; switch (ref->type) { case FRT_ROOT: case FRT_BUNDLE: { // End of record? if (left == 0) { tok = PT_EOR; break; } union { const bundle_header_t *hdr; const uint32_t *u32; const uint8_t *u8; } xptr; xptr.u8 = &buf->data[buf->offset]; size_t size = buf->size; // End of record? if (ref->type != FRT_ROOT) { size = BE_TO_CPU(xptr.u32[0]); ++xptr.u32; left -= 4; } else if (buf->offset > 0) return STATUS_CORRUPTED; // Check that size field is valid if (size_t(left) < size) return STATUS_CORRUPTED; if ((size >= sizeof(uint32_t)) && (xptr.u8[0] == '/')) tok = PT_MESSAGE; else if ((size >= sizeof(bundle_header_t)) && (xptr.hdr->sig == BUNDLE_SIG)) tok = PT_BUNDLE; break; } case FRT_MESSAGE: case FRT_ARRAY: if (buf->args == NULL) return STATUS_BAD_STATE; switch (*(buf->args)) { case FPT_INT32: tok = PT_INT32; break; case FPT_FLOAT32: tok = PT_FLOAT32; break; case FPT_OSC_STRING: tok = PT_OSC_STRING; break; case FPT_OSC_BLOB: tok = PT_OSC_BLOB; break; case FPT_INT64: tok = PT_INT64; break; case FPT_OSC_TIMETAG: tok = PT_OSC_TIMETAG; break; case FPT_DOUBLE64: tok = PT_DOUBLE64; break; case FPT_TYPE: tok = PT_TYPE; break; case FPT_ASCII_CHAR: tok = PT_ASCII_CHAR; break; case FPT_RGBA_COLOR: tok = PT_RGBA_COLOR; break; case FPT_MIDI_MESSAGE: tok = PT_MIDI_MESSAGE; break; case FPT_TRUE: tok = PT_TRUE; break; case FPT_FALSE: tok = PT_FALSE; break; case FPT_NULL: tok = PT_NULL; break; case FPT_INF: tok = PT_INF; break; case FPT_ARRAY_START: tok = PT_ARRAY; break; case FPT_ARRAY_END: if (ref->type == FRT_ARRAY) tok = PT_EOR; break; case 0: if ((ref->type == FRT_MESSAGE) && (left <= 0)) tok = PT_EOR; break; default: break; } break; default: return STATUS_BAD_STATE; } if (tok == -1) return STATUS_CORRUPTED; if (token != NULL) *token = parse_token_t(tok); return STATUS_OK; } status_t parse_begin_message(parse_frame_t *child, parse_frame_t *ref, const char **address) { // Check state and arguments if (!parse_check_child(child, ref)) return STATUS_BAD_ARGUMENTS; if ((ref->child != NULL) || (ref->parser == NULL)) return STATUS_BAD_STATE; if ((ref->type != FRT_ROOT) && (ref->type != FRT_BUNDLE)) return STATUS_BAD_STATE; // Initialize lookup union { const uint8_t *u8; const uint32_t *u32; const char *ch; } xptr; parser_t *buf = ref->parser; ssize_t left = ref->limit - buf->offset; size_t size = buf->size; xptr.u8 = &buf->data[buf->offset]; // Need to read size? if (ref->type == FRT_BUNDLE) { if (size_t(left) <= sizeof(uint32_t)) return STATUS_CORRUPTED; size = BE_TO_CPU(*(xptr.u32)) + sizeof(uint32_t); xptr.u8 += sizeof(uint32_t); // Analyze size if (size_t(left) < size) return STATUS_CORRUPTED; left -= sizeof(uint32_t); } // Is there enough size to read address? if (left <= ssize_t(sizeof(uint32_t))) return STATUS_CORRUPTED; else if ((xptr.ch[0] != '/')) return STATUS_BAD_TYPE; // Check address length const char *addr = xptr.ch; size_t addr_len = ::strnlen(addr, left); if (ssize_t(addr_len) >= left) return STATUS_CORRUPTED; // Estimate the padded data size and move pointer size_t padded = ((addr_len + sizeof(uint32_t)) >> 2) << 2; left -= padded; xptr.u8 += padded; // From OSC spec: // Note: some older implementations of OSC may omit the OSC Type Tag string. // Until all such implementations are updated, OSC implementations should be // robust in the case of a missing OSC Type Tag String. const char *args = ""; if (left > 0) { // Check that second argument is a type tag string if (xptr.ch[0] != ',') return STATUS_CORRUPTED; // Ensure that type tag string is valid size_t arg_len = ::strnlen(xptr.ch, left); if (ssize_t(arg_len) >= left) return STATUS_CORRUPTED; args = &xptr.ch[1]; padded = ((arg_len + sizeof(uint32_t)) >> 2) << 2; left -= padded; xptr.u8 += padded; } // Store new frame data child->parser = buf; child->parent = ref; child->child = NULL; child->type = FRT_MESSAGE; child->limit = buf->offset + size; ref->child = child; buf->offset = ref->limit - left; buf->args = args; ++ buf->refs; if (address != NULL) *address = addr; return STATUS_OK; } status_t parse_begin_bundle(parse_frame_t *child, parse_frame_t *ref, uint64_t *time_tag) { // Check state and arguments if (!parse_check_child(child, ref)) return STATUS_BAD_ARGUMENTS; if ((ref->child != NULL) || (ref->parser == NULL)) return STATUS_BAD_STATE; if ((ref->type != FRT_ROOT) && (ref->type != FRT_BUNDLE)) return STATUS_BAD_STATE; // Initialize lookup union { const uint8_t *u8; const uint32_t *u32; const bundle_header_t *hdr; } xptr; parser_t *buf = ref->parser; ssize_t left = ref->limit - buf->offset; size_t size = buf->size; xptr.u8 = &buf->data[buf->offset]; // Need to read size? if (ref->type == FRT_BUNDLE) { if (left <= ssize_t(sizeof(uint32_t))) return STATUS_CORRUPTED; size = BE_TO_CPU(*(xptr.u32)) + sizeof(uint32_t); xptr.u8 += sizeof(uint32_t); // Analyze size if (size_t(left) < size) return STATUS_CORRUPTED; left -= sizeof(uint32_t); } // Is there enough size to read bundle header? Bundle header is valid if (left <= ssize_t(sizeof(bundle_header_t))) return STATUS_CORRUPTED; else if (xptr.hdr->sig != BUNDLE_SIG) return STATUS_BAD_TYPE; left -= sizeof(bundle_header_t); // Store new frame data child->parser = buf; child->parent = ref; child->child = NULL; child->type = FRT_BUNDLE; child->limit = buf->offset + size; ref->child = child; buf->offset = ref->limit - left; buf->args = NULL; ++ buf->refs; if (time_tag != NULL) *time_tag = BE_TO_CPU(xptr.hdr->tag); return STATUS_OK; } status_t parse_raw_message(parse_frame_t *ref, const void **start, size_t *msize, const char **address) { // Check state and arguments if ((ref->child != NULL) || (ref->parser == NULL)) return STATUS_BAD_STATE; if ((ref->type != FRT_ROOT) && (ref->type != FRT_BUNDLE)) return STATUS_BAD_STATE; // Initialize lookup union { const uint8_t *u8; const uint32_t *u32; const char *ch; } xptr; parser_t *buf = ref->parser; ssize_t left = ref->limit - buf->offset; size_t xsize = buf->size; xptr.u8 = &buf->data[buf->offset]; // Need to read size? if (ref->type == FRT_BUNDLE) { if (size_t(left) <= sizeof(uint32_t)) return STATUS_CORRUPTED; xsize = BE_TO_CPU(*(xptr.u32)); xptr.u8 += sizeof(uint32_t); // Analyze size if (size_t(left) < (xsize + sizeof(uint32_t))) return STATUS_CORRUPTED; left -= sizeof(uint32_t); } // Is there enough size to read address? if (left <= ssize_t(sizeof(uint32_t))) return STATUS_CORRUPTED; else if ((xptr.ch[0] != '/')) return STATUS_BAD_TYPE; // Check address length const char *addr = xptr.ch; size_t addr_len = ::strnlen(addr, left); if (ssize_t(addr_len) >= left) return STATUS_CORRUPTED; // Return address string if (address != NULL) *address = addr; if (start != NULL) *start = xptr.u8; if (msize != NULL) *msize = xsize; return STATUS_OK; } inline bool parse_check_msg(parse_frame_t *ref) { if ((ref->child != NULL) || (ref->parser == NULL)) return false; if ((ref->type != FRT_ARRAY) && (ref->type != FRT_MESSAGE)) return false; return (ref->parser->args != NULL); } status_t parse_begin_array(parse_frame_t *child, parse_frame_t *ref) { // Check state and arguments if (!parse_check_child(child, ref)) return STATUS_BAD_ARGUMENTS; if (!parse_check_msg(ref)) return STATUS_BAD_STATE; parser_t *buf = ref->parser; if (*(buf->args) != FPT_ARRAY_START) return STATUS_BAD_STATE; // Store new frame data child->parser = buf; child->parent = ref; child->child = NULL; child->type = FRT_ARRAY; child->limit = ref->limit; ref->child = child; ++ buf->args; ++ buf->refs; return STATUS_OK; } status_t parse_skip(parse_frame_t *ref) { if ((ref->child != NULL) || (ref->parser == NULL)) return STATUS_BAD_STATE; if ((ref->type == FRT_ROOT) || (ref->type == FRT_BUNDLE)) { if (ref->parser->offset == ref->limit) return STATUS_EOF; else if ((ref->type == FRT_ROOT) && (ref->parser->offset > 0)) return STATUS_CORRUPTED; parse_frame_t frm; // Try to parse as message status_t res = parse_begin_message(&frm, ref, NULL); if (res == STATUS_OK) res = parse_end(&frm); else { // Try to parse as bundle res = parse_begin_bundle(&frm, ref, NULL); if (res == STATUS_OK) res = parse_end(&frm); } return res; } else if ((ref->type == FRT_ARRAY) || (ref->type == FRT_MESSAGE)) { parser_t *buf = ref->parser; if (buf->args == NULL) return STATUS_BAD_STATE; size_t skip = 0; switch (*(buf->args)) { case FPT_INT32: skip = sizeof(int32_t); break; case FPT_FLOAT32: skip = sizeof(float); break; case FPT_INT64: skip = sizeof(int64_t); break; case FPT_OSC_TIMETAG: skip = sizeof(uint64_t); break; case FPT_DOUBLE64: skip = sizeof(double); break; case FPT_ASCII_CHAR: skip = sizeof(uint32_t); break; case FPT_RGBA_COLOR: skip = sizeof(uint32_t); break; case FPT_MIDI_MESSAGE: skip = sizeof(uint32_t); break; case FPT_TRUE: case FPT_FALSE: case FPT_NULL: case FPT_INF: break; // skip = 0 case FPT_OSC_STRING: case FPT_TYPE: { ssize_t left = ref->limit - buf->offset; if (left <= 0) return STATUS_CORRUPTED; const char *ch = reinterpret_cast(&buf->data[buf->offset]); size_t len = ::strnlen(ch, left); skip = ((len + sizeof(uint32_t)) >> 2) << 2; if (skip > size_t(left)) return STATUS_CORRUPTED; break; } case FPT_OSC_BLOB: { ssize_t left = ref->limit - buf->offset; if (left < ssize_t(sizeof(uint32_t))) return STATUS_CORRUPTED; const uint32_t *u32 = reinterpret_cast(&buf->data[buf->offset]); size_t size = BE_TO_CPU(*u32); skip = ((size + 2*sizeof(uint32_t) - 1) >> 2) << 2; if (skip > size_t(left)) return STATUS_CORRUPTED; break; } case FPT_ARRAY_START: // Skip the entire array { parse_frame_t frm; status_t res = parse_begin_array(&frm, ref); if (res == STATUS_OK) res = parse_end(&frm); return res; } case FPT_ARRAY_END: // Do not allow to skip array end return (ref->type == FRT_ARRAY) ? STATUS_EOF : STATUS_CORRUPTED; case 0: if ((ref->type == FRT_ARRAY) || (buf->offset != ref->limit)) return STATUS_CORRUPTED; return STATUS_EOF; default: return STATUS_CORRUPTED; } // Update position buf->offset += skip; ++buf->args; } else return STATUS_BAD_STATE; return STATUS_OK; } template inline status_t parse_int(parse_frame_t *ref, T *value, forge_param_type_t type) { // Check state and arguments if (!parse_check_msg(ref)) return STATUS_BAD_STATE; parser_t *buf = ref->parser; char ch = *(buf->args); if (ch == type) { // Parse integer value if ((ref->limit - buf->offset) < sizeof(T)) return STATUS_CORRUPTED; if (value != NULL) *value = BE_TO_CPU(*(reinterpret_cast(&buf->data[buf->offset]))); buf->offset += sizeof(T); ++buf->args; return STATUS_OK; } if (!ch) return (buf->offset == ref->limit) ? STATUS_EOF : STATUS_CORRUPTED; if (ch == FPT_NULL) { ++buf->args; return STATUS_NULL; } return STATUS_BAD_TYPE; } status_t parse_int32(parse_frame_t *ref, int32_t *value) { return parse_int(ref, value, FPT_INT32); } status_t parse_rgba(parse_frame_t *ref, uint32_t *rgba) { return parse_int(ref, rgba, FPT_RGBA_COLOR); } status_t parse_int64(parse_frame_t *ref, int64_t *value) { return parse_int(ref, value, FPT_INT64); } status_t parse_time_tag(parse_frame_t *ref, uint64_t *value) { return parse_int(ref, value, FPT_OSC_TIMETAG); } status_t parse_ascii(parse_frame_t *ref, char *c) { // Check state and arguments if (!parse_check_msg(ref)) return STATUS_BAD_STATE; parser_t *buf = ref->parser; char ch = *(buf->args); if (ch == FPT_ASCII_CHAR) { // Parse as 32-bit value if ((ref->limit - buf->offset) < sizeof(uint32_t)) return STATUS_CORRUPTED; if (c != NULL) *c = buf->data[buf->offset + 3]; buf->offset += sizeof(uint32_t); ++buf->args; return STATUS_OK; } if (!ch) return (buf->offset == ref->limit) ? STATUS_EOF : STATUS_CORRUPTED; if (ch == FPT_NULL) { ++buf->args; return STATUS_NULL; } return STATUS_BAD_TYPE; } template inline status_t parse_float(parse_frame_t *ref, T *value, forge_param_type_t type) { // Check state and arguments if (!parse_check_msg(ref)) return STATUS_BAD_STATE; parser_t *buf = ref->parser; char ch = *(buf->args); if (ch == type) { // Parse float value if ((ref->limit - buf->offset) < sizeof(T)) return STATUS_CORRUPTED; if (value != NULL) *value = BE_TO_CPU(*(reinterpret_cast(&buf->data[buf->offset]))); buf->offset += sizeof(T); ++buf->args; return STATUS_OK; } if (!ch) return (buf->offset == ref->limit) ? STATUS_EOF : STATUS_CORRUPTED; if (ch == FPT_NULL) { ++buf->args; return STATUS_NULL; } if (ch == FPT_INF) { if (value != NULL) *value = INFINITY; ++buf->args; return STATUS_OK; } return STATUS_BAD_TYPE; } status_t parse_float32(parse_frame_t *ref, float *value) { return parse_float(ref, value, FPT_FLOAT32); } status_t parse_double64(parse_frame_t *ref, double *value) { return parse_float(ref, value, FPT_DOUBLE64); } status_t parse_string_value(parse_frame_t *ref, const char **s, forge_param_type_t type) { // Check state and arguments if (!parse_check_msg(ref)) return STATUS_BAD_STATE; parser_t *buf = ref->parser; char ch = *(buf->args); if (ch == type) { // Perform string read const char *str = reinterpret_cast(&buf->data[buf->offset]); size_t left = ref->limit - buf->offset; size_t len = ::strnlen(str, left); if (s != NULL) *s = str; buf->offset += ((len + sizeof(uint32_t)) >> 2) << 2; ++buf->args; return STATUS_OK; } if (!ch) return (buf->offset == ref->limit) ? STATUS_EOF : STATUS_CORRUPTED; if (ch == FPT_NULL) { ++buf->args; if (s == NULL) return STATUS_NULL; *s = NULL; return STATUS_OK; } return STATUS_BAD_TYPE; } status_t parse_string(parse_frame_t *ref, const char **s) { return parse_string_value(ref, s, FPT_OSC_STRING); } status_t parse_type(parse_frame_t *ref, const char **s) { return parse_string_value(ref, s, FPT_TYPE); } status_t parse_symbol(parse_frame_t *ref, const char **s) { return parse_string_value(ref, s, FPT_TYPE); } status_t parse_blob(parse_frame_t *ref, const void **data, size_t *len) { // Check state and arguments if (!parse_check_msg(ref)) return STATUS_BAD_STATE; parser_t *buf = ref->parser; switch (*(buf->args)) { case FPT_OSC_BLOB: { size_t left = ref->limit - buf->offset; if (left < sizeof(uint32_t)) return STATUS_CORRUPTED; size_t size = BE_TO_CPU(*(reinterpret_cast(&buf->data[buf->offset]))); size_t skip = ((size + 2*sizeof(uint32_t) - 1) >> 2) << 2; if (skip > left) return STATUS_CORRUPTED; if (data != NULL) *data = &buf->data[buf->offset + sizeof(uint32_t)]; if (len != NULL) *len = size; buf->offset += skip; ++buf->args; return STATUS_OK; } case FPT_NULL: { ++buf->args; if (data == NULL) return STATUS_NULL; *data = NULL; if (len != NULL) *len = 0; return STATUS_OK; } case 0: return (buf->offset == ref->limit) ? STATUS_EOF : STATUS_CORRUPTED; default: break; } return STATUS_BAD_TYPE; } inline status_t parse_flag(parse_frame_t *ref, forge_param_type_t type) { // Check state and arguments if (!parse_check_msg(ref)) return STATUS_BAD_STATE; parser_t *buf = ref->parser; char ch = *(buf->args); if (!ch) return (buf->offset == ref->limit) ? STATUS_EOF : STATUS_CORRUPTED; else if (ch != type) return STATUS_BAD_TYPE; ++buf->args; return STATUS_OK; } status_t parse_null(parse_frame_t *ref) { return parse_flag(ref, FPT_NULL); } status_t parse_inf(parse_frame_t *ref) { return parse_flag(ref, FPT_INF); } status_t parse_bool(parse_frame_t *ref, bool *value) { // Check state and arguments if (!parse_check_msg(ref)) return STATUS_BAD_STATE; parser_t *buf = ref->parser; switch (*(buf->args)) { case FPT_TRUE: ++buf->args; if (value != NULL) *value = true; return STATUS_OK; case FPT_FALSE: ++buf->args; if (value != NULL) *value = false; return STATUS_OK; case FPT_NULL: ++buf->args; return STATUS_NULL; case 0: return (buf->offset == ref->limit) ? STATUS_EOF : STATUS_CORRUPTED; default: break; } return STATUS_BAD_TYPE; } status_t parse_midi(parse_frame_t *ref, midi::event_t *event) { // Check state and arguments if (!parse_check_msg(ref)) return STATUS_BAD_STATE; parser_t *buf = ref->parser; switch (*(buf->args)) { case FPT_MIDI_MESSAGE: { size_t left = ref->limit - buf->offset; if (left < sizeof(uint32_t)) return STATUS_CORRUPTED; midi::event_t ev; ssize_t res = midi::decode(&ev, &buf->data[buf->offset]); if (res < 0) return status_t(-res); if (event != NULL) *event = ev; buf->offset += sizeof(uint32_t); ++buf->args; return STATUS_OK; } case FPT_NULL: ++buf->args; return STATUS_NULL; case 0: return (buf->offset == ref->limit) ? STATUS_EOF : STATUS_CORRUPTED; default: break; } return STATUS_BAD_TYPE; } status_t parse_midi_raw(parse_frame_t *ref, const uint8_t **event, size_t *len) { // Check state and arguments if (!parse_check_msg(ref)) return STATUS_BAD_STATE; parser_t *buf = ref->parser; switch (*(buf->args)) { case FPT_MIDI_MESSAGE: { size_t left = ref->limit - buf->offset; if (left < sizeof(uint32_t)) return STATUS_CORRUPTED; midi::event_t ev; ssize_t res = midi::decode(&ev, &buf->data[buf->offset]); if (res < 0) return status_t(-res); if (event != NULL) *event = &buf->data[buf->offset]; if (len != NULL) *len = res; buf->offset += sizeof(uint32_t); ++buf->args; return STATUS_OK; } case FPT_NULL: ++buf->args; return STATUS_NULL; case 0: return (buf->offset == ref->limit) ? STATUS_EOF : STATUS_CORRUPTED; default: break; } return STATUS_BAD_TYPE; } status_t parse_end(parse_frame_t *ref) { if (ref == NULL) return STATUS_BAD_ARGUMENTS; if (ref->child != NULL) return STATUS_BAD_STATE; parser_t *buf = ref->parser; if (buf == NULL) return STATUS_BAD_STATE; status_t res = STATUS_OK; switch (ref->type) { case FRT_ROOT: if (buf->refs <= 0) return STATUS_BAD_STATE; --buf->refs; return STATUS_OK; case FRT_ARRAY: if ((ref->parent == NULL) || (buf->args == NULL)) return STATUS_BAD_STATE; while (*(buf->args) != FPT_ARRAY_END) { res = parse_skip(ref); if (res != STATUS_OK) return (res == STATUS_EOF) ? STATUS_CORRUPTED : res; } --buf->refs; ++buf->args; break; case FRT_BUNDLE: case FRT_MESSAGE: if (ref->parent == NULL) return STATUS_BAD_STATE; else if (buf->offset > ref->limit) return STATUS_CORRUPTED; buf->offset = ref->limit; --buf->refs; break; default: return STATUS_CORRUPTED; } // Unlink frame ref->parent->child = NULL; ref->parser = NULL; ref->parent = NULL; ref->type = FRT_UNKNOWN; ref->limit = buf->size; return res; } status_t parse_destroy(parser_t *parser) { if (parser == NULL) return STATUS_BAD_ARGUMENTS; parser->data = NULL; parser->offset = 0; parser->size = 0; parser->refs = 0; parser->args = NULL; return STATUS_OK; } status_t parse_message(parse_frame_t *ref, const char *params, const char **address...) { va_list args; va_start(args, address); status_t res = parse_messagev(ref, params, address, args); va_end(args); return res; } status_t parse_messagev(parse_frame_t *ref, const char *params, const char **address, va_list args) { parse_frame_t message; status_t res = parse_begin_message(&message, ref, address); if (res != STATUS_OK) return res; ssize_t recursive = 0; if (params != NULL) { for (const char *fmt=params; *fmt != '\0'; ++fmt) { switch (*fmt) { case FPT_INT32: res = parse_int32(&message, va_arg(args, int32_t *)); break; case FPT_FLOAT32: res = parse_float32(&message, va_arg(args, float *)); break; case FPT_OSC_STRING: res = parse_string(&message, va_arg(args, const char **)); break; case FPT_INT64: res = parse_int64(&message, va_arg(args, int64_t *)); break; case FPT_OSC_TIMETAG: res = parse_time_tag(&message, va_arg(args, uint64_t *)); break; case FPT_DOUBLE64: res = parse_double64(&message, va_arg(args, double *)); break; case FPT_TYPE: res = parse_type(&message, va_arg(args, const char **)); break; case FPT_ASCII_CHAR: res = parse_ascii(&message, va_arg(args, char *)); break; case FPT_RGBA_COLOR: res = parse_rgba(&message, va_arg(args, uint32_t *)); break; case FPT_TRUE: case FPT_FALSE: res = parse_bool(&message, va_arg(args, bool *)); break; case FPT_ARRAY_START: if (message.parser->args[0] == FPT_ARRAY_START) { ++recursive; ++message.parser->args; } else res = STATUS_BAD_TYPE; break; case FPT_ARRAY_END: if (message.parser->args[0] == FPT_ARRAY_START) { if (--recursive < 0) res = STATUS_BAD_FORMAT; else ++ message.parser->args; } else res = STATUS_BAD_TYPE; break; case FPT_OSC_BLOB: { size_t *size = va_arg(args, size_t *); const void **ptr = va_arg(args, const void **); res = parse_blob(&message, ptr, size); break; } case FPT_MIDI_MESSAGE: res = STATUS_NOT_SUPPORTED; break; default: res = STATUS_BAD_FORMAT; break; } if (res == STATUS_NULL) res = STATUS_OK; else if (res != STATUS_OK) break; } } if ((res == STATUS_OK) && (recursive != 0)) res = STATUS_BAD_FORMAT; if (res == STATUS_OK) res = parse_end(&message); else parse_end(&message); return res; } } /* namespace osc */ } /* namespace lsp */