netlist-db 0.4.10

use std::{
    path::Path,
    sync::{Arc, LazyLock},
};

use indexmap::IndexMap;
use nom::{
    IResult, Input, Parser,
    branch::alt,
    bytes::complete::{tag, take, take_till, take_while, take_while1},
    character::{char, complete::digit1},
    combinator::{map, map_res, opt, recognize, verify},
    error::ErrorKind,
    multi::{many0, many1},
    sequence::{delimited, preceded},
};
use regex::Regex;

use super::{ast, manager::ParseManager};
use crate::{
    ast::{ASTBuilder, LocalAST, SubcktBuilder},
    err::ParseErrorInner,
    parser::{
        cmds::{init_condition, nodeset},
        instance::instance,
    },
};
use crate::{
    ast::{
        DataBuilder, DataFileBuilder, DataFilesBuilder, DataValuesBuilder, KeyValueBuilder,
        ModelBuilder, PnameColNumBuilder, TokenBuilder, UnknwonBuilder, ValueBuilder,
    },
    span::{EndReason, FileId, LocatedSpan, Pos, Span},
};

#[inline]
pub(super) fn space(i: LocatedSpan) -> IResult<LocatedSpan, LocatedSpan> {
    take_while(|c: char| matches!(c, '\t' | '\r' | ' ')).parse_complete(i)
}
#[inline]
pub(super) fn space1(i: LocatedSpan) -> IResult<LocatedSpan, LocatedSpan> {
    take_while1(|c: char| matches!(c, '\t' | '\r' | ' ')).parse_complete(i)
}
#[inline]
pub(super) fn space_newline(i: LocatedSpan) -> IResult<LocatedSpan, LocatedSpan> {
    take_while(|c: char| matches!(c, '\t' | '\r' | ' ' | '\n')).parse_complete(i)
}

#[inline]
pub(super) fn multiline_sep<'a, T>(
    f: fn(LocatedSpan<'a>) -> IResult<LocatedSpan<'a>, T>,
) -> impl MyParser<'a, T> {
    alt((
        preceded(space1, f),
        map(
            (comment_space_newline, char('+'), space, f),
            |(_, _, _, t)| t,
        ),
    ))
}

#[inline]
pub(super) fn loss_sep(i: LocatedSpan) -> IResult<LocatedSpan, LocatedSpan> {
    alt((
        map((comment_space_newline, char('+'), space), |(_, _, s)| s),
        space,
    ))
    .parse_complete(i)
}

#[inline]
pub(super) fn key(i: LocatedSpan) -> IResult<LocatedSpan, Span> {
    map(take_while1(is_key), |s: LocatedSpan| s.into()).parse_complete(i)
}

enum Unit {
    Factor(f64),
    DB,
}

// hspice/index.htm#page/hspice_5/about_hspice_measurement_system.htm#wwID0EOGJM
#[inline]
fn unit(i: LocatedSpan) -> IResult<LocatedSpan, Unit> {
    map_res(take_while1(char::is_alphanumeric), |s: LocatedSpan| match s
        .fragment()
        .to_uppercase()
        .as_str()
    {
        "T" => Ok(Unit::Factor(1e+12)),
        "G" => Ok(Unit::Factor(1e+9)),
        "ME" | "MEG" | "X" | "Z" => Ok(Unit::Factor(1e+6)),
        "K" => Ok(Unit::Factor(1e+3)),
        "MI" | "MIL" => Ok(Unit::Factor(25.4e-6)),
        "U" => Ok(Unit::Factor(1e-6)),
        "N" => Ok(Unit::Factor(1e-9)),
        "P" => Ok(Unit::Factor(1e-12)),
        "F" => Ok(Unit::Factor(1e-15)),
        "A" => Ok(Unit::Factor(1e-18)),
        "DB" => Ok(Unit::DB),
        "MIN" => Ok(Unit::Factor(60.0)),
        "HR" => Ok(Unit::Factor(3600.0)),
        "DAY" => Ok(Unit::Factor(86400.0)),
        "YR" => Ok(Unit::Factor(31536000.0)),
        _ => Err(ErrorKind::Float),
    })
    .parse_complete(i)
}

#[inline]
pub(super) fn float(i: LocatedSpan) -> IResult<LocatedSpan, f64> {
    match fast_float2::parse_partial(i) {
        Ok((f, pos)) => Ok((i.take_from(pos), f)),
        Err(_) => Err(nom::Err::Error(nom::error::Error::new(i, ErrorKind::Float))),
    }
}

#[inline]
pub(super) fn float_unit(i: LocatedSpan) -> IResult<LocatedSpan, f64> {
    map((float, opt(unit)), |(f, u)| match u {
        Some(Unit::Factor(u)) => f * u,
        Some(Unit::DB) => 10.0_f64.powf(f / 20.0),
        None => f,
    })
    .parse_complete(i)
}

#[inline]
pub(super) fn key_str(i: LocatedSpan) -> IResult<LocatedSpan, (&str, Span)> {
    map(take_while1(is_key), |s: LocatedSpan| {
        let _s: &str = s.fragment();
        (_s, s.into())
    })
    .parse_complete(i)
}

#[inline]
fn is_path(c: char) -> bool {
    c.is_alphanumeric() || !c.is_whitespace()
}

#[inline]
fn is_key(c: char) -> bool {
    c.is_alphanumeric() || c == '_'
}
fn is_name(c: char) -> bool {
    c.is_alphanumeric() || "/_.+-*^:@%#[]".contains(c)
}
fn is_formula(c: char) -> bool {
    c.is_alphanumeric() || "/_.+-*^:".contains(c)
}

#[inline]
pub(super) fn path(i: LocatedSpan) -> IResult<LocatedSpan, Span> {
    alt((
        unquote,
        map(take_while1(is_path), |s: LocatedSpan| s.into()),
    ))
    .parse_complete(i)
}

#[inline]
pub(super) fn integer(i: LocatedSpan) -> IResult<LocatedSpan, usize> {
    map_res(digit1, |s: LocatedSpan| s.parse()).parse_complete(i)
}

#[inline]
pub(super) fn path_str(i: LocatedSpan) -> IResult<LocatedSpan, &str> {
    alt((
        unquote_str,
        map(take_while1(is_path), |s: LocatedSpan| {
            let _s: &str = s.fragment();
            _s
        }),
    ))
    .parse_complete(i)
}

#[inline]
pub(super) fn name_char(i: LocatedSpan) -> IResult<LocatedSpan, (u8, Span)> {
    map(take_while1(is_name), |s: LocatedSpan| {
        (s.fragment().as_bytes()[0], s.into())
    })
    .parse_complete(i)
}

#[inline]
pub(super) fn name(i: LocatedSpan) -> IResult<LocatedSpan, Span> {
    map(take_while1(is_name), |s: LocatedSpan| s.into()).parse_complete(i)
}

#[inline]
pub(super) fn name_str(i: LocatedSpan) -> IResult<LocatedSpan, (&str, Span)> {
    map(take_while1(is_name), |s: LocatedSpan| {
        let _s: &str = s.fragment();
        (_s, s.into())
    })
    .parse_complete(i)
}

#[inline]
pub(super) fn formula(i: LocatedSpan) -> IResult<LocatedSpan, Span> {
    map(take_while1(is_formula), |s: LocatedSpan| s.into()).parse_complete(i)
}

#[inline]
pub(super) fn unquote(i: LocatedSpan) -> IResult<LocatedSpan, Span> {
    map(
        delimited(char('\''), take_till(|c| c == '\''), take(1_usize)),
        |s: LocatedSpan| s.into(),
    )
    .parse_complete(i)
}

#[inline]
pub(super) fn unquote_str(i: LocatedSpan) -> IResult<LocatedSpan, &str> {
    map(
        delimited(char('\''), take_till(|c| c == '\''), take(1_usize)),
        |s: LocatedSpan| {
            let _s: &str = s.fragment();
            _s
        },
    )
    .parse_complete(i)
}

#[inline]
pub(super) fn comment(i: LocatedSpan) -> IResult<LocatedSpan, LocatedSpan> {
    recognize((alt((tag("*"), tag("$"))), take_till(|c| c == '\n'))).parse_complete(i)
}

#[inline]
pub(super) fn comment_space_newline(i: LocatedSpan) -> IResult<LocatedSpan, LocatedSpan> {
    recognize(many0(verify(
        recognize((
            space,
            opt(comment),
            opt((
                char('\n'),
                // continue empty line
                opt((space, char('+'), space, opt(comment), char('\n'))),
            )),
        )),
        |s| !s.is_empty(),
    )))
    .parse_complete(i)
}

#[inline]
pub(super) fn value(i: LocatedSpan) -> IResult<LocatedSpan, ValueBuilder> {
    if let Ok((i, s)) = unquote.parse_complete(i) {
        return Ok((i, ValueBuilder::Expr(s)));
    }
    match (float_unit.parse_complete(i), formula.parse_complete(i)) {
        (Ok((i_num, num)), Ok((i_formula, formula))) => {
            // when the len of rest of formula is less than num
            // means there is a non-quote expression, like `2+2`
            if i_formula.len() < i_num.len() {
                Ok((i_formula, ValueBuilder::Expr(formula)))
            } else {
                Ok((i_num, ValueBuilder::Num(num)))
            }
        }
        (Ok((i_num, num)), Err(_)) => Ok((i_num, ValueBuilder::Num(num))),
        (Err(_), Ok((i_formula, formula))) => Ok((i_formula, ValueBuilder::Expr(formula))),
        (Err(e), Err(_)) => Err(e),
    }
}

pub(super) trait MyParser<'a, T>:
    Parser<LocatedSpan<'a>, Output = T, Error = nom::error::Error<LocatedSpan<'a>>>
{
}

impl<'a, T, P> MyParser<'a, T> for P where
    P: Parser<LocatedSpan<'a>, Output = T, Error = nom::error::Error<LocatedSpan<'a>>>
{
}

#[inline]
pub(super) fn equal<'a, T, F: MyParser<'a, T>>(f: F) -> impl MyParser<'a, T> {
    map((space, char('='), space, f), |(_, _, _, v)| v)
}

#[inline]
pub(super) fn key_value(i: LocatedSpan) -> IResult<LocatedSpan, KeyValueBuilder> {
    map((name, equal(value)), |(k, v)| KeyValueBuilder { k, v }).parse_complete(i)
}

#[inline]
pub(super) fn token(input: LocatedSpan) -> IResult<LocatedSpan, TokenBuilder> {
    alt((
        map(key_value, TokenBuilder::KV),
        map(v, TokenBuilder::V),
        map(i, TokenBuilder::I),
        map(value, TokenBuilder::Value),
    ))
    .parse_complete(input)
}

#[inline]
pub(super) fn option(i: LocatedSpan) -> IResult<LocatedSpan, (Span, Option<ValueBuilder>)> {
    alt((
        map(key_value, |kv| (kv.k, Some(kv.v))),
        map(name, |k| (k, None)),
    ))
    .parse_complete(i)
}
#[inline]
pub(super) fn v(i: LocatedSpan) -> IResult<LocatedSpan, Span> {
    map(
        (
            alt((char('V'), char('v'))),
            loss_sep,
            char('('),
            loss_sep,
            name,
            loss_sep,
            char(')'),
        ),
        |(_, _, _, _, name, _, _)| name,
    )
    .parse_complete(i)
}
#[inline]
pub(super) fn i(i: LocatedSpan) -> IResult<LocatedSpan, Span> {
    map(
        (
            alt((char('I'), char('i'))),
            loss_sep,
            char('('),
            loss_sep,
            name,
            loss_sep,
            char(')'),
        ),
        |(_, _, _, _, name, _, _)| name,
    )
    .parse_complete(i)
}

pub(super) fn many0_dummyfirst<'a, T, F>(
    mut f: F,
) -> impl FnMut(LocatedSpan<'a>) -> IResult<LocatedSpan<'a>, Vec<T>>
where
    F: MyParser<'a, T>,
    T: Default,
{
    move |mut i: LocatedSpan| {
        let mut acc = Vec::with_capacity(4);
        acc.push(T::default());
        loop {
            let len = i.input_len();
            match f.parse_complete(i) {
                Err(nom::Err::Error(_)) => return Ok((i, acc)),
                Err(e) => return Err(e),
                Ok((i1, o)) => {
                    // infinite loop check: the parser must always consume
                    if i1.input_len() == len {
                        return Err(nom::Err::Error(nom::error::Error::new(i, ErrorKind::Many0)));
                    }

                    i = i1;
                    acc.push(o);
                }
            }
        }
    }
}

#[inline]
pub(super) fn ports_params(
    i: LocatedSpan,
) -> IResult<LocatedSpan, (Vec<Span>, Vec<KeyValueBuilder>)> {
    map(
        (
            many1(multiline_sep(name)),
            opt((equal(value), many0_dummyfirst(multiline_sep(key_value)))),
        ),
        |(mut ports, _params)| match _params {
            Some((first_value, mut params)) => {
                let first_key = ports.pop().unwrap();
                params[0] = KeyValueBuilder {
                    k: first_key,
                    v: first_value,
                };
                (ports, params)
            }
            None => (ports, Vec::new()),
        },
    )
    .parse_complete(i)
}
#[inline]
pub(super) fn data(mut i: LocatedSpan) -> IResult<LocatedSpan, DataBuilder> {
    #[inline]
    fn enddata(i: LocatedSpan) -> IResult<LocatedSpan, ()> {
        map_res((char('.'), key_str), |(_, (key, _))| {
            if key.to_uppercase().as_str() == "ENDDATA" {
                Ok(())
            } else {
                // TODO: error information?
                Err(())
            }
        })
        .parse_complete(i)
    }
    #[inline]
    fn data_files(i: LocatedSpan) -> IResult<LocatedSpan, DataFilesBuilder> {
        #[inline]
        fn file(i: LocatedSpan) -> IResult<LocatedSpan, Span> {
            map_res(
                (multiline_sep(name_str), equal(path)),
                |((key, _), path)| {
                    if key.to_uppercase().as_str() == "FILE" {
                        Ok(path)
                    } else {
                        Err(())
                    }
                },
            )
            .parse_complete(i)
        }
        #[inline]
        fn out(i: LocatedSpan) -> IResult<LocatedSpan, Span> {
            map_res(
                (multiline_sep(name_str), equal(path)),
                |((key, _), path)| {
                    if key.to_uppercase().as_str() == "OUT" {
                        Ok(path)
                    } else {
                        Err(())
                    }
                },
            )
            .parse_complete(i)
        }
        #[inline]
        fn pname_col_num(i: LocatedSpan) -> IResult<LocatedSpan, PnameColNumBuilder> {
            map_res(
                (multiline_sep(name_str), equal(integer)),
                |((pname_str, pname), col_num)| {
                    let binding = pname_str.to_uppercase();
                    let s = binding.as_str();
                    if s != "FILE" && s != "OUT" {
                        Ok(PnameColNumBuilder { pname, col_num })
                    } else {
                        Err(())
                    }
                },
            )
            .parse_complete(i)
        }
        map(
            (
                many1(map(
                    (file, many1(pname_col_num)),
                    |(file, pname_col_num)| DataFileBuilder {
                        file,
                        pname_col_num,
                    },
                )),
                opt(out),
                space_newline,
                enddata,
            ),
            |(files, out, _, _)| DataFilesBuilder { files, out },
        )
        .parse_complete(i)
    }
    let name;
    (i, name) = multiline_sep(key).parse_complete(i)?;
    let first;
    let first_str;
    (i, (first_str, first)) = multiline_sep(name_str).parse_complete(i)?;
    match first_str.to_uppercase().as_str() {
        "MER" => {
            return data_files.parse_complete(i).map(|(i, data_files)| {
                (
                    i,
                    DataBuilder {
                        name,
                        values: DataValuesBuilder::MER(data_files),
                    },
                )
            });
        }
        "LAM" => {
            return data_files.parse_complete(i).map(|(i, data_files)| {
                (
                    i,
                    DataBuilder {
                        name,
                        values: DataValuesBuilder::LAM(data_files),
                    },
                )
            });
        }
        _ => {}
    }
    let mut params = vec![first];
    loop {
        match multiline_sep(float_unit).parse_complete(i) {
            Ok((_i, first_n)) => {
                return map(
                    (
                        many0_dummyfirst(multiline_sep(float_unit)),
                        space_newline,
                        opt(enddata),
                    ),
                    |(mut values, _, _)| {
                        values[0] = first_n;
                        values
                    },
                )
                .parse_complete(_i)
                .map(|(i, values)| {
                    (
                        i,
                        DataBuilder {
                            name,
                            values: DataValuesBuilder::InlineNum { params, values },
                        },
                    )
                });
            }
            Err(_) => {
                let param;
                let param_str;
                (i, (param_str, param)) = multiline_sep(name_str).parse_complete(i)?;
                if param_str.to_uppercase().as_str() == "DATAFORM" {
                    return map(
                        (many1(multiline_sep(value)), space_newline, opt(enddata)),
                        |(values, _, _)| values,
                    )
                    .parse_complete(i)
                    .map(|(i, values)| {
                        (
                            i,
                            DataBuilder {
                                name,
                                values: DataValuesBuilder::InlineExpr { params, values },
                            },
                        )
                    });
                } else {
                    params.push(param);
                }
            }
        }
    }
}

/// ``` spice
/// .MODEL mname ModelType ([level=val]
/// + [keyword1=val1][keyword2=val2]
/// + [keyword3=val3][LOT distribution value]
/// + [DEV distribution value]...)
/// ```
#[inline]
pub(super) fn model(i: LocatedSpan) -> IResult<LocatedSpan, ModelBuilder> {
    map(
        (
            multiline_sep(key),
            multiline_sep(key_str),
            alt((
                many1(multiline_sep(key_value)),
                map(
                    (
                        loss_sep,
                        char('('),
                        loss_sep,
                        opt((key_value, many0_dummyfirst(multiline_sep(key_value)))),
                        loss_sep,
                        char(')'),
                    ),
                    |(_, _, _, v, _, _)| {
                        if let Some((first, mut vec)) = v {
                            vec[0] = first;
                            vec
                        } else {
                            Vec::new()
                        }
                    },
                ),
            )),
        ),
        |(name, model_type_ctx, params)| ModelBuilder {
            name,
            model_type: model_type_ctx.into(),
            params,
        },
    )
    .parse_complete(i)
}

#[inline]
fn endlib(i: LocatedSpan) -> IResult<LocatedSpan, ()> {
    static RE: LazyLock<Regex> = LazyLock::new(|| Regex::new("(?i)\\.endl").unwrap());
    match RE.find(i.fragment()) {
        Some(m) => Ok((i.take_from(m.end()), ())),
        None => Err(nom::Err::Error(nom::error::Error::new(
            i,
            ErrorKind::RegexpCapture,
        ))),
    }
}
pub(super) fn lib(i: LocatedSpan) -> IResult<LocatedSpan, Option<(&str, String)>> {
    alt((
        // include lib section
        map(
            (path_str, space1, key_str),
            |(path_str, _, (section_str, _))| Some((path_str, section_str.to_lowercase())),
        ),
        // skip to `.endl`
        map((endlib, opt((space1, key))), |_| None),
    ))
    .parse_complete(i)
}
#[inline]
pub(super) fn subckt<'a>(
    i: LocatedSpan<'a>,
    loaded: &IndexMap<FileId, Option<Pos>>,
    manager: &Arc<ParseManager>,
    work_dir: &Path,
) -> IResult<LocatedSpan<'a>, SubcktBuilder> {
    let ast_subckt = |i: LocatedSpan<'a>| -> IResult<LocatedSpan<'a>, ASTBuilder> {
        ast(manager.clone(), loaded.clone(), work_dir.to_path_buf(), i)
    };
    map(
        (space1, name, ports_params, space_newline, ast_subckt),
        |(_, name, (ports, params), _, ast)| SubcktBuilder {
            name,
            ports,
            params,
            ast,
        },
    )
    .parse_complete(i)
}

#[inline]
pub(super) fn local_ast<'a>(
    mut i: LocatedSpan<'a>,
    loaded: &IndexMap<FileId, Option<Pos>>,
    manager: &Arc<ParseManager>,
    work_dir: &Path,
) -> IResult<LocatedSpan<'a>, (LocalAST, EndReason<'a>)> {
    let mut ast = LocalAST::default();
    loop {
        (i, _) = comment_space_newline(i)?;
        if i.is_empty() {
            return Ok((i, (ast, EndReason::End)));
        }
        match char('.').parse_complete(i) {
            Err(nom::Err::Error(_)) => {
                let inst;
                (i, inst) = instance(i)?;
                ast.instance.push(inst);
            }
            Err(e) => return Err(e),
            Ok((_i, _)) => {
                i = _i;
                let cmd;
                let cmd_str;
                (i, (cmd_str, cmd)) = key_str(i)?;
                match cmd_str.to_lowercase().as_str() {
                    "lib" => {
                        let lib_info;
                        (i, (_, lib_info)) = (space1, lib).parse_complete(i)?;
                        if let Some((file_name_str, section_str)) = lib_info {
                            return Ok((
                                i,
                                (
                                    ast,
                                    EndReason::Include {
                                        file_name: Path::new(file_name_str),
                                        section: Some(section_str),
                                    },
                                ),
                            ));
                        }
                    }
                    "inc" | "include" => {
                        let file_name;
                        (i, (_, file_name)) = (space1, path_str).parse_complete(i)?;
                        return Ok((
                            i,
                            (
                                ast,
                                EndReason::Include {
                                    file_name: Path::new(file_name),
                                    section: None,
                                },
                            ),
                        ));
                    }
                    "model" => {
                        let _model;
                        (i, _model) = model(i)?;
                        ast.model.push(_model);
                    }
                    "subckt" => {
                        let _subckt;
                        (i, _subckt) = subckt(i, loaded, manager, work_dir)?;
                        ast.subckt.push(_subckt);
                    }
                    "data" => {
                        let _data;
                        (i, _data) = data(i)?;
                        ast.data.push(_data);
                    }
                    "option" => {
                        let options;
                        (i, options) = many0(multiline_sep(option)).parse_complete(i)?;
                        ast.option.extend(options);
                    }
                    "param" | "parameter" => {
                        let param;
                        (i, param) = many0(multiline_sep(key_value)).parse_complete(i)?;
                        ast.param.extend(param);
                    }
                    "ic" => {
                        let _init_condition;
                        (i, _init_condition) = init_condition(i)?;
                        ast.init_condition.extend(_init_condition);
                    }
                    "nodeset" => {
                        let _nodeset;
                        (i, _nodeset) = nodeset(i)?;
                        ast.nodeset.extend(_nodeset);
                    }
                    "ends" => {
                        (i, _) = opt((space1, key)).parse_complete(i)?;
                        return Ok((i, (ast, EndReason::End)));
                    }
                    "end" => {
                        (i, _) = many0((loss_sep, name)).parse_complete(i)?;
                    }
                    _ => {
                        ast.errors.push(ParseErrorInner::Unknown(cmd).record(i));
                        let tokens;
                        (i, tokens) = many0(multiline_sep(token)).parse_complete(i)?;
                        ast.unknwon.push(UnknwonBuilder { cmd, tokens })
                    }
                }
            }
        }
    }
}

// #[cfg(test)]
// mod test {
//     macro_rules! assert_ctx {
//         ($i_res:expr, $ctx:expr $(,)?) => {
//             assert_eq!($ctx, $i_res.unwrap().1.ctx);
//         };
//     }
//     use std::path::PathBuf;

//     use crate::file::TestLocatedSpan;

//     // macro_rules! assert_kv {
//     //     ($i_res:expr, $k:expr, $v:expr $(,)?) => {{
//     //         let kv = $i_res.unwrap().1;
//     //         assert_eq!($k, kv.k.ctx);
//     //         assert_eq!($v, kv.v.ctx);
//     //     }};
//     // }
//     // macro_rules! assert_token {
//     //     ($i_res:expr, $k:expr, $v:expr $(,)?) => {{
//     //         let token = $i_res.unwrap().1;
//     //         if let TokenBuilder::KV(kv) = token {
//     //             assert_eq!($k, kv.k.ctx);
//     //             assert_eq!($v, kv.v.ctx);
//     //         } else {
//     //             panic!("should be key-value!")
//     //         }
//     //     }};
//     //     ($i_res:expr, $word:expr $(,)?) => {{
//     //         let token = $i_res.unwrap().1;
//     //         if let TokenBuilder::ValueBuilder(word) = token {
//     //             assert_eq!($word, word.ctx);
//     //         } else {
//     //             panic!("should be word!")
//     //         }
//     //     }};
//     // }
//     use super::*;
//     #[test]
//     fn test_num() {
//         assert_eq!(1.233, float_unit(span("1.233 ")).unwrap().1);
//         assert_eq!(1.233e-6, float_unit(span("1.233u ")).unwrap().1);
//     }
//     #[test]
//     fn test_key() {
//         assert_ctx!(key(span("iw_ww ")), "iw_ww");
//         assert_ctx!(key(span("iw.ww ")), "iw");
//         assert_ctx!(name(span("iw.ww ")), "iw.ww");
//         assert_ctx!(formula(span("8.00000000e-01+2")), "8.00000000e-01+2");
//         assert_ctx!(unquote(span("'8.00000000e-01 + 2'")), "8.00000000e-01 + 2");
//         // assert_kv!(
//         //     key_value(span("a='8.00000000e-01 + 2'")),
//         //     "a",
//         //     "8.00000000e-01 + 2"
//         // );
//         // assert!(formula(span("'8.00000000e-01 + 2'")).is_err());
//         // assert_token!(token(span("a")), "a");
//         // assert_token!(
//         //     token(span("a='8.00000000e-01 + 2'")),
//         //     "a",
//         //     "8.00000000e-01 + 2"
//         // );
//         crate::text_diff("'2+2'", value(span("2+2")).unwrap().1.to_string().as_str());
//         crate::text_diff(
//             "R1 node1 node2 var1='key1'",
//             instance(span("R1 node1 node2 var1=key1"))
//                 .unwrap()
//                 .1
//                 .to_string()
//                 .as_str(),
//         );
//         crate::text_diff(
//             "R1 node1 node2 var1='key1' var2='key2'",
//             instance(span("R1 node1 node2 var1=key1 var2=key2"))
//                 .unwrap()
//                 .1
//                 .to_string()
//                 .as_str(),
//         );
//         let (manager, _) = ParseManager::new();
//         let work_dir = PathBuf::new();
//         let loaded = IndexMap::new();
//         crate::text_diff(
//             r#"
// .MODEL nch_mac NMOS
// + level=2 version=4.5
// .SUBCKT INV0SR_12TH40 I ZN VDD VSS
// XX0 ZN I VSS VPW NHVT11LL_CKT W=0.00000031 L=0.00000004
// XX3 ZN I VDD VNW PHVT11LL_CKT W=0.00000027 L=0.00000004
// .ENDS INV0SR_12TH40
// R1 node1 node2 var1='key1' var2='key2'
// R2 node1 node2 var1='key1' var2='key2'
// .mode 'nch_mac' 'nmos' level=2"#,
//             local_ast(
//                 span(
//                     r#"R1 node1 node2 var1=key1 var2=key2
//         R2 node1 node2 var1=key1
//         +var2=key2
//         .model nch_mac nmos level=2
//         + version=4.5
//         .SUBCKT INV0SR_12TH40 I ZN VDD VSS
// XX0 ZN I VSS VPW NHVT11LL_CKT W=310.00n L=40.00n
// XX3 ZN I VDD VNW PHVT11LL_CKT W=270.00n L=40.00n
// .ENDS INV0SR_12TH40
// .mode 'nch_mac' 'nmos' level=2
//         "#,
//                 ),
//                 &loaded,
//                 &manager,
//                 &work_dir,
//             )
//             .unwrap()
//             .1
//             .0
//             .to_string()
//             .as_str(),
//         );
//         crate::text_diff(
//             r#"
// .MODEL nch_mac NMOS
// + level=2 version=4.5
// .SUBCKT INV0SR_12TH40 I ZN VDD VSS
// XX0 ZN I VSS VPW NHVT11LL_CKT W=0.00000031 L=0.00000004
// XX3 ZN I VDD VNW PHVT11LL_CKT W=0.00000027 L=0.00000004
// .ENDS INV0SR_12TH40
// R1 node1 node2 var1='key1' var2='key2'
// R2 node1 node2 var1='key1' var2='key2'
// .mode 'nch_mac' 'nmos' level=2"#,
//             local_ast(
//                 span(
//                     r#"R1 node1 node2 var1=key1 var2=key2
//         R2 node1 node2 var1=key1
//         +var2=key2
//         .model nch_mac
//         + nmos (
//             + level=2
//         + version=4.5
//     + )
//         .SUBCKT INV0SR_12TH40 I ZN VDD VSS
// XX0 ZN I VSS VPW NHVT11LL_CKT W=310.00n L=40.00n
// XX3 ZN I VDD VNW PHVT11LL_CKT W=270.00n L=40.00n
// .ENDS INV0SR_12TH40
// .mode 'nch_mac' 'nmos' level=2
//         "#,
//                 ),
//                 &loaded,
//                 &manager,
//                 &work_dir,
//             )
//             .unwrap()
//             .1
//             .0
//             .to_string()
//             .as_str(),
//         );
//         crate::text_diff(
//             r#"
// .DATA SWEEP
// + var1 var2
// + 1 2
// + 2 4
// .ENDDATA"#,
//             local_ast(
//                 span(
//                     r#".data SWEEP
//                     + var1 var2
//                     + 1    2
//                     + 2    4
//                     .enddata
//         "#,
//                 ),
//                 &loaded,
//                 &manager,
//                 &work_dir,
//             )
//             .unwrap()
//             .1
//             .0
//             .to_string()
//             .as_str(),
//         );
//         crate::text_diff(
//             r#"
// .DATA SWEEP
// + var1 var2 DATAFORM
// + 1 '2+2'
// + 2 4
// .ENDDATA"#,
//             local_ast(
//                 span(
//                     r#".data SWEEP
//                     + var1 var2 DATAFORM
//                     + 1 2+2
//                     + 2 4
//                     .enddata
//         "#,
//                 ),
//                 &loaded,
//                 &manager,
//                 &work_dir,
//             )
//             .unwrap()
//             .1
//             .0
//             .to_string()
//             .as_str(),
//         );
//         crate::text_diff(
//             r#"
// .DATA inputdata MER
// + FILE='file1' p1=1 p2=3 p3=4
// + FILE='file2' p1=1
// + FILE='file3' p1=1
// .ENDDATA"#,
//             local_ast(
//                 span(
//                     r#".DATA inputdata MER
//                     + FILE='file1' p1=1 p2=3 p3=4
//                     + FILE='file2' p1=1
//                     + FILE='file3' p1=1
//                  .ENDDATA
//         "#,
//                 ),
//                 &loaded,
//                 &manager,
//                 &work_dir,
//             )
//             .unwrap()
//             .1
//             .0
//             .to_string()
//             .as_str(),
//         );
//     }

//     #[test]
//     fn libmatch() {
//         assert_eq!(
//             TestLocatedSpan {
//                 offset: 10,
//                 line: 1,
//                 fragment: " \nlines"
//             },
//             lib(span("some .EndL \nlines")).unwrap().0
//         );
//         assert_eq!(
//             TestLocatedSpan {
//                 offset: 13,
//                 line: 1,
//                 fragment: " \nlines"
//             },
//             lib(span("some .EndL tt \nlines")).unwrap().0
//         );
//         assert_eq!(
//             TestLocatedSpan {
//                 offset: 12,
//                 line: 2,
//                 fragment: " "
//             },
//             lib(span("some \n .EndL ")).unwrap().0
//         );
//         println!("{:?}", lib(span("'some' tt")));
//     }
// }