module build_constraint

// lexing:
enum BTokenKind {
	tfact   // linux, tinyc, prod etc
	tdefine // abc, gcboehm
	tor     // ||
	tand    // &&
	tnot    // !
	tparen_open
	tparen_close
	teof
}

struct Token {
	kind  BTokenKind
	value string
}

fn unexpected(c u8) IError {
	return error('unexpected character `${rune(c)}`')
}

fn new_token(kind BTokenKind, value string) Token {
	return Token{
		kind:  kind
		value: value
	}
}

fn new_op(kind BTokenKind) Token {
	return new_token(kind, '')
}

fn new_span(kind BTokenKind, mut span []u8) Token {
	t := new_token(kind, span.bytestr())
	span.clear()
	return t
}

fn lex(original string) ![]Token {
	mut res := []Token{}
	mut span := []u8{cap: original.len}
	mut op := []u8{}
	s := original.all_before('//')
	for c in s {
		match c {
			` `, `\t`, `\n` {}
			`(` {
				if span.len > 0 {
					res << new_span(.tfact, mut span)
				}
				res << new_op(.tparen_open)
			}
			`)` {
				if span.len > 0 {
					res << new_span(.tfact, mut span)
				}
				res << new_op(.tparen_close)
			}
			`&`, `|` {
				if span.len > 0 {
					res << new_span(.tfact, mut span)
				}
				op << c
				if op == [c, c] {
					op.clear()
					if c == `&` {
						res << new_op(.tand)
					} else if c == `|` {
						res << new_op(.tor)
					} else {
						return unexpected(c)
					}
				}
				if op.len == 2 {
					return unexpected(c)
				}
			}
			`?` {
				res << new_span(.tdefine, mut span)
			}
			`!` {
				res << new_op(.tnot)
				if span.len > 0 {
					return unexpected(c)
				}
			}
			else {
				if u8(c).is_alnum() || c in [`_`, `-`] {
					span << c
				} else {
					return unexpected(c)
				}
			}
		}
	}
	if span.len > 0 {
		res << new_span(.tfact, mut span)
	}
	res << new_op(.teof)
	return res
}