* Returns a byte array */
func formatArgs(args [][]byte) []byte {
// * args count \r\n
n := 1 + intlen(len(args)) + 2
for i := 0; i < len(args); i++ {
n += arglen(args[i])
}
buf = append(buf, star)
buf = strconv.AppendUint(buf, uint64(len(args)), 10)
buf = append(buf, delim...)
* Returns a byte array */
func format(args ...interface{}) []byte {
buf := make([][]byte, len(args))
return formatArgs(buf)
}
* Returns a byte array */
func formatArgs(args [][]byte) []byte {
// * args count \r\n
n := 1 + intlen(len(args)) + 2
for i := 0; i < len(args); i++ {
n += arglen(args[i])
}
buf = append(buf, star)
buf = strconv.AppendUint(buf, uint64(len(args)), 10)
buf = append(buf, delim...)
* Returns a byte array */
func format(args ...interface{}) []byte {
buf := make([][]byte, len(args))
return formatArgs(buf)
}
func (check *checker) printTrace(format string, args []interface{}) {
const dots = ". . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . "
fmt.Print(dots[0:i])
fmt.Println(check.formatMsg(format, args))
}
func (check *checker) trace(pos token.Pos, format string, args ...interface{}) {
check.pos = append(check.pos, pos)
check.printTrace(format, args)
}
func (check *checker) untrace(format string, args ...interface{}) {
if len(format) > 0 {
check.printTrace(format, args)
}
// errorf formats the error and terminates processing.
func (s *state) errorf(format string, args ...interface{}) {
name := doublePercent(s.tmpl.Name())
}
panic(fmt.Errorf(format, args...))
}
argv := make([]reflect.Value, numIn)
// Args must be evaluated. Fixed args first.
i := 0
for ; i < numFixed; i++ {
argv[i] = s.evalArg(dot, typ.In(i), args[i])
}
// Now the ... args.
if typ.IsVariadic() {
argType := typ.In(typ.NumIn() - 1).Elem() // Argument is a slice.
for ; i < len(args); i++ {
argv[i] = s.evalArg(dot, argType, args[i])
// and records the text in the error log.
func (c *common) Logf(format string, args ...interface{}) { c.log(fmt.Sprintf(format, args...)) }
// Errorf is equivalent to Logf() followed by Fail().
func (c *common) Errorf(format string, args ...interface{}) {
c.log(fmt.Sprintf(format, args...))
c.Fail()
// Fatal is equivalent to Log() followed by FailNow().
func (c *common) Fatal(args ...interface{}) {
c.log(fmt.Sprintln(args...))
c.FailNow()
// Fatalf is equivalent to Logf() followed by FailNow().
func (c *common) Fatalf(format string, args ...interface{}) {
c.log(fmt.Sprintf(format, args...))
c.FailNow()
// FIXME don't assume string...
format += "%s"
case *types.Pointer:
format += "0x%lx"
args = append(args, llvm_value)
}
formatval := c.builder.CreateGlobalStringPtr(format, "")
args = append([]llvm.Value{formatval}, args...)
} else {
}
args = []llvm.Value{c.builder.CreateGlobalStringPtr(format, "")}
}
func (check *checker) sprintf(format string, args ...interface{}) string {
for i, arg := range args {
}
return fmt.Sprintf(format, args...)
}
func (check *checker) trace(pos token.Pos, format string, args ...interface{}) {
fmt.Printf("%s:\t%s%s\n",
strings.Repeat(". ", check.indent),
check.sprintf(format, args...),
)
// dump is only needed for debugging
func (check *checker) dump(format string, args ...interface{}) {
fmt.Println(check.sprintf(format, args...))
func NewUnmarshalError(n *Node, t reflect.Type, format string, args ...interface{}) *UnmarshalError {
return &UnmarshalError{
Node: n,
message: fmt.Sprintf(format, args...),
}
func (e *UnmarshalError) Error() string {
args := []interface{}{e.message}
format := "%s"
return fmt.Sprintf(format, args...)
}
func (n *Node) unmarshal_error(t reflect.Type, format string, args ...interface{}) {
panic(NewUnmarshalError(n, t, fmt.Sprintf(format, args...)))
}
// log.AddFilter("log", log4go.FINE, log4go.NewFileLogWriter("example.log", true))
// log.Info("The time is now: %s", time.LocalTime().Format("15:04:05 MST 2006/01/02"))
//
// log.AddFilter("log", log4go.FINE, log4go.NewFileLogWriter("example.log", true))
// log.Info("The time is now: %s", time.LocalTime().Format("15:04:05 MST 2006/01/02"))
//
// Send a formatted log message internally
func (log Logger) intLogf(lvl level, format string, args ...interface{}) {
skip := true
if len(args) > 0 {
msg = fmt.Sprintf(format, args...)
}
// its source.
func (log Logger) Logf(lvl level, format string, args ...interface{}) {
log.intLogf(lvl, format, args...)
}
// Logs the given message and crashes the program
func Crashf(format string, args ...interface{}) {
Global.intLogf(CRITICAL, format, args...)
Global.Close() // so that hopefully the messages get logged
panic(fmt.Sprintf(format, args...))
}
// Compatibility with `log`
func Exitf(format string, args ...interface{}) {
Global.intLogf(ERROR, format, args...)
Global.Close() // so that hopefully the messages get logged
// Compatibility with `log`
func Stderrf(format string, args ...interface{}) {
Global.intLogf(ERROR, format, args...)
}
// Compatibility with `log`
func Stdoutf(format string, args ...interface{}) {
Global.intLogf(INFO, format, args...)
// Run runs the command.
// The args are the arguments after the command name.
Run func(cmd *Command, args []string)
// help implements the 'help' command.
func help(args []string) {
if len(args) == 0 {
func fatalf(format string, args ...interface{}) {
errorf(format, args...)
exit()
func errorf(format string, args ...interface{}) {
log.Printf(format, args...)
setExitStatus(1)
func NewStringReply(source Identifiable, code StringCode,
format string, args ...interface{}) string {
var header string
if len(args) > 0 {
message = fmt.Sprintf(format, args...)
} else {
func NewNumericReply(target *Client, code NumericCode,
format string, args ...interface{}) string {
header := fmt.Sprintf(":%s %s %s ", target.server.Id(), code, target.Nick())
if len(args) > 0 {
message = fmt.Sprintf(format, args...)
} else {
func (target *Client) NumericReply(code NumericCode,
format string, args ...interface{}) {
target.Reply(NewNumericReply(target, code, format, args...))
}
if !strings.HasSuffix(format, ": %v") || len(n.Args) < 2 || !isName(n.Args[len(n.Args)-1], "err") {
// fmt.Errorf("foo %s", x) ->
}
// fmt.Errorf("format: %v", args..., err) ->
// errgo.Maskf(err, "format", args...)
newArgs := []ast.Expr{
Kind: token.STRING,
Value: fmt.Sprintf("%q", strings.TrimSuffix(format, ": %v")),
},
}
newArgs = append(newArgs, n.Args[1:len(n.Args)-1]...)
n.Args = newArgs
n.Fun = &ast.SelectorExpr{
}
} else if !isPkgDot(n.Args[1], gocheckIdent, "Equals") {
return false
// WriteAddr writes format with args in "addr" file of the window
func(this*Window)WriteAddr(format string,args...interface{})error{
f,err:=this.File("addr")
if len(args)> 0{
format= fmt.Sprintf(format,args...)
}
// WriteCtl writes format with args in "ctl" file of the window
// In case format is not ended by newline, '\n' will be added to the end of format
func(this*Window)WriteCtl(format string,args...interface{})error{
f,err:=this.File("ctl")
if len(args)> 0{
format= fmt.Sprintf(format,args...)
}
// and records the text in the error log.
func (b *B) Logf(format string, args ...interface{}) {
b.common.Logf(format, args...)
}
// Errorf is equivalent to Logf() followed by Fail().
func (b *B) Errorf(format string, args ...interface{}) {
b.common.Errorf(format, args...)
}
// Fatalf is equivalent to Logf() followed by FailNow().
func (b *B) Fatalf(format string, args ...interface{}) {
b.common.Fatalf(format, args...)
}
// and records the text in the error log.
func (t *T) Logf(format string, args ...interface{}) {
t.common.Logf(format, args...)
p func(format string, args ...interface{}) // print raw
pn func(format string, args ...interface{}) // print with indent and newline
}
func panicf(format string, args ...interface{}) {
panic(fmt.Sprintf(format, args...))
}
var buf bytes.Buffer
a.p = func(format string, args ...interface{}) {
_, err := fmt.Fprintf(&buf, format, args...)
if err != nil {
}
a.pn = func(format string, args ...interface{}) {
a.p(format+"\n", args...)
// log.AddFilter("log", elog.FINE, elog.NewFileLogWriter("example.log", true))
// log.Info("The time is now: %s", time.LocalTime().Format("15:04:05 MST 2006/01/02"))
//
// log.AddFilter("log", elog.FINE, elog.NewFileLogWriter("example.log", true))
// log.Info("The time is now: %s", time.LocalTime().Format("15:04:05 MST 2006/01/02"))
//
// Send a formatted log message internally
func (log *Logger) intLogf(level int, format string, args ...interface{}) {
// Create a vector long enough to not require resizing
// Make the log record
rec := newLogRecord(level, src, fmt.Sprintf(format, args...))
// Send a formatted log message easily
func (log *Logger) Logf(level int, format string, args ...interface{}) {
log.intLogf(level, format, args...)
}
// Logs the given message and crashes the program
func Crashf(format string, args ...interface{}) {
Global.intLogf(CRITICAL, format, args...)
Global.Close() // so that hopefully the messages get logged
panic(fmt.Sprintf(format, args...))
}
// Compatibility with `log`
func Exitf(format string, args ...interface{}) {
Global.intLogf(ERROR, format, args...)
Global.Close() // so that hopefully the messages get logged
// Compatibility with `log`
func Stderrf(format string, args ...interface{}) {
Global.intLogf(ERROR, format, args...)
}
// Compatibility with `log`
func Stdoutf(format string, args ...interface{}) {
Global.intLogf(INFO, format, args...)
// log.AddFilter("log", log4go.FINE, log4go.NewFileLogWriter("example.log", true))
// log.Info("The time is now: %s", time.LocalTime().Format("15:04:05 MST 2006/01/02"))
//
// log.AddFilter("log", log4go.FINE, log4go.NewFileLogWriter("example.log", true))
// log.Info("The time is now: %s", time.LocalTime().Format("15:04:05 MST 2006/01/02"))
//
// Send a formatted log message internally
func (log Logger) intLogf(lvl LogLevel, format string, args ...interface{}) {
skip := true
if len(args) > 0 {
msg = fmt.Sprintf(format, args...)
}
// its source.
func (log Logger) Logf(lvl LogLevel, format string, args ...interface{}) {
log.intLogf(lvl, format, args...)
}