code review 121520043: go.sys: update package names

windows/mksyscall_windows.go

 // Copyright 2013 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 // +build ignore
 
 /*
 mksyscall_windows generates windows system call bodies
 
 It parses all files specified on command line containing function
@@ skipping 51 matching lines @@
 func trim(s string) string {
         return strings.Trim(s, " \t")
 }
 
 var packageName string
 
 func packagename() string {
         return packageName
 }
 
-func syscalldot() string {
-        if packageName == "syscall" {
+func windowsdot() string {
+        if packageName == "windows" {
                 return ""
         }
-        return "syscall."
+        return "windows."
 }
 
 // Param is function parameter
 type Param struct {
         Name      string
         Type      string
         fn        *Fn
         tmpVarIdx int
 }
 
@@ skipping 171 matching lines @@
                 if e1 != 0 {
                         err = error(e1)
                 } else {
                         err = %sEINVAL
                 }
         }`
         cond := retvar + " == 0"
         if r.FailCond != "" {
                 cond = strings.Replace(r.FailCond, "failretval", retvar, 1)
         }
-        return fmt.Sprintf(code, cond, syscalldot())
+        return fmt.Sprintf(code, cond, windowsdot())
 }
 
 // SetErrorCode returns source code that sets return parameters.
 func (r *Rets) SetErrorCode() string {
         const code = `if r0 != 0 {
                 %s = %sErrno(r0)
         }`
         if r.Name == "" && !r.ReturnsError {
                 return ""
         }
         if r.Name == "" {
                 return r.useLongHandleErrorCode("r1")
         }
         if r.Type == "error" {
-                return fmt.Sprintf(code, r.Name, syscalldot())
+                return fmt.Sprintf(code, r.Name, windowsdot())
         }
         s := ""
         switch {
         case r.Type[0] == '*':
                 s = fmt.Sprintf("%s = (%s)(unsafe.Pointer(r0))", r.Name, r.Type)
         case r.Type == "bool":
                 s = fmt.Sprintf("%s = r0 != 0", r.Name)
         default:
                 s = fmt.Sprintf("%s = %s(r0)", r.Name, r.Type)
         }
         if !r.ReturnsError {
                 return s
         }
         return s + "\n\t" + r.useLongHandleErrorCode(r.Name)
 }
 
-// Fn describes syscall function.
+// Fn describes a syscall function.
 type Fn struct {
         Name        string
         Params      []*Param
         Rets        *Rets
         PrintTrace  bool
         dllname     string
         dllfuncname string
         src         string
         // TODO: get rid of this field and just use parameter index instead
         curTmpVarIdx int // insure tmp variables have uniq names
@@ skipping 175 matching lines @@
                 return 15
         default:
                 panic("too many arguments to system call")
         }
 }
 
 // Syscall determines which SyscallX function to use for function f.
 func (f *Fn) Syscall() string {
         c := f.SyscallParamCount()
         if c == 3 {
-                return syscalldot() + "Syscall"
+                return windowsdot() + "Syscall"
         }
-        return syscalldot() + "Syscall" + strconv.Itoa(c)
+        return windowsdot() + "Syscall" + strconv.Itoa(c)
 }
 
 // SyscallParamList returns source code for SyscallX parameters for function f.
 func (f *Fn) SyscallParamList() string {
         a := make([]string, 0)
         for _, p := range f.Params {
                 a = append(a, p.SyscallArgList()...)
         }
         for len(a) < f.SyscallParamCount() {
                 a = append(a, "0")
         }
         return strings.Join(a, ", ")
 }
 
 // IsUTF16 is true, if f is W (utf16) function. It is false
 // for all A (ascii) functions.
 func (f *Fn) IsUTF16() bool {
         s := f.DLLFuncName()
         return s[len(s)-1] == 'W'
 }
 
 // StrconvFunc returns name of Go string to OS string function for f.
 func (f *Fn) StrconvFunc() string {
         if f.IsUTF16() {
-                return syscalldot() + "UTF16PtrFromString"
+                return windowsdot() + "UTF16PtrFromString"
         }
-        return syscalldot() + "BytePtrFromString"
+        return windowsdot() + "BytePtrFromString"
 }
 
 // StrconvType returns Go type name used for OS string for f.
 func (f *Fn) StrconvType() string {
         if f.IsUTF16() {
                 return "*uint16"
         }
         return "*byte"
 }
 
@@ skipping 76 matching lines @@
                 return err
         }
         packageName = pkg.Name.Name
 
         return nil
 }
 
 // Generate output source file from a source set src.
 func (src *Source) Generate(w io.Writer) error {
         funcMap := template.FuncMap{
-                "syscalldot":  syscalldot,
+                "windowsdot":  windowsdot,
                 "packagename": packagename,
         }
         t := template.Must(template.New("main").Funcs(funcMap).Parse(srcTemplate))
         err := t.Execute(w, src)
         if err != nil {
                 return errors.New("Failed to execute template: " + err.Error())
         }
         return nil
 }
 
@@ skipping 20 matching lines @@
 }
 
 // TODO: use println instead to print in the following template
 const srcTemplate = `
 
 {{define "main"}}// go build mksyscall_windows.go && ./mksyscall_windows{{range .Files}} {{.}}{{end}}
 // MACHINE GENERATED BY THE COMMAND ABOVE; DO NOT EDIT
 
 package {{packagename}}
 
-import "unsafe"{{if syscalldot}}
-import "syscall"{{end}}
+import "unsafe"{{if windowsdot}}
+import "windows"{{end}}
 
 var (
 {{template "dlls" .}}
 {{template "funcnames" .}})
 {{range .Funcs}}{{template "funcbody" .}}{{end}}
 {{end}}
 
 {{/* help functions */}}
 
-{{define "dlls"}}{{range .DLLs}}        mod{{.}} = {{syscalldot}}NewLazyDLL("{{.}}.dll")
+{{define "dlls"}}{{range .DLLs}}        mod{{.}} = {{windowsdot}}NewLazyDLL("{{.}}.dll")
 {{end}}{{end}}
 
 {{define "funcnames"}}{{range .Funcs}}  proc{{.DLLFuncName}} = mod{{.DLLName}}.NewProc("{{.DLLFuncName}}")
 {{end}}{{end}}
 
 {{define "funcbody"}}
 func {{.Name}}({{.ParamList}}) {{if .Rets.List}}{{.Rets.List}} {{end}}{
 {{template "tmpvars" .}}        {{template "syscall" .}}
 {{template "seterror" .}}{{template "printtrace" .}}    return
 }
 {{end}}
 
 {{define "tmpvars"}}{{range .Params}}{{if .TmpVarCode}} {{.TmpVarCode}}
 {{end}}{{end}}{{end}}
 
 {{define "syscall"}}{{.Rets.SetReturnValuesCode}}{{.Syscall}}(proc{{.DLLFuncName}}.Addr(), {{.ParamCount}}, {{.SyscallParamList}}){{end}}
 
 {{define "seterror"}}{{if .Rets.SetErrorCode}}  {{.Rets.SetErrorCode}}
 {{end}}{{end}}
 
 {{define "printtrace"}}{{if .PrintTrace}}       print("SYSCALL: {{.Name}}(", {{.ParamPrintList}}") (", {{.Rets.PrintList}}")\n")
 {{end}}{{end}}
 
 `