Quelle  wast.rs   Sprache: unbekannt

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"
    }
}