dymokomi/luce-geocore
Source of release 0.7.8
0.7.8 / src / script_host / scan.lucb
# What the editor reads from a script's text without compiling it: the spare parameters
# its literal calls name (`k.f32("height", 0.3)` makes a row starting at 0.3, as in the Code
# node), and whether it reads the timeline. `k` is whatever `cook` calls its parameter.
# Comments and strings are skipped; a call whose name is not a literal makes a note.
## One spare parameter of a script's text.
struct Scanned:
var label: str
## f32, f64, i32, toggle, vec3, color, menu, text, file, ramp or ramp_color.
var kind: str
var components: i64
var defaults: f64[4]
var text: str
var choices: str
## A note at a line: a parameter call the scan could not read.
struct Note:
var line: i64
var text: str
## The parameters and time use of a script's text, for the node's rows.
pub struct ScriptText:
var found: Growing[Scanned]
var notes: Growing[Note]
var time_used: bool
## Scan `text` (a whole Script node module).
pub static func scan(text: str) -> interop.Reference[ScriptText]!:
let storage = try new ScriptText[1] --- in memory.heap
storage[0] = ScriptText(found = Growing[Scanned](), notes = Growing[Note](), time_used = false)
storage[0].read(text) catch failure:
storage[0].close()
free(storage) in memory.heap
error(failure.code, failure.message)
return try interop.Reference[ScriptText].adopt(storage.data, script_text_type, memory.heap)
## Whether it reads k.frame(), k.time() or k.fps().
pub func reads_time() -> bool:
return self.time_used
pub func parameter_count() -> i64:
return (i64)self.found.count
pub func parameter_name(index: i64) -> str:
return self.at(index).label
## f32, f64, i32, toggle, vec3, color, menu, text, file, ramp or ramp_color.
pub func parameter_kind(index: i64) -> str:
return self.at(index).kind
## Numbers the parameter holds (0 for text and file, 1 or 3 otherwise).
pub func parameter_components(index: i64) -> i64:
return self.at(index).components
## Component `component`'s default.
pub func parameter_default(index: i64, component: i64) -> f64:
if component < 0 or component > 3: return 0.0
return self.at(index).defaults[(usize)component]
## A text or file parameter's default.
pub func parameter_text(index: i64) -> str:
return self.at(index).text
## A menu's choices, "Low|Medium|High".
pub func parameter_choices(index: i64) -> str:
return self.at(index).choices
pub func note_count() -> i64:
return (i64)self.notes.count
pub func note_line(index: i64) -> i64:
return self.notes.items[(usize)index].line
pub func note(index: i64) -> str:
return self.notes.items[(usize)index].text
pub func close():
for scanned in self.found.view():
release_text(scanned.label)
release_text(scanned.text)
release_text(scanned.choices)
self.found.close()
self.notes.close()
func at(index: i64) -> const Scanned*:
if index < 0 or (usize)index >= self.found.count: trap("parameter index out of range")
return &self.found.items[(usize)index]
func read(text: str) -> !:
let k = cook_parameter(text)
var reader = Reader(text = text, at = 0, line = 1)
while reader.at < text.length:
let byte = text.bytes[reader.at]
if byte == '#':
reader.skip_line()
elif byte == '"' or byte == '\'':
reader.skip_string()
elif is_word_byte(byte):
let start = reader.at
let word = reader.word()
let follows_dot = start > 0 and text.bytes[start - 1] == '.'
if word == k and not follows_dot and reader.peek() == '.':
reader.at += 1
let member = reader.word()
reader.spaces()
if reader.peek() == '(':
reader.at += 1
try self.call(&reader, member)
else:
if byte == '\n': reader.line += 1
reader.at += 1
## A `k.member(` call, the reader just past its parenthesis.
func call(reader: Reader*, member: str) -> !:
if member == "frame" or member == "time" or member == "fps":
self.time_used = true
return
let kind = parameter_kind_of(member) else return
let line = reader.line
reader.spaces()
let named = reader.literal_text()
if named == none:
try self.notes.push(Note(line = line, text = "a parameter's name must be a literal string to make a row"))
return
let label = named else return
var scanned = Scanned(label = try heap_text(label), kind = kind, components = 0, defaults = [0.0, 0.0, 0.0, 0.0], text = "", choices = "")
if kind == "vec3" or kind == "color": scanned.components = 3
elif kind == "text" or kind == "file": scanned.components = 0
else: scanned.components = 1
if kind == "ramp" or kind == "ramp_color":
scanned.components = 0
elif reader.comma():
if kind == "menu":
if let choices = reader.literal_text(): scanned.choices = try heap_text(choices)
if reader.comma(): scanned.defaults[0] = reader.number()
elif kind == "text" or kind == "file":
if let given = reader.literal_text(): scanned.text = try heap_text(given)
elif kind == "vec3" or kind == "color":
reader.vector(&scanned.defaults)
elif kind == "toggle":
scanned.defaults[0] = 1.0 if reader.word() == "true" else 0.0
else:
scanned.defaults[0] = reader.number()
# A name met again keeps its first row.
for earlier in self.found.view():
if earlier.label == label:
release_text(scanned.label)
release_text(scanned.text)
release_text(scanned.choices)
return
try self.found.push(scanned)
## script_text_type: ScriptText's interop type, for luced-3d.
pub let script_text_type: interop.Type[ScriptText] = interop.Type[ScriptText]("ScriptText", ScriptText.close, closeable = true)
## The kind of row `k.member` makes, or none when it makes none.
func parameter_kind_of(member: str) -> str?:
for kind in ["f32", "f64", "i32", "toggle", "vec3", "color", "menu", "text", "file", "ramp", "ramp_color"]:
if member == kind: return kind
return none
## The name `cook` gives its first parameter ("k" when there is no cook).
func cook_parameter(text: str) -> str:
let at = strings.find(text, "func cook(") else return "k"
var end = at + 10
while end < text.length and text.bytes[end] == ' ': end += 1
let start = end
while end < text.length and is_word_byte(text.bytes[end]): end += 1
return (str)text.bytes[start..<end] if end > start else "k"
func is_word_byte(byte: u8) -> bool:
return (byte >= 'a' and byte <= 'z') or (byte >= 'A' and byte <= 'Z') or (byte >= '0' and byte <= '9') or byte == '_'
## A cursor over a script's text, counting lines.
struct Reader:
var text: str
var at: usize
var line: i64
func peek() -> u8:
return self.text.bytes[self.at] if self.at < self.text.length else 0
func spaces():
while self.at < self.text.length:
let byte = self.text.bytes[self.at]
if byte == '\n': self.line += 1
elif byte != ' ' and byte != '\t' and byte != '\r': return
self.at += 1
func skip_line():
while self.at < self.text.length and self.text.bytes[self.at] != '\n': self.at += 1
func skip_string():
let quote = self.text.bytes[self.at]
self.at += 1
while self.at < self.text.length:
let byte = self.text.bytes[self.at]
self.at += 1
if byte == '\\': self.at += 1
elif byte == quote or byte == '\n': return
func word() -> str:
let start = self.at
while self.at < self.text.length and is_word_byte(self.text.bytes[self.at]): self.at += 1
return (str)self.text.bytes[start..<self.at]
## A plain string literal's contents (no escapes), or none (the cursor left as it was).
func literal_text() -> str?:
self.spaces()
if self.peek() != '"': return none
let start = self.at + 1
var end = start
while end < self.text.length and self.text.bytes[end] != '"':
if self.text.bytes[end] == '\\' or self.text.bytes[end] == '\n': return none
end += 1
if end >= self.text.length: return none
self.at = end + 1
return (str)self.text.bytes[start..<end]
## Past a comma (true), or at something else (false).
func comma() -> bool:
self.spaces()
if self.peek() != ',': return false
self.at += 1
self.spaces()
return true
## A number literal, a leading cast such as (f32) and a sign allowed; 0 when there is none.
func number() -> f64:
self.spaces()
if self.peek() == '(':
let before = self.at
self.at += 1
_ = self.word()
if self.peek() == ')': self.at += 1
else: self.at = before
let start = self.at
if self.peek() == '-' or self.peek() == '+': self.at += 1
while self.at < self.text.length:
let byte = self.text.bytes[self.at]
let exponent_sign = (byte == '-' or byte == '+') and self.at > start and (self.text.bytes[self.at - 1] == 'e' or self.text.bytes[self.at - 1] == 'E')
if not ((byte >= '0' and byte <= '9') or byte == '.' or byte == 'e' or byte == 'E' or byte == '_' or exponent_sign): break
self.at += 1
return strings.parse_f64((str)self.text.bytes[start..<self.at]) catch failure: recover 0.0
## A vector literal [x, y, z(, w)] into `out`.
func vector(out: f64[4]*):
self.spaces()
if self.peek() != '[': return
self.at += 1
for index in 0..<(usize)4:
(*out)[index] = self.number()
self.spaces()
if self.peek() != ',': break
self.at += 1
## A heap copy of `text` (empty text owns nothing).
func heap_text(text: str) -> str!:
if text.length == 0: return ""
with memory.heap:
return try strings.copy(text)
## Give back a heap_text copy.
func release_text(text: str):
if text.length == 0: return
with memory.heap:
strings.release(text)