use std::io::Write as Wr;

mod error;
pub use error::Error;

#[rustfmt::skip]
macro_rules! three { ($a:expr) => { ($a, $a, $a) }; }
#[rustfmt::skip]
macro_rules! four { ($a:expr) => { ($a, $a, $a, $a) }; }
#[rustfmt::skip]
macro_rules! five { ($a:expr) => { ($a, $a, $a, $a, $a) }; }
#[rustfmt::skip]
macro_rules! six { ($a:expr) => { ($a, $a, $a, $a, $a, $a) }; }

use super::{
    debug::info::{VarData, VarInfo},
    executor::{ExecutorBuilderInternal, Instruction, UPInstr},
    instructions::{
        AlwaysJump, ConditionOp, DynJump, End, Instr, Jump, MathOp1, MathOp2, Op1, Op2, PackColor,
        Select, Set, Stop,
        draw::{
            Clear, Flush, Line, LinePoly, Poly, RectBordered, RectFilled, SetCol, SetColor,
            SetStroke, Triangle,
        },
        io::{Print, Read, Write},
    },
    lexer::{Lexer, Token},
    memory::{LAddress, LVar},
};

macro_rules! tokstr {
    ($tok:expr) => {
        match $tok {
            Token::Ident(i) => Some(i),
            Token::PackColor => Some("packcolor"),
            Token::Null => Some("null"),
            Token::Read => Some("read"),
            Token::Write => Some("write"),
            Token::Set => Some("set"),
            Token::Op => Some("op"),
            Token::End => Some("end"),
            Token::Draw => Some("draw"),
            Token::DrawFlush => Some("drawflush"),
            Token::Print => Some("print"),
            Token::Jump => Some("jump"),
            Token::Stop => Some("stop"),
            Token::Equal => Some("equal"),
            Token::NotEqual => Some("notEqual"),
            Token::LessThan => Some("lessThan"),
            Token::LessThanEq => Some("lessThanEq"),
            Token::GreaterThan => Some("greaterThan"),
            Token::GreaterThanEq => Some("greaterThanEq"),
            Token::StrictEqual => Some("strictEqual"),
            Token::Always => Some("always"),
            Token::Add => Some("add"),
            Token::Sub => Some("sub"),
            Token::Mul => Some("mul"),
            Token::Div => Some("div"),
            Token::IDiv => Some("idiv"),
            Token::Mod => Some("mod"),
            Token::Pow => Some("pow"),
            Token::And => Some("land"),
            Token::Not => Some("not"),
            Token::ShiftLeft => Some("shl"),
            Token::ShiftRight => Some("shr"),
            Token::BitOr => Some("or"),
            Token::BitAnd => Some("and"),
            Token::ExclusiveOr => Some("xor"),
            Token::Max => Some("max"),
            Token::Min => Some("min"),
            Token::Angle => Some("angle"),
            Token::AngleDiff => Some("angleDiff"),
            Token::Len => Some("len"),
            Token::Noise => Some("noise"),
            Token::Abs => Some("abs"),
            Token::Log => Some("log"),
            Token::Log10 => Some("log10"),
            Token::Floor => Some("floor"),
            Token::Ceil => Some("ceil"),
            Token::Sqrt => Some("sqrt"),
            Token::Rand => Some("rand"),
            Token::Sin => Some("sin"),
            Token::Cos => Some("cos"),
            Token::Tan => Some("tan"),
            Token::ASin => Some("asin"),
            Token::ACos => Some("acos"),
            Token::ATan => Some("atan"),
            _ => None,
        }
    };
}
use tokstr;

#[derive(Debug)]
enum UJump {
    Sometimes {
        a: LAddress,
        b: LAddress,
        op: ConditionOp,
    },
    Always,
}

pub fn parse<'source, W: Wr>(
    mut tokens: Lexer<'source>,
    executor: &mut ExecutorBuilderInternal<'source, W>,
) -> Result<(), Error<'source>> {
    let mut used = 0u32;
    let mut mem: Vec<Option<&str>> = Vec::with_capacity(64); // maps &str to usize 
    let mut dbg_info: Vec<VarInfo> = Vec::with_capacity(64);
    macro_rules! push {
        // push a ident
        (const $var:expr) => {{
            let v = $var;
            dbg_info.push(VarInfo {
                data: VarData::Constant(v.clone().into()),
                span: tokens.span(),
            });
            executor.mem.push(LVar::from(v));
            mem.push(None);
            used = used
                .checked_add(1)
                .ok_or(Error::TooManyVariables(tokens.span()))?;
            unsafe { Ok(LAddress::addr(used - 1)) }
        }};
        ($var:expr) => {{
            let v = $var;
            dbg_info.push(VarInfo {
                data: VarData::Variable(v),
                span: tokens.span(),
            });
            executor.mem.push(LVar::null());
            mem.push(Some(v));
            used = used
                .checked_add(1)
                .ok_or(Error::TooManyVariables(tokens.span()))?;
            // SAFETY: just initialized executor.mem
            unsafe { Ok(LAddress::addr(used - 1)) }
        }};
    }
    push!("@counter")?;
    macro_rules! addr {
        ($val:expr) => {{
            let val = $val;
            match mem
                .iter()
                .zip(0..used)
                .find(|&(&v, _)| v == Some(val))
                .map(|(_, i)| i)
            {
                Some(n) => unsafe { Ok(LAddress::addr(n)) },
                None => push!(val),
            }
        }};
    }

    let mut unfinished_jumps = Vec::new();
    macro_rules! tok {
        () => {
            tokens.next().ok_or(Error::UnexpectedEof)
        };
    }
    macro_rules! err {
        ($e:ident($($stuff:expr),+)) => {
            Error::$e($($stuff,)+ tokens.span())
        }
    }
    macro_rules! yeet {
        ($e:ident($($stuff:expr),+)) => {
            return Err(Error::$e($($stuff,)+ tokens.span()))
        };
    }
    #[rustfmt::skip] 
    macro_rules! nextline {
        () => {
            while let Some(tok) = tokens.next() && tok != Token::Newline { }
        };
    }
    macro_rules! take_int {
        ($tok:expr) => {
            match $tok {
                Token::Num(n) if n.fract() == 0.0 && n >= 0.0 => Ok(n as usize),
                t => Err(err!(ExpectedInt(t))),
            }
        };
    }
    macro_rules! take_memory {
        () => {{
            let t = tok!()?;
            let container = take_ident!(t.clone())?;
            let mut out = String::new();
            for ch in container.chars() {
                if matches!(ch, '0'..='9') {
                    out.push(ch);
                    continue;
                }
                if out.len() != 0 {
                    yeet!(InvalidMemoryType(container));
                }
            }
            let container = &container[..container.len() - out.len()];
            let n_span = tokens.span().start + container.len()..tokens.span().end;
            let cell_n = out
                .parse::<usize>()
                .map_err(|_| Error::ExpectedInt(t, n_span.clone()))?;
            if cell_n > 126 || cell_n == 0 {
                return Err(Error::MemoryTooFar(cell_n, n_span));
            }
            match container {
                "bank" => executor.bank(cell_n),
                "cell" => executor.cell(cell_n),
                _ => {
                    return Err(Error::InvalidMemoryType(
                        container,
                        tokens.span().start..tokens.span().end - out.len(),
                    ));
                }
            }
        }};
    }
    macro_rules! take_ident {
        ($tok:expr) => {{
            let tok = $tok;
            tokstr!(tok).ok_or(err!(ExpectedIdent(tok)))
        }};
    }
    macro_rules! take_var {
        ($tok:expr) => {{
            let tok = $tok;
            if let Some(i) = tokstr!(tok) {
                addr!(i)
            } else {
                match tok {
                    Token::Num(n) => push!(const n),
                    Token::String(s) => push!(const s),
                    t => Err(err!(ExpectedVar(t))),
                }
            }
        }};
    }
    macro_rules! take_numvar {
        ($tok:expr) => {{
            let tok = $tok;
            if let Some(i) = tokstr!(tok) {
                addr!(i)
            } else {
                match tok {
                    Token::Num(n) => push!(const n),
                    t => Err(err!(ExpectedNum(t))),
                }
            }
        }};
    }
    macro_rules! num_or_255 {
        ($tok:expr) => {
            match $tok {
                Ok(t) => match take_numvar!(t) {
                    Err(_) => push!(const 255),
                    n => n,
                },
                Err(_) => push!(const 255),
            }
        }
    }
    while let Some(token) = tokens.next() {
        match token {
            // # omg
            Token::Comment(c) => executor.program.push(UPInstr::Comment(c)),
            // label:
            Token::Ident(v) if v.ends_with(':') => executor
                .debug_info
                .labels
                .push((&v[..v.len() - 1], executor.next())),
            // print "5"
            Token::Print => {
                let val = take_var!(tok!()?)?;
                executor.add(Print { val });
            }
            // set x 4
            Token::Set => {
                let from = tok!()?;
                let from = addr!(take_ident!(from)?)?;
                let to = take_var!(tok!()?)?;
                executor.add(Set { from, to });
            }
            // stop
            Token::Stop => {
                executor.add(Stop {});
            }
            // jump start equal a b
            Token::Jump => {
                let tok = tok!()?;
                // label jump
                if let Some(i) = tokstr!(tok) {
                    let span = tokens.span();
                    let op = tok!()?;
                    if op == Token::Always {
                        executor.jmp();
                        unfinished_jumps.push((UJump::Always, (i, span), executor.last()));
                    } else {
                        let op = op.try_into().map_err(|op| err!(ExpectedOp(op)))?;
                        let a = take_var!(tok!()?)?;
                        let b = take_var!(tok!()?)?;
                        executor.jmp();
                        unfinished_jumps.push((
                            UJump::Sometimes { a, b, op },
                            (i, span),
                            executor.last(),
                        ));
                    }
                } else if let Ok(n) = take_int!(tok.clone()) {
                    // SAFETY: we check at the end of the block that it is valid
                    let to = unsafe { Instruction::new(n) };
                    let op = tok!()?;
                    if op == Token::Always {
                        executor.add(AlwaysJump { to });
                    } else {
                        let op = op.try_into().map_err(|op| err!(ExpectedOp(op)))?;
                        let a = take_var!(tok!()?)?;
                        let b = take_var!(tok!()?)?;
                        executor.add(Jump::new(op, to, a, b));
                    }
                } else {
                    yeet!(ExpectedJump(tok));
                };
            }
            // op add c 1 2
            Token::Op => {
                let op = tok!()?;
                if let Ok(op) = MathOp1::try_from(op.clone()) {
                    // assigning to a var is useless but legal
                    let out = take_numvar!(tok!()?)?;
                    let x = take_numvar!(tok!()?)?;
                    executor.add(Op1::new(op, x, out));
                } else if let Ok(op) = MathOp2::try_from(op.clone()) {
                    let out = take_numvar!(tok!()?)?;
                    let a = take_numvar!(tok!()?)?;
                    let b = take_numvar!(tok!()?)?;
                    executor.add(Op2::new(op, a, b, out));
                } else {
                    yeet!(ExpectedOp(op));
                }
            }
            // write 5.0 bank1 4 (aka bank1[4] = 5.0)
            Token::Write => {
                let set = take_numvar!(tok!()?)?;
                let container = take_memory!();
                let index = take_numvar!(tok!()?)?;
                // this is the parser so i wont bother getting unchecked
                if let LVar::Num(v) = executor.mem[index.address as usize]
                    && !container.fits(v.round() as usize)
                {
                    yeet!(IndexOutOfBounds(v.round() as usize, container.size()));
                }
                executor.add(Write {
                    index,
                    set,
                    container,
                });
            }
            // read result cell1 4 (aka result = cell1[4])
            Token::Read => {
                let output = take_var!(tok!()?)?;
                let container = take_memory!();
                let index = take_numvar!(tok!()?)?;
                if let LVar::Num(v) = executor.mem[index.address as usize]
                    && !container.fits(v.round() as usize)
                {
                    yeet!(IndexOutOfBounds(v.round() as usize, container.size()));
                }
                executor.add(Read {
                    index,
                    output,
                    container,
                });
            }
            Token::Draw => {
                let dty = tok!()?;
                let Token::Ident(instr) = dty else {
                    yeet!(ExpectedIdent(dty));
                };
                match instr {
                    "clear" => {
                        let (r, g, b) = three! { num_or_255!(tok!())? };
                        executor.draw(Clear { r, g, b });
                    }
                    "color" => {
                        let (r, g, b, a) = four! { num_or_255!(tok!())? };
                        executor.draw(SetColor { r, g, b, a });
                    }
                    "col" => {
                        let col = take_numvar!(tok!()?)?;
                        executor.draw(SetCol { col });
                    }
                    "stroke" => {
                        let size = take_numvar!(tok!()?)?;
                        executor.draw(SetStroke { size });
                    }
                    "line" => {
                        let (x, y, x2, y2) = four! { take_numvar!(tok!()?)? };
                        executor.draw(Line {
                            point_a: (x, y),
                            point_b: (x2, y2),
                        });
                    }
                    "rect" => {
                        let (x, y, width, height) = four! { take_numvar!(tok!()?)? };
                        executor.draw(RectFilled {
                            position: (x, y),
                            width,
                            height,
                        });
                    }
                    "lineRect" => {
                        let (x, y, width, height) = four! { take_numvar!(tok!()?)? };
                        executor.draw(RectBordered {
                            position: (x, y),
                            width,
                            height,
                        });
                    }
                    "triangle" => {
                        let (x, y, x2, y2, x3, y3) = six! { take_numvar!(tok!()?)? };
                        executor.draw(Triangle {
                            points: ((x, y), (x2, y2), (x3, y3)),
                        });
                    }
                    "poly" => {
                        let (x, y, sides, radius, rot) = five! { take_numvar!(tok!()?)? };
                        executor.draw(Poly {
                            pos: (x, y),
                            sides,
                            radius,
                            rot,
                        })
                    }
                    "linePoly" => {
                        let (x, y, sides, radius, rot) = five! { take_numvar!(tok!()?)? };
                        executor.draw(LinePoly {
                            pos: (x, y),
                            sides,
                            radius,
                            rot,
                        })
                    }
                    // image is WONTFIX
                    i => yeet!(UnsupportedImageOp(i)),
                }
            }
            Token::PackColor => {
                let out = take_numvar!(tok!()?)?;
                let (r, g, b, a) = four! { take_numvar!(tok!()?)? };
                executor.add(PackColor { out, r, g, b, a });
            }
            Token::DrawFlush => {
                let t = tok!();
                if let Ok(t) = t
                    && t != Token::Newline
                {
                    let screen = take_ident!(t.clone())?;
                    let mut out = String::new();
                    for ch in screen.chars() {
                        if ch.is_ascii_digit() {
                            out.push(ch);
                            continue;
                        }
                        if !out.is_empty() {
                            yeet!(InvalidDisplayType(screen));
                        }
                    }
                    let screen = &screen[..screen.len() - out.len()];
                    if screen != "display" {
                        yeet!(InvalidDisplayType(screen));
                    }
                    let n_span = tokens.span().start + screen.len()..tokens.span().end;
                    let screen_n = out
                        .parse::<usize>()
                        .map_err(|_| Error::ExpectedInt(t, n_span.clone()))?;
                    let display = executor
                        .display(screen_n)
                        .map_err(|n| Error::NoDisplay(n, n_span))?;
                    executor.add(Flush { display });
                } else {
                    executor.add(Flush::default())
                }
            }
            // end
            Token::End => {
                executor.add(End {});
            }
            Token::Select => {
                let to = addr!(take_ident!(tok!()?)?)?; // =
                // if
                let op: ConditionOp = tok!()?.try_into().map_err(|op| err!(ExpectedOp(op)))?;

                let x = take_var!(tok!()?)?;
                let y = take_var!(tok!()?)?;

                let a = take_var!(tok!()?)?; // then
                let b = take_var!(tok!()?)?; // else

                executor.add(Select {
                    op: op.get_fn(),
                    to,
                    x,
                    y,
                    a,
                    b,
                })
            }
            // starting newline, simply skip. continue, so as not to to trigger the nextline!()
            Token::Newline => continue,
            // unknown instruction
            Token::Ident(i) => {
                macro_rules! all {
                    ($is:expr) => {
                        |b| {
                            for var in &mut *b {
                                *var = $is;
                            }
                            Ok(())
                        }
                    };
                }
                macro_rules! take {
                    (@ $b:ident $n:ident skip) => {
                        $b[$n]=tok!()?;

                    };
                    (@ $b:ident $n:ident skip, $($rest:tt)*) => {
                        $b[$n] = tok!()?;$n+=1; take!(@ $b $n $($rest)*);
                    };
                    (@ $b:ident $n:ident $v: expr) => {
                        $b[$n] = $v;
                    };
                    (@ $b:ident $n:ident $v: expr, $($rest:tt)*) => {
                        $b[$n] = $v;
                        $n += 1;
                        take!(@ $b $n $($rest)*);
                    };
                    [$($this:tt)*] => {
                        |b| {
                            let mut n = 0;
                            take!(@ b n $($this)*);
                            Ok(())
                        }
                    };
                }
                macro_rules! num {
                    () => {{
                        let tok = tok!()?;
                        if let Some(i) = tokstr!(tok) {
                            Token::Ident(i)
                        } else {
                            match tok {
                                Token::Num(n) => Token::Num(n),
                                t => yeet!(ExpectedNum(t)),
                            }
                        }
                    }};
                }
                macro_rules! bool {
                    () => {{
                        let tok = tok!()?;
                        if let Some(i) = tokstr!(tok) {
                            Token::Ident(i)
                        } else {
                            match tok {
                                Token::Num(n) => Token::Num(n),
                                t => yeet!(ExpectedBool(t)),
                            }
                        }
                    }};
                }
                macro_rules! ident {
                    () => {
                        take_ident!(tok!()?).map(|v| Token::Ident(v))?
                    };
                }
                #[rustfmt::skip]
                macro_rules! build { () => { ident!() }}
                macro_rules! str {
                    () => {
                        match tok!()? {
                            Token::String(s) => Token::String(s),
                            t => yeet!(ExpectedString(t)),
                        }
                    };
                }
                macro_rules! var {
                    () => {{
                        let tok = tok!()?;
                        if let Some(i) = tokstr!(tok) {
                            Token::Ident(i)
                        } else {
                            match tok {
                                Token::Num(n) => Token::Num(n),
                                Token::String(s) => Token::String(s),
                                t => yeet!(ExpectedVar(t)),
                            }
                        }
                    }};
                }
                macro_rules! instr {
                    (($argc:literal) => $block:expr) => {{
                        let mut v: Box<[_; $argc + 1]> =
                            Box::new(std::array::from_fn(|_| Token::Newline));
                        v[0] = Token::Ident(i);
                        const fn castor<
                            'source,
                            F: FnMut(&mut [Token<'source>; $argc]) -> Result<(), Error<'source>>,
                        >(
                            f: F,
                        ) -> F {
                            f
                        }
                        castor($block)((&mut v[1..]).try_into().unwrap())?;
                        executor.code(v as Box<[Token<'source>]>);
                        nextline!();
                        continue;
                    }};
                }
                macro_rules! minstr {
                    ($($sub:ident($argc:literal) => $block:expr)+ => $err:expr $(,)?) => {{
                        let t = tok!()?;
                        let idnt = take_ident!(t.clone())?;
                        $(if idnt == stringify!($sub) {
                            let mut v: Box<[_; $argc + 2]> = Box::new(std::array::from_fn(|_| Token::Newline));
                            v[0]=Token::Ident(i);
                            v[1]=Token::Ident(stringify!($sub));
                            const fn castor<'source, F: FnMut(&mut [Token<'source>; $argc]) -> Result<(), Error<'source>>>(f: F) -> F { f }
                            castor($block)((&mut v[2..]).try_into().unwrap())?;
                            executor.code(v);
                            nextline!();
                            continue;
                        })+
                        return Err($err(idnt, t));
                    }};
                }
                match i {
                    "noop" => {
                        // executor.program.push(UPInstr::Comment("a"));
                        executor.add(crate::instructions::Noop {});
                    }
                    "printflush" => instr! {
                        (1) => |b| {
                            let t = tok!()?;
                            if let Some(t) = tokstr!(t) {
                                b[0] = Token::Ident(t);
                            } else if t == Token::Null {
                                b[0] = Token::Null;
                            } else {
                                b[0] = Token::Ident("message1");
                            }
                            Ok(())
                        }
                    },
                    "getlink" => instr! { (2) => take![var!(), num!()] },
                    "control" => minstr! {
                        enabled(2) => take![build!(), bool!()]
                        shoot(4) => take![build!(), num!(), num!(), bool!()]
                        shootp(3) => take![build!(), str!(), bool!()]
                        config(2) => take![build!(), tok!()?]
                        color(4) => take![build!(), num!(), num!(), num!()]
                        => |t, _| { err!(UnknownControlOp(t)) },
                    },
                    "radar" => {
                        instr! { (7) => take![ident!(), ident!(), ident!(), ident!(), build!(), num!(), var!()] }
                    }
                    "sensor" => instr! { (3) => take![var!(), tok!()?, tok!()?] },
                    "wait" => instr! { (1) => all!(num!()) },
                    "lookup" => instr! { (3) => take![ident!(), var!(), num!()] },
                    "packcolor" => instr! { (4) => all!(num!()) },
                    "ubind" => instr! { (1) => |b| {
                        let t = tok!()?;
                        if tokstr!(t).is_some() || matches!(t, Token::Null) {
                            b[0] = t;
                        } else {
                            yeet!(ExpectedString(t));
                        };
                        Ok(())
                    } },
                    "ucontrol" => minstr! {
                        idle(0) => |_| Ok(())
                        stop(0) => |_| Ok(())
                        move(2) => all!(num!())
                        approach(3) => all!(num!())
                        boost(1) => all!(bool!())
                        pathfind(2) => all!(num!())
                        target(3) => take![num!(), num!(), bool!()]
                        targetp(2) => take![str!(), bool!()]
                        itemDrop(2) => take![build!(), num!()]
                        itemTake(3) => take![build!(), str!(), num!()]
                        payDrop(0) => |_| Ok(())
                        payTake(1) => all!(bool!())
                        payEnter(0) => |_| Ok(())
                        mine(2) => all!(num!())
                        flag(1) => all!(num!())
                        build(5) => take![num!(), num!(), build!(), num!(), tok!()?]
                        getBlock(4) => take![num!(), num!(), build!(), build!()]
                        within(4) => take![num!(), num!(), num!(), var!()]
                        => |t, _| { err!(UnknownUnitControlOp(t)) }
                    },
                    "uradar" => {
                        instr! { (7) => take![ident!(), ident!(), ident!(), ident!(), build!(), num!(), var!()] }
                    }
                    "ulocate" => {
                        minstr! {
                            building(7) => take![build!(), bool!(), skip, num!(), num!(), bool!(), build!()]
                            spawn(6) => take![skip, skip, skip, num!(), num!(), bool!()]
                            damaged(7) => take![skip, skip, skip, num!(), num!(), var!(), var!()]
                            ore(6) => take![skip, skip, tok!()?, num!(), num!(), bool!()]
                            => |t, _| { err!(UnknownUnitLocateOp(t)) }
                        }
                    }
                    "getblock" => minstr! {
                        floor(3) => take![tok!()?, num!(), num!()]
                        ore(3) => take![tok!()?, num!(), num!()]
                        block(3) => take![tok!()?, num!(), num!()]
                        building(3) => take![tok!()?, num!(), num!()]
                        => |t, _| { err!(UnknownGetBlockOp(t)) }
                    },
                    "setblock" => minstr! {
                        floor(3) => take![num!(), num!(), str!()]
                        ore(3) => take![num!(), num!(), str!()]
                        block(3) => take![num!(), num!(), str!(), str!(), num!()]
                        => |t, _| { err!(UnknownSetBlockOp(t)) }
                    },
                    "spawn" => {
                        instr! { (6) => take![str!(), num!(), num!(), num!(), str!(), var!()] }
                    }
                    "status" => minstr! {
                        true(3) => take![ident!(), var!(), num!()]
                        false(2) => take![ident!(), var!()]
                        => |_, t| { err!(ExpectedBool(t)) }
                    },
                    "spawnwave" => instr! { (3) => take![num!(), num!(), bool!()] },
                    "setrule" => {
                        #[rustfmt::skip]
                        macro_rules! rule { () => { take![num!(), str!()] }}
                        minstr! {
                            currentWaveTime(1) => all!(num!())
                            waveTimer(1) => all!(num!())
                            waves(1) => all!(num!())
                            wave(1) => all!(num!())
                            waveSpacing(1) => all!(num!())
                            waveSending(1) => all!(num!())
                            attackMode(1) => all!(num!())
                            enemyCoreBuildRadius(1) => all!(num!())
                            dropZoneRadius(1) => all!(num!())
                            unitCap(1) => all!(num!())
                            wave(1) => all!(num!())
                            mapArea(4) => |b| {
                                tok!()?;
                                for var in &mut *b {
                                    *var = num!();
                                }
                                Ok(())
                            }
                            lighting(1) => all!(num!())
                            ambientLight(1) => all!(num!())
                            solarMultiplier(1) => all!(num!())
                            buildSpeed(2) => rule!{}
                            unitHealth(2) => rule!{}
                            unitBuildSpeed(2) => rule!{}
                            unitCost(2) => rule!{}
                            unitDamage(2) => rule!{}
                            blockHealth(2) => rule!{}
                            blockDamage(2) => rule!{}
                            rtsMinWeight(2) => rule!{}
                            rtsMinSquad(2) => rule!{}
                            => |t, _| { err!(UnknownRule(t)) }
                        }
                    }
                    "cutscene" => minstr! {
                        pan(3) => all!(num!())
                        zoom(1) => all!(num!())
                        stop(0) => |_| Ok(())
                        => |t, _| { err!(UnknownCutscene(t)) }
                    },
                    "explosion" => {
                        instr! { (8) => take![str!(), num!(), num!(), num!(), bool!(), bool!(), bool!()] }
                    }
                    "setrate" => instr! { (1) => all!(num!()) },
                    "fetch" => minstr! {
                        buildCount(4) => take![var!(), str!(), num!(), str!()] // useless 0
                        unitCount(4)  => take![var!(), str!()]
                        playerCount(4)  => take![var!(), str!()]
                        coreCount(4)  => take![var!(), str!()]
                        unit(3) => take![var!(), str!(), num!()]
                        player(3) => take![var!(), str!(), num!()]
                        core(3) => take![var!(), str!(), num!()]
                        build(3) => take![var!(), str!(), num!()]
                        => |t, _| { err!(UnknownFetchOp(t)) }
                    },
                    "getflag" => instr! { (2) => take![bool!(), str!()] },
                    "setflag" => instr! { (2) => take![str!(), bool!()] },
                    "setprop" => instr! { (3) => take![str!(), var!(), tok!()?] },
                    "effect" => {
                        let mut v = Vec::with_capacity(6);
                        v.push(Token::Ident("effect"));
                        while let Some(tok) = tokens.next()
                            && tok != Token::Newline
                        {
                            v.push(tok);
                        }
                        executor.code(v.into_boxed_slice());
                        // we take the newline here
                        continue;
                    }
                    t => yeet!(ExpectedInstr(Token::Ident(t))),
                }
            }
            t => yeet!(ExpectedInstr(t)),
        }
        nextline!();
    }

    for (j, (label, s), i) in unfinished_jumps {
        let to = executor
            .debug_info
            .labels
            .iter()
            .find(|(v, _)| v == &label)
            .ok_or_else(|| Error::LabelNotFound(label, s))?
            .1;
        executor.program[i.get()] = UPInstr::Instr(match j {
            UJump::Always => Instr::from(AlwaysJump { to }),
            UJump::Sometimes { a, b, op } => Instr::from(Jump::new(op, to, a, b)),
        });
    }

    // check jump validity
    for i in &executor.program {
        if let UPInstr::Instr(
            Instr::Jump(Jump { to, .. }) | Instr::AlwaysJump(AlwaysJump { to, .. }),
        ) = i
        {
            if !executor.valid(*to) {
                yeet!(InvalidJump(*to));
            }
        }
    }

    // set dynjumps
    let len = executor.program.len();
    for i in &mut executor.program {
        if let UPInstr::Instr(Instr::DynJump(DynJump { proglen, .. })) = i {
            *proglen = len;
        }
    }

    executor.debug_info.variables = dbg_info.into();

    Ok(())
}