Subversion Repositories openrisc

// Copyright 2009 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.

// Simple file i/o and string manipulation, to avoid

// depending on strconv and bufio and strings.

package net

import (

        "io"

        "os"

)

type file struct {

        file  *os.File

        data  []byte

        atEOF bool

}

func (f *file) close() { f.file.Close() }

func (f *file) getLineFromData() (s string, ok bool) {

        data := f.data

        i := 0

        for i = 0; i < len(data); i++ {

                if data[i] == '\n' {

                        s = string(data[0:i])

                        ok = true

                        // move data

                        i++

                        n := len(data) - i

                        copy(data[0:], data[i:])

                        f.data = data[0:n]

                        return

                }

        }

        if f.atEOF && len(f.data) > 0 {

                // EOF, return all we have

                s = string(data)

                f.data = f.data[0:0]

                ok = true

        }

        return

}

func (f *file) readLine() (s string, ok bool) {

        if s, ok = f.getLineFromData(); ok {

                return

        }

        if len(f.data) < cap(f.data) {

                ln := len(f.data)

                n, err := io.ReadFull(f.file, f.data[ln:cap(f.data)])

                if n >= 0 {

                        f.data = f.data[0 : ln+n]

                }

                if err == io.EOF {

                        f.atEOF = true

                }

        }

        s, ok = f.getLineFromData()

        return

}

func open(name string) (*file, error) {

        fd, err := os.Open(name)

        if err != nil {

                return nil, err

        }

        return &file{fd, make([]byte, 1024)[0:0], false}, nil

}

func byteIndex(s string, c byte) int {

        for i := 0; i < len(s); i++ {

                if s[i] == c {

                        return i

                }

        }

        return -1

}

// Count occurrences in s of any bytes in t.

func countAnyByte(s string, t string) int {

        n := 0

        for i := 0; i < len(s); i++ {

                if byteIndex(t, s[i]) >= 0 {

                        n++

                }

        }

        return n

}

// Split s at any bytes in t.

func splitAtBytes(s string, t string) []string {

        a := make([]string, 1+countAnyByte(s, t))

        n := 0

        last := 0

        for i := 0; i < len(s); i++ {

                if byteIndex(t, s[i]) >= 0 {

                        if last < i {

                                a[n] = string(s[last:i])

                                n++

                        }

                        last = i + 1

                }

        }

        if last < len(s) {

                a[n] = string(s[last:])

                n++

        }

        return a[0:n]

}

func getFields(s string) []string { return splitAtBytes(s, " \r\t\n") }

// Bigger than we need, not too big to worry about overflow

const big = 0xFFFFFF

// Decimal to integer starting at &s[i0].

// Returns number, new offset, success.

func dtoi(s string, i0 int) (n int, i int, ok bool) {

        n = 0

        for i = i0; i < len(s) && '0' <= s[i] && s[i] <= '9'; i++ {

                n = n*10 + int(s[i]-'0')

                if n >= big {

                        return 0, i, false

                }

        }

        if i == i0 {

                return 0, i, false

        }

        return n, i, true

}

// Hexadecimal to integer starting at &s[i0].

// Returns number, new offset, success.

func xtoi(s string, i0 int) (n int, i int, ok bool) {

        n = 0

        for i = i0; i < len(s); i++ {

                if '0' <= s[i] && s[i] <= '9' {

                        n *= 16

                        n += int(s[i] - '0')

                } else if 'a' <= s[i] && s[i] <= 'f' {

                        n *= 16

                        n += int(s[i]-'a') + 10

                } else if 'A' <= s[i] && s[i] <= 'F' {

                        n *= 16

                        n += int(s[i]-'A') + 10

                } else {

                        break

                }

                if n >= big {

                        return 0, i, false

                }

        }

        if i == i0 {

                return 0, i, false

        }

        return n, i, true

}

// xtoi2 converts the next two hex digits of s into a byte.

// If s is longer than 2 bytes then the third byte must be e.

// If the first two bytes of s are not hex digits or the third byte

// does not match e, false is returned.

func xtoi2(s string, e byte) (byte, bool) {

        if len(s) > 2 && s[2] != e {

                return 0, false

        }

        n, ei, ok := xtoi(s[:2], 0)

        return byte(n), ok && ei == 2

}

// Integer to decimal.

func itoa(i int) string {

        var buf [30]byte

        n := len(buf)

        neg := false

        if i < 0 {

                i = -i

                neg = true

        }

        ui := uint(i)

        for ui > 0 || n == len(buf) {

                n--

                buf[n] = byte('0' + ui%10)

                ui /= 10

        }

        if neg {

                n--

                buf[n] = '-'

        }

        return string(buf[n:])

}

// Convert i to decimal string.

func itod(i uint) string {

        if i == 0 {

                return "0"

        }

        // Assemble decimal in reverse order.

        var b [32]byte

        bp := len(b)

        for ; i > 0; i /= 10 {

                bp--

                b[bp] = byte(i%10) + '0'

        }

        return string(b[bp:])

}

// Convert i to hexadecimal string.

func itox(i uint, min int) string {

        // Assemble hexadecimal in reverse order.

        var b [32]byte

        bp := len(b)

        for ; i > 0 || min > 0; i /= 16 {

                bp--

                b[bp] = "0123456789abcdef"[byte(i%16)]

                min--

        }

        return string(b[bp:])

}

// Number of occurrences of b in s.

func count(s string, b byte) int {

        n := 0

        for i := 0; i < len(s); i++ {

                if s[i] == b {

                        n++

                }

        }

        return n

}

// Index of rightmost occurrence of b in s.

func last(s string, b byte) int {

        i := len(s)

        for i--; i >= 0; i-- {

                if s[i] == b {

                        break

                }

        }

        return i

}