use crate::host::PhpHost;
use crate::stdlib::common::throws;
use fusevm::Value;
use std::cell::Cell;
const JSON_ERROR_NONE: i64 = 0;
const JSON_ERROR_DEPTH: i64 = 1;
const JSON_ERROR_CTRL_CHAR: i64 = 3;
const JSON_ERROR_SYNTAX: i64 = 4;
const JSON_ERROR_UTF8: i64 = 5;
const JSON_INVALID_UTF8_IGNORE: i64 = 1_048_576;
const JSON_INVALID_UTF8_SUBSTITUTE: i64 = 2_097_152;
pub const JSON_ERROR_UNSUPPORTED_TYPE: i64 = 8;
const JSON_ERROR_INVALID_PROPERTY_NAME: i64 = 9;
const JSON_ERROR_UTF16: i64 = 10;
pub const JSON_ERROR_RECURSION: i64 = 6;
pub const JSON_ERROR_INF_OR_NAN: i64 = 7;
pub const JSON_ERROR_NON_BACKED_ENUM: i64 = 11;
thread_local! {
static LAST_ERROR: Cell<i64> = const { Cell::new(JSON_ERROR_NONE) };
}
pub fn set_last_error(code: i64) {
LAST_ERROR.with(|c| c.set(code));
}
pub const JSON_THROW_ON_ERROR: i64 = 4194304;
pub fn fail(code: i64, flags: i64) -> Option<String> {
if flags & JSON_THROW_ON_ERROR != 0 {
set_last_error(JSON_ERROR_NONE);
return Some(crate::builtins::throws_code(
"JsonException",
code,
error_msg(code),
));
}
set_last_error(code);
None
}
fn get_last_error() -> i64 {
LAST_ERROR.with(|c| c.get())
}
fn error_msg(code: i64) -> &'static str {
match code {
JSON_ERROR_NONE => "No error",
JSON_ERROR_DEPTH => "Maximum stack depth exceeded",
2 => "State mismatch (invalid or malformed JSON)",
JSON_ERROR_CTRL_CHAR => "Control character error, possibly incorrectly encoded",
JSON_ERROR_SYNTAX => "Syntax error",
5 => "Malformed UTF-8 characters, possibly incorrectly encoded",
JSON_ERROR_RECURSION => "Recursion detected",
JSON_ERROR_UTF16 => "Single unpaired UTF-16 surrogate in unicode escape",
JSON_ERROR_INF_OR_NAN => "Inf and NaN cannot be JSON encoded",
JSON_ERROR_UNSUPPORTED_TYPE => "Type is not supported",
JSON_ERROR_INVALID_PROPERTY_NAME => "The decoded property name is invalid",
JSON_ERROR_NON_BACKED_ENUM => "Non-backed enums have no default serialization",
_ => "Unknown error",
}
}
pub fn dispatch(name: &str, args: &[Value]) -> Option<Result<Value, String>> {
let v = match name {
"json_decode" => return Some(json_decode(args)),
"json_validate" => return Some(json_validate(args)),
"json_last_error" => Value::int(get_last_error()),
"json_last_error_msg" => Value::str(error_msg(get_last_error()).to_string()),
_ => return None,
};
Some(Ok(v))
}
fn decode_depth(args: &[Value], idx: usize, func: &str, pos: usize) -> Result<usize, String> {
match args.get(idx) {
Some(v) if !matches!(v, Value::Undef) => {
let d = crate::host::with_host(|h| h.to_number(v).to_int());
if d < 1 {
return Err(throws(
"ValueError",
format!("{func}(): Argument #{pos} ($depth) must be greater than 0"),
));
}
if d > i64::from(i32::MAX) {
return Err(throws(
"ValueError",
format!(
"{func}(): Argument #{pos} ($depth) must be less than {}",
i32::MAX
),
));
}
Ok((d as usize).min(NATIVE_DEPTH_CEILING))
}
_ => Ok(512),
}
}
const NATIVE_DEPTH_CEILING: usize = 1024;
const JSON_OBJECT_AS_ARRAY: i64 = 1;
const JSON_BIGINT_AS_STRING: i64 = 2;
fn json_decode(args: &[Value]) -> Result<Value, String> {
let json = crate::host::with_host(|h| h.to_str(&args.first().cloned().unwrap_or(Value::Undef)));
let depth = decode_depth(args, 2, "json_decode", 3)?;
let flags = args.get(3).map(crate::host::long_of).unwrap_or(0);
let assoc = match args.get(1) {
None | Some(Value::Undef) => flags & JSON_OBJECT_AS_ARRAY != 0,
Some(v) => crate::host::with_host(|h| h.is_truthy(v)),
};
set_last_error(JSON_ERROR_NONE);
let parsed = crate::host::with_host(|h| {
let bytes = crate::bytes::to_bytes(&json);
let mut p = Parser::new(&bytes, depth, h);
p.assoc = assoc;
p.bad_utf8 = flags & (JSON_INVALID_UTF8_IGNORE | JSON_INVALID_UTF8_SUBSTITUTE);
p.bigint_as_string = flags & JSON_BIGINT_AS_STRING != 0;
p.parse_document()
});
match parsed {
Ok(v) => Ok(v),
Err(code) => match fail(code, flags) {
Some(e) => Err(e),
None => Ok(Value::Undef),
},
}
}
fn json_validate(args: &[Value]) -> Result<Value, String> {
let json = crate::host::with_host(|h| h.to_str(&args.first().cloned().unwrap_or(Value::Undef)));
let depth = decode_depth(args, 1, "json_validate", 2)?;
set_last_error(JSON_ERROR_NONE);
let ok = crate::host::with_host(|h| {
let bytes = crate::bytes::to_bytes(&json);
let mut p = Parser::new_validate(&bytes, depth, h);
match p.parse_document() {
Ok(_) => true,
Err(code) => {
set_last_error(code);
false
}
}
});
Ok(Value::bool(ok))
}
struct Parser<'a, 'h> {
b: &'a [u8],
pos: usize,
max_depth: usize,
depth: usize,
build: bool,
assoc: bool,
bigint_as_string: bool,
bad_utf8: i64,
h: &'h mut PhpHost,
}
impl<'a, 'h> Parser<'a, 'h> {
fn new(b: &'a [u8], max_depth: usize, h: &'h mut PhpHost) -> Self {
Parser {
b,
pos: 0,
max_depth,
depth: 0,
build: true,
assoc: true,
bigint_as_string: false,
bad_utf8: 0,
h,
}
}
fn new_validate(b: &'a [u8], max_depth: usize, h: &'h mut PhpHost) -> Self {
Parser {
b,
pos: 0,
max_depth,
depth: 0,
build: false,
assoc: true,
bigint_as_string: false,
bad_utf8: 0,
h,
}
}
fn make_container(&mut self) -> Value {
if self.build {
self.h.new_array()
} else {
Value::Undef
}
}
fn make_object_container(&mut self) -> Value {
if !self.build {
return Value::Undef;
}
if self.assoc {
self.h.new_array()
} else {
self.h.new_object_bare("stdClass", Vec::new())
}
}
fn parse_document(&mut self) -> Result<Value, i64> {
match self.parse_document_value() {
Err(JSON_ERROR_SYNTAX)
if self.b.get(self.pos).is_some_and(|&c| c >= 0x80)
&& utf8_char_len(&self.b[self.pos..]).is_none() =>
{
Err(JSON_ERROR_UTF8)
}
other => other,
}
}
fn parse_document_value(&mut self) -> Result<Value, i64> {
self.skip_ws();
if self.pos >= self.b.len() {
return Err(JSON_ERROR_SYNTAX);
}
let v = self.parse_value()?;
self.skip_ws();
if self.pos != self.b.len() {
return Err(JSON_ERROR_SYNTAX);
}
Ok(v)
}
fn skip_ws(&mut self) {
while let Some(&c) = self.b.get(self.pos) {
match c {
b' ' | b'\t' | b'\n' | b'\r' => self.pos += 1,
_ => break,
}
}
}
fn peek(&self) -> Option<u8> {
self.b.get(self.pos).copied()
}
fn parse_value(&mut self) -> Result<Value, i64> {
match self.peek() {
Some(b'{') => self.parse_object(),
Some(b'[') => self.parse_array(),
Some(b'"') => Ok(Value::str(self.parse_string()?)),
Some(b't') => self.parse_literal(b"true", Value::bool(true)),
Some(b'f') => self.parse_literal(b"false", Value::bool(false)),
Some(b'n') => self.parse_literal(b"null", Value::Undef),
Some(c) if c == b'-' || c.is_ascii_digit() => self.parse_number(),
_ => Err(JSON_ERROR_SYNTAX),
}
}
fn parse_literal(&mut self, word: &[u8], val: Value) -> Result<Value, i64> {
if self.b[self.pos..].starts_with(word) {
self.pos += word.len();
Ok(val)
} else {
Err(JSON_ERROR_SYNTAX)
}
}
fn enter(&mut self) -> Result<(), i64> {
if self.depth + 1 >= self.max_depth {
return Err(JSON_ERROR_DEPTH);
}
self.depth += 1;
Ok(())
}
fn parse_array(&mut self) -> Result<Value, i64> {
self.enter()?;
self.pos += 1; let arr = self.make_container();
self.skip_ws();
if self.peek() == Some(b']') {
self.pos += 1;
self.depth -= 1;
return Ok(arr);
}
loop {
self.skip_ws();
let v = self.parse_value()?;
if self.build {
self.h.arr_push_auto(&arr, v);
}
self.skip_ws();
match self.peek() {
Some(b',') => {
self.pos += 1;
}
Some(b']') => {
self.pos += 1;
break;
}
_ => return Err(JSON_ERROR_SYNTAX),
}
}
self.depth -= 1;
Ok(arr)
}
fn parse_object(&mut self) -> Result<Value, i64> {
self.enter()?;
self.pos += 1; self.skip_ws();
if self.peek() == Some(b'}') {
self.pos += 1;
self.depth -= 1;
return Ok(self.make_object_container());
}
let mut arr: Option<Value> = None;
loop {
self.skip_ws();
if self.peek() != Some(b'"') {
return Err(JSON_ERROR_SYNTAX);
}
let key = self.parse_string()?;
self.skip_ws();
if self.peek() != Some(b':') {
return Err(JSON_ERROR_SYNTAX);
}
self.pos += 1; self.skip_ws();
let v = self.parse_value()?;
if self.build && !self.assoc && key.starts_with('\0') {
return Err(JSON_ERROR_INVALID_PROPERTY_NAME);
}
let container = match &arr {
Some(c) => c.clone(),
None => {
let c = self.make_object_container();
arr = Some(c.clone());
c
}
};
if self.build {
if self.assoc {
self.h.arr_set_key(&container, &Value::str(key), v);
} else {
self.h.prop_set(&container, &key, v);
}
}
self.skip_ws();
match self.peek() {
Some(b',') => {
self.pos += 1;
}
Some(b'}') => {
self.pos += 1;
break;
}
_ => return Err(JSON_ERROR_SYNTAX),
}
}
self.depth -= 1;
Ok(arr.unwrap_or(Value::Undef))
}
fn parse_string(&mut self) -> Result<String, i64> {
self.pos += 1; let mut out: Vec<u8> = Vec::new();
loop {
let c = self.peek().ok_or(JSON_ERROR_SYNTAX)?;
match c {
b'"' => {
self.pos += 1;
return Ok(crate::bytes::from_bytes(&out));
}
b'\\' => {
self.pos += 1;
let esc = self.peek().ok_or(JSON_ERROR_SYNTAX)?;
self.pos += 1;
match esc {
b'"' => out.push(b'"'),
b'\\' => out.push(b'\\'),
b'/' => out.push(b'/'),
b'b' => out.push(0x08),
b'f' => out.push(0x0C),
b'n' => out.push(b'\n'),
b'r' => out.push(b'\r'),
b't' => out.push(b'\t'),
b'u' => {
let cp = self.parse_hex4()?;
let c = self.push_unicode(cp)?;
out.extend_from_slice(c.encode_utf8(&mut [0u8; 4]).as_bytes());
}
_ => return Err(JSON_ERROR_SYNTAX),
}
}
c if c < 0x20 => return Err(JSON_ERROR_CTRL_CHAR),
_ => match utf8_char_len(&self.b[self.pos..]) {
Some(len) => {
out.extend_from_slice(&self.b[self.pos..self.pos + len]);
self.pos += len;
}
None => {
if self.bad_utf8 & JSON_INVALID_UTF8_SUBSTITUTE != 0 {
out.extend_from_slice("\u{FFFD}".as_bytes());
} else if self.bad_utf8 == 0 {
return Err(JSON_ERROR_UTF8);
}
self.pos += 1;
}
},
}
}
}
fn parse_hex4(&mut self) -> Result<u32, i64> {
if self.pos + 4 > self.b.len() {
return Err(JSON_ERROR_SYNTAX);
}
let mut val: u32 = 0;
for _ in 0..4 {
let d = hex_digit(self.b[self.pos]).ok_or(JSON_ERROR_SYNTAX)?;
val = (val << 4) | d as u32;
self.pos += 1;
}
Ok(val)
}
fn push_unicode(&mut self, first: u32) -> Result<char, i64> {
if (0xD800..=0xDBFF).contains(&first) {
if self.b.get(self.pos) == Some(&b'\\') && self.b.get(self.pos + 1) == Some(&b'u') {
self.pos += 2;
let low = self.parse_hex4()?;
if (0xDC00..=0xDFFF).contains(&low) {
let cp = 0x10000 + ((first - 0xD800) << 10) + (low - 0xDC00);
return char::from_u32(cp).ok_or(JSON_ERROR_UTF16);
}
return Err(JSON_ERROR_UTF16);
}
return Err(JSON_ERROR_UTF16);
}
if (0xDC00..=0xDFFF).contains(&first) {
return Err(JSON_ERROR_UTF16);
}
char::from_u32(first).ok_or(JSON_ERROR_UTF16)
}
fn parse_number(&mut self) -> Result<Value, i64> {
let start = self.pos;
let mut is_float = false;
if self.peek() == Some(b'-') {
self.pos += 1;
}
match self.peek() {
Some(b'0') => self.pos += 1,
Some(c) if c.is_ascii_digit() => {
while self.peek().is_some_and(|d| d.is_ascii_digit()) {
self.pos += 1;
}
}
_ => return Err(JSON_ERROR_SYNTAX),
}
if self.peek() == Some(b'.') {
is_float = true;
self.pos += 1;
if !self.peek().is_some_and(|d| d.is_ascii_digit()) {
return Err(JSON_ERROR_SYNTAX);
}
while self.peek().is_some_and(|d| d.is_ascii_digit()) {
self.pos += 1;
}
}
if matches!(self.peek(), Some(b'e' | b'E')) {
is_float = true;
self.pos += 1;
if matches!(self.peek(), Some(b'+' | b'-')) {
self.pos += 1;
}
if !self.peek().is_some_and(|d| d.is_ascii_digit()) {
return Err(JSON_ERROR_SYNTAX);
}
while self.peek().is_some_and(|d| d.is_ascii_digit()) {
self.pos += 1;
}
}
let text = std::str::from_utf8(&self.b[start..self.pos]).map_err(|_| JSON_ERROR_SYNTAX)?;
if is_float {
text.parse::<f64>()
.map(Value::float)
.map_err(|_| JSON_ERROR_SYNTAX)
} else {
match text.parse::<i64>() {
Ok(n) => Ok(Value::int(n)),
Err(_) if self.bigint_as_string => Ok(Value::str(text.to_string())),
Err(_) => text
.parse::<f64>()
.map(Value::float)
.map_err(|_| JSON_ERROR_SYNTAX),
}
}
}
}
fn utf8_char_len(b: &[u8]) -> Option<usize> {
let head = &b[..b.len().min(4)];
let valid = match std::str::from_utf8(head) {
Ok(s) => s,
Err(e) => std::str::from_utf8(&head[..e.valid_up_to()]).ok()?,
};
valid.chars().next().map(char::len_utf8)
}
fn hex_digit(b: u8) -> Option<u8> {
match b {
b'0'..=b'9' => Some(b - b'0'),
b'a'..=b'f' => Some(b - b'a' + 10),
b'A'..=b'F' => Some(b - b'A' + 10),
_ => None,
}
}