1 files changed, 387 insertions, 0 deletions
diff --git a/vendor/github.com/robertkrimen/otto/dbg/dbg.go b/vendor/github.com/robertkrimen/otto/dbg/dbg.go
new file mode 100644
index 000000000..8c27fa293
--- /dev/null
+++ b/vendor/github.com/robertkrimen/otto/dbg/dbg.go
@@ -0,0 +1,387 @@
+// This file was AUTOMATICALLY GENERATED by dbg-import (smuggol) from github.com/robertkrimen/dbg
+
+/*
+Package dbg is a println/printf/log-debugging utility library.
+
+    import (
+        Dbg "github.com/robertkrimen/dbg"
+    )
+
+    dbg, dbgf := Dbg.New()
+
+    dbg("Emit some debug stuff", []byte{120, 121, 122, 122, 121}, math.Pi)
+    # "2013/01/28 16:50:03 Emit some debug stuff [120 121 122 122 121] 3.141592653589793"
+
+    dbgf("With a %s formatting %.2f", "little", math.Pi)
+    # "2013/01/28 16:51:55 With a little formatting (3.14)"
+
+    dbgf("%/fatal//A fatal debug statement: should not be here")
+    # "A fatal debug statement: should not be here"
+    # ...and then, os.Exit(1)
+
+    dbgf("%/panic//Can also panic %s", "this")
+    # "Can also panic this"
+    # ...as a panic, equivalent to: panic("Can also panic this")
+
+    dbgf("Any %s arguments without a corresponding %%", "extra", "are treated like arguments to dbg()")
+    # "2013/01/28 17:14:40 Any extra arguments (without a corresponding %) are treated like arguments to dbg()"
+
+    dbgf("%d %d", 1, 2, 3, 4, 5)
+    # "2013/01/28 17:16:32 Another example: 1 2 3 4 5"
+
+    dbgf("%@: Include the function name for a little context (via %s)", "%@")
+    # "2013... github.com/robertkrimen/dbg.TestSynopsis: Include the function name for a little context (via %@)"
+
+By default, dbg uses log (log.Println, log.Printf, log.Panic, etc.) for output.
+However, you can also provide your own output destination by invoking dbg.New with
+a customization function:
+
+    import (
+        "bytes"
+        Dbg "github.com/robertkrimen/dbg"
+        "os"
+    )
+
+    # dbg to os.Stderr
+    dbg, dbgf := Dbg.New(func(dbgr *Dbgr) {
+        dbgr.SetOutput(os.Stderr)
+    })
+
+    # A slightly contrived example:
+    var buffer bytes.Buffer
+    dbg, dbgf := New(func(dbgr *Dbgr) {
+        dbgr.SetOutput(&buffer)
+    })
+
+*/
+package dbg
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"log"
+	"os"
+	"regexp"
+	"runtime"
+	"strings"
+	"unicode"
+)
+
+type _frmt struct {
+	ctl          string
+	format       string
+	operandCount int
+	panic        bool
+	fatal        bool
+	check        bool
+}
+
+var (
+	ctlTest = regexp.MustCompile(`^\s*%/`)
+	ctlScan = regexp.MustCompile(`%?/(panic|fatal|check)(?:\s|$)`)
+)
+
+func operandCount(format string) int {
+	count := 0
+	end := len(format)
+	for at := 0; at < end; {
+		for at < end && format[at] != '%' {
+			at++
+		}
+		at++
+		if at < end {
+			if format[at] != '%' && format[at] != '@' {
+				count++
+			}
+			at++
+		}
+	}
+	return count
+}
+
+func parseFormat(format string) (frmt _frmt) {
+	if ctlTest.MatchString(format) {
+		format = strings.TrimLeftFunc(format, unicode.IsSpace)
+		index := strings.Index(format, "//")
+		if index != -1 {
+			frmt.ctl = format[0:index]
+			format = format[index+2:] // Skip the second slash via +2 (instead of +1)
+		} else {
+			frmt.ctl = format
+			format = ""
+		}
+		for _, tmp := range ctlScan.FindAllStringSubmatch(frmt.ctl, -1) {
+			for _, value := range tmp[1:] {
+				switch value {
+				case "panic":
+					frmt.panic = true
+				case "fatal":
+					frmt.fatal = true
+				case "check":
+					frmt.check = true
+				}
+			}
+		}
+	}
+	frmt.format = format
+	frmt.operandCount = operandCount(format)
+	return
+}
+
+type Dbgr struct {
+	emit _emit
+}
+
+type DbgFunction func(values ...interface{})
+
+func NewDbgr() *Dbgr {
+	self := &Dbgr{}
+	return self
+}
+
+/*
+New will create and return a pair of debugging functions. You can customize where
+they output to by passing in an (optional) customization function:
+
+    import (
+        Dbg "github.com/robertkrimen/dbg"
+        "os"
+    )
+
+    # dbg to os.Stderr
+    dbg, dbgf := Dbg.New(func(dbgr *Dbgr) {
+        dbgr.SetOutput(os.Stderr)
+    })
+
+*/
+func New(options ...interface{}) (dbg DbgFunction, dbgf DbgFunction) {
+	dbgr := NewDbgr()
+	if len(options) > 0 {
+		if fn, ok := options[0].(func(*Dbgr)); ok {
+			fn(dbgr)
+		}
+	}
+	return dbgr.DbgDbgf()
+}
+
+func (self Dbgr) Dbg(values ...interface{}) {
+	self.getEmit().emit(_frmt{}, "", values...)
+}
+
+func (self Dbgr) Dbgf(values ...interface{}) {
+	self.dbgf(values...)
+}
+
+func (self Dbgr) DbgDbgf() (dbg DbgFunction, dbgf DbgFunction) {
+	dbg = func(vl ...interface{}) {
+		self.Dbg(vl...)
+	}
+	dbgf = func(vl ...interface{}) {
+		self.dbgf(vl...)
+	}
+	return dbg, dbgf // Redundant, but...
+}
+
+func (self Dbgr) dbgf(values ...interface{}) {
+
+	var frmt _frmt
+	if len(values) > 0 {
+		tmp := fmt.Sprint(values[0])
+		frmt = parseFormat(tmp)
+		values = values[1:]
+	}
+
+	buffer_f := bytes.Buffer{}
+	format := frmt.format
+	end := len(format)
+	for at := 0; at < end; {
+		last := at
+		for at < end && format[at] != '%' {
+			at++
+		}
+		if at > last {
+			buffer_f.WriteString(format[last:at])
+		}
+		if at >= end {
+			break
+		}
+		// format[at] == '%'
+		at++
+		// format[at] == ?
+		if format[at] == '@' {
+			depth := 2
+			pc, _, _, _ := runtime.Caller(depth)
+			name := runtime.FuncForPC(pc).Name()
+			buffer_f.WriteString(name)
+		} else {
+			buffer_f.WriteString(format[at-1 : at+1])
+		}
+		at++
+	}
+
+	//values_f := append([]interface{}{}, values[0:frmt.operandCount]...)
+	values_f := values[0:frmt.operandCount]
+	values_dbg := values[frmt.operandCount:]
+	if len(values_dbg) > 0 {
+		// Adjust frmt.format:
+		// (%v instead of %s because: frmt.check)
+		{
+			tmp := format
+			if len(tmp) > 0 {
+				if unicode.IsSpace(rune(tmp[len(tmp)-1])) {
+					buffer_f.WriteString("%v")
+				} else {
+					buffer_f.WriteString(" %v")
+				}
+			} else if frmt.check {
+				// Performing a check, so no output
+			} else {
+				buffer_f.WriteString("%v")
+			}
+		}
+
+		// Adjust values_f:
+		if !frmt.check {
+			tmp := []string{}
+			for _, value := range values_dbg {
+				tmp = append(tmp, fmt.Sprintf("%v", value))
+			}
+			// First, make a copy of values_f, so we avoid overwriting values_dbg when appending
+			values_f = append([]interface{}{}, values_f...)
+			values_f = append(values_f, strings.Join(tmp, " "))
+		}
+	}
+
+	format = buffer_f.String()
+	if frmt.check {
+		// We do not actually emit to the log, but panic if
+		// a non-nil value is detected (e.g. a non-nil error)
+		for _, value := range values_dbg {
+			if value != nil {
+				if format == "" {
+					panic(value)
+				} else {
+					panic(fmt.Sprintf(format, append(values_f, value)...))
+				}
+			}
+		}
+	} else {
+		self.getEmit().emit(frmt, format, values_f...)
+	}
+}
+
+// Idiot-proof &Dbgr{}, etc.
+func (self *Dbgr) getEmit() _emit {
+	if self.emit == nil {
+		self.emit = standardEmit()
+	}
+	return self.emit
+}
+
+// SetOutput will accept the following as a destination for output:
+//
+//      *log.Logger         Print*/Panic*/Fatal* of the logger
+//      io.Writer           -
+//      nil                 Reset to the default output (os.Stderr)
+//      "log"               Print*/Panic*/Fatal* via the "log" package
+//
+func (self *Dbgr) SetOutput(output interface{}) {
+	if output == nil {
+		self.emit = standardEmit()
+		return
+	}
+	switch output := output.(type) {
+	case *log.Logger:
+		self.emit = _emitLogger{
+			logger: output,
+		}
+		return
+	case io.Writer:
+		self.emit = _emitWriter{
+			writer: output,
+		}
+		return
+	case string:
+		if output == "log" {
+			self.emit = _emitLog{}
+			return
+		}
+	}
+	panic(output)
+}
+
+// ======== //
+// = emit = //
+// ======== //
+
+func standardEmit() _emit {
+	return _emitWriter{
+		writer: os.Stderr,
+	}
+}
+
+func ln(tmp string) string {
+	length := len(tmp)
+	if length > 0 && tmp[length-1] != '\n' {
+		return tmp + "\n"
+	}
+	return tmp
+}
+
+type _emit interface {
+	emit(_frmt, string, ...interface{})
+}
+
+type _emitWriter struct {
+	writer io.Writer
+}
+
+func (self _emitWriter) emit(frmt _frmt, format string, values ...interface{}) {
+	if format == "" {
+		fmt.Fprintln(self.writer, values...)
+	} else {
+		if frmt.panic {
+			panic(fmt.Sprintf(format, values...))
+		}
+		fmt.Fprintf(self.writer, ln(format), values...)
+		if frmt.fatal {
+			os.Exit(1)
+		}
+	}
+}
+
+type _emitLogger struct {
+	logger *log.Logger
+}
+
+func (self _emitLogger) emit(frmt _frmt, format string, values ...interface{}) {
+	if format == "" {
+		self.logger.Println(values...)
+	} else {
+		if frmt.panic {
+			self.logger.Panicf(format, values...)
+		} else if frmt.fatal {
+			self.logger.Fatalf(format, values...)
+		} else {
+			self.logger.Printf(format, values...)
+		}
+	}
+}
+
+type _emitLog struct {
+}
+
+func (self _emitLog) emit(frmt _frmt, format string, values ...interface{}) {
+	if format == "" {
+		log.Println(values...)
+	} else {
+		if frmt.panic {
+			log.Panicf(format, values...)
+		} else if frmt.fatal {
+			log.Fatalf(format, values...)
+		} else {
+			log.Printf(format, values...)
+		}
+	}
+}