func (m *clientHelloMsg) marshal() []byte {
if m.raw != nil {
return m.raw
}
length := 2 + 32 + 1 + len(m.sessionId) + 2 + len(m.cipherSuites)*2 + 1 + len(m.compressionMethods)
x := make([]byte, 4+length)
x[0] = typeClientHello
x[1] = uint8(length >> 16)
x[2] = uint8(length >> 8)
x[3] = uint8(length)
x[4] = m.major
x[5] = m.minor
bytes.Copy(x[6:38], m.random)
x[38] = uint8(len(m.sessionId))
bytes.Copy(x[39:39+len(m.sessionId)], m.sessionId)
y := x[39+len(m.sessionId) : len(x)]
y[0] = uint8(len(m.cipherSuites) >> 7)
y[1] = uint8(len(m.cipherSuites) << 1)
for i, suite := range m.cipherSuites {
y[2+i*2] = uint8(suite >> 8)
y[3+i*2] = uint8(suite)
}
z := y[2+len(m.cipherSuites)*2 : len(y)]
z[0] = uint8(len(m.compressionMethods))
bytes.Copy(z[1:len(z)], m.compressionMethods)
m.raw = x
return x
}
func main() {
in = bufio.NewReader(os.Stdin)
buf := make([]byte, 100*1024)
top := 0
for {
line, err := in.ReadSlice('\n')
if err != nil {
break
}
if line[0] == '>' {
if top > 0 {
output(buf[0:top])
top = 0
}
os.Stdout.Write(line)
continue
}
line = line[0 : len(line)-1] // drop newline
if top+len(line) > len(buf) {
nbuf := make([]byte, 2*len(buf)+1024*(100+len(line)))
bytes.Copy(nbuf, buf[0:top])
buf = nbuf
}
bytes.Copy(buf[top:len(buf)], line)
top += len(line)
}
output(buf[0:top])
}
// EncryptOAEP encrypts the given message with RSA-OAEP.
// The message must be no longer than the length of the public modulus less
// twice the hash length plus 2.
func EncryptOAEP(hash hash.Hash, rand io.Reader, pub *PublicKey, msg []byte, label []byte) (out []byte, err os.Error) {
hash.Reset()
k := (pub.N.Len() + 7) / 8
if len(msg) > k-2*hash.Size()-2 {
err = MessageTooLongError{}
return
}
hash.Write(label)
lHash := hash.Sum()
hash.Reset()
em := make([]byte, k)
seed := em[1 : 1+hash.Size()]
db := em[1+hash.Size() : len(em)]
bytes.Copy(db[0:hash.Size()], lHash)
db[len(db)-len(msg)-1] = 1
bytes.Copy(db[len(db)-len(msg):len(db)], msg)
_, err = io.ReadFull(rand, seed)
if err != nil {
return
}
mgf1XOR(db, hash, seed)
mgf1XOR(seed, hash, db)
m := new(big.Int)
m.SetBytes(em)
c := encrypt(new(big.Int), pub, m)
out = c.Bytes()
return
}
// finishedSum calculates the contents of the verify_data member of a Finished
// message given the MD5 and SHA1 hashes of a set of handshake messages.
func finishedSum(md5, sha1, label, masterSecret []byte) []byte {
seed := make([]byte, len(md5)+len(sha1))
bytes.Copy(seed, md5)
bytes.Copy(seed[len(md5):len(seed)], sha1)
out := make([]byte, finishedVerifyLength)
pRF11(out, masterSecret, label, seed)
return out
}
// WriteHeader writes hdr and prepares to accept the file's contents.
// WriteHeader calls Flush if it is not the first header.
func (tw *Writer) WriteHeader(hdr *Header) os.Error {
if tw.err == nil {
tw.Flush()
}
if tw.err != nil {
return tw.err
}
tw.nb = int64(hdr.Size)
tw.pad = -tw.nb & (blockSize - 1) // blockSize is a power of two
header := make([]byte, blockSize)
s := slicer(header)
// TODO(dsymonds): handle names longer than 100 chars
bytes.Copy(s.next(100), strings.Bytes(hdr.Name))
tw.octal(s.next(8), hdr.Mode) // 100:108
tw.numeric(s.next(8), hdr.Uid) // 108:116
tw.numeric(s.next(8), hdr.Gid) // 116:124
tw.numeric(s.next(12), hdr.Size) // 124:136
tw.numeric(s.next(12), hdr.Mtime) // 136:148
s.next(8) // chksum (148:156)
s.next(1)[0] = hdr.Typeflag // 156:157
s.next(100) // linkname (157:257)
bytes.Copy(s.next(8), strings.Bytes("ustar\x0000")) // 257:265
tw.cString(s.next(32), hdr.Uname) // 265:297
tw.cString(s.next(32), hdr.Gname) // 297:329
tw.numeric(s.next(8), hdr.Devmajor) // 329:337
tw.numeric(s.next(8), hdr.Devminor) // 337:345
// Use the GNU magic instead of POSIX magic if we used any GNU extensions.
if tw.usedBinary {
bytes.Copy(header[257:265], strings.Bytes("ustar \x00"))
}
// The chksum field is terminated by a NUL and a space.
// This is different from the other octal fields.
chksum, _ := checksum(header)
tw.octal(header[148:155], chksum)
header[155] = ' '
if tw.err != nil {
// problem with header; probably integer too big for a field.
return tw.err
}
_, tw.err = tw.w.Write(header)
return tw.err
}
func (p *recordProcessor) processHandshakeRecord(data []byte) {
if p.handshakeBuf == nil {
p.handshakeBuf = data
} else {
if len(p.handshakeBuf) > maxHandshakeMsg {
p.error(alertInternalError)
return
}
newBuf := make([]byte, len(p.handshakeBuf)+len(data))
bytes.Copy(newBuf, p.handshakeBuf)
bytes.Copy(newBuf[len(p.handshakeBuf):len(newBuf)], data)
p.handshakeBuf = newBuf
}
for len(p.handshakeBuf) >= 4 {
handshakeLen := int(p.handshakeBuf[1])<<16 |
int(p.handshakeBuf[2])<<8 |
int(p.handshakeBuf[3])
if handshakeLen+4 > len(p.handshakeBuf) {
break
}
bytes := p.handshakeBuf[0 : handshakeLen+4]
p.handshakeBuf = p.handshakeBuf[handshakeLen+4 : len(p.handshakeBuf)]
if bytes[0] == typeFinished {
// Special case because Finished is synchronous: the
// handshake handler has to tell us if it's ok to start
// forwarding application data.
m := new(finishedMsg)
if !m.unmarshal(bytes) {
p.error(alertUnexpectedMessage)
}
p.handshakeChan <- m
var ok bool
p.connState, ok = (<-p.controlChan).(ConnectionState)
if !ok || p.connState.Error != 0 {
p.shutdown = true
return
}
} else {
msg, ok := parseHandshakeMsg(bytes)
if !ok {
p.error(alertUnexpectedMessage)
return
}
p.handshakeChan <- msg
}
}
}
// RepeatFasta prints the characters of the byte slice s. When it
// reaches the end of the slice, it goes back to the beginning.
// It stops after generating count characters.
// After each WIDTH characters it prints a newline.
// It assumes that WIDTH <= len(s) + 1.
func RepeatFasta(s []byte, count int) {
pos := 0;
s2 := make([]byte, len(s) + WIDTH);
bytes.Copy(s2, s);
bytes.Copy(s2[len(s):len(s2)], s);
for count > 0 {
line := min(WIDTH, count);
out.Write(s2[pos:pos+line]);
out.WriteByte('\n');
pos += line;
if pos >= len(s) {
pos -= len(s);
}
count -= line;
}
}
func (tls *Conn) Read(p []byte) (int, os.Error) {
if len(tls.readBuf) == 0 {
if tls.eof {
return 0, os.EOF
}
var timeoutChan chan bool
if tls.readTimeout > 0 {
timeoutChan = make(chan bool)
go timeout(timeoutChan, tls.readTimeout)
}
select {
case b := <-tls.readChan:
tls.readBuf = b
case <-timeoutChan:
return 0, os.EAGAIN
}
// TLS distinguishes between orderly closes and truncations. An
// orderly close is represented by a zero length slice.
if closed(tls.readChan) {
return 0, io.ErrUnexpectedEOF
}
if len(tls.readBuf) == 0 {
tls.eof = true
return 0, os.EOF
}
}
n := bytes.Copy(p, tls.readBuf)
tls.readBuf = tls.readBuf[n:len(tls.readBuf)]
return n, nil
}
func (r *msgReceiver) recv() (*msg, os.Error) {
// Init pointers to buffers where syscall recvmsg can write.
r.iov.base = &r.data[0]
r.iov.len = int32(len(r.data))
r.hdr.iov = &r.iov
r.hdr.niov = 1
r.hdr.desc = &r.desc[0]
r.hdr.ndesc = int32(len(r.desc))
n, _, e := syscall.Syscall(syscall.SYS_IMC_RECVMSG, uintptr(r.fd), uintptr(unsafe.Pointer(&r.hdr)), 0)
if e != 0 {
return nil, os.NewSyscallError("imc_recvmsg", int(e))
}
// Make a copy of the data so that the next recvmsg doesn't
// smash it. The system call did not update r.iov.len. Instead it
// returned the total byte count as n.
m := new(msg)
m.rdata = make([]byte, n)
bytes.Copy(m.rdata, &r.data)
// Make a copy of the desc too.
// The system call *did* update r.hdr.ndesc.
if r.hdr.ndesc > 0 {
m.rdesc = make([]int32, r.hdr.ndesc)
for i := range m.rdesc {
m.rdesc[i] = r.desc[i]
}
}
return m, nil
}
func (d *deflater) fillWindow(index int) (int, os.Error) {
wSize := d.windowMask + 1
if index >= wSize+wSize-(minMatchLength+maxMatchLength) {
// shift the window by wSize
bytes.Copy(d.window, d.window[wSize:2*wSize])
index -= wSize
d.windowEnd -= wSize
if d.blockStart >= wSize {
d.blockStart -= wSize
} else {
d.blockStart = math.MaxInt32
}
for i, h := range d.hashHead {
d.hashHead[i] = max(h-wSize, -1)
}
for i, h := range d.hashPrev {
d.hashPrev[i] = max(h-wSize, -1)
}
}
var count int
var err os.Error
count, err = io.ReadAtLeast(d.r, d.window[d.windowEnd:len(d.window)], 1)
d.windowEnd += count
if err == os.EOF {
return index, nil
}
return index, err
}
func (m *certificateMsg) marshal() (x []byte) {
if m.raw != nil {
return m.raw
}
var i int
for _, slice := range m.certificates {
i += len(slice)
}
length := 3 + 3*len(m.certificates) + i
x = make([]byte, 4+length)
x[0] = typeCertificate
x[1] = uint8(length >> 16)
x[2] = uint8(length >> 8)
x[3] = uint8(length)
certificateOctets := length - 3
x[4] = uint8(certificateOctets >> 16)
x[5] = uint8(certificateOctets >> 8)
x[6] = uint8(certificateOctets)
y := x[7:len(x)]
for _, slice := range m.certificates {
y[0] = uint8(len(slice) >> 16)
y[1] = uint8(len(slice) >> 8)
y[2] = uint8(len(slice))
bytes.Copy(y[3:len(y)], slice)
y = y[3+len(slice) : len(y)]
}
m.raw = x
return
}
func (d *decoder) Read(p []byte) (n int, err os.Error) {
if d.err != nil {
return 0, d.err
}
// Use leftover decoded output from last read.
if len(d.out) > 0 {
n = bytes.Copy(p, d.out)
d.out = d.out[n:len(d.out)]
return n, nil
}
// Read a chunk.
nn := len(p) / 3 * 4
if nn < 4 {
nn = 4
}
if nn > len(d.buf) {
nn = len(d.buf)
}
nn, d.err = io.ReadAtLeast(d.r, d.buf[d.nbuf:nn], 4-d.nbuf)
d.nbuf += nn
if d.nbuf < 4 {
return 0, d.err
}
// Decode chunk into p, or d.out and then p if p is too small.
nr := d.nbuf / 4 * 4
nw := d.nbuf / 4 * 3
if nw > len(p) {
nw, d.end, d.err = d.enc.decode(&d.outbuf, d.buf[0:nr])
d.out = d.outbuf[0:nw]
n = bytes.Copy(p, d.out)
d.out = d.out[n:len(d.out)]
} else {
n, d.end, d.err = d.enc.decode(p, d.buf[0:nr])
}
d.nbuf -= nr
for i := 0; i < d.nbuf; i++ {
d.buf[i] = d.buf[i+nr]
}
if d.err == nil {
d.err = err
}
return n, d.err
}
// pRF11 implements the TLS 1.1 pseudo-random function, as defined in RFC 4346, section 5.
func pRF11(result, secret, label, seed []byte) {
hashSHA1 := sha1.New()
hashMD5 := md5.New()
labelAndSeed := make([]byte, len(label)+len(seed))
bytes.Copy(labelAndSeed, label)
bytes.Copy(labelAndSeed[len(label):len(labelAndSeed)], seed)
s1, s2 := splitPreMasterSecret(secret)
pHash(result, s1, labelAndSeed, hashMD5)
result2 := make([]byte, len(result))
pHash(result2, s2, labelAndSeed, hashSHA1)
for i, b := range result2 {
result[i] ^= b
}
}
func (r *reader) Read(p []byte) (n int, err os.Error) {
b := *r;
if len(b) == 0 && len(p) > 0 {
return 0, os.EOF
}
n = bytes.Copy(p, b);
*r = b[n:len(b)];
return;
}
// leftPad returns a new slice of length size. The contents of input are right
// aligned in the new slice.
func leftPad(input []byte, size int) (out []byte) {
n := len(input)
if n > size {
n = size
}
out = make([]byte, size)
bytes.Copy(out[len(out)-n:len(out)], input)
return
}
// keysFromPreMasterSecret generates the connection keys from the pre master
// secret, given the lengths of the MAC and cipher keys, as defined in RFC
// 4346, section 6.3.
func keysFromPreMasterSecret11(preMasterSecret, clientRandom, serverRandom []byte, macLen, keyLen int) (masterSecret, clientMAC, serverMAC, clientKey, serverKey []byte) {
var seed [tlsRandomLength * 2]byte
bytes.Copy(seed[0:len(clientRandom)], clientRandom)
bytes.Copy(seed[len(clientRandom):len(seed)], serverRandom)
masterSecret = make([]byte, masterSecretLength)
pRF11(masterSecret, preMasterSecret, masterSecretLabel, seed[0:len(seed)])
bytes.Copy(seed[0:len(clientRandom)], serverRandom)
bytes.Copy(seed[len(serverRandom):len(seed)], clientRandom)
n := 2*macLen + 2*keyLen
keyMaterial := make([]byte, n)
pRF11(keyMaterial, masterSecret, keyExpansionLabel, seed[0:len(seed)])
clientMAC = keyMaterial[0:macLen]
serverMAC = keyMaterial[macLen : macLen*2]
clientKey = keyMaterial[macLen*2 : macLen*2+keyLen]
serverKey = keyMaterial[macLen*2+keyLen : len(keyMaterial)]
return
}
// Writing to msg.wdata.
func (m *msg) grow(n int) []byte {
i := len(m.wdata)
if i+n > cap(m.wdata) {
a := make([]byte, i, (i+n)*2)
bytes.Copy(a, m.wdata)
m.wdata = a
}
m.wdata = m.wdata[0 : i+n]
return m.wdata[i : i+n]
}
func (d *decoder) Read(p []byte) (n int, err os.Error) {
if len(p) == 0 {
return 0, nil
}
if d.err != nil {
return 0, d.err
}
for {
// Copy leftover output from last decode.
if len(d.out) > 0 {
n = bytes.Copy(p, d.out)
d.out = d.out[n:len(d.out)]
return
}
// Decode leftover input from last read.
var nn, nsrc, ndst int
if d.nbuf > 0 {
ndst, nsrc, d.err = Decode(&d.outbuf, d.buf[0:d.nbuf], d.readErr != nil)
if ndst > 0 {
d.out = d.outbuf[0:ndst]
d.nbuf = bytes.Copy(&d.buf, d.buf[nsrc:d.nbuf])
continue // copy out and return
}
}
// Out of input, out of decoded output. Check errors.
if d.err != nil {
return 0, d.err
}
if d.readErr != nil {
d.err = d.readErr
return 0, d.err
}
// Read more data.
nn, d.readErr = d.r.Read(d.buf[d.nbuf:len(d.buf)])
d.nbuf += nn
}
panic("unreachable")
}
func (d *decoder) Read(p []byte) (n int, err os.Error) {
if len(p) == 0 {
return 0, nil
}
for {
// Copy leftover output from last decode.
if len(d.out) > 0 {
n = bytes.Copy(p, d.out)
d.out = d.out[n:len(d.out)]
return
}
// Out of decoded output. Check errors.
if d.err != nil {
return 0, d.err
}
if d.readErr != nil {
d.err = d.readErr
return 0, d.err
}
// Read and decode more input.
var nn int
nn, d.readErr = d.r.Read(d.buf[d.nbuf:len(d.buf)])
d.nbuf += nn
// Send complete lines to Decode.
nl := bytes.LastIndex(d.buf[0:d.nbuf], newline)
if nl < 0 {
continue
}
nn, d.err = Decode(&d.outbuf, d.buf[0:nl+1])
if e, ok := d.err.(CorruptInputError); ok {
d.err = CorruptInputError(int64(e) + d.off)
}
d.out = d.outbuf[0:nn]
d.nbuf = bytes.Copy(&d.buf, d.buf[nl+1:d.nbuf])
d.off += int64(nl + 1)
}
panic("unreacahable")
}
func copy(v int, x, y []byte) []byte {
if len(x) > len(y) {
x = x[0:len(y)]
} else {
y = y[0:len(x)]
}
if v == 1 {
bytes.Copy(x, y)
}
return x
}
func videoPollEvent(ev []byte) (err os.Error) {
if srpcEnabled {
r := bridge.share.eq.ri
if r == bridge.share.eq.wi {
return noEvents
}
bytes.Copy(ev, &bridge.share.eq.event[r])
bridge.share.eq.ri = (r + 1) % eqsize
return nil
}
return os.NewSyscallError("video_poll_event", syscall.VideoPollEvent(&ev[0]))
}
func (m *finishedMsg) marshal() (x []byte) {
if m.raw != nil {
return m.raw
}
x = make([]byte, 16)
x[0] = typeFinished
x[3] = 12
bytes.Copy(x[4:len(x)], m.verifyData)
m.raw = x
return
}
func TrSymbol_new(vm *RubyVM, str *string) RubyObject {
id := TrSymbol_lookup(vm, str);
if (!id) {
s := Symbol{type: TR_T_Symbol, class: vm.classes[TR_T_Symbol], ivars: make(map[string] RubyObject), len: strlen(str), ptr: make([]byte, s.len + 1), interned: true};
bytes.Copy(s.ptr, str[0:s.len - 1]);
s.ptr[s.len] = '\0';
id := s;
TrSymbol_add(vm, s.ptr, id);
}
return id;
}
func (a *decimal) String() string {
n := 10 + a.nd
if a.dp > 0 {
n += a.dp
}
if a.dp < 0 {
n += -a.dp
}
buf := make([]byte, n)
w := 0
switch {
case a.nd == 0:
return "0"
case a.dp <= 0:
// zeros fill space between decimal point and digits
buf[w] = '0'
w++
buf[w] = '.'
w++
w += digitZero(buf[w : w+-a.dp])
w += bytes.Copy(buf[w:w+a.nd], a.d[0:a.nd])
case a.dp < a.nd:
// decimal point in middle of digits
w += bytes.Copy(buf[w:w+a.dp], a.d[0:a.dp])
buf[w] = '.'
w++
w += bytes.Copy(buf[w:w+a.nd-a.dp], a.d[a.dp:a.nd])
default:
// zeros fill space between digits and decimal point
w += bytes.Copy(buf[w:w+a.nd], a.d[0:a.nd])
w += digitZero(buf[w : w+a.dp-a.nd])
}
return string(buf[0:w])
}
func (m *serverHelloMsg) marshal() []byte {
if m.raw != nil {
return m.raw
}
length := 38 + len(m.sessionId)
x := make([]byte, 4+length)
x[0] = typeServerHello
x[1] = uint8(length >> 16)
x[2] = uint8(length >> 8)
x[3] = uint8(length)
x[4] = m.major
x[5] = m.minor
bytes.Copy(x[6:38], m.random)
x[38] = uint8(len(m.sessionId))
bytes.Copy(x[39:39+len(m.sessionId)], m.sessionId)
z := x[39+len(m.sessionId) : len(x)]
z[0] = uint8(m.cipherSuite >> 8)
z[1] = uint8(m.cipherSuite)
z[2] = uint8(m.compressionMethod)
m.raw = x
return x
}
func (r *dataErrReader) Read(p []byte) (n int, err os.Error) {
// loop because first call needs two reads:
// one to get data and a second to look for an error.
for {
if len(r.unread) == 0 {
n1, err1 := r.r.Read(r.data)
r.unread = r.data[0:n1]
err = err1
}
if n > 0 {
break
}
n = bytes.Copy(p, r.unread)
r.unread = r.unread[n:len(r.unread)]
}
return
}
func (m *clientKeyExchangeMsg) marshal() []byte {
if m.raw != nil {
return m.raw
}
length := len(m.ciphertext) + 2
x := make([]byte, length+4)
x[0] = typeClientKeyExchange
x[1] = uint8(length >> 16)
x[2] = uint8(length >> 8)
x[3] = uint8(length)
x[4] = uint8(len(m.ciphertext) >> 8)
x[5] = uint8(len(m.ciphertext))
bytes.Copy(x[6:len(x)], m.ciphertext)
m.raw = x
return x
}
// EncryptPKCS1v15 encrypts the given message with RSA and the padding scheme from PKCS#1 v1.5.
// The message must be no longer than the length of the public modulus minus 11 bytes.
// WARNING: use of this function to encrypt plaintexts other than session keys
// is dangerous. Use RSA OAEP in new protocols.
func EncryptPKCS1v15(rand io.Reader, pub *PublicKey, msg []byte) (out []byte, err os.Error) {
k := (pub.N.Len() + 7) / 8
if len(msg) > k-11 {
err = MessageTooLongError{}
return
}
// EM = 0x02 || PS || 0x00 || M
em := make([]byte, k-1)
em[0] = 2
ps, mm := em[1:len(em)-len(msg)-1], em[len(em)-len(msg):len(em)]
err = nonZeroRandomBytes(ps, rand)
if err != nil {
return
}
em[len(em)-len(msg)-1] = 0
bytes.Copy(mm, msg)
m := new(big.Int).SetBytes(em)
c := encrypt(new(big.Int), pub, m)
out = c.Bytes()
return
}
// pHash implements the P_hash function, as defined in RFC 4346, section 5.
func pHash(result, secret, seed []byte, hash hash.Hash) {
h := hmac.New(hash, secret)
h.Write(seed)
a := h.Sum()
j := 0
for j < len(result) {
h.Reset()
h.Write(a)
h.Write(seed)
b := h.Sum()
todo := len(b)
if j+todo > len(result) {
todo = len(result) - j
}
bytes.Copy(result[j:j+todo], b)
j += todo
h.Reset()
h.Write(a)
a = h.Sum()
}
}
func main() {
flag.Usage = func() {
fmt.Fprintf(os.Stderr, "Usage: %s [options] file\nOptions:\n", os.Args[0])
flag.PrintDefaults()
}
async := flag.Bool("async", false, "transparently execute instructions concurrently")
coords := flag.Bool("coords", false, "print current instruction and coordinates to stderr")
debug := flag.Bool("debug", false, "synonym for -coords -pause -stack -trace")
help := flag.Bool("help", false, "show usage information")
pause := flag.Bool("pause", false, "pause for return keypress between instructions")
stack := flag.Bool("stack", false, "print stack contents to stderr ")
trace := flag.Bool("trace", false, "print instruction pointer superimposed over code to stderr")
flag.Parse()
if *help {
flag.Usage()
return
}
if *debug {
*coords = true
*pause = true
*stack = true
*trace = true
}
path := flag.Arg(0)
if len(path) == 0 {
fmt.Fprintln(os.Stderr, "No input file specified.")
flag.Usage()
return
}
raw, err := ReadFile(path)
if err != nil {
fmt.Fprintln(os.Stderr, "File error:", err.String())
}
code := bytes.Split(raw, []byte{'\n'}, len(raw))
space := make([][]byte, 25)
for i, _ := range space {
space[i] = make([]byte, 80)
rowLen := 0
if i < len(code) {
rowLen = len(code[i])
bytes.Copy(space[i], code[i])
}
for j := 0; j < len(space[i])-rowLen; j++ {
space[i][rowLen+j] = ' '
}
}
if *async {
befunge := gofunge93.NewAsyncGofunge93(space)
debugger := gofunge93.NewAsyncGofunge93Debugger(befunge)
debugger.SetPause(*pause)
debugger.SetPrintCoords(*coords)
debugger.SetPrintStack(*stack)
debugger.SetPrintTrace(*trace)
gofunge93.StartDebug(debugger, gofunge93.NewIP2d(0, 0, [2]int8{1, 0}, 80, 25))
} else {
befunge := gofunge93.NewGofunge93(space)
debugger := gofunge93.NewGofunge93Debugger(befunge)
debugger.SetPause(*pause)
debugger.SetPrintCoords(*coords)
debugger.SetPrintStack(*stack)
debugger.SetPrintTrace(*trace)
gofunge93.StartDebug(debugger, gofunge93.NewIP2d(0, 0, [2]int8{1, 0}, 80, 25))
}
}
