///|
fn reference_part(value : StringView) -> Bool {
if value.is_empty() {
return false
}
for i in 0.. Bool {
!value.is_empty() && ascii_word(value[0]) && reference_part(value)
}
///|
fn valid_spdx_id(value : StringView, exception : Bool) -> Bool {
if value == "AND" || value == "OR" || value == "WITH" {
return false
}
if !exception && value.has_prefix("DocumentRef-") {
return match value.split_once(":") {
Some((doc, license)) =>
reference_part(doc[12:]) && license.has_prefix("LicenseRef-") &&
reference_part(license[11:])
None => false
}
}
if value.has_prefix("LicenseRef-") {
return !exception && reference_part(value[11:])
}
if !exception && value.has_suffix("+") {
valid_id_part(value[:value.length() - 1])
} else {
valid_id_part(value)
}
}
///|
fn expression_end(
tokens : Array[StringView],
first : Int32,
depth : Int32,
check : (Int32, Bool) -> Unit,
) -> Int32 {
if depth > 16 {
return -1
}
let mut i = first
for ;; {
match tokens.get(i) {
Some("(") => {
i = expression_end(tokens, i + 1, depth + 1, check)
if i < 0 || tokens.get(i) != Some(")") {
return -1
}
i += 1
}
Some(id) if valid_spdx_id(id, false) => {
check(i, false)
i += 1
if tokens.get(i) == Some("WITH") {
match tokens.get(i + 1) {
Some(exception) if valid_spdx_id(exception, true) => {
check(i + 1, true)
i += 2
}
_ => return -1
}
}
}
_ => return -1
}
match tokens.get(i) {
Some("AND") | Some("OR") => i += 1
_ => return i
}
}
}
///|
fn spdx_parse(text : StringView, checked : Bool) -> (String?, Array[String]) {
if text.is_empty() || text.length() > 512 {
return (None, ["invalid_spdx_label"])
}
let tokens : Array[StringView] = []
let mut start = 0
for i in 0.. Unit {
if !flags.contains(reason) { flags.push(reason) }
}
fn check(i : Int32, exception : Bool) -> Unit {
if !checked { return }
let token = tokens[i]
if !exception && (token.has_prefix("LicenseRef-") || token.has_prefix("DocumentRef-")) {
flag("unresolved_license_ref")
return
}
let plus = token.has_suffix("+")
let name = if plus { token[:token.length() - 1] } else { token }
match @spdx_catalog.lookup(name, exception) {
Some((name, deprecated)) => {
if deprecated { flag("deprecated_spdx_id") }
canonical[i] = if plus { name + "+" } else { name }
}
None => flag("unknown_spdx_id")
}
}
if expression_end(tokens, 0, 0, check) != tokens.length() {
return (None, ["invalid_spdx_label"])
}
if flags.contains("unknown_spdx_id") {
return (None, flags)
}
let output = StringBuilder()
for i, token in tokens {
if i > 0 && tokens[i - 1] != "(" && token != ")" {
output.write_char(' ')
}
match canonical.get(i) {
Some(value) => output.write_string(value)
None => output.write_stringview(token)
}
}
let normalized = output.to_string()
if normalized.length() <= 512 {
(Some(normalized), flags)
} else {
(None, ["invalid_spdx_label"])
}
}
///|
fn spdx_expression(text : StringView) -> String? {
// Previously serialized reports can be parsed without applying today's catalog.
spdx_parse(text, false).0
}
///|
fn spdx_labels(text : String) -> (Array[Match], Array[String], Bool) {
let labels : Array[Match] = []
let flags : Array[String] = []
let mut complete = true
let marker = "SPDX-License-Identifier:"
each_line(text, (line, raw) => {
let mut value = if line == 1 && raw.has_prefix("\u{FEFF}") {
raw[1:].trim()
} else {
raw.trim()
}
for prefix in ["//", "/*", "", "*)"] {
if value.has_suffix(suffix) {
value = value[:value.length() - suffix.length()].trim()
break
}
}
let (expression, warnings) = spdx_parse(value, true)
for warning in warnings {
if !flags.contains(warning) { flags.push(warning) }
}
if expression is Some(expression) {
if labels.length() < 256 {
labels.push({
expression,
kind: "spdx",
rule_id: "spdx-label",
start_line: line,
end_line: line,
start_word: -1,
end_word: -1,
})
} else {
complete = false
}
}
}
})
(labels, flags, complete)
}