diff options
Diffstat (limited to 'nomnom/code_obj.nom')
| -rw-r--r-- | nomnom/code_obj.nom | 269 |
1 files changed, 117 insertions, 152 deletions
diff --git a/nomnom/code_obj.nom b/nomnom/code_obj.nom index 8379f36..c8d2784 100644 --- a/nomnom/code_obj.nom +++ b/nomnom/code_obj.nom @@ -2,103 +2,89 @@ # This file contains objects that are used to track code positions and incrementally build up generated code, while keeping track of where it came from, and managing indentation levels. -use "lib/object.nom" +use "lib/things.nom" -object (Hole): - externally (Hole from %lua) means: - return (Hole {lua:%lua}) - my action [as lua]: return %me.lua - my action [as nomsu]: - return "(Hole {lua:\(%me.lua)})" - my action [as text]: - barf "Not implemented" - my action [as smext]: - barf "Must fill in holes before smexting" +a (Code Buffer) is a thing: + that can (set up) by: + assume %its.source + %old_bits = (%its.bits if (%its.bits is a "List") else [%its.bits]) + %its.bits = [] + if (type of %its.source) is: + "Text": + %its.source = (Source from text %its.source) + "Syntax Tree": + %its.source = %its.source.source -object (Code): - my action [set up]: - assume %me.source - %old_bits = (%me.bits if (%me.bits is a "List") else [%me.bits]) - %me.bits = [] - if (%me.source is text): - %me.source = (Source from text %me.source) - for % in %old_bits: %me::add % - - my action [as text]: - barf "Not implemented" - my action [as smext]: - if (%me.__str == (nil)): - set {%buff:[], %indent:0} - for %bit in %me.bits: + for % in %old_bits: %its::add % + + whose (text) means: + if (%its._text == (nil)): + %buff = [] + %indent = 0 + for %bit in %its.bits: if (%bit is text): %spaces = (%bit::matching "\n([ ]*)[^\n]*$") if %spaces: %indent = (size of %spaces.1) ..else: - %bit = (%bit::as smext) + %bit = (%bit::text) if (%indent > 0): %bit = (%bit::with "\n" -> "\n\(" "::* %indent)") - %buff::add %bit - - %me.__str = (%buff::joined) - - return %me.__str - - my action [as lua]: - barf - return "\ - ..\(%me.class.name::as lua id)_from_1_2(\(..) - (%me.source::as lua) if %me.source else "nil" - .., \(%me.bits::as lua))" - - my action [as nomsu] "\ - ..(\(%me.class.name) \((%me.source::as nomsu) if %me.source else "(nil)") \(..) - %me.bits::as nomsu - ..)" - - my action [size] (size of (%me::as smext)) - my action [mark as dirty]: - %me.__str = (nil) - %me._trailing_line_len = (nil) - %me._num_lines = (nil) - - my action [add %new_bits]: + %its._text = (%buff::joined) + return %its._text + + whose (lua code) means "\ + ..a_\(%its.class.name::as lua id)_with{source=\(..) + (%its.source::as lua) if %its.source else "nil" + .., \(%its.bits::as lua)}" + + whose (nomsu code) means "\ + ..(a \(%its.class.name) with {source: \((%its.source::as nomsu) if %its.source else "(nil)"), bits: \(..) + %its.bits::as nomsu + ..})" + + whose (size) means (size of (%its::text)) + + that can (mark as dirty) by: + %its._text = (nil) + %its._trailing_line_len = (nil) + %its._num_lines = (nil) + + that can (add %new_bits) by: unless (%new_bits is a "List"): %new_bits = [%new_bits] for % in %new_bits: if (% == ""): do next % - #if ((% isn't text) and (% isn't a (Code))): % = (%::as lua) - %me.bits::add % - - %me::mark as dirty + %its.bits::add % + %its::mark as dirty - my action [trailing line length]: - if (%me._trailing_line_len == (nil)): - %me._trailing_line_len = (size of ((%me::as smext)::matching "[^\n]*$")) - return %me._trailing_line_len + whose (trailing line length) means: + if (%its._trailing_line_len == (nil)): + %its._trailing_line_len = (size of ((%its::text)::matching "[^\n]*$")) + return %its._trailing_line_len - my action [number of lines]: - unless %me._num_lines: + whose (number of lines) means: + unless %its._num_lines: %num_lines = 1 - for % in %me: + for % in %its: if (% is text): %num_lines += (size of (%::all matches of "\n")) ..else: %num_lines += ((%::number of lines) - 1) - %me._num_lines = %num_lines + %its._num_lines = %num_lines - return %me._num_lines + return %its._num_lines - my action [is multiline, is multi-line] ((%me::number of lines) > 1) - my action [is one line, is single line] ((%me::number of lines) == 1) - my action [add %values joined with %joiner]: - %me::add %values joined with %joiner or %joiner - my action [add %values joined with %joiner or %wrapping_joiner]: + whose [is multiline, is multi-line] all mean ((%its::number of lines) > 1) + whose [is one line, is single line] all mean ((%its::number of lines) == 1) + that can (add %values joined with %joiner) by: + %its::add %values joined with %joiner or %joiner + that can [add %values joined with %joiner or %wrapping_joiner] by: %line_len = 0 - %bits = %me.bits + %bits = %its.bits for %value in %values at %i: if (%i > 1): if (%line_len > 80): @@ -108,65 +94,71 @@ object (Code): %bits::add %value unless (%value is text): - %value = (%value::as smext) + %value = (%value::text) %line = (%value::matching "\n([^\n]*)$") if %line: %line_len = (size of %line) ..else: %line_len += (size of %value) - - %me::mark as dirty + %its::mark as dirty - my action [prepend %]: - #if ((% isn't text) and (% isn't a %me.__type)): + that can (prepend %) by: + #if ((% isn't text) and (% isn't a %its.__type)): % = (%::as lua) - %me.bits::add % at index 1 - %me::mark as dirty + %its.bits::add % at index 1 + %its::mark as dirty - my action [parenthesize]: - %me.bits::add "(" at index 1 - %me.bits::add ")" - %me::mark as dirty + that can (parenthesize) by: + %its.bits::add "(" at index 1 + %its.bits::add ")" + %its::mark as dirty -object (Lua Code) extends (Code): - my action [add free vars %vars]: +a (Lua Buffer) is a thing: + that has [..] + text, lua code, nomsu code, trailing line length, size, number of lines, + is multiline, is multi-line, is one line, is single line, + ..like a (Code Buffer) + that can [..] + set up, mark as dirty, add %, prepend %, parenthesize, + add % joined with %, add % joined with % or %, + ..like a (Code Buffer) + + that can (add free vars %vars) by: if ((size of %vars) == 0): return - %seen = (%v = (yes) for %v in %me.free_vars) + %seen = (%v = (yes) for %v in %its.free_vars) for %var in %vars: assume (%var is text) unless %seen.%var: - %me.free_vars::add %var + %its.free_vars::add %var %seen.%var = (yes) - %me::mark as dirty + %its::mark as dirty - my action [remove free vars %vars]: + that can (remove free vars %vars) by: if ((size of %vars) == 0): return %removals = {} for %var in %vars: assume (%var is text) %removals.%var = (yes) - %stack = [%me] + %stack = [%its] repeat while ((size of %stack) > 0): %lua = (%stack::pop) for %i in (size of %lua.free_vars) to 1 by -1: if %removals.(%lua.free_vars.%i): - lua> "table.remove(\%lua.free_vars, \%i)" - #TODO: reinstate this - #%lua.free_vars::remove at index %i - + %lua.free_vars::remove at index %i for % in %lua.bits: unless (% is text): %stack::add % - %me::mark as dirty + %its::mark as dirty - my action [declare locals] (%me::declare locals (nil)) - my action [declare locals %to_declare]: + that can (declare locals) by (%its::declare locals (nil)) + that can (declare locals %to_declare) by: unless %to_declare: - set {%to_declare:[], %seen:{}} - for %lua in recursive %me: + %to_declare = [] + %seen = {} + for %lua in recursive %its: for %var in %lua.free_vars: unless %seen.%var: %seen.%var = (yes) @@ -176,70 +168,43 @@ object (Lua Code) extends (Code): unless (% is text): recurse %lua on % if ((size of %to_declare) > 0): - %me::remove free vars %to_declare - %me::prepend "local \(%to_declare::joined with ", ");\n" + %its::remove free vars %to_declare + %its::prepend "local \(%to_declare::joined with ", ");\n" return %to_declare - my action [as statements] (%me::as statements "" ";") - my action [as statements %prefix] (%me::as statements %prefix ";") - my action [as statements %prefix %suffix]: - unless %me.is_value: return %me - %statements = (Lua Code from %me.source []) + whose (as statements) means (%its::as statements with "") + whose (as statements with %prefix) means: + unless %its.is_value: return %its + %statements = (a Lua Buffer with {source:%its.source}) if ((%prefix or "") != ""): %statements::add %prefix - %statements::add %me - if (%suffix != ""): - %statements::add (%suffix or ";") + %statements::add %its + %statements::add ";" return %statements - my action [variables]: + that can (mark as value) by: + %its.is_value = (yes) + + that can (mark as variable) by: + %its.is_variable = (yes) + %its.is_value = (yes) + + that can (variables) by: %vars = [] - for %code in recursive %me: + for %code in recursive %its: if %code.is_variable: - %vars::add (%code::as smext) + %vars::add (%code::text) for % in %code.bits: unless (% is text): recurse %code on % return %vars - externally (Lua Code from %source %bits) means: - assume %source - unless (%bits is a "List"): %bits = [%bits] - if (%source is a "Syntax Tree"): - %source = %source.source - return (Lua Code {source:%source, bits:%bits, is_value:no, free_vars:[]}) - - externally (Lua Code from %source) means (Lua Code from %source []) - externally (Lua Value from %source %bits) means: - assume %source - unless (%bits is a "List"): %bits = [%bits] - if (%source is a "Syntax Tree"): - %source = %source.source - return (Lua Code {source:%source, bits:%bits, is_value:yes, free_vars:[]}) - - externally (Lua Value from %source) means (Lua Value from %source []) - externally (Lua Variable from %source) means (Lua Variable from %source []) - externally (Lua Variable from %source %bits) means: - assume %source - unless (%bits is a "List"): %bits = [%bits] - if (%source is a "Syntax Tree"): - %source = %source.source - return (..) - Lua Code {..} - source:%source, bits:%bits, is_value:yes, is_variable:yes, free_vars:[] - -# TODO: remove this shim -(Lua Code).add_free_vars = (Lua Code).add_free_vars_1 -(Lua Code).remove_free_vars = (Lua Code).remove_free_vars_1 -(Lua Code).declare_locals = (Lua Code).declare_locals_1 -(Lua Code).as_statements = (Lua Code).as_statements_1_2 -object (Nomsu Code) extends (Code): - externally (Nomsu Code from %source %bits) means: - if (%bits is text): %bits = [%bits] - if (%source is a "Syntax Tree"): - %source = %source.source - return (Nomsu Code {source:%source, bits:%bits}) - - externally (Nomsu Code from %source) means (Nomsu Code from %source []) - externally (Nomsu Code %bits) means (Nomsu Code from (nil) %bits) - externally (Nomsu Code) means (Nomsu Code from (nil) []) +a (Nomsu Buffer) is a thing: + that has [..] + text, lua code, nomsu code, trailing line length, size, number of lines, + is multiline, is multi-line, is one line, is single line, + ..like a (Code Buffer) + that can [..] + set up, mark as dirty, add %, prepend %, parenthesize, + add % joined with %, add % joined with % or %, + ..like a (Code Buffer) |