if !file_exists(path)? {

// why is rust like this.

return Some(false);

}

include_path_if_exists(inputs, arena::sprintf(&mut (*c).arena, c!("%s/all.b"), path));

include_path_if_exists(inputs, arena::sprintf(&mut (*c).arena, c!("%s/%s.b"), path, target));

Some(true)

for i in 0..tokens.len() {

if (*tokens)[i] == (*l).token {

return Some(());

}

}

let mut sb: String_Builder = zeroed();

for i in 0..tokens.len() {

if i > 0 {

if i + 1 >= tokens.len() {

sb_appendf(&mut sb, c!(", or "));

} else {

sb_appendf(&mut sb, c!(", "));

}

}

sb_appendf(&mut sb, c!("%s"), lexer::display_token((*tokens)[i]));

}

da_append(&mut sb, 0);

diagf!((*l).loc, c!("ERROR: expected %s, but got %s\n"), sb.items, lexer::display_token((*l).token));

free(sb.items);

None

let saved_point = (*l).parse_point;

lexer::get_token(l)?;

if expect_token(l, token).is_none() {

(*l).parse_point = saved_point;

bump_error_count(c)

} else {

Some(())

}

expect_token(l, Token::ID)?;

if strcmp((*l).string, id) != 0 {

diagf!((*l).loc, c!("ERROR: expected `%s`, but got `%s`\n"), id, (*l).string);

return None;

}

Some(())

pub name: *const c_char,

pub loc: Loc,

pub storage: Storage,

if (*vars).count < (*vars).capacity {

// Reusing already allocated scopes

(*vars).count += 1;

(*da_last_mut(vars).expect("There should be always at least the global scope")).count = 0;

} else {

da_append(vars, zeroed());

}

for i in 0..(*vars).count {

let var = (*vars).items.add(i);

if strcmp((*var).name, name) == 0 {

return var

}

}

ptr::null()

let mut i = (*vars).count;

while i > 0 {

let var = find_var_near((*vars).items.add(i-1), name);

if !var.is_null() {

return var;

}

i -= 1;

}

ptr::null()

let scope = da_last_mut(&mut (*c).vars).expect("There should be always at least the global scope");

let existing_var = find_var_near(scope, name);

if !existing_var.is_null() {

diagf!(loc, c!("ERROR: redefinition of variable `%s`\n"), name);

diagf!((*existing_var).loc, c!("NOTE: the first declaration is located here\n"));

return bump_error_count(c);

}

if let Storage::Auto {index} = storage {

da_append(&mut (*c).func_scope_events, ScopeEvent::Declare {name, index});

}

da_append(scope, Var {name, loc, storage});

Some(())

name: *const c_char,

loc: Loc,

label: usize,

name: *const c_char,

loc: Loc,

addr: usize,

for i in 0..(*labels).count {

let label = (*labels).items.add(i);

if strcmp((*label).name, name) == 0 {

return label

}

}

ptr::null()

let existing_label = find_goto_label(&(*c).func_goto_labels, name);

if !existing_label.is_null() {

diagf!(loc, c!("ERROR: duplicate label `%s`\n"), name);

diagf!((*existing_label).loc, c!("NOTE: the first definition is located here\n"));

return bump_error_count(c);

}

da_append(&mut (*c).func_goto_labels, GotoLabel {name, loc, label});

Some(())

&[Binop::BitOr],

&[Binop::BitAnd],

&[Binop::BitShl, Binop::BitShr],

&[Binop::Equal, Binop::NotEqual],

&[Binop::Less, Binop::Greater, Binop::GreaterEqual, Binop::LessEqual],

&[Binop::Plus, Binop::Minus],

&[Binop::Mult, Binop::Mod, Binop::Div],

// The outer Option indicates success.

// The inner Option indicates whether the assign has binop associated with it.

// It's kinda confusing but I don't know how to make it "prettier"

pub fn from_assign_token(token: Token) -> Option<Option<Self>> {

match token {

Token::Eq => Some(None),

Token::PlusEq => Some(Some(Binop::Plus)),

Token::MinusEq => Some(Some(Binop::Minus)),

Token::MulEq => Some(Some(Binop::Mult)),

Token::DivEq => Some(Some(Binop::Div)),

Token::ModEq => Some(Some(Binop::Mod)),

Token::ShlEq => Some(Some(Binop::BitShl)),

Token::ShrEq => Some(Some(Binop::BitShr)),

Token::OrEq => Some(Some(Binop::BitOr)),

Token::AndEq => Some(Some(Binop::BitAnd)),

_ => None,

}

}

pub fn from_token(token: Token) -> Option<Self> {

match token {

Token::Plus => Some(Binop::Plus),

Token::Minus => Some(Binop::Minus),

Token::Mul => Some(Binop::Mult),

Token::Div => Some(Binop::Div),

Token::Mod => Some(Binop::Mod),

Token::EqEq => Some(Binop::Equal),

Token::NotEq => Some(Binop::NotEqual),

Token::Less => Some(Binop::Less),

Token::LessEq => Some(Binop::LessEqual),

Token::Greater => Some(Binop::Greater),

Token::GreaterEq => Some(Binop::GreaterEqual),

Token::Or => Some(Binop::BitOr),

Token::And => Some(Binop::BitAnd),

Token::Shl => Some(Binop::BitShl),

Token::Shr => Some(Binop::BitShr),

_ => None,

}

}

pub const MAX_PRECEDENCE: usize = PRECEDENCE.len();

pub unsafe fn precedence(self) -> usize {

for precedence in 0..PRECEDENCE.len() {

for i in 0..(*PRECEDENCE)[precedence].len() {

if self == (*(*PRECEDENCE)[precedence])[i] {

return precedence

}

}

}

unreachable!()

}

/// How many autovars currently allocated

pub count: usize,

/// Maximum allocated autovars throughout the function body

pub max: usize,

let index = (*c).op_label_count;

(*c).op_label_count += 1;

index

(*t).count += 1;

if (*t).count > (*t).max {

(*t).max = (*t).count;

}

(*t).count

let offset = (*c).program.data.count;

let string_len = strlen(string);

da_append_many(&mut (*c).program.data, slice::from_raw_parts(string as *const u8, string_len));

// TODO: Strings in B are not NULL-terminated.

// They are terminated with symbol '*e' ('*' is escape character akin to '\' in C) which according to the

// spec is called just "end-of-file" without any elaboration on what its value is. Maybe it had a specific

// value on PDP that was a common knowledge at the time? In any case that breaks compatibility with

// libc. While the language is still in development we gonna terminate it with 0. We will make it

// "spec complaint" later.

da_append(&mut (*c).program.data, 0); // NULL-terminator

offset

lexer::get_token(l)?;

let arg = match (*l).token {

Token::OParen => {

let result = compile_expression(l, c)?;

get_and_expect_token_but_continue(l, c, Token::CParen)?;

Some(result)

}

Token::Not => {

let (arg, _) = compile_primary_expression(l, c)?;

let result = allocate_auto_var(&mut (*c).auto_vars_ator);

push_opcode(Op::UnaryNot{result, arg}, (*l).loc, c);

Some((Arg::AutoVar(result), false))

}

Token::Mul => {

let (arg, _) = compile_primary_expression(l, c)?;

let index = allocate_auto_var(&mut (*c).auto_vars_ator);

push_opcode(Op::AutoAssign {index, arg}, (*l).loc, c);

Some((Arg::Deref(index), true))

}

Token::Minus => {

let (arg, _) = compile_primary_expression(l, c)?;

if let Arg::Literal(v) = arg {

Some((Arg::Literal(!v + 1), false))

} else {

let index = allocate_auto_var(&mut (*c).auto_vars_ator);

push_opcode(Op::Negate {result: index, arg}, (*l).loc, c);

Some((Arg::AutoVar(index), false))

}

}

Token::And => {

let loc = (*l).loc;

let (arg, is_lvalue) = compile_primary_expression(l, c)?;

if !is_lvalue {

diagf!(loc, c!("ERROR: cannot take the address of an rvalue\n"));

return bump_error_count(c).map(|()| (Arg::Bogus, false));

}

match arg {

Arg::Deref(index) => Some((Arg::AutoVar(index), false)), // "&*x is identically x"

Arg::External(name) => Some((Arg::RefExternal(name), false)),

Arg::AutoVar(index) => Some((Arg::RefAutoVar(index), false)),

Arg::Bogus => Some((Arg::Bogus, false)), // Reference of a bogus value is a bogus value

Arg::Literal(_) | Arg::DataOffset(_) | Arg::RefAutoVar(_) | Arg::RefExternal(_) => unreachable!(),

}

}

Token::PlusPlus => {

let loc = (*l).loc;

let (arg, is_lvalue) = compile_primary_expression(l, c)?;

if !is_lvalue {

diagf!(loc, c!("ERROR: cannot increment an rvalue\n"));

return bump_error_count(c).map(|()| (Arg::Bogus, false));

}

compile_binop(arg, Arg::Literal(1), Binop::Plus, loc, c);

Some((arg, false))

}

Token::MinusMinus => {

let loc = (*l).loc;

let (arg, is_lvalue) = compile_primary_expression(l, c)?;

if !is_lvalue {

diagf!(loc, c!("ERROR: cannot decrement an rvalue\n"));

return bump_error_count(c).map(|()| (Arg::Bogus, false));

}

compile_binop(arg, Arg::Literal(1), Binop::Minus, loc, c);

Some((arg, false))

}

Token::CharLit | Token::IntLit => Some((Arg::Literal((*l).int_number), false)),

Token::ID => {

let name = arena::strdup(&mut (*c).arena, (*l).string);

let var_def = find_var_deep(&mut (*c).vars, name);

if var_def.is_null() {

da_append(&mut (*c).used_funcs, UsedFunc {name, loc: (*l).loc});

Some((Arg::External(name), true))

} else {

match (*var_def).storage {

Storage::Auto{index} => Some((Arg::AutoVar(index), true)),

Storage::External{name} => Some((Arg::External(name), true)),

}

}

}

Token::String => {

let offset = compile_string((*l).string, c);

Some((Arg::DataOffset(offset), false))

}

_ => {

diagf!((*l).loc, c!("Expected start of a primary expression but got %s\n"), lexer::display_token((*l).token));

None

}

};

let (mut arg, mut is_lvalue) = arg?;

loop {

let saved_point = (*l).parse_point;

lexer::get_token(l)?;

(arg, is_lvalue) = match (*l).token {

Token::OParen => Some((compile_function_call(l, c, arg)?, false)),

Token::OBracket => {

let (offset, _) = compile_expression(l, c)?;

get_and_expect_token_but_continue(l, c, Token::CBracket)?;

let result = allocate_auto_var(&mut (*c).auto_vars_ator);

push_opcode(Op::Index {result, arg, offset}, (*l).loc, c);

Some((Arg::Deref(result), true))

}

Token::PlusPlus => {

let loc = (*l).loc;

if !is_lvalue {

diagf!(loc, c!("ERROR: cannot increment an rvalue\n"));

return bump_error_count(c).map(|()| (Arg::Bogus, false));

}

let pre = allocate_auto_var(&mut (*c).auto_vars_ator);

push_opcode(Op::AutoAssign {index: pre, arg}, loc, c);

compile_binop(arg, Arg::Literal(1), Binop::Plus, loc, c);

Some((Arg::AutoVar(pre), false))

}

Token::MinusMinus => {

let loc = (*l).loc;

if !is_lvalue {

diagf!(loc, c!("ERROR: cannot decrement an rvalue\n"));

return bump_error_count(c).map(|()| (Arg::Bogus, false));

}

let pre = allocate_auto_var(&mut (*c).auto_vars_ator);

push_opcode(Op::AutoAssign {index: pre, arg}, loc, c);

compile_binop(arg, Arg::Literal(1), Binop::Minus, loc, c);

Some((Arg::AutoVar(pre), false))

}

_ => {

(*l).parse_point = saved_point;

return Some((arg, is_lvalue));

}

}?;

}

match lhs {

Arg::Deref(index) => {

let tmp = allocate_auto_var(&mut (*c).auto_vars_ator);

push_opcode(Op::Binop {binop, index: tmp, lhs, rhs}, loc, c);

push_opcode(Op::Store {index, arg: Arg::AutoVar(tmp)}, loc, c);

},

Arg::External(name) => {

let tmp = allocate_auto_var(&mut (*c).auto_vars_ator);

push_opcode(Op::Binop {binop, index: tmp, lhs, rhs}, loc, c);

push_opcode(Op::ExternalAssign {name, arg: Arg::AutoVar(tmp)}, loc, c)

}

Arg::AutoVar(index) => {

push_opcode(Op::Binop {binop, index, lhs, rhs}, loc, c)

}

Arg::Bogus => {

// Bogus value does not compile to anything

}

Arg::Literal(_) | Arg::DataOffset(_) | Arg::RefAutoVar(_) | Arg::RefExternal(_) => unreachable!(),

}

if precedence >= Binop::MAX_PRECEDENCE {

return compile_primary_expression(l, c);

}

let (mut lhs, mut lvalue) = compile_binop_expression(l, c, precedence + 1)?;

let mut saved_point = (*l).parse_point;

lexer::get_token(l)?;

if let Some(binop) = Binop::from_token((*l).token) {

if binop.precedence() == precedence {

while let Some(binop) = Binop::from_token((*l).token) {

if binop.precedence() != precedence { break; }

let (rhs, _) = compile_binop_expression(l, c, precedence + 1)?;

let index = allocate_auto_var(&mut (*c).auto_vars_ator);

push_opcode(Op::Binop {binop, index, lhs, rhs}, (*l).loc, c);

lhs = Arg::AutoVar(index);

lvalue = false;

saved_point = (*l).parse_point;

lexer::get_token(l)?;

}

}

}

(*l).parse_point = saved_point;

Some((lhs, lvalue))

let (lhs, mut lvalue) = compile_binop_expression(l, c, 0)?;

let mut saved_point = (*l).parse_point;

lexer::get_token(l)?;

while let Some(binop) = Binop::from_assign_token((*l).token) {

let binop_loc = (*l).loc;

let (rhs, _) = compile_assign_expression(l, c)?;

if !lvalue {

diagf!(binop_loc, c!("ERROR: cannot assign to rvalue\n"));

return bump_error_count(c).map(|()| (Arg::Bogus, false));

}

if let Some(binop) = binop {

compile_binop(lhs, rhs, binop, binop_loc, c);

} else {

match lhs {

Arg::Deref(index) => {

push_opcode(Op::Store {index, arg: rhs}, binop_loc, c);

}

Arg::External(name) => {

push_opcode(Op::ExternalAssign {name, arg: rhs}, binop_loc, c);

}

Arg::AutoVar(index) => {

push_opcode(Op::AutoAssign {index, arg: rhs}, binop_loc, c);

}

Arg::Bogus => {

// Bogus value does not compile to anything

}

Arg::Literal(_) | Arg::DataOffset(_) | Arg::RefAutoVar(_) | Arg::RefExternal(_) => unreachable!(),

}

}

lvalue = false;

saved_point = (*l).parse_point;

lexer::get_token(l)?;

}

if (*l).token == Token::Question {

let result = allocate_auto_var(&mut (*c).auto_vars_ator);

let else_label = allocate_label_index(c);

push_opcode(Op::JmpIfNotLabel{label: else_label, arg: lhs}, (*l).loc, c);

let (if_true, _) = compile_expression(l, c)?;

push_opcode(Op::AutoAssign {index: result, arg: if_true}, (*l).loc, c);

let out_label = allocate_label_index(c);

push_opcode(Op::JmpLabel{label: out_label}, (*l).loc, c);

get_and_expect_token_but_continue(l, c, Token::Colon)?;

push_opcode(Op::Label{label: else_label}, (*l).loc, c);

let (if_false, _) = compile_expression(l, c)?;

push_opcode(Op::AutoAssign {index: result, arg: if_false}, (*l).loc, c);

push_opcode(Op::Label{label: out_label}, (*l).loc, c);

Some((Arg::AutoVar(result), false))

} else {

(*l).parse_point = saved_point;

Some((lhs, lvalue))

}

let index = (*c).func_blocks_count;

(*c).func_blocks_count += 1;

da_append(&mut (*c).func_scope_events, ScopeEvent::BlockBegin {index});

loop {

let saved_point = (*l).parse_point;

lexer::get_token(l)?;

if (*l).token == Token::CCurly { break }

(*l).parse_point = saved_point;

compile_statement(l, c)?

}

da_append(&mut (*c).func_scope_events, ScopeEvent::BlockEnd {index});

Some(())

let mut args: Array<Arg> = zeroed();

let saved_point = (*l).parse_point;

lexer::get_token(l)?;

if (*l).token != Token::CParen {

(*l).parse_point = saved_point;

loop {

let (expr, _) = compile_expression(l, c)?;

da_append(&mut args, expr);

get_and_expect_tokens(l, &[Token::CParen, Token::Comma])?;

match (*l).token {

Token::CParen => break,

Token::Comma => continue,

_ => unreachable!(),

}

}

}

let result = allocate_auto_var(&mut (*c).auto_vars_ator);

push_opcode(Op::Funcall {result, fun, args}, (*l).loc, c);

Some(Arg::AutoVar(result))

for i in 0..(*names).count {

if strcmp(*(*names).items.add(i), name) == 0 {

return;

}

}

da_append(names, name)

get_and_expect_token_but_continue(l, c, Token::OParen)?;

let saved_point = (*l).parse_point;

lexer::get_token(l)?;

if (*l).token != Token::CParen {

(*l).parse_point = saved_point;

loop {

get_and_expect_token(l, Token::String)?;

match (*l).token {

Token::String => {

let line = arena::strdup(&mut (*c).arena, (*l).string);

let loc = (*l).loc;

da_append(stmts, AsmStmt { line, loc });

}

_ => unreachable!(),

}

get_and_expect_tokens(l, &[Token::Comma, Token::CParen])?;

match (*l).token {

Token::Comma => {}

Token::CParen => break,

_ => unreachable!(),