From: Alexis Laferrière Date: Mon, 3 Feb 2014 03:13:45 +0000 (-0500) Subject: contrib: bring in the pep8 analysis framework X-Git-Tag: v0.6.6~129^2~18 X-Git-Url: http://nitlanguage.org contrib: bring in the pep8 analysis framework Signed-off-by: Alexis Laferrière --- diff --git a/contrib/pep8analysis/Makefile b/contrib/pep8analysis/Makefile new file mode 100644 index 0000000..7d05a20 --- /dev/null +++ b/contrib/pep8analysis/Makefile @@ -0,0 +1,11 @@ +bin/pep8analysis: + mkdir -p bin + ../../bin/nitg --global -o bin/pep8analysis -I lib src/pep8analysis.nit + +doc/index.html: + ../../bin/nitdoc -I lib src/pep8analysis.nit + +tests: bin/pep8analysis + bin/pep8analysis --cfg-long tests/privat/*.pep tests/laf/*.pep tests/terrasa/*.pep + +.PHONY: bin/pep8analysis tests doc/index.html diff --git a/contrib/pep8analysis/README.md b/contrib/pep8analysis/README.md new file mode 100644 index 0000000..216b878 --- /dev/null +++ b/contrib/pep8analysis/README.md @@ -0,0 +1,37 @@ +# Pep/8 Analysis + +This project provides tools to statically analyze Pep/8 programs in order to detect bugs or bad programming practices. + +For more information about the Pep/8 assembly language visit http://code.google.com/p/pep8-1/. + +# Installation + +Make sure you have a Nit compiler installed (http://nitlanguage.org) and the environment variable NIT\_DIR correctly set to the Nit installation directory. + +Clone the source from http://github.com/xymus/pep8analysis.git and compile with `make`. + +# Usage + +For basic results, execute on the Pep/8 program prog.pep with `bin/pep8analyzer prog.pep`. + +Call `bin/pep8analyer --help` for a description of the available (and up to date) options. + +The tools provides its results in two ways, the final report and an annotated CFG (usually created in the out directory). + +# Analyses + +## Dead code and possible execution of data + +The tools analyses statically the program according to possbile branches and function calls to find wrongfully placed instructions and directives. It reports dead code blocks and possibly executed data blocks. + +## Range analysis + +The range analysis reports the value of registers and memory on the annotated CFG. + +## Reaching definitions + +The reaching definitions analysis tracks what lines may have assigned values to register and memory. Its results are on the anotated CFG. They can be used to better understand a program. + +## Types analysis + +The types analysis detects wrongful use of types or of uninitialized data. It reports possible errors in the final report. diff --git a/contrib/pep8analysis/src/ast/ast.nit b/contrib/pep8analysis/src/ast/ast.nit new file mode 100644 index 0000000..2626881 --- /dev/null +++ b/contrib/pep8analysis/src/ast/ast.nit @@ -0,0 +1,4 @@ +import rich_instructions +import suffixed_instructions +import pretty_instructions + diff --git a/contrib/pep8analysis/src/ast/ast_base.nit b/contrib/pep8analysis/src/ast/ast_base.nit new file mode 100644 index 0000000..7054d29 --- /dev/null +++ b/contrib/pep8analysis/src/ast/ast_base.nit @@ -0,0 +1,24 @@ +import backbone +import parser + +redef class AnalysisManager + fun build_ast( filename : String ) : nullable AListing + do + var file = new IFStream.open( filename ) + + var source = new SourceFile(filename, file) + var lexer = new Lexer(source) + var parser = new Parser(lexer) + var node_tree = parser.parse + + var ast = node_tree.n_base + if ast == null then + var err = node_tree.n_eof + assert err isa AError + print "error at {err.location}: {err.message}" + return null + end + + return ast + end +end diff --git a/contrib/pep8analysis/src/ast/pretty_instructions.nit b/contrib/pep8analysis/src/ast/pretty_instructions.nit new file mode 100644 index 0000000..1a49886 --- /dev/null +++ b/contrib/pep8analysis/src/ast/pretty_instructions.nit @@ -0,0 +1,93 @@ +module pretty_instructions + +import ast_base +import rich_instructions + +redef class AnalysisManager + var opt_ast = new OptionBool("Print the AST","--ast") + + redef init + do + super + opts.add_option(opt_ast) + end + + redef fun build_ast(filename) + do + var ast = super + + if ast != null and opt_ast.value then + var printer = new ASTPrinter + printer.enter_visit(ast) + print printer.str + end + + return ast + end +end + +class ASTPrinter + super Visitor + + var str writable = "" + + init do end + redef fun visit(n) do n.accept_ast_printer(self) +end + +redef class ANode + fun accept_ast_printer(v: ASTPrinter) do visit_all(v) +end + +redef class Token + redef fun to_s do return text + redef fun accept_ast_printer(v: ASTPrinter) do v.str += self.to_s # + " " +end + +redef class TId + redef fun accept_ast_printer(v: ASTPrinter) + do + var len = self.to_s.length + if len < 6 and len > 1 then + v.str += self.to_s + " "*(6-len) + else + v.str += self.to_s + end + end +end + +redef class ANonEmptyLine + redef fun accept_ast_printer(v: ASTPrinter) + do + if n_label_decl == null then v.str += once " "*10 + visit_all(v) + end +end + +redef class AInstruction + redef fun accept_ast_printer(v: ASTPrinter) + do + var pre_size = v.str.length + visit_all(v) + var post_size = v.str.length + var diff_size = post_size - pre_size + if diff_size < 20 then v.str += " "*(20-diff_size) + end +end + +redef class ALabelDecl + redef fun accept_ast_printer(v: ASTPrinter) + do + var text = n_id.text + ":" + v.str += text + " "*(10-text.length) + end +end + +redef class ALine + fun text: String + do + var p = new ASTPrinter + p.enter_visit( self ) + return p.str + end +end diff --git a/contrib/pep8analysis/src/ast/rich_instructions.nit b/contrib/pep8analysis/src/ast/rich_instructions.nit new file mode 100644 index 0000000..22f3b87 --- /dev/null +++ b/contrib/pep8analysis/src/ast/rich_instructions.nit @@ -0,0 +1,391 @@ +# Pep/8 instructions are not reserved as keywords. It is common +# that the identifier of an instruction will be used for a label. +# For this reason, we cannot create precise instruction nodes with +# the parser. +# +# This module manually creates the expected subclass with an additionnal +# OOP hiearchy. + +module rich_instructions + +import backbone +intrude import parser +import ast_base + +redef class AnalysisManager + redef fun build_ast(filename) + do + var ast = super + if ast != null then + #fun enrich_ast( ast : AListing ) do + for line in ast.n_lines do + if line isa AInstructionLine then + line.enrich + end + end + end + return ast + end +end + +redef class AInstructionLine + # TODO move to AnalysisManager as private? + private fun enrich + do + var instr = n_instruction + var new_instr : AInstruction + + var id = instr.n_id.text.to_upper + if instr isa ABinaryInstruction then + if id == "BR" then + new_instr = new ABrInstruction.from(instr) + else if id == "BRLE" then + new_instr = new ABrleInstruction.from(instr) + else if id == "BRLT" then + new_instr = new ABrltInstruction.from(instr) + else if id == "BREQ" then + new_instr = new ABreqInstruction.from(instr) + else if id == "BRNE" then + new_instr = new ABrneInstruction.from(instr) + else if id == "BRGE" then + new_instr = new ABrgeInstruction.from(instr) + else if id == "BRGT" then + new_instr = new ABrgtInstruction.from(instr) + else if id == "BRV" then + new_instr = new ABrvInstruction.from(instr) + else if id == "BRC" then + new_instr = new ABrcInstruction.from(instr) + else if id == "CALL" then + new_instr = new ACallInstruction.from(instr) + else if id == "NOP" then + new_instr = new ABinaryNopInstruction.from(instr) + else if id == "DECI" then + new_instr = new ADeciInstruction.from(instr) + else if id == "DECO" then + new_instr = new ADecoInstruction.from(instr) + else if id == "STRO" then + new_instr = new AStroInstruction.from(instr) + else if id == "CHARI" then + new_instr = new AChariInstruction.from(instr) + else if id == "CHARO" then + new_instr = new ACharoInstruction.from(instr) + else if id == "ADDSP" then + new_instr = new AAddspInstruction.from(instr) + else if id == "SUBSP" then + new_instr = new ASubspInstruction.from(instr) + else if id.has_prefix("ADD") then + new_instr = new AAddInstruction.from(instr) + else if id.has_prefix("SUB") then + new_instr = new ASubInstruction.from(instr) + else if id.has_prefix("AND") then + new_instr = new AAndInstruction.from(instr) + else if id.has_prefix("OR") then + new_instr = new AOrInstruction.from(instr) + else if id.has_prefix("CP") then + new_instr = new ACpInstruction.from(instr) + else if id.has_prefix("LDBYTE") then + new_instr = new ALdbyteInstruction.from(instr) + else if id.has_prefix("LD") then + new_instr = new ALdInstruction.from(instr) + else if id.has_prefix("STBYTE") then + new_instr = new AStbyteInstruction.from(instr) + else if id.has_prefix("ST") then + new_instr = new AStInstruction.from(instr) + else + # error + print "error {instr.location}: invalid instruction {id} with data access" + abort + end + else if instr isa AUnaryInstruction then + if id == "STOP" then + new_instr = new AStopInstruction.from(instr) + else if id == "RETTR" then + new_instr = new ARettrInstruction.from(instr) + else if id == "MOVSPA" then + new_instr = new AMovspaInstruction.from(instr) + else if id == "MOVFLGA" then + new_instr = new AMovflgaInstruction.from(instr) + else if id.has_prefix("NOT") then + new_instr = new ANotInstruction.from(instr) + else if id.has_prefix("NEG") then + new_instr = new ANegInstruction.from(instr) + else if id.has_prefix("ASL") then + new_instr = new AAslInstruction.from(instr) + else if id.has_prefix("ASR") then + new_instr = new AAsrInstruction.from(instr) + else if id.has_prefix("ROL") then + new_instr = new ARolInstruction.from(instr) + else if id.has_prefix("ROR") then + new_instr = new ARorInstruction.from(instr) + else if id.has_prefix("NOP") then + new_instr = new AUnaryNopInstruction.from(instr) + else if id.has_prefix("RET") then + new_instr = new ARetInstruction.from(instr) + else + # error + print "error {instr.location}: invalid instruction {id} without data access" + abort + end + else abort + + # TODO check, one of those 2 might not be necessary + replace_child( instr, new_instr ) + #n_instruction = new_instr + end +end + +# +# Support classes +# +abstract class ARichBinaryInstruction + super ABinaryInstruction + + #redef var n_access : AAccess + #redef var n_id : TId + + init from( src: ABinaryInstruction ) do + _n_operand = src.n_operand + _n_id = src.n_id + location = src.location + parent = src.parent + end +end + +abstract class ARichUnaryInstruction + super AUnaryInstruction + + #redef var n_id : TId + + init from( src: AUnaryInstruction ) do + _n_id = src.n_id + _location = src.location + parent = src.parent + end +end + +# +# Categories +# +abstract class ABranchInstruction + super ARichBinaryInstruction + init from( src ) do super +end + +class ABrInstruction + super ABranchInstruction + init from( src ) do super +end +class ABrleInstruction + super ABranchInstruction + init from( src ) do super +end +class ABrltInstruction + super ABranchInstruction + init from( src ) do super +end +class ABreqInstruction + super ABranchInstruction + init from( src ) do super +end +class ABrneInstruction + super ABranchInstruction + init from( src ) do super +end +class ABrgeInstruction + super ABranchInstruction + init from( src ) do super +end +class ABrgtInstruction + super ABranchInstruction + init from( src ) do super +end +class ABrvInstruction + super ABranchInstruction + init from( src ) do super +end +class ABrcInstruction + super ABranchInstruction + init from( src ) do super +end +class ACallInstruction + super ABranchInstruction + init from( src ) do super +end + + +abstract class ANopInstruction + super AInstruction +end +class ABinaryNopInstruction + super ANopInstruction + super ARichBinaryInstruction + init from( src ) do super +end +class AUnaryNopInstruction + super ANopInstruction + super ARichUnaryInstruction + init from( src ) do super +end + + +abstract class AOutputInstruction + super ARichBinaryInstruction + init from( src ) do super +end +abstract class AInputInstruction + super ARichBinaryInstruction + init from( src ) do super +end +# TODO add category for ADecInstruction? +class ADeciInstruction + super AInputInstruction + init from( src ) do super +end +class ADecoInstruction + super AOutputInstruction + init from( src ) do super +end + +class AStroInstruction + super AOutputInstruction + init from( src ) do super +end + +class AChariInstruction + super AInputInstruction + init from( src ) do super +end +class ACharoInstruction + super AOutputInstruction + init from( src ) do super +end + + +abstract class AStackInstruction + super ARichBinaryInstruction + init from( src ) do super +end +class AAddspInstruction + super AStackInstruction + init from( src ) do super +end +class ASubspInstruction + super AStackInstruction + init from( src ) do super +end + +# Misc +class AStopInstruction + super ARichUnaryInstruction + init from( src ) do super +end + +class ARettrInstruction + super ARichUnaryInstruction + init from( src ) do super +end + +abstract class AMovInstruction + super ARichUnaryInstruction + init from( src ) do super +end +class AMovspaInstruction + super AMovInstruction + init from( src ) do super +end +class AMovflgaInstruction + super AMovInstruction + init from( src ) do super +end + + +class ANotInstruction + super ARichUnaryInstruction + init from( src ) do super +end + +class ANegInstruction + super ARichUnaryInstruction + init from( src ) do super +end + +abstract class AShiftInstruction + super ARichUnaryInstruction + init from( src ) do super +end +class AAslInstruction + super AShiftInstruction + init from( src ) do super +end +class AAsrInstruction + super AShiftInstruction + init from( src ) do super +end +class ARolInstruction + super AShiftInstruction + init from( src ) do super +end +class ARorInstruction + super AShiftInstruction + init from( src ) do super +end + +class ARetInstruction + super ARichUnaryInstruction + init from( src ) do super +end + + +# TODO find a better name +abstract class AArithmeticInstruction + super ARichBinaryInstruction + init from( src ) do super +end +class AAddInstruction + super AArithmeticInstruction + init from( src ) do super +end +class ASubInstruction + super AArithmeticInstruction + init from( src ) do super +end +class AAndInstruction + super AArithmeticInstruction + init from( src ) do super +end +class AOrInstruction + super AArithmeticInstruction + init from( src ) do super +end + +class ACpInstruction + super ARichBinaryInstruction + init from( src ) do super +end + + +abstract class ALoadInstruction + super ARichBinaryInstruction + init from( src ) do super +end +class ALdInstruction + super ALoadInstruction + init from( src ) do super +end +class ALdbyteInstruction + super ALoadInstruction + init from( src ) do super +end + +abstract class AStoreInstruction + super ARichBinaryInstruction + init from( src ) do super +end +class AStInstruction + super AStoreInstruction + init from( src ) do super +end +class AStbyteInstruction + super AStoreInstruction + init from( src ) do super +end diff --git a/contrib/pep8analysis/src/ast/suffixed_instructions.nit b/contrib/pep8analysis/src/ast/suffixed_instructions.nit new file mode 100644 index 0000000..6466430 --- /dev/null +++ b/contrib/pep8analysis/src/ast/suffixed_instructions.nit @@ -0,0 +1,65 @@ +# Pep/8 instructions are not reserved as keywords. It is common +# that the identifier of an instruction will be used for a label. +# For this reason, we cannot create precise instruction nodes with +# the parser. +# +# This module manually creates the expected subclass with an additionnal +# OOP hiearchy. + +module suffixed_instructions + +import rich_instructions + +# +# Support classes +# +abstract class ARegisterSuffixed + super AInstruction + + fun register : Char do return n_id.text.to_upper.last +end + +abstract class ADigitSuffixed + super AInstruction + + fun digit : Int do return n_id.text.last.to_i + fun digit_max : Int is abstract +end + + +# +# Other classification +# +redef class AUnaryNopInstruction + super ADigitSuffixed + redef fun digit_max do return 1.lshift(2)-1 +end + +redef class ANotInstruction + super ARegisterSuffixed +end + +redef class ANegInstruction + super ARegisterSuffixed +end + +redef class AShiftInstruction + super ARegisterSuffixed +end + +redef class ARetInstruction + super ADigitSuffixed + redef fun digit_max do return 1.lshift(3)-1 +end + +redef abstract class AArithmeticInstruction + super ARegisterSuffixed +end + +redef abstract class ALoadInstruction + super ARegisterSuffixed +end + +redef abstract class AStoreInstruction + super ARegisterSuffixed +end diff --git a/contrib/pep8analysis/src/backbone.nit b/contrib/pep8analysis/src/backbone.nit new file mode 100644 index 0000000..369c0a7 --- /dev/null +++ b/contrib/pep8analysis/src/backbone.nit @@ -0,0 +1,104 @@ +import opts + +import parser + +class AnalysisManager + super Noter + var opts = new OptionContext + + init do end +end + +abstract class Noter + var notes = new Array[Note] + + var failed = false + + fun print_notes + do + if not notes.is_empty then + print "# Notes:" + for n in notes do print n + end + end + + fun fatal_error(n: ANode, msg: String) + do + notes.add( new Fatal(n.location, msg) ) + failed = true + end + + fun reset + do + failed = false + end +end + +abstract class Note + var line: Location + var to: nullable Location = null + var msg: String + + init (line: Location, msg: String) + do + self.line = line + self.msg = msg + end + init range(from, to: Location, msg: String) + do + self.line = from + self.to = to + self.msg = msg + end + + fun prefix: String is abstract + redef fun to_s do + var s = "" + var to = to + if to != null then + s += " from {line} to {to}" + s = "{line.to_file_s}:{line.to_line_s}--{to.to_line_s}; " + else + s = "{line.to_file_s}:{line.to_line_s}; " + end + return "{prefix}{s}{msg}" + end +end + +class Warn + super Note + init (line: Location, msg: String) do super + init range(from, to: Location, msg: String) do super + redef fun prefix do return "Warning: " +end + +class Error + super Note + init (line: Location, msg: String) do super + init range(from, to: Location, msg: String) do super + redef fun prefix do return "Error: " +end + +class Fatal + super Note + init (line: Location, msg: String) do super + init range(from, to: Location, msg: String) do super + redef fun prefix do return "Fatal: " +end + +redef class Object + protected fun manager: AnalysisManager is abstract +end + +redef class Location + # "line 5" + fun to_line_s: String + do + return line_start.to_s + end + + fun to_file_s: String + do + return file.filename + end +end diff --git a/contrib/pep8analysis/src/cfg/cfg.nit b/contrib/pep8analysis/src/cfg/cfg.nit new file mode 100644 index 0000000..ac7d86f --- /dev/null +++ b/contrib/pep8analysis/src/cfg/cfg.nit @@ -0,0 +1,52 @@ +import cfg_base +import dot_printer +import sanity + +redef class AnalysisManager + var opt_cfg = new OptionBool("Print the CFG to \"cfg.dot\" (for debugging purposes)", "--cfg") + var opt_cfg_long = new OptionBool("Print the long format CFG", "--cfg-long") + + var opt_cfg_inline = new OptionBool("Inline function calls in the CFG", "--inline") + #var opt_cfg_not_inline = new OptionBool("Do not inline function calls in the CFG", "--no-inline") + + var cfg: nullable CFG = null + + redef init + do + super + + opts.add_option(opt_cfg) + opts.add_option(opt_cfg_long) + #opts.add_option(opt_cfg_not_inline) + opts.add_option(opt_cfg_inline) + end + + redef fun build_cfg(model) + do + var cfg = super + self.cfg = cfg + + if cfg.has_function_calls then + #if not opt_cfg_not_inline.value then + if opt_cfg_inline.value then + cfg.inline_functions + else + cfg.watchdog = 0 + var to_link = new List[BasicBlock] + if not cfg.link_ret_to_calls(cfg.start, to_link, new List[BasicBlock], 0) then + manager.fatal_error(model.lines.first, "failed to organize function calls") + end + end + end + + if opt_cfg.value or opt_cfg_long.value then + var of = new OFStream.open("cfg.dot") + cfg.print_dot(of, opt_cfg_long.value) + of.close + end + + verify_cfg_sanity(cfg) + + return cfg + end +end diff --git a/contrib/pep8analysis/src/cfg/cfg_base.nit b/contrib/pep8analysis/src/cfg/cfg_base.nit new file mode 100644 index 0000000..c532215 --- /dev/null +++ b/contrib/pep8analysis/src/cfg/cfg_base.nit @@ -0,0 +1,442 @@ +import pipeline + +import model + +redef class AnalysisManager + fun build_cfg( model: Model ) : CFG + do + var cfg = new CFG( model ) + return cfg + end +end + +redef class ABranchInstruction + fun is_indirect: Bool + do + var op = n_operand + return op isa AAnyOperand and (once ["x","d"]).has(op.addressing_mode) + end +end + +class CFG + var start : BasicBlock + var finish : BasicBlock + var addr_to_blocks = new HashMap[Int,BasicBlock] + var blocks = new Array[BasicBlock] + + var has_function_calls = false + + init (model: Model) + do + assert not model.lines.is_empty + + var starts = [0] + var ends = [model.lines.last.address] + + # check for indirect branches + #var indirect_jump_sites = new Array[Int] + var has_indirect_jump_sites = false + + # detect basic block limits + for line in model.lines do + if line isa AInstructionLine then + var instr = line.n_instruction + if instr isa ABranchInstruction then + if instr.is_indirect then + #indirect_jump_sites.add(line.address) + has_indirect_jump_sites = true + manager.notes.add(new Warn(instr.location, "use of indirect jumps, the CFG may be wrong")) + else + var op = instr.n_operand + var dest = op.n_value.to_i + starts.add(dest) + end + ends.add(line.address) + if not instr isa ABrInstruction then + # next line is possible start + starts.add(line.address+4) + end + else if instr isa AStopInstruction or + instr isa ARetInstruction then + ends.add(line.address) + end + end + end + + var addresses_in_memory = new Array[Int] + #if not indirect_jumps.is_empty then + if has_indirect_jump_sites then + # find possible jump destinations + + for line in model.lines do + if line isa ADirectiveLine then + var dir = line.n_directive + if dir isa AAddrssDirective then + var dest = dir.n_value.to_i + starts.add(dest) + addresses_in_memory.add(dest) + end + end + end + + # link indirect jumps to possible destinations + #for src in addresses_in_memory do + #end + end + + # sort breakpoints in order + starts = starts.uniq.sort_filter.to_a + ends = ends.uniq.sort_filter.to_a + + # create basic blocks + var current_block: nullable BasicBlock = null + var next_start_i = 0 + var next_end_i = 0 + for line in model.lines do + var addr = line.address + while next_start_i < starts.length and + starts[next_start_i] < addr do next_start_i += 1 + if next_start_i < starts.length and + starts[next_start_i] == addr then + # is a dest, and not already started + current_block = new BasicBlock + blocks.add(current_block) + end + + if current_block == null then + current_block = new BasicBlock + blocks.add(current_block) + end + + current_block.lines.add(line) + + while next_end_i < ends.length and + ends[next_end_i] < addr do next_end_i += 1 + if next_end_i < ends.length and + ends[next_end_i] == addr then + # stops here, unless already at the end + current_block = null + end + end + + # adds created blocks to instance attribute + for b in blocks do + # save them in the class attribute + addr_to_blocks[b.lines.first.address] = b + end + + # start node + start = new BasicBlock.start + blocks.add(start) + if blocks.length > 0 and blocks.first != start then + start.successors.add(blocks.first) + blocks.first.predecessors.add(start) + end + addr_to_blocks[-2] = start + + # end node + finish = new BasicBlock.finish + blocks.add(finish) + addr_to_blocks[-1] = finish + + # set successors and predecessors + for b in blocks do if not b.lines.is_empty then + var line = b.lines.last + + if line isa AInstructionLine then + var instr = line.n_instruction + if instr isa ABranchInstruction then + var op = instr.n_operand + if instr.is_indirect then + for dest in addresses_in_memory do + var db = addr_to_blocks[dest] + b.successors.add(db) + db.predecessors.add(b) + end + else + var dest = op.n_value.to_i + var db = addr_to_blocks[dest] + b.successors.add(db) + db.predecessors.add(b) + end + end + + if not instr isa ABrInstruction and + not instr isa AStopInstruction and + not instr isa ACallInstruction and + not instr isa ARetInstruction then + # next line is possible start + var dest = line.address+4 + if addr_to_blocks.has_key(dest) then + var db = addr_to_blocks[dest] + b.successors.add(db) + db.predecessors.add(b) + else + manager.notes.add(new Error(line.location, "invalid line following instruction")) + end + end + + if instr isa ACallInstruction then + has_function_calls = true + var next_addr = line.address+4 + if not addr_to_blocks.has_key(next_addr) then + print "error, no instruction following call {b.name}" + else + b.after_call = addr_to_blocks[next_addr] + end + end + + if b.successors.is_empty and + not instr isa ARetInstruction then + b.successors.add(finish) + finish.predecessors.add(b) + end + end + end + + # Verify use of function calls + # To be by the book, each path from the start to the end should have + # the same number of calls and rets. There should never be more rets + # than calls. + + # TODO check for instructions not in a path from start to end + + # TODO check if branching on variable + + # TODO check there is there is a consistant use of the stack between + # calls and rets. + end + + # duplicate function calls + # at each call site, the tree representing the + fun inline_functions + do + inline_functions_recursive(start, new List[BasicBlock]) #0) + + # retain only blocks reachble from start + var reachables = new HashSet[BasicBlock] + var todo = new Array[BasicBlock] + todo.add(start) + while not todo.is_empty do + var n = todo.pop + if not reachables.has(n) then + reachables.add(n) + for s in n.successors do if not reachables.has(s) then + todo.add(s) + end + end + end + self.blocks = reachables.to_a + end + + private fun inline_functions_recursive(b: BasicBlock, seq: List[BasicBlock]) #depth: Int) + do + # Protection against cycles + #if depth > 1000 then return + var sl = seq.length + var loop_length = 3 + if sl > loop_length then + for i in [0..sl-loop_length[ do + var same = true + for j in [0..loop_length[ do if seq[i+j]!=seq[sl-3+j] then + same = false + break + end + + if same then + print "recursive since {seq[i].name}" + return + end + end + end + #if seq.has(b) then return + + if not b.lines.is_empty then + var line = b.lines.last + if line isa AInstructionLine then + var instr = line.n_instruction + if instr isa ACallInstruction then + # replace called by a dup + assert b.successors.length == 1 + var called = b.successors.first + var rets = new HashSet[BasicBlock] + var n = called.duplicate_tree( + new HashMap[BasicBlock,BasicBlock], rets, 0, blocks) + b.successors[0] = n + n.predecessors.add(b) + + if b.after_call == null then + print "Already inlined" + return + else + # TODO bring back assert + if n.predecessors.length > 1 then + print "many pred" + print "n {n.name}" + print "preds {n.predecessors.join(" ")}" + end + assert n.predecessors.length == 1 else print n.predecessors.length + assert b.successors.length == 1 + # TODO add information about duplicated block that are not dead + + # link! + var next = b.after_call.as(not null) + # Another protection against cycles + for ret in rets do + ret.successors.add(next) + next.predecessors.add(ret) + end + #print "linking {b.name} to {next.name} ret len {rets.length}" + + b.after_call = null + end + end + end + end + + var si = 0 + while si < b.successors.length do + var s = b.successors[si] + seq.add(s) + inline_functions_recursive(s, seq) + seq.pop + si+=1 + end + end + + var watchdog writable = 0 + fun link_ret_to_calls(b: BasicBlock, to_link_ori: List[BasicBlock], seq: List[BasicBlock], depth: Int): Bool + do + watchdog += 1 + if watchdog == 100000 then + print "Error: Umanagable cycle detected" + return false + end + + var sl = seq.length + var loop_length = 4 + if sl > loop_length then + for i in [0..sl-loop_length[ do + var same = true + for j in [0..loop_length[ do if seq[i+j]!=seq[sl-loop_length+j] then + same = false + break + end + + if same then + #print "recursive since {seq[i].name}" + return true + end + end + end + + # copy to_list + var to_link = new List[BasicBlock] + to_link.add_all(to_link_ori) + + if not b.lines.is_empty then + var line = b.lines.last + if line isa AInstructionLine then + var instr = line.n_instruction + if instr isa ACallInstruction then + to_link.push(b) + + else if instr isa ARetInstruction then + if to_link.is_empty then + manager.notes.add( new Error(instr.location,"no CALL can be linked to return") ) + return false + else + var caller = to_link.pop + # link! + var next = caller.after_call.as(not null) + + # Another protection against cycles + if b.successors.has(next) then return true + + b.successors.add(next) + next.predecessors.add(b) + end + end + end + end + + var si = 0 + while si < b.successors.length do + var s = b.successors[si] + seq.add(s) + if not link_ret_to_calls(s, to_link,seq,depth+1) then return false + seq.pop + si+=1 + end + + return true # OK + end +end + +class BasicBlock + var name : String + var lines = new Array[ANonEmptyLine] + var successors = new Array[BasicBlock] + var predecessors = new Array[BasicBlock] + var after_call : nullable BasicBlock = null + + init + do + var count = (once new Counter).next + name = "b{count}" + end + init named(name: String) do self.name = name + init start do name = "start" + init finish + do + name = "end" + end + + fun duplicate_tree(dups: HashMap[BasicBlock,BasicBlock], + rets: Set[BasicBlock], calls: Int, + blocks: Array[BasicBlock]) : BasicBlock + do + if dups.has_key(self) then return dups[self] + + var n = new BasicBlock.from(self) + dups[self] = n + blocks.add(n) + n.successors = new Array[BasicBlock] + n.predecessors = new Array[BasicBlock] + + if after_call != null then + var nac = after_call.duplicate_tree(dups, rets, calls, blocks) + n.after_call = nac + calls += 1 # for within that call + end + + for s in successors do + var ns = s.duplicate_tree(dups, rets, calls, blocks) + n.successors.add(ns) + ns.predecessors.add(n) + end + + if calls == 0 and successors.is_empty then rets.add(n) + + return n + end + + init from(o: BasicBlock) + do + var count = (once new Counter).next + name = "c{count}_from_{o.name}" + lines = o.lines + successors = o.successors + predecessors = o.predecessors + after_call = o.after_call + end +end + +private class Counter + var count: Int = -1 + fun next : Int + do + count += 1 + return count + end +end diff --git a/contrib/pep8analysis/src/cfg/dot_printer.nit b/contrib/pep8analysis/src/cfg/dot_printer.nit new file mode 100644 index 0000000..b4fe76e --- /dev/null +++ b/contrib/pep8analysis/src/cfg/dot_printer.nit @@ -0,0 +1,51 @@ +import cfg_base + +redef class CFG + fun print_dot( f: OFStream, long: Bool ) + do + f.write("digraph \{\n") + f.write("charset=latin1\n") + f.write("node [shape=box,style=rounded,fontname=courier]\n") + for block in blocks do block.print_dot_nodes(f, long) + for block in blocks do block.print_dot_edges(f, long) + f.write("\}") + end +end + +redef class BasicBlock + fun print_dot_nodes( f: OFStream, long: Bool ) + do + var lbl + if long then + lbl = "\"{name}:\\n{dot_node_text}\"" + else + lbl = name + end + f.write( "{name} [label={lbl}]\n" ) + end + + fun dot_node_text : String + do + var code_lines = new Array[String] + for line in lines do code_lines.add(line.text) + var code = code_lines.join("") + + code = code.replace("\n","\\l").replace("\"","\\\"").replace("\\n","|n").replace("/","\\/").replace("\r","") + # the last one is a hack + return "{dot_node_header}{code}{dot_node_footer}" + end + + fun dot_node_header: String do return "" + fun dot_node_footer: String do return "" + + fun print_dot_edges( f: OFStream, long: Bool ) + do + for s in successors do + f.write( "{name} -> {s.name}\n" ) + end + var n = after_call + if n != null then + f.write( "{name} -> {n.name} [style=\"dashed\"]\n" ) + end + end +end diff --git a/contrib/pep8analysis/src/cfg/sanity.nit b/contrib/pep8analysis/src/cfg/sanity.nit new file mode 100644 index 0000000..78242c2 --- /dev/null +++ b/contrib/pep8analysis/src/cfg/sanity.nit @@ -0,0 +1,88 @@ +module sanity + +import cfg_base + +redef class BasicBlock + private var cfg_sanity_verified = false + + # reports data in code + private fun verify_cfg_sanity_code(v: Noter, data_in_code: Array[ALine]) + do + for line in lines do if line isa ADirectiveLine then + data_in_code.add(line) + end + + cfg_sanity_verified = true + end + + # reports code in data + private fun verify_cfg_sanity_data(v: Noter, dead_lines: Array[ALine]) + do + for line in lines do if line isa AInstructionLine then + dead_lines.add(line) + end + + cfg_sanity_verified = true + end +end + +redef class AnalysisManager + fun verify_cfg_sanity(cfg: CFG) + do + # verify executable code + var executed_data = new Array[ALine] + verify_cfg_sanity_recursively_code( cfg.start, executed_data ) + + # verify data or dead code + var dead_code = new Array[ALine] + for b in cfg.blocks do if not b.cfg_sanity_verified then + b.verify_cfg_sanity_data(self, dead_code) + end + + group( dead_code, "unreachable instructions", false ) + group( executed_data, "data in program flow", true ) + end + + fun verify_cfg_sanity_recursively_code(b: BasicBlock, executed_data: Array[ALine]) + do + if b.cfg_sanity_verified then return # is code + + b.verify_cfg_sanity_code(self,executed_data) + for s in b.successors do verify_cfg_sanity_recursively_code( s, executed_data ) + end + + private fun group(lines: Array[ALine], msg: String, error: Bool) + do + lines = lines.sort_filter.to_a + var len = lines.length + var first: nullable ALine = null + for i in [0..len[ do + var line = lines[i] + if first == null then + first = line + end + if i == len-1 or line.address + line.size != lines[i+1].address then + if error then + if first == line then + manager.notes.add(new Error(first.location, msg)) + else + manager.notes.add(new Error.range(first.location, line.location, msg)) + end + else + if first == line then + manager.notes.add(new Error(first.location, msg)) + else + manager.notes.add(new Warn.range(first.location, line.location, msg)) + end + end + first = null + end + end + end +end + +redef class ALine + super Comparable + redef type OTHER: ALine + redef fun <=>(o) do return address <=> o.address +end diff --git a/contrib/pep8analysis/src/flow_analysis/flow_analysis.nit b/contrib/pep8analysis/src/flow_analysis/flow_analysis.nit new file mode 100644 index 0000000..50cebd9 --- /dev/null +++ b/contrib/pep8analysis/src/flow_analysis/flow_analysis.nit @@ -0,0 +1,5 @@ +import framework + +import range +import reaching_defs +import types diff --git a/contrib/pep8analysis/src/flow_analysis/framework.nit b/contrib/pep8analysis/src/flow_analysis/framework.nit new file mode 100644 index 0000000..57444e4 --- /dev/null +++ b/contrib/pep8analysis/src/flow_analysis/framework.nit @@ -0,0 +1,152 @@ +import cfg +import advanced_collections + +class FlowAnalysis[S] + super Visitor + + var current_in: nullable S writable + var current_out: nullable S writable + + fun in_set(bb: BasicBlock): nullable S is abstract + fun out_set(bb: BasicBlock): nullable S is abstract + fun in_set=(bb: BasicBlock, s: S) is abstract + fun out_set=(bb: BasicBlock, s: S) is abstract + + init + do + current_in = default_in_set + current_out = default_in_set + end + + redef fun visit( node ) do node.visit_all(self) + + # If false, it is a backwards analysis + fun is_forward: Bool is abstract + + # ex: do return in1.union( in2 ) + # ex: do return in1.intersection( in2 ) + fun merge( in1, in2: nullable S): nullable S is abstract + + fun default_in_set: nullable S do return null + fun empty_set: S is abstract + + fun analyze(cfg: CFG) + do + # set defaults + var current_in: nullable S + var current_out: nullable S + + # set current input as default start case + var todo = new List[BasicBlock] + todo.add_all(cfg.blocks) + + # iterate until fixed point reached + while not todo.is_empty do + + var block = todo.shift + + if block == cfg.start then + continue + else if block.predecessors.is_empty then + # get default in (the most safe one) + current_in = default_in_set + else + current_in = out_set(block.predecessors.first) + for l in [1..block.predecessors.length[ do + var b = block.predecessors[l] + current_in = merge(current_in, out_set(b)) + end + end + + if current_in != null then + in_set(block) = current_in.as(not null) + else + continue + end + + if block == cfg.finish then continue + + var old_out = out_set(block) + for line in block.lines do + self.current_in = current_in.as(not null) + self.current_out = empty_set + pre_line_visit(line) + enter_visit(line) + post_line_visit(line) + current_out = self.current_out + current_in = self.current_out.as(not null) + #self.current_in = current_in + end + + current_out = self.current_out + if old_out != current_out then + out_set(block) = current_out.as(not null) + if is_forward then + for b in block.successors do todo.add(b) + else + for b in block.predecessors do todo.add(b) + end + end + end + end + + fun pre_line_visit(l: ALine) do end + fun post_line_visit(l: ALine) do end +end + +class FineFlowAnalysis[V] + super FlowAnalysis[V] + + redef fun in_set(bb) + do + if bb.lines.is_empty then return backup_in(bb) + return line_in( bb.lines.first ) + end + + redef fun in_set=(bb, v) + do + if bb.lines.is_empty then + backup_in(bb) = v + else line_in( bb.lines.first ) = v + end + + redef fun out_set(bb) + do + if bb.lines.is_empty then return backup_out(bb) + return line_out( bb.lines.last ) + end + + redef fun out_set=(bb, v) + do + if bb.lines.is_empty then + backup_out(bb) = v + else line_out( bb.lines.last ) = v + end + + fun backup_in(l: BasicBlock): nullable V is abstract + fun backup_out(l: BasicBlock): nullable V is abstract + fun backup_in=(l: BasicBlock, v: nullable V) is abstract + fun backup_out=(l: BasicBlock, v: nullable V) is abstract + + fun line_in(l: ALine): nullable V is abstract + fun line_out(l: ALine): nullable V is abstract + fun line_in=(l: ALine, v: nullable V) is abstract + fun line_out=(l: ALine, v: nullable V) is abstract + + redef fun pre_line_visit(line) do line_in(line) = current_in + redef fun post_line_visit(line) do line_out(line) = current_out +end + +class StaticAnalysis[S] + super Visitor + + var set: S + init (set: S) do self.set = set + + redef fun visit( node ) do node.visit_all(self) + fun analyze(ast: AListing): S + do + enter_visit(ast) + return set + end +end diff --git a/contrib/pep8analysis/src/flow_analysis/range.nit b/contrib/pep8analysis/src/flow_analysis/range.nit new file mode 100644 index 0000000..3d219fb --- /dev/null +++ b/contrib/pep8analysis/src/flow_analysis/range.nit @@ -0,0 +1,352 @@ +module range + +import framework + +# for linex, and should be used in the future +import reaching_defs + +redef class AnalysisManager + fun do_range_analysis(ast: AListing, cfg: CFG) + do + var range_init_analysis = new InitRangeAnalysis(ast) + range_init_analysis.analyze(ast) + + cfg.start.backup_ranges_out = range_init_analysis.set + + var range_analysis = new RangeAnalysis + range_analysis.analyze(cfg) + end +end + +class RangeAnalysis + super FineFlowAnalysis[RangeMap] + + var current_range: nullable ValRange = null + var current_var: nullable Var = null + + redef fun empty_set do return new RangeMap + redef fun is_forward do return true + + init do super + + redef fun visit(node) + do + node.accept_range_analysis(self, + current_in, current_out.as(not null)) + end + + # union + redef fun merge(a, b) + do + if a == null and b == null then return null + if a == null then return b.copy + if b == null then return a.copy + + var n = new RangeMap + for k, v in a do + if b.has_key(k) then + # merge ranges + var u = b[k] + n[k] = new ValRange(v.min.min(u.min), v.max.max(u.max)) + end + end + + return n + end + + redef fun line_in(line) do return line.ranges_in + redef fun line_out(line) do return line.ranges_out + redef fun line_in=(line, s) do line.ranges_in = s + redef fun line_out=(line, s) do line.ranges_out = s + + redef fun backup_in(bb) do return bb.backup_ranges_in + redef fun backup_out(bb) do return bb.backup_ranges_out + redef fun backup_in=(bb, s) do bb.backup_ranges_in = s + redef fun backup_out=(bb, s) do bb.backup_ranges_out = s +end + +class InitRangeAnalysis + super StaticAnalysis[RangeMap] + + var current_line: ALine + + init(prog: AListing) + do + super( new RangeMap ) + current_line = prog.n_lines.first + end + redef fun visit(node) + do + if node isa ALine then current_line = node + node.accept_init_range_analysis(self, set) + end +end + +redef class ALine + var ranges_in: nullable RangeMap = null + var ranges_out: nullable RangeMap = null +end + +redef class BasicBlock + var backup_ranges_in: nullable RangeMap = null + var backup_ranges_out: nullable RangeMap = null + + redef fun dot_node_header + do + if backup_ranges_in != null then + return "{super}-- ranges in = {backup_ranges_in.as(not null)}\\l" + else if not lines.is_empty and lines.first.ranges_in != null then + return "{super}-- ranges in = {lines.first.ranges_in.as(not null)}\\l" + else return super + end + redef fun dot_node_footer + do + if backup_ranges_out != null then + return "{super}-- ranges out = {backup_ranges_out.as(not null)}\\l" + else if not lines.is_empty and lines.last.ranges_out != null then + return "{super}-- ranges out = {lines.last.ranges_out.as(not null)}\\l" + else return super + end +end + +class ValRange + var min: Int + var max: Int + init(min, max: Int) + do + self.min = min + self.max = max + end + init from(o: ValRange) + do + self.min = o.min + self.max = o.max + end + init at(v: Int) + do + self.min = v + self.max = v + end + + redef fun to_s do + if min == max then return min.to_s + return "[{min}..{max}]" + end + + redef fun ==(o) do return o != null and o isa ValRange and + min == o.min and max == o.max + + fun ponctual: Bool do return min == max +end +class RangeMap + super HashMap[Var, ValRange] + redef fun ==(o) + do + if o == null or not o isa RangeMap then return false + if o.length != length then return false + + for k, v in self do if not o.has_key(k) or o[k] != v then return false + + return true + end + + fun copy: RangeMap + do + var c = new RangeMap + c.recover_with(self) + return c + end + + redef fun to_s do return "\{{join(", ", ":")}\}" +end + +redef class ANode + fun accept_range_analysis(v: RangeAnalysis, + ins: nullable RangeMap, outs: RangeMap) do visit_all(v) + fun accept_init_range_analysis(v: InitRangeAnalysis, + set: RangeMap) do visit_all(v) +end + +redef class AInstruction + redef fun accept_range_analysis(v, ins, outs) + do + visit_all(v) + if ins != null then outs.recover_with(ins) + end +end + +redef class ALoadInstruction + redef fun accept_range_analysis(v, ins, outs) + do + visit_all(v) + + if ins != null then outs.recover_with(ins) + var variable = def_var + #var add = new RangeMap[Var, ValRange](variable, + + # kill every set for variable + # (is automatic by HashMap) + + if variable != null then + # gen (&kill) + var cr = v.current_range + if cr != null then + outs[variable] = cr + else + outs.keys.remove(variable) + end + end + v.current_range = null + end +end + +redef class AStoreInstruction + redef fun accept_range_analysis(v, ins, outs) + do + visit_all(v) + + if ins != null then outs.recover_with(ins) + var src = src_var # reg + var def = def_var # mem + + if def != null then + if src != null and ins != null and ins.has_key(src) then # we know the source and dest + var cr = ins[src] + outs[def] = cr + else + outs.keys.remove(def) + end + end + end +end + +redef class AInputInstruction + redef fun accept_range_analysis(v, ins, outs) + do + visit_all(v) + + if ins != null then outs.recover_with(ins) + + var def = def_var # mem + + if def != null and outs.has_key(def) then + outs.keys.remove(def) + end + + end +end + +redef class AArithmeticInstruction + fun do_arithmetic(rv, rm: ValRange): nullable ValRange do return null + + redef fun accept_range_analysis(v, ins, outs) + do + v.current_range = null + visit_all(v) + + if ins != null then outs.recover_with(ins) + + var reg = reg_var + + var cr = v.current_range + + if cr != null and ins.has_key(reg) then + # and ins.has_key(mem) then + var r = do_arithmetic(ins[reg], cr) + + if r != null then + # this prevents infinite loops + # we assume that the max for a student program in 999 + if r.max > 999 then r.max = 999 + if r.min < -999 then r.min = -999 + + outs[reg] = r + else + outs.keys.remove(reg) + end + else + outs.keys.remove(reg) + end + end +end + +redef class AAddInstruction + redef fun do_arithmetic(rv, rm) do return new ValRange(rv.min+rm.min, rv.max+rm.max) +end + +redef class ASubInstruction + redef fun do_arithmetic(rv, rm) do return new ValRange(rv.min-rm.max, rv.max-rm.min) +end + +redef class ANegInstruction + redef fun accept_range_analysis(v, ins, outs) + do + v.current_range = null + visit_all(v) + + if ins != null then outs.recover_with(ins) + + var reg = reg_var + if ins.has_key(reg) then + var rm = ins[reg] + outs[reg] = new ValRange(-rm.max, -rm.min) + end + end +end + +redef class AAnyOperand + redef fun accept_range_analysis(v, ins, outs) + do + if addressing_mode == "i" then # immediate + v.current_var = null + v.current_range = new ValRange(n_value.to_i, n_value.to_i) + return + else if addressing_mode == "d" then # direct + var ci = v.current_in + var address = n_value.to_i + var variable = new MemVar(address) + v.current_var = variable + if ci != null and ci.has_key(variable) then + var value = ci[variable] + v.current_range = new ValRange(value.min, value.max) + return + end + end + + v.current_range = null + end +end + +redef class AMovInstruction + # Almost impossible to guess so, topped + redef fun accept_range_analysis(v, ins, outs) + do + v.current_range = null + visit_all(v) + + if ins != null then outs.recover_with(ins) + + var reg = new RegisterVar('A') + if outs.has_key(reg) then + outs.keys.remove(reg) + end + end +end + +redef class AWordDirective + redef fun accept_init_range_analysis(v, set) + do + var variable = new MemVar(v.current_line.address) + var value = new ValRange.at(n_value.to_i) + set[variable] = value + end +end + +redef class AByteDirective + redef fun accept_init_range_analysis(v, set) + do + var variable = new MemVar(v.current_line.address) + var value = new ValRange.at(n_value.to_i) + set[variable] = value + end +end diff --git a/contrib/pep8analysis/src/flow_analysis/reaching_defs.nit b/contrib/pep8analysis/src/flow_analysis/reaching_defs.nit new file mode 100644 index 0000000..187c4fd --- /dev/null +++ b/contrib/pep8analysis/src/flow_analysis/reaching_defs.nit @@ -0,0 +1,166 @@ +module reaching_defs + +import framework + +redef class AnalysisManager + fun do_reaching_defs_analysis(cfg: CFG) + do + cfg.start.backup_reaching_defs_out = new ReachingDefsMap + var reaching_defs_analysis = new ReachingDefsAnalysis + reaching_defs_analysis.analyze(cfg) + end +end + +class ReachingDefsAnalysis + super FineFlowAnalysis[ReachingDefsMap] + + init do end + redef fun is_forward do return true + + redef fun visit( node ) + do + node.accept_reaching_defs_analysis( self, current_in, current_out.as(not null) ) + end + redef fun merge(a,b) + do + if a == null then return b + if b == null then return a + return a.union(b) + end + + redef fun backup_in(bb) do return bb.backup_reaching_defs_in + redef fun backup_out(bb) do return bb.backup_reaching_defs_out + redef fun backup_in=(bb, v) do bb.backup_reaching_defs_in = v + redef fun backup_out=(bb, v) do bb.backup_reaching_defs_out = v + + redef fun line_in(line) do return line.reaching_defs_in + redef fun line_out(line) do return line.reaching_defs_out + redef fun line_in=(line, v) do line.reaching_defs_in = v + redef fun line_out=(line, v) do line.reaching_defs_out = v + + redef fun default_in_set do return new ReachingDefsMap + redef fun empty_set do return new ReachingDefsMap +end + +redef class ANode + fun accept_reaching_defs_analysis(v: ReachingDefsAnalysis, ins: nullable ReachingDefsMap, outs: ReachingDefsMap) do visit_all(v) +end + +redef class AInstruction + redef fun accept_reaching_defs_analysis(v, ins, outs) + do + if ins != null then outs.recover_with(ins) + end +end + +redef class ALoadInstruction + redef fun accept_reaching_defs_analysis(v, ins, outs) + do + if ins != null then outs.recover_with(ins) + + var variable = def_var + if variable != null then + # kill & gen + var set = new HashSet[ALine] + set.add(parent.as(ALine)) + outs[variable] = set + else + # TODO top + end + end +end + +redef class AStoreInstruction + redef fun accept_reaching_defs_analysis(v, ins, outs) + do + if ins != null then outs.recover_with(ins) + + var variable = def_var + if variable != null then + # kill & gen + var set = new HashSet[ALine] + set.add(parent.as(ALine)) + outs[variable] = set + else + # TODO top + end + end +end + +class ReachingDefsMap + super HashMap[Var,Set[ALine]] + + fun union(o: ReachingDefsMap): ReachingDefsMap + do + var n = new ReachingDefsMap + for k, v in self do + n[k] = new HashSet[ALine] + n[k].add_all(v) + end + for k, v in o do + if not n.has_key(k) then n[k] = new HashSet[ALine] + n[k].add_all(v) + end + return n + end + + fun intersection(o: ReachingDefsMap): ReachingDefsMap + do + var n = new ReachingDefsMap + for k, v in self do if n.has_key(k) then n[k].add_all(v) + for k, v in o do if n.has_key(k) then n[k].add_all(v) + return n + end + + redef fun to_s do return join(";", ":") + + redef fun ==(o) + do + if o != null and o isa ReachingDefsMap then + if length != o.length then return false + for k,v in self do + if not o.has_key(k) then return false + var ok = o[k] + if v.length != ok.length then return false + for l in v do if not ok.has(l) then return false + end + return true + else + return false + end + end +end + +redef class ALine + var reaching_defs_in: nullable ReachingDefsMap = null + var reaching_defs_out: nullable ReachingDefsMap = null +end + +redef class BasicBlock + var backup_reaching_defs_in: nullable ReachingDefsMap = null + var backup_reaching_defs_out: nullable ReachingDefsMap = null + + redef fun dot_node_header + do + if lines.is_empty then + if backup_reaching_defs_in != null then + return "{super}-- r defs in = \{{backup_reaching_defs_in.to_s}\}\\l" + end + else if lines.first.reaching_defs_in != null then return "{super}-- r defs in = \{{lines.first.reaching_defs_in.to_s}\}\\l" + return super + end + redef fun dot_node_footer + do + if lines.is_empty then + if backup_reaching_defs_out != null then + return "{super}-- r defs out = \{{backup_reaching_defs_out.to_s}\}\\l" + end + else if lines.first.reaching_defs_out != null then return "{super}-- r defs out = \{{lines.last.reaching_defs_out.to_s}\}\\l" + return super + end +end + +# This is bad. +redef class HashSet[E] + redef fun to_s do return join(",") +end diff --git a/contrib/pep8analysis/src/flow_analysis/types.nit b/contrib/pep8analysis/src/flow_analysis/types.nit new file mode 100644 index 0000000..445cde0 --- /dev/null +++ b/contrib/pep8analysis/src/flow_analysis/types.nit @@ -0,0 +1,662 @@ +import pipeline +import opts + +import framework +import range + +redef class AnalysisManager + var opt_report_unknown_types = new OptionBool("Report unknown types", "--report-types-top") + fun report_unknown_types: Bool do return opt_report_unknown_types.value + + redef init + do + super + opts.add_option(opt_report_unknown_types) + end + + fun do_types_analysis(ast: AListing, cfg: CFG) + do + # find types at program init + var tia = new TypesInitAnalysis(ast) + tia.analyze(ast) + + # evaluate types with program flow + cfg.start.backup_types_out = tia.set + var ta = new TypesAnalysis + ta.analyze(cfg) + + # check for errors + var tc = new TypesChecker(ast) + tc.analyze(ast) + end +end + +# Types 1st step, find state at program load +# one pass over the AST +class TypesInitAnalysis + super StaticAnalysis[TypesMap] + + var current_line: ALine + + init(prog: AListing) + do + super( new TypesMap ) + current_line = prog.n_lines.first + end + redef fun visit(node) + do + if node isa ALine then current_line = node + node.accept_types_init_analysis(self, set) + end +end + +# Types 2nd step, evaluate types evolution +# one pass over the AST +class TypesAnalysis + super FineFlowAnalysis[TypesMap] + + redef fun empty_set do return new TypesMap + redef fun is_forward do return true + + init do super + + redef fun visit(node) do node.accept_types_analysis(self, current_in, current_out.as(not null)) + + redef fun merge(a, b) + do + if a == null then + if b == null then return null + return b.copy + end + if b == null then return a.copy + return a.intersection(b) + end + + redef fun backup_in(bb) do return bb.backup_types_in + redef fun backup_out(bb) do return bb.backup_types_out + redef fun backup_in=(bb, v) do bb.backup_types_in = v + redef fun backup_out=(bb, v) do bb.backup_types_out = v + + redef fun line_in(line) do return line.types_in + redef fun line_out(line) do return line.types_out + redef fun line_in=(line, v) do line.types_in = v + redef fun line_out=(line, v) do line.types_out = v +end + +# Types 3rd step, verification +# one pass over the AST +class TypesChecker + super StaticAnalysis[TypesMap] + + var current_line: ALine + + init(prog: AListing) + do + super( new TypesMap ) + current_line = prog.n_lines.first + end + redef fun visit(node) + do + if node isa ALine then current_line = node + node.accept_types_checker(self) + end +end + +class TypesMap + type T: Char + + # bits + # 'u' unset + # 's' set + var bs = new HashMap[Char,T] + + # The type can be: + # 'u' for uninitialized + # '0' zeroed + # 'b' byte + # 'w' word begin + # 'W' word end + # 'c' executable code + # 'l' ascii + # 'a' address begin + # 'A' address end + + # registers + var rs = new HashMap[Char,Array[T]] + + # stack + var stack = new Array[T] + + # mem + var mem = new HashMap[Int, T] + + init + do + rs['A'] = new Array[T].with_items('u', 'u') + rs['X'] = new Array[T].with_items('u', 'u') + bs['N'] = 'u' + bs['Z'] = 'u' + bs['V'] = 'u' + bs['C'] = 'u' + end + + fun memory(a: Int): T + do + if mem.has_key(a) then return mem[a] + return 'u' + end + fun memory=(a: Int, v: T) do mem[a] = v + + fun copy_to(o: TypesMap) + do + for k,v in rs do for b in [0..1] do o.rs[k][b] = rs[k][b] + for k,v in bs do o.bs[k] = v + for f in stack do o.stack.add(f) + for k, v in mem do o.mem[k] = v + end + fun copy: TypesMap + do + var tm = new TypesMap + copy_to(tm) + return tm + end + + fun intersection(o: TypesMap): TypesMap + do + var tm = new TypesMap + for k,v in rs do for b in [0..1] do + var v1 = o.rs[k][b] + var v2 = rs[k][b] + if v1 == v2 then + tm.rs[k][b] = v1 + else tm.rs[k][b] = merge(v1, v2) + end + + for k,v in bs do o.bs[k] = v + for f in stack do o.stack.add(f) + + for k, v in mem do if o.mem.has_key(k) then + if v == o.mem[k] then + tm.mem[k] = v + else tm.mem[k] = merge(v, o.mem[k]) + else tm.mem[k] = 't' + for k, v in o.mem do if not tm.mem.has_key(k) then + tm.mem[k] = 't' + end + return tm + end + + fun merge(a, b: Char): Char + do + var c = [a,b] + if c.has('w') and c.has('0') then return 'w' + if c.has('W') and c.has('0') then return 'W' + return 't' + end + + fun label_at(index: Int): nullable String + do + var ltl = manager.model.address_to_line + if ltl.has_key(index) then + var line = ltl[index] + return line.lbl + end + return null + end + + redef fun to_s + do + var s = "regs:\{{rs.join(",",":")}\}, " + #s = "{s}bits:\{{bs.join(",",":")}\}, " + #s = "{s}stack:\{{stack.join(",")}\}, " + + var blocks = new Array[String] + var block_begin: nullable Int = null + var block_end = 0 + var block_type = ' ' + for a in mem.keys.to_a.sort_filter do + var t = mem[a] + if block_begin != null and (block_type != t or block_end != a-1) then + var lbl = label_at(block_begin) + if lbl != null then + lbl = "{lbl}@" + else lbl = "" + + if block_begin == block_end then + blocks.add("{lbl}{block_begin}:{block_type}") + else blocks.add("{lbl}[{block_begin}..{block_end}]:{block_type}") + block_begin = null + end + + if block_begin == null then block_begin = a + + block_type = t + block_end = a + end + if block_begin != null then + var lbl = label_at(block_begin) + if lbl != null then + lbl = "{lbl}@" + else lbl = "" + + if block_begin == block_end then + blocks.add("{lbl}{block_begin}:{block_type}") + else blocks.add("{lbl}[{block_begin}..{block_end}]:{block_type}") + end + s = "{s}mem:\{{blocks.join(",")}\}" + + return s + end + + redef fun ==(o) + do + if o == null or not o isa TypesMap then return false + for r,v in rs do for i in [0..2[ do if o.rs[r][i] != v[i] then return false + + if stack.length != o.stack.length then return false + for s in [0..stack.length[ do if o.stack[s] != stack[s] then return false + + if mem.length != o.mem.length then return false + for k,v in mem do if not o.mem.has_key(k) or o.mem[k] != v then return false + + return true + end +end + +redef class ALine + var types_in: nullable TypesMap = null + var types_out: nullable TypesMap = null +end + +redef class BasicBlock + var backup_types_in: nullable TypesMap = null + var backup_types_out: nullable TypesMap = null + + redef fun dot_node_header + do + if lines.is_empty then + if backup_types_in != null then + return "{super}-- types = \{{backup_types_in.to_s}\}\\l" + end + else if lines.first.types_in != null then return "{super}-- types = \{{lines.first.types_in.to_s}\}\\l" + return super + end + redef fun dot_node_footer + do + if lines.is_empty then + if backup_types_out != null then + return "{super}-- types = \{{backup_types_out.to_s}\}\\l" + end + else if lines.first.types_out != null then return "{super}-- types = \{{lines.last.types_out.to_s}\}\\l" + return super + end +end + +redef class ANode + fun accept_types_analysis(v: TypesAnalysis, ins: nullable TypesMap, outs: TypesMap) do visit_all(v) + fun accept_types_init_analysis(v: TypesInitAnalysis, set: TypesMap) do visit_all(v) + fun accept_types_checker(v: TypesChecker) do visit_all(v) +end + +redef class AAnyOperand + redef fun to_var + do + var line = parent.parent.as(ALine) + var ranges = line.ranges_in + if ranges != null then + if addressing_mode == "n" then + var addr_pos = new MemVar(n_value.to_i) + if ranges.has_key(addr_pos) and ranges[addr_pos].ponctual then + var addr_var = ranges[addr_pos].min + return new MemVar(addr_var) + end + else if addressing_mode == "x" then + var addr_pos: Var = new RegisterVar('X') + if ranges.has_key(addr_pos) and ranges[addr_pos].ponctual then + var reg_val = ranges[addr_pos].min + return new MemVar(n_value.to_i+reg_val) + end + end + end + return super + end +end + +redef class AInstruction + # does not change the set + redef fun accept_types_analysis(v, ins, outs) + do + ins.copy_to(outs) + end + + # set the memory for the line as being code + redef fun accept_types_init_analysis(v, set) + do + for i in [0..4[ do set.memory(v.current_line.address+i) = 'c' + end + + fun verify_word(content: Array[Char], mem_str: String) + do + #if content.count('u') == 2 then + # uninitialized data + #manager.notes.add(new Error(location, "use of uninitialized values in {mem_str}, got {long_content_name(content)}")) + if content[0] == 'W' or content[1] == 'w' then + manager.notes.add(new Warn(location, "use of deorganized word in {mem_str}, got {long_content_name(content)}")) + #else if (content[0] == 'w' and content[1] != 'W') or (content[1] == 'W' and content[0] != 'w') then + else if (content[0] == 'w') != (content[1] == 'W') then + manager.notes.add(new Warn(location, "use of partial word in {mem_str}, got {long_content_name(content)}")) + #else if content.count('u') == 1 then # partially unitialized, a bad sign + #manager.notes.add(new Warn(location, "use of partially uninitialized values in {mem_str}, got {long_content_name(content)}")) + else if content.count('t') == 2 then # uninitialized data + if manager.report_unknown_types then + manager.notes.add(new Warn(location, "use of values from unknown source in {mem_str}, got {long_content_name(content)}")) + end + else if content[0] == '0' and content[1] == 'b' then # byte only OK! + else if content[0] == '0' and content[1] == 'l' then # ASCII only OK? + else if content[0] == '0' and content[1] == '0' then # all zero OK! + else if content[0] == 'a' and content[1] == 'A' then # address OK! + else if content[0] != 'w' and content[1] != 'W' then + manager.notes.add(new Warn(location, "expected word in {mem_str}, got {long_content_name(content)}")) + end + end + + # 'u' for uninitialized + # '0' zeroed + # 'b' byte + # 'w' word begin + # 'W' word end + # 'c' executable code + # 'l' ascii + # 'a' address begin + # 'A' address end + fun long_data_name(d: Char): String + do + if d == 'u' then return "uninitialized" + if d == '0' then return "zero" + if d == 'b' then return "byte" + if d == 'w' then return "1st byte of word" + if d == 'W' then return "2nd byte of word" + if d == 'c' then return "code" + if d == 'l' then return "ASCII" + if d == 'a' then return "1st byte of address" + if d == 'A' then return "2nd byte of address" + if d == 't' then return "top" + print "Unknown data type '{d}'" + abort + end + + fun long_content_name(c: Array[Char]): String + do + if (c[0]=='w' or c[0]=='0') and c[1]=='W' then return "word" + if c[0]=='a' and c[1]=='A' then return "address" + if c[0]==c[1] then return "2x {long_data_name(c[0])}" + return "{long_data_name(c[0])} then {long_data_name(c[1])}" + end +end + + +## Section: directives + +redef class AByteDirective + redef fun accept_types_init_analysis(v, set) + do + set.memory(v.current_line.address) = 'b' + end +end + +redef class AWordDirective + redef fun accept_types_init_analysis(v, set) + do + set.memory(v.current_line.address) = 'w' + set.memory(v.current_line.address+1) = 'W' + end +end + +redef class AAsciiDirective + redef fun accept_types_init_analysis(v, set) + do + # TODO AOperand::data + for i in [0..data.length[ do + set.memory(v.current_line.address+i) = 'l' + end + end +end + +redef class AAddrssDirective + redef fun accept_types_init_analysis(v, set) + do + set.memory(v.current_line.address ) = 'a' + set.memory(v.current_line.address+1) = 'A' + end +end + +## Section: other instructions + +redef class ALdInstruction + redef fun accept_types_analysis(v, ins, outs) + do + super + + var op = n_operand + if op isa AAnyOperand and op.addressing_mode == "i" then + if op.n_value.to_i == 0 then + outs.rs[register][0] = '0' + outs.rs[register][1] = '0' + else + outs.rs[register][0] = 'w' + outs.rs[register][1] = 'W' + end + return + end + + var mem = mem_var + if mem isa MemVar then + var content = [ins.memory(mem.index), ins.memory(mem.index+1)] + outs.rs[register][0] = content[0] + outs.rs[register][1] = content[1] + #outs.rs[register][0] = 'w' + #outs.rs[register][1] = 'W' + end + end +end + +redef class ALdbyteInstruction + redef fun accept_types_analysis(v, ins, outs) + do + super + # outs.rs[register][1] = 'b' + var mem = mem_var + if mem isa MemVar then + var content = ins.memory(mem.index) + #verify_word(content, "m{mem.index}") + outs.rs[register][1] = content + end + end +end + +redef class AStInstruction + redef fun accept_types_analysis(v, ins, outs) + do + super + #outs.mem[n_operand.n_value.to_i ] = 'w' + #outs.mem[n_operand.n_value.to_i+1] = 'W' + var mem = mem_var + if mem isa MemVar then + var content = ins.rs[register] + outs.mem[n_operand.n_value.to_i ] = content[0] + outs.mem[n_operand.n_value.to_i+1] = content[1] + end + end + + redef fun accept_types_checker(v) + do + var ins = v.current_line.types_in + var mem = mem_var + if mem isa MemVar and ins != null then + var content = ins.rs[register] + if ins.memory(n_operand.n_value.to_i) == 'c' or + ins.memory(n_operand.n_value.to_i) == 'c' then + manager.notes.add(new Warn(location, "overwriting code at {mem} with {long_content_name(content)}")) + end + end + end +end + +redef class AStbyteInstruction + redef fun accept_types_analysis(v, ins, outs) + do + super + #outs.mem[n_operand.n_value.to_i] = 'b' + var mem = mem_var + if mem isa MemVar then + var content = ins.rs[register] + outs.mem[n_operand.n_value.to_i] = content[1] + end + end + + redef fun accept_types_checker(v) + do + var ins = v.current_line.types_in + var mem = mem_var + if mem isa MemVar and ins != null then + var content = ins.rs[register] + if ins.memory(n_operand.n_value.to_i) == 'c' then + manager.notes.add(new Warn(location, "overwriting code at {mem} with {long_data_name(content[1])}")) + end + end + end +end + +redef class AShiftInstruction + redef fun accept_types_analysis(v, ins, outs) + do + super + end +end + +redef class AArithmeticInstruction + redef fun accept_types_analysis(v, ins, outs) + do + super + outs.rs[register][0] = 'w' + outs.rs[register][1] = 'W' + end + + redef fun accept_types_checker(v) + do + var ins = v.current_line.types_in + if ins == null then return + + # register + var content = ins.rs[register] + verify_word(content, "r{register}") + + # memory source + var mem = mem_var + if mem isa MemVar then + content = [ins.memory(mem.index), ins.memory(mem.index+1)] + verify_word(content, "m{mem.index}") + end + end +end + +redef class ADecoInstruction + redef fun accept_types_checker(v) + do + var ins = v.current_line.types_in + if ins == null then return + + var mem = mem_var + if mem isa MemVar then + var content = [ins.memory(mem.index), ins.memory(mem.index+1)] + verify_word(content, "m{mem.index}") + end + end +end + +redef class ADeciInstruction + redef fun accept_types_analysis(v, ins, outs) + do + super + var mem = mem_var + if mem isa MemVar then + outs.mem[mem.index ] = 'w' + outs.mem[mem.index+1] = 'W' + end + end +end + +redef class AOutputInstruction + fun verify_ascii(content: Char) + do + if content == 'u' then + manager.notes.add(new Warn(location, "use of uninitialized values")) + else if content != 'l' then + if content != 't' or manager.opt_report_unknown_types.value then + manager.notes.add(new Warn(location, "use of non-ascii types ({content})")) + end + end + end +end + +redef class ACharoInstruction + redef fun accept_types_checker(v) + do + var ins = v.current_line.types_in + if ins == null then return + + var mem = mem_var + if mem isa MemVar then + var content = ins.memory(mem.index) + verify_ascii(content) + end + end +end + +redef class AStroInstruction + redef fun accept_types_checker(v) + do + var ins = v.current_line.types_in + if ins == null then return + + var mem = mem_var + if mem isa MemVar then + var content = ins.memory(mem.index) + verify_ascii(content) + end + end +end + +redef class AChariInstruction + redef fun accept_types_analysis(v, ins, outs) + do + super + outs.mem[n_operand.n_value.to_i] = 'l' + end +end + +redef class ABranchInstruction + redef fun accept_types_checker(v) + do + var ins = v.current_line.types_in + if ins == null then return + + var mem = mem_var + if mem isa MemVar then + var content = [ins.memory(mem.index), ins.memory(mem.index+1)] + if content[0] != 'a' or content[1] != 'A' then + manager.notes.add(new Warn(location, "use of non-address data for branching, got {long_content_name(content)}")) + end + end + end +end + +redef class AMovInstruction + redef fun accept_types_analysis(v, ins, outs) + do + super + + outs.rs['A'][0] = 'w' + outs.rs['A'][1] = 'W' + end +end diff --git a/contrib/pep8analysis/src/location.nit b/contrib/pep8analysis/src/location.nit new file mode 100644 index 0000000..b3e8458 --- /dev/null +++ b/contrib/pep8analysis/src/location.nit @@ -0,0 +1,207 @@ +# This file is part of NIT ( http://www.nitlanguage.org ). +# +# Copyright 2009 Jean-Sebastien Gelinas +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# This module is used to model Nit source-file and locations in source-file +module location + +# A raw text Nit source file +class SourceFile + # The path of the source + var filename: String + + # The content of the source + var string: String + + # Create a new sourcefile using a filename and a stream + init(filename: String, stream: IStream) + do + self.filename = filename + string = stream.read_all + line_starts[0] = 0 + end + + # Create a new sourcefile using a dummy filename and a given content + init from_string(filename: String, string: String) + do + self.filename = filename + self.string = string + line_starts[0] = 0 + end + + # Position of each line start + var line_starts: Array[Int] = new Array[Int] +end + +# A location inside a source file +class Location + super Comparable + redef type OTHER: Location + + var file: nullable SourceFile + var line_start: Int + var line_end: Int + var column_start: Int + var column_end: Int + + init(f: nullable SourceFile, line_s: Int, line_e: Int, column_s: Int, column_e: Int) do + file = f + line_start = line_s + line_end = line_e + column_start = column_s + column_end = column_e + end + + # The index in the start character in the source + fun pstart: Int do return file.line_starts[line_start-1] + column_start-1 + + # The index on the end character in the source + fun pend: Int do return file.line_starts[line_end-1] + column_end-1 + + # The verbatim associated text in the source-file + fun text: String + do + var res = self.text_cache + if res != null then return res + var l = self + var pstart = self.pstart + var pend = self.pend + res = l.file.string.substring(pstart, pend-pstart+1) + self.text_cache = res + return res + end + + private var text_cache: nullable String + + init with_file(f: SourceFile) do init(f,0,0,0,0) + + redef fun ==(other: nullable Object): Bool do + if other == null then return false + if not other isa Location then return false + + if other.file != file then return false + if other.line_start != line_start then return false + if other.line_end != line_end then return false + if other.column_start != column_start then return false + if other.column_end != column_end then return false + + return true + end + + fun located_in(loc: nullable Location): Bool do + if loc == null then return false + + if line_start < loc.line_start then return false + if line_start > loc.line_end then return false + + if line_end > loc.line_end then return false + + if line_start == loc.line_start then + if column_start < loc.column_start then return false + if column_start > loc.column_end then return false + end + + if line_end == loc.line_end and column_end > loc.column_end then return false + + return true + end + + redef fun to_s: String do + var file_part = "" + if file != null then + file_part = file.filename + if file.filename.length > 0 then file_part += ":" + end + + if line_start == line_end then + if column_start == column_end then + return "{file_part}{line_start},{column_start}" + else + return "{file_part}{line_start},{column_start}--{column_end}" + end + else + return "{file_part}{line_start},{column_start}--{line_end},{column_end}" + end + end + + fun relative_to(loc: nullable Location): String do + var relative: Location + if loc != null and loc.file == self.file then + relative = new Location(null, self.line_start, self.line_end, self.column_start, self.column_end) + else + relative = new Location(self.file, self.line_start, self.line_end, self.column_start, self.column_end) + end + return relative.to_s + end + + redef fun <(other: OTHER): Bool do + if self == other then return false + if self.located_in(other) then return true + if other.located_in(self) then return false + + if line_start != other.line_start then return line_start < other.line_start + if column_start != other.column_start then return column_start < other.column_start + if line_end != other.line_end then return line_end < other.line_end + + return column_end < other.column_end + end + + # Return the associated line with the location highlihted with color and a carret under the starting position + # `color` must be and terminal escape sequence used as `"{escape}[{color}m;"` + # * `"0;31"` for red + # * `"1;31"` for bright red + # * `"0;32"` for green + fun colored_line(color: String): String + do + var esc = 27.ascii + var def = "{esc}[0m" + var col = "{esc}[{color}m" + + var l = self + var i = l.line_start + var line_start = l.file.line_starts[i-1] + var line_end = line_start + var string = l.file.string + while line_end+1 < string.length and string[line_end+1] != '\n' and string[line_end+1] != '\r' do + line_end += 1 + end + var lstart = string.substring(line_start, l.column_start - 1) + var cend + if i != l.line_end then + cend = line_end - line_start + 1 + else + cend = l.column_end + end + var lmid + var lend + if line_start + cend <= string.length then + lmid = string.substring(line_start + l.column_start - 1, cend - l.column_start + 1) + lend = string.substring(line_start + cend, line_end - line_start - cend + 1) + else + lmid = "" + lend = "" + end + var indent = new Buffer + for j in [line_start..line_start+l.column_start-1[ do + if string[j] == '\t' then + indent.add '\t' + else + indent.add ' ' + end + end + return "\t{lstart}{col}{lmid}{def}{lend}\n\t{indent}^" + end +end + diff --git a/contrib/pep8analysis/src/model/directives.nit b/contrib/pep8analysis/src/model/directives.nit new file mode 100644 index 0000000..73d3086 --- /dev/null +++ b/contrib/pep8analysis/src/model/directives.nit @@ -0,0 +1,27 @@ +import ast + +import operands + +redef class ADirective + fun size: Int is abstract +end +redef class AByteDirective + redef fun size do return 1 +end +redef class AWordDirective + redef fun size do return 2 +end +redef class ABlockDirective + redef fun size do return n_value.to_i +end +redef class AAsciiDirective + fun data: String do return n_value.as(AStringValue).n_string.content + redef fun size do return data.length +end +redef class AAddrssDirective + redef fun size do return 2 +end +redef class AEquateDirective + redef fun size do return 0 +end + diff --git a/contrib/pep8analysis/src/model/model.nit b/contrib/pep8analysis/src/model/model.nit new file mode 100644 index 0000000..beea28d --- /dev/null +++ b/contrib/pep8analysis/src/model/model.nit @@ -0,0 +1,116 @@ +import backbone +import ast + +import directives +import operands +import vars + +redef class AnalysisManager + var model: nullable Model = null + fun build_model(ast: AListing): Model + do + var model = new Model(ast) + self.model = model + return model + end +end + +class Model + # lines to appear on the resulting program + var lines = new Array[ANonEmptyLine] + + # labet to declaation line + var labels_to_line = new HashMap[String,ALine] + var labels_to_address = new HashMap[String,Int] + + # from adress to line + var address_to_line = new HashMap[Int,ANonEmptyLine] + + init (ast: AListing) + do + var offset = 0 + for line in ast.n_lines do + # TODO if directive = equate + var label_decl = line.n_label_decl + if label_decl != null then + var lbl = label_decl.n_id + var label_name = lbl.text + + if line isa ADirectiveLine and line.n_directive isa AEquateDirective then + # .EQUATE + labels_to_address[label_name] = line.n_directive.as(AEquateDirective).n_value.to_i + lbl.labels_to_address[label_name] = line.n_directive.as(AEquateDirective).n_value.to_i + else + labels_to_address[label_name] = offset + lbl.labels_to_address[label_name] = offset + end + end + + line.address = offset + + if line isa ANonEmptyLine and line.size > 0 then + lines.add( line ) + address_to_line[offset] = line + end + offset += line.size + end + + for lbl,address in labels_to_address do + if address_to_line.has_key(address) then + var line = address_to_line[address] + labels_to_line[lbl] = line + end + end + end +end + +redef class ALine + var address: Int = -1 + + fun size: Int is abstract + + redef fun to_s do return "L{address}" + + redef fun text + do + var text = super + var size = size + if size > 0 then + return "L{location.to_line_s} (m{address}..{address+size}): {text}" + else + return "L{location.to_line_s}: {text}" + end + end + + fun lbl: nullable String + do + var lbl_decl = n_label_decl + if lbl_decl != null then + var lbl = lbl_decl.n_id.text + return lbl + else return null + end +end +redef class AInstructionLine + redef fun size do return 4 +end +redef class ADirectiveLine + redef fun size do return n_directive.size +end +redef class AEmptyLine + redef fun size do return 0 +end + +redef class MemVar + redef fun to_s do + var ltl = manager.model.address_to_line + if ltl.has_key(index) then + var line = ltl[index] + var lbl = line.lbl + if lbl != null then + return "{lbl}@m{index}" + end + end + return "m{index}" + end +end diff --git a/contrib/pep8analysis/src/model/operands.nit b/contrib/pep8analysis/src/model/operands.nit new file mode 100644 index 0000000..592e1af --- /dev/null +++ b/contrib/pep8analysis/src/model/operands.nit @@ -0,0 +1,51 @@ +import ast + +redef class AValue + fun to_i: Int is abstract +end + +redef class ALabelValue + redef fun to_i do + if not n_id.labels_to_address.has_key(n_id.text) then + manager.fatal_error( self, "Label {n_id.text} used but not defined.") + return 0 + else + return n_id.labels_to_address[n_id.text] + end + end +end +redef class TId + var labels_to_address: HashMap[String,Int] = (once new HashMap[String,Int]) + #redef fun to_i: Int do return label_to_address[text] +end + +redef class ANumberValue + redef fun to_i do return n_number.text.to_i +end + +redef class ACharValue + redef fun to_i do return n_char.content.first.ascii +end + +redef class AStringValue + # legal but no not recommended + redef fun to_i do return n_string.content.first.ascii +end + +redef class AHexValue + #TODO + redef fun to_i do return n_hex.text.to_hex +end + +redef class TString # TkBlock + fun content : String + do + return text.substring(1, text.length-2) + end +end +redef class TChar # TkAscii + fun content : String + do + return text.substring(1, text.length-2) + end +end diff --git a/contrib/pep8analysis/src/model/vars.nit b/contrib/pep8analysis/src/model/vars.nit new file mode 100644 index 0000000..94aa4ca --- /dev/null +++ b/contrib/pep8analysis/src/model/vars.nit @@ -0,0 +1,105 @@ +module vars + +import ast + +import operands + +class Var +end + +class RegisterVar + super Var + + init (register: Char) do self.register = register + + var register: Char + + redef fun to_s do return "r{register}" + + redef fun ==(o) do return o isa RegisterVar and register == o.register + redef fun hash do return 128 + register.hash +end + +class StackVar + super Var + + init (offset: Int) do self.offset = offset + + var offset: Int + + redef fun ==(o) do return o isa StackVar and offset == o.offset + redef fun hash do return 512 + offset.hash +end + +class MemVar + super Var + + init (index: Int) do self.index = index + + var index: Int + + # need Object::AnalysisManager + #redef fun to_s is abstract + + redef fun ==(o) do return o isa MemVar and index == o.index + redef fun hash do return 1024 + index.hash +end + +redef class AInstruction + fun def_var: nullable Var is abstract + fun src_var: nullable Var is abstract +end + +redef class ABinaryInstruction + fun mem_var: nullable Var do return n_operand.to_var +end + +redef class ALoadInstruction + redef fun def_var do return new RegisterVar(register) + redef fun src_var do return n_operand.to_var +end + +redef class AStoreInstruction + redef fun def_var do return n_operand.to_var + redef fun src_var do return new RegisterVar(register) +end + +redef class AInputInstruction + redef fun def_var do return n_operand.to_var +end + +redef class ARegisterSuffixed + fun reg_var: Var do return new RegisterVar(register) +end + +redef class AArithmeticInstruction +end + +redef class AOperand + fun to_var: nullable Var is abstract +end + +redef class AImmediateOperand + redef fun to_var do return null +end + +redef class AAnyOperand + fun addressing_mode: String do return n_id.text + redef fun to_var + do + if addressing_mode == "i" then + else if addressing_mode == "d" then + return new MemVar(n_value.to_i) + else if addressing_mode == "n" then + else if addressing_mode == "s" then + return new StackVar(n_value.to_i) + else if addressing_mode == "sf" then + else if addressing_mode == "x" then + else if addressing_mode == "sx" then + else if addressing_mode == "sxf" then + end + + return null + end +end + diff --git a/contrib/pep8analysis/src/parser/README b/contrib/pep8analysis/src/parser/README new file mode 100644 index 0000000..227bcfc --- /dev/null +++ b/contrib/pep8analysis/src/parser/README @@ -0,0 +1,30 @@ +This directory contains the nit parser. It is generated from a grammar for sablecc3 ( http://www.sablecc.org ). +In order to generate nit parser, you need the alternate SableCC3 generator ( http://www.mare.ee/indrek/sablecc/ ). + +Contents: + + fact_parser.pl: Script used to factorize parser.nit + Makefile: Update grammar and generate .nit files + nit.sablecc3xx: Extended sablecc3 grammar (see prescc.sh) + prescc.sh: Program to transform an extended sablecc3 to a standard one + parser_nodes.nit: token and nodes classes hierarchy used by the parser and the lexer + tables.nit, tables_nit.h: Interfaces to access the tables needed by the parser and the lexer + test_parser.nit: + xss/*.xss: alternate SableCC3 template files for the Nit language + + +The following are generated but present to avoid the need of sablecc3: + + lexer.nit: generated lexer + parser.nit: generated parser + parser_prod.nit: All production with generated visit methods + tables_nit.c: The tables needed by the parser and the lexer + parser_abs.nit: Raw generated token and nodes classes used to maintain coherence of parser_nodes.nit + + +Other temp files produced by the Makefile: + + .nit.sablecc3: Sablecc3 grammar after processing + .nit.sablecc3.dump: Dump of the grammar to improve sablecc3 multiple runs + .parser-nofact.nit: The parser generated by SableCC3 before factorization by fact_parser.pl + diff --git a/contrib/pep8analysis/src/parser/fact_parser.pl b/contrib/pep8analysis/src/parser/fact_parser.pl new file mode 100755 index 0000000..df7c9cf --- /dev/null +++ b/contrib/pep8analysis/src/parser/fact_parser.pl @@ -0,0 +1,84 @@ +#!/usr/bin/perl + +# This file is part of NIT ( http://www.nitlanguage.org ). +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# fact_parser, a Sablecc postprocessor. +# +# Factorize comon actions in a generated sablecc parser file +# Synopsys: fact_parser < infile > outfile + +use warnings; + +%actions = (); # body of an action -> id of the first action with this body +%dupl = (); # id of a duplicate action -> id of the first action with this body + +@text = (); # Resulting file +$start = 0; # current mode: 0=begin of file; 1=after an action; 2=inside an action +$tot = 0; # original total number of actions +$cpt = 0; # final total number of action +while (<>) { + # Process the body of the action? + if ($start == 2) { + push @action, $_; + if (/ new (?!Array)/) { $has_new = 1; } + } + + # Start a new action? + if (/private class ReduceAction(\d+)/) { + $tot++; + $start = 2; + $nb = $1; # Identifier of the action + $head = $_; # The declaration line + @action = (); # Body of the action + $has_new = 0; # Is a new something used? + } + + # Process the begin of the file? + if ($start == 0) { push @text, $_; } + + # End of an action? + if ($start == 2 and /^end/) { + # Build the action body by filtering useless new + $action = ""; + foreach $l (@action) { + if ($has_new or $l !~ / isa (?!Array)/) { $action .= $l; } + } + + # Is it an original action? + if (not defined $actions{$action}) { + # Yes, so register it + $actions{$action} = $nb; + push @text, $head, $action; + $cpt++; + } else { + # No, so link the duplicate to the original + $mainnb = $actions{$action}; + $dupl{$nb} = $mainnb; + } + $start = 1; + } +} + +# Substitute duplicate actions with the originals in the whole file +foreach (@text) { + if (/ReduceAction(\d+)/ && defined $dupl{$1}) { + $d = $dupl{$1}; + s/$1/$d/; + } +} + +print STDERR "* fact_parser: $tot -> $cpt\n"; + +print @text; diff --git a/contrib/pep8analysis/src/parser/lexer.nit b/contrib/pep8analysis/src/parser/lexer.nit new file mode 100644 index 0000000..5f02813 --- /dev/null +++ b/contrib/pep8analysis/src/parser/lexer.nit @@ -0,0 +1,487 @@ +# Lexer and its tokens. +# This file was generated by SableCC (http://www.sablecc.org/). +module lexer + +intrude import parser_nodes +private import tables + +redef class Token + var _text: nullable String + + redef fun text + do + var res = _text + if res != null then return res + res = location.text + _text = res + return res + end + + fun parser_index: Int is abstract +end + +redef class TEol + redef fun parser_index: Int + do + return 0 + end + + init init_tk(loc: Location) + do + _location = loc + end +end + +redef class TNumber + redef fun parser_index: Int + do + return 1 + end + + init init_tk(loc: Location) + do + _location = loc + end +end + +redef class TFloat + redef fun parser_index: Int + do + return 2 + end + + init init_tk(loc: Location) + do + _location = loc + end +end + +redef class TChar + redef fun parser_index: Int + do + return 3 + end + + init init_tk(loc: Location) + do + _location = loc + end +end + +redef class TString + redef fun parser_index: Int + do + return 4 + end + + init init_tk(loc: Location) + do + _location = loc + end +end + +redef class THex + redef fun parser_index: Int + do + return 5 + end + + init init_tk(loc: Location) + do + _location = loc + end +end + +redef class TColon + redef fun parser_index: Int + do + return 6 + end + + init init_tk(loc: Location) + do + _location = loc + end +end + +redef class TComma + redef fun parser_index: Int + do + return 7 + end + + init init_tk(loc: Location) + do + _location = loc + end +end + +redef class TComment + redef fun parser_index: Int + do + return 8 + end + + init init_tk(loc: Location) + do + _location = loc + end +end + +redef class TTkByte + redef fun parser_index: Int + do + return 9 + end + + init init_tk(loc: Location) + do + _location = loc + end +end + +redef class TTkWord + redef fun parser_index: Int + do + return 10 + end + + init init_tk(loc: Location) + do + _location = loc + end +end + +redef class TTkBlock + redef fun parser_index: Int + do + return 11 + end + + init init_tk(loc: Location) + do + _location = loc + end +end + +redef class TTkAscii + redef fun parser_index: Int + do + return 12 + end + + init init_tk(loc: Location) + do + _location = loc + end +end + +redef class TTkAddrss + redef fun parser_index: Int + do + return 13 + end + + init init_tk(loc: Location) + do + _location = loc + end +end + +redef class TTkEquate + redef fun parser_index: Int + do + return 14 + end + + init init_tk(loc: Location) + do + _location = loc + end +end + +redef class TTkBurn + redef fun parser_index: Int + do + return 15 + end + + init init_tk(loc: Location) + do + _location = loc + end +end + +redef class TEndBlock + redef fun parser_index: Int + do + return 16 + end + + init init_tk(loc: Location) + do + _location = loc + end +end + +redef class TId + redef fun parser_index: Int + do + return 17 + end + + init init_tk(loc: Location) + do + _location = loc + end +end + + +redef class EOF + redef fun parser_index: Int + do + return 18 + end + + init(loc: Location) + do + _text = "" + _location = loc + end +end + +redef class AError + readable var _message: String + + init init_error(message: String, loc: Location) + do + init(loc) + _message = message + end +end + + +# The lexer extract NIT tokens from an input stream. +# It is better user with the Parser +class Lexer + super TablesCapable + # Last peeked token + var _token: nullable Token + + # Lexer current state + var _state: Int = 0 + + # The source file + readable var _file: SourceFile + + # Current character in the stream + var _stream_pos: Int = 0 + + # Current line number in the input stream + var _line: Int = 0 + + # Current column in the input stream + var _pos: Int = 0 + + # Was the last character a cariage-return? + var _cr: Bool = false + + # Constante state values + private fun state_initial: Int do return 0 end + + # Create a new lexer for a stream (and a name) + init(file: SourceFile) + do + _file = file + end + + # Give the next token (but do not consume it) + fun peek: Token + do + while _token == null do + _token = get_token + end + return _token.as(not null) + end + + # Give and consume the next token + fun next: Token + do + var result = _token + while result == null do + result = get_token + end + _token = null + return result + end + + # Get a token, or null if it is discarded + private fun get_token: nullable Token + do + var dfa_state = 0 + + var sp = _stream_pos + var start_stream_pos = sp + var start_pos = _pos + var start_line = _line + var string = _file.string + var string_len = string.length + + var accept_state = -1 + var accept_token = -1 + var accept_length = -1 + var accept_pos = -1 + var accept_line = -1 + + loop + if sp >= string_len then + dfa_state = -1 + else + var c = string[sp].ascii + sp += 1 + + var cr = _cr + var line = _line + var pos = _pos + if c == 10 then + if cr then + cr = false + _file.line_starts[line] = sp + else + line = line + 1 + pos = 0 + _file.line_starts[line] = sp + end + else if c == 13 then + line = line + 1 + pos = 0 + cr = true + _file.line_starts[line] = sp + else + pos = pos + 1 + cr = false + end + + loop + var old_state = dfa_state + if dfa_state < -1 then + old_state = -2 - dfa_state + end + + dfa_state = -1 + + var low = 0 + var high = lexer_goto(old_state, 0) - 1 + + if high >= 0 then + while low <= high do + var middle = (low + high) / 2 + var offset = middle * 3 + 1 # +1 because length is at 0 + + if c < lexer_goto(old_state, offset) then + high = middle - 1 + else if c > lexer_goto(old_state, offset+1) then + low = middle + 1 + else + dfa_state = lexer_goto(old_state, offset+2) + break + end + end + end + if dfa_state > -2 then break + end + + _cr = cr + _line = line + _pos = pos + end + + if dfa_state >= 0 then + var tok = lexer_accept(dfa_state) + if tok != -1 then + accept_state = dfa_state + accept_token = tok + accept_length = sp - start_stream_pos + accept_pos = _pos + accept_line = _line + end + else + if accept_state != -1 then + var location = new Location(_file, start_line + 1, accept_line + 1, start_pos + 1, accept_pos) + _pos = accept_pos + _line = accept_line + _stream_pos = start_stream_pos + accept_length + if accept_token == 0 then + return null + end + if accept_token == 1 then + return new TEol.init_tk(location) + end + if accept_token == 2 then + return new TNumber.init_tk(location) + end + if accept_token == 3 then + return new TFloat.init_tk(location) + end + if accept_token == 4 then + return new TChar.init_tk(location) + end + if accept_token == 5 then + return new TString.init_tk(location) + end + if accept_token == 6 then + return new THex.init_tk(location) + end + if accept_token == 7 then + return new TColon.init_tk(location) + end + if accept_token == 8 then + return new TComma.init_tk(location) + end + if accept_token == 9 then + return new TComment.init_tk(location) + end + if accept_token == 10 then + return new TTkByte.init_tk(location) + end + if accept_token == 11 then + return new TTkWord.init_tk(location) + end + if accept_token == 12 then + return new TTkBlock.init_tk(location) + end + if accept_token == 13 then + return new TTkAscii.init_tk(location) + end + if accept_token == 14 then + return new TTkAddrss.init_tk(location) + end + if accept_token == 15 then + return new TTkEquate.init_tk(location) + end + if accept_token == 16 then + return new TTkBurn.init_tk(location) + end + if accept_token == 17 then + return new TEndBlock.init_tk(location) + end + if accept_token == 18 then + return new TId.init_tk(location) + end + else + _stream_pos = sp + var location = new Location(_file, start_line + 1, start_line + 1, start_pos + 1, start_pos + 1) + if sp > start_stream_pos then + var text = string.substring(start_stream_pos, sp-start_stream_pos) + var token = new AError.init_error("Syntax error: unknown token {text}.", location) + return token + else + var token = new EOF(location) + return token + end + end + end + end + end +end + diff --git a/contrib/pep8analysis/src/parser/parser.nit b/contrib/pep8analysis/src/parser/parser.nit new file mode 100644 index 0000000..3e57cee --- /dev/null +++ b/contrib/pep8analysis/src/parser/parser.nit @@ -0,0 +1,1002 @@ +# Parser. +# This file was generated by SableCC (http://www.sablecc.org/). +module parser + +intrude import parser_prod +import tables + +# State of the parser automata as stored in the parser stack. +private class State + # The internal state number + readable writable var _state: Int + + # The node stored with the state in the stack + readable writable var _nodes: nullable Object + + init(state: Int, nodes: nullable Object) + do + _state = state + _nodes = nodes + end +end + +class Parser + super TablesCapable + # Associated lexer + var _lexer: Lexer + + # Stack of pushed states and productions + var _stack: Array[State] + + # Position in the stack + var _stack_pos: Int + + # Create a new parser based on a given lexer + init(lexer: Lexer) + do + _lexer = lexer + _stack = new Array[State] + _stack_pos = -1 + build_reduce_table + end + + # Do a transition in the automata + private fun go_to(index: Int): Int + do + var state = state + var low = 1 + var high = parser_goto(index, 0) - 1 + + while low <= high do + var middle = (low + high) / 2 + var subindex = middle * 2 + 1 # +1 because parser_goto(index, 0) is the length + + var goal = parser_goto(index, subindex) + if state < goal then + high = middle - 1 + else if state > goal then + low = middle + 1 + else + return parser_goto(index, subindex+1) + end + end + + return parser_goto(index, 2) # Default value + end + + # Push someting in the state stack + private fun push(numstate: Int, list_node: nullable Object) + do + var pos = _stack_pos + 1 + _stack_pos = pos + if pos < _stack.length then + var state = _stack[pos] + state.state = numstate + state.nodes = list_node + else + _stack.push(new State(numstate, list_node)) + end + end + + # The current state + private fun state: Int + do + return _stack[_stack_pos].state + end + + # Pop something from the stack state + private fun pop: nullable Object + do + var res = _stack[_stack_pos].nodes + _stack_pos = _stack_pos -1 + return res + end + + # Build and return a full AST. + fun parse: Start + do + push(0, null) + + var lexer = _lexer + loop + var token = lexer.peek + if token isa AError then + return new Start(null, token) + end + + var state = self.state + var index = token.parser_index + var action_type = parser_action(state, 2) + var action_value = parser_action(state, 3) + + var low = 1 + var high = parser_action(state, 0) - 1 + + while low <= high do + var middle = (low + high) / 2 + var subindex = middle * 3 + 1 # +1 because parser_action(state, 0) is the length + + var goal = parser_action(state, subindex) + if index < goal then + high = middle - 1 + else if index > goal then + low = middle + 1 + else + action_type = parser_action(state, subindex+1) + action_value = parser_action(state, subindex+2) + break + end + end + + if action_type == 0 then # SHIFT + push(action_value, lexer.next) + else if action_type == 1 then # REDUCE + _reduce_table[action_value].action(self) + else if action_type == 2 then # ACCEPT + var node2 = lexer.next + assert node2 isa EOF + var node1 = pop + assert node1 isa AListing + var node = new Start(node1, node2) + (new ComputeProdLocationVisitor).enter_visit(node) + return node + else if action_type == 3 then # ERROR + var node2 = new AError.init_error("Syntax error: unexpected {token}.", token.location) + var node = new Start(null, node2) + return node + end + end + end + + var _reduce_table: Array[ReduceAction] + private fun build_reduce_table + do + _reduce_table = new Array[ReduceAction].with_items( + new ReduceAction0(0), + new ReduceAction1(0), + new ReduceAction2(0), + new ReduceAction3(0), + new ReduceAction4(1), + new ReduceAction5(1), + new ReduceAction6(1), + new ReduceAction7(1), + new ReduceAction8(1), + new ReduceAction9(1), + new ReduceAction10(1), + new ReduceAction11(1), + new ReduceAction12(1), + new ReduceAction13(1), + new ReduceAction14(1), + new ReduceAction15(1), + new ReduceAction16(2), + new ReduceAction17(3), + new ReduceAction18(3), + new ReduceAction19(4), + new ReduceAction20(4), + new ReduceAction21(5), + new ReduceAction22(5), + new ReduceAction23(5), + new ReduceAction24(5), + new ReduceAction25(5), + new ReduceAction26(6), + new ReduceAction27(6), + new ReduceAction28(6), + new ReduceAction29(6), + new ReduceAction30(6), + new ReduceAction31(6), + new ReduceAction32(6), + new ReduceAction33(7), + new ReduceAction34(7) + ) + end +end + +redef class Prod + # Location on the first token after the start of a production + # So outside the production for epilon production + var _first_location: nullable Location + + # Location of the last token before the end of a production + # So outside the production for epilon production + var _last_location: nullable Location +end + +# Find location of production nodes +# Uses existing token locations to infer location of productions. +private class ComputeProdLocationVisitor + super Visitor + # Currenlty visited productions that need a first token + var _need_first_prods: Array[Prod] = new Array[Prod] + + # Already visited epsilon productions that waits something after them + var _need_after_epsilons: Array[Prod] = new Array[Prod] + + # Already visited epsilon production that waits something before them + var _need_before_epsilons: Array[Prod] = new Array[Prod] + + # Location of the last visited token in the current production + var _last_location: nullable Location = null + + redef fun visit(n: nullable ANode) + do + if n == null then + return + else if n isa Token then + var loc = n.location + _last_location = loc + + # Add a first token to productions that need one + if not _need_first_prods.is_empty then + for no in _need_first_prods do + no._first_location = loc + end + _need_first_prods.clear + end + + # Find location for already visited epsilon production that need one + if not _need_after_epsilons.is_empty then + for no in _need_after_epsilons do + # Epsilon production that is in the middle of a non-epsilon production + # The epsilon production has both a token before and after it + var endl = loc + var startl = no._last_location + no.location = new Location(endl.file, startl.line_end, endl.line_start, startl.column_end, endl.column_start) + end + _need_after_epsilons.clear + end + else + assert n isa Prod + _need_first_prods.add(n) + + var old_last = _last_location + _last_location = null + n.visit_all(self) + var endl = _last_location + if endl == null then _last_location = old_last + + n._last_location = endl + var startl = n._first_location + if startl != null then + # Non-epsilon production + assert endl != null + + n.location = new Location(startl.file, startl.line_start, endl.line_end, startl.column_start, endl.column_end) + + if not _need_before_epsilons.is_empty then + var loc = new Location(startl.file, startl.line_start, startl.line_start, startl.column_start, startl.column_start) + for no in _need_before_epsilons do + # Epsilon production that starts the current non-epsilon production + no.location = loc + end + _need_before_epsilons.clear + end + + if not _need_after_epsilons.is_empty then + var loc = new Location(endl.file, endl.line_end, endl.line_end, endl.column_end, endl.column_end) + for no in _need_after_epsilons do + # Epsilon production that finishes the current non-epsilon production + no.location = loc + end + _need_after_epsilons.clear + end + else + # No first token means epsilon production (or "throw all my tokens" production) + # So, it must be located it later + if endl == null then + # Epsilon production that starts a parent non-epsilon production + _need_before_epsilons.add(n) + else + # Epsilon production in the middle or that finishes a parent non-epsilon production + _need_after_epsilons.add(n) + end + end + end + end + + init do end +end + +# Each reduca action has its own class, this one is the root of the hierarchy. +private abstract class ReduceAction + fun action(p: Parser) is abstract + fun concat(l1, l2 : Array[Object]): Array[Object] + do + if l1.is_empty then return l2 + l1.append(l2) + return l1 + end + var _goto: Int + init(g: Int) do _goto = g +end + +private class ReduceAction0 + super ReduceAction + redef fun action(p: Parser) + do + var node_list: nullable Object = null + var nodearraylist1 = p.pop + var listnode2 = new Array[Object] + var tendblocknode4 = nodearraylist1 + assert tendblocknode4 isa nullable TEndBlock + var plistingnode1: nullable AListing = new AListing.init_alisting( + listnode2, + null, + tendblocknode4 + ) + node_list = plistingnode1 + p.push(p.go_to(_goto), node_list) + end +end +private class ReduceAction1 + super ReduceAction + redef fun action(p: Parser) + do + var node_list: nullable Object = null + var nodearraylist2 = p.pop + var nodearraylist1 = p.pop + var listnode3 = new Array[Object] + var listnode2 = nodearraylist1 + assert listnode2 isa Array[Object] + listnode3 = concat(listnode3, listnode2) + var tendblocknode5 = nodearraylist2 + assert tendblocknode5 isa nullable TEndBlock + var plistingnode1: nullable AListing = new AListing.init_alisting( + listnode3, + null, + tendblocknode5 + ) + node_list = plistingnode1 + p.push(p.go_to(_goto), node_list) + end +end +private class ReduceAction2 + super ReduceAction + redef fun action(p: Parser) + do + var node_list: nullable Object = null + var nodearraylist2 = p.pop + var nodearraylist1 = p.pop + var listnode2 = new Array[Object] + var plabeldeclnode3 = nodearraylist1 + assert plabeldeclnode3 isa nullable ALabelDecl + var tendblocknode4 = nodearraylist2 + assert tendblocknode4 isa nullable TEndBlock + var plistingnode1: nullable AListing = new AListing.init_alisting( + listnode2, + plabeldeclnode3, + tendblocknode4 + ) + node_list = plistingnode1 + p.push(p.go_to(_goto), node_list) + end +end +private class ReduceAction3 + super ReduceAction + redef fun action(p: Parser) + do + var node_list: nullable Object = null + var nodearraylist3 = p.pop + var nodearraylist2 = p.pop + var nodearraylist1 = p.pop + var listnode3 = new Array[Object] + var listnode2 = nodearraylist1 + assert listnode2 isa Array[Object] + listnode3 = concat(listnode3, listnode2) + var plabeldeclnode4 = nodearraylist2 + assert plabeldeclnode4 isa nullable ALabelDecl + var tendblocknode5 = nodearraylist3 + assert tendblocknode5 isa nullable TEndBlock + var plistingnode1: nullable AListing = new AListing.init_alisting( + listnode3, + plabeldeclnode4, + tendblocknode5 + ) + node_list = plistingnode1 + p.push(p.go_to(_goto), node_list) + end +end +private class ReduceAction4 + super ReduceAction + redef fun action(p: Parser) + do + var node_list: nullable Object = null + var nodearraylist1 = p.pop + var teolnode4 = nodearraylist1 + assert teolnode4 isa nullable TEol + var plinenode1: nullable AEmptyLine = new AEmptyLine.init_aemptyline( + null, + null, + teolnode4 + ) + node_list = plinenode1 + p.push(p.go_to(_goto), node_list) + end +end +private class ReduceAction5 + super ReduceAction + redef fun action(p: Parser) + do + var node_list: nullable Object = null + var nodearraylist2 = p.pop + var nodearraylist1 = p.pop + var plabeldeclnode2 = nodearraylist1 + assert plabeldeclnode2 isa nullable ALabelDecl + var teolnode4 = nodearraylist2 + assert teolnode4 isa nullable TEol + var plinenode1: nullable AEmptyLine = new AEmptyLine.init_aemptyline( + plabeldeclnode2, + null, + teolnode4 + ) + node_list = plinenode1 + p.push(p.go_to(_goto), node_list) + end +end +private class ReduceAction6 + super ReduceAction + redef fun action(p: Parser) + do + var node_list: nullable Object = null + var nodearraylist2 = p.pop + var nodearraylist1 = p.pop + var tcommentnode3 = nodearraylist1 + assert tcommentnode3 isa nullable TComment + var teolnode4 = nodearraylist2 + assert teolnode4 isa nullable TEol + var plinenode1: nullable AEmptyLine = new AEmptyLine.init_aemptyline( + null, + tcommentnode3, + teolnode4 + ) + node_list = plinenode1 + p.push(p.go_to(_goto), node_list) + end +end +private class ReduceAction7 + super ReduceAction + redef fun action(p: Parser) + do + var node_list: nullable Object = null + var nodearraylist3 = p.pop + var nodearraylist2 = p.pop + var nodearraylist1 = p.pop + var plabeldeclnode2 = nodearraylist1 + assert plabeldeclnode2 isa nullable ALabelDecl + var tcommentnode3 = nodearraylist2 + assert tcommentnode3 isa nullable TComment + var teolnode4 = nodearraylist3 + assert teolnode4 isa nullable TEol + var plinenode1: nullable AEmptyLine = new AEmptyLine.init_aemptyline( + plabeldeclnode2, + tcommentnode3, + teolnode4 + ) + node_list = plinenode1 + p.push(p.go_to(_goto), node_list) + end +end +private class ReduceAction8 + super ReduceAction + redef fun action(p: Parser) + do + var node_list: nullable Object = null + var nodearraylist2 = p.pop + var nodearraylist1 = p.pop + var pinstructionnode3 = nodearraylist1 + assert pinstructionnode3 isa nullable AInstruction + var teolnode5 = nodearraylist2 + assert teolnode5 isa nullable TEol + var plinenode1: nullable AInstructionLine = new AInstructionLine.init_ainstructionline( + null, + pinstructionnode3, + null, + teolnode5 + ) + node_list = plinenode1 + p.push(p.go_to(_goto), node_list) + end +end +private class ReduceAction9 + super ReduceAction + redef fun action(p: Parser) + do + var node_list: nullable Object = null + var nodearraylist3 = p.pop + var nodearraylist2 = p.pop + var nodearraylist1 = p.pop + var plabeldeclnode2 = nodearraylist1 + assert plabeldeclnode2 isa nullable ALabelDecl + var pinstructionnode3 = nodearraylist2 + assert pinstructionnode3 isa nullable AInstruction + var teolnode5 = nodearraylist3 + assert teolnode5 isa nullable TEol + var plinenode1: nullable AInstructionLine = new AInstructionLine.init_ainstructionline( + plabeldeclnode2, + pinstructionnode3, + null, + teolnode5 + ) + node_list = plinenode1 + p.push(p.go_to(_goto), node_list) + end +end +private class ReduceAction10 + super ReduceAction + redef fun action(p: Parser) + do + var node_list: nullable Object = null + var nodearraylist3 = p.pop + var nodearraylist2 = p.pop + var nodearraylist1 = p.pop + var pinstructionnode3 = nodearraylist1 + assert pinstructionnode3 isa nullable AInstruction + var tcommentnode4 = nodearraylist2 + assert tcommentnode4 isa nullable TComment + var teolnode5 = nodearraylist3 + assert teolnode5 isa nullable TEol + var plinenode1: nullable AInstructionLine = new AInstructionLine.init_ainstructionline( + null, + pinstructionnode3, + tcommentnode4, + teolnode5 + ) + node_list = plinenode1 + p.push(p.go_to(_goto), node_list) + end +end +private class ReduceAction11 + super ReduceAction + redef fun action(p: Parser) + do + var node_list: nullable Object = null + var nodearraylist4 = p.pop + var nodearraylist3 = p.pop + var nodearraylist2 = p.pop + var nodearraylist1 = p.pop + var plabeldeclnode2 = nodearraylist1 + assert plabeldeclnode2 isa nullable ALabelDecl + var pinstructionnode3 = nodearraylist2 + assert pinstructionnode3 isa nullable AInstruction + var tcommentnode4 = nodearraylist3 + assert tcommentnode4 isa nullable TComment + var teolnode5 = nodearraylist4 + assert teolnode5 isa nullable TEol + var plinenode1: nullable AInstructionLine = new AInstructionLine.init_ainstructionline( + plabeldeclnode2, + pinstructionnode3, + tcommentnode4, + teolnode5 + ) + node_list = plinenode1 + p.push(p.go_to(_goto), node_list) + end +end +private class ReduceAction12 + super ReduceAction + redef fun action(p: Parser) + do + var node_list: nullable Object = null + var nodearraylist2 = p.pop + var nodearraylist1 = p.pop + var pdirectivenode3 = nodearraylist1 + assert pdirectivenode3 isa nullable ADirective + var teolnode5 = nodearraylist2 + assert teolnode5 isa nullable TEol + var plinenode1: nullable ADirectiveLine = new ADirectiveLine.init_adirectiveline( + null, + pdirectivenode3, + null, + teolnode5 + ) + node_list = plinenode1 + p.push(p.go_to(_goto), node_list) + end +end +private class ReduceAction13 + super ReduceAction + redef fun action(p: Parser) + do + var node_list: nullable Object = null + var nodearraylist3 = p.pop + var nodearraylist2 = p.pop + var nodearraylist1 = p.pop + var plabeldeclnode2 = nodearraylist1 + assert plabeldeclnode2 isa nullable ALabelDecl + var pdirectivenode3 = nodearraylist2 + assert pdirectivenode3 isa nullable ADirective + var teolnode5 = nodearraylist3 + assert teolnode5 isa nullable TEol + var plinenode1: nullable ADirectiveLine = new ADirectiveLine.init_adirectiveline( + plabeldeclnode2, + pdirectivenode3, + null, + teolnode5 + ) + node_list = plinenode1 + p.push(p.go_to(_goto), node_list) + end +end +private class ReduceAction14 + super ReduceAction + redef fun action(p: Parser) + do + var node_list: nullable Object = null + var nodearraylist3 = p.pop + var nodearraylist2 = p.pop + var nodearraylist1 = p.pop + var pdirectivenode3 = nodearraylist1 + assert pdirectivenode3 isa nullable ADirective + var tcommentnode4 = nodearraylist2 + assert tcommentnode4 isa nullable TComment + var teolnode5 = nodearraylist3 + assert teolnode5 isa nullable TEol + var plinenode1: nullable ADirectiveLine = new ADirectiveLine.init_adirectiveline( + null, + pdirectivenode3, + tcommentnode4, + teolnode5 + ) + node_list = plinenode1 + p.push(p.go_to(_goto), node_list) + end +end +private class ReduceAction15 + super ReduceAction + redef fun action(p: Parser) + do + var node_list: nullable Object = null + var nodearraylist4 = p.pop + var nodearraylist3 = p.pop + var nodearraylist2 = p.pop + var nodearraylist1 = p.pop + var plabeldeclnode2 = nodearraylist1 + assert plabeldeclnode2 isa nullable ALabelDecl + var pdirectivenode3 = nodearraylist2 + assert pdirectivenode3 isa nullable ADirective + var tcommentnode4 = nodearraylist3 + assert tcommentnode4 isa nullable TComment + var teolnode5 = nodearraylist4 + assert teolnode5 isa nullable TEol + var plinenode1: nullable ADirectiveLine = new ADirectiveLine.init_adirectiveline( + plabeldeclnode2, + pdirectivenode3, + tcommentnode4, + teolnode5 + ) + node_list = plinenode1 + p.push(p.go_to(_goto), node_list) + end +end +private class ReduceAction16 + super ReduceAction + redef fun action(p: Parser) + do + var node_list: nullable Object = null + var nodearraylist2 = p.pop + var nodearraylist1 = p.pop + var tidnode2 = nodearraylist1 + assert tidnode2 isa nullable TId + var tcolonnode3 = nodearraylist2 + assert tcolonnode3 isa nullable TColon + var plabeldeclnode1: nullable ALabelDecl = new ALabelDecl.init_alabeldecl( + tidnode2, + tcolonnode3 + ) + node_list = plabeldeclnode1 + p.push(p.go_to(_goto), node_list) + end +end +private class ReduceAction17 + super ReduceAction + redef fun action(p: Parser) + do + var node_list: nullable Object = null + var nodearraylist1 = p.pop + var tidnode2 = nodearraylist1 + assert tidnode2 isa nullable TId + var pinstructionnode1: nullable AUnaryInstruction = new AUnaryInstruction.init_aunaryinstruction( + tidnode2 + ) + node_list = pinstructionnode1 + p.push(p.go_to(_goto), node_list) + end +end +private class ReduceAction18 + super ReduceAction + redef fun action(p: Parser) + do + var node_list: nullable Object = null + var nodearraylist2 = p.pop + var nodearraylist1 = p.pop + var tidnode2 = nodearraylist1 + assert tidnode2 isa nullable TId + var poperandnode3 = nodearraylist2 + assert poperandnode3 isa nullable AOperand + var pinstructionnode1: nullable ABinaryInstruction = new ABinaryInstruction.init_abinaryinstruction( + tidnode2, + poperandnode3 + ) + node_list = pinstructionnode1 + p.push(p.go_to(_goto), node_list) + end +end +private class ReduceAction19 + super ReduceAction + redef fun action(p: Parser) + do + var node_list: nullable Object = null + var nodearraylist1 = p.pop + var pvaluenode2 = nodearraylist1 + assert pvaluenode2 isa nullable AValue + var poperandnode1: nullable AImmediateOperand = new AImmediateOperand.init_aimmediateoperand( + pvaluenode2 + ) + node_list = poperandnode1 + p.push(p.go_to(_goto), node_list) + end +end +private class ReduceAction20 + super ReduceAction + redef fun action(p: Parser) + do + var node_list: nullable Object = null + var nodearraylist3 = p.pop + var nodearraylist2 = p.pop + var nodearraylist1 = p.pop + var pvaluenode2 = nodearraylist1 + assert pvaluenode2 isa nullable AValue + var tcommanode3 = nodearraylist2 + assert tcommanode3 isa nullable TComma + var tidnode4 = nodearraylist3 + assert tidnode4 isa nullable TId + var poperandnode1: nullable AAnyOperand = new AAnyOperand.init_aanyoperand( + pvaluenode2, + tcommanode3, + tidnode4 + ) + node_list = poperandnode1 + p.push(p.go_to(_goto), node_list) + end +end +private class ReduceAction21 + super ReduceAction + redef fun action(p: Parser) + do + var node_list: nullable Object = null + var nodearraylist1 = p.pop + var tidnode2 = nodearraylist1 + assert tidnode2 isa nullable TId + var pvaluenode1: nullable ALabelValue = new ALabelValue.init_alabelvalue( + tidnode2 + ) + node_list = pvaluenode1 + p.push(p.go_to(_goto), node_list) + end +end +private class ReduceAction22 + super ReduceAction + redef fun action(p: Parser) + do + var node_list: nullable Object = null + var nodearraylist1 = p.pop + var tnumbernode2 = nodearraylist1 + assert tnumbernode2 isa nullable TNumber + var pvaluenode1: nullable ANumberValue = new ANumberValue.init_anumbervalue( + tnumbernode2 + ) + node_list = pvaluenode1 + p.push(p.go_to(_goto), node_list) + end +end +private class ReduceAction23 + super ReduceAction + redef fun action(p: Parser) + do + var node_list: nullable Object = null + var nodearraylist1 = p.pop + var tcharnode2 = nodearraylist1 + assert tcharnode2 isa nullable TChar + var pvaluenode1: nullable ACharValue = new ACharValue.init_acharvalue( + tcharnode2 + ) + node_list = pvaluenode1 + p.push(p.go_to(_goto), node_list) + end +end +private class ReduceAction24 + super ReduceAction + redef fun action(p: Parser) + do + var node_list: nullable Object = null + var nodearraylist1 = p.pop + var tstringnode2 = nodearraylist1 + assert tstringnode2 isa nullable TString + var pvaluenode1: nullable AStringValue = new AStringValue.init_astringvalue( + tstringnode2 + ) + node_list = pvaluenode1 + p.push(p.go_to(_goto), node_list) + end +end +private class ReduceAction25 + super ReduceAction + redef fun action(p: Parser) + do + var node_list: nullable Object = null + var nodearraylist1 = p.pop + var thexnode2 = nodearraylist1 + assert thexnode2 isa nullable THex + var pvaluenode1: nullable AHexValue = new AHexValue.init_ahexvalue( + thexnode2 + ) + node_list = pvaluenode1 + p.push(p.go_to(_goto), node_list) + end +end +private class ReduceAction26 + super ReduceAction + redef fun action(p: Parser) + do + var node_list: nullable Object = null + var nodearraylist2 = p.pop + var nodearraylist1 = p.pop + var ttkbytenode2 = nodearraylist1 + assert ttkbytenode2 isa nullable TTkByte + var pvaluenode3 = nodearraylist2 + assert pvaluenode3 isa nullable AValue + var pdirectivenode1: nullable AByteDirective = new AByteDirective.init_abytedirective( + ttkbytenode2, + pvaluenode3 + ) + node_list = pdirectivenode1 + p.push(p.go_to(_goto), node_list) + end +end +private class ReduceAction27 + super ReduceAction + redef fun action(p: Parser) + do + var node_list: nullable Object = null + var nodearraylist2 = p.pop + var nodearraylist1 = p.pop + var ttkwordnode2 = nodearraylist1 + assert ttkwordnode2 isa nullable TTkWord + var pvaluenode3 = nodearraylist2 + assert pvaluenode3 isa nullable AValue + var pdirectivenode1: nullable AWordDirective = new AWordDirective.init_aworddirective( + ttkwordnode2, + pvaluenode3 + ) + node_list = pdirectivenode1 + p.push(p.go_to(_goto), node_list) + end +end +private class ReduceAction28 + super ReduceAction + redef fun action(p: Parser) + do + var node_list: nullable Object = null + var nodearraylist2 = p.pop + var nodearraylist1 = p.pop + var ttkblocknode2 = nodearraylist1 + assert ttkblocknode2 isa nullable TTkBlock + var pvaluenode3 = nodearraylist2 + assert pvaluenode3 isa nullable AValue + var pdirectivenode1: nullable ABlockDirective = new ABlockDirective.init_ablockdirective( + ttkblocknode2, + pvaluenode3 + ) + node_list = pdirectivenode1 + p.push(p.go_to(_goto), node_list) + end +end +private class ReduceAction29 + super ReduceAction + redef fun action(p: Parser) + do + var node_list: nullable Object = null + var nodearraylist2 = p.pop + var nodearraylist1 = p.pop + var ttkasciinode2 = nodearraylist1 + assert ttkasciinode2 isa nullable TTkAscii + var pvaluenode3 = nodearraylist2 + assert pvaluenode3 isa nullable AValue + var pdirectivenode1: nullable AAsciiDirective = new AAsciiDirective.init_aasciidirective( + ttkasciinode2, + pvaluenode3 + ) + node_list = pdirectivenode1 + p.push(p.go_to(_goto), node_list) + end +end +private class ReduceAction30 + super ReduceAction + redef fun action(p: Parser) + do + var node_list: nullable Object = null + var nodearraylist2 = p.pop + var nodearraylist1 = p.pop + var ttkaddrssnode2 = nodearraylist1 + assert ttkaddrssnode2 isa nullable TTkAddrss + var pvaluenode3 = nodearraylist2 + assert pvaluenode3 isa nullable AValue + var pdirectivenode1: nullable AAddrssDirective = new AAddrssDirective.init_aaddrssdirective( + ttkaddrssnode2, + pvaluenode3 + ) + node_list = pdirectivenode1 + p.push(p.go_to(_goto), node_list) + end +end +private class ReduceAction31 + super ReduceAction + redef fun action(p: Parser) + do + var node_list: nullable Object = null + var nodearraylist2 = p.pop + var nodearraylist1 = p.pop + var ttkequatenode2 = nodearraylist1 + assert ttkequatenode2 isa nullable TTkEquate + var pvaluenode3 = nodearraylist2 + assert pvaluenode3 isa nullable AValue + var pdirectivenode1: nullable AEquateDirective = new AEquateDirective.init_aequatedirective( + ttkequatenode2, + pvaluenode3 + ) + node_list = pdirectivenode1 + p.push(p.go_to(_goto), node_list) + end +end +private class ReduceAction32 + super ReduceAction + redef fun action(p: Parser) + do + var node_list: nullable Object = null + var nodearraylist2 = p.pop + var nodearraylist1 = p.pop + var ttkburnnode2 = nodearraylist1 + assert ttkburnnode2 isa nullable TTkBurn + var pvaluenode3 = nodearraylist2 + assert pvaluenode3 isa nullable AValue + var pdirectivenode1: nullable ABurnDirective = new ABurnDirective.init_aburndirective( + ttkburnnode2, + pvaluenode3 + ) + node_list = pdirectivenode1 + p.push(p.go_to(_goto), node_list) + end +end +private class ReduceAction33 + super ReduceAction + redef fun action(p: Parser) + do + var node_list: nullable Object = null + var nodearraylist1 = p.pop + var listnode2 = new Array[Object] + var plinenode1 = nodearraylist1 + if plinenode1 != null then + listnode2.add(plinenode1) + end + node_list = listnode2 + p.push(p.go_to(_goto), node_list) + end +end +private class ReduceAction34 + super ReduceAction + redef fun action(p: Parser) + do + var node_list: nullable Object = null + var nodearraylist2 = p.pop + var nodearraylist1 = p.pop + var listnode3 = new Array[Object] + var listnode1 = nodearraylist1 + assert listnode1 isa Array[Object] + var plinenode2 = nodearraylist2 + listnode3 = concat(listnode3, listnode1) + if plinenode2 != null then + listnode3.add(plinenode2) + end + node_list = listnode3 + p.push(p.go_to(_goto), node_list) + end +end diff --git a/contrib/pep8analysis/src/parser/parser_abs.nit b/contrib/pep8analysis/src/parser/parser_abs.nit new file mode 100644 index 0000000..a0c8af4 --- /dev/null +++ b/contrib/pep8analysis/src/parser/parser_abs.nit @@ -0,0 +1,215 @@ +# Raw AST node hierarchy. +# This file was generated by SableCC (http://www.sablecc.org/). +package parser_abs + +import location + +# Root of the AST hierarchy +abstract class ANode + var _location: nullable Location + + # Location is set during AST building. Once built, location cannon be null + # However, manual instanciated nodes may need mode care + fun location: Location do return _location.as(not null) +end + +# Ancestor of all tokens +abstract class Token + super ANode +end + +# Ancestor of all productions +abstract class Prod + super ANode + fun location=(loc: Location) do _location = loc +end +class TEol + super Token +end +class TNumber + super Token +end +class TFloat + super Token +end +class TChar + super Token +end +class TString + super Token +end +class THex + super Token +end +class TColon + super Token +end +class TComma + super Token +end +class TComment + super Token +end +class TTkByte + super Token +end +class TTkWord + super Token +end +class TTkBlock + super Token +end +class TTkAscii + super Token +end +class TTkAddrss + super Token +end +class TTkEquate + super Token +end +class TTkBurn + super Token +end +class TEndBlock + super Token +end +class TId + super Token +end +class EOF + super Token +private init noinit do end +end +class AError + super EOF +private init noinit do end +end + +class AListing super Prod end +class ALine super Prod end +class ALabelDecl super Prod end +class AInstruction super Prod end +class AOperand super Prod end +class AValue super Prod end +class ADirective super Prod end + +class AListing + super AListing + readable var _n_lines: List[ALine] = new List[ALine] + readable var _n_label_decl: nullable ALabelDecl = null + readable var _n_end_block: TEndBlock +end +class AEmptyLine + super ALine + readable var _n_label_decl: nullable ALabelDecl = null + readable var _n_comment: nullable TComment = null + readable var _n_eol: TEol +end +class AInstructionLine + super ALine + readable var _n_label_decl: nullable ALabelDecl = null + readable var _n_instruction: AInstruction + readable var _n_comment: nullable TComment = null + readable var _n_eol: TEol +end +class ADirectiveLine + super ALine + readable var _n_label_decl: nullable ALabelDecl = null + readable var _n_directive: ADirective + readable var _n_comment: nullable TComment = null + readable var _n_eol: TEol +end +class ALabelDecl + super ALabelDecl + readable var _n_id: TId + readable var _n_colon: TColon +end +class AUnaryInstruction + super AInstruction + readable var _n_id: TId +end +class ABinaryInstruction + super AInstruction + readable var _n_id: TId + readable var _n_operand: AOperand +end +class AImmediateOperand + super AOperand + readable var _n_value: AValue +end +class AAnyOperand + super AOperand + readable var _n_value: AValue + readable var _n_comma: TComma + readable var _n_id: TId +end +class ALabelValue + super AValue + readable var _n_id: TId +end +class ANumberValue + super AValue + readable var _n_number: TNumber +end +class ACharValue + super AValue + readable var _n_char: TChar +end +class AStringValue + super AValue + readable var _n_string: TString +end +class AHexValue + super AValue + readable var _n_hex: THex +end +class AByteDirective + super ADirective + readable var _n_tk_byte: TTkByte + readable var _n_value: AValue +end +class AWordDirective + super ADirective + readable var _n_tk_word: TTkWord + readable var _n_value: AValue +end +class ABlockDirective + super ADirective + readable var _n_tk_block: TTkBlock + readable var _n_value: AValue +end +class AAsciiDirective + super ADirective + readable var _n_tk_ascii: TTkAscii + readable var _n_value: AValue +end +class AAddrssDirective + super ADirective + readable var _n_tk_addrss: TTkAddrss + readable var _n_value: AValue +end +class AEquateDirective + super ADirective + readable var _n_tk_equate: TTkEquate + readable var _n_value: AValue +end +class ABurnDirective + super ADirective + readable var _n_tk_burn: TTkBurn + readable var _n_value: AValue +end + +class Start + super Prod + readable var _n_base: nullable AListing + readable var _n_eof: EOF + init( + n_base: nullable AListing, + n_eof: EOF) + do + _n_base = n_base + _n_eof = n_eof + end + +end diff --git a/contrib/pep8analysis/src/parser/parser_nodes.nit b/contrib/pep8analysis/src/parser/parser_nodes.nit new file mode 100644 index 0000000..62efb2a --- /dev/null +++ b/contrib/pep8analysis/src/parser/parser_nodes.nit @@ -0,0 +1,216 @@ +# Raw AST node hierarchy. +# This file was generated by SableCC (http://www.sablecc.org/). +module parser_nodes + +import location + +# Root of the AST hierarchy +abstract class ANode + var _location: nullable Location + + # Location is set during AST building. Once built, location cannon be null + # However, manual instanciated nodes may need mode care + fun location: Location do return _location.as(not null) +end + +# Ancestor of all tokens +abstract class Token + super ANode + + fun text : String is abstract +end + +# Ancestor of all productions +abstract class Prod + super ANode + fun location=(loc: Location) do _location = loc +end +class TEol + super Token +end +class TNumber + super Token +end +class TFloat + super Token +end +class TChar + super Token +end +class TString + super Token +end +class THex + super Token +end +class TColon + super Token +end +class TComma + super Token +end +class TComment + super Token +end +class TTkByte + super Token +end +class TTkWord + super Token +end +class TTkBlock + super Token +end +class TTkAscii + super Token +end +class TTkAddrss + super Token +end +class TTkEquate + super Token +end +class TTkBurn + super Token +end +class TEndBlock + super Token +end +class TId + super Token +end +class EOF + super Token + #private init noinit do end +end +class AError + super EOF + #private init noinit do end +end + +class ALine + super Prod + readable var _n_label_decl: nullable ALabelDecl = null + readable var _n_comment: nullable TComment = null +end +class AInstruction + super Prod + readable writable var _n_id: TId +end +class AOperand + super Prod + readable var _n_value: AValue +end +class AValue super Prod end +class ADirective super Prod end + +class AListing + super Prod + readable var _n_lines: List[ALine] = new List[ALine] + readable var _n_label_decl: nullable ALabelDecl = null + readable var _n_end_block: TEndBlock +end +class AEmptyLine + super ALine + readable var _n_eol: TEol +end +abstract class ANonEmptyLine + super ALine +end +class AInstructionLine + super ANonEmptyLine + readable var _n_instruction: AInstruction + readable var _n_eol: TEol +end +class ADirectiveLine + super ANonEmptyLine + readable var _n_directive: ADirective + readable var _n_eol: TEol +end +class ALabelDecl + super Prod + readable var _n_id: TId + readable var _n_colon: TColon +end +class AUnaryInstruction + super AInstruction +end +class ABinaryInstruction + super AInstruction + readable var _n_operand: AOperand +end +class AImmediateOperand + super AOperand +end +class AAnyOperand + super AOperand + readable var _n_comma: TComma + readable var _n_id: TId +end +class ALabelValue + super AValue + readable var _n_id: TId +end +class ANumberValue + super AValue + readable var _n_number: TNumber +end +class ACharValue + super AValue + readable var _n_char: TChar +end +class AStringValue + super AValue + readable var _n_string: TString +end +class AHexValue + super AValue + readable var _n_hex: THex +end +class AByteDirective + super ADirective + readable var _n_tk_byte: TTkByte + readable var _n_value: AValue +end +class AWordDirective + super ADirective + readable var _n_tk_word: TTkWord + readable var _n_value: AValue +end +class ABlockDirective + super ADirective + readable var _n_tk_block: TTkBlock + readable var _n_value: AValue +end +class AAsciiDirective + super ADirective + readable var _n_tk_ascii: TTkAscii + readable var _n_value: AValue +end +class AAddrssDirective + super ADirective + readable var _n_tk_addrss: TTkAddrss + readable var _n_value: AValue +end +class AEquateDirective + super ADirective + readable var _n_tk_equate: TTkEquate + readable var _n_value: AValue +end +class ABurnDirective + super ADirective + readable var _n_tk_burn: TTkBurn + readable var _n_value: AValue +end + +class Start + super Prod + readable var _n_base: nullable AListing + readable var _n_eof: EOF + init(n_base: nullable AListing, n_eof: EOF) + do + super(null) + _n_base = n_base + _n_eof = n_eof + end +end diff --git a/contrib/pep8analysis/src/parser/parser_prod.nit b/contrib/pep8analysis/src/parser/parser_prod.nit new file mode 100644 index 0000000..05bb5b2 --- /dev/null +++ b/contrib/pep8analysis/src/parser/parser_prod.nit @@ -0,0 +1,1073 @@ +# Production AST nodes full definition. +# This file was generated by SableCC (http://www.sablecc.org/). +module parser_prod + +import lexer +intrude import parser_nodes +private import tables + +redef class ANode + # Parent of the node in the AST + readable writable var _parent: nullable ANode + + # Remove a child from the AST + fun remove_child(child: ANode) + do + replace_child(child, null) + end + + # Replace a child with an other node in the AST + fun replace_child(old_child: ANode, new_child: nullable ANode) is abstract + + # Replace itself with an other node in the AST + fun replace_with(node: ANode) + do + if _parent != null then + _parent.replace_child(self, node) + end + end + + # Visit all nodes in order. + # Thus, call "v.visit(e)" for each node e + fun visit_all(v: Visitor) is abstract +end + +redef class Token + redef fun visit_all(v: Visitor) do end + redef fun replace_child(old_child: ANode, new_child: nullable ANode) do end +end + +redef class Prod + redef fun replace_with(n: ANode) + do + super + assert n isa Prod + n.location = location + end +end + +# Abstract standard visitor +abstract class Visitor + # What the visitor do when a node is visited + # Concrete visitors should redefine this method. + protected fun visit(e: nullable ANode) is abstract + + # Ask the visitor to visit a given node. + # Usually automatically called by visit_all* methods. + # This methos should not be redefined + fun enter_visit(e: nullable ANode) + do + var old = _current_node + _current_node = e + visit(e) + _current_node = old + end + + # The current visited node + readable var _current_node: nullable ANode = null +end + +redef class AListing + private init empty_init do end + + init init_alisting ( + n_lines: Collection[Object], # Should be Collection[ALine] + n_label_decl: nullable ALabelDecl, + n_end_block: nullable TEndBlock + ) + do + empty_init + for n in n_lines do + assert n isa ALine + _n_lines.add(n) + n.parent = self + end + _n_label_decl = n_label_decl + if n_label_decl != null then + n_label_decl.parent = self + end + _n_end_block = n_end_block.as(not null) + n_end_block.parent = self + end + + redef fun replace_child(old_child: ANode, new_child: nullable ANode) + do + for i in [0.._n_lines.length[ do + if _n_lines[i] == old_child then + if new_child != null then + assert new_child isa ALine + _n_lines[i] = new_child + new_child.parent = self + else + _n_lines.remove_at(i) + end + return + end + end + if _n_label_decl == old_child then + if new_child != null then + new_child.parent = self + assert new_child isa ALabelDecl + _n_label_decl = new_child + else + _n_label_decl = null + end + return + end + if _n_end_block == old_child then + if new_child != null then + new_child.parent = self + assert new_child isa TEndBlock + _n_end_block = new_child + else + abort + end + return + end + end + + redef fun visit_all(v: Visitor) + do + for n in _n_lines do + v.enter_visit(n) + end + if _n_label_decl != null then + v.enter_visit(_n_label_decl.as(not null)) + end + v.enter_visit(_n_end_block) + end +end +redef class AEmptyLine + private init empty_init do end + + init init_aemptyline ( + n_label_decl: nullable ALabelDecl, + n_comment: nullable TComment, + n_eol: nullable TEol + ) + do + empty_init + _n_label_decl = n_label_decl + if n_label_decl != null then + n_label_decl.parent = self + end + _n_comment = n_comment + if n_comment != null then + n_comment.parent = self + end + _n_eol = n_eol.as(not null) + n_eol.parent = self + end + + redef fun replace_child(old_child: ANode, new_child: nullable ANode) + do + if _n_label_decl == old_child then + if new_child != null then + new_child.parent = self + assert new_child isa ALabelDecl + _n_label_decl = new_child + else + _n_label_decl = null + end + return + end + if _n_comment == old_child then + if new_child != null then + new_child.parent = self + assert new_child isa TComment + _n_comment = new_child + else + _n_comment = null + end + return + end + if _n_eol == old_child then + if new_child != null then + new_child.parent = self + assert new_child isa TEol + _n_eol = new_child + else + abort + end + return + end + end + + redef fun visit_all(v: Visitor) + do + if _n_label_decl != null then + v.enter_visit(_n_label_decl.as(not null)) + end + if _n_comment != null then + v.enter_visit(_n_comment.as(not null)) + end + v.enter_visit(_n_eol) + end +end +redef class AInstructionLine + private init empty_init do end + + init init_ainstructionline ( + n_label_decl: nullable ALabelDecl, + n_instruction: nullable AInstruction, + n_comment: nullable TComment, + n_eol: nullable TEol + ) + do + empty_init + _n_label_decl = n_label_decl + if n_label_decl != null then + n_label_decl.parent = self + end + _n_instruction = n_instruction.as(not null) + n_instruction.parent = self + _n_comment = n_comment + if n_comment != null then + n_comment.parent = self + end + _n_eol = n_eol.as(not null) + n_eol.parent = self + end + + redef fun replace_child(old_child: ANode, new_child: nullable ANode) + do + if _n_label_decl == old_child then + if new_child != null then + new_child.parent = self + assert new_child isa ALabelDecl + _n_label_decl = new_child + else + _n_label_decl = null + end + return + end + if _n_instruction == old_child then + if new_child != null then + new_child.parent = self + assert new_child isa AInstruction + _n_instruction = new_child + else + abort + end + return + end + if _n_comment == old_child then + if new_child != null then + new_child.parent = self + assert new_child isa TComment + _n_comment = new_child + else + _n_comment = null + end + return + end + if _n_eol == old_child then + if new_child != null then + new_child.parent = self + assert new_child isa TEol + _n_eol = new_child + else + abort + end + return + end + end + + redef fun visit_all(v: Visitor) + do + if _n_label_decl != null then + v.enter_visit(_n_label_decl.as(not null)) + end + v.enter_visit(_n_instruction) + if _n_comment != null then + v.enter_visit(_n_comment.as(not null)) + end + v.enter_visit(_n_eol) + end +end +redef class ADirectiveLine + private init empty_init do end + + init init_adirectiveline ( + n_label_decl: nullable ALabelDecl, + n_directive: nullable ADirective, + n_comment: nullable TComment, + n_eol: nullable TEol + ) + do + empty_init + _n_label_decl = n_label_decl + if n_label_decl != null then + n_label_decl.parent = self + end + _n_directive = n_directive.as(not null) + n_directive.parent = self + _n_comment = n_comment + if n_comment != null then + n_comment.parent = self + end + _n_eol = n_eol.as(not null) + n_eol.parent = self + end + + redef fun replace_child(old_child: ANode, new_child: nullable ANode) + do + if _n_label_decl == old_child then + if new_child != null then + new_child.parent = self + assert new_child isa ALabelDecl + _n_label_decl = new_child + else + _n_label_decl = null + end + return + end + if _n_directive == old_child then + if new_child != null then + new_child.parent = self + assert new_child isa ADirective + _n_directive = new_child + else + abort + end + return + end + if _n_comment == old_child then + if new_child != null then + new_child.parent = self + assert new_child isa TComment + _n_comment = new_child + else + _n_comment = null + end + return + end + if _n_eol == old_child then + if new_child != null then + new_child.parent = self + assert new_child isa TEol + _n_eol = new_child + else + abort + end + return + end + end + + redef fun visit_all(v: Visitor) + do + if _n_label_decl != null then + v.enter_visit(_n_label_decl.as(not null)) + end + v.enter_visit(_n_directive) + if _n_comment != null then + v.enter_visit(_n_comment.as(not null)) + end + v.enter_visit(_n_eol) + end +end +redef class ALabelDecl + private init empty_init do end + + init init_alabeldecl ( + n_id: nullable TId, + n_colon: nullable TColon + ) + do + empty_init + _n_id = n_id.as(not null) + n_id.parent = self + _n_colon = n_colon.as(not null) + n_colon.parent = self + end + + redef fun replace_child(old_child: ANode, new_child: nullable ANode) + do + if _n_id == old_child then + if new_child != null then + new_child.parent = self + assert new_child isa TId + _n_id = new_child + else + abort + end + return + end + if _n_colon == old_child then + if new_child != null then + new_child.parent = self + assert new_child isa TColon + _n_colon = new_child + else + abort + end + return + end + end + + redef fun visit_all(v: Visitor) + do + v.enter_visit(_n_id) + v.enter_visit(_n_colon) + end +end +redef class AUnaryInstruction + private init empty_init do end + + init init_aunaryinstruction ( + n_id: nullable TId + ) + do + empty_init + _n_id = n_id.as(not null) + n_id.parent = self + end + + redef fun replace_child(old_child: ANode, new_child: nullable ANode) + do + if _n_id == old_child then + if new_child != null then + new_child.parent = self + assert new_child isa TId + _n_id = new_child + else + abort + end + return + end + end + + redef fun visit_all(v: Visitor) + do + v.enter_visit(_n_id) + end +end +redef class ABinaryInstruction + private init empty_init do end + + init init_abinaryinstruction ( + n_id: nullable TId, + n_operand: nullable AOperand + ) + do + empty_init + _n_id = n_id.as(not null) + n_id.parent = self + _n_operand = n_operand.as(not null) + n_operand.parent = self + end + + redef fun replace_child(old_child: ANode, new_child: nullable ANode) + do + if _n_id == old_child then + if new_child != null then + new_child.parent = self + assert new_child isa TId + _n_id = new_child + else + abort + end + return + end + if _n_operand == old_child then + if new_child != null then + new_child.parent = self + assert new_child isa AOperand + _n_operand = new_child + else + abort + end + return + end + end + + redef fun visit_all(v: Visitor) + do + v.enter_visit(_n_id) + v.enter_visit(_n_operand) + end +end +redef class AImmediateOperand + private init empty_init do end + + init init_aimmediateoperand ( + n_value: nullable AValue + ) + do + empty_init + _n_value = n_value.as(not null) + n_value.parent = self + end + + redef fun replace_child(old_child: ANode, new_child: nullable ANode) + do + if _n_value == old_child then + if new_child != null then + new_child.parent = self + assert new_child isa AValue + _n_value = new_child + else + abort + end + return + end + end + + redef fun visit_all(v: Visitor) + do + v.enter_visit(_n_value) + end +end +redef class AAnyOperand + private init empty_init do end + + init init_aanyoperand ( + n_value: nullable AValue, + n_comma: nullable TComma, + n_id: nullable TId + ) + do + empty_init + _n_value = n_value.as(not null) + n_value.parent = self + _n_comma = n_comma.as(not null) + n_comma.parent = self + _n_id = n_id.as(not null) + n_id.parent = self + end + + redef fun replace_child(old_child: ANode, new_child: nullable ANode) + do + if _n_value == old_child then + if new_child != null then + new_child.parent = self + assert new_child isa AValue + _n_value = new_child + else + abort + end + return + end + if _n_comma == old_child then + if new_child != null then + new_child.parent = self + assert new_child isa TComma + _n_comma = new_child + else + abort + end + return + end + if _n_id == old_child then + if new_child != null then + new_child.parent = self + assert new_child isa TId + _n_id = new_child + else + abort + end + return + end + end + + redef fun visit_all(v: Visitor) + do + v.enter_visit(_n_value) + v.enter_visit(_n_comma) + v.enter_visit(_n_id) + end +end +redef class ALabelValue + private init empty_init do end + + init init_alabelvalue ( + n_id: nullable TId + ) + do + empty_init + _n_id = n_id.as(not null) + n_id.parent = self + end + + redef fun replace_child(old_child: ANode, new_child: nullable ANode) + do + if _n_id == old_child then + if new_child != null then + new_child.parent = self + assert new_child isa TId + _n_id = new_child + else + abort + end + return + end + end + + redef fun visit_all(v: Visitor) + do + v.enter_visit(_n_id) + end +end +redef class ANumberValue + private init empty_init do end + + init init_anumbervalue ( + n_number: nullable TNumber + ) + do + empty_init + _n_number = n_number.as(not null) + n_number.parent = self + end + + redef fun replace_child(old_child: ANode, new_child: nullable ANode) + do + if _n_number == old_child then + if new_child != null then + new_child.parent = self + assert new_child isa TNumber + _n_number = new_child + else + abort + end + return + end + end + + redef fun visit_all(v: Visitor) + do + v.enter_visit(_n_number) + end +end +redef class ACharValue + private init empty_init do end + + init init_acharvalue ( + n_char: nullable TChar + ) + do + empty_init + _n_char = n_char.as(not null) + n_char.parent = self + end + + redef fun replace_child(old_child: ANode, new_child: nullable ANode) + do + if _n_char == old_child then + if new_child != null then + new_child.parent = self + assert new_child isa TChar + _n_char = new_child + else + abort + end + return + end + end + + redef fun visit_all(v: Visitor) + do + v.enter_visit(_n_char) + end +end +redef class AStringValue + private init empty_init do end + + init init_astringvalue ( + n_string: nullable TString + ) + do + empty_init + _n_string = n_string.as(not null) + n_string.parent = self + end + + redef fun replace_child(old_child: ANode, new_child: nullable ANode) + do + if _n_string == old_child then + if new_child != null then + new_child.parent = self + assert new_child isa TString + _n_string = new_child + else + abort + end + return + end + end + + redef fun visit_all(v: Visitor) + do + v.enter_visit(_n_string) + end +end +redef class AHexValue + private init empty_init do end + + init init_ahexvalue ( + n_hex: nullable THex + ) + do + empty_init + _n_hex = n_hex.as(not null) + n_hex.parent = self + end + + redef fun replace_child(old_child: ANode, new_child: nullable ANode) + do + if _n_hex == old_child then + if new_child != null then + new_child.parent = self + assert new_child isa THex + _n_hex = new_child + else + abort + end + return + end + end + + redef fun visit_all(v: Visitor) + do + v.enter_visit(_n_hex) + end +end +redef class AByteDirective + private init empty_init do end + + init init_abytedirective ( + n_tk_byte: nullable TTkByte, + n_value: nullable AValue + ) + do + empty_init + _n_tk_byte = n_tk_byte.as(not null) + n_tk_byte.parent = self + _n_value = n_value.as(not null) + n_value.parent = self + end + + redef fun replace_child(old_child: ANode, new_child: nullable ANode) + do + if _n_tk_byte == old_child then + if new_child != null then + new_child.parent = self + assert new_child isa TTkByte + _n_tk_byte = new_child + else + abort + end + return + end + if _n_value == old_child then + if new_child != null then + new_child.parent = self + assert new_child isa AValue + _n_value = new_child + else + abort + end + return + end + end + + redef fun visit_all(v: Visitor) + do + v.enter_visit(_n_tk_byte) + v.enter_visit(_n_value) + end +end +redef class AWordDirective + private init empty_init do end + + init init_aworddirective ( + n_tk_word: nullable TTkWord, + n_value: nullable AValue + ) + do + empty_init + _n_tk_word = n_tk_word.as(not null) + n_tk_word.parent = self + _n_value = n_value.as(not null) + n_value.parent = self + end + + redef fun replace_child(old_child: ANode, new_child: nullable ANode) + do + if _n_tk_word == old_child then + if new_child != null then + new_child.parent = self + assert new_child isa TTkWord + _n_tk_word = new_child + else + abort + end + return + end + if _n_value == old_child then + if new_child != null then + new_child.parent = self + assert new_child isa AValue + _n_value = new_child + else + abort + end + return + end + end + + redef fun visit_all(v: Visitor) + do + v.enter_visit(_n_tk_word) + v.enter_visit(_n_value) + end +end +redef class ABlockDirective + private init empty_init do end + + init init_ablockdirective ( + n_tk_block: nullable TTkBlock, + n_value: nullable AValue + ) + do + empty_init + _n_tk_block = n_tk_block.as(not null) + n_tk_block.parent = self + _n_value = n_value.as(not null) + n_value.parent = self + end + + redef fun replace_child(old_child: ANode, new_child: nullable ANode) + do + if _n_tk_block == old_child then + if new_child != null then + new_child.parent = self + assert new_child isa TTkBlock + _n_tk_block = new_child + else + abort + end + return + end + if _n_value == old_child then + if new_child != null then + new_child.parent = self + assert new_child isa AValue + _n_value = new_child + else + abort + end + return + end + end + + redef fun visit_all(v: Visitor) + do + v.enter_visit(_n_tk_block) + v.enter_visit(_n_value) + end +end +redef class AAsciiDirective + private init empty_init do end + + init init_aasciidirective ( + n_tk_ascii: nullable TTkAscii, + n_value: nullable AValue + ) + do + empty_init + _n_tk_ascii = n_tk_ascii.as(not null) + n_tk_ascii.parent = self + _n_value = n_value.as(not null) + n_value.parent = self + end + + redef fun replace_child(old_child: ANode, new_child: nullable ANode) + do + if _n_tk_ascii == old_child then + if new_child != null then + new_child.parent = self + assert new_child isa TTkAscii + _n_tk_ascii = new_child + else + abort + end + return + end + if _n_value == old_child then + if new_child != null then + new_child.parent = self + assert new_child isa AValue + _n_value = new_child + else + abort + end + return + end + end + + redef fun visit_all(v: Visitor) + do + v.enter_visit(_n_tk_ascii) + v.enter_visit(_n_value) + end +end +redef class AAddrssDirective + private init empty_init do end + + init init_aaddrssdirective ( + n_tk_addrss: nullable TTkAddrss, + n_value: nullable AValue + ) + do + empty_init + _n_tk_addrss = n_tk_addrss.as(not null) + n_tk_addrss.parent = self + _n_value = n_value.as(not null) + n_value.parent = self + end + + redef fun replace_child(old_child: ANode, new_child: nullable ANode) + do + if _n_tk_addrss == old_child then + if new_child != null then + new_child.parent = self + assert new_child isa TTkAddrss + _n_tk_addrss = new_child + else + abort + end + return + end + if _n_value == old_child then + if new_child != null then + new_child.parent = self + assert new_child isa AValue + _n_value = new_child + else + abort + end + return + end + end + + redef fun visit_all(v: Visitor) + do + v.enter_visit(_n_tk_addrss) + v.enter_visit(_n_value) + end +end +redef class AEquateDirective + private init empty_init do end + + init init_aequatedirective ( + n_tk_equate: nullable TTkEquate, + n_value: nullable AValue + ) + do + empty_init + _n_tk_equate = n_tk_equate.as(not null) + n_tk_equate.parent = self + _n_value = n_value.as(not null) + n_value.parent = self + end + + redef fun replace_child(old_child: ANode, new_child: nullable ANode) + do + if _n_tk_equate == old_child then + if new_child != null then + new_child.parent = self + assert new_child isa TTkEquate + _n_tk_equate = new_child + else + abort + end + return + end + if _n_value == old_child then + if new_child != null then + new_child.parent = self + assert new_child isa AValue + _n_value = new_child + else + abort + end + return + end + end + + redef fun visit_all(v: Visitor) + do + v.enter_visit(_n_tk_equate) + v.enter_visit(_n_value) + end +end +redef class ABurnDirective + private init empty_init do end + + init init_aburndirective ( + n_tk_burn: nullable TTkBurn, + n_value: nullable AValue + ) + do + empty_init + _n_tk_burn = n_tk_burn.as(not null) + n_tk_burn.parent = self + _n_value = n_value.as(not null) + n_value.parent = self + end + + redef fun replace_child(old_child: ANode, new_child: nullable ANode) + do + if _n_tk_burn == old_child then + if new_child != null then + new_child.parent = self + assert new_child isa TTkBurn + _n_tk_burn = new_child + else + abort + end + return + end + if _n_value == old_child then + if new_child != null then + new_child.parent = self + assert new_child isa AValue + _n_value = new_child + else + abort + end + return + end + end + + redef fun visit_all(v: Visitor) + do + v.enter_visit(_n_tk_burn) + v.enter_visit(_n_value) + end +end + +redef class Start + redef fun replace_child(old_child: ANode, new_child: nullable ANode) + do + if _n_base == old_child then + if new_child == null then + else + new_child.parent = self + assert new_child isa AListing + _n_base = new_child + end + old_child.parent = null + return + end + end + + redef fun visit_all(v: Visitor) + do + if _n_base != null then + v.enter_visit(_n_base.as(not null)) + end + v.enter_visit(_n_eof) + end +end diff --git a/contrib/pep8analysis/src/parser/pep8.sablecc b/contrib/pep8analysis/src/parser/pep8.sablecc new file mode 100644 index 0000000..d74cbb1 --- /dev/null +++ b/contrib/pep8analysis/src/parser/pep8.sablecc @@ -0,0 +1,113 @@ +/* + * This file is part of the pep8analyser project. + * + * Copyright 2013 Alexis Laferriere + * + * Inspired from the Nit language grammar by: + * Copyright 2008-2009 Jean Privat + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* This grammar defines the Pep/8 language. */ +Grammar pep8; + +/*****************************************************************************/ +Lexer +/*****************************************************************************/ + +all = ' ' .. '~'; +lowercase = 'a' .. 'z'; +uppercase = 'A' .. 'Z'; +digit = '0' .. '9'; +letter = lowercase | uppercase | digit | '_'; + +tab = '\t'; +cr = '\n'; +lf = '\r'; +any = all - (cr | lf); + +str_char + = (any - '"') + '\\' + | '\\' any; + +eol_helper = cr lf | cr | lf; // This takes care of different platforms; + +hex_digit = '0' .. '9' | 'A' .. 'F' | 'a' .. 'f'; + +blank = (' ' | tab)+; + +eol = eol_helper; + +number = '-'? digit+; +hex = '0' ('x'|'X') hex_digit+; +float = digit* '.' digit+; +char = ('\'' ((any - '\'') - '\\') '\'') + | ('\'' '\\' any '\'') + | ('\'' '\\' 'x' hex_digit hex_digit '\''); +string = '"' str_char* '"'; + +colon = ':'; +comma = ','; +comment = ';' any*; + +tk_byte = '.' ('B'|'b') ('Y'|'y') ('T'|'t') ('E'|'e'); +tk_word = '.' ('W'|'w') ('O'|'o') ('R'|'r') ('D'|'d'); +tk_block = '.' ('B'|'b') ('L'|'l') ('O'|'o') ('C'|'c') ('K'|'k'); +tk_ascii = '.' ('A'|'a') ('S'|'s') ('C'|'c') ('I'|'i') ('I'|'i'); +tk_addrss = '.' ('A'|'a') ('D'|'d') ('D'|'d') ('R'|'r') ('S'|'s') ('S'|'s'); +tk_equate = '.' ('E'|'e') ('Q'|'q') ('U'|'u') ('A'|'a') ('T'|'t') ('E'|'e'); +tk_burn = '.' ('B'|'b') ('U'|'u') ('R'|'r') ('N'|'n'); + +end_block = '.' ('E'|'e') ('N'|'n') ('D'|'d') (any | eol_helper)*; + +id = (lowercase|uppercase|'_') letter*; + +/*****************************************************************************/ +Parser +/*****************************************************************************/ +Ignored blank; +listing = [lines]:line* label_decl? end_block; + +line + = {empty} label_decl? comment? eol + | {instruction} label_decl? instruction comment? eol + | {directive} label_decl? directive comment? eol; + +label_decl = id colon; + +instruction + = {unary} id + | {binary} id operand; + +/* operands + * We will manage which operands are possible with each stmt at a higher level. + * This will allow better error messages and a cleaner model. */ +operand + = {immediate} value + | {any} value comma id; + +value + = {label} id + | {char} char + | {string} string; + /*| {hex} hex;*/ +directive + = {byte} tk_byte value + | {word} tk_word value + | {block} tk_block value + | {ascii} tk_ascii value + | {addrss} tk_addrss value + | {equate} tk_equate value + | {burn} tk_burn value; + diff --git a/contrib/pep8analysis/src/parser/pep8_lexer.nit b/contrib/pep8analysis/src/parser/pep8_lexer.nit new file mode 100644 index 0000000..5e0fa09 --- /dev/null +++ b/contrib/pep8analysis/src/parser/pep8_lexer.nit @@ -0,0 +1,3654 @@ +# Lexer generated by nitccimport nitcc_runtime +import pep8_parser +class MyLexer + super Lexer + redef fun start_state do return dfastate_0 +end +redef class Object + private fun dfastate_0: DFAState0 do return once new DFAState0 + private fun dfastate_1: DFAState1 do return once new DFAState1 + private fun dfastate_2: DFAState2 do return once new DFAState2 + private fun dfastate_3: DFAState3 do return once new DFAState3 + private fun dfastate_4: DFAState4 do return once new DFAState4 + private fun dfastate_5: DFAState5 do return once new DFAState5 + private fun dfastate_6: DFAState6 do return once new DFAState6 + private fun dfastate_7: DFAState7 do return once new DFAState7 + private fun dfastate_8: DFAState8 do return once new DFAState8 + private fun dfastate_9: DFAState9 do return once new DFAState9 + private fun dfastate_10: DFAState10 do return once new DFAState10 + private fun dfastate_11: DFAState11 do return once new DFAState11 + private fun dfastate_12: DFAState12 do return once new DFAState12 + private fun dfastate_13: DFAState13 do return once new DFAState13 + private fun dfastate_14: DFAState14 do return once new DFAState14 + private fun dfastate_15: DFAState15 do return once new DFAState15 + private fun dfastate_16: DFAState16 do return once new DFAState16 + private fun dfastate_17: DFAState17 do return once new DFAState17 + private fun dfastate_18: DFAState18 do return once new DFAState18 + private fun dfastate_19: DFAState19 do return once new DFAState19 + private fun dfastate_20: DFAState20 do return once new DFAState20 + private fun dfastate_21: DFAState21 do return once new DFAState21 + private fun dfastate_22: DFAState22 do return once new DFAState22 + private fun dfastate_23: DFAState23 do return once new DFAState23 + private fun dfastate_24: DFAState24 do return once new DFAState24 + private fun dfastate_25: DFAState25 do return once new DFAState25 + private fun dfastate_26: DFAState26 do return once new DFAState26 + private fun dfastate_27: DFAState27 do return once new DFAState27 + private fun dfastate_28: DFAState28 do return once new DFAState28 + private fun dfastate_29: DFAState29 do return once new DFAState29 + private fun dfastate_30: DFAState30 do return once new DFAState30 + private fun dfastate_31: DFAState31 do return once new DFAState31 + private fun dfastate_32: DFAState32 do return once new DFAState32 + private fun dfastate_33: DFAState33 do return once new DFAState33 + private fun dfastate_34: DFAState34 do return once new DFAState34 + private fun dfastate_35: DFAState35 do return once new DFAState35 + private fun dfastate_36: DFAState36 do return once new DFAState36 + private fun dfastate_37: DFAState37 do return once new DFAState37 + private fun dfastate_38: DFAState38 do return once new DFAState38 + private fun dfastate_39: DFAState39 do return once new DFAState39 + private fun dfastate_40: DFAState40 do return once new DFAState40 + private fun dfastate_41: DFAState41 do return once new DFAState41 + private fun dfastate_42: DFAState42 do return once new DFAState42 + private fun dfastate_43: DFAState43 do return once new DFAState43 + private fun dfastate_44: DFAState44 do return once new DFAState44 + private fun dfastate_45: DFAState45 do return once new DFAState45 + private fun dfastate_46: DFAState46 do return once new DFAState46 + private fun dfastate_47: DFAState47 do return once new DFAState47 + private fun dfastate_48: DFAState48 do return once new DFAState48 + private fun dfastate_49: DFAState49 do return once new DFAState49 + private fun dfastate_50: DFAState50 do return once new DFAState50 + private fun dfastate_51: DFAState51 do return once new DFAState51 + private fun dfastate_52: DFAState52 do return once new DFAState52 + private fun dfastate_53: DFAState53 do return once new DFAState53 + private fun dfastate_54: DFAState54 do return once new DFAState54 + private fun dfastate_55: DFAState55 do return once new DFAState55 + private fun dfastate_56: DFAState56 do return once new DFAState56 + private fun dfastate_57: DFAState57 do return once new DFAState57 + private fun dfastate_58: DFAState58 do return once new DFAState58 + private fun dfastate_59: DFAState59 do return once new DFAState59 + private fun dfastate_60: DFAState60 do return once new DFAState60 + private fun dfastate_61: DFAState61 do return once new DFAState61 + private fun dfastate_62: DFAState62 do return once new DFAState62 + private fun dfastate_63: DFAState63 do return once new DFAState63 + private fun dfastate_64: DFAState64 do return once new DFAState64 + private fun dfastate_65: DFAState65 do return once new DFAState65 + private fun dfastate_66: DFAState66 do return once new DFAState66 + private fun dfastate_67: DFAState67 do return once new DFAState67 + private fun dfastate_68: DFAState68 do return once new DFAState68 + private fun dfastate_69: DFAState69 do return once new DFAState69 + private fun dfastate_70: DFAState70 do return once new DFAState70 + private fun dfastate_71: DFAState71 do return once new DFAState71 + private fun dfastate_72: DFAState72 do return once new DFAState72 + private fun dfastate_73: DFAState73 do return once new DFAState73 + private fun dfastate_74: DFAState74 do return once new DFAState74 + private fun dfastate_75: DFAState75 do return once new DFAState75 + private fun dfastate_76: DFAState76 do return once new DFAState76 + private fun dfastate_77: DFAState77 do return once new DFAState77 + private fun dfastate_78: DFAState78 do return once new DFAState78 + private fun dfastate_79: DFAState79 do return once new DFAState79 + private fun dfastate_80: DFAState80 do return once new DFAState80 + private fun dfastate_81: DFAState81 do return once new DFAState81 + private fun dfastate_82: DFAState82 do return once new DFAState82 + private fun dfastate_83: DFAState83 do return once new DFAState83 + private fun dfastate_84: DFAState84 do return once new DFAState84 + private fun dfastate_85: DFAState85 do return once new DFAState85 + private fun dfastate_86: DFAState86 do return once new DFAState86 + private fun dfastate_87: DFAState87 do return once new DFAState87 + private fun dfastate_88: DFAState88 do return once new DFAState88 + private fun dfastate_89: DFAState89 do return once new DFAState89 + private fun dfastate_90: DFAState90 do return once new DFAState90 + private fun dfastate_91: DFAState91 do return once new DFAState91 + private fun dfastate_92: DFAState92 do return once new DFAState92 + private fun dfastate_93: DFAState93 do return once new DFAState93 + private fun dfastate_94: DFAState94 do return once new DFAState94 + private fun dfastate_95: DFAState95 do return once new DFAState95 + private fun dfastate_96: DFAState96 do return once new DFAState96 + private fun dfastate_97: DFAState97 do return once new DFAState97 + private fun dfastate_98: DFAState98 do return once new DFAState98 + private fun dfastate_99: DFAState99 do return once new DFAState99 + private fun dfastate_100: DFAState100 do return once new DFAState100 + private fun dfastate_101: DFAState101 do return once new DFAState101 + private fun dfastate_102: DFAState102 do return once new DFAState102 + private fun dfastate_103: DFAState103 do return once new DFAState103 + private fun dfastate_104: DFAState104 do return once new DFAState104 + private fun dfastate_105: DFAState105 do return once new DFAState105 + private fun dfastate_106: DFAState106 do return once new DFAState106 + private fun dfastate_107: DFAState107 do return once new DFAState107 + private fun dfastate_108: DFAState108 do return once new DFAState108 + private fun dfastate_109: DFAState109 do return once new DFAState109 + private fun dfastate_110: DFAState110 do return once new DFAState110 + private fun dfastate_111: DFAState111 do return once new DFAState111 + private fun dfastate_112: DFAState112 do return once new DFAState112 +end +class MyNToken + super NToken +end +class DFAState0 + super DFAState + redef fun trans(c) do + if c.ascii == 46 then return dfastate_1 + if c.ascii == 34 then return dfastate_2 + if c.ascii == 39 then return dfastate_3 + if c.ascii == 44 then return dfastate_4 + if c.ascii == 58 then return dfastate_5 + if c.ascii == 95 then return dfastate_6 + if c.ascii == 97 then return dfastate_7 + if c.ascii == 98 then return dfastate_7 + if c.ascii == 99 then return dfastate_7 + if c.ascii == 100 then return dfastate_7 + if c.ascii == 101 then return dfastate_7 + if c.ascii == 102 then return dfastate_7 + if c.ascii == 103 then return dfastate_7 + if c.ascii == 104 then return dfastate_7 + if c.ascii == 105 then return dfastate_7 + if c.ascii == 106 then return dfastate_7 + if c.ascii == 107 then return dfastate_7 + if c.ascii == 108 then return dfastate_7 + if c.ascii == 109 then return dfastate_7 + if c.ascii == 110 then return dfastate_7 + if c.ascii == 111 then return dfastate_7 + if c.ascii == 112 then return dfastate_7 + if c.ascii == 113 then return dfastate_7 + if c.ascii == 114 then return dfastate_7 + if c.ascii == 115 then return dfastate_7 + if c.ascii == 116 then return dfastate_7 + if c.ascii == 117 then return dfastate_7 + if c.ascii == 118 then return dfastate_7 + if c.ascii == 119 then return dfastate_7 + if c.ascii == 120 then return dfastate_7 + if c.ascii == 121 then return dfastate_7 + if c.ascii == 122 then return dfastate_7 + if c.ascii == 65 then return dfastate_8 + if c.ascii == 66 then return dfastate_8 + if c.ascii == 67 then return dfastate_8 + if c.ascii == 68 then return dfastate_8 + if c.ascii == 69 then return dfastate_8 + if c.ascii == 70 then return dfastate_8 + if c.ascii == 71 then return dfastate_8 + if c.ascii == 72 then return dfastate_8 + if c.ascii == 73 then return dfastate_8 + if c.ascii == 74 then return dfastate_8 + if c.ascii == 75 then return dfastate_8 + if c.ascii == 76 then return dfastate_8 + if c.ascii == 77 then return dfastate_8 + if c.ascii == 78 then return dfastate_8 + if c.ascii == 79 then return dfastate_8 + if c.ascii == 80 then return dfastate_8 + if c.ascii == 81 then return dfastate_8 + if c.ascii == 82 then return dfastate_8 + if c.ascii == 83 then return dfastate_8 + if c.ascii == 84 then return dfastate_8 + if c.ascii == 85 then return dfastate_8 + if c.ascii == 86 then return dfastate_8 + if c.ascii == 87 then return dfastate_8 + if c.ascii == 88 then return dfastate_8 + if c.ascii == 89 then return dfastate_8 + if c.ascii == 90 then return dfastate_8 + if c.ascii == 13 then return dfastate_9 + if c.ascii == 10 then return dfastate_10 + if c.ascii == 59 then return dfastate_11 + if c.ascii == 9 then return dfastate_12 + if c.ascii == 32 then return dfastate_13 + return null + end +end +class DFAState1 + super DFAState + redef fun trans(c) do + if c.ascii == 101 then return dfastate_43 + if c.ascii == 69 then return dfastate_44 + if c.ascii == 98 then return dfastate_45 + if c.ascii == 66 then return dfastate_46 + if c.ascii == 119 then return dfastate_47 + if c.ascii == 87 then return dfastate_48 + if c.ascii == 97 then return dfastate_49 + if c.ascii == 65 then return dfastate_50 + return null + end +end +class DFAState2 + super DFAState + redef fun trans(c) do + if c.ascii == 32 then return dfastate_33 + if c.ascii == 33 then return dfastate_33 + if c.ascii == 35 then return dfastate_33 + if c.ascii == 36 then return dfastate_33 + if c.ascii == 37 then return dfastate_33 + if c.ascii == 38 then return dfastate_33 + if c.ascii == 39 then return dfastate_33 + if c.ascii == 40 then return dfastate_33 + if c.ascii == 41 then return dfastate_33 + if c.ascii == 42 then return dfastate_33 + if c.ascii == 43 then return dfastate_33 + if c.ascii == 44 then return dfastate_33 + if c.ascii == 45 then return dfastate_33 + if c.ascii == 46 then return dfastate_33 + if c.ascii == 47 then return dfastate_33 + if c.ascii == 48 then return dfastate_33 + if c.ascii == 49 then return dfastate_33 + if c.ascii == 50 then return dfastate_33 + if c.ascii == 51 then return dfastate_33 + if c.ascii == 52 then return dfastate_33 + if c.ascii == 53 then return dfastate_33 + if c.ascii == 54 then return dfastate_33 + if c.ascii == 55 then return dfastate_33 + if c.ascii == 56 then return dfastate_33 + if c.ascii == 57 then return dfastate_33 + if c.ascii == 58 then return dfastate_33 + if c.ascii == 59 then return dfastate_33 + if c.ascii == 60 then return dfastate_33 + if c.ascii == 61 then return dfastate_33 + if c.ascii == 62 then return dfastate_33 + if c.ascii == 63 then return dfastate_33 + if c.ascii == 64 then return dfastate_33 + if c.ascii == 65 then return dfastate_33 + if c.ascii == 66 then return dfastate_33 + if c.ascii == 67 then return dfastate_33 + if c.ascii == 68 then return dfastate_33 + if c.ascii == 69 then return dfastate_33 + if c.ascii == 70 then return dfastate_33 + if c.ascii == 71 then return dfastate_33 + if c.ascii == 72 then return dfastate_33 + if c.ascii == 73 then return dfastate_33 + if c.ascii == 74 then return dfastate_33 + if c.ascii == 75 then return dfastate_33 + if c.ascii == 76 then return dfastate_33 + if c.ascii == 77 then return dfastate_33 + if c.ascii == 78 then return dfastate_33 + if c.ascii == 79 then return dfastate_33 + if c.ascii == 80 then return dfastate_33 + if c.ascii == 81 then return dfastate_33 + if c.ascii == 82 then return dfastate_33 + if c.ascii == 83 then return dfastate_33 + if c.ascii == 84 then return dfastate_33 + if c.ascii == 85 then return dfastate_33 + if c.ascii == 86 then return dfastate_33 + if c.ascii == 87 then return dfastate_33 + if c.ascii == 88 then return dfastate_33 + if c.ascii == 89 then return dfastate_33 + if c.ascii == 90 then return dfastate_33 + if c.ascii == 91 then return dfastate_33 + if c.ascii == 92 then return dfastate_34 + if c.ascii == 93 then return dfastate_33 + if c.ascii == 94 then return dfastate_33 + if c.ascii == 95 then return dfastate_33 + if c.ascii == 96 then return dfastate_33 + if c.ascii == 97 then return dfastate_33 + if c.ascii == 98 then return dfastate_33 + if c.ascii == 99 then return dfastate_33 + if c.ascii == 100 then return dfastate_33 + if c.ascii == 101 then return dfastate_33 + if c.ascii == 102 then return dfastate_33 + if c.ascii == 103 then return dfastate_33 + if c.ascii == 104 then return dfastate_33 + if c.ascii == 105 then return dfastate_33 + if c.ascii == 106 then return dfastate_33 + if c.ascii == 107 then return dfastate_33 + if c.ascii == 108 then return dfastate_33 + if c.ascii == 109 then return dfastate_33 + if c.ascii == 110 then return dfastate_33 + if c.ascii == 111 then return dfastate_33 + if c.ascii == 112 then return dfastate_33 + if c.ascii == 113 then return dfastate_33 + if c.ascii == 114 then return dfastate_33 + if c.ascii == 115 then return dfastate_33 + if c.ascii == 116 then return dfastate_33 + if c.ascii == 117 then return dfastate_33 + if c.ascii == 118 then return dfastate_33 + if c.ascii == 119 then return dfastate_33 + if c.ascii == 120 then return dfastate_33 + if c.ascii == 121 then return dfastate_33 + if c.ascii == 122 then return dfastate_33 + if c.ascii == 123 then return dfastate_33 + if c.ascii == 124 then return dfastate_33 + if c.ascii == 125 then return dfastate_33 + if c.ascii == 126 then return dfastate_33 + if c.ascii == 34 then return dfastate_35 + return null + end +end +class DFAState3 + super DFAState + redef fun trans(c) do + if c.ascii == 32 then return dfastate_20 + if c.ascii == 33 then return dfastate_20 + if c.ascii == 34 then return dfastate_20 + if c.ascii == 35 then return dfastate_20 + if c.ascii == 36 then return dfastate_20 + if c.ascii == 37 then return dfastate_20 + if c.ascii == 38 then return dfastate_20 + if c.ascii == 40 then return dfastate_20 + if c.ascii == 41 then return dfastate_20 + if c.ascii == 42 then return dfastate_20 + if c.ascii == 43 then return dfastate_20 + if c.ascii == 44 then return dfastate_20 + if c.ascii == 45 then return dfastate_20 + if c.ascii == 46 then return dfastate_20 + if c.ascii == 47 then return dfastate_20 + if c.ascii == 48 then return dfastate_20 + if c.ascii == 49 then return dfastate_20 + if c.ascii == 50 then return dfastate_20 + if c.ascii == 51 then return dfastate_20 + if c.ascii == 52 then return dfastate_20 + if c.ascii == 53 then return dfastate_20 + if c.ascii == 54 then return dfastate_20 + if c.ascii == 55 then return dfastate_20 + if c.ascii == 56 then return dfastate_20 + if c.ascii == 57 then return dfastate_20 + if c.ascii == 58 then return dfastate_20 + if c.ascii == 59 then return dfastate_20 + if c.ascii == 60 then return dfastate_20 + if c.ascii == 61 then return dfastate_20 + if c.ascii == 62 then return dfastate_20 + if c.ascii == 63 then return dfastate_20 + if c.ascii == 64 then return dfastate_20 + if c.ascii == 65 then return dfastate_20 + if c.ascii == 66 then return dfastate_20 + if c.ascii == 67 then return dfastate_20 + if c.ascii == 68 then return dfastate_20 + if c.ascii == 69 then return dfastate_20 + if c.ascii == 70 then return dfastate_20 + if c.ascii == 71 then return dfastate_20 + if c.ascii == 72 then return dfastate_20 + if c.ascii == 73 then return dfastate_20 + if c.ascii == 74 then return dfastate_20 + if c.ascii == 75 then return dfastate_20 + if c.ascii == 76 then return dfastate_20 + if c.ascii == 77 then return dfastate_20 + if c.ascii == 78 then return dfastate_20 + if c.ascii == 79 then return dfastate_20 + if c.ascii == 80 then return dfastate_20 + if c.ascii == 81 then return dfastate_20 + if c.ascii == 82 then return dfastate_20 + if c.ascii == 83 then return dfastate_20 + if c.ascii == 84 then return dfastate_20 + if c.ascii == 85 then return dfastate_20 + if c.ascii == 86 then return dfastate_20 + if c.ascii == 87 then return dfastate_20 + if c.ascii == 88 then return dfastate_20 + if c.ascii == 89 then return dfastate_20 + if c.ascii == 90 then return dfastate_20 + if c.ascii == 91 then return dfastate_20 + if c.ascii == 93 then return dfastate_20 + if c.ascii == 94 then return dfastate_20 + if c.ascii == 95 then return dfastate_20 + if c.ascii == 96 then return dfastate_20 + if c.ascii == 97 then return dfastate_20 + if c.ascii == 98 then return dfastate_20 + if c.ascii == 99 then return dfastate_20 + if c.ascii == 100 then return dfastate_20 + if c.ascii == 101 then return dfastate_20 + if c.ascii == 102 then return dfastate_20 + if c.ascii == 103 then return dfastate_20 + if c.ascii == 104 then return dfastate_20 + if c.ascii == 105 then return dfastate_20 + if c.ascii == 106 then return dfastate_20 + if c.ascii == 107 then return dfastate_20 + if c.ascii == 108 then return dfastate_20 + if c.ascii == 109 then return dfastate_20 + if c.ascii == 110 then return dfastate_20 + if c.ascii == 111 then return dfastate_20 + if c.ascii == 112 then return dfastate_20 + if c.ascii == 113 then return dfastate_20 + if c.ascii == 114 then return dfastate_20 + if c.ascii == 115 then return dfastate_20 + if c.ascii == 116 then return dfastate_20 + if c.ascii == 117 then return dfastate_20 + if c.ascii == 118 then return dfastate_20 + if c.ascii == 119 then return dfastate_20 + if c.ascii == 120 then return dfastate_20 + if c.ascii == 121 then return dfastate_20 + if c.ascii == 122 then return dfastate_20 + if c.ascii == 123 then return dfastate_20 + if c.ascii == 124 then return dfastate_20 + if c.ascii == 125 then return dfastate_20 + if c.ascii == 126 then return dfastate_20 + if c.ascii == 92 then return dfastate_21 + return null + end +end +class DFAState4 + super DFAState + redef fun is_accept do return true + redef fun make_token(position, text) do + var t = new Ncomma + t.position = position + t.text = text + return t + end +end +class DFAState5 + super DFAState + redef fun is_accept do return true + redef fun make_token(position, text) do + var t = new Ncolon + t.position = position + t.text = text + return t + end +end +class DFAState6 + super DFAState + redef fun is_accept do return true + redef fun make_token(position, text) do + var t = new Nid + t.position = position + t.text = text + return t + end + redef fun trans(c) do + if c.ascii == 95 then return dfastate_16 + if c.ascii == 48 then return dfastate_17 + if c.ascii == 49 then return dfastate_17 + if c.ascii == 50 then return dfastate_17 + if c.ascii == 51 then return dfastate_17 + if c.ascii == 52 then return dfastate_17 + if c.ascii == 53 then return dfastate_17 + if c.ascii == 54 then return dfastate_17 + if c.ascii == 55 then return dfastate_17 + if c.ascii == 56 then return dfastate_17 + if c.ascii == 57 then return dfastate_17 + if c.ascii == 97 then return dfastate_18 + if c.ascii == 98 then return dfastate_18 + if c.ascii == 99 then return dfastate_18 + if c.ascii == 100 then return dfastate_18 + if c.ascii == 101 then return dfastate_18 + if c.ascii == 102 then return dfastate_18 + if c.ascii == 103 then return dfastate_18 + if c.ascii == 104 then return dfastate_18 + if c.ascii == 105 then return dfastate_18 + if c.ascii == 106 then return dfastate_18 + if c.ascii == 107 then return dfastate_18 + if c.ascii == 108 then return dfastate_18 + if c.ascii == 109 then return dfastate_18 + if c.ascii == 110 then return dfastate_18 + if c.ascii == 111 then return dfastate_18 + if c.ascii == 112 then return dfastate_18 + if c.ascii == 113 then return dfastate_18 + if c.ascii == 114 then return dfastate_18 + if c.ascii == 115 then return dfastate_18 + if c.ascii == 116 then return dfastate_18 + if c.ascii == 117 then return dfastate_18 + if c.ascii == 118 then return dfastate_18 + if c.ascii == 119 then return dfastate_18 + if c.ascii == 120 then return dfastate_18 + if c.ascii == 121 then return dfastate_18 + if c.ascii == 122 then return dfastate_18 + if c.ascii == 65 then return dfastate_19 + if c.ascii == 66 then return dfastate_19 + if c.ascii == 67 then return dfastate_19 + if c.ascii == 68 then return dfastate_19 + if c.ascii == 69 then return dfastate_19 + if c.ascii == 70 then return dfastate_19 + if c.ascii == 71 then return dfastate_19 + if c.ascii == 72 then return dfastate_19 + if c.ascii == 73 then return dfastate_19 + if c.ascii == 74 then return dfastate_19 + if c.ascii == 75 then return dfastate_19 + if c.ascii == 76 then return dfastate_19 + if c.ascii == 77 then return dfastate_19 + if c.ascii == 78 then return dfastate_19 + if c.ascii == 79 then return dfastate_19 + if c.ascii == 80 then return dfastate_19 + if c.ascii == 81 then return dfastate_19 + if c.ascii == 82 then return dfastate_19 + if c.ascii == 83 then return dfastate_19 + if c.ascii == 84 then return dfastate_19 + if c.ascii == 85 then return dfastate_19 + if c.ascii == 86 then return dfastate_19 + if c.ascii == 87 then return dfastate_19 + if c.ascii == 88 then return dfastate_19 + if c.ascii == 89 then return dfastate_19 + if c.ascii == 90 then return dfastate_19 + return null + end +end +class DFAState7 + super DFAState + redef fun is_accept do return true + redef fun make_token(position, text) do + var t = new Nid + t.position = position + t.text = text + return t + end + redef fun trans(c) do + if c.ascii == 95 then return dfastate_16 + if c.ascii == 48 then return dfastate_17 + if c.ascii == 49 then return dfastate_17 + if c.ascii == 50 then return dfastate_17 + if c.ascii == 51 then return dfastate_17 + if c.ascii == 52 then return dfastate_17 + if c.ascii == 53 then return dfastate_17 + if c.ascii == 54 then return dfastate_17 + if c.ascii == 55 then return dfastate_17 + if c.ascii == 56 then return dfastate_17 + if c.ascii == 57 then return dfastate_17 + if c.ascii == 97 then return dfastate_18 + if c.ascii == 98 then return dfastate_18 + if c.ascii == 99 then return dfastate_18 + if c.ascii == 100 then return dfastate_18 + if c.ascii == 101 then return dfastate_18 + if c.ascii == 102 then return dfastate_18 + if c.ascii == 103 then return dfastate_18 + if c.ascii == 104 then return dfastate_18 + if c.ascii == 105 then return dfastate_18 + if c.ascii == 106 then return dfastate_18 + if c.ascii == 107 then return dfastate_18 + if c.ascii == 108 then return dfastate_18 + if c.ascii == 109 then return dfastate_18 + if c.ascii == 110 then return dfastate_18 + if c.ascii == 111 then return dfastate_18 + if c.ascii == 112 then return dfastate_18 + if c.ascii == 113 then return dfastate_18 + if c.ascii == 114 then return dfastate_18 + if c.ascii == 115 then return dfastate_18 + if c.ascii == 116 then return dfastate_18 + if c.ascii == 117 then return dfastate_18 + if c.ascii == 118 then return dfastate_18 + if c.ascii == 119 then return dfastate_18 + if c.ascii == 120 then return dfastate_18 + if c.ascii == 121 then return dfastate_18 + if c.ascii == 122 then return dfastate_18 + if c.ascii == 65 then return dfastate_19 + if c.ascii == 66 then return dfastate_19 + if c.ascii == 67 then return dfastate_19 + if c.ascii == 68 then return dfastate_19 + if c.ascii == 69 then return dfastate_19 + if c.ascii == 70 then return dfastate_19 + if c.ascii == 71 then return dfastate_19 + if c.ascii == 72 then return dfastate_19 + if c.ascii == 73 then return dfastate_19 + if c.ascii == 74 then return dfastate_19 + if c.ascii == 75 then return dfastate_19 + if c.ascii == 76 then return dfastate_19 + if c.ascii == 77 then return dfastate_19 + if c.ascii == 78 then return dfastate_19 + if c.ascii == 79 then return dfastate_19 + if c.ascii == 80 then return dfastate_19 + if c.ascii == 81 then return dfastate_19 + if c.ascii == 82 then return dfastate_19 + if c.ascii == 83 then return dfastate_19 + if c.ascii == 84 then return dfastate_19 + if c.ascii == 85 then return dfastate_19 + if c.ascii == 86 then return dfastate_19 + if c.ascii == 87 then return dfastate_19 + if c.ascii == 88 then return dfastate_19 + if c.ascii == 89 then return dfastate_19 + if c.ascii == 90 then return dfastate_19 + return null + end +end +class DFAState8 + super DFAState + redef fun is_accept do return true + redef fun make_token(position, text) do + var t = new Nid + t.position = position + t.text = text + return t + end + redef fun trans(c) do + if c.ascii == 95 then return dfastate_16 + if c.ascii == 48 then return dfastate_17 + if c.ascii == 49 then return dfastate_17 + if c.ascii == 50 then return dfastate_17 + if c.ascii == 51 then return dfastate_17 + if c.ascii == 52 then return dfastate_17 + if c.ascii == 53 then return dfastate_17 + if c.ascii == 54 then return dfastate_17 + if c.ascii == 55 then return dfastate_17 + if c.ascii == 56 then return dfastate_17 + if c.ascii == 57 then return dfastate_17 + if c.ascii == 97 then return dfastate_18 + if c.ascii == 98 then return dfastate_18 + if c.ascii == 99 then return dfastate_18 + if c.ascii == 100 then return dfastate_18 + if c.ascii == 101 then return dfastate_18 + if c.ascii == 102 then return dfastate_18 + if c.ascii == 103 then return dfastate_18 + if c.ascii == 104 then return dfastate_18 + if c.ascii == 105 then return dfastate_18 + if c.ascii == 106 then return dfastate_18 + if c.ascii == 107 then return dfastate_18 + if c.ascii == 108 then return dfastate_18 + if c.ascii == 109 then return dfastate_18 + if c.ascii == 110 then return dfastate_18 + if c.ascii == 111 then return dfastate_18 + if c.ascii == 112 then return dfastate_18 + if c.ascii == 113 then return dfastate_18 + if c.ascii == 114 then return dfastate_18 + if c.ascii == 115 then return dfastate_18 + if c.ascii == 116 then return dfastate_18 + if c.ascii == 117 then return dfastate_18 + if c.ascii == 118 then return dfastate_18 + if c.ascii == 119 then return dfastate_18 + if c.ascii == 120 then return dfastate_18 + if c.ascii == 121 then return dfastate_18 + if c.ascii == 122 then return dfastate_18 + if c.ascii == 65 then return dfastate_19 + if c.ascii == 66 then return dfastate_19 + if c.ascii == 67 then return dfastate_19 + if c.ascii == 68 then return dfastate_19 + if c.ascii == 69 then return dfastate_19 + if c.ascii == 70 then return dfastate_19 + if c.ascii == 71 then return dfastate_19 + if c.ascii == 72 then return dfastate_19 + if c.ascii == 73 then return dfastate_19 + if c.ascii == 74 then return dfastate_19 + if c.ascii == 75 then return dfastate_19 + if c.ascii == 76 then return dfastate_19 + if c.ascii == 77 then return dfastate_19 + if c.ascii == 78 then return dfastate_19 + if c.ascii == 79 then return dfastate_19 + if c.ascii == 80 then return dfastate_19 + if c.ascii == 81 then return dfastate_19 + if c.ascii == 82 then return dfastate_19 + if c.ascii == 83 then return dfastate_19 + if c.ascii == 84 then return dfastate_19 + if c.ascii == 85 then return dfastate_19 + if c.ascii == 86 then return dfastate_19 + if c.ascii == 87 then return dfastate_19 + if c.ascii == 88 then return dfastate_19 + if c.ascii == 89 then return dfastate_19 + if c.ascii == 90 then return dfastate_19 + return null + end +end +class DFAState9 + super DFAState + redef fun is_accept do return true + redef fun make_token(position, text) do + var t = new Neol + t.position = position + t.text = text + return t + end +end +class DFAState10 + super DFAState + redef fun is_accept do return true + redef fun make_token(position, text) do + var t = new Neol + t.position = position + t.text = text + return t + end + redef fun trans(c) do + if c.ascii == 13 then return dfastate_15 + return null + end +end +class DFAState11 + super DFAState + redef fun is_accept do return true + redef fun make_token(position, text) do + var t = new Ncomment + t.position = position + t.text = text + return t + end + redef fun trans(c) do + if c.ascii == 32 then return dfastate_14 + if c.ascii == 33 then return dfastate_14 + if c.ascii == 34 then return dfastate_14 + if c.ascii == 35 then return dfastate_14 + if c.ascii == 36 then return dfastate_14 + if c.ascii == 37 then return dfastate_14 + if c.ascii == 38 then return dfastate_14 + if c.ascii == 39 then return dfastate_14 + if c.ascii == 40 then return dfastate_14 + if c.ascii == 41 then return dfastate_14 + if c.ascii == 42 then return dfastate_14 + if c.ascii == 43 then return dfastate_14 + if c.ascii == 44 then return dfastate_14 + if c.ascii == 45 then return dfastate_14 + if c.ascii == 46 then return dfastate_14 + if c.ascii == 47 then return dfastate_14 + if c.ascii == 48 then return dfastate_14 + if c.ascii == 49 then return dfastate_14 + if c.ascii == 50 then return dfastate_14 + if c.ascii == 51 then return dfastate_14 + if c.ascii == 52 then return dfastate_14 + if c.ascii == 53 then return dfastate_14 + if c.ascii == 54 then return dfastate_14 + if c.ascii == 55 then return dfastate_14 + if c.ascii == 56 then return dfastate_14 + if c.ascii == 57 then return dfastate_14 + if c.ascii == 58 then return dfastate_14 + if c.ascii == 59 then return dfastate_14 + if c.ascii == 60 then return dfastate_14 + if c.ascii == 61 then return dfastate_14 + if c.ascii == 62 then return dfastate_14 + if c.ascii == 63 then return dfastate_14 + if c.ascii == 64 then return dfastate_14 + if c.ascii == 65 then return dfastate_14 + if c.ascii == 66 then return dfastate_14 + if c.ascii == 67 then return dfastate_14 + if c.ascii == 68 then return dfastate_14 + if c.ascii == 69 then return dfastate_14 + if c.ascii == 70 then return dfastate_14 + if c.ascii == 71 then return dfastate_14 + if c.ascii == 72 then return dfastate_14 + if c.ascii == 73 then return dfastate_14 + if c.ascii == 74 then return dfastate_14 + if c.ascii == 75 then return dfastate_14 + if c.ascii == 76 then return dfastate_14 + if c.ascii == 77 then return dfastate_14 + if c.ascii == 78 then return dfastate_14 + if c.ascii == 79 then return dfastate_14 + if c.ascii == 80 then return dfastate_14 + if c.ascii == 81 then return dfastate_14 + if c.ascii == 82 then return dfastate_14 + if c.ascii == 83 then return dfastate_14 + if c.ascii == 84 then return dfastate_14 + if c.ascii == 85 then return dfastate_14 + if c.ascii == 86 then return dfastate_14 + if c.ascii == 87 then return dfastate_14 + if c.ascii == 88 then return dfastate_14 + if c.ascii == 89 then return dfastate_14 + if c.ascii == 90 then return dfastate_14 + if c.ascii == 91 then return dfastate_14 + if c.ascii == 92 then return dfastate_14 + if c.ascii == 93 then return dfastate_14 + if c.ascii == 94 then return dfastate_14 + if c.ascii == 95 then return dfastate_14 + if c.ascii == 96 then return dfastate_14 + if c.ascii == 97 then return dfastate_14 + if c.ascii == 98 then return dfastate_14 + if c.ascii == 99 then return dfastate_14 + if c.ascii == 100 then return dfastate_14 + if c.ascii == 101 then return dfastate_14 + if c.ascii == 102 then return dfastate_14 + if c.ascii == 103 then return dfastate_14 + if c.ascii == 104 then return dfastate_14 + if c.ascii == 105 then return dfastate_14 + if c.ascii == 106 then return dfastate_14 + if c.ascii == 107 then return dfastate_14 + if c.ascii == 108 then return dfastate_14 + if c.ascii == 109 then return dfastate_14 + if c.ascii == 110 then return dfastate_14 + if c.ascii == 111 then return dfastate_14 + if c.ascii == 112 then return dfastate_14 + if c.ascii == 113 then return dfastate_14 + if c.ascii == 114 then return dfastate_14 + if c.ascii == 115 then return dfastate_14 + if c.ascii == 116 then return dfastate_14 + if c.ascii == 117 then return dfastate_14 + if c.ascii == 118 then return dfastate_14 + if c.ascii == 119 then return dfastate_14 + if c.ascii == 120 then return dfastate_14 + if c.ascii == 121 then return dfastate_14 + if c.ascii == 122 then return dfastate_14 + if c.ascii == 123 then return dfastate_14 + if c.ascii == 124 then return dfastate_14 + if c.ascii == 125 then return dfastate_14 + if c.ascii == 126 then return dfastate_14 + return null + end +end +class DFAState12 + super DFAState + redef fun is_accept do return true + redef fun make_token(position, text) do + return null + end + redef fun trans(c) do + if c.ascii == 9 then return dfastate_12 + if c.ascii == 32 then return dfastate_13 + return null + end +end +class DFAState13 + super DFAState + redef fun is_accept do return true + redef fun make_token(position, text) do + return null + end + redef fun trans(c) do + if c.ascii == 9 then return dfastate_12 + if c.ascii == 32 then return dfastate_13 + return null + end +end +class DFAState14 + super DFAState + redef fun is_accept do return true + redef fun make_token(position, text) do + var t = new Ncomment + t.position = position + t.text = text + return t + end + redef fun trans(c) do + if c.ascii == 32 then return dfastate_14 + if c.ascii == 33 then return dfastate_14 + if c.ascii == 34 then return dfastate_14 + if c.ascii == 35 then return dfastate_14 + if c.ascii == 36 then return dfastate_14 + if c.ascii == 37 then return dfastate_14 + if c.ascii == 38 then return dfastate_14 + if c.ascii == 39 then return dfastate_14 + if c.ascii == 40 then return dfastate_14 + if c.ascii == 41 then return dfastate_14 + if c.ascii == 42 then return dfastate_14 + if c.ascii == 43 then return dfastate_14 + if c.ascii == 44 then return dfastate_14 + if c.ascii == 45 then return dfastate_14 + if c.ascii == 46 then return dfastate_14 + if c.ascii == 47 then return dfastate_14 + if c.ascii == 48 then return dfastate_14 + if c.ascii == 49 then return dfastate_14 + if c.ascii == 50 then return dfastate_14 + if c.ascii == 51 then return dfastate_14 + if c.ascii == 52 then return dfastate_14 + if c.ascii == 53 then return dfastate_14 + if c.ascii == 54 then return dfastate_14 + if c.ascii == 55 then return dfastate_14 + if c.ascii == 56 then return dfastate_14 + if c.ascii == 57 then return dfastate_14 + if c.ascii == 58 then return dfastate_14 + if c.ascii == 59 then return dfastate_14 + if c.ascii == 60 then return dfastate_14 + if c.ascii == 61 then return dfastate_14 + if c.ascii == 62 then return dfastate_14 + if c.ascii == 63 then return dfastate_14 + if c.ascii == 64 then return dfastate_14 + if c.ascii == 65 then return dfastate_14 + if c.ascii == 66 then return dfastate_14 + if c.ascii == 67 then return dfastate_14 + if c.ascii == 68 then return dfastate_14 + if c.ascii == 69 then return dfastate_14 + if c.ascii == 70 then return dfastate_14 + if c.ascii == 71 then return dfastate_14 + if c.ascii == 72 then return dfastate_14 + if c.ascii == 73 then return dfastate_14 + if c.ascii == 74 then return dfastate_14 + if c.ascii == 75 then return dfastate_14 + if c.ascii == 76 then return dfastate_14 + if c.ascii == 77 then return dfastate_14 + if c.ascii == 78 then return dfastate_14 + if c.ascii == 79 then return dfastate_14 + if c.ascii == 80 then return dfastate_14 + if c.ascii == 81 then return dfastate_14 + if c.ascii == 82 then return dfastate_14 + if c.ascii == 83 then return dfastate_14 + if c.ascii == 84 then return dfastate_14 + if c.ascii == 85 then return dfastate_14 + if c.ascii == 86 then return dfastate_14 + if c.ascii == 87 then return dfastate_14 + if c.ascii == 88 then return dfastate_14 + if c.ascii == 89 then return dfastate_14 + if c.ascii == 90 then return dfastate_14 + if c.ascii == 91 then return dfastate_14 + if c.ascii == 92 then return dfastate_14 + if c.ascii == 93 then return dfastate_14 + if c.ascii == 94 then return dfastate_14 + if c.ascii == 95 then return dfastate_14 + if c.ascii == 96 then return dfastate_14 + if c.ascii == 97 then return dfastate_14 + if c.ascii == 98 then return dfastate_14 + if c.ascii == 99 then return dfastate_14 + if c.ascii == 100 then return dfastate_14 + if c.ascii == 101 then return dfastate_14 + if c.ascii == 102 then return dfastate_14 + if c.ascii == 103 then return dfastate_14 + if c.ascii == 104 then return dfastate_14 + if c.ascii == 105 then return dfastate_14 + if c.ascii == 106 then return dfastate_14 + if c.ascii == 107 then return dfastate_14 + if c.ascii == 108 then return dfastate_14 + if c.ascii == 109 then return dfastate_14 + if c.ascii == 110 then return dfastate_14 + if c.ascii == 111 then return dfastate_14 + if c.ascii == 112 then return dfastate_14 + if c.ascii == 113 then return dfastate_14 + if c.ascii == 114 then return dfastate_14 + if c.ascii == 115 then return dfastate_14 + if c.ascii == 116 then return dfastate_14 + if c.ascii == 117 then return dfastate_14 + if c.ascii == 118 then return dfastate_14 + if c.ascii == 119 then return dfastate_14 + if c.ascii == 120 then return dfastate_14 + if c.ascii == 121 then return dfastate_14 + if c.ascii == 122 then return dfastate_14 + if c.ascii == 123 then return dfastate_14 + if c.ascii == 124 then return dfastate_14 + if c.ascii == 125 then return dfastate_14 + if c.ascii == 126 then return dfastate_14 + return null + end +end +class DFAState15 + super DFAState + redef fun is_accept do return true + redef fun make_token(position, text) do + var t = new Neol + t.position = position + t.text = text + return t + end +end +class DFAState16 + super DFAState + redef fun is_accept do return true + redef fun make_token(position, text) do + var t = new Nid + t.position = position + t.text = text + return t + end + redef fun trans(c) do + if c.ascii == 95 then return dfastate_16 + if c.ascii == 48 then return dfastate_17 + if c.ascii == 49 then return dfastate_17 + if c.ascii == 50 then return dfastate_17 + if c.ascii == 51 then return dfastate_17 + if c.ascii == 52 then return dfastate_17 + if c.ascii == 53 then return dfastate_17 + if c.ascii == 54 then return dfastate_17 + if c.ascii == 55 then return dfastate_17 + if c.ascii == 56 then return dfastate_17 + if c.ascii == 57 then return dfastate_17 + if c.ascii == 97 then return dfastate_18 + if c.ascii == 98 then return dfastate_18 + if c.ascii == 99 then return dfastate_18 + if c.ascii == 100 then return dfastate_18 + if c.ascii == 101 then return dfastate_18 + if c.ascii == 102 then return dfastate_18 + if c.ascii == 103 then return dfastate_18 + if c.ascii == 104 then return dfastate_18 + if c.ascii == 105 then return dfastate_18 + if c.ascii == 106 then return dfastate_18 + if c.ascii == 107 then return dfastate_18 + if c.ascii == 108 then return dfastate_18 + if c.ascii == 109 then return dfastate_18 + if c.ascii == 110 then return dfastate_18 + if c.ascii == 111 then return dfastate_18 + if c.ascii == 112 then return dfastate_18 + if c.ascii == 113 then return dfastate_18 + if c.ascii == 114 then return dfastate_18 + if c.ascii == 115 then return dfastate_18 + if c.ascii == 116 then return dfastate_18 + if c.ascii == 117 then return dfastate_18 + if c.ascii == 118 then return dfastate_18 + if c.ascii == 119 then return dfastate_18 + if c.ascii == 120 then return dfastate_18 + if c.ascii == 121 then return dfastate_18 + if c.ascii == 122 then return dfastate_18 + if c.ascii == 65 then return dfastate_19 + if c.ascii == 66 then return dfastate_19 + if c.ascii == 67 then return dfastate_19 + if c.ascii == 68 then return dfastate_19 + if c.ascii == 69 then return dfastate_19 + if c.ascii == 70 then return dfastate_19 + if c.ascii == 71 then return dfastate_19 + if c.ascii == 72 then return dfastate_19 + if c.ascii == 73 then return dfastate_19 + if c.ascii == 74 then return dfastate_19 + if c.ascii == 75 then return dfastate_19 + if c.ascii == 76 then return dfastate_19 + if c.ascii == 77 then return dfastate_19 + if c.ascii == 78 then return dfastate_19 + if c.ascii == 79 then return dfastate_19 + if c.ascii == 80 then return dfastate_19 + if c.ascii == 81 then return dfastate_19 + if c.ascii == 82 then return dfastate_19 + if c.ascii == 83 then return dfastate_19 + if c.ascii == 84 then return dfastate_19 + if c.ascii == 85 then return dfastate_19 + if c.ascii == 86 then return dfastate_19 + if c.ascii == 87 then return dfastate_19 + if c.ascii == 88 then return dfastate_19 + if c.ascii == 89 then return dfastate_19 + if c.ascii == 90 then return dfastate_19 + return null + end +end +class DFAState17 + super DFAState + redef fun is_accept do return true + redef fun make_token(position, text) do + var t = new Nid + t.position = position + t.text = text + return t + end + redef fun trans(c) do + if c.ascii == 95 then return dfastate_16 + if c.ascii == 48 then return dfastate_17 + if c.ascii == 49 then return dfastate_17 + if c.ascii == 50 then return dfastate_17 + if c.ascii == 51 then return dfastate_17 + if c.ascii == 52 then return dfastate_17 + if c.ascii == 53 then return dfastate_17 + if c.ascii == 54 then return dfastate_17 + if c.ascii == 55 then return dfastate_17 + if c.ascii == 56 then return dfastate_17 + if c.ascii == 57 then return dfastate_17 + if c.ascii == 97 then return dfastate_18 + if c.ascii == 98 then return dfastate_18 + if c.ascii == 99 then return dfastate_18 + if c.ascii == 100 then return dfastate_18 + if c.ascii == 101 then return dfastate_18 + if c.ascii == 102 then return dfastate_18 + if c.ascii == 103 then return dfastate_18 + if c.ascii == 104 then return dfastate_18 + if c.ascii == 105 then return dfastate_18 + if c.ascii == 106 then return dfastate_18 + if c.ascii == 107 then return dfastate_18 + if c.ascii == 108 then return dfastate_18 + if c.ascii == 109 then return dfastate_18 + if c.ascii == 110 then return dfastate_18 + if c.ascii == 111 then return dfastate_18 + if c.ascii == 112 then return dfastate_18 + if c.ascii == 113 then return dfastate_18 + if c.ascii == 114 then return dfastate_18 + if c.ascii == 115 then return dfastate_18 + if c.ascii == 116 then return dfastate_18 + if c.ascii == 117 then return dfastate_18 + if c.ascii == 118 then return dfastate_18 + if c.ascii == 119 then return dfastate_18 + if c.ascii == 120 then return dfastate_18 + if c.ascii == 121 then return dfastate_18 + if c.ascii == 122 then return dfastate_18 + if c.ascii == 65 then return dfastate_19 + if c.ascii == 66 then return dfastate_19 + if c.ascii == 67 then return dfastate_19 + if c.ascii == 68 then return dfastate_19 + if c.ascii == 69 then return dfastate_19 + if c.ascii == 70 then return dfastate_19 + if c.ascii == 71 then return dfastate_19 + if c.ascii == 72 then return dfastate_19 + if c.ascii == 73 then return dfastate_19 + if c.ascii == 74 then return dfastate_19 + if c.ascii == 75 then return dfastate_19 + if c.ascii == 76 then return dfastate_19 + if c.ascii == 77 then return dfastate_19 + if c.ascii == 78 then return dfastate_19 + if c.ascii == 79 then return dfastate_19 + if c.ascii == 80 then return dfastate_19 + if c.ascii == 81 then return dfastate_19 + if c.ascii == 82 then return dfastate_19 + if c.ascii == 83 then return dfastate_19 + if c.ascii == 84 then return dfastate_19 + if c.ascii == 85 then return dfastate_19 + if c.ascii == 86 then return dfastate_19 + if c.ascii == 87 then return dfastate_19 + if c.ascii == 88 then return dfastate_19 + if c.ascii == 89 then return dfastate_19 + if c.ascii == 90 then return dfastate_19 + return null + end +end +class DFAState18 + super DFAState + redef fun is_accept do return true + redef fun make_token(position, text) do + var t = new Nid + t.position = position + t.text = text + return t + end + redef fun trans(c) do + if c.ascii == 95 then return dfastate_16 + if c.ascii == 48 then return dfastate_17 + if c.ascii == 49 then return dfastate_17 + if c.ascii == 50 then return dfastate_17 + if c.ascii == 51 then return dfastate_17 + if c.ascii == 52 then return dfastate_17 + if c.ascii == 53 then return dfastate_17 + if c.ascii == 54 then return dfastate_17 + if c.ascii == 55 then return dfastate_17 + if c.ascii == 56 then return dfastate_17 + if c.ascii == 57 then return dfastate_17 + if c.ascii == 97 then return dfastate_18 + if c.ascii == 98 then return dfastate_18 + if c.ascii == 99 then return dfastate_18 + if c.ascii == 100 then return dfastate_18 + if c.ascii == 101 then return dfastate_18 + if c.ascii == 102 then return dfastate_18 + if c.ascii == 103 then return dfastate_18 + if c.ascii == 104 then return dfastate_18 + if c.ascii == 105 then return dfastate_18 + if c.ascii == 106 then return dfastate_18 + if c.ascii == 107 then return dfastate_18 + if c.ascii == 108 then return dfastate_18 + if c.ascii == 109 then return dfastate_18 + if c.ascii == 110 then return dfastate_18 + if c.ascii == 111 then return dfastate_18 + if c.ascii == 112 then return dfastate_18 + if c.ascii == 113 then return dfastate_18 + if c.ascii == 114 then return dfastate_18 + if c.ascii == 115 then return dfastate_18 + if c.ascii == 116 then return dfastate_18 + if c.ascii == 117 then return dfastate_18 + if c.ascii == 118 then return dfastate_18 + if c.ascii == 119 then return dfastate_18 + if c.ascii == 120 then return dfastate_18 + if c.ascii == 121 then return dfastate_18 + if c.ascii == 122 then return dfastate_18 + if c.ascii == 65 then return dfastate_19 + if c.ascii == 66 then return dfastate_19 + if c.ascii == 67 then return dfastate_19 + if c.ascii == 68 then return dfastate_19 + if c.ascii == 69 then return dfastate_19 + if c.ascii == 70 then return dfastate_19 + if c.ascii == 71 then return dfastate_19 + if c.ascii == 72 then return dfastate_19 + if c.ascii == 73 then return dfastate_19 + if c.ascii == 74 then return dfastate_19 + if c.ascii == 75 then return dfastate_19 + if c.ascii == 76 then return dfastate_19 + if c.ascii == 77 then return dfastate_19 + if c.ascii == 78 then return dfastate_19 + if c.ascii == 79 then return dfastate_19 + if c.ascii == 80 then return dfastate_19 + if c.ascii == 81 then return dfastate_19 + if c.ascii == 82 then return dfastate_19 + if c.ascii == 83 then return dfastate_19 + if c.ascii == 84 then return dfastate_19 + if c.ascii == 85 then return dfastate_19 + if c.ascii == 86 then return dfastate_19 + if c.ascii == 87 then return dfastate_19 + if c.ascii == 88 then return dfastate_19 + if c.ascii == 89 then return dfastate_19 + if c.ascii == 90 then return dfastate_19 + return null + end +end +class DFAState19 + super DFAState + redef fun is_accept do return true + redef fun make_token(position, text) do + var t = new Nid + t.position = position + t.text = text + return t + end + redef fun trans(c) do + if c.ascii == 95 then return dfastate_16 + if c.ascii == 48 then return dfastate_17 + if c.ascii == 49 then return dfastate_17 + if c.ascii == 50 then return dfastate_17 + if c.ascii == 51 then return dfastate_17 + if c.ascii == 52 then return dfastate_17 + if c.ascii == 53 then return dfastate_17 + if c.ascii == 54 then return dfastate_17 + if c.ascii == 55 then return dfastate_17 + if c.ascii == 56 then return dfastate_17 + if c.ascii == 57 then return dfastate_17 + if c.ascii == 97 then return dfastate_18 + if c.ascii == 98 then return dfastate_18 + if c.ascii == 99 then return dfastate_18 + if c.ascii == 100 then return dfastate_18 + if c.ascii == 101 then return dfastate_18 + if c.ascii == 102 then return dfastate_18 + if c.ascii == 103 then return dfastate_18 + if c.ascii == 104 then return dfastate_18 + if c.ascii == 105 then return dfastate_18 + if c.ascii == 106 then return dfastate_18 + if c.ascii == 107 then return dfastate_18 + if c.ascii == 108 then return dfastate_18 + if c.ascii == 109 then return dfastate_18 + if c.ascii == 110 then return dfastate_18 + if c.ascii == 111 then return dfastate_18 + if c.ascii == 112 then return dfastate_18 + if c.ascii == 113 then return dfastate_18 + if c.ascii == 114 then return dfastate_18 + if c.ascii == 115 then return dfastate_18 + if c.ascii == 116 then return dfastate_18 + if c.ascii == 117 then return dfastate_18 + if c.ascii == 118 then return dfastate_18 + if c.ascii == 119 then return dfastate_18 + if c.ascii == 120 then return dfastate_18 + if c.ascii == 121 then return dfastate_18 + if c.ascii == 122 then return dfastate_18 + if c.ascii == 65 then return dfastate_19 + if c.ascii == 66 then return dfastate_19 + if c.ascii == 67 then return dfastate_19 + if c.ascii == 68 then return dfastate_19 + if c.ascii == 69 then return dfastate_19 + if c.ascii == 70 then return dfastate_19 + if c.ascii == 71 then return dfastate_19 + if c.ascii == 72 then return dfastate_19 + if c.ascii == 73 then return dfastate_19 + if c.ascii == 74 then return dfastate_19 + if c.ascii == 75 then return dfastate_19 + if c.ascii == 76 then return dfastate_19 + if c.ascii == 77 then return dfastate_19 + if c.ascii == 78 then return dfastate_19 + if c.ascii == 79 then return dfastate_19 + if c.ascii == 80 then return dfastate_19 + if c.ascii == 81 then return dfastate_19 + if c.ascii == 82 then return dfastate_19 + if c.ascii == 83 then return dfastate_19 + if c.ascii == 84 then return dfastate_19 + if c.ascii == 85 then return dfastate_19 + if c.ascii == 86 then return dfastate_19 + if c.ascii == 87 then return dfastate_19 + if c.ascii == 88 then return dfastate_19 + if c.ascii == 89 then return dfastate_19 + if c.ascii == 90 then return dfastate_19 + return null + end +end +class DFAState20 + super DFAState + redef fun trans(c) do + if c.ascii == 39 then return dfastate_32 + return null + end +end +class DFAState21 + super DFAState + redef fun trans(c) do + if c.ascii == 120 then return dfastate_22 + if c.ascii == 32 then return dfastate_23 + if c.ascii == 33 then return dfastate_23 + if c.ascii == 34 then return dfastate_23 + if c.ascii == 35 then return dfastate_23 + if c.ascii == 36 then return dfastate_23 + if c.ascii == 37 then return dfastate_23 + if c.ascii == 38 then return dfastate_23 + if c.ascii == 39 then return dfastate_23 + if c.ascii == 40 then return dfastate_23 + if c.ascii == 41 then return dfastate_23 + if c.ascii == 42 then return dfastate_23 + if c.ascii == 43 then return dfastate_23 + if c.ascii == 44 then return dfastate_23 + if c.ascii == 45 then return dfastate_23 + if c.ascii == 46 then return dfastate_23 + if c.ascii == 47 then return dfastate_23 + if c.ascii == 48 then return dfastate_23 + if c.ascii == 49 then return dfastate_23 + if c.ascii == 50 then return dfastate_23 + if c.ascii == 51 then return dfastate_23 + if c.ascii == 52 then return dfastate_23 + if c.ascii == 53 then return dfastate_23 + if c.ascii == 54 then return dfastate_23 + if c.ascii == 55 then return dfastate_23 + if c.ascii == 56 then return dfastate_23 + if c.ascii == 57 then return dfastate_23 + if c.ascii == 58 then return dfastate_23 + if c.ascii == 59 then return dfastate_23 + if c.ascii == 60 then return dfastate_23 + if c.ascii == 61 then return dfastate_23 + if c.ascii == 62 then return dfastate_23 + if c.ascii == 63 then return dfastate_23 + if c.ascii == 64 then return dfastate_23 + if c.ascii == 65 then return dfastate_23 + if c.ascii == 66 then return dfastate_23 + if c.ascii == 67 then return dfastate_23 + if c.ascii == 68 then return dfastate_23 + if c.ascii == 69 then return dfastate_23 + if c.ascii == 70 then return dfastate_23 + if c.ascii == 71 then return dfastate_23 + if c.ascii == 72 then return dfastate_23 + if c.ascii == 73 then return dfastate_23 + if c.ascii == 74 then return dfastate_23 + if c.ascii == 75 then return dfastate_23 + if c.ascii == 76 then return dfastate_23 + if c.ascii == 77 then return dfastate_23 + if c.ascii == 78 then return dfastate_23 + if c.ascii == 79 then return dfastate_23 + if c.ascii == 80 then return dfastate_23 + if c.ascii == 81 then return dfastate_23 + if c.ascii == 82 then return dfastate_23 + if c.ascii == 83 then return dfastate_23 + if c.ascii == 84 then return dfastate_23 + if c.ascii == 85 then return dfastate_23 + if c.ascii == 86 then return dfastate_23 + if c.ascii == 87 then return dfastate_23 + if c.ascii == 88 then return dfastate_23 + if c.ascii == 89 then return dfastate_23 + if c.ascii == 90 then return dfastate_23 + if c.ascii == 91 then return dfastate_23 + if c.ascii == 92 then return dfastate_23 + if c.ascii == 93 then return dfastate_23 + if c.ascii == 94 then return dfastate_23 + if c.ascii == 95 then return dfastate_23 + if c.ascii == 96 then return dfastate_23 + if c.ascii == 97 then return dfastate_23 + if c.ascii == 98 then return dfastate_23 + if c.ascii == 99 then return dfastate_23 + if c.ascii == 100 then return dfastate_23 + if c.ascii == 101 then return dfastate_23 + if c.ascii == 102 then return dfastate_23 + if c.ascii == 103 then return dfastate_23 + if c.ascii == 104 then return dfastate_23 + if c.ascii == 105 then return dfastate_23 + if c.ascii == 106 then return dfastate_23 + if c.ascii == 107 then return dfastate_23 + if c.ascii == 108 then return dfastate_23 + if c.ascii == 109 then return dfastate_23 + if c.ascii == 110 then return dfastate_23 + if c.ascii == 111 then return dfastate_23 + if c.ascii == 112 then return dfastate_23 + if c.ascii == 113 then return dfastate_23 + if c.ascii == 114 then return dfastate_23 + if c.ascii == 115 then return dfastate_23 + if c.ascii == 116 then return dfastate_23 + if c.ascii == 117 then return dfastate_23 + if c.ascii == 118 then return dfastate_23 + if c.ascii == 119 then return dfastate_23 + if c.ascii == 121 then return dfastate_23 + if c.ascii == 122 then return dfastate_23 + if c.ascii == 123 then return dfastate_23 + if c.ascii == 124 then return dfastate_23 + if c.ascii == 125 then return dfastate_23 + if c.ascii == 126 then return dfastate_23 + return null + end +end +class DFAState22 + super DFAState + redef fun trans(c) do + if c.ascii == 39 then return dfastate_24 + if c.ascii == 97 then return dfastate_25 + if c.ascii == 98 then return dfastate_25 + if c.ascii == 99 then return dfastate_25 + if c.ascii == 100 then return dfastate_25 + if c.ascii == 101 then return dfastate_25 + if c.ascii == 102 then return dfastate_25 + if c.ascii == 48 then return dfastate_26 + if c.ascii == 49 then return dfastate_26 + if c.ascii == 50 then return dfastate_26 + if c.ascii == 51 then return dfastate_26 + if c.ascii == 52 then return dfastate_26 + if c.ascii == 53 then return dfastate_26 + if c.ascii == 54 then return dfastate_26 + if c.ascii == 55 then return dfastate_26 + if c.ascii == 56 then return dfastate_26 + if c.ascii == 57 then return dfastate_26 + if c.ascii == 65 then return dfastate_27 + if c.ascii == 66 then return dfastate_27 + if c.ascii == 67 then return dfastate_27 + if c.ascii == 68 then return dfastate_27 + if c.ascii == 69 then return dfastate_27 + if c.ascii == 70 then return dfastate_27 + return null + end +end +class DFAState23 + super DFAState + redef fun trans(c) do + if c.ascii == 39 then return dfastate_24 + return null + end +end +class DFAState24 + super DFAState + redef fun is_accept do return true + redef fun make_token(position, text) do + var t = new Nchar + t.position = position + t.text = text + return t + end +end +class DFAState25 + super DFAState + redef fun trans(c) do + if c.ascii == 97 then return dfastate_28 + if c.ascii == 98 then return dfastate_28 + if c.ascii == 99 then return dfastate_28 + if c.ascii == 100 then return dfastate_28 + if c.ascii == 101 then return dfastate_28 + if c.ascii == 102 then return dfastate_28 + if c.ascii == 48 then return dfastate_29 + if c.ascii == 49 then return dfastate_29 + if c.ascii == 50 then return dfastate_29 + if c.ascii == 51 then return dfastate_29 + if c.ascii == 52 then return dfastate_29 + if c.ascii == 53 then return dfastate_29 + if c.ascii == 54 then return dfastate_29 + if c.ascii == 55 then return dfastate_29 + if c.ascii == 56 then return dfastate_29 + if c.ascii == 57 then return dfastate_29 + if c.ascii == 65 then return dfastate_30 + if c.ascii == 66 then return dfastate_30 + if c.ascii == 67 then return dfastate_30 + if c.ascii == 68 then return dfastate_30 + if c.ascii == 69 then return dfastate_30 + if c.ascii == 70 then return dfastate_30 + return null + end +end +class DFAState26 + super DFAState + redef fun trans(c) do + if c.ascii == 97 then return dfastate_28 + if c.ascii == 98 then return dfastate_28 + if c.ascii == 99 then return dfastate_28 + if c.ascii == 100 then return dfastate_28 + if c.ascii == 101 then return dfastate_28 + if c.ascii == 102 then return dfastate_28 + if c.ascii == 48 then return dfastate_29 + if c.ascii == 49 then return dfastate_29 + if c.ascii == 50 then return dfastate_29 + if c.ascii == 51 then return dfastate_29 + if c.ascii == 52 then return dfastate_29 + if c.ascii == 53 then return dfastate_29 + if c.ascii == 54 then return dfastate_29 + if c.ascii == 55 then return dfastate_29 + if c.ascii == 56 then return dfastate_29 + if c.ascii == 57 then return dfastate_29 + if c.ascii == 65 then return dfastate_30 + if c.ascii == 66 then return dfastate_30 + if c.ascii == 67 then return dfastate_30 + if c.ascii == 68 then return dfastate_30 + if c.ascii == 69 then return dfastate_30 + if c.ascii == 70 then return dfastate_30 + return null + end +end +class DFAState27 + super DFAState + redef fun trans(c) do + if c.ascii == 97 then return dfastate_28 + if c.ascii == 98 then return dfastate_28 + if c.ascii == 99 then return dfastate_28 + if c.ascii == 100 then return dfastate_28 + if c.ascii == 101 then return dfastate_28 + if c.ascii == 102 then return dfastate_28 + if c.ascii == 48 then return dfastate_29 + if c.ascii == 49 then return dfastate_29 + if c.ascii == 50 then return dfastate_29 + if c.ascii == 51 then return dfastate_29 + if c.ascii == 52 then return dfastate_29 + if c.ascii == 53 then return dfastate_29 + if c.ascii == 54 then return dfastate_29 + if c.ascii == 55 then return dfastate_29 + if c.ascii == 56 then return dfastate_29 + if c.ascii == 57 then return dfastate_29 + if c.ascii == 65 then return dfastate_30 + if c.ascii == 66 then return dfastate_30 + if c.ascii == 67 then return dfastate_30 + if c.ascii == 68 then return dfastate_30 + if c.ascii == 69 then return dfastate_30 + if c.ascii == 70 then return dfastate_30 + return null + end +end +class DFAState28 + super DFAState + redef fun trans(c) do + if c.ascii == 39 then return dfastate_31 + return null + end +end +class DFAState29 + super DFAState + redef fun trans(c) do + if c.ascii == 39 then return dfastate_31 + return null + end +end +class DFAState30 + super DFAState + redef fun trans(c) do + if c.ascii == 39 then return dfastate_31 + return null + end +end +class DFAState31 + super DFAState + redef fun is_accept do return true + redef fun make_token(position, text) do + var t = new Nchar + t.position = position + t.text = text + return t + end +end +class DFAState32 + super DFAState + redef fun is_accept do return true + redef fun make_token(position, text) do + var t = new Nchar + t.position = position + t.text = text + return t + end +end +class DFAState33 + super DFAState + redef fun trans(c) do + if c.ascii == 32 then return dfastate_33 + if c.ascii == 33 then return dfastate_33 + if c.ascii == 35 then return dfastate_33 + if c.ascii == 36 then return dfastate_33 + if c.ascii == 37 then return dfastate_33 + if c.ascii == 38 then return dfastate_33 + if c.ascii == 39 then return dfastate_33 + if c.ascii == 40 then return dfastate_33 + if c.ascii == 41 then return dfastate_33 + if c.ascii == 42 then return dfastate_33 + if c.ascii == 43 then return dfastate_33 + if c.ascii == 44 then return dfastate_33 + if c.ascii == 45 then return dfastate_33 + if c.ascii == 46 then return dfastate_33 + if c.ascii == 47 then return dfastate_33 + if c.ascii == 48 then return dfastate_33 + if c.ascii == 49 then return dfastate_33 + if c.ascii == 50 then return dfastate_33 + if c.ascii == 51 then return dfastate_33 + if c.ascii == 52 then return dfastate_33 + if c.ascii == 53 then return dfastate_33 + if c.ascii == 54 then return dfastate_33 + if c.ascii == 55 then return dfastate_33 + if c.ascii == 56 then return dfastate_33 + if c.ascii == 57 then return dfastate_33 + if c.ascii == 58 then return dfastate_33 + if c.ascii == 59 then return dfastate_33 + if c.ascii == 60 then return dfastate_33 + if c.ascii == 61 then return dfastate_33 + if c.ascii == 62 then return dfastate_33 + if c.ascii == 63 then return dfastate_33 + if c.ascii == 64 then return dfastate_33 + if c.ascii == 65 then return dfastate_33 + if c.ascii == 66 then return dfastate_33 + if c.ascii == 67 then return dfastate_33 + if c.ascii == 68 then return dfastate_33 + if c.ascii == 69 then return dfastate_33 + if c.ascii == 70 then return dfastate_33 + if c.ascii == 71 then return dfastate_33 + if c.ascii == 72 then return dfastate_33 + if c.ascii == 73 then return dfastate_33 + if c.ascii == 74 then return dfastate_33 + if c.ascii == 75 then return dfastate_33 + if c.ascii == 76 then return dfastate_33 + if c.ascii == 77 then return dfastate_33 + if c.ascii == 78 then return dfastate_33 + if c.ascii == 79 then return dfastate_33 + if c.ascii == 80 then return dfastate_33 + if c.ascii == 81 then return dfastate_33 + if c.ascii == 82 then return dfastate_33 + if c.ascii == 83 then return dfastate_33 + if c.ascii == 84 then return dfastate_33 + if c.ascii == 85 then return dfastate_33 + if c.ascii == 86 then return dfastate_33 + if c.ascii == 87 then return dfastate_33 + if c.ascii == 88 then return dfastate_33 + if c.ascii == 89 then return dfastate_33 + if c.ascii == 90 then return dfastate_33 + if c.ascii == 91 then return dfastate_33 + if c.ascii == 92 then return dfastate_42 + if c.ascii == 93 then return dfastate_33 + if c.ascii == 94 then return dfastate_33 + if c.ascii == 95 then return dfastate_33 + if c.ascii == 96 then return dfastate_33 + if c.ascii == 97 then return dfastate_33 + if c.ascii == 98 then return dfastate_33 + if c.ascii == 99 then return dfastate_33 + if c.ascii == 100 then return dfastate_33 + if c.ascii == 101 then return dfastate_33 + if c.ascii == 102 then return dfastate_33 + if c.ascii == 103 then return dfastate_33 + if c.ascii == 104 then return dfastate_33 + if c.ascii == 105 then return dfastate_33 + if c.ascii == 106 then return dfastate_33 + if c.ascii == 107 then return dfastate_33 + if c.ascii == 108 then return dfastate_33 + if c.ascii == 109 then return dfastate_33 + if c.ascii == 110 then return dfastate_33 + if c.ascii == 111 then return dfastate_33 + if c.ascii == 112 then return dfastate_33 + if c.ascii == 113 then return dfastate_33 + if c.ascii == 114 then return dfastate_33 + if c.ascii == 115 then return dfastate_33 + if c.ascii == 116 then return dfastate_33 + if c.ascii == 117 then return dfastate_33 + if c.ascii == 118 then return dfastate_33 + if c.ascii == 119 then return dfastate_33 + if c.ascii == 120 then return dfastate_33 + if c.ascii == 121 then return dfastate_33 + if c.ascii == 122 then return dfastate_33 + if c.ascii == 123 then return dfastate_33 + if c.ascii == 124 then return dfastate_33 + if c.ascii == 125 then return dfastate_33 + if c.ascii == 126 then return dfastate_33 + return null + end +end +class DFAState34 + super DFAState + redef fun trans(c) do + if c.ascii == 32 then return dfastate_36 + if c.ascii == 33 then return dfastate_36 + if c.ascii == 34 then return dfastate_37 + if c.ascii == 35 then return dfastate_36 + if c.ascii == 36 then return dfastate_36 + if c.ascii == 37 then return dfastate_36 + if c.ascii == 38 then return dfastate_36 + if c.ascii == 39 then return dfastate_36 + if c.ascii == 40 then return dfastate_36 + if c.ascii == 41 then return dfastate_36 + if c.ascii == 42 then return dfastate_36 + if c.ascii == 43 then return dfastate_36 + if c.ascii == 44 then return dfastate_36 + if c.ascii == 45 then return dfastate_36 + if c.ascii == 46 then return dfastate_36 + if c.ascii == 47 then return dfastate_36 + if c.ascii == 48 then return dfastate_36 + if c.ascii == 49 then return dfastate_36 + if c.ascii == 50 then return dfastate_36 + if c.ascii == 51 then return dfastate_36 + if c.ascii == 52 then return dfastate_36 + if c.ascii == 53 then return dfastate_36 + if c.ascii == 54 then return dfastate_36 + if c.ascii == 55 then return dfastate_36 + if c.ascii == 56 then return dfastate_36 + if c.ascii == 57 then return dfastate_36 + if c.ascii == 58 then return dfastate_36 + if c.ascii == 59 then return dfastate_36 + if c.ascii == 60 then return dfastate_36 + if c.ascii == 61 then return dfastate_36 + if c.ascii == 62 then return dfastate_36 + if c.ascii == 63 then return dfastate_36 + if c.ascii == 64 then return dfastate_36 + if c.ascii == 65 then return dfastate_36 + if c.ascii == 66 then return dfastate_36 + if c.ascii == 67 then return dfastate_36 + if c.ascii == 68 then return dfastate_36 + if c.ascii == 69 then return dfastate_36 + if c.ascii == 70 then return dfastate_36 + if c.ascii == 71 then return dfastate_36 + if c.ascii == 72 then return dfastate_36 + if c.ascii == 73 then return dfastate_36 + if c.ascii == 74 then return dfastate_36 + if c.ascii == 75 then return dfastate_36 + if c.ascii == 76 then return dfastate_36 + if c.ascii == 77 then return dfastate_36 + if c.ascii == 78 then return dfastate_36 + if c.ascii == 79 then return dfastate_36 + if c.ascii == 80 then return dfastate_36 + if c.ascii == 81 then return dfastate_36 + if c.ascii == 82 then return dfastate_36 + if c.ascii == 83 then return dfastate_36 + if c.ascii == 84 then return dfastate_36 + if c.ascii == 85 then return dfastate_36 + if c.ascii == 86 then return dfastate_36 + if c.ascii == 87 then return dfastate_36 + if c.ascii == 88 then return dfastate_36 + if c.ascii == 89 then return dfastate_36 + if c.ascii == 90 then return dfastate_36 + if c.ascii == 91 then return dfastate_36 + if c.ascii == 92 then return dfastate_38 + if c.ascii == 93 then return dfastate_36 + if c.ascii == 94 then return dfastate_36 + if c.ascii == 95 then return dfastate_36 + if c.ascii == 96 then return dfastate_36 + if c.ascii == 97 then return dfastate_36 + if c.ascii == 98 then return dfastate_36 + if c.ascii == 99 then return dfastate_36 + if c.ascii == 100 then return dfastate_36 + if c.ascii == 101 then return dfastate_36 + if c.ascii == 102 then return dfastate_36 + if c.ascii == 103 then return dfastate_36 + if c.ascii == 104 then return dfastate_36 + if c.ascii == 105 then return dfastate_36 + if c.ascii == 106 then return dfastate_36 + if c.ascii == 107 then return dfastate_36 + if c.ascii == 108 then return dfastate_36 + if c.ascii == 109 then return dfastate_36 + if c.ascii == 110 then return dfastate_36 + if c.ascii == 111 then return dfastate_36 + if c.ascii == 112 then return dfastate_36 + if c.ascii == 113 then return dfastate_36 + if c.ascii == 114 then return dfastate_36 + if c.ascii == 115 then return dfastate_36 + if c.ascii == 116 then return dfastate_36 + if c.ascii == 117 then return dfastate_36 + if c.ascii == 118 then return dfastate_36 + if c.ascii == 119 then return dfastate_36 + if c.ascii == 120 then return dfastate_36 + if c.ascii == 121 then return dfastate_36 + if c.ascii == 122 then return dfastate_36 + if c.ascii == 123 then return dfastate_36 + if c.ascii == 124 then return dfastate_36 + if c.ascii == 125 then return dfastate_36 + if c.ascii == 126 then return dfastate_36 + return null + end +end +class DFAState35 + super DFAState + redef fun is_accept do return true + redef fun make_token(position, text) do + var t = new Nstring + t.position = position + t.text = text + return t + end +end +class DFAState36 + super DFAState + redef fun trans(c) do + if c.ascii == 32 then return dfastate_33 + if c.ascii == 33 then return dfastate_33 + if c.ascii == 35 then return dfastate_33 + if c.ascii == 36 then return dfastate_33 + if c.ascii == 37 then return dfastate_33 + if c.ascii == 38 then return dfastate_33 + if c.ascii == 39 then return dfastate_33 + if c.ascii == 40 then return dfastate_33 + if c.ascii == 41 then return dfastate_33 + if c.ascii == 42 then return dfastate_33 + if c.ascii == 43 then return dfastate_33 + if c.ascii == 44 then return dfastate_33 + if c.ascii == 45 then return dfastate_33 + if c.ascii == 46 then return dfastate_33 + if c.ascii == 47 then return dfastate_33 + if c.ascii == 48 then return dfastate_33 + if c.ascii == 49 then return dfastate_33 + if c.ascii == 50 then return dfastate_33 + if c.ascii == 51 then return dfastate_33 + if c.ascii == 52 then return dfastate_33 + if c.ascii == 53 then return dfastate_33 + if c.ascii == 54 then return dfastate_33 + if c.ascii == 55 then return dfastate_33 + if c.ascii == 56 then return dfastate_33 + if c.ascii == 57 then return dfastate_33 + if c.ascii == 58 then return dfastate_33 + if c.ascii == 59 then return dfastate_33 + if c.ascii == 60 then return dfastate_33 + if c.ascii == 61 then return dfastate_33 + if c.ascii == 62 then return dfastate_33 + if c.ascii == 63 then return dfastate_33 + if c.ascii == 64 then return dfastate_33 + if c.ascii == 65 then return dfastate_33 + if c.ascii == 66 then return dfastate_33 + if c.ascii == 67 then return dfastate_33 + if c.ascii == 68 then return dfastate_33 + if c.ascii == 69 then return dfastate_33 + if c.ascii == 70 then return dfastate_33 + if c.ascii == 71 then return dfastate_33 + if c.ascii == 72 then return dfastate_33 + if c.ascii == 73 then return dfastate_33 + if c.ascii == 74 then return dfastate_33 + if c.ascii == 75 then return dfastate_33 + if c.ascii == 76 then return dfastate_33 + if c.ascii == 77 then return dfastate_33 + if c.ascii == 78 then return dfastate_33 + if c.ascii == 79 then return dfastate_33 + if c.ascii == 80 then return dfastate_33 + if c.ascii == 81 then return dfastate_33 + if c.ascii == 82 then return dfastate_33 + if c.ascii == 83 then return dfastate_33 + if c.ascii == 84 then return dfastate_33 + if c.ascii == 85 then return dfastate_33 + if c.ascii == 86 then return dfastate_33 + if c.ascii == 87 then return dfastate_33 + if c.ascii == 88 then return dfastate_33 + if c.ascii == 89 then return dfastate_33 + if c.ascii == 90 then return dfastate_33 + if c.ascii == 91 then return dfastate_33 + if c.ascii == 92 then return dfastate_39 + if c.ascii == 93 then return dfastate_33 + if c.ascii == 94 then return dfastate_33 + if c.ascii == 95 then return dfastate_33 + if c.ascii == 96 then return dfastate_33 + if c.ascii == 97 then return dfastate_33 + if c.ascii == 98 then return dfastate_33 + if c.ascii == 99 then return dfastate_33 + if c.ascii == 100 then return dfastate_33 + if c.ascii == 101 then return dfastate_33 + if c.ascii == 102 then return dfastate_33 + if c.ascii == 103 then return dfastate_33 + if c.ascii == 104 then return dfastate_33 + if c.ascii == 105 then return dfastate_33 + if c.ascii == 106 then return dfastate_33 + if c.ascii == 107 then return dfastate_33 + if c.ascii == 108 then return dfastate_33 + if c.ascii == 109 then return dfastate_33 + if c.ascii == 110 then return dfastate_33 + if c.ascii == 111 then return dfastate_33 + if c.ascii == 112 then return dfastate_33 + if c.ascii == 113 then return dfastate_33 + if c.ascii == 114 then return dfastate_33 + if c.ascii == 115 then return dfastate_33 + if c.ascii == 116 then return dfastate_33 + if c.ascii == 117 then return dfastate_33 + if c.ascii == 118 then return dfastate_33 + if c.ascii == 119 then return dfastate_33 + if c.ascii == 120 then return dfastate_33 + if c.ascii == 121 then return dfastate_33 + if c.ascii == 122 then return dfastate_33 + if c.ascii == 123 then return dfastate_33 + if c.ascii == 124 then return dfastate_33 + if c.ascii == 125 then return dfastate_33 + if c.ascii == 126 then return dfastate_33 + if c.ascii == 34 then return dfastate_35 + return null + end +end +class DFAState37 + super DFAState + redef fun trans(c) do + if c.ascii == 34 then return dfastate_35 + if c.ascii == 32 then return dfastate_33 + if c.ascii == 33 then return dfastate_33 + if c.ascii == 35 then return dfastate_33 + if c.ascii == 36 then return dfastate_33 + if c.ascii == 37 then return dfastate_33 + if c.ascii == 38 then return dfastate_33 + if c.ascii == 39 then return dfastate_33 + if c.ascii == 40 then return dfastate_33 + if c.ascii == 41 then return dfastate_33 + if c.ascii == 42 then return dfastate_33 + if c.ascii == 43 then return dfastate_33 + if c.ascii == 44 then return dfastate_33 + if c.ascii == 45 then return dfastate_33 + if c.ascii == 46 then return dfastate_33 + if c.ascii == 47 then return dfastate_33 + if c.ascii == 48 then return dfastate_33 + if c.ascii == 49 then return dfastate_33 + if c.ascii == 50 then return dfastate_33 + if c.ascii == 51 then return dfastate_33 + if c.ascii == 52 then return dfastate_33 + if c.ascii == 53 then return dfastate_33 + if c.ascii == 54 then return dfastate_33 + if c.ascii == 55 then return dfastate_33 + if c.ascii == 56 then return dfastate_33 + if c.ascii == 57 then return dfastate_33 + if c.ascii == 58 then return dfastate_33 + if c.ascii == 59 then return dfastate_33 + if c.ascii == 60 then return dfastate_33 + if c.ascii == 61 then return dfastate_33 + if c.ascii == 62 then return dfastate_33 + if c.ascii == 63 then return dfastate_33 + if c.ascii == 64 then return dfastate_33 + if c.ascii == 65 then return dfastate_33 + if c.ascii == 66 then return dfastate_33 + if c.ascii == 67 then return dfastate_33 + if c.ascii == 68 then return dfastate_33 + if c.ascii == 69 then return dfastate_33 + if c.ascii == 70 then return dfastate_33 + if c.ascii == 71 then return dfastate_33 + if c.ascii == 72 then return dfastate_33 + if c.ascii == 73 then return dfastate_33 + if c.ascii == 74 then return dfastate_33 + if c.ascii == 75 then return dfastate_33 + if c.ascii == 76 then return dfastate_33 + if c.ascii == 77 then return dfastate_33 + if c.ascii == 78 then return dfastate_33 + if c.ascii == 79 then return dfastate_33 + if c.ascii == 80 then return dfastate_33 + if c.ascii == 81 then return dfastate_33 + if c.ascii == 82 then return dfastate_33 + if c.ascii == 83 then return dfastate_33 + if c.ascii == 84 then return dfastate_33 + if c.ascii == 85 then return dfastate_33 + if c.ascii == 86 then return dfastate_33 + if c.ascii == 87 then return dfastate_33 + if c.ascii == 88 then return dfastate_33 + if c.ascii == 89 then return dfastate_33 + if c.ascii == 90 then return dfastate_33 + if c.ascii == 91 then return dfastate_33 + if c.ascii == 92 then return dfastate_34 + if c.ascii == 93 then return dfastate_33 + if c.ascii == 94 then return dfastate_33 + if c.ascii == 95 then return dfastate_33 + if c.ascii == 96 then return dfastate_33 + if c.ascii == 97 then return dfastate_33 + if c.ascii == 98 then return dfastate_33 + if c.ascii == 99 then return dfastate_33 + if c.ascii == 100 then return dfastate_33 + if c.ascii == 101 then return dfastate_33 + if c.ascii == 102 then return dfastate_33 + if c.ascii == 103 then return dfastate_33 + if c.ascii == 104 then return dfastate_33 + if c.ascii == 105 then return dfastate_33 + if c.ascii == 106 then return dfastate_33 + if c.ascii == 107 then return dfastate_33 + if c.ascii == 108 then return dfastate_33 + if c.ascii == 109 then return dfastate_33 + if c.ascii == 110 then return dfastate_33 + if c.ascii == 111 then return dfastate_33 + if c.ascii == 112 then return dfastate_33 + if c.ascii == 113 then return dfastate_33 + if c.ascii == 114 then return dfastate_33 + if c.ascii == 115 then return dfastate_33 + if c.ascii == 116 then return dfastate_33 + if c.ascii == 117 then return dfastate_33 + if c.ascii == 118 then return dfastate_33 + if c.ascii == 119 then return dfastate_33 + if c.ascii == 120 then return dfastate_33 + if c.ascii == 121 then return dfastate_33 + if c.ascii == 122 then return dfastate_33 + if c.ascii == 123 then return dfastate_33 + if c.ascii == 124 then return dfastate_33 + if c.ascii == 125 then return dfastate_33 + if c.ascii == 126 then return dfastate_33 + return null + end +end +class DFAState38 + super DFAState + redef fun trans(c) do + if c.ascii == 34 then return dfastate_35 + if c.ascii == 32 then return dfastate_33 + if c.ascii == 33 then return dfastate_33 + if c.ascii == 35 then return dfastate_33 + if c.ascii == 36 then return dfastate_33 + if c.ascii == 37 then return dfastate_33 + if c.ascii == 38 then return dfastate_33 + if c.ascii == 39 then return dfastate_33 + if c.ascii == 40 then return dfastate_33 + if c.ascii == 41 then return dfastate_33 + if c.ascii == 42 then return dfastate_33 + if c.ascii == 43 then return dfastate_33 + if c.ascii == 44 then return dfastate_33 + if c.ascii == 45 then return dfastate_33 + if c.ascii == 46 then return dfastate_33 + if c.ascii == 47 then return dfastate_33 + if c.ascii == 48 then return dfastate_33 + if c.ascii == 49 then return dfastate_33 + if c.ascii == 50 then return dfastate_33 + if c.ascii == 51 then return dfastate_33 + if c.ascii == 52 then return dfastate_33 + if c.ascii == 53 then return dfastate_33 + if c.ascii == 54 then return dfastate_33 + if c.ascii == 55 then return dfastate_33 + if c.ascii == 56 then return dfastate_33 + if c.ascii == 57 then return dfastate_33 + if c.ascii == 58 then return dfastate_33 + if c.ascii == 59 then return dfastate_33 + if c.ascii == 60 then return dfastate_33 + if c.ascii == 61 then return dfastate_33 + if c.ascii == 62 then return dfastate_33 + if c.ascii == 63 then return dfastate_33 + if c.ascii == 64 then return dfastate_33 + if c.ascii == 65 then return dfastate_33 + if c.ascii == 66 then return dfastate_33 + if c.ascii == 67 then return dfastate_33 + if c.ascii == 68 then return dfastate_33 + if c.ascii == 69 then return dfastate_33 + if c.ascii == 70 then return dfastate_33 + if c.ascii == 71 then return dfastate_33 + if c.ascii == 72 then return dfastate_33 + if c.ascii == 73 then return dfastate_33 + if c.ascii == 74 then return dfastate_33 + if c.ascii == 75 then return dfastate_33 + if c.ascii == 76 then return dfastate_33 + if c.ascii == 77 then return dfastate_33 + if c.ascii == 78 then return dfastate_33 + if c.ascii == 79 then return dfastate_33 + if c.ascii == 80 then return dfastate_33 + if c.ascii == 81 then return dfastate_33 + if c.ascii == 82 then return dfastate_33 + if c.ascii == 83 then return dfastate_33 + if c.ascii == 84 then return dfastate_33 + if c.ascii == 85 then return dfastate_33 + if c.ascii == 86 then return dfastate_33 + if c.ascii == 87 then return dfastate_33 + if c.ascii == 88 then return dfastate_33 + if c.ascii == 89 then return dfastate_33 + if c.ascii == 90 then return dfastate_33 + if c.ascii == 91 then return dfastate_33 + if c.ascii == 92 then return dfastate_39 + if c.ascii == 93 then return dfastate_33 + if c.ascii == 94 then return dfastate_33 + if c.ascii == 95 then return dfastate_33 + if c.ascii == 96 then return dfastate_33 + if c.ascii == 97 then return dfastate_33 + if c.ascii == 98 then return dfastate_33 + if c.ascii == 99 then return dfastate_33 + if c.ascii == 100 then return dfastate_33 + if c.ascii == 101 then return dfastate_33 + if c.ascii == 102 then return dfastate_33 + if c.ascii == 103 then return dfastate_33 + if c.ascii == 104 then return dfastate_33 + if c.ascii == 105 then return dfastate_33 + if c.ascii == 106 then return dfastate_33 + if c.ascii == 107 then return dfastate_33 + if c.ascii == 108 then return dfastate_33 + if c.ascii == 109 then return dfastate_33 + if c.ascii == 110 then return dfastate_33 + if c.ascii == 111 then return dfastate_33 + if c.ascii == 112 then return dfastate_33 + if c.ascii == 113 then return dfastate_33 + if c.ascii == 114 then return dfastate_33 + if c.ascii == 115 then return dfastate_33 + if c.ascii == 116 then return dfastate_33 + if c.ascii == 117 then return dfastate_33 + if c.ascii == 118 then return dfastate_33 + if c.ascii == 119 then return dfastate_33 + if c.ascii == 120 then return dfastate_33 + if c.ascii == 121 then return dfastate_33 + if c.ascii == 122 then return dfastate_33 + if c.ascii == 123 then return dfastate_33 + if c.ascii == 124 then return dfastate_33 + if c.ascii == 125 then return dfastate_33 + if c.ascii == 126 then return dfastate_33 + return null + end +end +class DFAState39 + super DFAState + redef fun trans(c) do + if c.ascii == 34 then return dfastate_40 + if c.ascii == 32 then return dfastate_36 + if c.ascii == 33 then return dfastate_36 + if c.ascii == 35 then return dfastate_36 + if c.ascii == 36 then return dfastate_36 + if c.ascii == 37 then return dfastate_36 + if c.ascii == 38 then return dfastate_36 + if c.ascii == 39 then return dfastate_36 + if c.ascii == 40 then return dfastate_36 + if c.ascii == 41 then return dfastate_36 + if c.ascii == 42 then return dfastate_36 + if c.ascii == 43 then return dfastate_36 + if c.ascii == 44 then return dfastate_36 + if c.ascii == 45 then return dfastate_36 + if c.ascii == 46 then return dfastate_36 + if c.ascii == 47 then return dfastate_36 + if c.ascii == 48 then return dfastate_36 + if c.ascii == 49 then return dfastate_36 + if c.ascii == 50 then return dfastate_36 + if c.ascii == 51 then return dfastate_36 + if c.ascii == 52 then return dfastate_36 + if c.ascii == 53 then return dfastate_36 + if c.ascii == 54 then return dfastate_36 + if c.ascii == 55 then return dfastate_36 + if c.ascii == 56 then return dfastate_36 + if c.ascii == 57 then return dfastate_36 + if c.ascii == 58 then return dfastate_36 + if c.ascii == 59 then return dfastate_36 + if c.ascii == 60 then return dfastate_36 + if c.ascii == 61 then return dfastate_36 + if c.ascii == 62 then return dfastate_36 + if c.ascii == 63 then return dfastate_36 + if c.ascii == 64 then return dfastate_36 + if c.ascii == 65 then return dfastate_36 + if c.ascii == 66 then return dfastate_36 + if c.ascii == 67 then return dfastate_36 + if c.ascii == 68 then return dfastate_36 + if c.ascii == 69 then return dfastate_36 + if c.ascii == 70 then return dfastate_36 + if c.ascii == 71 then return dfastate_36 + if c.ascii == 72 then return dfastate_36 + if c.ascii == 73 then return dfastate_36 + if c.ascii == 74 then return dfastate_36 + if c.ascii == 75 then return dfastate_36 + if c.ascii == 76 then return dfastate_36 + if c.ascii == 77 then return dfastate_36 + if c.ascii == 78 then return dfastate_36 + if c.ascii == 79 then return dfastate_36 + if c.ascii == 80 then return dfastate_36 + if c.ascii == 81 then return dfastate_36 + if c.ascii == 82 then return dfastate_36 + if c.ascii == 83 then return dfastate_36 + if c.ascii == 84 then return dfastate_36 + if c.ascii == 85 then return dfastate_36 + if c.ascii == 86 then return dfastate_36 + if c.ascii == 87 then return dfastate_36 + if c.ascii == 88 then return dfastate_36 + if c.ascii == 89 then return dfastate_36 + if c.ascii == 90 then return dfastate_36 + if c.ascii == 91 then return dfastate_36 + if c.ascii == 92 then return dfastate_41 + if c.ascii == 93 then return dfastate_36 + if c.ascii == 94 then return dfastate_36 + if c.ascii == 95 then return dfastate_36 + if c.ascii == 96 then return dfastate_36 + if c.ascii == 97 then return dfastate_36 + if c.ascii == 98 then return dfastate_36 + if c.ascii == 99 then return dfastate_36 + if c.ascii == 100 then return dfastate_36 + if c.ascii == 101 then return dfastate_36 + if c.ascii == 102 then return dfastate_36 + if c.ascii == 103 then return dfastate_36 + if c.ascii == 104 then return dfastate_36 + if c.ascii == 105 then return dfastate_36 + if c.ascii == 106 then return dfastate_36 + if c.ascii == 107 then return dfastate_36 + if c.ascii == 108 then return dfastate_36 + if c.ascii == 109 then return dfastate_36 + if c.ascii == 110 then return dfastate_36 + if c.ascii == 111 then return dfastate_36 + if c.ascii == 112 then return dfastate_36 + if c.ascii == 113 then return dfastate_36 + if c.ascii == 114 then return dfastate_36 + if c.ascii == 115 then return dfastate_36 + if c.ascii == 116 then return dfastate_36 + if c.ascii == 117 then return dfastate_36 + if c.ascii == 118 then return dfastate_36 + if c.ascii == 119 then return dfastate_36 + if c.ascii == 120 then return dfastate_36 + if c.ascii == 121 then return dfastate_36 + if c.ascii == 122 then return dfastate_36 + if c.ascii == 123 then return dfastate_36 + if c.ascii == 124 then return dfastate_36 + if c.ascii == 125 then return dfastate_36 + if c.ascii == 126 then return dfastate_36 + return null + end +end +class DFAState40 + super DFAState + redef fun is_accept do return true + redef fun make_token(position, text) do + var t = new Nstring + t.position = position + t.text = text + return t + end + redef fun trans(c) do + if c.ascii == 34 then return dfastate_35 + if c.ascii == 32 then return dfastate_33 + if c.ascii == 33 then return dfastate_33 + if c.ascii == 35 then return dfastate_33 + if c.ascii == 36 then return dfastate_33 + if c.ascii == 37 then return dfastate_33 + if c.ascii == 38 then return dfastate_33 + if c.ascii == 39 then return dfastate_33 + if c.ascii == 40 then return dfastate_33 + if c.ascii == 41 then return dfastate_33 + if c.ascii == 42 then return dfastate_33 + if c.ascii == 43 then return dfastate_33 + if c.ascii == 44 then return dfastate_33 + if c.ascii == 45 then return dfastate_33 + if c.ascii == 46 then return dfastate_33 + if c.ascii == 47 then return dfastate_33 + if c.ascii == 48 then return dfastate_33 + if c.ascii == 49 then return dfastate_33 + if c.ascii == 50 then return dfastate_33 + if c.ascii == 51 then return dfastate_33 + if c.ascii == 52 then return dfastate_33 + if c.ascii == 53 then return dfastate_33 + if c.ascii == 54 then return dfastate_33 + if c.ascii == 55 then return dfastate_33 + if c.ascii == 56 then return dfastate_33 + if c.ascii == 57 then return dfastate_33 + if c.ascii == 58 then return dfastate_33 + if c.ascii == 59 then return dfastate_33 + if c.ascii == 60 then return dfastate_33 + if c.ascii == 61 then return dfastate_33 + if c.ascii == 62 then return dfastate_33 + if c.ascii == 63 then return dfastate_33 + if c.ascii == 64 then return dfastate_33 + if c.ascii == 65 then return dfastate_33 + if c.ascii == 66 then return dfastate_33 + if c.ascii == 67 then return dfastate_33 + if c.ascii == 68 then return dfastate_33 + if c.ascii == 69 then return dfastate_33 + if c.ascii == 70 then return dfastate_33 + if c.ascii == 71 then return dfastate_33 + if c.ascii == 72 then return dfastate_33 + if c.ascii == 73 then return dfastate_33 + if c.ascii == 74 then return dfastate_33 + if c.ascii == 75 then return dfastate_33 + if c.ascii == 76 then return dfastate_33 + if c.ascii == 77 then return dfastate_33 + if c.ascii == 78 then return dfastate_33 + if c.ascii == 79 then return dfastate_33 + if c.ascii == 80 then return dfastate_33 + if c.ascii == 81 then return dfastate_33 + if c.ascii == 82 then return dfastate_33 + if c.ascii == 83 then return dfastate_33 + if c.ascii == 84 then return dfastate_33 + if c.ascii == 85 then return dfastate_33 + if c.ascii == 86 then return dfastate_33 + if c.ascii == 87 then return dfastate_33 + if c.ascii == 88 then return dfastate_33 + if c.ascii == 89 then return dfastate_33 + if c.ascii == 90 then return dfastate_33 + if c.ascii == 91 then return dfastate_33 + if c.ascii == 92 then return dfastate_34 + if c.ascii == 93 then return dfastate_33 + if c.ascii == 94 then return dfastate_33 + if c.ascii == 95 then return dfastate_33 + if c.ascii == 96 then return dfastate_33 + if c.ascii == 97 then return dfastate_33 + if c.ascii == 98 then return dfastate_33 + if c.ascii == 99 then return dfastate_33 + if c.ascii == 100 then return dfastate_33 + if c.ascii == 101 then return dfastate_33 + if c.ascii == 102 then return dfastate_33 + if c.ascii == 103 then return dfastate_33 + if c.ascii == 104 then return dfastate_33 + if c.ascii == 105 then return dfastate_33 + if c.ascii == 106 then return dfastate_33 + if c.ascii == 107 then return dfastate_33 + if c.ascii == 108 then return dfastate_33 + if c.ascii == 109 then return dfastate_33 + if c.ascii == 110 then return dfastate_33 + if c.ascii == 111 then return dfastate_33 + if c.ascii == 112 then return dfastate_33 + if c.ascii == 113 then return dfastate_33 + if c.ascii == 114 then return dfastate_33 + if c.ascii == 115 then return dfastate_33 + if c.ascii == 116 then return dfastate_33 + if c.ascii == 117 then return dfastate_33 + if c.ascii == 118 then return dfastate_33 + if c.ascii == 119 then return dfastate_33 + if c.ascii == 120 then return dfastate_33 + if c.ascii == 121 then return dfastate_33 + if c.ascii == 122 then return dfastate_33 + if c.ascii == 123 then return dfastate_33 + if c.ascii == 124 then return dfastate_33 + if c.ascii == 125 then return dfastate_33 + if c.ascii == 126 then return dfastate_33 + return null + end +end +class DFAState41 + super DFAState + redef fun trans(c) do + if c.ascii == 34 then return dfastate_40 + if c.ascii == 32 then return dfastate_36 + if c.ascii == 33 then return dfastate_36 + if c.ascii == 35 then return dfastate_36 + if c.ascii == 36 then return dfastate_36 + if c.ascii == 37 then return dfastate_36 + if c.ascii == 38 then return dfastate_36 + if c.ascii == 39 then return dfastate_36 + if c.ascii == 40 then return dfastate_36 + if c.ascii == 41 then return dfastate_36 + if c.ascii == 42 then return dfastate_36 + if c.ascii == 43 then return dfastate_36 + if c.ascii == 44 then return dfastate_36 + if c.ascii == 45 then return dfastate_36 + if c.ascii == 46 then return dfastate_36 + if c.ascii == 47 then return dfastate_36 + if c.ascii == 48 then return dfastate_36 + if c.ascii == 49 then return dfastate_36 + if c.ascii == 50 then return dfastate_36 + if c.ascii == 51 then return dfastate_36 + if c.ascii == 52 then return dfastate_36 + if c.ascii == 53 then return dfastate_36 + if c.ascii == 54 then return dfastate_36 + if c.ascii == 55 then return dfastate_36 + if c.ascii == 56 then return dfastate_36 + if c.ascii == 57 then return dfastate_36 + if c.ascii == 58 then return dfastate_36 + if c.ascii == 59 then return dfastate_36 + if c.ascii == 60 then return dfastate_36 + if c.ascii == 61 then return dfastate_36 + if c.ascii == 62 then return dfastate_36 + if c.ascii == 63 then return dfastate_36 + if c.ascii == 64 then return dfastate_36 + if c.ascii == 65 then return dfastate_36 + if c.ascii == 66 then return dfastate_36 + if c.ascii == 67 then return dfastate_36 + if c.ascii == 68 then return dfastate_36 + if c.ascii == 69 then return dfastate_36 + if c.ascii == 70 then return dfastate_36 + if c.ascii == 71 then return dfastate_36 + if c.ascii == 72 then return dfastate_36 + if c.ascii == 73 then return dfastate_36 + if c.ascii == 74 then return dfastate_36 + if c.ascii == 75 then return dfastate_36 + if c.ascii == 76 then return dfastate_36 + if c.ascii == 77 then return dfastate_36 + if c.ascii == 78 then return dfastate_36 + if c.ascii == 79 then return dfastate_36 + if c.ascii == 80 then return dfastate_36 + if c.ascii == 81 then return dfastate_36 + if c.ascii == 82 then return dfastate_36 + if c.ascii == 83 then return dfastate_36 + if c.ascii == 84 then return dfastate_36 + if c.ascii == 85 then return dfastate_36 + if c.ascii == 86 then return dfastate_36 + if c.ascii == 87 then return dfastate_36 + if c.ascii == 88 then return dfastate_36 + if c.ascii == 89 then return dfastate_36 + if c.ascii == 90 then return dfastate_36 + if c.ascii == 91 then return dfastate_36 + if c.ascii == 92 then return dfastate_41 + if c.ascii == 93 then return dfastate_36 + if c.ascii == 94 then return dfastate_36 + if c.ascii == 95 then return dfastate_36 + if c.ascii == 96 then return dfastate_36 + if c.ascii == 97 then return dfastate_36 + if c.ascii == 98 then return dfastate_36 + if c.ascii == 99 then return dfastate_36 + if c.ascii == 100 then return dfastate_36 + if c.ascii == 101 then return dfastate_36 + if c.ascii == 102 then return dfastate_36 + if c.ascii == 103 then return dfastate_36 + if c.ascii == 104 then return dfastate_36 + if c.ascii == 105 then return dfastate_36 + if c.ascii == 106 then return dfastate_36 + if c.ascii == 107 then return dfastate_36 + if c.ascii == 108 then return dfastate_36 + if c.ascii == 109 then return dfastate_36 + if c.ascii == 110 then return dfastate_36 + if c.ascii == 111 then return dfastate_36 + if c.ascii == 112 then return dfastate_36 + if c.ascii == 113 then return dfastate_36 + if c.ascii == 114 then return dfastate_36 + if c.ascii == 115 then return dfastate_36 + if c.ascii == 116 then return dfastate_36 + if c.ascii == 117 then return dfastate_36 + if c.ascii == 118 then return dfastate_36 + if c.ascii == 119 then return dfastate_36 + if c.ascii == 120 then return dfastate_36 + if c.ascii == 121 then return dfastate_36 + if c.ascii == 122 then return dfastate_36 + if c.ascii == 123 then return dfastate_36 + if c.ascii == 124 then return dfastate_36 + if c.ascii == 125 then return dfastate_36 + if c.ascii == 126 then return dfastate_36 + return null + end +end +class DFAState42 + super DFAState + redef fun trans(c) do + if c.ascii == 34 then return dfastate_35 + if c.ascii == 32 then return dfastate_33 + if c.ascii == 33 then return dfastate_33 + if c.ascii == 35 then return dfastate_33 + if c.ascii == 36 then return dfastate_33 + if c.ascii == 37 then return dfastate_33 + if c.ascii == 38 then return dfastate_33 + if c.ascii == 39 then return dfastate_33 + if c.ascii == 40 then return dfastate_33 + if c.ascii == 41 then return dfastate_33 + if c.ascii == 42 then return dfastate_33 + if c.ascii == 43 then return dfastate_33 + if c.ascii == 44 then return dfastate_33 + if c.ascii == 45 then return dfastate_33 + if c.ascii == 46 then return dfastate_33 + if c.ascii == 47 then return dfastate_33 + if c.ascii == 48 then return dfastate_33 + if c.ascii == 49 then return dfastate_33 + if c.ascii == 50 then return dfastate_33 + if c.ascii == 51 then return dfastate_33 + if c.ascii == 52 then return dfastate_33 + if c.ascii == 53 then return dfastate_33 + if c.ascii == 54 then return dfastate_33 + if c.ascii == 55 then return dfastate_33 + if c.ascii == 56 then return dfastate_33 + if c.ascii == 57 then return dfastate_33 + if c.ascii == 58 then return dfastate_33 + if c.ascii == 59 then return dfastate_33 + if c.ascii == 60 then return dfastate_33 + if c.ascii == 61 then return dfastate_33 + if c.ascii == 62 then return dfastate_33 + if c.ascii == 63 then return dfastate_33 + if c.ascii == 64 then return dfastate_33 + if c.ascii == 65 then return dfastate_33 + if c.ascii == 66 then return dfastate_33 + if c.ascii == 67 then return dfastate_33 + if c.ascii == 68 then return dfastate_33 + if c.ascii == 69 then return dfastate_33 + if c.ascii == 70 then return dfastate_33 + if c.ascii == 71 then return dfastate_33 + if c.ascii == 72 then return dfastate_33 + if c.ascii == 73 then return dfastate_33 + if c.ascii == 74 then return dfastate_33 + if c.ascii == 75 then return dfastate_33 + if c.ascii == 76 then return dfastate_33 + if c.ascii == 77 then return dfastate_33 + if c.ascii == 78 then return dfastate_33 + if c.ascii == 79 then return dfastate_33 + if c.ascii == 80 then return dfastate_33 + if c.ascii == 81 then return dfastate_33 + if c.ascii == 82 then return dfastate_33 + if c.ascii == 83 then return dfastate_33 + if c.ascii == 84 then return dfastate_33 + if c.ascii == 85 then return dfastate_33 + if c.ascii == 86 then return dfastate_33 + if c.ascii == 87 then return dfastate_33 + if c.ascii == 88 then return dfastate_33 + if c.ascii == 89 then return dfastate_33 + if c.ascii == 90 then return dfastate_33 + if c.ascii == 91 then return dfastate_33 + if c.ascii == 92 then return dfastate_39 + if c.ascii == 93 then return dfastate_33 + if c.ascii == 94 then return dfastate_33 + if c.ascii == 95 then return dfastate_33 + if c.ascii == 96 then return dfastate_33 + if c.ascii == 97 then return dfastate_33 + if c.ascii == 98 then return dfastate_33 + if c.ascii == 99 then return dfastate_33 + if c.ascii == 100 then return dfastate_33 + if c.ascii == 101 then return dfastate_33 + if c.ascii == 102 then return dfastate_33 + if c.ascii == 103 then return dfastate_33 + if c.ascii == 104 then return dfastate_33 + if c.ascii == 105 then return dfastate_33 + if c.ascii == 106 then return dfastate_33 + if c.ascii == 107 then return dfastate_33 + if c.ascii == 108 then return dfastate_33 + if c.ascii == 109 then return dfastate_33 + if c.ascii == 110 then return dfastate_33 + if c.ascii == 111 then return dfastate_33 + if c.ascii == 112 then return dfastate_33 + if c.ascii == 113 then return dfastate_33 + if c.ascii == 114 then return dfastate_33 + if c.ascii == 115 then return dfastate_33 + if c.ascii == 116 then return dfastate_33 + if c.ascii == 117 then return dfastate_33 + if c.ascii == 118 then return dfastate_33 + if c.ascii == 119 then return dfastate_33 + if c.ascii == 120 then return dfastate_33 + if c.ascii == 121 then return dfastate_33 + if c.ascii == 122 then return dfastate_33 + if c.ascii == 123 then return dfastate_33 + if c.ascii == 124 then return dfastate_33 + if c.ascii == 125 then return dfastate_33 + if c.ascii == 126 then return dfastate_33 + return null + end +end +class DFAState43 + super DFAState + redef fun trans(c) do + if c.ascii == 113 then return dfastate_95 + if c.ascii == 81 then return dfastate_96 + if c.ascii == 110 then return dfastate_97 + if c.ascii == 78 then return dfastate_98 + return null + end +end +class DFAState44 + super DFAState + redef fun trans(c) do + if c.ascii == 113 then return dfastate_95 + if c.ascii == 81 then return dfastate_96 + if c.ascii == 110 then return dfastate_97 + if c.ascii == 78 then return dfastate_98 + return null + end +end +class DFAState45 + super DFAState + redef fun trans(c) do + if c.ascii == 117 then return dfastate_75 + if c.ascii == 85 then return dfastate_76 + if c.ascii == 108 then return dfastate_77 + if c.ascii == 76 then return dfastate_78 + if c.ascii == 121 then return dfastate_79 + if c.ascii == 89 then return dfastate_80 + return null + end +end +class DFAState46 + super DFAState + redef fun trans(c) do + if c.ascii == 117 then return dfastate_75 + if c.ascii == 85 then return dfastate_76 + if c.ascii == 108 then return dfastate_77 + if c.ascii == 76 then return dfastate_78 + if c.ascii == 121 then return dfastate_79 + if c.ascii == 89 then return dfastate_80 + return null + end +end +class DFAState47 + super DFAState + redef fun trans(c) do + if c.ascii == 111 then return dfastate_69 + if c.ascii == 79 then return dfastate_70 + return null + end +end +class DFAState48 + super DFAState + redef fun trans(c) do + if c.ascii == 111 then return dfastate_69 + if c.ascii == 79 then return dfastate_70 + return null + end +end +class DFAState49 + super DFAState + redef fun trans(c) do + if c.ascii == 100 then return dfastate_51 + if c.ascii == 68 then return dfastate_52 + if c.ascii == 115 then return dfastate_53 + if c.ascii == 83 then return dfastate_54 + return null + end +end +class DFAState50 + super DFAState + redef fun trans(c) do + if c.ascii == 100 then return dfastate_51 + if c.ascii == 68 then return dfastate_52 + if c.ascii == 115 then return dfastate_53 + if c.ascii == 83 then return dfastate_54 + return null + end +end +class DFAState51 + super DFAState + redef fun trans(c) do + if c.ascii == 100 then return dfastate_61 + if c.ascii == 68 then return dfastate_62 + return null + end +end +class DFAState52 + super DFAState + redef fun trans(c) do + if c.ascii == 100 then return dfastate_61 + if c.ascii == 68 then return dfastate_62 + return null + end +end +class DFAState53 + super DFAState + redef fun trans(c) do + if c.ascii == 99 then return dfastate_55 + if c.ascii == 67 then return dfastate_56 + return null + end +end +class DFAState54 + super DFAState + redef fun trans(c) do + if c.ascii == 99 then return dfastate_55 + if c.ascii == 67 then return dfastate_56 + return null + end +end +class DFAState55 + super DFAState + redef fun trans(c) do + if c.ascii == 105 then return dfastate_57 + if c.ascii == 73 then return dfastate_58 + return null + end +end +class DFAState56 + super DFAState + redef fun trans(c) do + if c.ascii == 105 then return dfastate_57 + if c.ascii == 73 then return dfastate_58 + return null + end +end +class DFAState57 + super DFAState + redef fun trans(c) do + if c.ascii == 105 then return dfastate_59 + if c.ascii == 73 then return dfastate_60 + return null + end +end +class DFAState58 + super DFAState + redef fun trans(c) do + if c.ascii == 105 then return dfastate_59 + if c.ascii == 73 then return dfastate_60 + return null + end +end +class DFAState59 + super DFAState + redef fun is_accept do return true + redef fun make_token(position, text) do + var t = new Ntk_ascii + t.position = position + t.text = text + return t + end +end +class DFAState60 + super DFAState + redef fun is_accept do return true + redef fun make_token(position, text) do + var t = new Ntk_ascii + t.position = position + t.text = text + return t + end +end +class DFAState61 + super DFAState + redef fun trans(c) do + if c.ascii == 114 then return dfastate_63 + if c.ascii == 82 then return dfastate_64 + return null + end +end +class DFAState62 + super DFAState + redef fun trans(c) do + if c.ascii == 114 then return dfastate_63 + if c.ascii == 82 then return dfastate_64 + return null + end +end +class DFAState63 + super DFAState + redef fun trans(c) do + if c.ascii == 115 then return dfastate_65 + if c.ascii == 83 then return dfastate_66 + return null + end +end +class DFAState64 + super DFAState + redef fun trans(c) do + if c.ascii == 115 then return dfastate_65 + if c.ascii == 83 then return dfastate_66 + return null + end +end +class DFAState65 + super DFAState + redef fun trans(c) do + if c.ascii == 115 then return dfastate_67 + if c.ascii == 83 then return dfastate_68 + return null + end +end +class DFAState66 + super DFAState + redef fun trans(c) do + if c.ascii == 115 then return dfastate_67 + if c.ascii == 83 then return dfastate_68 + return null + end +end +class DFAState67 + super DFAState + redef fun is_accept do return true + redef fun make_token(position, text) do + var t = new Ntk_addrss + t.position = position + t.text = text + return t + end +end +class DFAState68 + super DFAState + redef fun is_accept do return true + redef fun make_token(position, text) do + var t = new Ntk_addrss + t.position = position + t.text = text + return t + end +end +class DFAState69 + super DFAState + redef fun trans(c) do + if c.ascii == 114 then return dfastate_71 + if c.ascii == 82 then return dfastate_72 + return null + end +end +class DFAState70 + super DFAState + redef fun trans(c) do + if c.ascii == 114 then return dfastate_71 + if c.ascii == 82 then return dfastate_72 + return null + end +end +class DFAState71 + super DFAState + redef fun trans(c) do + if c.ascii == 100 then return dfastate_73 + if c.ascii == 68 then return dfastate_74 + return null + end +end +class DFAState72 + super DFAState + redef fun trans(c) do + if c.ascii == 100 then return dfastate_73 + if c.ascii == 68 then return dfastate_74 + return null + end +end +class DFAState73 + super DFAState + redef fun is_accept do return true + redef fun make_token(position, text) do + var t = new Ntk_word + t.position = position + t.text = text + return t + end +end +class DFAState74 + super DFAState + redef fun is_accept do return true + redef fun make_token(position, text) do + var t = new Ntk_word + t.position = position + t.text = text + return t + end +end +class DFAState75 + super DFAState + redef fun trans(c) do + if c.ascii == 114 then return dfastate_91 + if c.ascii == 82 then return dfastate_92 + return null + end +end +class DFAState76 + super DFAState + redef fun trans(c) do + if c.ascii == 114 then return dfastate_91 + if c.ascii == 82 then return dfastate_92 + return null + end +end +class DFAState77 + super DFAState + redef fun trans(c) do + if c.ascii == 111 then return dfastate_85 + if c.ascii == 79 then return dfastate_86 + return null + end +end +class DFAState78 + super DFAState + redef fun trans(c) do + if c.ascii == 111 then return dfastate_85 + if c.ascii == 79 then return dfastate_86 + return null + end +end +class DFAState79 + super DFAState + redef fun trans(c) do + if c.ascii == 116 then return dfastate_81 + if c.ascii == 84 then return dfastate_82 + return null + end +end +class DFAState80 + super DFAState + redef fun trans(c) do + if c.ascii == 116 then return dfastate_81 + if c.ascii == 84 then return dfastate_82 + return null + end +end +class DFAState81 + super DFAState + redef fun trans(c) do + if c.ascii == 101 then return dfastate_83 + if c.ascii == 69 then return dfastate_84 + return null + end +end +class DFAState82 + super DFAState + redef fun trans(c) do + if c.ascii == 101 then return dfastate_83 + if c.ascii == 69 then return dfastate_84 + return null + end +end +class DFAState83 + super DFAState + redef fun is_accept do return true + redef fun make_token(position, text) do + var t = new Ntk_byte + t.position = position + t.text = text + return t + end +end +class DFAState84 + super DFAState + redef fun is_accept do return true + redef fun make_token(position, text) do + var t = new Ntk_byte + t.position = position + t.text = text + return t + end +end +class DFAState85 + super DFAState + redef fun trans(c) do + if c.ascii == 99 then return dfastate_87 + if c.ascii == 67 then return dfastate_88 + return null + end +end +class DFAState86 + super DFAState + redef fun trans(c) do + if c.ascii == 99 then return dfastate_87 + if c.ascii == 67 then return dfastate_88 + return null + end +end +class DFAState87 + super DFAState + redef fun trans(c) do + if c.ascii == 107 then return dfastate_89 + if c.ascii == 75 then return dfastate_90 + return null + end +end +class DFAState88 + super DFAState + redef fun trans(c) do + if c.ascii == 107 then return dfastate_89 + if c.ascii == 75 then return dfastate_90 + return null + end +end +class DFAState89 + super DFAState + redef fun is_accept do return true + redef fun make_token(position, text) do + var t = new Ntk_block + t.position = position + t.text = text + return t + end +end +class DFAState90 + super DFAState + redef fun is_accept do return true + redef fun make_token(position, text) do + var t = new Ntk_block + t.position = position + t.text = text + return t + end +end +class DFAState91 + super DFAState + redef fun trans(c) do + if c.ascii == 110 then return dfastate_93 + if c.ascii == 78 then return dfastate_94 + return null + end +end +class DFAState92 + super DFAState + redef fun trans(c) do + if c.ascii == 110 then return dfastate_93 + if c.ascii == 78 then return dfastate_94 + return null + end +end +class DFAState93 + super DFAState + redef fun is_accept do return true + redef fun make_token(position, text) do + var t = new Ntk_burn + t.position = position + t.text = text + return t + end +end +class DFAState94 + super DFAState + redef fun is_accept do return true + redef fun make_token(position, text) do + var t = new Ntk_burn + t.position = position + t.text = text + return t + end +end +class DFAState95 + super DFAState + redef fun trans(c) do + if c.ascii == 117 then return dfastate_105 + if c.ascii == 85 then return dfastate_106 + return null + end +end +class DFAState96 + super DFAState + redef fun trans(c) do + if c.ascii == 117 then return dfastate_105 + if c.ascii == 85 then return dfastate_106 + return null + end +end +class DFAState97 + super DFAState + redef fun trans(c) do + if c.ascii == 100 then return dfastate_99 + if c.ascii == 68 then return dfastate_100 + return null + end +end +class DFAState98 + super DFAState + redef fun trans(c) do + if c.ascii == 100 then return dfastate_99 + if c.ascii == 68 then return dfastate_100 + return null + end +end +class DFAState99 + super DFAState + redef fun is_accept do return true + redef fun make_token(position, text) do + var t = new Nend_block + t.position = position + t.text = text + return t + end + redef fun trans(c) do + if c.ascii == 32 then return dfastate_101 + if c.ascii == 33 then return dfastate_101 + if c.ascii == 34 then return dfastate_101 + if c.ascii == 35 then return dfastate_101 + if c.ascii == 36 then return dfastate_101 + if c.ascii == 37 then return dfastate_101 + if c.ascii == 38 then return dfastate_101 + if c.ascii == 39 then return dfastate_101 + if c.ascii == 40 then return dfastate_101 + if c.ascii == 41 then return dfastate_101 + if c.ascii == 42 then return dfastate_101 + if c.ascii == 43 then return dfastate_101 + if c.ascii == 44 then return dfastate_101 + if c.ascii == 45 then return dfastate_101 + if c.ascii == 46 then return dfastate_101 + if c.ascii == 47 then return dfastate_101 + if c.ascii == 48 then return dfastate_101 + if c.ascii == 49 then return dfastate_101 + if c.ascii == 50 then return dfastate_101 + if c.ascii == 51 then return dfastate_101 + if c.ascii == 52 then return dfastate_101 + if c.ascii == 53 then return dfastate_101 + if c.ascii == 54 then return dfastate_101 + if c.ascii == 55 then return dfastate_101 + if c.ascii == 56 then return dfastate_101 + if c.ascii == 57 then return dfastate_101 + if c.ascii == 58 then return dfastate_101 + if c.ascii == 59 then return dfastate_101 + if c.ascii == 60 then return dfastate_101 + if c.ascii == 61 then return dfastate_101 + if c.ascii == 62 then return dfastate_101 + if c.ascii == 63 then return dfastate_101 + if c.ascii == 64 then return dfastate_101 + if c.ascii == 65 then return dfastate_101 + if c.ascii == 66 then return dfastate_101 + if c.ascii == 67 then return dfastate_101 + if c.ascii == 68 then return dfastate_101 + if c.ascii == 69 then return dfastate_101 + if c.ascii == 70 then return dfastate_101 + if c.ascii == 71 then return dfastate_101 + if c.ascii == 72 then return dfastate_101 + if c.ascii == 73 then return dfastate_101 + if c.ascii == 74 then return dfastate_101 + if c.ascii == 75 then return dfastate_101 + if c.ascii == 76 then return dfastate_101 + if c.ascii == 77 then return dfastate_101 + if c.ascii == 78 then return dfastate_101 + if c.ascii == 79 then return dfastate_101 + if c.ascii == 80 then return dfastate_101 + if c.ascii == 81 then return dfastate_101 + if c.ascii == 82 then return dfastate_101 + if c.ascii == 83 then return dfastate_101 + if c.ascii == 84 then return dfastate_101 + if c.ascii == 85 then return dfastate_101 + if c.ascii == 86 then return dfastate_101 + if c.ascii == 87 then return dfastate_101 + if c.ascii == 88 then return dfastate_101 + if c.ascii == 89 then return dfastate_101 + if c.ascii == 90 then return dfastate_101 + if c.ascii == 91 then return dfastate_101 + if c.ascii == 92 then return dfastate_101 + if c.ascii == 93 then return dfastate_101 + if c.ascii == 94 then return dfastate_101 + if c.ascii == 95 then return dfastate_101 + if c.ascii == 96 then return dfastate_101 + if c.ascii == 97 then return dfastate_101 + if c.ascii == 98 then return dfastate_101 + if c.ascii == 99 then return dfastate_101 + if c.ascii == 100 then return dfastate_101 + if c.ascii == 101 then return dfastate_101 + if c.ascii == 102 then return dfastate_101 + if c.ascii == 103 then return dfastate_101 + if c.ascii == 104 then return dfastate_101 + if c.ascii == 105 then return dfastate_101 + if c.ascii == 106 then return dfastate_101 + if c.ascii == 107 then return dfastate_101 + if c.ascii == 108 then return dfastate_101 + if c.ascii == 109 then return dfastate_101 + if c.ascii == 110 then return dfastate_101 + if c.ascii == 111 then return dfastate_101 + if c.ascii == 112 then return dfastate_101 + if c.ascii == 113 then return dfastate_101 + if c.ascii == 114 then return dfastate_101 + if c.ascii == 115 then return dfastate_101 + if c.ascii == 116 then return dfastate_101 + if c.ascii == 117 then return dfastate_101 + if c.ascii == 118 then return dfastate_101 + if c.ascii == 119 then return dfastate_101 + if c.ascii == 120 then return dfastate_101 + if c.ascii == 121 then return dfastate_101 + if c.ascii == 122 then return dfastate_101 + if c.ascii == 123 then return dfastate_101 + if c.ascii == 124 then return dfastate_101 + if c.ascii == 125 then return dfastate_101 + if c.ascii == 126 then return dfastate_101 + if c.ascii == 13 then return dfastate_102 + if c.ascii == 10 then return dfastate_103 + return null + end +end +class DFAState100 + super DFAState + redef fun is_accept do return true + redef fun make_token(position, text) do + var t = new Nend_block + t.position = position + t.text = text + return t + end + redef fun trans(c) do + if c.ascii == 32 then return dfastate_101 + if c.ascii == 33 then return dfastate_101 + if c.ascii == 34 then return dfastate_101 + if c.ascii == 35 then return dfastate_101 + if c.ascii == 36 then return dfastate_101 + if c.ascii == 37 then return dfastate_101 + if c.ascii == 38 then return dfastate_101 + if c.ascii == 39 then return dfastate_101 + if c.ascii == 40 then return dfastate_101 + if c.ascii == 41 then return dfastate_101 + if c.ascii == 42 then return dfastate_101 + if c.ascii == 43 then return dfastate_101 + if c.ascii == 44 then return dfastate_101 + if c.ascii == 45 then return dfastate_101 + if c.ascii == 46 then return dfastate_101 + if c.ascii == 47 then return dfastate_101 + if c.ascii == 48 then return dfastate_101 + if c.ascii == 49 then return dfastate_101 + if c.ascii == 50 then return dfastate_101 + if c.ascii == 51 then return dfastate_101 + if c.ascii == 52 then return dfastate_101 + if c.ascii == 53 then return dfastate_101 + if c.ascii == 54 then return dfastate_101 + if c.ascii == 55 then return dfastate_101 + if c.ascii == 56 then return dfastate_101 + if c.ascii == 57 then return dfastate_101 + if c.ascii == 58 then return dfastate_101 + if c.ascii == 59 then return dfastate_101 + if c.ascii == 60 then return dfastate_101 + if c.ascii == 61 then return dfastate_101 + if c.ascii == 62 then return dfastate_101 + if c.ascii == 63 then return dfastate_101 + if c.ascii == 64 then return dfastate_101 + if c.ascii == 65 then return dfastate_101 + if c.ascii == 66 then return dfastate_101 + if c.ascii == 67 then return dfastate_101 + if c.ascii == 68 then return dfastate_101 + if c.ascii == 69 then return dfastate_101 + if c.ascii == 70 then return dfastate_101 + if c.ascii == 71 then return dfastate_101 + if c.ascii == 72 then return dfastate_101 + if c.ascii == 73 then return dfastate_101 + if c.ascii == 74 then return dfastate_101 + if c.ascii == 75 then return dfastate_101 + if c.ascii == 76 then return dfastate_101 + if c.ascii == 77 then return dfastate_101 + if c.ascii == 78 then return dfastate_101 + if c.ascii == 79 then return dfastate_101 + if c.ascii == 80 then return dfastate_101 + if c.ascii == 81 then return dfastate_101 + if c.ascii == 82 then return dfastate_101 + if c.ascii == 83 then return dfastate_101 + if c.ascii == 84 then return dfastate_101 + if c.ascii == 85 then return dfastate_101 + if c.ascii == 86 then return dfastate_101 + if c.ascii == 87 then return dfastate_101 + if c.ascii == 88 then return dfastate_101 + if c.ascii == 89 then return dfastate_101 + if c.ascii == 90 then return dfastate_101 + if c.ascii == 91 then return dfastate_101 + if c.ascii == 92 then return dfastate_101 + if c.ascii == 93 then return dfastate_101 + if c.ascii == 94 then return dfastate_101 + if c.ascii == 95 then return dfastate_101 + if c.ascii == 96 then return dfastate_101 + if c.ascii == 97 then return dfastate_101 + if c.ascii == 98 then return dfastate_101 + if c.ascii == 99 then return dfastate_101 + if c.ascii == 100 then return dfastate_101 + if c.ascii == 101 then return dfastate_101 + if c.ascii == 102 then return dfastate_101 + if c.ascii == 103 then return dfastate_101 + if c.ascii == 104 then return dfastate_101 + if c.ascii == 105 then return dfastate_101 + if c.ascii == 106 then return dfastate_101 + if c.ascii == 107 then return dfastate_101 + if c.ascii == 108 then return dfastate_101 + if c.ascii == 109 then return dfastate_101 + if c.ascii == 110 then return dfastate_101 + if c.ascii == 111 then return dfastate_101 + if c.ascii == 112 then return dfastate_101 + if c.ascii == 113 then return dfastate_101 + if c.ascii == 114 then return dfastate_101 + if c.ascii == 115 then return dfastate_101 + if c.ascii == 116 then return dfastate_101 + if c.ascii == 117 then return dfastate_101 + if c.ascii == 118 then return dfastate_101 + if c.ascii == 119 then return dfastate_101 + if c.ascii == 120 then return dfastate_101 + if c.ascii == 121 then return dfastate_101 + if c.ascii == 122 then return dfastate_101 + if c.ascii == 123 then return dfastate_101 + if c.ascii == 124 then return dfastate_101 + if c.ascii == 125 then return dfastate_101 + if c.ascii == 126 then return dfastate_101 + if c.ascii == 13 then return dfastate_102 + if c.ascii == 10 then return dfastate_103 + return null + end +end +class DFAState101 + super DFAState + redef fun is_accept do return true + redef fun make_token(position, text) do + var t = new Nend_block + t.position = position + t.text = text + return t + end + redef fun trans(c) do + if c.ascii == 32 then return dfastate_101 + if c.ascii == 33 then return dfastate_101 + if c.ascii == 34 then return dfastate_101 + if c.ascii == 35 then return dfastate_101 + if c.ascii == 36 then return dfastate_101 + if c.ascii == 37 then return dfastate_101 + if c.ascii == 38 then return dfastate_101 + if c.ascii == 39 then return dfastate_101 + if c.ascii == 40 then return dfastate_101 + if c.ascii == 41 then return dfastate_101 + if c.ascii == 42 then return dfastate_101 + if c.ascii == 43 then return dfastate_101 + if c.ascii == 44 then return dfastate_101 + if c.ascii == 45 then return dfastate_101 + if c.ascii == 46 then return dfastate_101 + if c.ascii == 47 then return dfastate_101 + if c.ascii == 48 then return dfastate_101 + if c.ascii == 49 then return dfastate_101 + if c.ascii == 50 then return dfastate_101 + if c.ascii == 51 then return dfastate_101 + if c.ascii == 52 then return dfastate_101 + if c.ascii == 53 then return dfastate_101 + if c.ascii == 54 then return dfastate_101 + if c.ascii == 55 then return dfastate_101 + if c.ascii == 56 then return dfastate_101 + if c.ascii == 57 then return dfastate_101 + if c.ascii == 58 then return dfastate_101 + if c.ascii == 59 then return dfastate_101 + if c.ascii == 60 then return dfastate_101 + if c.ascii == 61 then return dfastate_101 + if c.ascii == 62 then return dfastate_101 + if c.ascii == 63 then return dfastate_101 + if c.ascii == 64 then return dfastate_101 + if c.ascii == 65 then return dfastate_101 + if c.ascii == 66 then return dfastate_101 + if c.ascii == 67 then return dfastate_101 + if c.ascii == 68 then return dfastate_101 + if c.ascii == 69 then return dfastate_101 + if c.ascii == 70 then return dfastate_101 + if c.ascii == 71 then return dfastate_101 + if c.ascii == 72 then return dfastate_101 + if c.ascii == 73 then return dfastate_101 + if c.ascii == 74 then return dfastate_101 + if c.ascii == 75 then return dfastate_101 + if c.ascii == 76 then return dfastate_101 + if c.ascii == 77 then return dfastate_101 + if c.ascii == 78 then return dfastate_101 + if c.ascii == 79 then return dfastate_101 + if c.ascii == 80 then return dfastate_101 + if c.ascii == 81 then return dfastate_101 + if c.ascii == 82 then return dfastate_101 + if c.ascii == 83 then return dfastate_101 + if c.ascii == 84 then return dfastate_101 + if c.ascii == 85 then return dfastate_101 + if c.ascii == 86 then return dfastate_101 + if c.ascii == 87 then return dfastate_101 + if c.ascii == 88 then return dfastate_101 + if c.ascii == 89 then return dfastate_101 + if c.ascii == 90 then return dfastate_101 + if c.ascii == 91 then return dfastate_101 + if c.ascii == 92 then return dfastate_101 + if c.ascii == 93 then return dfastate_101 + if c.ascii == 94 then return dfastate_101 + if c.ascii == 95 then return dfastate_101 + if c.ascii == 96 then return dfastate_101 + if c.ascii == 97 then return dfastate_101 + if c.ascii == 98 then return dfastate_101 + if c.ascii == 99 then return dfastate_101 + if c.ascii == 100 then return dfastate_101 + if c.ascii == 101 then return dfastate_101 + if c.ascii == 102 then return dfastate_101 + if c.ascii == 103 then return dfastate_101 + if c.ascii == 104 then return dfastate_101 + if c.ascii == 105 then return dfastate_101 + if c.ascii == 106 then return dfastate_101 + if c.ascii == 107 then return dfastate_101 + if c.ascii == 108 then return dfastate_101 + if c.ascii == 109 then return dfastate_101 + if c.ascii == 110 then return dfastate_101 + if c.ascii == 111 then return dfastate_101 + if c.ascii == 112 then return dfastate_101 + if c.ascii == 113 then return dfastate_101 + if c.ascii == 114 then return dfastate_101 + if c.ascii == 115 then return dfastate_101 + if c.ascii == 116 then return dfastate_101 + if c.ascii == 117 then return dfastate_101 + if c.ascii == 118 then return dfastate_101 + if c.ascii == 119 then return dfastate_101 + if c.ascii == 120 then return dfastate_101 + if c.ascii == 121 then return dfastate_101 + if c.ascii == 122 then return dfastate_101 + if c.ascii == 123 then return dfastate_101 + if c.ascii == 124 then return dfastate_101 + if c.ascii == 125 then return dfastate_101 + if c.ascii == 126 then return dfastate_101 + if c.ascii == 13 then return dfastate_102 + if c.ascii == 10 then return dfastate_103 + return null + end +end +class DFAState102 + super DFAState + redef fun is_accept do return true + redef fun make_token(position, text) do + var t = new Nend_block + t.position = position + t.text = text + return t + end + redef fun trans(c) do + if c.ascii == 32 then return dfastate_101 + if c.ascii == 33 then return dfastate_101 + if c.ascii == 34 then return dfastate_101 + if c.ascii == 35 then return dfastate_101 + if c.ascii == 36 then return dfastate_101 + if c.ascii == 37 then return dfastate_101 + if c.ascii == 38 then return dfastate_101 + if c.ascii == 39 then return dfastate_101 + if c.ascii == 40 then return dfastate_101 + if c.ascii == 41 then return dfastate_101 + if c.ascii == 42 then return dfastate_101 + if c.ascii == 43 then return dfastate_101 + if c.ascii == 44 then return dfastate_101 + if c.ascii == 45 then return dfastate_101 + if c.ascii == 46 then return dfastate_101 + if c.ascii == 47 then return dfastate_101 + if c.ascii == 48 then return dfastate_101 + if c.ascii == 49 then return dfastate_101 + if c.ascii == 50 then return dfastate_101 + if c.ascii == 51 then return dfastate_101 + if c.ascii == 52 then return dfastate_101 + if c.ascii == 53 then return dfastate_101 + if c.ascii == 54 then return dfastate_101 + if c.ascii == 55 then return dfastate_101 + if c.ascii == 56 then return dfastate_101 + if c.ascii == 57 then return dfastate_101 + if c.ascii == 58 then return dfastate_101 + if c.ascii == 59 then return dfastate_101 + if c.ascii == 60 then return dfastate_101 + if c.ascii == 61 then return dfastate_101 + if c.ascii == 62 then return dfastate_101 + if c.ascii == 63 then return dfastate_101 + if c.ascii == 64 then return dfastate_101 + if c.ascii == 65 then return dfastate_101 + if c.ascii == 66 then return dfastate_101 + if c.ascii == 67 then return dfastate_101 + if c.ascii == 68 then return dfastate_101 + if c.ascii == 69 then return dfastate_101 + if c.ascii == 70 then return dfastate_101 + if c.ascii == 71 then return dfastate_101 + if c.ascii == 72 then return dfastate_101 + if c.ascii == 73 then return dfastate_101 + if c.ascii == 74 then return dfastate_101 + if c.ascii == 75 then return dfastate_101 + if c.ascii == 76 then return dfastate_101 + if c.ascii == 77 then return dfastate_101 + if c.ascii == 78 then return dfastate_101 + if c.ascii == 79 then return dfastate_101 + if c.ascii == 80 then return dfastate_101 + if c.ascii == 81 then return dfastate_101 + if c.ascii == 82 then return dfastate_101 + if c.ascii == 83 then return dfastate_101 + if c.ascii == 84 then return dfastate_101 + if c.ascii == 85 then return dfastate_101 + if c.ascii == 86 then return dfastate_101 + if c.ascii == 87 then return dfastate_101 + if c.ascii == 88 then return dfastate_101 + if c.ascii == 89 then return dfastate_101 + if c.ascii == 90 then return dfastate_101 + if c.ascii == 91 then return dfastate_101 + if c.ascii == 92 then return dfastate_101 + if c.ascii == 93 then return dfastate_101 + if c.ascii == 94 then return dfastate_101 + if c.ascii == 95 then return dfastate_101 + if c.ascii == 96 then return dfastate_101 + if c.ascii == 97 then return dfastate_101 + if c.ascii == 98 then return dfastate_101 + if c.ascii == 99 then return dfastate_101 + if c.ascii == 100 then return dfastate_101 + if c.ascii == 101 then return dfastate_101 + if c.ascii == 102 then return dfastate_101 + if c.ascii == 103 then return dfastate_101 + if c.ascii == 104 then return dfastate_101 + if c.ascii == 105 then return dfastate_101 + if c.ascii == 106 then return dfastate_101 + if c.ascii == 107 then return dfastate_101 + if c.ascii == 108 then return dfastate_101 + if c.ascii == 109 then return dfastate_101 + if c.ascii == 110 then return dfastate_101 + if c.ascii == 111 then return dfastate_101 + if c.ascii == 112 then return dfastate_101 + if c.ascii == 113 then return dfastate_101 + if c.ascii == 114 then return dfastate_101 + if c.ascii == 115 then return dfastate_101 + if c.ascii == 116 then return dfastate_101 + if c.ascii == 117 then return dfastate_101 + if c.ascii == 118 then return dfastate_101 + if c.ascii == 119 then return dfastate_101 + if c.ascii == 120 then return dfastate_101 + if c.ascii == 121 then return dfastate_101 + if c.ascii == 122 then return dfastate_101 + if c.ascii == 123 then return dfastate_101 + if c.ascii == 124 then return dfastate_101 + if c.ascii == 125 then return dfastate_101 + if c.ascii == 126 then return dfastate_101 + if c.ascii == 13 then return dfastate_102 + if c.ascii == 10 then return dfastate_103 + return null + end +end +class DFAState103 + super DFAState + redef fun is_accept do return true + redef fun make_token(position, text) do + var t = new Nend_block + t.position = position + t.text = text + return t + end + redef fun trans(c) do + if c.ascii == 13 then return dfastate_104 + if c.ascii == 32 then return dfastate_101 + if c.ascii == 33 then return dfastate_101 + if c.ascii == 34 then return dfastate_101 + if c.ascii == 35 then return dfastate_101 + if c.ascii == 36 then return dfastate_101 + if c.ascii == 37 then return dfastate_101 + if c.ascii == 38 then return dfastate_101 + if c.ascii == 39 then return dfastate_101 + if c.ascii == 40 then return dfastate_101 + if c.ascii == 41 then return dfastate_101 + if c.ascii == 42 then return dfastate_101 + if c.ascii == 43 then return dfastate_101 + if c.ascii == 44 then return dfastate_101 + if c.ascii == 45 then return dfastate_101 + if c.ascii == 46 then return dfastate_101 + if c.ascii == 47 then return dfastate_101 + if c.ascii == 48 then return dfastate_101 + if c.ascii == 49 then return dfastate_101 + if c.ascii == 50 then return dfastate_101 + if c.ascii == 51 then return dfastate_101 + if c.ascii == 52 then return dfastate_101 + if c.ascii == 53 then return dfastate_101 + if c.ascii == 54 then return dfastate_101 + if c.ascii == 55 then return dfastate_101 + if c.ascii == 56 then return dfastate_101 + if c.ascii == 57 then return dfastate_101 + if c.ascii == 58 then return dfastate_101 + if c.ascii == 59 then return dfastate_101 + if c.ascii == 60 then return dfastate_101 + if c.ascii == 61 then return dfastate_101 + if c.ascii == 62 then return dfastate_101 + if c.ascii == 63 then return dfastate_101 + if c.ascii == 64 then return dfastate_101 + if c.ascii == 65 then return dfastate_101 + if c.ascii == 66 then return dfastate_101 + if c.ascii == 67 then return dfastate_101 + if c.ascii == 68 then return dfastate_101 + if c.ascii == 69 then return dfastate_101 + if c.ascii == 70 then return dfastate_101 + if c.ascii == 71 then return dfastate_101 + if c.ascii == 72 then return dfastate_101 + if c.ascii == 73 then return dfastate_101 + if c.ascii == 74 then return dfastate_101 + if c.ascii == 75 then return dfastate_101 + if c.ascii == 76 then return dfastate_101 + if c.ascii == 77 then return dfastate_101 + if c.ascii == 78 then return dfastate_101 + if c.ascii == 79 then return dfastate_101 + if c.ascii == 80 then return dfastate_101 + if c.ascii == 81 then return dfastate_101 + if c.ascii == 82 then return dfastate_101 + if c.ascii == 83 then return dfastate_101 + if c.ascii == 84 then return dfastate_101 + if c.ascii == 85 then return dfastate_101 + if c.ascii == 86 then return dfastate_101 + if c.ascii == 87 then return dfastate_101 + if c.ascii == 88 then return dfastate_101 + if c.ascii == 89 then return dfastate_101 + if c.ascii == 90 then return dfastate_101 + if c.ascii == 91 then return dfastate_101 + if c.ascii == 92 then return dfastate_101 + if c.ascii == 93 then return dfastate_101 + if c.ascii == 94 then return dfastate_101 + if c.ascii == 95 then return dfastate_101 + if c.ascii == 96 then return dfastate_101 + if c.ascii == 97 then return dfastate_101 + if c.ascii == 98 then return dfastate_101 + if c.ascii == 99 then return dfastate_101 + if c.ascii == 100 then return dfastate_101 + if c.ascii == 101 then return dfastate_101 + if c.ascii == 102 then return dfastate_101 + if c.ascii == 103 then return dfastate_101 + if c.ascii == 104 then return dfastate_101 + if c.ascii == 105 then return dfastate_101 + if c.ascii == 106 then return dfastate_101 + if c.ascii == 107 then return dfastate_101 + if c.ascii == 108 then return dfastate_101 + if c.ascii == 109 then return dfastate_101 + if c.ascii == 110 then return dfastate_101 + if c.ascii == 111 then return dfastate_101 + if c.ascii == 112 then return dfastate_101 + if c.ascii == 113 then return dfastate_101 + if c.ascii == 114 then return dfastate_101 + if c.ascii == 115 then return dfastate_101 + if c.ascii == 116 then return dfastate_101 + if c.ascii == 117 then return dfastate_101 + if c.ascii == 118 then return dfastate_101 + if c.ascii == 119 then return dfastate_101 + if c.ascii == 120 then return dfastate_101 + if c.ascii == 121 then return dfastate_101 + if c.ascii == 122 then return dfastate_101 + if c.ascii == 123 then return dfastate_101 + if c.ascii == 124 then return dfastate_101 + if c.ascii == 125 then return dfastate_101 + if c.ascii == 126 then return dfastate_101 + if c.ascii == 10 then return dfastate_103 + return null + end +end +class DFAState104 + super DFAState + redef fun is_accept do return true + redef fun make_token(position, text) do + var t = new Nend_block + t.position = position + t.text = text + return t + end + redef fun trans(c) do + if c.ascii == 32 then return dfastate_101 + if c.ascii == 33 then return dfastate_101 + if c.ascii == 34 then return dfastate_101 + if c.ascii == 35 then return dfastate_101 + if c.ascii == 36 then return dfastate_101 + if c.ascii == 37 then return dfastate_101 + if c.ascii == 38 then return dfastate_101 + if c.ascii == 39 then return dfastate_101 + if c.ascii == 40 then return dfastate_101 + if c.ascii == 41 then return dfastate_101 + if c.ascii == 42 then return dfastate_101 + if c.ascii == 43 then return dfastate_101 + if c.ascii == 44 then return dfastate_101 + if c.ascii == 45 then return dfastate_101 + if c.ascii == 46 then return dfastate_101 + if c.ascii == 47 then return dfastate_101 + if c.ascii == 48 then return dfastate_101 + if c.ascii == 49 then return dfastate_101 + if c.ascii == 50 then return dfastate_101 + if c.ascii == 51 then return dfastate_101 + if c.ascii == 52 then return dfastate_101 + if c.ascii == 53 then return dfastate_101 + if c.ascii == 54 then return dfastate_101 + if c.ascii == 55 then return dfastate_101 + if c.ascii == 56 then return dfastate_101 + if c.ascii == 57 then return dfastate_101 + if c.ascii == 58 then return dfastate_101 + if c.ascii == 59 then return dfastate_101 + if c.ascii == 60 then return dfastate_101 + if c.ascii == 61 then return dfastate_101 + if c.ascii == 62 then return dfastate_101 + if c.ascii == 63 then return dfastate_101 + if c.ascii == 64 then return dfastate_101 + if c.ascii == 65 then return dfastate_101 + if c.ascii == 66 then return dfastate_101 + if c.ascii == 67 then return dfastate_101 + if c.ascii == 68 then return dfastate_101 + if c.ascii == 69 then return dfastate_101 + if c.ascii == 70 then return dfastate_101 + if c.ascii == 71 then return dfastate_101 + if c.ascii == 72 then return dfastate_101 + if c.ascii == 73 then return dfastate_101 + if c.ascii == 74 then return dfastate_101 + if c.ascii == 75 then return dfastate_101 + if c.ascii == 76 then return dfastate_101 + if c.ascii == 77 then return dfastate_101 + if c.ascii == 78 then return dfastate_101 + if c.ascii == 79 then return dfastate_101 + if c.ascii == 80 then return dfastate_101 + if c.ascii == 81 then return dfastate_101 + if c.ascii == 82 then return dfastate_101 + if c.ascii == 83 then return dfastate_101 + if c.ascii == 84 then return dfastate_101 + if c.ascii == 85 then return dfastate_101 + if c.ascii == 86 then return dfastate_101 + if c.ascii == 87 then return dfastate_101 + if c.ascii == 88 then return dfastate_101 + if c.ascii == 89 then return dfastate_101 + if c.ascii == 90 then return dfastate_101 + if c.ascii == 91 then return dfastate_101 + if c.ascii == 92 then return dfastate_101 + if c.ascii == 93 then return dfastate_101 + if c.ascii == 94 then return dfastate_101 + if c.ascii == 95 then return dfastate_101 + if c.ascii == 96 then return dfastate_101 + if c.ascii == 97 then return dfastate_101 + if c.ascii == 98 then return dfastate_101 + if c.ascii == 99 then return dfastate_101 + if c.ascii == 100 then return dfastate_101 + if c.ascii == 101 then return dfastate_101 + if c.ascii == 102 then return dfastate_101 + if c.ascii == 103 then return dfastate_101 + if c.ascii == 104 then return dfastate_101 + if c.ascii == 105 then return dfastate_101 + if c.ascii == 106 then return dfastate_101 + if c.ascii == 107 then return dfastate_101 + if c.ascii == 108 then return dfastate_101 + if c.ascii == 109 then return dfastate_101 + if c.ascii == 110 then return dfastate_101 + if c.ascii == 111 then return dfastate_101 + if c.ascii == 112 then return dfastate_101 + if c.ascii == 113 then return dfastate_101 + if c.ascii == 114 then return dfastate_101 + if c.ascii == 115 then return dfastate_101 + if c.ascii == 116 then return dfastate_101 + if c.ascii == 117 then return dfastate_101 + if c.ascii == 118 then return dfastate_101 + if c.ascii == 119 then return dfastate_101 + if c.ascii == 120 then return dfastate_101 + if c.ascii == 121 then return dfastate_101 + if c.ascii == 122 then return dfastate_101 + if c.ascii == 123 then return dfastate_101 + if c.ascii == 124 then return dfastate_101 + if c.ascii == 125 then return dfastate_101 + if c.ascii == 126 then return dfastate_101 + if c.ascii == 13 then return dfastate_102 + if c.ascii == 10 then return dfastate_103 + return null + end +end +class DFAState105 + super DFAState + redef fun trans(c) do + if c.ascii == 97 then return dfastate_107 + if c.ascii == 65 then return dfastate_108 + return null + end +end +class DFAState106 + super DFAState + redef fun trans(c) do + if c.ascii == 97 then return dfastate_107 + if c.ascii == 65 then return dfastate_108 + return null + end +end +class DFAState107 + super DFAState + redef fun trans(c) do + if c.ascii == 116 then return dfastate_109 + if c.ascii == 84 then return dfastate_110 + return null + end +end +class DFAState108 + super DFAState + redef fun trans(c) do + if c.ascii == 116 then return dfastate_109 + if c.ascii == 84 then return dfastate_110 + return null + end +end +class DFAState109 + super DFAState + redef fun trans(c) do + if c.ascii == 101 then return dfastate_111 + if c.ascii == 69 then return dfastate_112 + return null + end +end +class DFAState110 + super DFAState + redef fun trans(c) do + if c.ascii == 101 then return dfastate_111 + if c.ascii == 69 then return dfastate_112 + return null + end +end +class DFAState111 + super DFAState + redef fun is_accept do return true + redef fun make_token(position, text) do + var t = new Ntk_equate + t.position = position + t.text = text + return t + end +end +class DFAState112 + super DFAState + redef fun is_accept do return true + redef fun make_token(position, text) do + var t = new Ntk_equate + t.position = position + t.text = text + return t + end +end diff --git a/contrib/pep8analysis/src/parser/pep8_parser.nit b/contrib/pep8analysis/src/parser/pep8_parser.nit new file mode 100644 index 0000000..1b91658 --- /dev/null +++ b/contrib/pep8analysis/src/parser/pep8_parser.nit @@ -0,0 +1,1754 @@ +# Parser generated by nitcc +import nitcc_runtime +class MyParser + super Parser + redef fun start_state do return state_Start +end +redef class Object + private fun state_Start: LRStateStart do return once new LRStateStart + private fun state_listing: LRStatelisting do return once new LRStatelisting + private fun state_line_43d: LRStateline_43d do return once new LRStateline_43d + private fun state_line: LRStateline do return once new LRStateline + private fun state_label_decl: LRStatelabel_decl do return once new LRStatelabel_decl + private fun state_id: LRStateid do return once new LRStateid + private fun state_comment: LRStatecomment do return once new LRStatecomment + private fun state_eol: LRStateeol do return once new LRStateeol + private fun state_instruction: LRStateinstruction do return once new LRStateinstruction + private fun state_directive: LRStatedirective do return once new LRStatedirective + private fun state_tk_byte: LRStatetk_byte do return once new LRStatetk_byte + private fun state_tk_word: LRStatetk_word do return once new LRStatetk_word + private fun state_tk_block: LRStatetk_block do return once new LRStatetk_block + private fun state_tk_ascii: LRStatetk_ascii do return once new LRStatetk_ascii + private fun state_tk_addrss: LRStatetk_addrss do return once new LRStatetk_addrss + private fun state_tk_equate: LRStatetk_equate do return once new LRStatetk_equate + private fun state_tk_burn: LRStatetk_burn do return once new LRStatetk_burn + private fun state_end_block: LRStateend_block do return once new LRStateend_block + private fun state_listing_32dEof: LRStatelisting_32dEof do return once new LRStatelisting_32dEof + private fun state_line_43d_32dlabel_decl: LRStateline_43d_32dlabel_decl do return once new LRStateline_43d_32dlabel_decl + private fun state_line_43d_32dline: LRStateline_43d_32dline do return once new LRStateline_43d_32dline + private fun state_line_43d_32dend_block: LRStateline_43d_32dend_block do return once new LRStateline_43d_32dend_block + private fun state_label_decl_32dcomment: LRStatelabel_decl_32dcomment do return once new LRStatelabel_decl_32dcomment + private fun state_label_decl_32deol: LRStatelabel_decl_32deol do return once new LRStatelabel_decl_32deol + private fun state_label_decl_32dinstruction: LRStatelabel_decl_32dinstruction do return once new LRStatelabel_decl_32dinstruction + private fun state_label_decl_32ddirective: LRStatelabel_decl_32ddirective do return once new LRStatelabel_decl_32ddirective + private fun state_label_decl_32dend_block: LRStatelabel_decl_32dend_block do return once new LRStatelabel_decl_32dend_block + private fun state_label_decl_32did: LRStatelabel_decl_32did do return once new LRStatelabel_decl_32did + private fun state_id_32dcolon: LRStateid_32dcolon do return once new LRStateid_32dcolon + private fun state_id_32doperand: LRStateid_32doperand do return once new LRStateid_32doperand + private fun state_id_32dvalue: LRStateid_32dvalue do return once new LRStateid_32dvalue + private fun state_id_32did: LRStateid_32did do return once new LRStateid_32did + private fun state_id_32dchar: LRStateid_32dchar do return once new LRStateid_32dchar + private fun state_id_32dstring: LRStateid_32dstring do return once new LRStateid_32dstring + private fun state_comment_32deol: LRStatecomment_32deol do return once new LRStatecomment_32deol + private fun state_instruction_32dcomment: LRStateinstruction_32dcomment do return once new LRStateinstruction_32dcomment + private fun state_instruction_32deol: LRStateinstruction_32deol do return once new LRStateinstruction_32deol + private fun state_directive_32dcomment: LRStatedirective_32dcomment do return once new LRStatedirective_32dcomment + private fun state_directive_32deol: LRStatedirective_32deol do return once new LRStatedirective_32deol + private fun state_tk_byte_32dvalue: LRStatetk_byte_32dvalue do return once new LRStatetk_byte_32dvalue + private fun state_tk_word_32dvalue: LRStatetk_word_32dvalue do return once new LRStatetk_word_32dvalue + private fun state_tk_block_32dvalue: LRStatetk_block_32dvalue do return once new LRStatetk_block_32dvalue + private fun state_tk_ascii_32dvalue: LRStatetk_ascii_32dvalue do return once new LRStatetk_ascii_32dvalue + private fun state_tk_addrss_32dvalue: LRStatetk_addrss_32dvalue do return once new LRStatetk_addrss_32dvalue + private fun state_tk_equate_32dvalue: LRStatetk_equate_32dvalue do return once new LRStatetk_equate_32dvalue + private fun state_tk_burn_32dvalue: LRStatetk_burn_32dvalue do return once new LRStatetk_burn_32dvalue + private fun state_line_43d_32dlabel_decl_32dend_block: LRStateline_43d_32dlabel_decl_32dend_block do return once new LRStateline_43d_32dlabel_decl_32dend_block + private fun state_label_decl_32dcomment_32deol: LRStatelabel_decl_32dcomment_32deol do return once new LRStatelabel_decl_32dcomment_32deol + private fun state_label_decl_32dinstruction_32dcomment: LRStatelabel_decl_32dinstruction_32dcomment do return once new LRStatelabel_decl_32dinstruction_32dcomment + private fun state_label_decl_32dinstruction_32deol: LRStatelabel_decl_32dinstruction_32deol do return once new LRStatelabel_decl_32dinstruction_32deol + private fun state_label_decl_32ddirective_32dcomment: LRStatelabel_decl_32ddirective_32dcomment do return once new LRStatelabel_decl_32ddirective_32dcomment + private fun state_label_decl_32ddirective_32deol: LRStatelabel_decl_32ddirective_32deol do return once new LRStatelabel_decl_32ddirective_32deol + private fun state_id_32dvalue_32dcomma: LRStateid_32dvalue_32dcomma do return once new LRStateid_32dvalue_32dcomma + private fun state_instruction_32dcomment_32deol: LRStateinstruction_32dcomment_32deol do return once new LRStateinstruction_32dcomment_32deol + private fun state_directive_32dcomment_32deol: LRStatedirective_32dcomment_32deol do return once new LRStatedirective_32dcomment_32deol + private fun state_label_decl_32dinstruction_32dcomment_32deol: LRStatelabel_decl_32dinstruction_32dcomment_32deol do return once new LRStatelabel_decl_32dinstruction_32dcomment_32deol + private fun state_label_decl_32ddirective_32dcomment_32deol: LRStatelabel_decl_32ddirective_32dcomment_32deol do return once new LRStatelabel_decl_32ddirective_32dcomment_32deol + private fun state_id_32dvalue_32dcomma_32did: LRStateid_32dvalue_32dcomma_32did do return once new LRStateid_32dvalue_32dcomma_32did + private fun goto_Nlisting: Goto_Nlisting do return once new Goto_Nlisting + private fun goto_Nline: Goto_Nline do return once new Goto_Nline + private fun goto_Nlabel_decl: Goto_Nlabel_decl do return once new Goto_Nlabel_decl + private fun goto_Ninstruction: Goto_Ninstruction do return once new Goto_Ninstruction + private fun goto_Noperand: Goto_Noperand do return once new Goto_Noperand + private fun goto_Nvalue: Goto_Nvalue do return once new Goto_Nvalue + private fun goto_Ndirective: Goto_Ndirective do return once new Goto_Ndirective + private fun goto_Nline_43d: Goto_Nline_43d do return once new Goto_Nline_43d + private fun goto_N_start: Goto_N_start do return once new Goto_N_start +end +redef class NToken + # guarded action for state Start + # 11 shift(s) and 0 reduce(s) + private fun action_sStart(parser: Parser) do + parser.parse_error + end + # guarded action for state listing + # 1 shift(s) and 0 reduce(s) + private fun action_slisting(parser: Parser) do + parser.parse_error + end + # guarded action for state line+ + # 11 shift(s) and 0 reduce(s) + private fun action_sline_43d(parser: Parser) do + parser.parse_error + end + # guarded action for state label_decl + # 11 shift(s) and 0 reduce(s) + private fun action_slabel_decl(parser: Parser) do + parser.parse_error + end + # guarded action for state id + # 4 shift(s) and 1 reduce(s) + private fun action_sid(parser: Parser) do + # REDUCE instruction::instruction_unary=id + var n0 = parser.pop.as(Nid) + var p1 = new Ninstruction_unary(n0) + var prod = p1 + parser.node_stack.push prod + parser.goto(goto_Ninstruction) + end + # guarded action for state comment + # 1 shift(s) and 0 reduce(s) + private fun action_scomment(parser: Parser) do + parser.parse_error + end + # guarded action for state instruction + # 2 shift(s) and 0 reduce(s) + private fun action_sinstruction(parser: Parser) do + parser.parse_error + end + # guarded action for state directive + # 2 shift(s) and 0 reduce(s) + private fun action_sdirective(parser: Parser) do + parser.parse_error + end + # guarded action for state tk_byte + # 3 shift(s) and 0 reduce(s) + private fun action_stk_byte(parser: Parser) do + parser.parse_error + end + # guarded action for state tk_word + # 3 shift(s) and 0 reduce(s) + private fun action_stk_word(parser: Parser) do + parser.parse_error + end + # guarded action for state tk_block + # 3 shift(s) and 0 reduce(s) + private fun action_stk_block(parser: Parser) do + parser.parse_error + end + # guarded action for state tk_ascii + # 3 shift(s) and 0 reduce(s) + private fun action_stk_ascii(parser: Parser) do + parser.parse_error + end + # guarded action for state tk_addrss + # 3 shift(s) and 0 reduce(s) + private fun action_stk_addrss(parser: Parser) do + parser.parse_error + end + # guarded action for state tk_equate + # 3 shift(s) and 0 reduce(s) + private fun action_stk_equate(parser: Parser) do + parser.parse_error + end + # guarded action for state tk_burn + # 3 shift(s) and 0 reduce(s) + private fun action_stk_burn(parser: Parser) do + parser.parse_error + end + # guarded action for state line+ label_decl + # 11 shift(s) and 0 reduce(s) + private fun action_sline_43d_32dlabel_decl(parser: Parser) do + parser.parse_error + end + # guarded action for state label_decl comment + # 1 shift(s) and 0 reduce(s) + private fun action_slabel_decl_32dcomment(parser: Parser) do + parser.parse_error + end + # guarded action for state label_decl instruction + # 2 shift(s) and 0 reduce(s) + private fun action_slabel_decl_32dinstruction(parser: Parser) do + parser.parse_error + end + # guarded action for state label_decl directive + # 2 shift(s) and 0 reduce(s) + private fun action_slabel_decl_32ddirective(parser: Parser) do + parser.parse_error + end + # guarded action for state label_decl id + # 3 shift(s) and 1 reduce(s) + private fun action_slabel_decl_32did(parser: Parser) do + # REDUCE instruction::instruction_unary=id + var n0 = parser.pop.as(Nid) + var p1 = new Ninstruction_unary(n0) + var prod = p1 + parser.node_stack.push prod + parser.goto(goto_Ninstruction) + end + # guarded action for state id value + # 1 shift(s) and 1 reduce(s) + private fun action_sid_32dvalue(parser: Parser) do + # REDUCE operand::operand_immediate=value + var n0 = parser.pop.as(Nvalue) + var p1 = new Noperand_immediate(n0) + var prod = p1 + parser.node_stack.push prod + parser.goto(goto_Noperand) + end + # guarded action for state instruction comment + # 1 shift(s) and 0 reduce(s) + private fun action_sinstruction_32dcomment(parser: Parser) do + parser.parse_error + end + # guarded action for state directive comment + # 1 shift(s) and 0 reduce(s) + private fun action_sdirective_32dcomment(parser: Parser) do + parser.parse_error + end + # guarded action for state label_decl instruction comment + # 1 shift(s) and 0 reduce(s) + private fun action_slabel_decl_32dinstruction_32dcomment(parser: Parser) do + parser.parse_error + end + # guarded action for state label_decl directive comment + # 1 shift(s) and 0 reduce(s) + private fun action_slabel_decl_32ddirective_32dcomment(parser: Parser) do + parser.parse_error + end + # guarded action for state id value comma + # 1 shift(s) and 0 reduce(s) + private fun action_sid_32dvalue_32dcomma(parser: Parser) do + parser.parse_error + end +end +class NIgnored + super NToken + redef fun node_name do return "Ignored" +end +class Nend_block + super NToken + redef fun action_sStart(parser) do + parser.shift(state_end_block) + end + redef fun action_sline_43d(parser) do + parser.shift(state_line_43d_32dend_block) + end + redef fun action_slabel_decl(parser) do + parser.shift(state_label_decl_32dend_block) + end + redef fun action_sline_43d_32dlabel_decl(parser) do + parser.shift(state_line_43d_32dlabel_decl_32dend_block) + end + redef fun node_name do return "end_block" +end +class Ncomment + super NToken + redef fun action_sStart(parser) do + parser.shift(state_comment) + end + redef fun action_sline_43d(parser) do + parser.shift(state_comment) + end + redef fun action_slabel_decl(parser) do + parser.shift(state_label_decl_32dcomment) + end + redef fun action_sinstruction(parser) do + parser.shift(state_instruction_32dcomment) + end + redef fun action_sdirective(parser) do + parser.shift(state_directive_32dcomment) + end + redef fun action_sline_43d_32dlabel_decl(parser) do + parser.shift(state_label_decl_32dcomment) + end + redef fun action_slabel_decl_32dinstruction(parser) do + parser.shift(state_label_decl_32dinstruction_32dcomment) + end + redef fun action_slabel_decl_32ddirective(parser) do + parser.shift(state_label_decl_32ddirective_32dcomment) + end + redef fun node_name do return "comment" +end +class Neol + super NToken + redef fun action_sStart(parser) do + parser.shift(state_eol) + end + redef fun action_sline_43d(parser) do + parser.shift(state_eol) + end + redef fun action_slabel_decl(parser) do + parser.shift(state_label_decl_32deol) + end + redef fun action_scomment(parser) do + parser.shift(state_comment_32deol) + end + redef fun action_sinstruction(parser) do + parser.shift(state_instruction_32deol) + end + redef fun action_sdirective(parser) do + parser.shift(state_directive_32deol) + end + redef fun action_sline_43d_32dlabel_decl(parser) do + parser.shift(state_label_decl_32deol) + end + redef fun action_slabel_decl_32dcomment(parser) do + parser.shift(state_label_decl_32dcomment_32deol) + end + redef fun action_slabel_decl_32dinstruction(parser) do + parser.shift(state_label_decl_32dinstruction_32deol) + end + redef fun action_slabel_decl_32ddirective(parser) do + parser.shift(state_label_decl_32ddirective_32deol) + end + redef fun action_sinstruction_32dcomment(parser) do + parser.shift(state_instruction_32dcomment_32deol) + end + redef fun action_sdirective_32dcomment(parser) do + parser.shift(state_directive_32dcomment_32deol) + end + redef fun action_slabel_decl_32dinstruction_32dcomment(parser) do + parser.shift(state_label_decl_32dinstruction_32dcomment_32deol) + end + redef fun action_slabel_decl_32ddirective_32dcomment(parser) do + parser.shift(state_label_decl_32ddirective_32dcomment_32deol) + end + redef fun node_name do return "eol" +end +class Nid + super NToken + redef fun action_sStart(parser) do + parser.shift(state_id) + end + redef fun action_sline_43d(parser) do + parser.shift(state_id) + end + redef fun action_slabel_decl(parser) do + parser.shift(state_label_decl_32did) + end + redef fun action_sid(parser) do + parser.shift(state_id_32did) + end + redef fun action_stk_byte(parser) do + parser.shift(state_id_32did) + end + redef fun action_stk_word(parser) do + parser.shift(state_id_32did) + end + redef fun action_stk_block(parser) do + parser.shift(state_id_32did) + end + redef fun action_stk_ascii(parser) do + parser.shift(state_id_32did) + end + redef fun action_stk_addrss(parser) do + parser.shift(state_id_32did) + end + redef fun action_stk_equate(parser) do + parser.shift(state_id_32did) + end + redef fun action_stk_burn(parser) do + parser.shift(state_id_32did) + end + redef fun action_sline_43d_32dlabel_decl(parser) do + parser.shift(state_label_decl_32did) + end + redef fun action_slabel_decl_32did(parser) do + parser.shift(state_id_32did) + end + redef fun action_sid_32dvalue_32dcomma(parser) do + parser.shift(state_id_32dvalue_32dcomma_32did) + end + redef fun node_name do return "id" +end +class Ncolon + super NToken + redef fun action_sid(parser) do + parser.shift(state_id_32dcolon) + end + redef fun node_name do return "colon" +end +class Ncomma + super NToken + redef fun action_sid_32dvalue(parser) do + parser.shift(state_id_32dvalue_32dcomma) + end + redef fun node_name do return "comma" +end +class Nchar + super NToken + redef fun action_sid(parser) do + parser.shift(state_id_32dchar) + end + redef fun action_stk_byte(parser) do + parser.shift(state_id_32dchar) + end + redef fun action_stk_word(parser) do + parser.shift(state_id_32dchar) + end + redef fun action_stk_block(parser) do + parser.shift(state_id_32dchar) + end + redef fun action_stk_ascii(parser) do + parser.shift(state_id_32dchar) + end + redef fun action_stk_addrss(parser) do + parser.shift(state_id_32dchar) + end + redef fun action_stk_equate(parser) do + parser.shift(state_id_32dchar) + end + redef fun action_stk_burn(parser) do + parser.shift(state_id_32dchar) + end + redef fun action_slabel_decl_32did(parser) do + parser.shift(state_id_32dchar) + end + redef fun node_name do return "char" +end +class Nstring + super NToken + redef fun action_sid(parser) do + parser.shift(state_id_32dstring) + end + redef fun action_stk_byte(parser) do + parser.shift(state_id_32dstring) + end + redef fun action_stk_word(parser) do + parser.shift(state_id_32dstring) + end + redef fun action_stk_block(parser) do + parser.shift(state_id_32dstring) + end + redef fun action_stk_ascii(parser) do + parser.shift(state_id_32dstring) + end + redef fun action_stk_addrss(parser) do + parser.shift(state_id_32dstring) + end + redef fun action_stk_equate(parser) do + parser.shift(state_id_32dstring) + end + redef fun action_stk_burn(parser) do + parser.shift(state_id_32dstring) + end + redef fun action_slabel_decl_32did(parser) do + parser.shift(state_id_32dstring) + end + redef fun node_name do return "string" +end +class Ntk_byte + super NToken + redef fun action_sStart(parser) do + parser.shift(state_tk_byte) + end + redef fun action_sline_43d(parser) do + parser.shift(state_tk_byte) + end + redef fun action_slabel_decl(parser) do + parser.shift(state_tk_byte) + end + redef fun action_sline_43d_32dlabel_decl(parser) do + parser.shift(state_tk_byte) + end + redef fun node_name do return "tk_byte" +end +class Ntk_word + super NToken + redef fun action_sStart(parser) do + parser.shift(state_tk_word) + end + redef fun action_sline_43d(parser) do + parser.shift(state_tk_word) + end + redef fun action_slabel_decl(parser) do + parser.shift(state_tk_word) + end + redef fun action_sline_43d_32dlabel_decl(parser) do + parser.shift(state_tk_word) + end + redef fun node_name do return "tk_word" +end +class Ntk_block + super NToken + redef fun action_sStart(parser) do + parser.shift(state_tk_block) + end + redef fun action_sline_43d(parser) do + parser.shift(state_tk_block) + end + redef fun action_slabel_decl(parser) do + parser.shift(state_tk_block) + end + redef fun action_sline_43d_32dlabel_decl(parser) do + parser.shift(state_tk_block) + end + redef fun node_name do return "tk_block" +end +class Ntk_ascii + super NToken + redef fun action_sStart(parser) do + parser.shift(state_tk_ascii) + end + redef fun action_sline_43d(parser) do + parser.shift(state_tk_ascii) + end + redef fun action_slabel_decl(parser) do + parser.shift(state_tk_ascii) + end + redef fun action_sline_43d_32dlabel_decl(parser) do + parser.shift(state_tk_ascii) + end + redef fun node_name do return "tk_ascii" +end +class Ntk_addrss + super NToken + redef fun action_sStart(parser) do + parser.shift(state_tk_addrss) + end + redef fun action_sline_43d(parser) do + parser.shift(state_tk_addrss) + end + redef fun action_slabel_decl(parser) do + parser.shift(state_tk_addrss) + end + redef fun action_sline_43d_32dlabel_decl(parser) do + parser.shift(state_tk_addrss) + end + redef fun node_name do return "tk_addrss" +end +class Ntk_equate + super NToken + redef fun action_sStart(parser) do + parser.shift(state_tk_equate) + end + redef fun action_sline_43d(parser) do + parser.shift(state_tk_equate) + end + redef fun action_slabel_decl(parser) do + parser.shift(state_tk_equate) + end + redef fun action_sline_43d_32dlabel_decl(parser) do + parser.shift(state_tk_equate) + end + redef fun node_name do return "tk_equate" +end +class Ntk_burn + super NToken + redef fun action_sStart(parser) do + parser.shift(state_tk_burn) + end + redef fun action_sline_43d(parser) do + parser.shift(state_tk_burn) + end + redef fun action_slabel_decl(parser) do + parser.shift(state_tk_burn) + end + redef fun action_sline_43d_32dlabel_decl(parser) do + parser.shift(state_tk_burn) + end + redef fun node_name do return "tk_burn" +end +redef class NEof + super NToken + redef fun action_slisting(parser) do + parser.shift(state_listing_32dEof) + end + redef fun node_name do return "Eof" +end +redef class LRGoto + private fun goto_sStart(parser: Parser) do abort + private fun goto_sline_43d(parser: Parser) do abort + private fun goto_slabel_decl(parser: Parser) do abort + private fun goto_sid(parser: Parser) do abort + private fun goto_sline_43d_32dlabel_decl(parser: Parser) do abort + private fun goto_slabel_decl_32did(parser: Parser) do abort +end +class Goto_Nlisting + super LRGoto + redef fun goto_sStart(parser) do + parser.push(state_listing) + end +end +class Goto_Nline + super LRGoto + redef fun goto_sStart(parser) do + parser.push(state_line) + end + redef fun goto_sline_43d(parser) do + parser.push(state_line_43d_32dline) + end +end +class Goto_Nlabel_decl + super LRGoto + redef fun goto_sStart(parser) do + parser.push(state_label_decl) + end + redef fun goto_sline_43d(parser) do + parser.push(state_line_43d_32dlabel_decl) + end +end +class Goto_Ninstruction + super LRGoto + redef fun goto_sStart(parser) do + parser.push(state_instruction) + end + redef fun goto_sline_43d(parser) do + parser.push(state_instruction) + end + redef fun goto_slabel_decl(parser) do + parser.push(state_label_decl_32dinstruction) + end + redef fun goto_sline_43d_32dlabel_decl(parser) do + parser.push(state_label_decl_32dinstruction) + end +end +class Goto_Noperand + super LRGoto + redef fun goto_sid(parser) do + parser.push(state_id_32doperand) + end + redef fun goto_slabel_decl_32did(parser) do + parser.push(state_id_32doperand) + end +end +class Goto_Nvalue + super LRGoto + redef fun goto_sid(parser) do + parser.push(state_id_32dvalue) + end + redef fun goto_slabel_decl_32did(parser) do + parser.push(state_id_32dvalue) + end +end +class Goto_Ndirective + super LRGoto + redef fun goto_sStart(parser) do + parser.push(state_directive) + end + redef fun goto_sline_43d(parser) do + parser.push(state_directive) + end + redef fun goto_slabel_decl(parser) do + parser.push(state_label_decl_32ddirective) + end + redef fun goto_sline_43d_32dlabel_decl(parser) do + parser.push(state_label_decl_32ddirective) + end +end +class Goto_Nline_43d + super LRGoto + redef fun goto_sStart(parser) do + parser.push(state_line_43d) + end +end +class Goto_N_start + super LRGoto +end +class Nlisting + super NProd + redef fun node_name do return "listing" + var n_lines: nullable Nodes[Nline] + var n_label_decl: nullable Nlabel_decl + var n_end_block: Nend_block + init(n_lines: nullable Nodes[Nline], n_label_decl: nullable Nlabel_decl, n_end_block: Nend_block) do + self.n_lines = n_lines + self.n_label_decl = n_label_decl + self.n_end_block = n_end_block + end + redef fun number_of_children do return 3 + redef fun child(i) do + if i == 0 then return n_lines + if i == 1 then return n_label_decl + if i == 2 then return n_end_block + abort + end +end +class Nline + super NProd + redef fun node_name do return "line" +end +class Nline_empty + super Nline + redef fun node_name do return "line_empty" + var n_label_decl: nullable Nlabel_decl + var n_comment: nullable Ncomment + var n_eol: Neol + init(n_label_decl: nullable Nlabel_decl, n_comment: nullable Ncomment, n_eol: Neol) do + self.n_label_decl = n_label_decl + self.n_comment = n_comment + self.n_eol = n_eol + end + redef fun number_of_children do return 3 + redef fun child(i) do + if i == 0 then return n_label_decl + if i == 1 then return n_comment + if i == 2 then return n_eol + abort + end +end +class Nline_instruction + super Nline + redef fun node_name do return "line_instruction" + var n_label_decl: nullable Nlabel_decl + var n_instruction: Ninstruction + var n_comment: nullable Ncomment + var n_eol: Neol + init(n_label_decl: nullable Nlabel_decl, n_instruction: Ninstruction, n_comment: nullable Ncomment, n_eol: Neol) do + self.n_label_decl = n_label_decl + self.n_instruction = n_instruction + self.n_comment = n_comment + self.n_eol = n_eol + end + redef fun number_of_children do return 4 + redef fun child(i) do + if i == 0 then return n_label_decl + if i == 1 then return n_instruction + if i == 2 then return n_comment + if i == 3 then return n_eol + abort + end +end +class Nline_directive + super Nline + redef fun node_name do return "line_directive" + var n_label_decl: nullable Nlabel_decl + var n_directive: Ndirective + var n_comment: nullable Ncomment + var n_eol: Neol + init(n_label_decl: nullable Nlabel_decl, n_directive: Ndirective, n_comment: nullable Ncomment, n_eol: Neol) do + self.n_label_decl = n_label_decl + self.n_directive = n_directive + self.n_comment = n_comment + self.n_eol = n_eol + end + redef fun number_of_children do return 4 + redef fun child(i) do + if i == 0 then return n_label_decl + if i == 1 then return n_directive + if i == 2 then return n_comment + if i == 3 then return n_eol + abort + end +end +class Nlabel_decl + super NProd + redef fun node_name do return "label_decl" + var n_id: Nid + var n_colon: Ncolon + init(n_id: Nid, n_colon: Ncolon) do + self.n_id = n_id + self.n_colon = n_colon + end + redef fun number_of_children do return 2 + redef fun child(i) do + if i == 0 then return n_id + if i == 1 then return n_colon + abort + end +end +class Ninstruction + super NProd + redef fun node_name do return "instruction" +end +class Ninstruction_unary + super Ninstruction + redef fun node_name do return "instruction_unary" + var n_id: Nid + init(n_id: Nid) do + self.n_id = n_id + end + redef fun number_of_children do return 1 + redef fun child(i) do + if i == 0 then return n_id + abort + end +end +class Ninstruction_binary + super Ninstruction + redef fun node_name do return "instruction_binary" + var n_id: Nid + var n_operand: Noperand + init(n_id: Nid, n_operand: Noperand) do + self.n_id = n_id + self.n_operand = n_operand + end + redef fun number_of_children do return 2 + redef fun child(i) do + if i == 0 then return n_id + if i == 1 then return n_operand + abort + end +end +class Noperand + super NProd + redef fun node_name do return "operand" +end +class Noperand_immediate + super Noperand + redef fun node_name do return "operand_immediate" + var n_value: Nvalue + init(n_value: Nvalue) do + self.n_value = n_value + end + redef fun number_of_children do return 1 + redef fun child(i) do + if i == 0 then return n_value + abort + end +end +class Noperand_any + super Noperand + redef fun node_name do return "operand_any" + var n_value: Nvalue + var n_comma: Ncomma + var n_id: Nid + init(n_value: Nvalue, n_comma: Ncomma, n_id: Nid) do + self.n_value = n_value + self.n_comma = n_comma + self.n_id = n_id + end + redef fun number_of_children do return 3 + redef fun child(i) do + if i == 0 then return n_value + if i == 1 then return n_comma + if i == 2 then return n_id + abort + end +end +class Nvalue + super NProd + redef fun node_name do return "value" +end +class Nvalue_label + super Nvalue + redef fun node_name do return "value_label" + var n_id: Nid + init(n_id: Nid) do + self.n_id = n_id + end + redef fun number_of_children do return 1 + redef fun child(i) do + if i == 0 then return n_id + abort + end +end +class Nvalue_char + super Nvalue + redef fun node_name do return "value_char" + var n_char: Nchar + init(n_char: Nchar) do + self.n_char = n_char + end + redef fun number_of_children do return 1 + redef fun child(i) do + if i == 0 then return n_char + abort + end +end +class Nvalue_string + super Nvalue + redef fun node_name do return "value_string" + var n_string: Nstring + init(n_string: Nstring) do + self.n_string = n_string + end + redef fun number_of_children do return 1 + redef fun child(i) do + if i == 0 then return n_string + abort + end +end +class Ndirective + super NProd + redef fun node_name do return "directive" +end +class Ndirective_byte + super Ndirective + redef fun node_name do return "directive_byte" + var n_tk_byte: Ntk_byte + var n_value: Nvalue + init(n_tk_byte: Ntk_byte, n_value: Nvalue) do + self.n_tk_byte = n_tk_byte + self.n_value = n_value + end + redef fun number_of_children do return 2 + redef fun child(i) do + if i == 0 then return n_tk_byte + if i == 1 then return n_value + abort + end +end +class Ndirective_word + super Ndirective + redef fun node_name do return "directive_word" + var n_tk_word: Ntk_word + var n_value: Nvalue + init(n_tk_word: Ntk_word, n_value: Nvalue) do + self.n_tk_word = n_tk_word + self.n_value = n_value + end + redef fun number_of_children do return 2 + redef fun child(i) do + if i == 0 then return n_tk_word + if i == 1 then return n_value + abort + end +end +class Ndirective_block + super Ndirective + redef fun node_name do return "directive_block" + var n_tk_block: Ntk_block + var n_value: Nvalue + init(n_tk_block: Ntk_block, n_value: Nvalue) do + self.n_tk_block = n_tk_block + self.n_value = n_value + end + redef fun number_of_children do return 2 + redef fun child(i) do + if i == 0 then return n_tk_block + if i == 1 then return n_value + abort + end +end +class Ndirective_ascii + super Ndirective + redef fun node_name do return "directive_ascii" + var n_tk_ascii: Ntk_ascii + var n_value: Nvalue + init(n_tk_ascii: Ntk_ascii, n_value: Nvalue) do + self.n_tk_ascii = n_tk_ascii + self.n_value = n_value + end + redef fun number_of_children do return 2 + redef fun child(i) do + if i == 0 then return n_tk_ascii + if i == 1 then return n_value + abort + end +end +class Ndirective_addrss + super Ndirective + redef fun node_name do return "directive_addrss" + var n_tk_addrss: Ntk_addrss + var n_value: Nvalue + init(n_tk_addrss: Ntk_addrss, n_value: Nvalue) do + self.n_tk_addrss = n_tk_addrss + self.n_value = n_value + end + redef fun number_of_children do return 2 + redef fun child(i) do + if i == 0 then return n_tk_addrss + if i == 1 then return n_value + abort + end +end +class Ndirective_equate + super Ndirective + redef fun node_name do return "directive_equate" + var n_tk_equate: Ntk_equate + var n_value: Nvalue + init(n_tk_equate: Ntk_equate, n_value: Nvalue) do + self.n_tk_equate = n_tk_equate + self.n_value = n_value + end + redef fun number_of_children do return 2 + redef fun child(i) do + if i == 0 then return n_tk_equate + if i == 1 then return n_value + abort + end +end +class Ndirective_burn + super Ndirective + redef fun node_name do return "directive_burn" + var n_tk_burn: Ntk_burn + var n_value: Nvalue + init(n_tk_burn: Ntk_burn, n_value: Nvalue) do + self.n_tk_burn = n_tk_burn + self.n_value = n_value + end + redef fun number_of_children do return 2 + redef fun child(i) do + if i == 0 then return n_tk_burn + if i == 1 then return n_value + abort + end +end +class N_start + super NProd + redef fun node_name do return "_start" +end +class NStart + super N_start + redef fun node_name do return "Start" + var n_0: Nlisting + var n_1: NEof + init(n_0: Nlisting, n_1: NEof) do + self.n_0 = n_0 + self.n_1 = n_1 + end + redef fun number_of_children do return 2 + redef fun child(i) do + if i == 0 then return n_0 + if i == 1 then return n_1 + abort + end +end +# State Start +private class LRStateStart + super LRState + redef fun to_s do return "Start" + redef fun error_msg do return "listing, line+, line, label_decl, instruction, directive" + redef fun action(parser) do + parser.peek_token.action_sStart(parser) + end + redef fun goto(parser, goto) do + goto.goto_sStart(parser) + end +end +# State listing +private class LRStatelisting + super LRState + redef fun to_s do return "listing" + redef fun error_msg do return "Eof" + redef fun action(parser) do + parser.peek_token.action_slisting(parser) + end +end +# State line+ +private class LRStateline_43d + super LRState + redef fun to_s do return "line+" + redef fun error_msg do return "label_decl, line, instruction, directive" + redef fun action(parser) do + parser.peek_token.action_sline_43d(parser) + end + redef fun goto(parser, goto) do + goto.goto_sline_43d(parser) + end +end +# State line +private class LRStateline + super LRState + redef fun to_s do return "line" + redef fun error_msg do return "" + redef fun action(parser) do + # REDUCE line+::line+_one=line + var n0 = parser.pop.as(Nline) + var prod = new Nodes[Nline] + prod.items.add(n0) + parser.node_stack.push prod + parser.goto(goto_Nline_43d) + end +end +# State label_decl +private class LRStatelabel_decl + super LRState + redef fun to_s do return "label_decl" + redef fun error_msg do return "instruction, directive" + redef fun action(parser) do + parser.peek_token.action_slabel_decl(parser) + end + redef fun goto(parser, goto) do + goto.goto_slabel_decl(parser) + end +end +# State id +private class LRStateid + super LRState + redef fun to_s do return "id" + redef fun error_msg do return "operand, value" + redef fun action(parser) do + parser.peek_token.action_sid(parser) + end + redef fun goto(parser, goto) do + goto.goto_sid(parser) + end +end +# State comment +private class LRStatecomment + super LRState + redef fun to_s do return "comment" + redef fun error_msg do return "eol" + redef fun action(parser) do + parser.peek_token.action_scomment(parser) + end +end +# State eol +private class LRStateeol + super LRState + redef fun to_s do return "eol" + redef fun error_msg do return "" + redef fun action(parser) do + # REDUCE line::line_empty_3=eol + var n0 = parser.pop.as(Neol) + var p1 = new Nline_empty(null, null, n0) + var prod = p1 + parser.node_stack.push prod + parser.goto(goto_Nline) + end +end +# State instruction +private class LRStateinstruction + super LRState + redef fun to_s do return "instruction" + redef fun error_msg do return "comment, eol" + redef fun action(parser) do + parser.peek_token.action_sinstruction(parser) + end +end +# State directive +private class LRStatedirective + super LRState + redef fun to_s do return "directive" + redef fun error_msg do return "comment, eol" + redef fun action(parser) do + parser.peek_token.action_sdirective(parser) + end +end +# State tk_byte +private class LRStatetk_byte + super LRState + redef fun to_s do return "tk_byte" + redef fun error_msg do return "value" + redef fun action(parser) do + parser.peek_token.action_stk_byte(parser) + end + redef fun goto(parser, goto) do + parser.push(state_tk_byte_32dvalue) + end +end +# State tk_word +private class LRStatetk_word + super LRState + redef fun to_s do return "tk_word" + redef fun error_msg do return "value" + redef fun action(parser) do + parser.peek_token.action_stk_word(parser) + end + redef fun goto(parser, goto) do + parser.push(state_tk_word_32dvalue) + end +end +# State tk_block +private class LRStatetk_block + super LRState + redef fun to_s do return "tk_block" + redef fun error_msg do return "value" + redef fun action(parser) do + parser.peek_token.action_stk_block(parser) + end + redef fun goto(parser, goto) do + parser.push(state_tk_block_32dvalue) + end +end +# State tk_ascii +private class LRStatetk_ascii + super LRState + redef fun to_s do return "tk_ascii" + redef fun error_msg do return "value" + redef fun action(parser) do + parser.peek_token.action_stk_ascii(parser) + end + redef fun goto(parser, goto) do + parser.push(state_tk_ascii_32dvalue) + end +end +# State tk_addrss +private class LRStatetk_addrss + super LRState + redef fun to_s do return "tk_addrss" + redef fun error_msg do return "value" + redef fun action(parser) do + parser.peek_token.action_stk_addrss(parser) + end + redef fun goto(parser, goto) do + parser.push(state_tk_addrss_32dvalue) + end +end +# State tk_equate +private class LRStatetk_equate + super LRState + redef fun to_s do return "tk_equate" + redef fun error_msg do return "value" + redef fun action(parser) do + parser.peek_token.action_stk_equate(parser) + end + redef fun goto(parser, goto) do + parser.push(state_tk_equate_32dvalue) + end +end +# State tk_burn +private class LRStatetk_burn + super LRState + redef fun to_s do return "tk_burn" + redef fun error_msg do return "value" + redef fun action(parser) do + parser.peek_token.action_stk_burn(parser) + end + redef fun goto(parser, goto) do + parser.push(state_tk_burn_32dvalue) + end +end +# State end_block +private class LRStateend_block + super LRState + redef fun to_s do return "end_block" + redef fun error_msg do return "" + redef fun action(parser) do + # REDUCE listing::listing_3=end_block + var n0 = parser.pop.as(Nend_block) + var p1 = new Nlisting(null, null, n0) + var prod = p1 + parser.node_stack.push prod + parser.goto(goto_Nlisting) + end +end +# State listing Eof +private class LRStatelisting_32dEof + super LRState + redef fun to_s do return "listing Eof" + redef fun error_msg do return "" + redef fun action(parser) do + # REDUCE _start::Start=listing Eof + var n1 = parser.pop.as(NEof) + var n0 = parser.pop.as(Nlisting) + var p1 = new NStart(n0, n1) + var prod = p1 + parser.node_stack.push prod + parser.stop = true + end +end +# State line+ label_decl +private class LRStateline_43d_32dlabel_decl + super LRState + redef fun to_s do return "line+ label_decl" + redef fun error_msg do return "instruction, directive" + redef fun action(parser) do + parser.peek_token.action_sline_43d_32dlabel_decl(parser) + end + redef fun goto(parser, goto) do + goto.goto_sline_43d_32dlabel_decl(parser) + end +end +# State line+ line +private class LRStateline_43d_32dline + super LRState + redef fun to_s do return "line+ line" + redef fun error_msg do return "" + redef fun action(parser) do + # REDUCE line+::line+_more=line+ line + var n1 = parser.pop.as(Nline) + var n0 = parser.pop.as(Nodes[Nline]) + var prod = n0 + n0.items.add(n1) + parser.node_stack.push prod + parser.goto(goto_Nline_43d) + end +end +# State line+ end_block +private class LRStateline_43d_32dend_block + super LRState + redef fun to_s do return "line+ end_block" + redef fun error_msg do return "" + redef fun action(parser) do + # REDUCE listing::listing_2=line+ end_block + var n1 = parser.pop.as(Nend_block) + var n0 = parser.pop.as(Nodes[Nline]) + var p1 = new Nlisting(n0, null, n1) + var prod = p1 + parser.node_stack.push prod + parser.goto(goto_Nlisting) + end +end +# State label_decl comment +private class LRStatelabel_decl_32dcomment + super LRState + redef fun to_s do return "label_decl comment" + redef fun error_msg do return "eol" + redef fun action(parser) do + parser.peek_token.action_slabel_decl_32dcomment(parser) + end +end +# State label_decl eol +private class LRStatelabel_decl_32deol + super LRState + redef fun to_s do return "label_decl eol" + redef fun error_msg do return "" + redef fun action(parser) do + # REDUCE line::line_empty_2=label_decl eol + var n1 = parser.pop.as(Neol) + var n0 = parser.pop.as(Nlabel_decl) + var p1 = new Nline_empty(n0, null, n1) + var prod = p1 + parser.node_stack.push prod + parser.goto(goto_Nline) + end +end +# State label_decl instruction +private class LRStatelabel_decl_32dinstruction + super LRState + redef fun to_s do return "label_decl instruction" + redef fun error_msg do return "comment, eol" + redef fun action(parser) do + parser.peek_token.action_slabel_decl_32dinstruction(parser) + end +end +# State label_decl directive +private class LRStatelabel_decl_32ddirective + super LRState + redef fun to_s do return "label_decl directive" + redef fun error_msg do return "comment, eol" + redef fun action(parser) do + parser.peek_token.action_slabel_decl_32ddirective(parser) + end +end +# State label_decl end_block +private class LRStatelabel_decl_32dend_block + super LRState + redef fun to_s do return "label_decl end_block" + redef fun error_msg do return "" + redef fun action(parser) do + # REDUCE listing::listing_1=label_decl end_block + var n1 = parser.pop.as(Nend_block) + var n0 = parser.pop.as(Nlabel_decl) + var p1 = new Nlisting(null, n0, n1) + var prod = p1 + parser.node_stack.push prod + parser.goto(goto_Nlisting) + end +end +# State label_decl id +private class LRStatelabel_decl_32did + super LRState + redef fun to_s do return "label_decl id" + redef fun error_msg do return "operand, value" + redef fun action(parser) do + parser.peek_token.action_slabel_decl_32did(parser) + end + redef fun goto(parser, goto) do + goto.goto_slabel_decl_32did(parser) + end +end +# State id colon +private class LRStateid_32dcolon + super LRState + redef fun to_s do return "id colon" + redef fun error_msg do return "" + redef fun action(parser) do + # REDUCE label_decl::label_decl=id colon + var n1 = parser.pop.as(Ncolon) + var n0 = parser.pop.as(Nid) + var p1 = new Nlabel_decl(n0, n1) + var prod = p1 + parser.node_stack.push prod + parser.goto(goto_Nlabel_decl) + end +end +# State id operand +private class LRStateid_32doperand + super LRState + redef fun to_s do return "id operand" + redef fun error_msg do return "" + redef fun action(parser) do + # REDUCE instruction::instruction_binary=id operand + var n1 = parser.pop.as(Noperand) + var n0 = parser.pop.as(Nid) + var p1 = new Ninstruction_binary(n0, n1) + var prod = p1 + parser.node_stack.push prod + parser.goto(goto_Ninstruction) + end +end +# State id value +private class LRStateid_32dvalue + super LRState + redef fun to_s do return "id value" + redef fun error_msg do return "comma" + redef fun action(parser) do + parser.peek_token.action_sid_32dvalue(parser) + end +end +# State id id +private class LRStateid_32did + super LRState + redef fun to_s do return "id id" + redef fun error_msg do return "" + redef fun action(parser) do + # REDUCE value::value_label=id + var n0 = parser.pop.as(Nid) + var p1 = new Nvalue_label(n0) + var prod = p1 + parser.node_stack.push prod + parser.goto(goto_Nvalue) + end +end +# State id char +private class LRStateid_32dchar + super LRState + redef fun to_s do return "id char" + redef fun error_msg do return "" + redef fun action(parser) do + # REDUCE value::value_char=char + var n0 = parser.pop.as(Nchar) + var p1 = new Nvalue_char(n0) + var prod = p1 + parser.node_stack.push prod + parser.goto(goto_Nvalue) + end +end +# State id string +private class LRStateid_32dstring + super LRState + redef fun to_s do return "id string" + redef fun error_msg do return "" + redef fun action(parser) do + # REDUCE value::value_string=string + var n0 = parser.pop.as(Nstring) + var p1 = new Nvalue_string(n0) + var prod = p1 + parser.node_stack.push prod + parser.goto(goto_Nvalue) + end +end +# State comment eol +private class LRStatecomment_32deol + super LRState + redef fun to_s do return "comment eol" + redef fun error_msg do return "" + redef fun action(parser) do + # REDUCE line::line_empty_1=comment eol + var n1 = parser.pop.as(Neol) + var n0 = parser.pop.as(Ncomment) + var p1 = new Nline_empty(null, n0, n1) + var prod = p1 + parser.node_stack.push prod + parser.goto(goto_Nline) + end +end +# State instruction comment +private class LRStateinstruction_32dcomment + super LRState + redef fun to_s do return "instruction comment" + redef fun error_msg do return "eol" + redef fun action(parser) do + parser.peek_token.action_sinstruction_32dcomment(parser) + end +end +# State instruction eol +private class LRStateinstruction_32deol + super LRState + redef fun to_s do return "instruction eol" + redef fun error_msg do return "" + redef fun action(parser) do + # REDUCE line::line_instruction_3=instruction eol + var n1 = parser.pop.as(Neol) + var n0 = parser.pop.as(Ninstruction) + var p1 = new Nline_instruction(null, n0, null, n1) + var prod = p1 + parser.node_stack.push prod + parser.goto(goto_Nline) + end +end +# State directive comment +private class LRStatedirective_32dcomment + super LRState + redef fun to_s do return "directive comment" + redef fun error_msg do return "eol" + redef fun action(parser) do + parser.peek_token.action_sdirective_32dcomment(parser) + end +end +# State directive eol +private class LRStatedirective_32deol + super LRState + redef fun to_s do return "directive eol" + redef fun error_msg do return "" + redef fun action(parser) do + # REDUCE line::line_directive_3=directive eol + var n1 = parser.pop.as(Neol) + var n0 = parser.pop.as(Ndirective) + var p1 = new Nline_directive(null, n0, null, n1) + var prod = p1 + parser.node_stack.push prod + parser.goto(goto_Nline) + end +end +# State tk_byte value +private class LRStatetk_byte_32dvalue + super LRState + redef fun to_s do return "tk_byte value" + redef fun error_msg do return "" + redef fun action(parser) do + # REDUCE directive::directive_byte=tk_byte value + var n1 = parser.pop.as(Nvalue) + var n0 = parser.pop.as(Ntk_byte) + var p1 = new Ndirective_byte(n0, n1) + var prod = p1 + parser.node_stack.push prod + parser.goto(goto_Ndirective) + end +end +# State tk_word value +private class LRStatetk_word_32dvalue + super LRState + redef fun to_s do return "tk_word value" + redef fun error_msg do return "" + redef fun action(parser) do + # REDUCE directive::directive_word=tk_word value + var n1 = parser.pop.as(Nvalue) + var n0 = parser.pop.as(Ntk_word) + var p1 = new Ndirective_word(n0, n1) + var prod = p1 + parser.node_stack.push prod + parser.goto(goto_Ndirective) + end +end +# State tk_block value +private class LRStatetk_block_32dvalue + super LRState + redef fun to_s do return "tk_block value" + redef fun error_msg do return "" + redef fun action(parser) do + # REDUCE directive::directive_block=tk_block value + var n1 = parser.pop.as(Nvalue) + var n0 = parser.pop.as(Ntk_block) + var p1 = new Ndirective_block(n0, n1) + var prod = p1 + parser.node_stack.push prod + parser.goto(goto_Ndirective) + end +end +# State tk_ascii value +private class LRStatetk_ascii_32dvalue + super LRState + redef fun to_s do return "tk_ascii value" + redef fun error_msg do return "" + redef fun action(parser) do + # REDUCE directive::directive_ascii=tk_ascii value + var n1 = parser.pop.as(Nvalue) + var n0 = parser.pop.as(Ntk_ascii) + var p1 = new Ndirective_ascii(n0, n1) + var prod = p1 + parser.node_stack.push prod + parser.goto(goto_Ndirective) + end +end +# State tk_addrss value +private class LRStatetk_addrss_32dvalue + super LRState + redef fun to_s do return "tk_addrss value" + redef fun error_msg do return "" + redef fun action(parser) do + # REDUCE directive::directive_addrss=tk_addrss value + var n1 = parser.pop.as(Nvalue) + var n0 = parser.pop.as(Ntk_addrss) + var p1 = new Ndirective_addrss(n0, n1) + var prod = p1 + parser.node_stack.push prod + parser.goto(goto_Ndirective) + end +end +# State tk_equate value +private class LRStatetk_equate_32dvalue + super LRState + redef fun to_s do return "tk_equate value" + redef fun error_msg do return "" + redef fun action(parser) do + # REDUCE directive::directive_equate=tk_equate value + var n1 = parser.pop.as(Nvalue) + var n0 = parser.pop.as(Ntk_equate) + var p1 = new Ndirective_equate(n0, n1) + var prod = p1 + parser.node_stack.push prod + parser.goto(goto_Ndirective) + end +end +# State tk_burn value +private class LRStatetk_burn_32dvalue + super LRState + redef fun to_s do return "tk_burn value" + redef fun error_msg do return "" + redef fun action(parser) do + # REDUCE directive::directive_burn=tk_burn value + var n1 = parser.pop.as(Nvalue) + var n0 = parser.pop.as(Ntk_burn) + var p1 = new Ndirective_burn(n0, n1) + var prod = p1 + parser.node_stack.push prod + parser.goto(goto_Ndirective) + end +end +# State line+ label_decl end_block +private class LRStateline_43d_32dlabel_decl_32dend_block + super LRState + redef fun to_s do return "line+ label_decl end_block" + redef fun error_msg do return "" + redef fun action(parser) do + # REDUCE listing::listing_0=line+ label_decl end_block + var n2 = parser.pop.as(Nend_block) + var n1 = parser.pop.as(Nlabel_decl) + var n0 = parser.pop.as(Nodes[Nline]) + var p1 = new Nlisting(n0, n1, n2) + var prod = p1 + parser.node_stack.push prod + parser.goto(goto_Nlisting) + end +end +# State label_decl comment eol +private class LRStatelabel_decl_32dcomment_32deol + super LRState + redef fun to_s do return "label_decl comment eol" + redef fun error_msg do return "" + redef fun action(parser) do + # REDUCE line::line_empty_0=label_decl comment eol + var n2 = parser.pop.as(Neol) + var n1 = parser.pop.as(Ncomment) + var n0 = parser.pop.as(Nlabel_decl) + var p1 = new Nline_empty(n0, n1, n2) + var prod = p1 + parser.node_stack.push prod + parser.goto(goto_Nline) + end +end +# State label_decl instruction comment +private class LRStatelabel_decl_32dinstruction_32dcomment + super LRState + redef fun to_s do return "label_decl instruction comment" + redef fun error_msg do return "eol" + redef fun action(parser) do + parser.peek_token.action_slabel_decl_32dinstruction_32dcomment(parser) + end +end +# State label_decl instruction eol +private class LRStatelabel_decl_32dinstruction_32deol + super LRState + redef fun to_s do return "label_decl instruction eol" + redef fun error_msg do return "" + redef fun action(parser) do + # REDUCE line::line_instruction_2=label_decl instruction eol + var n2 = parser.pop.as(Neol) + var n1 = parser.pop.as(Ninstruction) + var n0 = parser.pop.as(Nlabel_decl) + var p1 = new Nline_instruction(n0, n1, null, n2) + var prod = p1 + parser.node_stack.push prod + parser.goto(goto_Nline) + end +end +# State label_decl directive comment +private class LRStatelabel_decl_32ddirective_32dcomment + super LRState + redef fun to_s do return "label_decl directive comment" + redef fun error_msg do return "eol" + redef fun action(parser) do + parser.peek_token.action_slabel_decl_32ddirective_32dcomment(parser) + end +end +# State label_decl directive eol +private class LRStatelabel_decl_32ddirective_32deol + super LRState + redef fun to_s do return "label_decl directive eol" + redef fun error_msg do return "" + redef fun action(parser) do + # REDUCE line::line_directive_2=label_decl directive eol + var n2 = parser.pop.as(Neol) + var n1 = parser.pop.as(Ndirective) + var n0 = parser.pop.as(Nlabel_decl) + var p1 = new Nline_directive(n0, n1, null, n2) + var prod = p1 + parser.node_stack.push prod + parser.goto(goto_Nline) + end +end +# State id value comma +private class LRStateid_32dvalue_32dcomma + super LRState + redef fun to_s do return "id value comma" + redef fun error_msg do return "id" + redef fun action(parser) do + parser.peek_token.action_sid_32dvalue_32dcomma(parser) + end +end +# State instruction comment eol +private class LRStateinstruction_32dcomment_32deol + super LRState + redef fun to_s do return "instruction comment eol" + redef fun error_msg do return "" + redef fun action(parser) do + # REDUCE line::line_instruction_1=instruction comment eol + var n2 = parser.pop.as(Neol) + var n1 = parser.pop.as(Ncomment) + var n0 = parser.pop.as(Ninstruction) + var p1 = new Nline_instruction(null, n0, n1, n2) + var prod = p1 + parser.node_stack.push prod + parser.goto(goto_Nline) + end +end +# State directive comment eol +private class LRStatedirective_32dcomment_32deol + super LRState + redef fun to_s do return "directive comment eol" + redef fun error_msg do return "" + redef fun action(parser) do + # REDUCE line::line_directive_1=directive comment eol + var n2 = parser.pop.as(Neol) + var n1 = parser.pop.as(Ncomment) + var n0 = parser.pop.as(Ndirective) + var p1 = new Nline_directive(null, n0, n1, n2) + var prod = p1 + parser.node_stack.push prod + parser.goto(goto_Nline) + end +end +# State label_decl instruction comment eol +private class LRStatelabel_decl_32dinstruction_32dcomment_32deol + super LRState + redef fun to_s do return "label_decl instruction comment eol" + redef fun error_msg do return "" + redef fun action(parser) do + # REDUCE line::line_instruction_0=label_decl instruction comment eol + var n3 = parser.pop.as(Neol) + var n2 = parser.pop.as(Ncomment) + var n1 = parser.pop.as(Ninstruction) + var n0 = parser.pop.as(Nlabel_decl) + var p1 = new Nline_instruction(n0, n1, n2, n3) + var prod = p1 + parser.node_stack.push prod + parser.goto(goto_Nline) + end +end +# State label_decl directive comment eol +private class LRStatelabel_decl_32ddirective_32dcomment_32deol + super LRState + redef fun to_s do return "label_decl directive comment eol" + redef fun error_msg do return "" + redef fun action(parser) do + # REDUCE line::line_directive_0=label_decl directive comment eol + var n3 = parser.pop.as(Neol) + var n2 = parser.pop.as(Ncomment) + var n1 = parser.pop.as(Ndirective) + var n0 = parser.pop.as(Nlabel_decl) + var p1 = new Nline_directive(n0, n1, n2, n3) + var prod = p1 + parser.node_stack.push prod + parser.goto(goto_Nline) + end +end +# State id value comma id +private class LRStateid_32dvalue_32dcomma_32did + super LRState + redef fun to_s do return "id value comma id" + redef fun error_msg do return "" + redef fun action(parser) do + # REDUCE operand::operand_any=value comma id + var n2 = parser.pop.as(Nid) + var n1 = parser.pop.as(Ncomma) + var n0 = parser.pop.as(Nvalue) + var p1 = new Noperand_any(n0, n1, n2) + var prod = p1 + parser.node_stack.push prod + parser.goto(goto_Noperand) + end +end diff --git a/contrib/pep8analysis/src/parser/pep8_test_parser.nit b/contrib/pep8analysis/src/parser/pep8_test_parser.nit new file mode 100644 index 0000000..9f015d0 --- /dev/null +++ b/contrib/pep8analysis/src/parser/pep8_test_parser.nit @@ -0,0 +1,12 @@ +# Generated by nitcc for the language pep8 +import nitcc_runtime +import pep8_lexer +import pep8_parser +class MyTest + super TestParser + redef fun name do return "pep8" + redef fun new_lexer(text) do return new MyLexer(text) + redef fun new_parser do return new MyParser +end +var t = new MyTest +t.main diff --git a/contrib/pep8analysis/src/parser/prescc.pl b/contrib/pep8analysis/src/parser/prescc.pl new file mode 100755 index 0000000..debd2f8 --- /dev/null +++ b/contrib/pep8analysis/src/parser/prescc.pl @@ -0,0 +1,132 @@ +#!/usr/bin/perl -w +# This file is part of NIT ( http://www.nitlanguage.org ). +# +# Copyright 2009 Jean Privat +# Copyright 2009 Jean-Sebastien Gelinas +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# prescc, a Sablecc preprocessor. +# +# Synopsis +# +# Extends a sablecc grammar with parametrized productions and other syntactic stuff. +# +# Description +# +# A production named foo~bar~baz semantically correspond to a production foo with two boolean parameters bar and baz +# In fact foo is a family of 4 distinct productions: foo, foo_bar, foo_baz and foo_bar_baz +# In a parametrized production with a parameter ~xxx: +# * parameters (~xxx) are substituted with _xxx if the parameter is true and removed if the parameter is false +# * guarded alternatives (!xxx) are disabled if the parameter is true +# +# Limitations +# +# prescc is badly implemented in perl and is not robust. +# Users must remember the following: +# * parametrized productions MUST be terminated with a line containing only a single semicolon (;) +# * parameters (~) and guards (!) in alternatives MUST correspond to a parameter of the enclosing production +# * if required, names in transformations MUST contain the full invocation name (with all parameters) +# foo bar_x~y~z_t baz {-> New p(foo, bar_x~y~z_t.q)} +# * guards do not understand grammar, they just remove the whole line +# * The AST MUST start with a line containing only "Abstract Syntax Tree" +# +# Example of the dangling else implementation: +# +# stmt~withelse = +# 'if' expr 'then' stmt_withelse 'else' stmt~withelse | +# !withelse 'if' expr 'then' stmt | +# nop +# ; + +while (<>) { + push @lines, $_; +} +$lines = join "", @lines; + +$current = ""; +for (@lines) { + if (/^.*{\s*->\s*(\w+)\s*}/) { + $current = $1; + } + $current = "" if /;/; + next if ($current eq ""); + if (s/{\:(\w+)}/{$1}/) { + $alt = $1; + @newargs = (); + while (/((\[(\w*)\])?:)?([\w~]+)(})?/g) { + $id=defined $3?$3:$4; + next if ((defined $1) && !(defined $3)); + next if (defined $5); + $4 =~ /([a-z]+)/; + $argalt = $1; + if ($id eq $argalt) { + push @newargs, "$id"; + } else { + push @newargs, "$id.$argalt"; + } + } + chomp; + $_ .= " {-> New $current.$alt(". join(", ", @newargs) .")}\n"; + s/([^\]])\:(\w+)/$1$2/g; + } +} + +# List all the available parameters in the extended grammar +@params = (); +while ($lines =~ /\~([a-zA-Z]+)/g) { + if (!$found{$1}) { + push @params, $1; + $found{$1}=1; + } +} + +$ast = "Abstract Syntax Tree"; +@res = (); +for $token (@params) { + print STDERR "Parameter ~$token\n"; + #push @res, "//Start part $token\n"; +# first, sed starts from first line to the AST line and removes ~xxx and !xxx + for $l (@lines) { + $_ = $l; + last if (/^$ast/); + s/[~!]$token//g; + push @res, $_; + } + #push @res, "//Generated part $token\n"; + # second, sed clones ~xxx parametrized productions, substitute ~xxx with _xxx and delete !xxx lines + $into = 0; + for $l (@lines) { + $_ = $l; + $into = 1 if (/~$token/); + next if (!$into); + s/~$token/_$token/g; + next if /!$token/; + push @res, $_; + $into = 0 if (/;/); + } + #push @res, "//End of generated part $token\n"; + + # third, sed continues fron AST line to last line and remove ~xxx and !xxx + $into = 0; + for (@lines) { + $into = 1 if (/^$ast/); + next if (!$into); + push @res, $_; + } + #push @res, "//End part $token\n"; + @lines = @res; + @res = (); +} +print "/* This file is autogenerated, do not modify it */"; +print (join "", @lines); diff --git a/contrib/pep8analysis/src/parser/prescc.sh b/contrib/pep8analysis/src/parser/prescc.sh new file mode 100755 index 0000000..e5ab277 --- /dev/null +++ b/contrib/pep8analysis/src/parser/prescc.sh @@ -0,0 +1,94 @@ +# This file is part of NIT ( http://www.nitlanguage.org ). +# +# Copyright 2009 Jean Privat +# Copyright 2009 Jean-Sebastien Gelinas +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# prescc, a Sablecc preprocessor. +# +# Synopsis +# +# Extends a sablecc grammar with parametrized productions. +# +# Description +# +# A production named foo~bar~baz semantically correspond to a production foo with two boolean parameters bar and baz +# In fact foo is a family of 4 distinct productions: foo, foo_bar, foo_baz and foo_bar_baz +# In a parametrized production with a parameter ~xxx: +# * parameters (~xxx) are substituted with _xxx if the parameter is true and removed if the parameter is false +# * guarded alternatives (!xxx) are disabled if the parameter is true +# +# Limitations +# +# prescc is badly implemented with shell, sed and perl and is not robust. +# Users must remember the following: +# * parametrized productions MUST be terminated with a line containing only a single semicolon (;) +# * parameters (~) and guards (!) in alternatives MUST correspond to a parameter of the enclosing production +# * if required, names in transformations MUST contain the full invocation name (with all parameters) +# foo bar_x~y~z_t baz {-> New p(foo, bar_x~y~z_t.q)} +# * guards do not understand grammar, they just remove the whole line +# * The AST MUST start with a line containing only "Abstract Syntax Tree" +# +# Example of the dangling else implementation: +# +# stmt~withelse = +# 'if' expr 'then' stmt_withelse 'else' stmt~withelse | +# !withelse 'if' expr 'then' stmt | +# nop +# ; + + +case $# in + 2);; + *) echo "Usage: prescc infile outfile"; exit +esac + + +infile=$1 +outfile=$2 +tmpfile=`mktemp "$2.XXXXXX"` + +printf "/* This file is autogenerated, do not modify it */" > "$outfile" +cat "$infile" >> "$outfile" + +# The perl code is used to list all the available parameters in the extended grammar +for token in `perl -ne 'while (/\~([a-zA-Z]+)/g) {if (!$found{$1}) {print "$1\n"; $found{$1}=1}}' "$infile"` +do + echo "Parameter ~$token" + # first, sed starts from first line to the AST line and removes ~xxx and !xxx + sed -n -e " + 1,/^Abstract Syntax Tree/{ + /^Abstract Syntax Tree/b + s/[\~!]$token//g + p + } + " "$outfile" > "$tmpfile" + # second, sed clones ~xxx parametrized productions, substitute ~xxx with _xxx and delete !xxx lines + sed -n -e " + /\~$token/,/;/{ + s/\~$token/_$token/g + /!$token/d + p + } + " "$outfile" >> "$tmpfile" + # third, sed continues fron AST line to last line and remove ~xxx and !xxx + sed -n -e " + /^Abstract Syntax Tree/,\${ + s/[\~!]$token//g + p + } + " "$outfile" >> "$tmpfile" + mv "$tmpfile" "$outfile" +done + diff --git a/contrib/pep8analysis/src/parser/tables.nit b/contrib/pep8analysis/src/parser/tables.nit new file mode 100644 index 0000000..54b7b59 --- /dev/null +++ b/contrib/pep8analysis/src/parser/tables.nit @@ -0,0 +1,34 @@ +# This file is part of NIT ( http://www.nitlanguage.org ). +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# Module that interfaces the parsing tables. +module tables + +# Interface allowing the acces of the tables used during the parsing. +interface TablesCapable + # The goto value of the lexer at row i, column j-1 + # Note that the length of the row r is stored at (r, 0) + fun lexer_goto(i, j: Int): Int is extern "lexer_goto" + + # The accept value of the lexer at i + fun lexer_accept(i: Int): Int is extern "lexer_accept" + + # The goto value of the parser at row i, column j-1 + # Note that the length of the row r is stored at (r, 0) + fun parser_goto(i, j: Int): Int is extern "parser_goto" + + # The action value of the parser at row i, column j-1 + # Note that the length of the row r is stored at (r, 0) + fun parser_action(i, j: Int): Int is extern "parser_action" +end diff --git a/contrib/pep8analysis/src/parser/xss/lexer.xss b/contrib/pep8analysis/src/parser/xss/lexer.xss new file mode 100644 index 0000000..6a4d1d0 --- /dev/null +++ b/contrib/pep8analysis/src/parser/xss/lexer.xss @@ -0,0 +1,252 @@ +$ // This file is part of NIT ( http://www.nitlanguage.org ). +$ // +$ // Copyright 2008 Jean Privat +$ // Based on algorithms developped for ( http://www.sablecc.org/ ). +$ // +$ // Licensed under the Apache License, Version 2.0 (the "License"); +$ // you may not use this file except in compliance with the License. +$ // You may obtain a copy of the License at +$ // +$ // http://www.apache.org/licenses/LICENSE-2.0 +$ // +$ // Unless required by applicable law or agreed to in writing, software +$ // distributed under the License is distributed on an "AS IS" BASIS, +$ // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +$ // See the License for the specific language governing permissions and +$ // limitations under the License. + +$ template make_lexer() + +# The lexer extract NIT tokens from an input stream. +# It is better user with the Parser +class Lexer + super TablesCapable + # Last peeked token + var _token: nullable Token + + # Lexer current state + var _state: Int = 0 + + # The source file + readable var _file: SourceFile + + # Current character in the stream + var _stream_pos: Int = 0 + + # Current line number in the input stream + var _line: Int = 0 + + # Current column in the input stream + var _pos: Int = 0 + + # Was the last character a cariage-return? + var _cr: Bool = false + +$ foreach {lexer_data/state} + # Constante state values + private fun state_${translate(@name,"ABCDEFGHIJKLMNOPQRSTUVWXYZ","abcdefghijklmnopqrstuvwxyz")}: Int do return @id end +$ end foreach + + # Create a new lexer for a stream (and a name) + init(file: SourceFile) + do + _file = file + end + + # The last peeked token to chain them + private var last_token: nullable Token = null + + # Give the next token (but do not consume it) + fun peek: Token + do + var t = _token + if t != null then return t + + t = get_token + while t == null do t = get_token + + var l = last_token + if l != null then + l.next_token = t + t.prev_token = l + end + + last_token = t + _token = t + return t + end + + # Give and consume the next token + fun next: Token + do + var result = peek + _token = null + return result + end + + # Primitive method to return a token, or return null if it is discarded + # Is used to implement `peek` and `next` + protected fun get_token: nullable Token + do + var dfa_state = 0 + + var sp = _stream_pos + var start_stream_pos = sp + var start_pos = _pos + var start_line = _line + var string = _file.string + var string_len = string.length + + var accept_state = -1 + var accept_token = -1 + var accept_length = -1 + var accept_pos = -1 + var accept_line = -1 + + loop + if sp >= string_len then + dfa_state = -1 + else + var c = string[sp].ascii + sp += 1 + + var cr = _cr + var line = _line + var pos = _pos + if c == 10 then + if cr then + cr = false + _file.line_starts[line] = sp + else + line = line + 1 + pos = 0 + _file.line_starts[line] = sp + end + else if c == 13 then + line = line + 1 + pos = 0 + cr = true + _file.line_starts[line] = sp + else + pos = pos + 1 + cr = false + end + + loop + var old_state = dfa_state + if dfa_state < -1 then + old_state = -2 - dfa_state + end + + dfa_state = -1 + + var low = 0 + var high = lexer_goto(old_state, 0) - 1 + + if high >= 0 then + while low <= high do + var middle = (low + high) / 2 + var offset = middle * 3 + 1 # +1 because length is at 0 + + if c < lexer_goto(old_state, offset) then + high = middle - 1 + else if c > lexer_goto(old_state, offset+1) then + low = middle + 1 + else + dfa_state = lexer_goto(old_state, offset+2) + break + end + end + end + if dfa_state > -2 then break + end + + _cr = cr + _line = line + _pos = pos + end + + if dfa_state >= 0 then + var tok = lexer_accept(dfa_state) + if tok != -1 then + accept_state = dfa_state + accept_token = tok + accept_length = sp - start_stream_pos + accept_pos = _pos + accept_line = _line + end + else + if accept_state != -1 then + var location = new Location(_file, start_line + 1, accept_line + 1, start_pos + 1, accept_pos) + _pos = accept_pos + _line = accept_line + _stream_pos = start_stream_pos + accept_length +$ foreach {//token} + if accept_token == ${position()-1} then +$ if {count(transition[@from!=@to])!=0} + var state_id = _state +$ foreach transition in {transition[@from!=@to]} + if state_id == ${/parser/lexer_data/state[@name=$transition/@from]/@id} then + _state = state_${translate(@to,"ABCDEFGHIJKLMNOPQRSTUVWXYZ","abcdefghijklmnopqrstuvwxyz")} + end +$ end +$ end if +$ if {@parser_index} + return new @ename.init_tk(location) +$ else + return null +$ end + end +$ end foreach + else + _stream_pos = sp + var location = new Location(_file, start_line + 1, start_line + 1, start_pos + 1, start_pos + 1) + if sp > start_stream_pos then + var text = string.substring(start_stream_pos, sp-start_stream_pos) + var token = new PLexerError.init_lexer_error("Syntax error: unknown token {text}.", location, text) + return token + else + var token = new EOF.init_tk(location) + return token + end + end + end + end + end +end + +$ end template + + + +$ template make_lexer_table() +$ foreach {lexer_data/goto_table/state} +$ foreach {row} +$ if {count(goto)!=0} +static const int lexer_goto_row${position()}[] = { + ${count(goto)}, +$ foreach {goto} + @low, @high, @state[-sep ','-] +$ end foreach +}; +$ end +$ end foreach +static const int lexer_goto_row_null[] = {0}; +const int* const lexer_goto_table[] = { +$ foreach {row} +$ if {count(goto)!=0} + lexer_goto_row${position()}[-sep ','-] +$ else + lexer_goto_row_null[-sep ','-] +$ end +$ end foreach +}; +$ end foreach + +$ foreach {lexer_data/accept_table/state} +const int lexer_accept_table[] = { + [-foreach {i}-]${.}[-sep ','-][-end foreach-] +}; +$ end foreach + +$ end template diff --git a/contrib/pep8analysis/src/parser/xss/main.xss b/contrib/pep8analysis/src/parser/xss/main.xss new file mode 100644 index 0000000..db69a01 --- /dev/null +++ b/contrib/pep8analysis/src/parser/xss/main.xss @@ -0,0 +1,82 @@ +$ // This file is part of NIT ( http://www.nitlanguage.org ). +$ // +$ // Copyright 2008 Jean Privat +$ // Based on algorithms developped for ( http://www.sablecc.org/ ). +$ // +$ // Licensed under the Apache License, Version 2.0 (the "License"); +$ // you may not use this file except in compliance with the License. +$ // You may obtain a copy of the License at +$ // +$ // http://www.apache.org/licenses/LICENSE-2.0 +$ // +$ // Unless required by applicable law or agreed to in writing, software +$ // distributed under the License is distributed on an "AS IS" BASIS, +$ // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +$ // See the License for the specific language governing permissions and +$ // limitations under the License. + +$ include 'lexer.xss' +$ include 'parser.xss' +$ include 'tokens.xss' +$ include 'prods.xss' + +$ output 'parser_abs.nit' +# Raw AST node hierarchy. +# This file was generated by SableCC (http://www.sablecc.org/). +module parser_abs + +import location + +$ call make_abs_tokens() +$ call make_abs_prods() +$ end output + +$ output 'lexer.nit' +# Lexer and its tokens. +# This file was generated by SableCC (http://www.sablecc.org/). +module lexer + +$ if $usermodule +intrude import $usermodule +$ else +intrude import parser_abs +$ end +private import tables +$ call make_tokens() +$ call make_lexer() +$ end output + +$ output 'parser_prod.nit' +# Production AST nodes full definition. +# This file was generated by SableCC (http://www.sablecc.org/). +module parser_prod + +import lexer +$ if $usermodule +intrude import $usermodule +$ else +intrude import parser_abs +$ end +private import tables + +$ call make_prods() +$ end output + +$ output 'parser.nit' +# Parser. +# This file was generated by SableCC (http://www.sablecc.org/). +module parser + +intrude import parser_prod +import tables +$ call make_parser() +$ end output + +$ output 'tables_nit.c' +/* This file was generated by SableCC (http://www.sablecc.org/). */ +#include +#include "tables_nit.h" + +$ call make_lexer_table() +$ call make_parser_table() +$ end output diff --git a/contrib/pep8analysis/src/parser/xss/parser.xss b/contrib/pep8analysis/src/parser/xss/parser.xss new file mode 100644 index 0000000..7e24374 --- /dev/null +++ b/contrib/pep8analysis/src/parser/xss/parser.xss @@ -0,0 +1,353 @@ +$ // This file is part of NIT ( http://www.nitlanguage.org ). +$ // +$ // Copyright 2008 Jean Privat +$ // Based on algorithms developped for ( http://www.sablecc.org/ ). +$ // +$ // Licensed under the Apache License, Version 2.0 (the "License"); +$ // you may not use this file except in compliance with the License. +$ // You may obtain a copy of the License at +$ // +$ // http://www.apache.org/licenses/LICENSE-2.0 +$ // +$ // Unless required by applicable law or agreed to in writing, software +$ // distributed under the License is distributed on an "AS IS" BASIS, +$ // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +$ // See the License for the specific language governing permissions and +$ // limitations under the License. + +$ template make_parser() + +# State of the parser automata as stored in the parser stack. +private class State + # The internal state number + readable writable var _state: Int + + # The node stored with the state in the stack + readable writable var _nodes: nullable Object + + init(state: Int, nodes: nullable Object) + do + _state = state + _nodes = nodes + end +end + +class Parser + super TablesCapable + # Associated lexer + var _lexer: Lexer + + # Stack of pushed states and productions + var _stack: Array[State] + + # Position in the stack + var _stack_pos: Int + + # Create a new parser based on a given lexer + init(lexer: Lexer) + do + _lexer = lexer + _stack = new Array[State] + _stack_pos = -1 + build_reduce_table + end + + # Do a transition in the automata + private fun go_to(index: Int): Int + do + var state = state + var low = 1 + var high = parser_goto(index, 0) - 1 + + while low <= high do + var middle = (low + high) / 2 + var subindex = middle * 2 + 1 # +1 because parser_goto(index, 0) is the length + + var goal = parser_goto(index, subindex) + if state < goal then + high = middle - 1 + else if state > goal then + low = middle + 1 + else + return parser_goto(index, subindex+1) + end + end + + return parser_goto(index, 2) # Default value + end + + # Push someting in the state stack + private fun push(numstate: Int, list_node: nullable Object) + do + var pos = _stack_pos + 1 + _stack_pos = pos + if pos < _stack.length then + var state = _stack[pos] + state.state = numstate + state.nodes = list_node + else + _stack.push(new State(numstate, list_node)) + end + end + + # The current state + private fun state: Int + do + return _stack[_stack_pos].state + end + + # Pop something from the stack state + private fun pop: nullable Object + do + var res = _stack[_stack_pos].nodes + _stack_pos = _stack_pos -1 + return res + end + + # Build and return a full AST. + fun parse: Start + do + push(0, null) + + var lexer = _lexer + loop + var token = lexer.peek + if token isa PError then + return new Start(null, token) + end + + var state = self.state + var index = token.parser_index + var action_type = parser_action(state, 2) + var action_value = parser_action(state, 3) + + var low = 1 + var high = parser_action(state, 0) - 1 + + while low <= high do + var middle = (low + high) / 2 + var subindex = middle * 3 + 1 # +1 because parser_action(state, 0) is the length + + var goal = parser_action(state, subindex) + if index < goal then + high = middle - 1 + else if index > goal then + low = middle + 1 + else + action_type = parser_action(state, subindex+1) + action_value = parser_action(state, subindex+2) + break + end + end + + if action_type == 0 then # SHIFT + push(action_value, lexer.next) + else if action_type == 1 then # REDUCE + _reduce_table[action_value].action(self) + else if action_type == 2 then # ACCEPT + var node2 = lexer.next + assert node2 isa EOF + var node1 = pop + assert node1 isa ${/parser/prods/prod/@ename} + var node = new Start(node1, node2) + (new ComputeProdLocationVisitor).enter_visit(node) + return node + else if action_type == 3 then # ERROR + var node2 = new PParserError.init_parser_error("Syntax error: unexpected {token}.", token.location, token) + var node = new Start(null, node2) + return node + end + end + end + + var _reduce_table: Array[ReduceAction] + private fun build_reduce_table + do + _reduce_table = new Array[ReduceAction].with_items( +$ foreach {rules/rule} + new ReduceAction@index(@leftside)[-sep ','-] +$ end foreach + ) + end +end + +redef class Prod + # Location on the first token after the start of a production + # So outside the production for epilon production + var _first_location: nullable Location +end + +# Find location of production nodes +# Uses existing token locations to infer location of productions. +private class ComputeProdLocationVisitor + super Visitor + # Currenlty visited productions that need a first token + var _need_first_prods: Array[Prod] = new Array[Prod] + + # Already visited epsilon productions that waits something after them + var _need_after_epsilons: Array[Prod] = new Array[Prod] + + # Location of the last visited token in the current production + var _last_location: nullable Location = null + + redef fun visit(n: ANode) + do + if n isa Token then + var loc = n.location + _last_location = loc + + # Add a first token to productions that need one + if not _need_first_prods.is_empty then + for no in _need_first_prods do + no._first_location = loc + end + _need_first_prods.clear + end + + # Find location for already visited epsilon production that need one + if not _need_after_epsilons.is_empty then + var loco = new Location(loc.file, loc.line_start, loc.line_start, loc.column_start, loc.column_start) + for no in _need_after_epsilons do + no.location = loco + end + _need_after_epsilons.clear + end + else + assert n isa Prod + _need_first_prods.add(n) + + n.visit_all(self) + + var startl = n._first_location + if startl != null then + # Non-epsilon production + var endl = _last_location + assert endl != null + + n.location = new Location(startl.file, startl.line_start, endl.line_end, startl.column_start, endl.column_end) + + if not _need_after_epsilons.is_empty then + var loc = new Location(endl.file, endl.line_end, endl.line_end, endl.column_end, endl.column_end) + for no in _need_after_epsilons do + # Epsilon production that finishes the current non-epsilon production + no.location = loc + end + _need_after_epsilons.clear + end + else + # Epsilon production in the middle or that finishes a parent non-epsilon production + _need_after_epsilons.add(n) + end + end + end + + init do end +end + +# Each reduca action has its own class, this one is the root of the hierarchy. +private abstract class ReduceAction + fun action(p: Parser) is abstract + fun concat(l1, l2 : Array[Object]): Array[Object] + do + if l1.is_empty then return l2 + l1.append(l2) + return l1 + end + var _goto: Int + init(g: Int) do _goto = g +end + +$ foreach {rules/rule} +private class ReduceAction@index + super ReduceAction + redef fun action(p: Parser) + do + var node_list: nullable Object = null +$ foreach {action} +$ choose +$ when {@cmd='POP'} + var ${translate(@result,"ABCDEFGHIJKLMNOPQRSTUVWXYZ","abcdefghijklmnopqrstuvwxyz")} = p.pop +$ end +$ when {@cmd='FETCHLIST'} + var ${translate(@result,"ABCDEFGHIJKLMNOPQRSTUVWXYZ","abcdefghijklmnopqrstuvwxyz")} = ${translate(@from,"ABCDEFGHIJKLMNOPQRSTUVWXYZ","abcdefghijklmnopqrstuvwxyz")} + assert ${translate(@result,"ABCDEFGHIJKLMNOPQRSTUVWXYZ","abcdefghijklmnopqrstuvwxyz")} isa Array[Object] +$ end +$ when {@cmd='FETCHNODE'} + var ${translate(@result,"ABCDEFGHIJKLMNOPQRSTUVWXYZ","abcdefghijklmnopqrstuvwxyz")} = ${translate(@from,"ABCDEFGHIJKLMNOPQRSTUVWXYZ","abcdefghijklmnopqrstuvwxyz")} + assert ${translate(@result,"ABCDEFGHIJKLMNOPQRSTUVWXYZ","abcdefghijklmnopqrstuvwxyz")} isa nullable @etype +$ end +$ when {@cmd='ADDNODE'} + if ${translate(@node,"ABCDEFGHIJKLMNOPQRSTUVWXYZ","abcdefghijklmnopqrstuvwxyz")} != null then + ${translate(@tolist,"ABCDEFGHIJKLMNOPQRSTUVWXYZ","abcdefghijklmnopqrstuvwxyz")}.add(${translate(@node,"ABCDEFGHIJKLMNOPQRSTUVWXYZ","abcdefghijklmnopqrstuvwxyz")}) + end +$ end +$ when {@cmd='ADDLIST'} + ${translate(@tolist,"ABCDEFGHIJKLMNOPQRSTUVWXYZ","abcdefghijklmnopqrstuvwxyz")} = concat(${translate(@tolist,"ABCDEFGHIJKLMNOPQRSTUVWXYZ","abcdefghijklmnopqrstuvwxyz")}, ${translate(@fromlist,"ABCDEFGHIJKLMNOPQRSTUVWXYZ","abcdefghijklmnopqrstuvwxyz")}) +$ end +$ when {@cmd='MAKELIST'} + var ${translate(@result,"ABCDEFGHIJKLMNOPQRSTUVWXYZ","abcdefghijklmnopqrstuvwxyz")} = new Array[Object] +$ end +$ when {@cmd='MAKENODE'} +$ if {count(arg)!=0} + var ${translate(@result,"ABCDEFGHIJKLMNOPQRSTUVWXYZ","abcdefghijklmnopqrstuvwxyz")}: nullable @etype = new @etype.init_${translate(@etype,"ABCDEFGHIJKLMNOPQRSTUVWXYZ","abcdefghijklmnopqrstuvwxyz")}( +$ foreach {arg} +$ if @null + null[-sep ','-] +$ else + ${translate(.,"ABCDEFGHIJKLMNOPQRSTUVWXYZ","abcdefghijklmnopqrstuvwxyz")}[-sep ','-] +$ end +$ end foreach + ) +$ else + var ${translate(@result,"ABCDEFGHIJKLMNOPQRSTUVWXYZ","abcdefghijklmnopqrstuvwxyz")}: nullable @etype = new @etype.init_${translate(@etype,"ABCDEFGHIJKLMNOPQRSTUVWXYZ","abcdefghijklmnopqrstuvwxyz")} +$ end +$ end +$ when {@cmd='RETURNNODE'} +$ if @null + node_list = null +$ else + node_list = ${translate(@node,"ABCDEFGHIJKLMNOPQRSTUVWXYZ","abcdefghijklmnopqrstuvwxyz")} +$ end +$ end +$ when {@cmd='RETURNLIST'} + node_list = ${translate(@list,"ABCDEFGHIJKLMNOPQRSTUVWXYZ","abcdefghijklmnopqrstuvwxyz")} +$ end +$ end choose +$ end foreach + p.push(p.go_to(_goto), node_list) + end +end +$ end foreach +$ end template + +$ template make_parser_table() +$ foreach {parser_data/action_table/row} +static int parser_action_row${position()}[] = { + ${count(action)}, +$ foreach {action} + @from, @action, @to[-sep ','-] +$ end foreach +}; +$ end foreach + +const int* const parser_action_table[] = { +$ foreach {parser_data/action_table/row} + parser_action_row${position()}[-sep ','-] +$ end foreach +}; + +$ foreach {parser_data/goto_table/row} +static int parser_goto_row${position()}[] = { + ${count(goto)}, +$ foreach {goto} + @from, @to[-sep ','-] +$ end foreach +}; +$ end foreach + +const int* const parser_goto_table[] = { +$ foreach {parser_data/goto_table/row} + parser_goto_row${position()}[-sep ','-] +$ end foreach +}; +$ end template diff --git a/contrib/pep8analysis/src/parser/xss/prods.xss b/contrib/pep8analysis/src/parser/xss/prods.xss new file mode 100644 index 0000000..a1d34a1 --- /dev/null +++ b/contrib/pep8analysis/src/parser/xss/prods.xss @@ -0,0 +1,196 @@ +$ // This file is part of NIT ( http://www.nitlanguage.org ). +$ // +$ // Copyright 2008 Jean Privat +$ // Based on algorithms developped for ( http://www.sablecc.org/ ). +$ // +$ // Licensed under the Apache License, Version 2.0 (the "License"); +$ // you may not use this file except in compliance with the License. +$ // You may obtain a copy of the License at +$ // +$ // http://www.apache.org/licenses/LICENSE-2.0 +$ // +$ // Unless required by applicable law or agreed to in writing, software +$ // distributed under the License is distributed on an "AS IS" BASIS, +$ // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +$ // See the License for the specific language governing permissions and +$ // limitations under the License. + +$ template make_abs_prods() +$ set baseprod = {//prod/@ename} + +$ foreach {//prod} +class @ename super Prod end +$ end + +$ foreach {//alt} +class @ename + super ${../@ename} +$ foreach {elem} +$ if @is_list + readable var _n_@name: List[@etype] = new List[@etype] +$ else +$ if @modifier + readable var _n_@name: nullable @etype = null +$ else + readable var _n_@name: @etype +$ end +$ end +$ end +end +$ end + +class Start + super Prod + readable var _n_base: nullable $baseprod + readable var _n_eof: EOF + init( + n_base: nullable $baseprod, + n_eof: EOF) + do + _n_base = n_base + _n_eof = n_eof + end + +end +$ end template + +$ template make_prods() +$ set baseprod = {//prod/@ename} +$ foreach {//alt} +redef class @ename + private init empty_init do end + +$ if {count(elem)!=0} + init init_${translate(@ename,"ABCDEFGHIJKLMNOPQRSTUVWXYZ","abcdefghijklmnopqrstuvwxyz")} ( +$ foreach {elem} +$ if {@is_list} + n_@{name}: Collection[Object][-sep ','-] # Should be Collection[@etype] +$ else + n_@{name}: nullable @etype[-sep ','-] +$ end +$ end + ) +$ else + init init_${translate(@ename,"ABCDEFGHIJKLMNOPQRSTUVWXYZ","abcdefghijklmnopqrstuvwxyz")} +$ end + do + empty_init +$ foreach {elem} +$ if @is_list + for n in n_@{name} do + assert n isa @{etype} + _n_@{name}.add(n) + n.parent = self + end +$ else +$ if {@modifier} + _n_@name = n_@{name} + if n_@{name} != null then + n_@{name}.parent = self + end +$ else + _n_@name = n_@{name}.as(not null) + n_@{name}.parent = self +$ end +$ end +$ end + end + + redef fun replace_child(old_child: PNode, new_child: nullable PNode) + do +$ foreach {elem} +$ if @is_list + for i in [0.._n_@{name}.length[ do + if _n_@{name}[i] == old_child then + if new_child != null then + assert new_child isa @etype + _n_@{name}[i] = new_child + new_child.parent = self + else + _n_@{name}.remove_at(i) + end + return + end + end +$ else + if _n_@{name} == old_child then + if new_child != null then + new_child.parent = self + assert new_child isa @etype + _n_@{name} = new_child + else +$ if @modifier + _n_@{name} = null +$ else + abort +$ end + end + return + end +$ end +$ end foreach + end + +$ foreach {elem} +$ if @is_list +$ else + redef fun n_@{name}=(node) + do + _n_@{name} = node +$ if @modifier + if node != null then + node.parent = self + end +$ else + node.parent = self +$ end + end +$ end +$ end foreach + + + redef fun visit_all(v: Visitor) + do +$ foreach {elem} +$ if @is_list + for n in _n_@{name} do + v.enter_visit(n) + end +$ else +$ if @modifier + if _n_@{name} != null then + v.enter_visit(_n_@{name}.as(not null)) + end +$ else + v.enter_visit(_n_@{name}) +$ end +$ end +$ end foreach + end +end +$ end foreach + +redef class Start + redef fun replace_child(old_child: PNode, new_child: nullable PNode) + do + if _n_base == old_child then + if new_child == null then + else + new_child.parent = self + assert new_child isa $baseprod + _n_base = new_child + end + old_child.parent = null + return + end + end + + redef fun visit_all(v: Visitor) + do + if _n_base != null then + v.enter_visit(_n_base.as(not null)) + end + v.enter_visit(_n_eof) + end +end +$ end template diff --git a/contrib/pep8analysis/src/parser/xss/tokens.xss b/contrib/pep8analysis/src/parser/xss/tokens.xss new file mode 100644 index 0000000..0b84e09 --- /dev/null +++ b/contrib/pep8analysis/src/parser/xss/tokens.xss @@ -0,0 +1,121 @@ +$ // This file is part of NIT ( http://www.nitlanguage.org ). +$ // +$ // Copyright 2008 Jean Privat +$ // Based on algorithms developped for ( http://www.sablecc.org/ ). +$ // +$ // Licensed under the Apache License, Version 2.0 (the "License"); +$ // you may not use this file except in compliance with the License. +$ // You may obtain a copy of the License at +$ // +$ // http://www.apache.org/licenses/LICENSE-2.0 +$ // +$ // Unless required by applicable law or agreed to in writing, software +$ // distributed under the License is distributed on an "AS IS" BASIS, +$ // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +$ // See the License for the specific language governing permissions and +$ // limitations under the License. + +$ template make_abs_tokens() +$ foreach {//token} +$ if {@parser_index} +class @ename + super Token +end +$ end +$ end +class EOF + super Token +end +class PError + super EOF +end +class PLexerError + super PError +end +class PParserError + super PError +end +$ end template + +$ template make_tokens() + +redef class Token + var _text: nullable String + + redef fun text + do + var res = _text + if res != null then return res + res = location.text + _text = res + return res + end + + redef fun text=(text) + do + _text = text + end + + fun parser_index: Int is abstract +end + +$ foreach {//token} +$ if {@parser_index} +redef class @ename + redef fun parser_index: Int + do + return @parser_index + end + + init init_tk(loc: Location) + do + _location = loc + end +end + +$ end if +$ end foreach + +redef class EOF + redef fun parser_index: Int + do + return ${tokens/eof/@parser_index} + end + + init init_tk(loc: Location) + do + _text = "" + _location = loc + end +end + +redef class PError + readable var _message: String + + init init_error(message: String, loc: Location) + do + init_tk(loc) + _message = message + end +end + +redef class PLexerError + readable var _string: String + + init init_lexer_error(message: String, loc: Location, string: String) + do + init_error(message, loc) + _string = string + end +end + +redef class PParserError + readable var _token: Token + + init init_parser_error(message: String, loc: Location, token: Token) + do + init_error(message, loc) + _token = token + end +end +$ end template diff --git a/contrib/pep8analysis/src/pep8analysis.nit b/contrib/pep8analysis/src/pep8analysis.nit new file mode 100644 index 0000000..17e2232 --- /dev/null +++ b/contrib/pep8analysis/src/pep8analysis.nit @@ -0,0 +1,97 @@ +module pep8analysis + +import backbone +import ast +import model +import cfg +import flow_analysis + +redef class AnalysisManager + var opt_help = new OptionBool("Display this help message", "--help","-h") + var opt_quiet = new OptionBool("Do not show notes", "--quiet","-q") + fun quiet: Bool do return opt_quiet.value + fun verbose: Bool do return not opt_quiet.value + + var opt_output = new OptionString("Output directory", "--output", "-o") + + redef init + do + super + + opts.add_option(opt_help) + opts.add_option(opt_quiet) + opts.add_option(opt_output) + end + + fun run + do + opts.parse(args) + var files = opts.rest + + if files.is_empty or opt_help.value then + print "Usage: {sys.program_name} [options] file.pep [other_file.pep [...]]" + print "Options:" + opts.usage + return + end + + var dir = opt_output.value + if dir == null then dir = "out" + if not dir.file_exists then dir.mkdir + + # Parsing + for filename in files do + reset # noter + + if verbose then print "Analyzing {filename}" + if not filename.file_exists then + print "Target file \"{filename}\" does not exist." + exit 1 + end + var ast = build_ast( filename ) + assert ast != null + + if failed then continue + + # Build program model + var model = build_model(ast) + + if failed then continue + + if model.lines.is_empty then + fatal_error( ast, "This programs appears empty" ) + continue + end + + # Create CFG + var cfg = build_cfg(model) + + if failed then continue + + # Run analyses + + ## Reaching defs + do_reaching_defs_analysis(cfg) + + ## Range + do_range_analysis(ast, cfg) + + ## Types + do_types_analysis(ast, cfg) + + # Print results + var of = new OFStream.open("{dir}/{filename.replace("/","-").replace(".pep",".dot")}") + cfg.print_dot(of, true) + of.close + end + if not opt_quiet.value then + print_notes + end + end +end + +redef class Object + redef fun manager do return once new AnalysisManager +end + +manager.run