func RootOf(o Object) Object {
assert.For(!fn.IsNil(o), 20)
if fn.IsNil(o.Parent()) {
return o
} else {
return RootOf(o.Parent())
}
}
func (f *fm) Write(o otm.Object) {
if !fn.IsNil(o) {
f.object(o)
} else {
f.Trinary(tri.NIL)
}
}
func (t *target) emit(_s ir.Statement) {
assert.For(!fn.IsNil(_s), 20)
switch s := _s.(type) {
default:
t.tpl.Stmt = append(t.tpl.Stmt, s)
}
}
func (d *direct) init(v *ir.Variable, ctrl chan bool, def ...interface{}) {
d.c = make(chan interface{})
d.s = make(chan interface{})
d.v = v
d.ctrl = ctrl
go func() {
d.ctrl <- true
var x interface{}
for stop := false; !stop; {
if fn.IsNil(x) {
select {
case x = <-d.s:
log.Println("rd", x)
case stop = <-d.ctrl:
}
} else {
select {
case d.c <- x:
log.Println("wr", x)
case stop = <-d.ctrl:
}
}
}
d.ctrl <- true
}()
}
func prettyPrintObject(o otm.Object, log *testing.T) {
parent := ""
for x := o.Parent(); !fn.IsNil(x); x = x.Parent() {
parent = fmt.Sprint(x.Qualident(), "<-", parent)
}
log.Log(parent, o.Qualident())
if o.ChildrenCount() > 0 {
log.Log(":")
for _x := range o.Children() {
switch x := _x.(type) {
case otm.Object:
prettyPrintObject(x, log)
case otm.Link:
log.Log("@", x.Object().Qualident())
case string, float64, int64, rune, tri.Trit:
log.Log(_x)
case []uint8:
s := zbase32.EncodeToString(x)
log.Log("zbase32(", s, ")", x)
default:
halt.As(100, reflect.TypeOf(x))
}
}
log.Log(";")
}
}
func (l *futureLink) Object() otm.Object {
if l.o == nil {
assert.For(!fn.IsNil(l.up), 20)
l.o = otm.RootOf(l.up).FindById(l.to).(*object)
assert.For(l.o != nil, 60, "object not found ", l.to)
}
return l.o
}
func (b *builder) Child(prod otm.Producer, mod ...otm.Modifier) otm.Builder {
assert.For(b.root != nil, 20)
n := prod(mod...).(*object)
if n.id != "" {
old := b.root.FindById(n.id)
assert.For(fn.IsNil(old), 40, "non unique id")
}
b.root.vl = append(b.root.vl, n)
n.up = b.root
return b
}
func Resolve(o otm.Object) (err error) {
assert.For(!fn.IsNil(o), 20)
switch tpl := o.Qualident().Template; tpl {
case Core.TemplateName:
err = resolve(Core, o)
default:
err = errors.New("nothing to resolve")
}
return
}
func ResolveContext(o otm.Object, resolver ResolverFunc, data map[string]interface{}) (err error) {
assert.For(!fn.IsNil(o), 20)
switch tpl := o.Qualident().Template; tpl {
case Core.TemplateName:
err = resolveContext(o.(*object), resolver, data)
default:
err = errors.New("nothing to resolve")
}
return
}
func initCore() {
Core = &ForeignTemplate{TemplateName: "core"}
Core.Classes = make(map[string]*ForeignClass)
Core.Classes["template"] = &ForeignClass{
Template: Core,
Class: "template",
Applicator: func(c *ForeignClass, o otm.Object) (_ func(*ForeignClass, otm.Object) error, err error) {
c.Entity = &TemplateEntity{}
x := otm.RootOf(o)
if x != o {
err = errors.New("core.template must be root")
}
return
}}
Core.Classes["import"] = &ForeignClass{
Template: Core,
Class: "import",
Applicator: func(c *ForeignClass, o otm.Object) (post func(*ForeignClass, otm.Object) error, err error) {
e := &ImportEntity{Imports: make(map[otm.Qualident]otm.Object), Ref: o}
c.Entity = e
for imp := range o.ChildrenObjects() {
e.Imports[imp.Qualident()] = imp
}
for k, _ := range e.Imports {
if k.Template != "" || k.Identifier != "" || k.Class == Core.TemplateName {
err = errors.New(fmt.Sprintln("cannot import ", k))
}
}
post = func(c *ForeignClass, o otm.Object) (err error) {
e := c.Entity.(*ImportEntity)
for k, _ := range e.Imports {
if t, ok := tm[k.Class]; ok {
if p := o.Parent(); !fn.IsNil(p) {
resolve(t, p)
} else {
halt.As(100, "cannot apply import to nil")
}
} else {
err = errors.New(fmt.Sprintln("unknown template ", k))
}
}
return
}
return
}}
}
func Transfer(l *model.Layer) {
assert.For(l != nil && l.Next != nil, 20)
wg := new(sync.WaitGroup)
for _, n := range l.Next.Nodes {
wg.Add(1)
go func(n *model.Node) {
tmp := make(map[model.Link]interface{})
for k, _ := range n.In {
v := l.Nodes[k.NodeId].Out[k.LinkId]
if fn.IsNil(v) {
halt.As(100, k)
}
tmp[k] = v
}
n.In = tmp
wg.Done()
}(n)
}
wg.Wait()
}
func (m *mem) init(v *ir.Variable, ctrl chan bool, def ...interface{}) {
m.c = make(chan interface{})
m.s = make(chan interface{})
m.v = v
m.ctrl = ctrl
go func() {
x := <-m.s
m.ctrl <- true
for stop := false; !stop; {
select {
case n := <-m.s:
m.f = n
case m.c <- x:
case stop = <-m.ctrl:
}
}
m.ctrl <- true
}()
if len(def) != 0 && !fn.IsNil(def[0]) {
m.s <- def[0]
} else {
m.s <- m.defaults(v).val
}
}
func (i *Iq) UnmarshalXML(d *xml.Decoder, start xml.StartElement) (err error) {
i.Id = getAttr(&start, "id")
i.Type = IqType(getAttr(&start, "type"))
var _t xml.Token
for stop := false; !stop && err == nil; {
_t, err = d.Token()
switch t := _t.(type) {
case xml.StartElement:
if fact, ok := us[t.Name]; ok {
i.Inner = fact()
}
if !fn.IsNil(i.Inner) {
d.DecodeElement(i.Inner, &t)
} else {
//halt.As(100, t.Name)
}
case xml.EndElement:
stop = t.Name == start.Name
default:
//halt.As(100, reflect.TypeOf(t))
}
}
return
}
func resolve(t *ForeignTemplate, o otm.Object) (err error) {
assert.For(!fn.IsNil(o), 20)
var processList []pfunc
var upd func(t *ForeignTemplate, o otm.Object)
upd = func(t *ForeignTemplate, o otm.Object) {
if clazz, ok := t.Classes[o.Qualident().Class]; ok && (o.Qualident().Template == t.TemplateName || o.Qualident().Template == "") {
inst := clazz.copyOf()
o.InstanceOf(inst)
if fn := inst.apply(o); fn != nil {
processList = append(processList, fn)
}
//log.Println("class updated for", o.Qualident(), " set ", clazz.Qualident())
}
for x := range o.ChildrenObjects() {
upd(t, x)
}
}
upd(t, o)
for tmp := processList; len(tmp) > 0; {
var _tmp []pfunc
for _, f := range tmp {
var p pfunc
if p, err = f(); err == nil && p != nil {
_tmp = append(_tmp, p)
} else if err != nil {
_tmp = nil
break
}
}
tmp = _tmp
}
return
}
func (u *Unit) expr(e ir.Expression) *value {
stack := &exprStack{}
stack.init()
var expr func(ir.Expression)
expr = func(_e ir.Expression) {
switch e := _e.(type) {
case ir.WrappedExpression:
expr(e.Process())
case *ir.ConstExpr:
stack.push(cval(e))
case *ir.AtomExpr:
stack.push(&value{typ: types.ATOM, val: Atom(e.Value)})
case *ir.SelectExpr:
if e.Var != nil {
e.Var = u.code.Variables[e.Var.Name]
var o object
if e.Foreign == nil {
o = u.objects[e.Var.Name]
} else {
if imp := u.imps[imp(e.Var)]; imp != nil {
o = imp.objects[e.Foreign.Name]
}
}
stack.push(get(o))
} else if e.Const != nil {
if c := u.code.Const[e.Const.Name]; c != nil {
expr(c.Expr)
} else {
halt.As(100, "wrong constant name", e.Const.Name)
}
} else {
halt.As(100)
}
if e.Inner != mods.NONE {
base := stack.pop()
switch {
case e.Inner == mods.LIST && len(e.ExprList) == 1: //single item
expr(e.ExprList[0])
_i := stack.pop()
switch base.typ {
case types.STRING:
idx := int(_i.toInt().Int64())
s := []rune(base.toStr())
assert.For(idx >= 0 && idx < len(s), 40)
stack.push(&value{typ: types.CHAR, val: s[idx]})
case types.MAP:
idx := ThisAny(_i)
m := base.asMap()
data := m.Get(idx)
stack.push(&value{typ: types.ANY, val: data})
case types.LIST:
idx := int(_i.toInt().Int64())
l := base.asList()
data := l.Get(idx)
stack.push(&value{typ: types.ANY, val: data})
default:
halt.As(100, "not indexable ", base.typ)
}
case e.Inner == mods.LIST && len(e.ExprList) > 1: //some items
switch base.typ {
case types.STRING:
s := []rune(base.toStr())
var ret []rune
for _, _e := range e.ExprList {
expr(_e)
_i := stack.pop()
i := int(_i.toInt().Int64())
assert.For(i >= 0 && i < len(s), 40)
ret = append(ret, s[i])
}
stack.push(&value{typ: types.STRING, val: string(ret)})
default:
halt.As(100, "not indexable ")
}
case e.Inner == mods.RANGE && len(e.ExprList) == 2: //range min (from, to) .. max(from, to) with reverse
expr(e.ExprList[0])
_f := stack.pop()
expr(e.ExprList[1])
_t := stack.pop()
from := _f.toInt().Int64()
to := _t.toInt().Int64()
if int64(math.Max(float64(from), float64(to))) == to { //forward
switch base.typ {
case types.STRING:
s := []rune(base.toStr())
var ret []rune
for i := int(from); i <= int(to); i++ {
assert.For(i >= 0 && i < len(s), 40)
ret = append(ret, s[i])
}
stack.push(&value{typ: types.STRING, val: string(ret)})
default:
halt.As(100, "not indexable ", base.typ)
}
} else {
switch base.typ {
case types.STRING:
s := []rune(base.toStr())
var ret []rune
for i := int(to); i >= int(from); i-- {
assert.For(i >= 0 && i < len(s), 40)
ret = append(ret, s[i])
}
stack.push(&value{typ: types.STRING, val: string(ret)})
default:
halt.As(100, "not indexable ", base.typ)
}
}
case e.Inner == mods.RANGE && len(e.ExprList) == 1: //open range from `from` to the end of smth
expr(e.ExprList[0])
_i := stack.pop()
idx := int(_i.toInt().Int64())
switch base.typ {
case types.STRING:
s := []rune(base.toStr())
var ret []rune
for i := int(idx); i < len(s); i++ {
assert.For(i >= 0 && i < len(s), 40)
ret = append(ret, s[i])
}
stack.push(&value{typ: types.STRING, val: string(ret)})
default:
halt.As(100, "not indexable ")
}
case e.Inner == mods.DEREF:
switch base.typ {
case types.ANY:
a := base.toAny()
if !fn.IsNil(a.x) {
stack.push(&value{typ: a.typ, val: a.x})
} else {
halt.As(100, "undef dereference read")
}
default:
halt.As(101, "not a ref ", base.typ)
}
default:
halt.As(100, "unexpected selector ", base, e.Inner)
}
}
case *ir.Monadic:
expr(e.Expr)
v := stack.pop()
switch e.Op {
case ops.Neg:
switch v.typ {
case types.INTEGER:
i := v.toInt()
i = i.Neg(i)
v = &value{typ: v.typ, val: ThisInt(i)}
case types.REAL:
i := v.toReal()
i = i.Neg(i)
v = &value{typ: v.typ, val: ThisRat(i)}
default:
halt.As(100, v.typ)
}
case ops.Not:
switch v.typ {
case types.BOOLEAN:
b := v.toBool()
v = &value{typ: v.typ, val: !b}
case types.TRILEAN:
t := v.toTril()
v = &value{typ: v.typ, val: tri.Not(t)}
case types.SET:
s := v.toSet()
ns := ThisSet(s)
ns.inv = !ns.inv
v = &value{typ: v.typ, val: ns}
default:
halt.As(100, "unexpected logical type")
}
case ops.Im:
switch v.typ {
case types.INTEGER:
i := v.toInt()
im := big.NewRat(0, 1)
im.SetInt(i)
re := big.NewRat(0, 1)
c := &Cmp{}
c.re = re
c.im = im
v = &value{typ: types.COMPLEX, val: c}
case types.REAL:
im := v.toReal()
re := big.NewRat(0, 1)
c := &Cmp{}
c.re = re
c.im = im
v = &value{typ: types.COMPLEX, val: c}
default:
halt.As(100, "unexpected operand type ", v.typ)
}
default:
halt.As(100, e.Op)
}
stack.push(v)
case *ir.Dyadic:
var l, r *value
if !(e.Op == ops.Or || e.Op == ops.And) {
expr(e.Left)
l = stack.pop()
if e.Op == ops.In {
l = &value{typ: types.ANY, val: ThisAny(l)}
}
expr(e.Right)
r = stack.pop()
v := calcDyadic(l, e.Op, r)
stack.push(v)
} else {
expr(e.Left)
l = stack.pop()
switch e.Op {
case ops.And:
switch l.typ {
case types.BOOLEAN:
lb := l.toBool()
if lb {
expr(e.Right)
r = stack.pop()
rb := r.toBool()
lb = lb && rb
}
stack.push(&value{typ: l.typ, val: lb})
case types.TRILEAN:
lt := l.toTril()
if !tri.False(lt) {
expr(e.Right)
r = stack.pop()
rt := r.toTril()
lt = tri.And(lt, rt)
}
stack.push(&value{typ: l.typ, val: lt})
default:
halt.As(100, "unexpected logical type")
}
case ops.Or:
switch l.typ {
case types.BOOLEAN:
lb := l.toBool()
if !lb {
expr(e.Right)
r = stack.pop()
rb := r.toBool()
lb = lb || rb
}
stack.push(&value{typ: l.typ, val: lb})
case types.TRILEAN:
lt := l.toTril()
if !tri.True(lt) {
expr(e.Right)
r = stack.pop()
rt := r.toTril()
lt = tri.Or(lt, rt)
}
stack.push(&value{typ: l.typ, val: lt})
default:
halt.As(100, "unexpected logical type")
}
default:
halt.As(100, "unknown dyadic op ", e.Op)
}
}
case *ir.Ternary:
expr(e.If)
c := stack.pop()
if c.toBool() {
expr(e.Then)
} else {
expr(e.Else)
}
case *ir.InfixExpr:
var args []*value
for _, a := range e.Args {
expr(a)
args = append(args, stack.pop())
}
cm := Init(e.Unit.Name(), u.loader)
c := make(chan value, 1)
Do(cm, func(cm Cluster) {
inf := cm[e.Unit.Name()]
assert.For(inf != nil, 40)
for i := len(args) - 1; i >= 0; i-- {
go func(i int, v *value) {
o := inf.objects[inf.code.Infix[i].Name]
set(o, v)
}(i+1, args[i])
}
go func(c chan value) {
o := inf.objects[inf.code.Infix[0].Name]
v := get(o)
log.Println("infix", v)
c <- *v
}(c)
}).Wait()
v := <-c
Close(cm).Wait()
stack.push(&v)
case *ir.TypeTest:
expr(e.Operand)
v := stack.pop()
var a *Any
switch v.typ {
case types.ANY:
a = v.toAny()
/*case types.PTR:
p := v.toPtr()
if p.adr != 0 {
a = p.link.Get()
} else {
a = &Any{}
} */
default:
halt.As(100, "unsupported ")
}
switch {
case a.x == nil:
stack.push(&value{typ: types.TRILEAN, val: tri.NIL})
case a.x != nil && a.typ == e.Typ.Builtin.Code:
stack.push(&value{typ: types.TRILEAN, val: tri.TRUE})
case a.x != nil && a.typ != e.Typ.Builtin.Code:
stack.push(&value{typ: types.TRILEAN, val: tri.FALSE})
default:
halt.As(100, "unhandled type testing for ", v.typ, v.val)
}
case *ir.ListExpr:
var tmp []*value
for _, x := range e.Expr {
expr(x)
v := stack.pop()
tmp = append(tmp, v)
}
stack.push(&value{typ: types.LIST, val: NewList(tmp...)})
case *ir.SetExpr:
var tmp []*value
for _, x := range e.Expr {
expr(x)
v := stack.pop()
tmp = append(tmp, v)
}
stack.push(&value{typ: types.SET, val: NewSet(tmp...)})
case *ir.MapExpr:
var k []*value
for _, x := range e.Key {
expr(x)
v := stack.pop()
k = append(k, v)
}
var v []*value
for _, x := range e.Value {
expr(x)
n := stack.pop()
v = append(v, n)
}
stack.push(&value{typ: types.MAP, val: NewMap(k, v)})
default:
halt.As(100, reflect.TypeOf(e))
}
}
expr(e)
return stack.pop()
}
func (c *ForeignClass) copyOf() *ForeignClass {
assert.For(fn.IsNil(c.Entity), 20)
ret := &ForeignClass{}
*ret = *c
return ret
}
func main() {
var s, r *model.Layer
if _, err := os.Stat(name); os.IsNotExist(err) {
s = generate()
if f, err := os.Create(name); err == nil {
if err := std.Store(f, s); err != nil {
log.Fatal(err)
}
f.Close()
}
} else {
log.Println("file exists")
}
if f, err := os.Open(name); err == nil {
defer f.Close()
if s, err = std.Load(f); err != nil {
log.Fatal(err)
}
}
white := color.RGBA{R: 0xff, G: 0xFF, B: 0xFF, A: 0xFF}
if fi, err := os.Open("0.png"); err == nil {
if i, _, err := image.Decode(fi); err == nil {
j := 0
log.Println("image", i.Bounds())
for y := i.Bounds().Min.Y; y < i.Bounds().Max.Y; y++ {
for x := i.Bounds().Min.X; x < i.Bounds().Max.X; x++ {
c := i.At(x, y)
if c == white {
s.Nodes[j].In[model.Link{NodeId: 0, LinkId: 0}] = 1
} else {
s.Nodes[j].In[model.Link{NodeId: 0, LinkId: 0}] = 0
}
j++
}
}
} else {
log.Fatal(err)
}
} else {
log.Fatal(err)
}
/* for _, n := range s.Nodes {
n.In[model.Link{NodeId: 0, LinkId: 0}] = rand.Intn(2)
} */
t := make([]int, Nreact)
for i := 0; i < len(t); i++ {
t[i] = -1
}
t[0] = 1
for stop := false; !stop; { //autolearn for t pattern
for l := s; !fn.IsNil(l); l = l.Next {
proc.Process(l)
if l.Next != nil {
proc.Transfer(l)
} else {
r = l
}
}
a := make([]int, Nreact)
for i, n := range r.Nodes {
a[i] = n.Out[0].(int)
}
log.Println(t)
log.Println(a)
stop = true
for i, _ := range t {
switch {
case t[i] == 1 && a[i] == 1: //ok
case t[i] == 1 && a[i] != t[i]:
std.Update(s.Next, r.Nodes[i].In, 1)
stop = false
case t[i] == -1 && a[i] != t[i]:
std.Update(s.Next, r.Nodes[i].In, -1)
stop = false
}
}
}
if f, err := os.Create(name + ".0"); err == nil {
if err := std.Store(f, s); err != nil {
log.Fatal(err)
}
f.Close()
}
}