///|
/// Reads `include`d and `subninja` files. Errors carry the system message,
/// e.g. "No such file or directory".
pub(open) trait FileReader {
fn read_file(Self, String) -> String raise NinjaError
}
///|
/// What to do with `build a: phony a` (written by CMake 2.8.12.x/3.0.x).
#derive(Eq, Debug)
pub(all) enum PhonyCycleAction {
/// Drop the self-reference and warn (`-w phonycycle=warn`, the default).
Warn
/// Keep it, so the build reports a dependency cycle.
Error
}
///|
pub(all) struct ManifestParserOptions {
phony_cycle_action : PhonyCycleAction
}
///|
pub fn ManifestParserOptions::default() -> ManifestParserOptions {
{ phony_cycle_action: Warn, }
}
///|
/// Parses `.ninja` files into a `State`.
pub struct ManifestParser {
state : State
read : ((String) -> String raise NinjaError)?
options : ManifestParserOptions
env : BindingEnv
mut quiet : Bool
mut lexer : Lexer
/// Warnings in the order ninja would print them (without "ninja: warning: ").
warnings : Array[String]
}
///|
pub fn[R : FileReader] ManifestParser::new(
state : State,
reader? : R,
options~ : ManifestParserOptions = ManifestParserOptions::default(),
) -> ManifestParser {
let read = match reader {
Some(reader) =>
Some(fn(path : String) raise NinjaError { reader.read_file(path) })
None => None
}
{
state,
read,
options,
env: state.bindings,
quiet: false,
lexer: Lexer::new(""),
warnings: [],
}
}
///|
/// A parser that cannot read other files.
pub fn ManifestParser::without_files(
state : State,
options~ : ManifestParserOptions = ManifestParserOptions::default(),
) -> ManifestParser {
{
state,
read: None,
options,
env: state.bindings,
quiet: false,
lexer: Lexer::new(""),
warnings: [],
}
}
///|
pub fn ManifestParser::warnings(self : ManifestParser) -> Array[String] {
self.warnings
}
///|
fn ManifestParser::subparser(
self : ManifestParser,
env : BindingEnv,
) -> ManifestParser {
{
state: self.state,
read: self.read,
options: self.options,
env,
quiet: self.quiet,
lexer: Lexer::new(""),
warnings: self.warnings,
}
}
///|
/// Loads and parses `filename`. When `parent` is given (an `include` or
/// `subninja`), a read failure is reported at the parent's position.
pub fn ManifestParser::load(
self : ManifestParser,
filename : String,
parent? : Lexer,
) -> Unit raise NinjaError {
let contents = match self.read {
Some(read) =>
read(filename) catch {
error => {
let message = "loading '\{filename}': \{error.message()}"
match parent {
Some(lexer) => raise Error(lexer.error(message))
None => raise Error(message)
}
}
}
None => {
let message = "loading '\{filename}': No such file or directory"
match parent {
Some(lexer) => raise Error(lexer.error(message))
None => raise Error(message)
}
}
}
self.parse(filename, contents)
}
///|
/// Parses `input` as a file named "input", without warnings (ninja's
/// `ParseTest`).
pub fn ManifestParser::parse_test(
self : ManifestParser,
input : String,
) -> Unit raise NinjaError {
self.quiet = true
self.parse("input", input)
}
///|
pub fn ManifestParser::parse(
self : ManifestParser,
filename : String,
input : String,
) -> Unit raise NinjaError {
self.lexer = Lexer::new(input, filename~)
while true {
let token = self.lexer.read_token()
match token {
Pool => self.parse_pool()
Build => self.parse_edge()
Rule => self.parse_rule()
Default => self.parse_default()
Ident => {
self.lexer.unread_token()
let (name, let_value) = self.parse_let()
let value = let_value.evaluate(self.env)
// Check the version at once, before any syntax it might not know.
if name == "ninja_required_version" {
self.check_ninja_version(value)
}
self.env.add_binding(name, value)
}
Include => self.parse_file_include(false)
Subninja => self.parse_file_include(true)
Error => raise self.lexer.fail(self.lexer.describe_last_error())
Eof => return
Newline => ()
_ => raise self.lexer.fail("unexpected \{token.name()}")
}
}
}
///|
fn parse_version(version : String) -> (Int32, Int32) {
match version.find(".") {
None => (atoi(version), 0)
Some(end) => {
let major = atoi(version.unsafe_substring(start=0, end~))
let rest = version.unsafe_substring(start=end + 1, end=version.length())
let minor = match rest.find(".") {
Some(dot) => atoi(rest.unsafe_substring(start=0, end=dot))
None => atoi(rest)
}
(major, minor)
}
}
}
///|
fn ManifestParser::check_ninja_version(
self : ManifestParser,
version : String,
) -> Unit raise NinjaError {
let (bin_major, bin_minor) = parse_version(ninja_version)
let (file_major, file_minor) = parse_version(version)
if bin_major > file_major {
self.warnings.push(
"ninja executable version (\{ninja_version}) greater than build file ninja_required_version (\{version}); versions may be incompatible.",
)
return
}
if (bin_major == file_major && bin_minor < file_minor) ||
bin_major < file_major {
raise Fatal(
"ninja version (\{ninja_version}) incompatible with build file ninja_required_version version (\{version}).",
)
}
}
///|
fn ManifestParser::expect_token(
self : ManifestParser,
expected : Token,
) -> Unit raise NinjaError {
let token = self.lexer.read_token()
if token != expected {
raise self.lexer.fail(
"expected \{expected.name()}, got \{token.name()}\{expected.error_hint()}",
)
}
}
///|
fn ManifestParser::parse_let(
self : ManifestParser,
) -> (String, EvalString) raise NinjaError {
guard self.lexer.read_ident() is Some(key) else {
raise self.lexer.fail("expected variable name")
}
self.expect_token(Equals)
(key, self.lexer.read_var_value())
}
///|
fn ManifestParser::parse_pool(self : ManifestParser) -> Unit raise NinjaError {
guard self.lexer.read_ident() is Some(name) else {
raise self.lexer.fail("expected pool name")
}
self.expect_token(Newline)
if self.state.lookup_pool(name) is Some(_) {
raise self.lexer.fail("duplicate pool '\{name}'")
}
let mut depth = -1
while self.lexer.peek_token(Indent) {
let (key, value) = self.parse_let()
if key == "depth" {
depth = atoi(value.evaluate(self.env))
if depth < 0 {
raise self.lexer.fail("invalid pool depth")
}
} else {
raise self.lexer.fail("unexpected variable '\{key}'")
}
}
if depth < 0 {
raise self.lexer.fail("expected 'depth =' line")
}
self.state.add_pool(Pool::new(name, depth))
}
///|
fn ManifestParser::parse_rule(self : ManifestParser) -> Unit raise NinjaError {
guard self.lexer.read_ident() is Some(name) else {
raise self.lexer.fail("expected rule name")
}
self.expect_token(Newline)
if self.env.lookup_rule_current_scope(name) is Some(_) {
raise self.lexer.fail("duplicate rule '\{name}'")
}
let rule = Rule::new(name)
while self.lexer.peek_token(Indent) {
let (key, value) = self.parse_let()
if is_reserved_binding(key) {
rule.add_binding(key, value)
} else {
// Rules have no scope of their own.
raise self.lexer.fail("unexpected variable '\{key}'")
}
}
if rule.binding_or_insert("rspfile").is_empty() !=
rule.binding_or_insert("rspfile_content").is_empty() {
raise self.lexer.fail(
"rspfile and rspfile_content need to be both specified",
)
}
if rule.binding_or_insert("command").is_empty() {
raise self.lexer.fail("expected 'command =' line")
}
self.env.add_rule(rule)
}
///|
fn ManifestParser::parse_default(
self : ManifestParser,
) -> Unit raise NinjaError {
let mut eval = self.lexer.read_path()
if eval.is_empty() {
raise self.lexer.fail("expected target name")
}
while !eval.is_empty() {
let path = eval.evaluate(self.env)
if path == "" {
raise self.lexer.fail("empty path")
}
let (path, _) = canonicalize_path(path, platform=self.state.platform)
self.state.add_default(path) catch {
error => raise self.lexer.fail(error.message())
}
eval = self.lexer.read_path()
}
self.expect_token(Newline)
}
///|
/// Reads paths until an empty one.
fn ManifestParser::read_paths(
self : ManifestParser,
into : Array[EvalString],
) -> Int32 raise NinjaError {
let mut count = 0
while true {
let path = self.lexer.read_path()
if path.is_empty() {
break
}
into.push(path)
count += 1
}
count
}
///|
fn ManifestParser::canonical(
self : ManifestParser,
eval : EvalString,
env : BindingEnv,
) -> (String, UInt64) raise NinjaError {
let path = eval.evaluate(env)
if path == "" {
raise self.lexer.fail("empty path")
}
canonicalize_path(path, platform=self.state.platform)
}
///|
fn ManifestParser::parse_edge(self : ManifestParser) -> Unit raise NinjaError {
let outs : Array[EvalString] = []
let ins : Array[EvalString] = []
let validations : Array[EvalString] = []
ignore(self.read_paths(outs))
let implicit_outs = if self.lexer.peek_token(Pipe) {
self.read_paths(outs)
} else {
0
}
if outs.is_empty() {
raise self.lexer.fail("expected path")
}
self.expect_token(Colon)
guard self.lexer.read_ident() is Some(rule_name) else {
raise self.lexer.fail("expected build command name")
}
guard self.env.lookup_rule(rule_name) is Some(rule) else {
raise self.lexer.fail("unknown build rule '\{rule_name}'")
}
ignore(self.read_paths(ins))
let implicit = if self.lexer.peek_token(Pipe) {
self.read_paths(ins)
} else {
0
}
let order_only = if self.lexer.peek_token(Pipe2) {
self.read_paths(ins)
} else {
0
}
if self.lexer.peek_token(PipeAt) {
ignore(self.read_paths(validations))
}
self.expect_token(Newline)
// Bindings on edges are rare; only then does the edge get its own scope.
let mut has_indent = self.lexer.peek_token(Indent)
let env = if has_indent { BindingEnv::new(parent=self.env) } else { self.env }
while has_indent {
let (key, value) = self.parse_let()
env.add_binding(key, value.evaluate(self.env))
has_indent = self.lexer.peek_token(Indent)
}
let edge = self.state.add_edge(rule)
edge.env = env
let pool_name = edge.get_binding("pool")
if pool_name != "" {
guard self.state.lookup_pool(pool_name) is Some(pool) else {
raise self.lexer.fail("unknown pool name '\{pool_name}'")
}
edge.pool = pool
}
for out in outs {
let (path, slash_bits) = self.canonical(out, env)
self.state.add_out(edge, path, slash_bits) catch {
error => raise self.lexer.fail(error.message())
}
}
if edge.outputs.is_empty() {
// Every output is produced by another edge already; drop this one
// before connecting its inputs.
ignore(self.state.edges.pop())
return
}
edge.implicit_outs = implicit_outs
for input in ins {
let (path, slash_bits) = self.canonical(input, env)
self.state.add_in(edge, path, slash_bits)
}
edge.implicit_deps = implicit
edge.order_only_deps = order_only
for validation in validations {
let (path, slash_bits) = self.canonical(validation, env)
self.state.add_validation(edge, path, slash_bits)
}
if self.options.phony_cycle_action is Warn &&
edge.maybe_phonycycle_diagnostic() {
// The output keeps the edge among its out-edges, as in ninja.
let out = edge.outputs[0]
let before = edge.inputs.length()
edge.inputs.retain(fn(node) { !physical_equal(node, out) })
if edge.inputs.length() != before && !self.quiet {
self.warnings.push(
"phony target '\{out.path}' names itself as an input; ignoring [-w phonycycle=warn]",
)
}
}
// A dyndep file is loaded later, but it must be one of the inputs.
let dyndep = edge.get_unescaped_dyndep()
if dyndep != "" {
let (path, slash_bits) = canonicalize_path(
dyndep,
platform=self.state.platform,
)
let node = self.state.get_node(path, slash_bits)
node.dyndep_pending = true
edge.dyndep = Some(node)
if !edge.inputs.iter().any(fn(input) { physical_equal(input, node) }) {
raise self.lexer.fail("dyndep '\{path}' is not an input")
}
}
}
///|
fn ManifestParser::parse_file_include(
self : ManifestParser,
new_scope : Bool,
) -> Unit raise NinjaError {
let eval = self.lexer.read_path()
let path = eval.evaluate(self.env)
let env = if new_scope { BindingEnv::new(parent=self.env) } else { self.env }
self.subparser(env).load(path, parent=self.lexer)
self.expect_token(Newline)
}