// Format implements the NodeFormatter interface.
func (node IndexElem) Format(buf *bytes.Buffer, f FmtFlags) {
FormatNode(buf, f, node.Column)
if node.Direction != DefaultDirection {
buf.WriteByte(' ')
buf.WriteString(node.Direction.String())
}
}
func (c *aliasColumn) SerializeSqlForColumnList(out *bytes.Buffer) error {
if !validIdentifierName(c.name) {
return errors.Newf(
"Invalid alias name `%s`. Generated sql: %s",
c.name,
out.String())
}
if c.expression == nil {
return errors.Newf(
"Cannot alias a nil expression. Generated sql: %s",
out.String())
}
out.WriteByte('(')
if c.expression == nil {
return errors.Newf("nil alias clause. Generate sql: %s", out.String())
}
if err := c.expression.SerializeSql(out); err != nil {
return err
}
out.WriteString(") AS `")
out.WriteString(c.name)
out.WriteByte('`')
return nil
}
// parseMultivalueLine parses a line that includes several quoted values separated by whitespaces.
// Example: MachineMetadata="foo=bar" "baz=qux"
// If the provided line is not a multivalue string, the line is returned as the sole value.
func parseMultivalueLine(line string) (values []string) {
if !strings.HasPrefix(line, `"`) || !strings.HasSuffix(line, `"`) {
return []string{line}
}
var v bytes.Buffer
w := false // check whether we're within quotes or not
for _, e := range []byte(line) {
// ignore quotes
if e == '"' {
w = !w
continue
}
if e == ' ' {
if !w { // between quoted values, keep the previous value and reset.
values = append(values, v.String())
v.Reset()
continue
}
}
v.WriteByte(e)
}
values = append(values, v.String())
return
}
// Encode encodes the values into ``URL encoded'' form
// ("acl&bar=baz&foo=quux") sorted by key.
func Encode(v url.Values) string {
if v == nil {
return ""
}
var buf bytes.Buffer
keys := make([]string, 0, len(v))
for k := range v {
keys = append(keys, k)
}
sort.Strings(keys)
for _, k := range keys {
vs := v[k]
prefix := url.QueryEscape(k)
for _, v := range vs {
if buf.Len() > 0 {
buf.WriteByte('&')
}
buf.WriteString(prefix)
if v != "" {
buf.WriteString("=")
buf.WriteString(url.QueryEscape(v))
}
}
}
return buf.String()
}
// write2d prints the 2d matrix m into the buffer.
// value is a slice of already-printed values.
// The receiver provides only the shape of the matrix.
func (m Matrix) write2d(b *bytes.Buffer, value []string, width int) {
nrows := int(m.shape[0].(Int))
ncols := int(m.shape[1].(Int))
for row := 0; row < nrows; row++ {
if row > 0 {
b.WriteByte('\n')
}
index := row * ncols
for col := 0; col < ncols; col++ {
if col > 0 {
b.WriteByte(' ')
}
s := value[index]
pad := width - len(s)
for ; pad >= 10; pad -= 10 {
b.WriteString(" ")
}
for ; pad > 0; pad-- {
b.WriteString(" ")
}
b.WriteString(s)
index++
}
}
}
/**
* Escape string
*/
func (mysql *MySQL) Escape(str string) (esc string) {
if mysql.Logging {
log.Print("Escape called")
}
var prev byte
var b bytes.Buffer
for i := 0; i < len(str); i++ {
switch str[i] {
case '\'', '"':
if prev != '\\' {
b.WriteString(str[:i])
b.WriteByte('\\')
str = str[i:]
i = 0
}
}
prev = str[i]
}
b.WriteString(str)
return b.String()
}
func readSlidesDat() (slides []string, err error) {
f, err := os.Open("slides.dat")
if err != nil {
return
}
defer f.Close()
var buf bytes.Buffer
flush := func() {
s := strings.TrimSpace(buf.String())
if s != "" {
slides = append(slides, s+"\n")
}
buf.Reset()
}
bs := bufio.NewScanner(f)
for bs.Scan() {
if bs.Text() == "--" {
flush()
continue
}
buf.WriteString(bs.Text())
buf.WriteByte('\n')
}
flush()
return slides, bs.Err()
}
func (f *TextFormatter) appendKeyValue(b *bytes.Buffer, key string, value interface{}) {
b.WriteString(key)
b.WriteByte('=')
switch value := value.(type) {
case string:
if needsQuoting(value) {
b.WriteString(value)
} else {
fmt.Fprintf(b, "%q", value)
}
case error:
errmsg := value.Error()
if needsQuoting(errmsg) {
b.WriteString(errmsg)
} else {
fmt.Fprintf(b, "%q", value)
}
default:
fmt.Fprint(b, value)
}
b.WriteByte(' ')
}
func binExprFmtWithParen(buf *bytes.Buffer, f FmtFlags, e1 Expr, op string, e2 Expr) {
exprFmtWithParen(buf, f, e1)
buf.WriteByte(' ')
buf.WriteString(op)
buf.WriteByte(' ')
exprFmtWithParen(buf, f, e2)
}
func attrEscapeInCode(r Renderer, out *bytes.Buffer, src []byte) {
var prev byte
j := 0
for i := 0; i < len(src); i++ {
ch := src[i]
if ch == '<' && prev != '\\' {
if x := leftAngleCode(src[i:]); x > 0 {
j++
// Call the renderer's CalloutCode
r.CalloutCode(out, strconv.Itoa(j), string(src[i:i+x+1]))
i += x
prev = ch
continue
}
}
if ch == '\\' && i < len(src)-1 && src[i+1] == '<' {
// skip \\ here
prev = ch
continue
}
if entity, ok := escapeSingleChar(ch); ok {
out.WriteString(entity)
prev = ch
continue
}
out.WriteByte(ch)
prev = ch
}
}
func (options *html) Image(out *bytes.Buffer, link []byte, title []byte, alt []byte, subfigure bool) {
if options.flags&HTML_SKIP_IMAGES != 0 {
return
}
s := options.inlineAttr().String()
if subfigure {
s += " role=\"group\""
}
out.WriteString("<figure" + s + ">")
out.WriteString("<img src=\"")
options.maybeWriteAbsolutePrefix(out, link)
attrEscape(out, link)
out.WriteString("\" alt=\"")
if len(alt) > 0 {
attrEscape(out, alt)
}
if len(title) > 0 {
out.WriteString("\" title=\"")
attrEscape(out, title)
}
out.WriteByte('"')
out.WriteString(options.closeTag)
if len(title) > 0 {
out.WriteString("<figcaption>")
out.Write(title)
out.WriteString("</figcaption>")
}
out.WriteString("</figure>")
return
}
func (h FrameHeader) String() string {
var buf bytes.Buffer
buf.WriteString("[FrameHeader ")
buf.WriteString(h.Type.String())
if h.Flags != 0 {
buf.WriteString(" flags=")
set := 0
for i := uint8(0); i < 8; i++ {
if h.Flags&(1<<i) == 0 {
continue
}
set++
if set > 1 {
buf.WriteByte('|')
}
name := flagName[h.Type][Flags(1<<i)]
if name != "" {
buf.WriteString(name)
} else {
fmt.Fprintf(&buf, "0x%x", 1<<i)
}
}
}
if h.StreamID != 0 {
fmt.Fprintf(&buf, " stream=%d", h.StreamID)
}
fmt.Fprintf(&buf, " len=%d]", h.Length)
return buf.String()
}
func writeParam(buf *bytes.Buffer, key, value string) {
buf.Write([]byte("; "))
buf.WriteString(key)
buf.Write([]byte(`="`))
buf.WriteString(value)
buf.WriteByte('"')
}
func (c *ConnectPacket) Write(w io.Writer) error {
var body bytes.Buffer
var err error
body.Write(encodeString(c.ProtocolName))
body.WriteByte(c.ProtocolVersion)
body.WriteByte(boolToByte(c.CleanSession)<<1 | boolToByte(c.WillFlag)<<2 | c.WillQos<<3 | boolToByte(c.WillRetain)<<5 | boolToByte(c.PasswordFlag)<<6 | boolToByte(c.UsernameFlag)<<7)
body.Write(encodeUint16(c.KeepaliveTimer))
body.Write(encodeString(c.ClientIdentifier))
if c.WillFlag {
body.Write(encodeString(c.WillTopic))
body.Write(encodeBytes(c.WillMessage))
}
if c.UsernameFlag {
body.Write(encodeString(c.Username))
}
if c.PasswordFlag {
body.Write(encodeBytes(c.Password))
}
c.FixedHeader.RemainingLength = body.Len()
packet := c.FixedHeader.pack()
packet.Write(body.Bytes())
_, err = packet.WriteTo(w)
return err
}
func TestBMP180DriverMeasurements(t *testing.T) {
bmp180, adaptor := initTestBMP180DriverWithStubbedAdaptor()
adaptor.i2cReadImpl = func() ([]byte, error) {
buf := new(bytes.Buffer)
// Values from the datasheet example.
if adaptor.written[len(adaptor.written)-1] == bmp180RegisterAC1MSB {
binary.Write(buf, binary.BigEndian, int16(408))
binary.Write(buf, binary.BigEndian, int16(-72))
binary.Write(buf, binary.BigEndian, int16(-14383))
binary.Write(buf, binary.BigEndian, uint16(32741))
binary.Write(buf, binary.BigEndian, uint16(32757))
binary.Write(buf, binary.BigEndian, uint16(23153))
binary.Write(buf, binary.BigEndian, int16(6190))
binary.Write(buf, binary.BigEndian, int16(4))
binary.Write(buf, binary.BigEndian, int16(-32768))
binary.Write(buf, binary.BigEndian, int16(-8711))
binary.Write(buf, binary.BigEndian, int16(2868))
} else if adaptor.written[len(adaptor.written)-2] == bmp180CmdTemp && adaptor.written[len(adaptor.written)-1] == bmp180RegisterTempMSB {
binary.Write(buf, binary.BigEndian, int16(27898))
} else if adaptor.written[len(adaptor.written)-2] == bmp180CmdPressure && adaptor.written[len(adaptor.written)-1] == bmp180RegisterPressureMSB {
binary.Write(buf, binary.BigEndian, int16(23843))
// XLSB, not used in this test.
buf.WriteByte(0)
}
return buf.Bytes(), nil
}
bmp180.Start()
temp, err := bmp180.Temperature()
gobottest.Assert(t, err, nil)
gobottest.Assert(t, temp, float32(15.0))
pressure, err := bmp180.Pressure(BMP180UltraLowPower)
gobottest.Assert(t, err, nil)
gobottest.Assert(t, pressure, float32(69964))
}
// Format implements the NodeFormatter interface.
func (node *NullIfExpr) Format(buf *bytes.Buffer, f FmtFlags) {
buf.WriteString("NULLIF(")
FormatNode(buf, f, node.Expr1)
buf.WriteString(", ")
FormatNode(buf, f, node.Expr2)
buf.WriteByte(')')
}
func wrap(text string, length int) string {
var buf bytes.Buffer
var last rune
var lastNL bool
var col int
for _, c := range text {
switch c {
case '\r': // ignore this
continue // and also don't track `last`
case '\n': // ignore this too, but reset col
if col >= length || last == '\n' {
buf.WriteString("\n\n")
}
col = 0
case ' ', '\t': // opportunity to split
if col >= length {
buf.WriteByte('\n')
col = 0
} else {
if !lastNL {
buf.WriteRune(c)
}
col++ // count column
}
default:
buf.WriteRune(c)
col++
}
lastNL = c == '\n'
last = c
}
return buf.String()
}
func Decompress(dat []byte) ([]byte, error) {
buf := new(bytes.Buffer)
for i := 0; i < len(dat); i++ {
if dat[i] == token {
if i+1 < len(dat) {
switch dat[i+1] {
case emptyShaToken:
buf.Write(empty)
case emptyListShaToken:
buf.Write(emptyList)
case tokenToken:
buf.WriteByte(token)
default:
buf.Write(make([]byte, int(dat[i+1]-2)))
}
i++
} else {
return nil, errors.New("error reading bytes. token encountered without proceeding bytes")
}
} else {
buf.WriteByte(dat[i])
}
}
return buf.Bytes(), nil
}
func randomString(r *rand.Rand, n int) []byte {
b := new(bytes.Buffer)
for i := 0; i < n; i++ {
b.WriteByte(' ' + byte(r.Intn(95)))
}
return b.Bytes()
}
func (d *WordDecoder) convert(buf *bytes.Buffer, charset string, content []byte) error {
switch {
case strings.EqualFold("utf-8", charset):
buf.Write(content)
case strings.EqualFold("iso-8859-1", charset):
for _, c := range content {
buf.WriteRune(rune(c))
}
case strings.EqualFold("us-ascii", charset):
for _, c := range content {
if c >= utf8.RuneSelf {
buf.WriteRune(unicode.ReplacementChar)
} else {
buf.WriteByte(c)
}
}
default:
if d.CharsetReader == nil {
return fmt.Errorf("mime: unhandled charset %q", charset)
}
r, err := d.CharsetReader(strings.ToLower(charset), bytes.NewReader(content))
if err != nil {
return err
}
if _, err = buf.ReadFrom(r); err != nil {
return err
}
}
return nil
}
func (w *Walker) funcSigString(ft *ast.FuncType) string {
var b bytes.Buffer
b.WriteByte('(')
if ft.Params != nil {
for i, f := range ft.Params.List {
if i > 0 {
b.WriteString(", ")
}
b.WriteString(w.nodeString(w.namelessType(f.Type)))
}
}
b.WriteByte(')')
if ft.Results != nil {
if nr := len(ft.Results.List); nr > 0 {
b.WriteByte(' ')
if nr > 1 {
b.WriteByte('(')
}
for i, f := range ft.Results.List {
if i > 0 {
b.WriteString(", ")
}
b.WriteString(w.nodeString(w.namelessType(f.Type)))
}
if nr > 1 {
b.WriteByte(')')
}
}
}
return b.String()
}
// TODO gocui doesn't support color text:
// https://github.com/jroimartin/gocui/issues/9
func (f *GuiFormatter) Format(entry *log.Entry) ([]byte, error) {
buf := new(bytes.Buffer)
ts := entry.Time.Format("15:04:05")
fmt.Fprintf(buf, "%s %s | ", ts, entry.Level.String())
call, hasCall := entry.Data["call"].(string)
if hasCall {
fmt.Fprintf(buf, "%s ", call)
}
if entry.Message != "" {
fmt.Fprintf(buf, "%s ", entry.Message)
}
for _, k := range []string{"call"} {
delete(entry.Data, k)
}
if len(entry.Data) > 0 {
fmt.Fprint(buf, "| ")
writeMap(buf, entry.Data)
}
buf.WriteByte('\n')
return buf.Bytes(), nil
}
func newline(dst *bytes.Buffer, prefix, indent string, depth int) {
dst.WriteByte('\n')
dst.WriteString(prefix)
for i := 0; i < depth; i++ {
dst.WriteString(indent)
}
}
func twoDigits(b *bytes.Buffer, d int) {
c2 := digits[d%10]
d /= 10
c1 := digits[d%10]
b.WriteByte(c1)
b.WriteByte(c2)
}
// decorate prefixes the string with the file and line of the call site
// and inserts the final newline if needed and indentation tabs for formatting.
func decorate(s string) string {
_, file, line, ok := runtime.Caller(3) // decorate + log + public function.
if ok {
// Truncate file name at last file name separator.
if index := strings.LastIndex(file, "/"); index >= 0 {
file = file[index+1:]
} else if index = strings.LastIndex(file, "\\"); index >= 0 {
file = file[index+1:]
}
} else {
file = "???"
line = 1
}
buf := new(bytes.Buffer)
// Every line is indented at least one tab.
buf.WriteByte('\t')
fmt.Fprintf(buf, "%s:%d: ", file, line)
lines := strings.Split(s, "\n")
if l := len(lines); l > 1 && lines[l-1] == "" {
lines = lines[:l-1]
}
for i, line := range lines {
if i > 0 {
// Second and subsequent lines are indented an extra tab.
buf.WriteString("\n\t\t")
}
buf.WriteString(line)
}
buf.WriteByte('\n')
return buf.String()
}
// tracef is like fmt.Printf but it rewrites the format string
// to take care of indentation.
func (p *exporter) tracef(format string, args ...interface{}) {
if strings.IndexAny(format, "<>\n") >= 0 {
var buf bytes.Buffer
for i := 0; i < len(format); i++ {
// no need to deal with runes
ch := format[i]
switch ch {
case '>':
p.indent++
continue
case '<':
p.indent--
continue
}
buf.WriteByte(ch)
if ch == '\n' {
for j := p.indent; j > 0; j-- {
buf.WriteString(". ")
}
}
}
format = buf.String()
}
fmt.Printf(format, args...)
}
// String reassembles the URL into a valid URL string.
func (u *URL) String() string {
var buf bytes.Buffer
if u.Scheme != "" {
buf.WriteString(u.Scheme)
buf.WriteByte(':')
}
if u.Opaque != "" {
buf.WriteString(u.Opaque)
} else {
if u.Scheme != "" || u.Host != "" || u.User != nil {
buf.WriteString("//")
if ui := u.User; ui != nil {
buf.WriteString(ui.String())
buf.WriteByte('@')
}
if h := u.Host; h != "" {
buf.WriteString(h)
}
}
if u.Path != "" && u.Path[0] != '/' && u.Host != "" {
buf.WriteByte('/')
}
buf.WriteString(escape(u.Path, encodePath))
}
if u.RawQuery != "" {
buf.WriteByte('?')
buf.WriteString(u.RawQuery)
}
if u.Fragment != "" {
buf.WriteByte('#')
buf.WriteString(escape(u.Fragment, encodeFragment))
}
return buf.String()
}
func buildCallerPrefix(file string, line int, s string) string {
buf := new(bytes.Buffer)
// Every line is indented at least one tab.
err := buf.WriteByte('\t')
if err != nil {
return "???:1"
}
fmt.Fprintf(buf, "%s:%d: ", file, line)
lines := strings.Split(s, "\n")
if l := len(lines); l > 1 && lines[l-1] == "" {
lines = lines[:l-1]
}
for i, l := range lines {
if i > 0 {
// Second and subsequent lines are indented an extra tab.
_, err = buf.WriteString("\n\t\t")
if err != nil {
return "???:1"
}
}
_, err = buf.WriteString(l)
if err != nil {
return "???:1"
}
}
err = buf.WriteByte('\n')
if err != nil {
return "???:1"
}
return buf.String()
}
func (options *Html) BlockCode(out *bytes.Buffer, text []byte, lang string) {
doubleSpace(out)
// parse out the language names/classes
count := 0
for _, elt := range strings.Fields(lang) {
if elt[0] == '.' {
elt = elt[1:]
}
if len(elt) == 0 {
continue
}
if count == 0 {
out.WriteString("<pre><code class=\"language-")
} else {
out.WriteByte(' ')
}
attrEscape(out, []byte(elt))
count++
}
if count == 0 {
out.WriteString("<pre><code>")
} else {
out.WriteString("\">")
}
attrEscape(out, text)
out.WriteString("</code></pre>\n")
}
func exactInvertedPrefix(val []byte) []byte {
var buf bytes.Buffer
buf.Grow(len(val) + 1)
buf.Write(val)
buf.WriteByte(invertedKeySep)
return buf.Bytes()
}