108 lines
3.3 KiB
Plaintext
108 lines
3.3 KiB
Plaintext
import grammer
|
|
import symbol
|
|
import tree
|
|
import vector
|
|
import stack
|
|
import map
|
|
import util
|
|
import string
|
|
import io
|
|
import mem
|
|
|
|
obj parser (Object) {
|
|
var input: vector::vector<symbol::symbol>
|
|
var gram: grammer::grammer
|
|
// gss
|
|
var to_reduce: stack::stack<reduction>
|
|
var to_shift: stack::stack< util::pair<*tree::tree<int>, int> >
|
|
var SPPFStepNodes: vector::vector< util::pair<*tree::tree<symbol::symbol>, int> >
|
|
var packed_map: map::map<*tree::tree<symbol::symbol>, bool>
|
|
|
|
fun construct(grammerIn: grammer::grammer): *parser {
|
|
input.construct()
|
|
gram.copy_construct(&grammerIn)
|
|
to_reduce.construct()
|
|
to_shift.construct()
|
|
SPPFStepNodes.construct()
|
|
packed_map.construct()
|
|
return this
|
|
}
|
|
fun copy_construct(old: *parser) {
|
|
input.copy_construct(&old->input)
|
|
gram.copy_construct(&old->gram)
|
|
to_reduce.copy_construct(&old->to_reduce)
|
|
to_shift.copy_construct(&old->to_shift)
|
|
SPPFStepNodes.copy_construct(&old->SPPFStepNodes)
|
|
packed_map.copy_construct(&old->packed_map)
|
|
}
|
|
fun operator=(old: ref parser) {
|
|
destruct()
|
|
copy_construct(&old)
|
|
}
|
|
fun destruct() {
|
|
input.destruct()
|
|
gram.destruct()
|
|
to_reduce.destruct()
|
|
to_shift.destruct()
|
|
SPPFStepNodes.destruct()
|
|
packed_map.destruct()
|
|
}
|
|
|
|
fun parse_input(inputStr: string::string, name: string::string): *tree::tree<symbol::symbol> {
|
|
input.clear()
|
|
// gss.clear
|
|
to_reduce.clear()
|
|
to_shift.clear()
|
|
SPPFStepNodes.clear()
|
|
packed_map.clear()
|
|
|
|
// if the zero state contains any reductions for state 0 and eof, then
|
|
// it must be reducing to the goal state
|
|
io::println("checking the bidness")
|
|
if (inputStr == "" && gram.parse_table.get(0, symbol::eof_symbol()).contains(grammer::action(grammer::reduce, 0))) {
|
|
io::println("Accept on no input for ")
|
|
io::println(name)
|
|
return mem::new<tree::tree<symbol::symbol>>()->construct(symbol::null_symbol())
|
|
}
|
|
io::println("failed for ")
|
|
io::println(name)
|
|
return mem::new<tree::tree<symbol::symbol>>()->construct(symbol::null_symbol())
|
|
}
|
|
}
|
|
|
|
fun reduction(f: *tree::tree<int>, s: symbol::symbol, l: int, n: *tree::tree<symbol::symbol>, label:*tree::tree<symbol::symbol>): reduction {
|
|
var toRet.construct(f,s,l,n,label): reduction
|
|
return toRet
|
|
}
|
|
|
|
obj reduction (Object) {
|
|
var from: *tree::tree<int>
|
|
var sym: symbol::symbol
|
|
var length: int
|
|
var nullable_parts: *tree::tree<symbol::symbol>
|
|
var label: *tree::tree<symbol::symbol>
|
|
|
|
fun construct(f: *tree::tree<int>, s: symbol::symbol, l: int, n: *tree::tree<symbol::symbol>, label:*tree::tree<symbol::symbol>): *reduction {
|
|
from = f
|
|
sym.copy_construct(&s)
|
|
length = l
|
|
nullable_parts = n
|
|
label = label
|
|
return this
|
|
}
|
|
fun copy_construct(old: *reduction) {
|
|
from = old->from
|
|
sym.copy_construct(&old->sym)
|
|
length = old->length
|
|
nullable_parts = old->nullable_parts
|
|
label = old->label
|
|
}
|
|
fun operator=(other: reduction):void {
|
|
destruct()
|
|
copy_construct(&other)
|
|
}
|
|
fun destruct() {
|
|
sym.destruct()
|
|
}
|
|
}
|