← Back to branch summary

~nskaggs/+junk/xenial-test

« back to all changes in this revision

Viewing changes to src/github.com/gabriel-samfira/sys/plan9/syscall.go

  • Committer: Nicholas Skaggs
  • Date: 2016-10-24 20:56:05 UTC
  • Revision ID: nicholas.skaggs@canonical.com-20161024205605-z8lta0uvuhtxwzwl
Initi with beta15

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/github.com/gabriel-samfira/sys/plan9/syscall.go
 
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
// +build plan9
 
6
 
 
7
// Package plan9 contains an interface to the low-level operating system
 
8
// primitives.  OS details vary depending on the underlying system, and
 
9
// by default, godoc will display the OS-specific documentation for the current
 
10
// system.  If you want godoc to display documentation for another
 
11
// system, set $GOOS and $GOARCH to the desired system.  For example, if
 
12
// you want to view documentation for freebsd/arm on linux/amd64, set $GOOS
 
13
// to freebsd and $GOARCH to arm.
 
14
// The primary use of this package is inside other packages that provide a more
 
15
// portable interface to the system, such as "os", "time" and "net".  Use
 
16
// those packages rather than this one if you can.
 
17
// For details of the functions and data types in this package consult
 
18
// the manuals for the appropriate operating system.
 
19
// These calls return err == nil to indicate success; otherwise
 
20
// err represents an operating system error describing the failure and
 
21
// holds a value of type syscall.ErrorString.
 
22
package plan9 // import "github.com/gabriel-samfira/sys/plan9"
 
23
 
 
24
import "unsafe"
 
25
 
 
26
// ByteSliceFromString returns a NUL-terminated slice of bytes
 
27
// containing the text of s. If s contains a NUL byte at any
 
28
// location, it returns (nil, EINVAL).
 
29
func ByteSliceFromString(s string) ([]byte, error) {
 
30
        for i := 0; i < len(s); i++ {
 
31
                if s[i] == 0 {
 
32
                        return nil, EINVAL
 
33
                }
 
34
        }
 
35
        a := make([]byte, len(s)+1)
 
36
        copy(a, s)
 
37
        return a, nil
 
38
}
 
39
 
 
40
// BytePtrFromString returns a pointer to a NUL-terminated array of
 
41
// bytes containing the text of s. If s contains a NUL byte at any
 
42
// location, it returns (nil, EINVAL).
 
43
func BytePtrFromString(s string) (*byte, error) {
 
44
        a, err := ByteSliceFromString(s)
 
45
        if err != nil {
 
46
                return nil, err
 
47
        }
 
48
        return &a[0], nil
 
49
}
 
50
 
 
51
// Single-word zero for use when we need a valid pointer to 0 bytes.
 
52
// See mksyscall.pl.
 
53
var _zero uintptr
 
54
 
 
55
func (ts *Timespec) Unix() (sec int64, nsec int64) {
 
56
        return int64(ts.Sec), int64(ts.Nsec)
 
57
}
 
58
 
 
59
func (tv *Timeval) Unix() (sec int64, nsec int64) {
 
60
        return int64(tv.Sec), int64(tv.Usec) * 1000
 
61
}
 
62
 
 
63
func (ts *Timespec) Nano() int64 {
 
64
        return int64(ts.Sec)*1e9 + int64(ts.Nsec)
 
65
}
 
66
 
 
67
func (tv *Timeval) Nano() int64 {
 
68
        return int64(tv.Sec)*1e9 + int64(tv.Usec)*1000
 
69
}
 
70
 
 
71
// use is a no-op, but the compiler cannot see that it is.
 
72
// Calling use(p) ensures that p is kept live until that point.
 
73
//go:noescape
 
74
func use(p unsafe.Pointer)