// Print calls Output to print to the standard logger.
// Arguments are handled in the manner of fmt.Print.
424215
func (l *dglog) Debug(v ...interface{}) {
	if l.runLevel == common.RUN_DEBUG {
		v = append([]interface{}{common.RUN_DEBUG_FORMAT}, v...)
		logDataChan <- fmt.Sprint(v...)
	}
}
283025
func Print(v ...interface{}) {
	std.Fprint(std.flags, LEVEL_PRINT, 2, fmt.Sprint(v...), nil)
}
661916
func (g *Generator) Printf(format string, a ...interface{}) {
	if _, err := fmt.Fprintf(&g.buf, format, a...); err != nil {
		log.Fatalln(err)
	}
}
188967
func (tp *TabPrinter) Print(arg interface{}) {
	if tp.current > 0 {
		if (tp.current % tp.max) == 0 {
			fmt.Fprintln(tp.w, "")
			tp.w.Flush()
			tp.current = 0
		} else {
			fmt.Fprint(tp.w, "\t")
		}
	}

	tp.current++
	fmt.Fprint(tp.w, arg)
}
522730
func (h *Histogram) Print(w io.Writer) {
	h.h.RLock()
	defer h.h.RUnlock()
	fmt.Fprintf(w, h.h.String())
}
161776
func (p *Printer) Print(obj runtime.Object, w io.Writer) error {
	if obj == nil {
		return nil
	}
	data, err := yaml.Marshal(obj)
	if err != nil {
		return err
	}
	_, err = w.Write(data)
	return err

}
1062564
func (p FmtPrinter) Println(logger *Logger, a ...interface{}) {
	b := make([]interface{}, 1)
	b[0] = logger.Color(logger.Name)
	a = append(b, a...)
	format := strings.Repeat("%s ", len(b))
	fmt.Fprintf(os.Stderr, format, a...)
}
844059
func (l *loggerImpl) print(level int, lstr string, msg string, args ...interface{}) {
	l.Lock()
	defer l.Unlock()
	var t = time.Now().Format("15:04:05.000000")
	var c = colors[level]
	c.Println(fmt.Sprintf("%s%s %s %s", l.prefix, lstr, t, fmt.Sprintf(msg, args...)))
}
733428
func (p *Progress) Print(optionals ...bool) {
	stream := os.Stderr
	if len(optionals) > 0 {
		if optionals[0] {
			stream = os.Stdout
		}
	}
	f := bufio.NewWriter(stream)
	defer f.Flush()
	f.WriteString(fmt.Sprintf("% *s\r", p.sOutput, ""))
	f.WriteString(p.String() + "\r")
}
847957
func Print(priority Priority, format string, a ...interface{}) error {
	return Send(fmt.Sprintf(format, a...), priority, nil)
}
320666
func (logger *Logger) Printf(format string, args ...interface{}) {
	logger.header(1).Printf(format, args...)
}
1051032
func (l *Logger) Printf(format string, a ...interface{}) {
	if l.Enabled {
		currentPrinter.Printf(l, format, a...)
	}
}
385053
func (l *Logger) Printf(format string, v ...interface{}) {
	l.Fprint(l.flags, LEVEL_PRINT, 2, fmt.Sprintf(format, v...), nil)
}
899133
func (c *Chan) Print() {
	c.Do(func(path Path) { fmt.Printf("path %s\n", path.String()) })
}
994414
func (l Logger) Println(args ...interface{}) {
	l.fileMu.RLock()
	l.Logger.Println(args...)
	l.fileMu.RUnlock()
}
880202
func (n *LevelLogger) Printf(format string, v ...interface{}) {
	if !n.Enabled() {
		return
	}
	n.mu.RLock()
	n.logger.Output(callDepth, fmt.Sprintf(format, v...))
	n.mu.RUnlock()
}
916257
func print(thread *Thread, fn *Builtin, args Tuple, kwargs []Tuple) (Value, error) {
	var buf bytes.Buffer
	path := make([]Value, 0, 4)
	sep := ""
	for _, v := range args {
		buf.WriteString(sep)
		if s, ok := AsString(v); ok {
			buf.WriteString(s)
		} else {
			writeValue(&buf, v, path)
		}
		sep = " "
	}
	for _, pair := range kwargs {
		buf.WriteString(sep)
		buf.WriteString(string(pair[0].(String)))
		buf.WriteString("=")
		if s, ok := AsString(pair[1]); ok {
			buf.WriteString(s)
		} else {
			writeValue(&buf, pair[1], path)
		}
		sep = " "
	}

	if thread.Print != nil {
		thread.Print(thread, buf.String())
	} else {
		fmt.Fprintln(os.Stderr, &buf)
	}
	return None, nil
}