|
1 // Copyright 2009 The Go Authors. All rights reserved. |
|
2 // Use of this source code is governed by a BSD-style |
|
3 // license that can be found in the LICENSE file. |
|
4 |
|
5 //go:build windows |
|
6 // +build windows |
|
7 |
|
8 // Package windows contains an interface to the low-level operating system |
|
9 // primitives. OS details vary depending on the underlying system, and |
|
10 // by default, godoc will display the OS-specific documentation for the current |
|
11 // system. If you want godoc to display syscall documentation for another |
|
12 // system, set $GOOS and $GOARCH to the desired system. For example, if |
|
13 // you want to view documentation for freebsd/arm on linux/amd64, set $GOOS |
|
14 // to freebsd and $GOARCH to arm. |
|
15 // |
|
16 // The primary use of this package is inside other packages that provide a more |
|
17 // portable interface to the system, such as "os", "time" and "net". Use |
|
18 // those packages rather than this one if you can. |
|
19 // |
|
20 // For details of the functions and data types in this package consult |
|
21 // the manuals for the appropriate operating system. |
|
22 // |
|
23 // These calls return err == nil to indicate success; otherwise |
|
24 // err represents an operating system error describing the failure and |
|
25 // holds a value of type syscall.Errno. |
|
26 package windows // import "golang.org/x/sys/windows" |
|
27 |
|
28 import ( |
|
29 "bytes" |
|
30 "strings" |
|
31 "syscall" |
|
32 "unsafe" |
|
33 ) |
|
34 |
|
35 // ByteSliceFromString returns a NUL-terminated slice of bytes |
|
36 // containing the text of s. If s contains a NUL byte at any |
|
37 // location, it returns (nil, syscall.EINVAL). |
|
38 func ByteSliceFromString(s string) ([]byte, error) { |
|
39 if strings.IndexByte(s, 0) != -1 { |
|
40 return nil, syscall.EINVAL |
|
41 } |
|
42 a := make([]byte, len(s)+1) |
|
43 copy(a, s) |
|
44 return a, nil |
|
45 } |
|
46 |
|
47 // BytePtrFromString returns a pointer to a NUL-terminated array of |
|
48 // bytes containing the text of s. If s contains a NUL byte at any |
|
49 // location, it returns (nil, syscall.EINVAL). |
|
50 func BytePtrFromString(s string) (*byte, error) { |
|
51 a, err := ByteSliceFromString(s) |
|
52 if err != nil { |
|
53 return nil, err |
|
54 } |
|
55 return &a[0], nil |
|
56 } |
|
57 |
|
58 // ByteSliceToString returns a string form of the text represented by the slice s, with a terminating NUL and any |
|
59 // bytes after the NUL removed. |
|
60 func ByteSliceToString(s []byte) string { |
|
61 if i := bytes.IndexByte(s, 0); i != -1 { |
|
62 s = s[:i] |
|
63 } |
|
64 return string(s) |
|
65 } |
|
66 |
|
67 // BytePtrToString takes a pointer to a sequence of text and returns the corresponding string. |
|
68 // If the pointer is nil, it returns the empty string. It assumes that the text sequence is terminated |
|
69 // at a zero byte; if the zero byte is not present, the program may crash. |
|
70 func BytePtrToString(p *byte) string { |
|
71 if p == nil { |
|
72 return "" |
|
73 } |
|
74 if *p == 0 { |
|
75 return "" |
|
76 } |
|
77 |
|
78 // Find NUL terminator. |
|
79 n := 0 |
|
80 for ptr := unsafe.Pointer(p); *(*byte)(ptr) != 0; n++ { |
|
81 ptr = unsafe.Pointer(uintptr(ptr) + 1) |
|
82 } |
|
83 |
|
84 return string(unsafe.Slice(p, n)) |
|
85 } |
|
86 |
|
87 // Single-word zero for use when we need a valid pointer to 0 bytes. |
|
88 // See mksyscall.pl. |
|
89 var _zero uintptr |
|
90 |
|
91 func (ts *Timespec) Unix() (sec int64, nsec int64) { |
|
92 return int64(ts.Sec), int64(ts.Nsec) |
|
93 } |
|
94 |
|
95 func (tv *Timeval) Unix() (sec int64, nsec int64) { |
|
96 return int64(tv.Sec), int64(tv.Usec) * 1000 |
|
97 } |
|
98 |
|
99 func (ts *Timespec) Nano() int64 { |
|
100 return int64(ts.Sec)*1e9 + int64(ts.Nsec) |
|
101 } |
|
102 |
|
103 func (tv *Timeval) Nano() int64 { |
|
104 return int64(tv.Sec)*1e9 + int64(tv.Usec)*1000 |
|
105 } |