func writeQuotedString(s string, b *bufio.Writer, f *Format) {
b.WriteRune('"')
for i := range s {
c := s[i] // don't decode as runes
switch c {
case '\r':
b.WriteString(`\r`)
case '\n':
b.WriteString(`\n`)
case '\t':
b.WriteString(`\t`)
case '"':
b.WriteString(`\"`)
case '\\':
b.WriteString(`\\`)
default:
if c < 0x80 && unicode.IsPrint(rune(c)) {
b.WriteRune(rune(c))
} else {
b.WriteString(`\x`)
b.WriteRune(enchex((c >> 4) & 0x0F))
b.WriteRune(enchex(c & 0x0F))
}
}
}
b.WriteRune('"')
}
func CSVWriteVal(cw *bufio.Writer, i interface{}) {
sVal := fmt.Sprintf("%v", i)
if len(sVal) <= 0 {
return
}
bQuot := strings.IndexRune(sVal, ',') >= 0 || strings.IndexAny(sVal, "\"\r\n") >= 0
if !bQuot {
cw.WriteString(sVal)
return
}
cw.WriteByte('"')
for _, r1 := range sVal {
switch r1 {
case '"':
cw.WriteString(`""`)
case '\r':
cw.WriteByte('\r')
case '\n':
cw.WriteByte('\n')
default:
cw.WriteRune(r1)
}
}
cw.WriteByte('"')
}
func writeBase64String(s string, b *bufio.Writer, f *Format) {
b.WriteRune('|')
w := base64.NewEncoder(base64.StdEncoding, b)
w.Write([]byte(s))
w.Close()
b.WriteRune('|')
}
func doWriteRune(w *bufio.Writer) {
if written, err := w.WriteRune(rune('o')); err != nil {
log.Fatalf("failed writing a rune: %s", err)
} else {
log.Printf("Wrote rune in %d bytes", written)
}
}
func (t *TcpPlayer) sendUpdates(w *bufio.Writer, wg *sync.WaitGroup) {
defer wg.Done()
enc := json.NewEncoder(w)
lastTurnSent := -1
for update := range t.update {
t.stateL.Lock()
t.state = update
t.stateL.Unlock()
if update.Turn == lastTurnSent {
continue
}
if err := enc.Encode(update); err != nil {
t.l.Errorf("[TCP] sending update to player, %v", err)
return
}
if _, err := w.WriteRune('\n'); err != nil {
t.l.Errorf("[TCP] sending EOL to player, %v", err)
return
}
if err := w.Flush(); err != nil {
t.l.Errorf("[TCP] flushing update to player, %v", err)
return
}
lastTurnSent = update.Turn
}
}
func (s *spacer) write(b *bufio.Writer, t rune) {
if s.f.serializationMode == szModeCanonical {
return
}
if s.prevType == 'i' || s.prevType == 's' {
b.WriteRune(' ')
}
s.prevType = t
}
// Prints a horizontal line for the table based on a row.
func (table Table) printHorizontalLine(w *bufio.Writer, r row) {
if len(r) != 0 {
w.WriteRune(table.CSeparator)
for i, _ := range r {
fmt.Fprintf(w, "%s%s", strings.Repeat(string(table.HSeparator), table.colWidth[i]+2), string(table.CSeparator))
}
w.WriteRune(newline)
}
}
func copyNext(in *scanner.Scanner, out *bufio.Writer) error {
c := in.Next()
if out != nil {
if n, err := out.WriteRune(c); err == nil && n < 1 {
return fmt.Errorf("Couldn't write: %c", c)
} else if err != nil {
return err
}
}
return nil
}
func (p *Parser) writeHelpOption(writer *bufio.Writer, option *Option, maxlen int, hasshort bool, termcol int) {
if option.ShortName != 0 {
writer.WriteString(" -")
writer.WriteRune(option.ShortName)
} else if hasshort {
writer.WriteString(" ")
}
written := 0
prelen := 4
if option.LongName != "" {
if option.ShortName != 0 {
writer.WriteString(", ")
} else {
writer.WriteString(" ")
}
fmt.Fprintf(writer, "--%s", option.LongName)
written = utf8.RuneCountInString(option.LongName)
prelen += written + 4
}
if option.Description != "" {
if written < maxlen {
dw := maxlen - written
writer.WriteString(strings.Repeat(" ", dw))
prelen += dw
}
def := option.Default
if def == "" && !option.isBool() {
def = convertToString(option.Value, option.Field.Tag)
}
var desc string
if def != "" {
desc = fmt.Sprintf("%s (%v)", option.Description, def)
} else {
desc = option.Description
}
writer.WriteString(wrapText(desc,
termcol-prelen,
strings.Repeat(" ", prelen)))
}
writer.WriteString("\n")
}
func writeString(s string, b *bufio.Writer, f *Format) {
if f.serializationMode == szModeAdvanced {
if isBinary(s) {
writeBase64String(s, b, f)
} else if usesTokenCharset(s) {
writeToken(s, b, f)
} else {
writeQuotedString(s, b, f)
}
return
}
writeUint(uint64(len(s)), b, f)
b.WriteRune(':')
b.WriteString(s)
}
func outputLine(w *bufio.Writer, line string, suffix string, count int) (err error) {
if count > 0 {
if _, err = w.WriteRune('\t'); nil != err {
return err
}
}
if _, err = w.WriteString(line); nil != err {
return err
}
if _, err = w.WriteString(suffix); nil != err {
return err
}
if _, err = w.WriteRune('\n'); nil != err {
return err
}
return nil
}
// write writes a protocol buffer to the socketAPI socket.
func write(w *bufio.Writer, pb proto.Message) error {
b, err := proto.Marshal(pb)
if err != nil {
return err
}
var buf bytes.Buffer
buf.WriteString(strconv.Itoa(len(b)))
buf.WriteString("\n")
buf.Write(b)
body := base64.StdEncoding.EncodeToString(buf.Bytes())
w.WriteString(body)
w.WriteRune('\n')
return w.Flush()
}
func writeList(vs []interface{}, b *bufio.Writer, f *Format) error {
spacer := spacer{f: f}
for _, v := range vs {
switch vv := v.(type) {
case string:
spacer.write(b, 's')
writeString(vv, b, f)
case []byte:
spacer.write(b, 's')
writeString(string(vv), b, f)
case int:
spacer.write(b, 'i')
writeInt(int64(vv), b, f)
if f.serializationMode == szModeCanonical {
b.WriteRune(' ')
}
case int64:
spacer.write(b, 'i')
writeInt(vv, b, f)
if f.serializationMode == szModeCanonical {
b.WriteRune(' ')
}
case uint64:
spacer.write(b, 'i')
writeUint(vv, b, f)
if f.serializationMode == szModeCanonical {
b.WriteRune(' ')
}
case []interface{}:
spacer.write(b, '(')
b.WriteRune('(')
if err := writeList(vv, b, f); err != nil {
return err
}
b.WriteRune(')')
default:
return ErrUnsupportedType
}
}
return nil
}
func writeSanitized(buf *bufio.Writer, s string) error {
prevUnderscore := false
for _, c := range s {
c = replaceInvalidRune(c)
if c == '_' {
if prevUnderscore {
continue
}
prevUnderscore = true
} else {
prevUnderscore = false
}
if _, err := buf.WriteRune(c); err != nil {
return err
}
}
return nil
}
// Prints the data that is contained inside the specified row.
func (table Table) printRowData(w *bufio.Writer, r row) {
maxLines := r.maxLines()
for i := 0; i < maxLines; i++ {
w.WriteRune(table.VSeparator)
for j := 0; j < len(r); j++ {
var data string
if i >= len(r[j]) {
data = strings.Repeat(" ", table.colWidth[j])
} else {
data = r[j][i]
}
fmt.Fprintf(w, " %s ", table.Align.align(data, table.colWidth[j]))
w.WriteRune(table.VSeparator)
}
w.WriteRune(newline)
}
}
func escapeProp(buf *bufio.Writer, s string, isKey bool) {
for x, r := range s {
if r > 61 && r < 127 {
if r == '\\' {
buf.WriteRune('\\')
buf.WriteRune('\\')
continue
}
buf.WriteRune(r)
continue
}
switch {
case r == ' ':
if x == 0 || isKey {
buf.WriteRune('\\')
}
buf.WriteRune(' ')
case r == '\t':
buf.WriteRune('\\')
buf.WriteRune('t')
case r == '\n':
buf.WriteRune('\\')
buf.WriteRune('n')
case r == '\r':
buf.WriteRune('\\')
buf.WriteRune('r')
case r == '\f':
buf.WriteRune('\\')
buf.WriteRune('f')
case r == '=', r == ':', r == '#', r == '!':
buf.WriteRune('\\')
buf.WriteRune(r)
case int32(r) < 0x20, int32(r) > 0x7e:
buf.WriteRune('\\')
buf.WriteRune('u')
buf.WriteRune(rune(unhex[int32(r)>>12&0xF]))
buf.WriteRune(rune(unhex[int32(r)>>8&0xF]))
buf.WriteRune(rune(unhex[int32(r)>>4&0xF]))
buf.WriteRune(rune(unhex[int32(r)&0xF]))
default:
buf.WriteRune(r)
}
}
}
func LogKeeper(verbose bool) {
var skip error
var logw *bufio.Writer
defer func() {
if r := recover(); r != nil {
fmt.Println("Logger trace:", r)
}
}()
logq = make(chan LogMessage, 1024)
logf, skip := os.Create(cfg.ErrorLog)
if skip == nil {
logw = bufio.NewWriter(logf)
fmt.Printf("Error log: %s\n", cfg.ErrorLog)
} else {
println("Can't create file for error log. Error logging to file skiped.")
}
for {
timeout := make(chan bool, 1)
go func() {
time.Sleep(2 * time.Second)
timeout <- true
}()
select {
case msg := <-logq:
if skip == nil {
logw.WriteString(msg.Started.Format(TimeFormat))
logw.WriteRune(' ')
switch msg.Severity {
case WARNING:
logw.WriteString("warning")
case ERROR:
logw.WriteString("error")
}
logw.WriteString(": ")
logw.WriteString(StreamErr2String(msg.Result.ErrType))
logw.WriteRune(' ')
logw.WriteString(strconv.Itoa(msg.HTTPCode))
logw.WriteRune(' ')
logw.WriteString(strconv.FormatInt(msg.ContentLength, 10))
logw.WriteRune(' ')
logw.WriteString(msg.Elapsed.String())
logw.WriteRune(' ')
logw.WriteString(msg.Group)
logw.WriteString(": ")
logw.WriteString(msg.Name)
logw.WriteRune('\n')
}
case <-timeout:
if skip == nil {
_ = logw.Flush()
}
}
}
}
// Write internal data structure to stream writer.
func (d *Data) writeData(wrt *bufio.Writer, level int) {
// emit name (if defined)
if len(d.Name) > 0 {
wrt.WriteString(d.Name)
wrt.WriteRune('=')
}
// handle value..
if d.Len() == 0 {
// .. as direct value
wrt.WriteRune('"')
wrt.WriteString(d.Value)
wrt.WriteRune('"')
} else {
// .. as list of data
if level > 0 {
wrt.WriteRune('{')
}
// handle all list elements...
count := d.Len()
for n := 0; n < count; n++ {
// emit delimiter
if n > 0 {
wrt.WriteRune(',')
}
// recursively write list element
s := d.At(n).(*Data)
s.writeData(wrt, level+1)
}
if level > 0 {
wrt.WriteRune('}')
}
}
}
