Revision control
Copy as Markdown
Other Tools
use crate::kw;
use crate::parser::{Cursor, Parse, Parser, Peek, Result};
use crate::token::{F32, F64};
/// Expression that can be used inside of `invoke` expressions for core wasm
/// functions.
#[derive(Debug)]
#[allow(missing_docs)]
pub enum WastVal<'a> {
Bool(bool),
U8(u8),
S8(i8),
U16(u16),
S16(i16),
U32(u32),
S32(i32),
U64(u64),
S64(i64),
F32(F32),
F64(F64),
Char(char),
String(&'a str),
List(Vec<WastVal<'a>>),
Record(Vec<(&'a str, WastVal<'a>)>),
Tuple(Vec<WastVal<'a>>),
Variant(&'a str, Option<Box<WastVal<'a>>>),
Enum(&'a str),
Option(Option<Box<WastVal<'a>>>),
Result(Result<Option<Box<WastVal<'a>>>, Option<Box<WastVal<'a>>>>),
Flags(Vec<&'a str>),
}
static CASES: &[(&str, fn(Parser<'_>) -> Result<WastVal<'_>>)] = {
use WastVal::*;
&[
("bool.const", |p| {
let mut l = p.lookahead1();
if l.peek::<kw::true_>()? {
p.parse::<kw::true_>()?;
Ok(Bool(true))
} else if l.peek::<kw::false_>()? {
p.parse::<kw::false_>()?;
Ok(Bool(false))
} else {
Err(l.error())
}
}),
("u8.const", |p| Ok(U8(p.parse()?))),
("s8.const", |p| Ok(S8(p.parse()?))),
("u16.const", |p| Ok(U16(p.parse()?))),
("s16.const", |p| Ok(S16(p.parse()?))),
("u32.const", |p| Ok(U32(p.parse()?))),
("s32.const", |p| Ok(S32(p.parse()?))),
("u64.const", |p| Ok(U64(p.parse()?))),
("s64.const", |p| Ok(S64(p.parse()?))),
("f32.const", |p| Ok(F32(p.parse()?))),
("f64.const", |p| Ok(F64(p.parse()?))),
("char.const", |p| {
let s = p.parse::<&str>()?;
let mut ch = s.chars();
let ret = match ch.next() {
Some(c) => c,
None => return Err(p.error("empty string")),
};
if ch.next().is_some() {
return Err(p.error("more than one character"));
}
Ok(Char(ret))
}),
("str.const", |p| Ok(String(p.parse()?))),
("list.const", |p| {
let mut ret = Vec::new();
while !p.is_empty() {
ret.push(p.parens(|p| p.parse())?);
}
Ok(List(ret))
}),
("record.const", |p| {
let mut ret = Vec::new();
while !p.is_empty() {
ret.push(p.parens(|p| {
p.parse::<kw::field>()?;
Ok((p.parse()?, p.parse()?))
})?);
}
Ok(Record(ret))
}),
("tuple.const", |p| {
let mut ret = Vec::new();
while !p.is_empty() {
ret.push(p.parens(|p| p.parse())?);
}
Ok(Tuple(ret))
}),
("variant.const", |p| {
let name = p.parse()?;
let payload = if p.is_empty() {
None
} else {
Some(Box::new(p.parens(|p| p.parse())?))
};
Ok(Variant(name, payload))
}),
("enum.const", |p| Ok(Enum(p.parse()?))),
("option.none", |_| Ok(Option(None))),
("option.some", |p| {
Ok(Option(Some(Box::new(p.parens(|p| p.parse())?))))
}),
("result.ok", |p| {
Ok(Result(Ok(if p.is_empty() {
None
} else {
Some(Box::new(p.parens(|p| p.parse())?))
})))
}),
("result.err", |p| {
Ok(Result(Err(if p.is_empty() {
None
} else {
Some(Box::new(p.parens(|p| p.parse())?))
})))
}),
("flags.const", |p| {
let mut ret = Vec::new();
while !p.is_empty() {
ret.push(p.parse()?);
}
Ok(Flags(ret))
}),
]
};
impl<'a> Parse<'a> for WastVal<'a> {
fn parse(parser: Parser<'a>) -> Result<Self> {
parser.depth_check()?;
let parse = parser.step(|c| {
if let Some((kw, rest)) = c.keyword()? {
if let Some(i) = CASES.iter().position(|(name, _)| *name == kw) {
return Ok((CASES[i].1, rest));
}
}
Err(c.error("expected a [type].const expression"))
})?;
parse(parser)
}
}
impl Peek for WastVal<'_> {
fn peek(cursor: Cursor<'_>) -> Result<bool> {
let kw = match cursor.keyword()? {
Some((kw, _)) => kw,
None => return Ok(false),
};
Ok(CASES.iter().any(|(name, _)| *name == kw))
}
fn display() -> &'static str {
"core wasm argument"
}
}