miloignis/kraken
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Now it compiles

Browse Source
This commit is contained in:
Nathan Braswell
2020-03-26 23:34:25 -04:00
parent a10238e493
commit 3cef008a93
1 changed files with 65 additions and 25 deletions
Download Patch File Download Diff File Expand all files Collapse all files

90
fungll.krak
View File

@@ -7,7 +7,7 @@ import str:*
// nonterminals are negative, terminals are positive
obj Grammer (Object) {
var nonterminals: vec<vec<int>>
var nonterminals: vec<vec<vec<int>>>
var terminals: vec<char>
fun construct(): *Grammer {
nonterminals.construct()
@@ -28,27 +28,33 @@ obj Grammer (Object) {
}
fun add_new_nonterminal(rule: ref vec<int>): int {
nonterminals.add(vec(rule))
return -1*nonterminal.size
return -1*nonterminals.size
}
fun add_to_nonterminal(nonterminal: int, rule: ref vec<int>) {
nonterminals[(-1*nonterminal)-1].add(rule)
}
fun add_terminal(c: char): int {
terminals.add(rule)
terminals.add(c)
return terminals.size
}
fun get_nonterminal_rules(nonterminal: int): ref vec<int> {
fun get_nonterminal_rules(nonterminal: int): ref vec<vec<int>> {
return nonterminals[(-1*nonterminal)-1]
}
fun get_terminal(terminal: int): char {
return terminals[terminal-1]
}
fun is_terminal(x: int): bool {
return x > 0
}
}
obj Pending (Object) {
var nonterminal: int
var rule_idx: int
var idx_into_rule: int
var left: int
fun construct(): *Pending {
return this->construct(0,0,0,0)
}
fun construct(nonterminal: int, rule_idx: int, idx_into_rule: int, left: int): *Pending {
this->nonterminal = nonterminal;
this->rule_idx = rule_idx;
@@ -67,6 +73,9 @@ obj Pending (Object) {
destruct()
copy_construct(&other)
}
fun operator==(rhs: ref Pending): bool {
return nonterminal == rhs.nonterminal && rule_idx == rhs.rule_idx && idx_into_rule == rhs.idx_into_rule && left == rhs.left
}
}
fun pending(nonterminal: int, rule_idx: int, idx_into_rule: int, left: int): Pending {
var to_ret.construct(nonterminal, rule_idx, idx_into_rule, left): Pending
@@ -78,6 +87,9 @@ obj Descriptor (Object) {
var idx_into_rule: int
var left: int
var pivot: int
fun construct(): *Descriptor {
return this->construct(0,0,0,0,0)
}
fun construct(nonterminal: int, rule_idx: int, idx_into_rule: int, left: int, pivot: int): *Descriptor {
this->nonterminal = nonterminal;
this->rule_idx = rule_idx;
@@ -98,6 +110,9 @@ obj Descriptor (Object) {
destruct()
copy_construct(&other)
}
fun operator==(rhs: ref Descriptor): bool {
return nonterminal == rhs.nonterminal && rule_idx == rhs.rule_idx && idx_into_rule == rhs.idx_into_rule && left == rhs.left && pivot == rhs.pivot
}
}
fun descriptor(nonterminal: int, rule_idx: int, idx_into_rule: int, left: int, pivot: int): Descriptor {
var to_ret.construct(nonterminal, rule_idx, idx_into_rule, left, pivot): Descriptor
@@ -110,6 +125,9 @@ obj BS (Object) {
var left: int
var pivot: int
var right: int
fun construct(): *BS {
return this->construct(0,0,0,0,0,0)
}
fun construct(nonterminal: int, rule_idx: int, idx_into_rule: int, left: int, pivot: int, right: int): *BS {
this->nonterminal = nonterminal;
this->rule_idx = rule_idx;
@@ -135,6 +153,9 @@ obj BS (Object) {
fun to_string(): str {
return str() + nonterminal + " " + rule_idx + " " + idx_into_rule + " " + left + " " + pivot + " " + right
}
fun operator==(rhs: ref BS): bool {
return nonterminal == rhs.nonterminal && rule_idx == rhs.rule_idx && idx_into_rule == rhs.idx_into_rule && left == rhs.left && pivot == rhs.pivot && right == rhs.right
}
}
fun bs(nonterminal: int, rule_idx: int, idx_into_rule: int, left: int, pivot: int, right: int): BS {
var to_ret.construct(nonterminal, rule_idx, idx_into_rule, left, pivot, right): BS
@@ -146,14 +167,18 @@ fun bs(nonterminal: int, rule_idx: int, idx_into_rule: int, left: int, pivot: in
/*fun fungll(grammer: ref Grammer, input: ref str, start_symbol: int): set<BS> {*/
/*fun fungll(grammer: ref Grammer, input: ref str): <, set<BS>> {*/
fun fungll(grammer: ref Grammer, input: ref str): set<BS> {
/*loop(grammer, input, decend(grammer, 0 [>start_symbol<], 0), set(), set(), set(), set())*/
loop(grammer, input, decend(grammer, 0 /*start_symbol*/, 0), set(), map<pair<int, int>, vec<Pending>>(), set(), set<BS>())
/*loop(grammer, input, descend(grammer, 0 [>start_symbol<], 0), set(), set(), set(), set())*/
loop(grammer, input, descend(grammer, 0 /*start_symbol*/, 0), set<Descriptor>(), map<pair<int, int>, set<Pending>>(), map<pair<int,int>, set<int>>(), set<BS>())
}
fun descend(grammer: ref Grammer, symbol: int, l: int): set<Descriptor> {
/*grammer.get_nonterminal_rules(symbol).map(fun(rhs): descriptor { <X::=.rhs,l,l> })*/
return grammer.get_nonterminal_rules(symbol).map(fun(rhs: int): Descriptor { return descriptor(symbol, rhs, 0, l, l); })
/*return grammer.get_nonterminal_rules(symbol).map(fun(rhs: int): Descriptor { return descriptor(symbol, rhs, 0, l, l); })*/
var to_ret = set<Descriptor>()
for (var rhs = 0; rhs < grammer.get_nonterminal_rules(symbol).size; rhs++;)
to_ret.add(descriptor(symbol, rhs, 0, l, l))
return to_ret
}
fun loop(grammer: ref Grammer, input: ref str, R: set<Descriptor>, U: set<Descriptor>, G: map<pair<int, int>, vec<Pending>>, P: map<pair<int,int>, set<int>>, Y: set<BS>): set<BS> {
fun loop(grammer: ref Grammer, input: ref str, R: set<Descriptor>, U: set<Descriptor>, G: map<pair<int, int>, set<Pending>>, P: map<pair<int,int>, set<int>>, Y: set<BS>): set<BS> {
/*if R.size() == 0 {*/
/*return <U,Y>*/
/*} else {*/
@@ -176,31 +201,46 @@ fun loop(grammer: ref Grammer, input: ref str, R: set<Descriptor>, U: set<Descri
var nextR = R.union(Rp) - U_with_d
R = nextR
U = U_with_d
G += Gp
P += Pp
/*G += Gp*/
for (var i = 0; i < Gp.keys.size; i++;) {
if G.contains_key(Gp.keys[i]) {
G[Gp.keys[i]].add(Gp.values[i])
} else {
G[Gp.keys[i]] = Gp.values[i]
}
}
/*P += Pp*/
for (var i = 0; i < Pp.keys.size; i++;) {
if P.contains_key(Pp.keys[i]) {
P[Pp.keys[i]].add(Pp.values[i])
} else {
P[Pp.keys[i]] = Pp.values[i]
}
}
Y += Yp
}
return Y
}
/*fun process(grammer: ref Grammer, input: ref str, <X:=a.b,l,k>, G, P): {*/
fun process(grammer: ref Grammer, input: ref str, discript: Descriptor, G: map<pair<int, int>, vec<Pending>>, P: map<pair<int,int>, set<int>>): triple<pair<set<Descriptor>, set<BS>>, map<pair<int, int>, Pending>, map<pair<int,int>, set<int>>> {
fun process(grammer: ref Grammer, input: ref str, descript: Descriptor, G: map<pair<int, int>, set<Pending>>, P: map<pair<int,int>, set<int>>): triple<pair<set<Descriptor>, set<BS>>, map<pair<int, int>, set<Pending>>, map<pair<int,int>, set<int>>> {
/*if is_e(b) {*/
if descript.idx_into_rule == grammer.get_nonterminal_rules(discript.nonterminal)[descript.rule_idx].size {
if descript.idx_into_rule == grammer.get_nonterminal_rules(descript.nonterminal)[descript.rule_idx].size {
/*return process_e(<X::=a.,l,k>, G, P)*/
return process_e(descript, G, P)
return process_e(grammer, descript, G, P)
} else {
/*return process_symbol(grammer, input, <X::=a.sb',l,k>, G, P) // b=sb'*/
return process_symbol(grammer, input, descript, G, P)
}
}
/*fun process_e(<X::=a.,l,k>, G, P) {*/
fun process_e(descript: Descriptor, G: ref map<pair<int, int>, vec<Pending>>, P: ref map<pair<int,int>, set<int>>): triple<pair<set<Descriptor>, set<BS>>, map<pair<int, int>, Pending>, map<pair<int,int>, set<int>>> {
fun process_e(grammer: ref Grammer, descript: Descriptor, G: ref map<pair<int, int>, set<Pending>>, P: ref map<pair<int,int>, set<int>>): triple<pair<set<Descriptor>, set<BS>>, map<pair<int, int>, set<Pending>>, map<pair<int,int>, set<int>>> {
var nonterminal: int
var rule_idx: int
var left: int
var pivot: int
var X = descript.nonterminal
var l = descript.left;
var k = descript.pivot;
/*var K = { <g,l'> | <<X,l>,<g,l'>> in G }*/
var K = G.get(make_pair(X,l))
/*var <R,Y> = ascend(l,K,k)*/
@@ -212,20 +252,20 @@ fun process_e(descript: Descriptor, G: ref map<pair<int, int>, vec<Pending>>, P:
Y.add(bs(X,descript.rule_idx, 0, l, l, l))
}
/*return <<R,Y.union(Y')>,set(),set(<<X,l>,k>)>*/
return make_triple(make_pair(R,Y), map<pair<int, int>, Pending>(), map(make_pair(X,l), set(k)))
return make_triple(make_pair(R,Y), map<pair<int, int>, set<Pending>>(), map(make_pair(X,l), set(k)))
}
/*fun process_symbol(grammer: ref Grammer, input: ref str, <X::=a.sb',l,k>, G, P) {*/
fun process_symbol(grammer: ref Grammer, input: ref str, descript: Descriptor, G: ref map<pair<int, int>, vec<Pending>>, P: ref map<pair<int,int>, set<int>>): triple<pair<set<Descriptor>, set<BS>>, map<pair<int, int>, Pending>, map<pair<int,int>, set<int>>> {
fun process_symbol(grammer: ref Grammer, input: ref str, descript: Descriptor, G: ref map<pair<int, int>, set<Pending>>, P: ref map<pair<int,int>, set<int>>): triple<pair<set<Descriptor>, set<BS>>, map<pair<int, int>, set<Pending>>, map<pair<int,int>, set<int>>> {
var s = grammer.get_nonterminal_rules(descript.nonterminal)[descript.rule_idx][descript.idx_into_rule]
var k = descript.pivot
/*R = { r | <<s,k>,r> in P }*/
R = P.get(make_pair(s,k))
var R = P.get(make_pair(s,k))
/*G' = {<<s,k>, <X::=as.b',l>>}*/
var Gp = map(make_pair(s,k), pending(descript.nonterminal, descript.rule_idx, descript.idx_into_rule, descript.left))
var Gp = map(make_pair(s,k), set(pending(descript.nonterminal, descript.rule_idx, descript.idx_into_rule, descript.left)))
if grammer.is_terminal(s) {
/*return <match(input,<X::=a.sb',l,k>),set(),set()>*/
/*return make_triple(match(input,descript), map<pair<int,int>, vec<Pending>>(), map<pair<int,int>, set<int>>())*/
return make_triple(matc(input,descript), map<pair<int,int>, vec<Pending>>(), map<pair<int,int>, set<int>>())
return make_triple(matc(grammer,input,descript), map<pair<int,int>, set<Pending>>(), map<pair<int,int>, set<int>>())
} else if R.size() == 0 { // s in N
/*return <<descend(grammer,s,k), set()>, G', set()>*/
return make_triple(make_pair(descend(grammer,s,k), set<BS>()), Gp, map<pair<int,int>, set<int>>())
@@ -235,9 +275,9 @@ fun process_symbol(grammer: ref Grammer, input: ref str, descript: Descriptor, G
}
}
/*fun match(input: ref str, <X::=a.sb',l,k>): <discriptor_set, set<BS>> {*/
fun matc(input: ref str, descript: Descriptor): pair<set<Descriptor>, set<BS>> {
fun matc(grammer: ref Grammer, input: ref str, descript: Descriptor): pair<set<Descriptor>, set<BS>> {
/*if input[k] == grammer.get_terminal(s) {*/
if input[descript.piviot] == grammer.get_terminal(s) {
if input[descript.pivot] == grammer.get_terminal(descript.idx_into_rule) {
/*return <set(X::=as.b',l,k+1>), set(<X::=as.b',l,k,k+1)>*/
return make_pair(set(descriptor(descript.nonterminal, descript.rule_idx, descript.idx_into_rule+1, descript.left, descript.pivot+1)), set(bs(descript.nonterminal, descript.rule_idx, descript.idx_into_rule+1, descript.left, descript.pivot, descript.pivot+1)))
} else {
@@ -249,7 +289,7 @@ fun ascend(k:int, K: ref set<Pending>, r: int): pair<set<Descriptor>, set<BS>> {
fun nmatch(k:int, K: ref set<Pending>, R: ref set<int>): pair<set<Descriptor>, set<BS>> {
/*var R = { <g,l,r> | <g,l> in K, r in R }*/
/*var Y = { <g,l,k,r> | <g,l> in K, r in R }*/
var R = set<Descriptor>()
var Rp = set<Descriptor>()
var Y = set<BS>()
/*for pending in K {*/
for (var i = 0; i < K.data.size; i++;) {
@@ -257,11 +297,11 @@ fun nmatch(k:int, K: ref set<Pending>, R: ref set<int>): pair<set<Descriptor>, s
/*for r in R {*/
for (var j = 0; j < R.data.size; j++;) {
var r = R.data[j]
R.push(descriptor(pending.nonterminal, pending.rule_idx, pending.idx_into_rule, pending.left, r))
Y.push(bs(pending.nonterminal, pending.rule_idx, pending.idx_into_rule, pending.left, k, r))
Rp.add(descriptor(pending.nonterminal, pending.rule_idx, pending.idx_into_rule, pending.left, r))
Y.add(bs(pending.nonterminal, pending.rule_idx, pending.idx_into_rule, pending.left, k, r))
}
}
return make_pair(R,Y)
return make_pair(Rp,Y)
}
fun main(argc: int, argv: **char): int {