func (e *Engine) ascii85() error {
b := e.stack.Pop()
enc := make([]byte, ascii85.MaxEncodedLen(len(b)))
sz := ascii85.Encode(enc, b)
e.stack.Push(enc[0:sz])
return nil
}
func (x *XMLLLSDParser) parseBinary(encoding string) []byte {
for {
token, err := x.decoder.Token()
if err != nil {
panic(err)
}
switch t := token.(type) {
case xml.StartElement:
panic("Unexpected start element in <binary>")
case xml.CharData:
defer x.decoder.Skip()
switch encoding {
case "base64", "":
b64, _ := base64.StdEncoding.DecodeString(string(t))
return b64
case "base85":
b85 := make([]byte, ascii85.MaxEncodedLen(len(t)))
n, _, _ := ascii85.Decode(b85, t, true)
return b85[:n]
case "base16":
output := make([]byte, len(t)/2)
for i := 0; i < len(t); i += 2 {
n, _ := strconv.ParseInt(string(t[i:i+2]), 16, 8)
output[i/2] = byte(n)
}
return output
}
case xml.EndElement:
return make([]byte, 0)
}
}
panic("unreachable")
}
func poplop(master string, n Scheme) (string, error) {
h := sha512.New()
io.WriteString(h, master)
io.WriteString(h, n.Name)
if n.Counter > 0 {
io.WriteString(h, strconv.Itoa(n.Counter))
}
hash := h.Sum(nil)
dst := make([]byte, ascii85.MaxEncodedLen(len(hash)))
ascii85.Encode(dst, hash)
str := string(dst)
if n.Forbidden != "" {
str = strings.Map(n.mapping(), str)
}
length := 20
if n.MaxLength > 0 {
length = n.MaxLength
}
if len(str) < length {
return "", errors.New("hash not long enough " + str)
}
return str[:length], nil
}
func (x *DNSTransportDownstreamCodec) Encode(msg []byte, header DNSCodecHeader) string {
header_bytes := x.header_codec.EncodeToBytes(&header)
dst := make([]byte, ascii85.MaxEncodedLen(4+len(msg)))
ret_len := ascii85.Encode(dst[0:5], header_bytes[:])
ret_len += ascii85.Encode(dst[5:], msg)
return string(dst[:ret_len])
}
func insertAssets(w io.Writer, fc *fileCollection, c *config) (err error) {
// NewAsset(name string, content []byte, size int64, mode os.FileMode, modTime time.Time) *Asset
_, err = fmt.Fprint(w, "\n\tvar assets = map[string]magpie.Asset{\n")
if err != nil {
return
}
for _, a := range fc.assets {
fmt.Printf("Hash length:%v\n", a.hash)
hash := make([]byte, ascii85.MaxEncodedLen(len(a.hash)))
l := ascii85.Encode(hash, a.hash)
_, err = fmt.Fprintf(w, "\t\t%q: magpie.NewAsset(%q, read(_%s), %d, os.FileMode(%d), time.Unix(%d, 0), %q),\n", a.name, a.name, a.constant, a.info.Size(), a.info.Mode(), a.info.ModTime().Unix(), string(hash[:l]))
if err != nil {
return
}
}
_, err = fmt.Fprint(w, "\n\t}\n")
return
}
func main() {
// lock
ln, err := net.Listen("tcp", "127.0.0.1:61297")
if err != nil {
fmt.Printf("lock failed.\n")
return
}
defer ln.Close()
mem := &Memory{
Concepts: make(map[string]*Concept),
Connects: make(map[string]*Connect),
}
mem.Load()
getPendingConnect := func(now time.Time) []*Connect {
var connects []*Connect
for _, connect := range mem.Connects {
from := mem.Concepts[connect.From]
if (from.What == WORD || from.What == SENTENCE) && from.Incomplete {
continue
}
lastHistory := connect.Histories[len(connect.Histories)-1]
if lastHistory.Time.Add(LevelTime[lastHistory.Level]).After(now) {
continue
}
connects = append(connects, connect)
}
return connects
}
var cmd string
if len(os.Args) == 1 {
cmd = "train"
} else {
cmd = os.Args[1]
}
max := 22
if len(os.Args) == 2 && regexp.MustCompile(`[0-9]+`).MatchString(os.Args[1]) {
max, _ = strconv.Atoi(os.Args[1])
cmd = "train"
}
// add audio files
if cmd == "add" {
if len(os.Args) < 3 {
fmt.Printf("word or sentence?\n")
os.Exit(0)
}
t := os.Args[2]
var what int
if strings.HasPrefix(t, "w") {
what = WORD
} else if strings.HasPrefix(t, "s") {
what = SENTENCE
} else {
fmt.Printf("unknown type\n")
os.Exit(0)
}
p := filepath.Join(rootPath, "files")
fmt.Printf("files directory: %s\n", p)
hasher := sha512.New()
for _, f := range os.Args[2:] {
data, err := ioutil.ReadFile(f)
if err != nil {
continue
}
f, _ = filepath.Abs(f)
f = strings.TrimPrefix(f, p)
hasher.Reset()
hasher.Write(data)
buf := make([]byte, ascii85.MaxEncodedLen(sha512.Size))
l := ascii85.Encode(buf, hasher.Sum(nil))
concept := &Concept{
What: AUDIO,
File: f,
FileHash: string(buf[:l]),
}
exists := mem.AddConcept(concept)
if exists {
fmt.Printf("skip %s\n", f)
} else {
fmt.Printf("add %s %s\n", f, concept.FileHash)
// add text concept
textConcept := &Concept{
What: what,
Incomplete: true,
Serial: mem.NextSerial(),
}
mem.AddConcept(textConcept)
// add connect
mem.AddConnect(&Connect{
From: concept.Key(),
To: textConcept.Key(),
Histories: []History{
{Level: 0, Time: time.Now()},
},
})
if what == WORD {
mem.AddConnect(&Connect{
From: textConcept.Key(),
To: concept.Key(),
Histories: []History{
{Level: 0, Time: time.Now()},
},
})
}
}
}
// show stat
fmt.Printf("%d concepts, %d connects\n", len(mem.Concepts), len(mem.Connects))
mem.Save()
// train
} else if cmd == "train" {
connects := getPendingConnect(time.Now())
// sort
sort.Sort(ConnectSorter{connects, mem})
if len(connects) > max {
connects = connects[:max]
}
// ui
//ui_qt(connects, mem)
ui_gtk(connects, mem)
// complete connection
} else if cmd == "complete" {
for _, connect := range mem.Connects {
from := mem.Concepts[connect.From]
if !from.Incomplete && from.Text != "" {
continue
}
if from.What != WORD {
continue
}
to := mem.Concepts[connect.To]
fmt.Printf("%s\n", to.File)
to.Play()
fmt.Scanf("%s\n", &from.Text)
if from.Text == "" {
continue
}
from.Incomplete = false
mem.Save()
}
// train history
} else if cmd == "history" {
counter := make(map[string]int)
for _, connect := range mem.Connects {
for _, entry := range connect.Histories {
t := entry.Time
counter[fmt.Sprintf("%04d-%02d-%02d", t.Year(), t.Month(), t.Day())]++
}
}
var dates []string
for date := range counter {
dates = append(dates, date)
}
sort.Strings(dates)
for _, date := range dates {
fmt.Printf("%s %d\n", date, counter[date])
}
}
}