diff options
| author | Robert Griesemer <gri@golang.org> | 2009-12-15 15:27:16 -0800 |
|---|---|---|
| committer | Robert Griesemer <gri@golang.org> | 2009-12-15 15:27:16 -0800 |
| commit | 881d6064d23d9da5c7ff368bc7d41d271290deff (patch) | |
| tree | 44d5d948e3f27cc7eff15ec8cd7ee5165d9a7e90 /src | |
| parent | d9dfea3ebd51cea89fef8afc6b2377c2958b24f1 (diff) | |
| download | golang-881d6064d23d9da5c7ff368bc7d41d271290deff.tar.gz | |
1) Change default gofmt default settings for
parsing and printing to new syntax.
Use -oldparser to parse the old syntax,
use -oldprinter to print the old syntax.
2) Change default gofmt formatting settings
to use tabs for indentation only and to use
spaces for alignment. This will make the code
alignment insensitive to an editor's tabwidth.
Use -spaces=false to use tabs for alignment.
3) Manually changed src/exp/parser/parser_test.go
so that it doesn't try to parse the parser's
source files using the old syntax (they have
new syntax now).
4) gofmt -w src misc test/bench
2nd set of files.
R=rsc
CC=golang-dev
http://codereview.appspot.com/179067
Diffstat (limited to 'src')
105 files changed, 10478 insertions, 10476 deletions
diff --git a/src/pkg/debug/dwarf/buf.go b/src/pkg/debug/dwarf/buf.go index 2ece903a0..2d29cebdd 100644 --- a/src/pkg/debug/dwarf/buf.go +++ b/src/pkg/debug/dwarf/buf.go @@ -7,20 +7,20 @@ package dwarf import ( - "encoding/binary"; - "os"; - "strconv"; + "encoding/binary" + "os" + "strconv" ) // Data buffer being decoded. type buf struct { - dwarf *Data; - order binary.ByteOrder; - name string; - off Offset; - data []byte; - addrsize int; - err os.Error; + dwarf *Data + order binary.ByteOrder + name string + off Offset + data []byte + addrsize int + err os.Error } func makeBuf(d *Data, name string, off Offset, data []byte, addrsize int) buf { @@ -29,95 +29,95 @@ func makeBuf(d *Data, name string, off Offset, data []byte, addrsize int) buf { func (b *buf) uint8() uint8 { if len(b.data) < 1 { - b.error("underflow"); - return 0; + b.error("underflow") + return 0 } - val := b.data[0]; - b.data = b.data[1:]; - b.off++; - return val; + val := b.data[0] + b.data = b.data[1:] + b.off++ + return val } func (b *buf) bytes(n int) []byte { if len(b.data) < n { - b.error("underflow"); - return nil; + b.error("underflow") + return nil } - data := b.data[0:n]; - b.data = b.data[n:]; - b.off += Offset(n); - return data; + data := b.data[0:n] + b.data = b.data[n:] + b.off += Offset(n) + return data } -func (b *buf) skip(n int) { b.bytes(n) } +func (b *buf) skip(n int) { b.bytes(n) } func (b *buf) string() string { for i := 0; i < len(b.data); i++ { if b.data[i] == 0 { - s := string(b.data[0:i]); - b.data = b.data[i+1:]; - b.off += Offset(i + 1); - return s; + s := string(b.data[0:i]) + b.data = b.data[i+1:] + b.off += Offset(i + 1) + return s } } - b.error("underflow"); - return ""; + b.error("underflow") + return "" } func (b *buf) uint16() uint16 { - a := b.bytes(2); + a := b.bytes(2) if a == nil { return 0 } - return b.order.Uint16(a); + return b.order.Uint16(a) } func (b *buf) uint32() uint32 { - a := b.bytes(4); + a := b.bytes(4) if a == nil { return 0 } - return b.order.Uint32(a); + return b.order.Uint32(a) } func (b *buf) uint64() uint64 { - a := b.bytes(8); + a := b.bytes(8) if a == nil { return 0 } - return b.order.Uint64(a); + return b.order.Uint64(a) } // Read a varint, which is 7 bits per byte, little endian. // the 0x80 bit means read another byte. func (b *buf) varint() (c uint64, bits uint) { for i := 0; i < len(b.data); i++ { - byte := b.data[i]; - c |= uint64(byte&0x7F) << bits; - bits += 7; + byte := b.data[i] + c |= uint64(byte&0x7F) << bits + bits += 7 if byte&0x80 == 0 { - b.off += Offset(i + 1); - b.data = b.data[i+1:]; - return c, bits; + b.off += Offset(i + 1) + b.data = b.data[i+1:] + return c, bits } } - return 0, 0; + return 0, 0 } // Unsigned int is just a varint. func (b *buf) uint() uint64 { - x, _ := b.varint(); - return x; + x, _ := b.varint() + return x } // Signed int is a sign-extended varint. func (b *buf) int() int64 { - ux, bits := b.varint(); - x := int64(ux); + ux, bits := b.varint() + x := int64(ux) if x&(1<<(bits-1)) != 0 { x |= -1 << bits } - return x; + return x } // Address-sized uint. @@ -132,21 +132,21 @@ func (b *buf) addr() uint64 { case 8: return uint64(b.uint64()) } - b.error("unknown address size"); - return 0; + b.error("unknown address size") + return 0 } func (b *buf) error(s string) { if b.err == nil { - b.data = nil; - b.err = DecodeError{b.name, b.off, s}; + b.data = nil + b.err = DecodeError{b.name, b.off, s} } } type DecodeError struct { - Name string; - Offset Offset; - Error string; + Name string + Offset Offset + Error string } func (e DecodeError) String() string { diff --git a/src/pkg/debug/dwarf/const.go b/src/pkg/debug/dwarf/const.go index 808a80c8a..d73480cb2 100644 --- a/src/pkg/debug/dwarf/const.go +++ b/src/pkg/debug/dwarf/const.go @@ -12,78 +12,78 @@ import "strconv" type Attr uint32 const ( - AttrSibling Attr = 0x01; - AttrLocation Attr = 0x02; - AttrName Attr = 0x03; - AttrOrdering Attr = 0x09; - AttrByteSize Attr = 0x0B; - AttrBitOffset Attr = 0x0C; - AttrBitSize Attr = 0x0D; - AttrStmtList Attr = 0x10; - AttrLowpc Attr = 0x11; - AttrHighpc Attr = 0x12; - AttrLanguage Attr = 0x13; - AttrDiscr Attr = 0x15; - AttrDiscrValue Attr = 0x16; - AttrVisibility Attr = 0x17; - AttrImport Attr = 0x18; - AttrStringLength Attr = 0x19; - AttrCommonRef Attr = 0x1A; - AttrCompDir Attr = 0x1B; - AttrConstValue Attr = 0x1C; - AttrContainingType Attr = 0x1D; - AttrDefaultValue Attr = 0x1E; - AttrInline Attr = 0x20; - AttrIsOptional Attr = 0x21; - AttrLowerBound Attr = 0x22; - AttrProducer Attr = 0x25; - AttrPrototyped Attr = 0x27; - AttrReturnAddr Attr = 0x2A; - AttrStartScope Attr = 0x2C; - AttrStrideSize Attr = 0x2E; - AttrUpperBound Attr = 0x2F; - AttrAbstractOrigin Attr = 0x31; - AttrAccessibility Attr = 0x32; - AttrAddrClass Attr = 0x33; - AttrArtificial Attr = 0x34; - AttrBaseTypes Attr = 0x35; - AttrCalling Attr = 0x36; - AttrCount Attr = 0x37; - AttrDataMemberLoc Attr = 0x38; - AttrDeclColumn Attr = 0x39; - AttrDeclFile Attr = 0x3A; - AttrDeclLine Attr = 0x3B; - AttrDeclaration Attr = 0x3C; - AttrDiscrList Attr = 0x3D; - AttrEncoding Attr = 0x3E; - AttrExternal Attr = 0x3F; - AttrFrameBase Attr = 0x40; - AttrFriend Attr = 0x41; - AttrIdentifierCase Attr = 0x42; - AttrMacroInfo Attr = 0x43; - AttrNamelistItem Attr = 0x44; - AttrPriority Attr = 0x45; - AttrSegment Attr = 0x46; - AttrSpecification Attr = 0x47; - AttrStaticLink Attr = 0x48; - AttrType Attr = 0x49; - AttrUseLocation Attr = 0x4A; - AttrVarParam Attr = 0x4B; - AttrVirtuality Attr = 0x4C; - AttrVtableElemLoc Attr = 0x4D; - AttrAllocated Attr = 0x4E; - AttrAssociated Attr = 0x4F; - AttrDataLocation Attr = 0x50; - AttrStride Attr = 0x51; - AttrEntrypc Attr = 0x52; - AttrUseUTF8 Attr = 0x53; - AttrExtension Attr = 0x54; - AttrRanges Attr = 0x55; - AttrTrampoline Attr = 0x56; - AttrCallColumn Attr = 0x57; - AttrCallFile Attr = 0x58; - AttrCallLine Attr = 0x59; - AttrDescription Attr = 0x5A; + AttrSibling Attr = 0x01 + AttrLocation Attr = 0x02 + AttrName Attr = 0x03 + AttrOrdering Attr = 0x09 + AttrByteSize Attr = 0x0B + AttrBitOffset Attr = 0x0C + AttrBitSize Attr = 0x0D + AttrStmtList Attr = 0x10 + AttrLowpc Attr = 0x11 + AttrHighpc Attr = 0x12 + AttrLanguage Attr = 0x13 + AttrDiscr Attr = 0x15 + AttrDiscrValue Attr = 0x16 + AttrVisibility Attr = 0x17 + AttrImport Attr = 0x18 + AttrStringLength Attr = 0x19 + AttrCommonRef Attr = 0x1A + AttrCompDir Attr = 0x1B + AttrConstValue Attr = 0x1C + AttrContainingType Attr = 0x1D + AttrDefaultValue Attr = 0x1E + AttrInline Attr = 0x20 + AttrIsOptional Attr = 0x21 + AttrLowerBound Attr = 0x22 + AttrProducer Attr = 0x25 + AttrPrototyped Attr = 0x27 + AttrReturnAddr Attr = 0x2A + AttrStartScope Attr = 0x2C + AttrStrideSize Attr = 0x2E + AttrUpperBound Attr = 0x2F + AttrAbstractOrigin Attr = 0x31 + AttrAccessibility Attr = 0x32 + AttrAddrClass Attr = 0x33 + AttrArtificial Attr = 0x34 + AttrBaseTypes Attr = 0x35 + AttrCalling Attr = 0x36 + AttrCount Attr = 0x37 + AttrDataMemberLoc Attr = 0x38 + AttrDeclColumn Attr = 0x39 + AttrDeclFile Attr = 0x3A + AttrDeclLine Attr = 0x3B + AttrDeclaration Attr = 0x3C + AttrDiscrList Attr = 0x3D + AttrEncoding Attr = 0x3E + AttrExternal Attr = 0x3F + AttrFrameBase Attr = 0x40 + AttrFriend Attr = 0x41 + AttrIdentifierCase Attr = 0x42 + AttrMacroInfo Attr = 0x43 + AttrNamelistItem Attr = 0x44 + AttrPriority Attr = 0x45 + AttrSegment Attr = 0x46 + AttrSpecification Attr = 0x47 + AttrStaticLink Attr = 0x48 + AttrType Attr = 0x49 + AttrUseLocation Attr = 0x4A + AttrVarParam Attr = 0x4B + AttrVirtuality Attr = 0x4C + AttrVtableElemLoc Attr = 0x4D + AttrAllocated Attr = 0x4E + AttrAssociated Attr = 0x4F + AttrDataLocation Attr = 0x50 + AttrStride Attr = 0x51 + AttrEntrypc Attr = 0x52 + AttrUseUTF8 Attr = 0x53 + AttrExtension Attr = 0x54 + AttrRanges Attr = 0x55 + AttrTrampoline Attr = 0x56 + AttrCallColumn Attr = 0x57 + AttrCallFile Attr = 0x58 + AttrCallLine Attr = 0x59 + AttrDescription Attr = 0x5A ) var attrNames = [...]string{ @@ -163,22 +163,22 @@ var attrNames = [...]string{ func (a Attr) String() string { if int(a) < len(attrNames) { - s := attrNames[a]; + s := attrNames[a] if s != "" { return s } } - return strconv.Itoa(int(a)); + return strconv.Itoa(int(a)) } func (a Attr) GoString() string { if int(a) < len(attrNames) { - s := attrNames[a]; + s := attrNames[a] if s != "" { return "dwarf.Attr" + s } } - return "dwarf.Attr(" + strconv.Itoa64(int64(a)) + ")"; + return "dwarf.Attr(" + strconv.Itoa64(int64(a)) + ")" } // A format is a DWARF data encoding format. @@ -186,89 +186,89 @@ type format uint32 const ( // value formats - formAddr format = 0x01; - formDwarfBlock2 format = 0x03; - formDwarfBlock4 format = 0x04; - formData2 format = 0x05; - formData4 format = 0x06; - formData8 format = 0x07; - formString format = 0x08; - formDwarfBlock format = 0x09; - formDwarfBlock1 format = 0x0A; - formData1 format = 0x0B; - formFlag format = 0x0C; - formSdata format = 0x0D; - formStrp format = 0x0E; - formUdata format = 0x0F; - formRefAddr format = 0x10; - formRef1 format = 0x11; - formRef2 format = 0x12; - formRef4 format = 0x13; - formRef8 format = 0x14; - formRefUdata format = 0x15; - formIndirect format = 0x16; + formAddr format = 0x01 + formDwarfBlock2 format = 0x03 + formDwarfBlock4 format = 0x04 + formData2 format = 0x05 + formData4 format = 0x06 + formData8 format = 0x07 + formString format = 0x08 + formDwarfBlock format = 0x09 + formDwarfBlock1 format = 0x0A + formData1 format = 0x0B + formFlag format = 0x0C + formSdata format = 0x0D + formStrp format = 0x0E + formUdata format = 0x0F + formRefAddr format = 0x10 + formRef1 format = 0x11 + formRef2 format = 0x12 + formRef4 format = 0x13 + formRef8 format = 0x14 + formRefUdata format = 0x15 + formIndirect format = 0x16 ) // A Tag is the classification (the type) of an Entry. type Tag uint32 const ( - TagArrayType Tag = 0x01; - TagClassType Tag = 0x02; - TagEntryPoint Tag = 0x03; - TagEnumerationType Tag = 0x04; - TagFormalParameter Tag = 0x05; - TagImportedDeclaration Tag = 0x08; - TagLabel Tag = 0x0A; - TagLexDwarfBlock Tag = 0x0B; - TagMember Tag = 0x0D; - TagPointerType Tag = 0x0F; - TagReferenceType Tag = 0x10; - TagCompileUnit Tag = 0x11; - TagStringType Tag = 0x12; - TagStructType Tag = 0x13; - TagSubroutineType Tag = 0x15; - TagTypedef Tag = 0x16; - TagUnionType Tag = 0x17; - TagUnspecifiedParameters Tag = 0x18; - TagVariant Tag = 0x19; - TagCommonDwarfBlock Tag = 0x1A; - TagCommonInclusion Tag = 0x1B; - TagInheritance Tag = 0x1C; - TagInlinedSubroutine Tag = 0x1D; - TagModule Tag = 0x1E; - TagPtrToMemberType Tag = 0x1F; - TagSetType Tag = 0x20; - TagSubrangeType Tag = 0x21; - TagWithStmt Tag = 0x22; - TagAccessDeclaration Tag = 0x23; - TagBaseType Tag = 0x24; - TagCatchDwarfBlock Tag = 0x25; - TagConstType Tag = 0x26; - TagConstant Tag = 0x27; - TagEnumerator Tag = 0x28; - TagFileType Tag = 0x29; - TagFriend Tag = 0x2A; - TagNamelist Tag = 0x2B; - TagNamelistItem Tag = 0x2C; - TagPackedType Tag = 0x2D; - TagSubprogram Tag = 0x2E; - TagTemplateTypeParameter Tag = 0x2F; - TagTemplateValueParameter Tag = 0x30; - TagThrownType Tag = 0x31; - TagTryDwarfBlock Tag = 0x32; - TagVariantPart Tag = 0x33; - TagVariable Tag = 0x34; - TagVolatileType Tag = 0x35; - TagDwarfProcedure Tag = 0x36; - TagRestrictType Tag = 0x37; - TagInterfaceType Tag = 0x38; - TagNamespace Tag = 0x39; - TagImportedModule Tag = 0x3A; - TagUnspecifiedType Tag = 0x3B; - TagPartialUnit Tag = 0x3C; - TagImportedUnit Tag = 0x3D; - TagMutableType Tag = 0x3E; + TagArrayType Tag = 0x01 + TagClassType Tag = 0x02 + TagEntryPoint Tag = 0x03 + TagEnumerationType Tag = 0x04 + TagFormalParameter Tag = 0x05 + TagImportedDeclaration Tag = 0x08 + TagLabel Tag = 0x0A + TagLexDwarfBlock Tag = 0x0B + TagMember Tag = 0x0D + TagPointerType Tag = 0x0F + TagReferenceType Tag = 0x10 + TagCompileUnit Tag = 0x11 + TagStringType Tag = 0x12 + TagStructType Tag = 0x13 + TagSubroutineType Tag = 0x15 + TagTypedef Tag = 0x16 + TagUnionType Tag = 0x17 + TagUnspecifiedParameters Tag = 0x18 + TagVariant Tag = 0x19 + TagCommonDwarfBlock Tag = 0x1A + TagCommonInclusion Tag = 0x1B + TagInheritance Tag = 0x1C + TagInlinedSubroutine Tag = 0x1D + TagModule Tag = 0x1E + TagPtrToMemberType Tag = 0x1F + TagSetType Tag = 0x20 + TagSubrangeType Tag = 0x21 + TagWithStmt Tag = 0x22 + TagAccessDeclaration Tag = 0x23 + TagBaseType Tag = 0x24 + TagCatchDwarfBlock Tag = 0x25 + TagConstType Tag = 0x26 + TagConstant Tag = 0x27 + TagEnumerator Tag = 0x28 + TagFileType Tag = 0x29 + TagFriend Tag = 0x2A + TagNamelist Tag = 0x2B + TagNamelistItem Tag = 0x2C + TagPackedType Tag = 0x2D + TagSubprogram Tag = 0x2E + TagTemplateTypeParameter Tag = 0x2F + TagTemplateValueParameter Tag = 0x30 + TagThrownType Tag = 0x31 + TagTryDwarfBlock Tag = 0x32 + TagVariantPart Tag = 0x33 + TagVariable Tag = 0x34 + TagVolatileType Tag = 0x35 + TagDwarfProcedure Tag = 0x36 + TagRestrictType Tag = 0x37 + TagInterfaceType Tag = 0x38 + TagNamespace Tag = 0x39 + TagImportedModule Tag = 0x3A + TagUnspecifiedType Tag = 0x3B + TagPartialUnit Tag = 0x3C + TagImportedUnit Tag = 0x3D + TagMutableType Tag = 0x3E ) var tagNames = [...]string{ @@ -332,22 +332,22 @@ var tagNames = [...]string{ func (t Tag) String() string { if int(t) < len(tagNames) { - s := tagNames[t]; + s := tagNames[t] if s != "" { return s } } - return strconv.Itoa(int(t)); + return strconv.Itoa(int(t)) } func (t Tag) GoString() string { if int(t) < len(tagNames) { - s := tagNames[t]; + s := tagNames[t] if s != "" { return "dwarf.Tag" + s } } - return "dwarf.Tag(" + strconv.Itoa64(int64(t)) + ")"; + return "dwarf.Tag(" + strconv.Itoa64(int64(t)) + ")" } // Location expression operators. @@ -356,78 +356,78 @@ func (t Tag) GoString() string { // This package does not implement full expressions; // the opPlusUconst operator is expected by the type parser. const ( - opAddr = 0x03; /* 1 op, const addr */ - opDeref = 0x06; - opConst1u = 0x08; /* 1 op, 1 byte const */ - opConst1s = 0x09; /* " signed */ - opConst2u = 0x0A; /* 1 op, 2 byte const */ - opConst2s = 0x0B; /* " signed */ - opConst4u = 0x0C; /* 1 op, 4 byte const */ - opConst4s = 0x0D; /* " signed */ - opConst8u = 0x0E; /* 1 op, 8 byte const */ - opConst8s = 0x0F; /* " signed */ - opConstu = 0x10; /* 1 op, LEB128 const */ - opConsts = 0x11; /* " signed */ - opDup = 0x12; - opDrop = 0x13; - opOver = 0x14; - opPick = 0x15; /* 1 op, 1 byte stack index */ - opSwap = 0x16; - opRot = 0x17; - opXderef = 0x18; - opAbs = 0x19; - opAnd = 0x1A; - opDiv = 0x1B; - opMinus = 0x1C; - opMod = 0x1D; - opMul = 0x1E; - opNeg = 0x1F; - opNot = 0x20; - opOr = 0x21; - opPlus = 0x22; - opPlusUconst = 0x23; /* 1 op, ULEB128 addend */ - opShl = 0x24; - opShr = 0x25; - opShra = 0x26; - opXor = 0x27; - opSkip = 0x2F; /* 1 op, signed 2-byte constant */ - opBra = 0x28; /* 1 op, signed 2-byte constant */ - opEq = 0x29; - opGe = 0x2A; - opGt = 0x2B; - opLe = 0x2C; - opLt = 0x2D; - opNe = 0x2E; - opLit0 = 0x30; + opAddr = 0x03 /* 1 op, const addr */ + opDeref = 0x06 + opConst1u = 0x08 /* 1 op, 1 byte const */ + opConst1s = 0x09 /* " signed */ + opConst2u = 0x0A /* 1 op, 2 byte const */ + opConst2s = 0x0B /* " signed */ + opConst4u = 0x0C /* 1 op, 4 byte const */ + opConst4s = 0x0D /* " signed */ + opConst8u = 0x0E /* 1 op, 8 byte const */ + opConst8s = 0x0F /* " signed */ + opConstu = 0x10 /* 1 op, LEB128 const */ + opConsts = 0x11 /* " signed */ + opDup = 0x12 + opDrop = 0x13 + opOver = 0x14 + opPick = 0x15 /* 1 op, 1 byte stack index */ + opSwap = 0x16 + opRot = 0x17 + opXderef = 0x18 + opAbs = 0x19 + opAnd = 0x1A + opDiv = 0x1B + opMinus = 0x1C + opMod = 0x1D + opMul = 0x1E + opNeg = 0x1F + opNot = 0x20 + opOr = 0x21 + opPlus = 0x22 + opPlusUconst = 0x23 /* 1 op, ULEB128 addend */ + opShl = 0x24 + opShr = 0x25 + opShra = 0x26 + opXor = 0x27 + opSkip = 0x2F /* 1 op, signed 2-byte constant */ + opBra = 0x28 /* 1 op, signed 2-byte constant */ + opEq = 0x29 + opGe = 0x2A + opGt = 0x2B + opLe = 0x2C + opLt = 0x2D + opNe = 0x2E + opLit0 = 0x30 /* OpLitN = OpLit0 + N for N = 0..31 */ - opReg0 = 0x50; + opReg0 = 0x50 /* OpRegN = OpReg0 + N for N = 0..31 */ - opBreg0 = 0x70; /* 1 op, signed LEB128 constant */ + opBreg0 = 0x70 /* 1 op, signed LEB128 constant */ /* OpBregN = OpBreg0 + N for N = 0..31 */ - opRegx = 0x90; /* 1 op, ULEB128 register */ - opFbreg = 0x91; /* 1 op, SLEB128 offset */ - opBregx = 0x92; /* 2 op, ULEB128 reg; SLEB128 off */ - opPiece = 0x93; /* 1 op, ULEB128 size of piece */ - opDerefSize = 0x94; /* 1-byte size of data retrieved */ - opXderefSize = 0x95; /* 1-byte size of data retrieved */ - opNop = 0x96; + opRegx = 0x90 /* 1 op, ULEB128 register */ + opFbreg = 0x91 /* 1 op, SLEB128 offset */ + opBregx = 0x92 /* 2 op, ULEB128 reg; SLEB128 off */ + opPiece = 0x93 /* 1 op, ULEB128 size of piece */ + opDerefSize = 0x94 /* 1-byte size of data retrieved */ + opXderefSize = 0x95 /* 1-byte size of data retrieved */ + opNop = 0x96 /* next four new in Dwarf v3 */ - opPushObjAddr = 0x97; - opCall2 = 0x98; /* 2-byte offset of DIE */ - opCall4 = 0x99; /* 4-byte offset of DIE */ - opCallRef = 0x9A; /* 4- or 8- byte offset of DIE */ + opPushObjAddr = 0x97 + opCall2 = 0x98 /* 2-byte offset of DIE */ + opCall4 = 0x99 /* 4-byte offset of DIE */ + opCallRef = 0x9A /* 4- or 8- byte offset of DIE */ /* 0xE0-0xFF reserved for user-specific */ ) // Basic type encodings -- the value for AttrEncoding in a TagBaseType Entry. const ( - encAddress = 0x01; - encBoolean = 0x02; - encComplexFloat = 0x03; - encFloat = 0x04; - encSigned = 0x05; - encSignedChar = 0x06; - encUnsigned = 0x07; - encUnsignedChar = 0x08; - encImaginaryFloat = 0x09; + encAddress = 0x01 + encBoolean = 0x02 + encComplexFloat = 0x03 + encFloat = 0x04 + encSigned = 0x05 + encSignedChar = 0x06 + encUnsigned = 0x07 + encUnsignedChar = 0x08 + encImaginaryFloat = 0x09 ) diff --git a/src/pkg/debug/dwarf/entry.go b/src/pkg/debug/dwarf/entry.go index a4f013c39..5f739c426 100644 --- a/src/pkg/debug/dwarf/entry.go +++ b/src/pkg/debug/dwarf/entry.go @@ -14,14 +14,14 @@ import "os" // a single entry's description: a sequence of attributes type abbrev struct { - tag Tag; - children bool; - field []afield; + tag Tag + children bool + field []afield } type afield struct { - attr Attr; - fmt format; + attr Attr + fmt format } // a map from entry format ids to their descriptions @@ -34,74 +34,74 @@ func (d *Data) parseAbbrev(off uint32) (abbrevTable, os.Error) { return m, nil } - data := d.abbrev; + data := d.abbrev if off > uint32(len(data)) { data = nil } else { data = data[off:] } - b := makeBuf(d, "abbrev", 0, data, 0); + b := makeBuf(d, "abbrev", 0, data, 0) // Error handling is simplified by the buf getters // returning an endless stream of 0s after an error. - m := make(abbrevTable); + m := make(abbrevTable) for { // Table ends with id == 0. - id := uint32(b.uint()); + id := uint32(b.uint()) if id == 0 { break } // Walk over attributes, counting. - n := 0; - b1 := b; // Read from copy of b. - b1.uint(); - b1.uint8(); + n := 0 + b1 := b // Read from copy of b. + b1.uint() + b1.uint8() for { - tag := b1.uint(); - fmt := b1.uint(); + tag := b1.uint() + fmt := b1.uint() if tag == 0 && fmt == 0 { break } - n++; + n++ } if b1.err != nil { return nil, b1.err } // Walk over attributes again, this time writing them down. - var a abbrev; - a.tag = Tag(b.uint()); - a.children = b.uint8() != 0; - a.field = make([]afield, n); + var a abbrev + a.tag = Tag(b.uint()) + a.children = b.uint8() != 0 + a.field = make([]afield, n) for i := range a.field { - a.field[i].attr = Attr(b.uint()); - a.field[i].fmt = format(b.uint()); + a.field[i].attr = Attr(b.uint()) + a.field[i].fmt = format(b.uint()) } - b.uint(); - b.uint(); + b.uint() + b.uint() - m[id] = a; + m[id] = a } if b.err != nil { return nil, b.err } - d.abbrevCache[off] = m; - return m, nil; + d.abbrevCache[off] = m + return m, nil } // An entry is a sequence of attribute/value pairs. type Entry struct { - Offset Offset; // offset of Entry in DWARF info - Tag Tag; // tag (kind of Entry) - Children bool; // whether Entry is followed by children - Field []Field; + Offset Offset // offset of Entry in DWARF info + Tag Tag // tag (kind of Entry) + Children bool // whether Entry is followed by children + Field []Field } // A Field is a single attribute/value pair in an Entry. type Field struct { - Attr Attr; - Val interface{}; + Attr Attr + Val interface{} } // Val returns the value associated with attribute Attr in Entry, @@ -117,7 +117,7 @@ func (e *Entry) Val(a Attr) interface{} { return f.Val } } - return nil; + return nil } // An Offset represents the location of an Entry within the DWARF info. @@ -127,25 +127,25 @@ type Offset uint32 // Entry reads a single entry from buf, decoding // according to the given abbreviation table. func (b *buf) entry(atab abbrevTable, ubase Offset) *Entry { - off := b.off; - id := uint32(b.uint()); + off := b.off + id := uint32(b.uint()) if id == 0 { return &Entry{} } - a, ok := atab[id]; + a, ok := atab[id] if !ok { - b.error("unknown abbreviation table index"); - return nil; + b.error("unknown abbreviation table index") + return nil } e := &Entry{ Offset: off, Tag: a.tag, Children: a.children, Field: make([]Field, len(a.field)), - }; + } for i := range e.Field { - e.Field[i].Attr = a.field[i].attr; - fmt := a.field[i].fmt; + e.Field[i].Attr = a.field[i].attr + fmt := a.field[i].fmt if fmt == formIndirect { fmt = format(b.uint()) } @@ -204,24 +204,24 @@ func (b *buf) entry(atab abbrevTable, ubase Offset) *Entry { case formString: val = b.string() case formStrp: - off := b.uint32(); // offset into .debug_str + off := b.uint32() // offset into .debug_str if b.err != nil { return nil } - b1 := makeBuf(b.dwarf, "str", 0, b.dwarf.str, 0); - b1.skip(int(off)); - val = b1.string(); + b1 := makeBuf(b.dwarf, "str", 0, b.dwarf.str, 0) + b1.skip(int(off)) + val = b1.string() if b1.err != nil { - b.err = b1.err; - return nil; + b.err = b1.err + return nil } } - e.Field[i].Val = val; + e.Field[i].Val = val } if b.err != nil { return nil } - return e; + return e } // A Reader allows reading Entry structures from a DWARF ``info'' section. @@ -230,58 +230,58 @@ func (b *buf) entry(atab abbrevTable, ubase Offset) *Entry { // If an entry has children, its Children field will be true, and the children // follow, terminated by an Entry with Tag 0. type Reader struct { - b buf; - d *Data; - err os.Error; - unit int; - lastChildren bool; // .Children of last entry returned by Next - lastSibling Offset; // .Val(AttrSibling) of last entry returned by Next + b buf + d *Data + err os.Error + unit int + lastChildren bool // .Children of last entry returned by Next + lastSibling Offset // .Val(AttrSibling) of last entry returned by Next } // Reader returns a new Reader for Data. // The reader is positioned at byte offset 0 in the DWARF ``info'' section. func (d *Data) Reader() *Reader { - r := &Reader{d: d}; - r.Seek(0); - return r; + r := &Reader{d: d} + r.Seek(0) + return r } // Seek positions the Reader at offset off in the encoded entry stream. // Offset 0 can be used to denote the first entry. func (r *Reader) Seek(off Offset) { - d := r.d; - r.err = nil; - r.lastChildren = false; + d := r.d + r.err = nil + r.lastChildren = false if off == 0 { if len(d.unit) == 0 { return } - u := &d.unit[0]; - r.unit = 0; - r.b = makeBuf(r.d, "info", u.off, u.data, u.addrsize); - return; + u := &d.unit[0] + r.unit = 0 + r.b = makeBuf(r.d, "info", u.off, u.data, u.addrsize) + return } // TODO(rsc): binary search (maybe a new package) - var i int; - var u *unit; + var i int + var u *unit for i = range d.unit { - u = &d.unit[i]; + u = &d.unit[i] if u.off <= off && off < u.off+Offset(len(u.data)) { - r.unit = i; - r.b = makeBuf(r.d, "info", off, u.data[off-u.off:], u.addrsize); - return; + r.unit = i + r.b = makeBuf(r.d, "info", off, u.data[off-u.off:], u.addrsize) + return } } - r.err = os.NewError("offset out of range"); + r.err = os.NewError("offset out of range") } // maybeNextUnit advances to the next unit if this one is finished. func (r *Reader) maybeNextUnit() { for len(r.b.data) == 0 && r.unit+1 < len(r.d.unit) { - r.unit++; - u := &r.d.unit[r.unit]; - r.b = makeBuf(r.d, "info", u.off, u.data, u.addrsize); + r.unit++ + u := &r.d.unit[r.unit] + r.b = makeBuf(r.d, "info", u.off, u.data, u.addrsize) } } @@ -293,25 +293,25 @@ func (r *Reader) Next() (*Entry, os.Error) { if r.err != nil { return nil, r.err } - r.maybeNextUnit(); + r.maybeNextUnit() if len(r.b.data) == 0 { return nil, nil } - u := &r.d.unit[r.unit]; - e := r.b.entry(u.atable, u.base); + u := &r.d.unit[r.unit] + e := r.b.entry(u.atable, u.base) if r.b.err != nil { - r.err = r.b.err; - return nil, r.err; + r.err = r.b.err + return nil, r.err } if e != nil { - r.lastChildren = e.Children; + r.lastChildren = e.Children if r.lastChildren { r.lastSibling, _ = e.Val(AttrSibling).(Offset) } } else { r.lastChildren = false } - return e, nil; + return e, nil } // SkipChildren skips over the child entries associated with @@ -327,12 +327,12 @@ func (r *Reader) SkipChildren() { // sibling, so we can avoid decoding the // child subtrees. if r.lastSibling >= r.b.off { - r.Seek(r.lastSibling); - return; + r.Seek(r.lastSibling) + return } for { - e, err := r.Next(); + e, err := r.Next() if err != nil || e == nil || e.Tag == 0 { break } diff --git a/src/pkg/debug/dwarf/open.go b/src/pkg/debug/dwarf/open.go index a5cb1a103..3a1b00311 100644 --- a/src/pkg/debug/dwarf/open.go +++ b/src/pkg/debug/dwarf/open.go @@ -8,29 +8,29 @@ package dwarf import ( - "encoding/binary"; - "os"; + "encoding/binary" + "os" ) // Data represents the DWARF debugging information // loaded from an executable file (for example, an ELF or Mach-O executable). type Data struct { // raw data - abbrev []byte; - aranges []byte; - frame []byte; - info []byte; - line []byte; - pubnames []byte; - ranges []byte; - str []byte; + abbrev []byte + aranges []byte + frame []byte + info []byte + line []byte + pubnames []byte + ranges []byte + str []byte // parsed data - abbrevCache map[uint32]abbrevTable; - addrsize int; - order binary.ByteOrder; - typeCache map[Offset]Type; - unit []unit; + abbrevCache map[uint32]abbrevTable + addrsize int + order binary.ByteOrder + typeCache map[Offset]Type + unit []unit } // New returns a new Data object initialized from the given parameters. @@ -52,14 +52,14 @@ func New(abbrev, aranges, frame, info, line, pubnames, ranges, str []byte) (*Dat str: str, abbrevCache: make(map[uint32]abbrevTable), typeCache: make(map[Offset]Type), - }; + } // Sniff .debug_info to figure out byte order. // bytes 4:6 are the version, a tiny 16-bit number (1, 2, 3). if len(d.info) < 6 { return nil, DecodeError{"info", Offset(len(d.info)), "too short"} } - x, y := d.info[4], d.info[5]; + x, y := d.info[4], d.info[5] switch { case x == 0 && y == 0: return nil, DecodeError{"info", 4, "unsupported version 0"} @@ -71,10 +71,10 @@ func New(abbrev, aranges, frame, info, line, pubnames, ranges, str []byte) (*Dat return nil, DecodeError{"info", 4, "cannot determine byte order"} } - u, err := d.parseUnits(); + u, err := d.parseUnits() if err != nil { return nil, err } - d.unit = u; - return d, nil; + d.unit = u + return d, nil } diff --git a/src/pkg/debug/dwarf/type.go b/src/pkg/debug/dwarf/type.go index bf57fd4bf..5d4a51653 100644 --- a/src/pkg/debug/dwarf/type.go +++ b/src/pkg/debug/dwarf/type.go @@ -9,259 +9,259 @@ package dwarf import ( - "os"; - "strconv"; + "os" + "strconv" ) // A Type conventionally represents a pointer to any of the // specific Type structures (CharType, StructType, etc.). type Type interface { - Common() *CommonType; - String() string; - Size() int64; + Common() *CommonType + String() string + Size() int64 } // A CommonType holds fields common to multiple types. // If a field is not known or not applicable for a given type, // the zero value is used. type CommonType struct { - ByteSize int64; // size of value of this type, in bytes - Name string; // name that can be used to refer to type + ByteSize int64 // size of value of this type, in bytes + Name string // name that can be used to refer to type } -func (c *CommonType) Common() *CommonType { return c } +func (c *CommonType) Common() *CommonType { return c } -func (c *CommonType) Size() int64 { return c.ByteSize } +func (c *CommonType) Size() int64 { return c.ByteSize } // Basic types // A BasicType holds fields common to all basic types. type BasicType struct { - CommonType; - BitSize int64; - BitOffset int64; + CommonType + BitSize int64 + BitOffset int64 } -func (b *BasicType) Basic() *BasicType { return b } +func (b *BasicType) Basic() *BasicType { return b } func (t *BasicType) String() string { if t.Name != "" { return t.Name } - return "?"; + return "?" } // A CharType represents a signed character type. type CharType struct { - BasicType; + BasicType } // A UcharType represents an unsigned character type. type UcharType struct { - BasicType; + BasicType } // An IntType represents a signed integer type. type IntType struct { - BasicType; + BasicType } // A UintType represents an unsigned integer type. type UintType struct { - BasicType; + BasicType } // A FloatType represents a floating point type. type FloatType struct { - BasicType; + BasicType } // A ComplexType represents a complex floating point type. type ComplexType struct { - BasicType; + BasicType } // A BoolType represents a boolean type. type BoolType struct { - BasicType; + BasicType } // An AddrType represents a machine address type. type AddrType struct { - BasicType; + BasicType } // qualifiers // A QualType represents a type that has the C/C++ "const", "restrict", or "volatile" qualifier. type QualType struct { - CommonType; - Qual string; - Type Type; + CommonType + Qual string + Type Type } -func (t *QualType) String() string { return t.Qual + " " + t.Type.String() } +func (t *QualType) String() string { return t.Qual + " " + t.Type.String() } -func (t *QualType) Size() int64 { return t.Type.Size() } +func (t *QualType) Size() int64 { return t.Type.Size() } // An ArrayType represents a fixed size array type. type ArrayType struct { - CommonType; - Type Type; - StrideBitSize int64; // if > 0, number of bits to hold each element - Count int64; // if == -1, an incomplete array, like char x[]. + CommonType + Type Type + StrideBitSize int64 // if > 0, number of bits to hold each element + Count int64 // if == -1, an incomplete array, like char x[]. } func (t *ArrayType) String() string { return "[" + strconv.Itoa64(t.Count) + "]" + t.Type.String() } -func (t *ArrayType) Size() int64 { return t.Count * t.Type.Size() } +func (t *ArrayType) Size() int64 { return t.Count * t.Type.Size() } // A VoidType represents the C void type. type VoidType struct { - CommonType; + CommonType } -func (t *VoidType) String() string { return "void" } +func (t *VoidType) String() string { return "void" } // A PtrType represents a pointer type. type PtrType struct { - CommonType; - Type Type; + CommonType + Type Type } -func (t *PtrType) String() string { return "*" + t.Type.String() } +func (t *PtrType) String() string { return "*" + t.Type.String() } // A StructType represents a struct, union, or C++ class type. type StructType struct { - CommonType; - StructName string; - Kind string; // "struct", "union", or "class". - Field []*StructField; - Incomplete bool; // if true, struct, union, class is declared but not defined + CommonType + StructName string + Kind string // "struct", "union", or "class". + Field []*StructField + Incomplete bool // if true, struct, union, class is declared but not defined } // A StructField represents a field in a struct, union, or C++ class type. type StructField struct { - Name string; - Type Type; - ByteOffset int64; - ByteSize int64; - BitOffset int64; // within the ByteSize bytes at ByteOffset - BitSize int64; // zero if not a bit field + Name string + Type Type + ByteOffset int64 + ByteSize int64 + BitOffset int64 // within the ByteSize bytes at ByteOffset + BitSize int64 // zero if not a bit field } func (t *StructType) String() string { if t.StructName != "" { return t.Kind + " " + t.StructName } - return t.Defn(); + return t.Defn() } func (t *StructType) Defn() string { - s := t.Kind; + s := t.Kind if t.StructName != "" { s += " " + t.StructName } if t.Incomplete { - s += " /*incomplete*/"; - return s; + s += " /*incomplete*/" + return s } - s += " {"; + s += " {" for i, f := range t.Field { if i > 0 { s += "; " } - s += f.Name + " " + f.Type.String(); - s += "@" + strconv.Itoa64(f.ByteOffset); + s += f.Name + " " + f.Type.String() + s += "@" + strconv.Itoa64(f.ByteOffset) if f.BitSize > 0 { - s += " : " + strconv.Itoa64(f.BitSize); - s += "@" + strconv.Itoa64(f.BitOffset); + s += " : " + strconv.Itoa64(f.BitSize) + s += "@" + strconv.Itoa64(f.BitOffset) } } - s += "}"; - return s; + s += "}" + return s } // An EnumType represents an enumerated type. // The only indication of its native integer type is its ByteSize // (inside CommonType). type EnumType struct { - CommonType; - EnumName string; - Val []*EnumValue; + CommonType + EnumName string + Val []*EnumValue } // An EnumValue represents a single enumeration value. type EnumValue struct { - Name string; - Val int64; + Name string + Val int64 } func (t *EnumType) String() string { - s := "enum"; + s := "enum" if t.EnumName != "" { s += " " + t.EnumName } - s += " {"; + s += " {" for i, v := range t.Val { if i > 0 { s += "; " } - s += v.Name + "=" + strconv.Itoa64(v.Val); + s += v.Name + "=" + strconv.Itoa64(v.Val) } - s += "}"; - return s; + s += "}" + return s } // A FuncType represents a function type. type FuncType struct { - CommonType; - ReturnType Type; - ParamType []Type; + CommonType + ReturnType Type + ParamType []Type } func (t *FuncType) String() string { - s := "func("; + s := "func(" for i, t := range t.ParamType { if i > 0 { s += ", " } - s += t.String(); + s += t.String() } - s += ")"; + s += ")" if t.ReturnType != nil { s += " " + t.ReturnType.String() } - return s; + return s } // A DotDotDotType represents the variadic ... function parameter. type DotDotDotType struct { - CommonType; + CommonType } -func (t *DotDotDotType) String() string { return "..." } +func (t *DotDotDotType) String() string { return "..." } // A TypedefType represents a named type. type TypedefType struct { - CommonType; - Type Type; + CommonType + Type Type } -func (t *TypedefType) String() string { return t.Name } +func (t *TypedefType) String() string { return t.Name } -func (t *TypedefType) Size() int64 { return t.Type.Size() } +func (t *TypedefType) Size() int64 { return t.Type.Size() } func (d *Data) Type(off Offset) (Type, os.Error) { if t, ok := d.typeCache[off]; ok { return t, nil } - r := d.Reader(); - r.Seek(off); - e, err := r.Next(); + r := d.Reader() + r.Seek(off) + e, err := r.Next() if err != nil { return nil, err } @@ -272,42 +272,42 @@ func (d *Data) Type(off Offset) (Type, os.Error) { // Parse type from Entry. // Must always set d.typeCache[off] before calling // d.Type recursively, to handle circular types correctly. - var typ Type; + var typ Type // Get next child; set err if error happens. next := func() *Entry { if !e.Children { return nil } - kid, err1 := r.Next(); + kid, err1 := r.Next() if err1 != nil { - err = err1; - return nil; + err = err1 + return nil } if kid == nil { - err = DecodeError{"info", r.b.off, "unexpected end of DWARF entries"}; - return nil; + err = DecodeError{"info", r.b.off, "unexpected end of DWARF entries"} + return nil } if kid.Tag == 0 { return nil } - return kid; - }; + return kid + } // Get Type referred to by Entry's AttrType field. // Set err if error happens. Not having a type is an error. typeOf := func(e *Entry) Type { - toff, ok := e.Val(AttrType).(Offset); + toff, ok := e.Val(AttrType).(Offset) if !ok { // It appears that no Type means "void". return new(VoidType) } - var t Type; + var t Type if t, err = d.Type(toff); err != nil { return nil } - return t; - }; + return t + } switch e.Tag { case TagArrayType: @@ -319,24 +319,24 @@ func (d *Data) Type(off Offset) (Type, os.Error) { // Children: // TagSubrangeType or TagEnumerationType giving one dimension. // dimensions are in left to right order. - t := new(ArrayType); - typ = t; - d.typeCache[off] = t; + t := new(ArrayType) + typ = t + d.typeCache[off] = t if t.Type = typeOf(e); err != nil { goto Error } - t.StrideBitSize, _ = e.Val(AttrStrideSize).(int64); + t.StrideBitSize, _ = e.Val(AttrStrideSize).(int64) // Accumulate dimensions, - ndim := 0; + ndim := 0 for kid := next(); kid != nil; kid = next() { // TODO(rsc): Can also be TagEnumerationType // but haven't seen that in the wild yet. switch kid.Tag { case TagSubrangeType: - max, ok := kid.Val(AttrUpperBound).(int64); + max, ok := kid.Val(AttrUpperBound).(int64) if !ok { - max = -2 // Count == -1, as in x[]. + max = -2 // Count == -1, as in x[]. } if ndim == 0 { t.Count = max + 1 @@ -345,15 +345,15 @@ func (d *Data) Type(off Offset) (Type, os.Error) { // Create new array type underneath this one. t.Type = &ArrayType{Type: t.Type, Count: max + 1} } - ndim++; + ndim++ case TagEnumerationType: - err = DecodeError{"info", kid.Offset, "cannot handle enumeration type as array bound"}; - goto Error; + err = DecodeError{"info", kid.Offset, "cannot handle enumeration type as array bound"} + goto Error } } if ndim == 0 { - err = DecodeError{"info", e.Offset, "missing dimension for array"}; - goto Error; + err = DecodeError{"info", e.Offset, "missing dimension for array"} + goto Error } case TagBaseType: @@ -364,16 +364,16 @@ func (d *Data) Type(off Offset) (Type, os.Error) { // AttrByteSize: size of type in bytes [required] // AttrBitOffset: for sub-byte types, size in bits // AttrBitSize: for sub-byte types, bit offset of high order bit in the AttrByteSize bytes - name, _ := e.Val(AttrName).(string); - enc, ok := e.Val(AttrEncoding).(int64); + name, _ := e.Val(AttrName).(string) + enc, ok := e.Val(AttrEncoding).(int64) if !ok { - err = DecodeError{"info", e.Offset, "missing encoding attribute for " + name}; - goto Error; + err = DecodeError{"info", e.Offset, "missing encoding attribute for " + name} + goto Error } switch enc { default: - err = DecodeError{"info", e.Offset, "unrecognized encoding attribute value"}; - goto Error; + err = DecodeError{"info", e.Offset, "unrecognized encoding attribute value"} + goto Error case encAddress: typ = new(AddrType) @@ -392,13 +392,13 @@ func (d *Data) Type(off Offset) (Type, os.Error) { case encUnsignedChar: typ = new(UcharType) } - d.typeCache[off] = typ; + d.typeCache[off] = typ t := typ.(interface { - Basic() *BasicType; - }).Basic(); - t.Name = name; - t.BitSize, _ = e.Val(AttrBitSize).(int64); - t.BitOffset, _ = e.Val(AttrBitOffset).(int64); + Basic() *BasicType + }).Basic() + t.Name = name + t.BitSize, _ = e.Val(AttrBitSize).(int64) + t.BitOffset, _ = e.Val(AttrBitOffset).(int64) case TagClassType, TagStructType, TagUnionType: // Structure, union, or class type. (DWARF v2 §5.5) @@ -415,9 +415,9 @@ func (d *Data) Type(off Offset) (Type, os.Error) { // AttrBitSize: bit size for bit fields // AttrDataMemberLoc: location within struct [required for struct, class] // There is much more to handle C++, all ignored for now. - t := new(StructType); - typ = t; - d.typeCache[off] = t; + t := new(StructType) + typ = t + d.typeCache[off] = t switch e.Tag { case TagClassType: t.Kind = "class" @@ -426,41 +426,41 @@ func (d *Data) Type(off Offset) (Type, os.Error) { case TagUnionType: t.Kind = "union" } - t.StructName, _ = e.Val(AttrName).(string); - t.Incomplete = e.Val(AttrDeclaration) != nil; - t.Field = make([]*StructField, 0, 8); + t.StructName, _ = e.Val(AttrName).(string) + t.Incomplete = e.Val(AttrDeclaration) != nil + t.Field = make([]*StructField, 0, 8) for kid := next(); kid != nil; kid = next() { if kid.Tag == TagMember { - f := new(StructField); + f := new(StructField) if f.Type = typeOf(kid); err != nil { goto Error } if loc, ok := kid.Val(AttrDataMemberLoc).([]byte); ok { - b := makeBuf(d, "location", 0, loc, d.addrsize); + b := makeBuf(d, "location", 0, loc, d.addrsize) if b.uint8() != opPlusUconst { - err = DecodeError{"info", kid.Offset, "unexpected opcode"}; - goto Error; + err = DecodeError{"info", kid.Offset, "unexpected opcode"} + goto Error } - f.ByteOffset = int64(b.uint()); + f.ByteOffset = int64(b.uint()) if b.err != nil { - err = b.err; - goto Error; + err = b.err + goto Error } } - f.Name, _ = kid.Val(AttrName).(string); - f.ByteSize, _ = kid.Val(AttrByteSize).(int64); - f.BitOffset, _ = kid.Val(AttrBitOffset).(int64); - f.BitSize, _ = kid.Val(AttrBitSize).(int64); - n := len(t.Field); + f.Name, _ = kid.Val(AttrName).(string) + f.ByteSize, _ = kid.Val(AttrByteSize).(int64) + f.BitOffset, _ = kid.Val(AttrBitOffset).(int64) + f.BitSize, _ = kid.Val(AttrBitSize).(int64) + n := len(t.Field) if n >= cap(t.Field) { - fld := make([]*StructField, n, n*2); + fld := make([]*StructField, n, n*2) for i, f := range t.Field { fld[i] = f } - t.Field = fld; + t.Field = fld } - t.Field = t.Field[0 : n+1]; - t.Field[n] = f; + t.Field = t.Field[0 : n+1] + t.Field[n] = f } } @@ -468,9 +468,9 @@ func (d *Data) Type(off Offset) (Type, os.Error) { // Type modifier (DWARF v2 §5.2) // Attributes: // AttrType: subtype - t := new(QualType); - typ = t; - d.typeCache[off] = t; + t := new(QualType) + typ = t + d.typeCache[off] = t if t.Type = typeOf(e); err != nil { goto Error } @@ -492,26 +492,26 @@ func (d *Data) Type(off Offset) (Type, os.Error) { // TagEnumerator: // AttrName: name of constant // AttrConstValue: value of constant - t := new(EnumType); - typ = t; - d.typeCache[off] = t; - t.EnumName, _ = e.Val(AttrName).(string); - t.Val = make([]*EnumValue, 0, 8); + t := new(EnumType) + typ = t + d.typeCache[off] = t + t.EnumName, _ = e.Val(AttrName).(string) + t.Val = make([]*EnumValue, 0, 8) for kid := next(); kid != nil; kid = next() { if kid.Tag == TagEnumerator { - f := new(EnumValue); - f.Name, _ = kid.Val(AttrName).(string); - f.Val, _ = kid.Val(AttrConstValue).(int64); - n := len(t.Val); + f := new(EnumValue) + f.Name, _ = kid.Val(AttrName).(string) + f.Val, _ = kid.Val(AttrConstValue).(int64) + n := len(t.Val) if n >= cap(t.Val) { - val := make([]*EnumValue, n, n*2); + val := make([]*EnumValue, n, n*2) for i, f := range t.Val { val[i] = f } - t.Val = val; + t.Val = val } - t.Val = t.Val[0 : n+1]; - t.Val[n] = f; + t.Val = t.Val[0 : n+1] + t.Val[n] = f } } @@ -520,14 +520,14 @@ func (d *Data) Type(off Offset) (Type, os.Error) { // Attributes: // AttrType: subtype [not required! void* has no AttrType] // AttrAddrClass: address class [ignored] - t := new(PtrType); - typ = t; - d.typeCache[off] = t; + t := new(PtrType) + typ = t + d.typeCache[off] = t if e.Val(AttrType) == nil { - t.Type = &VoidType{}; - break; + t.Type = &VoidType{} + break } - t.Type = typeOf(e); + t.Type = typeOf(e) case TagSubroutineType: // Subroutine type. (DWARF v2 §5.7) @@ -539,15 +539,15 @@ func (d *Data) Type(off Offset) (Type, os.Error) { // TagFormalParameter: typed parameter // AttrType: type of parameter // TagUnspecifiedParameter: final ... - t := new(FuncType); - typ = t; - d.typeCache[off] = t; + t := new(FuncType) + typ = t + d.typeCache[off] = t if t.ReturnType = typeOf(e); err != nil { goto Error } - t.ParamType = make([]Type, 0, 8); + t.ParamType = make([]Type, 0, 8) for kid := next(); kid != nil; kid = next() { - var tkid Type; + var tkid Type switch kid.Tag { default: continue @@ -558,16 +558,16 @@ func (d *Data) Type(off Offset) (Type, os.Error) { case TagUnspecifiedParameters: tkid = &DotDotDotType{} } - n := len(t.ParamType); + n := len(t.ParamType) if n >= cap(t.ParamType) { - param := make([]Type, n, n*2); + param := make([]Type, n, n*2) for i, t := range t.ParamType { param[i] = t } - t.ParamType = param; + t.ParamType = param } - t.ParamType = t.ParamType[0 : n+1]; - t.ParamType[n] = tkid; + t.ParamType = t.ParamType[0 : n+1] + t.ParamType[n] = tkid } case TagTypedef: @@ -575,29 +575,29 @@ func (d *Data) Type(off Offset) (Type, os.Error) { // Attributes: // AttrName: name [required] // AttrType: type definition [required] - t := new(TypedefType); - typ = t; - d.typeCache[off] = t; - t.Name, _ = e.Val(AttrName).(string); - t.Type = typeOf(e); + t := new(TypedefType) + typ = t + d.typeCache[off] = t + t.Name, _ = e.Val(AttrName).(string) + t.Type = typeOf(e) } if err != nil { goto Error } - b, ok := e.Val(AttrByteSize).(int64); + b, ok := e.Val(AttrByteSize).(int64) if !ok { b = -1 } - typ.Common().ByteSize = b; + typ.Common().ByteSize = b - return typ, nil; + return typ, nil Error: // If the parse fails, take the type out of the cache // so that the next call with this offset doesn't hit // the cache and return success. - d.typeCache[off] = nil, false; - return nil, err; + d.typeCache[off] = nil, false + return nil, err } diff --git a/src/pkg/debug/dwarf/type_test.go b/src/pkg/debug/dwarf/type_test.go index 629f0fb16..2c5aabd39 100644 --- a/src/pkg/debug/dwarf/type_test.go +++ b/src/pkg/debug/dwarf/type_test.go @@ -5,10 +5,10 @@ package dwarf_test import ( - . "debug/dwarf"; - "debug/elf"; - "debug/macho"; - "testing"; + . "debug/dwarf" + "debug/elf" + "debug/macho" + "testing" ) var typedefTests = map[string]string{ @@ -30,43 +30,43 @@ var typedefTests = map[string]string{ } func elfData(t *testing.T, name string) *Data { - f, err := elf.Open(name); + f, err := elf.Open(name) if err != nil { t.Fatal(err) } - d, err := f.DWARF(); + d, err := f.DWARF() if err != nil { t.Fatal(err) } - return d; + return d } func machoData(t *testing.T, name string) *Data { - f, err := macho.Open(name); + f, err := macho.Open(name) if err != nil { t.Fatal(err) } - d, err := f.DWARF(); + d, err := f.DWARF() if err != nil { t.Fatal(err) } - return d; + return d } -func TestTypedefsELF(t *testing.T) { testTypedefs(t, elfData(t, "testdata/typedef.elf")) } +func TestTypedefsELF(t *testing.T) { testTypedefs(t, elfData(t, "testdata/typedef.elf")) } func TestTypedefsMachO(t *testing.T) { testTypedefs(t, machoData(t, "testdata/typedef.macho")) } func testTypedefs(t *testing.T, d *Data) { - r := d.Reader(); - seen := make(map[string]bool); + r := d.Reader() + seen := make(map[string]bool) for { - e, err := r.Next(); + e, err := r.Next() if err != nil { t.Fatal("r.Next:", err) } @@ -74,12 +74,12 @@ func testTypedefs(t *testing.T, d *Data) { break } if e.Tag == TagTypedef { - typ, err := d.Type(e.Offset); + typ, err := d.Type(e.Offset) if err != nil { t.Fatal("d.Type:", err) } - t1 := typ.(*TypedefType); - var typstr string; + t1 := typ.(*TypedefType) + var typstr string if ts, ok := t1.Type.(*StructType); ok { typstr = ts.Defn() } else { @@ -90,7 +90,7 @@ func testTypedefs(t *testing.T, d *Data) { if _, ok := seen[t1.Name]; ok { t.Errorf("multiple definitions for %s", t1.Name) } - seen[t1.Name] = true; + seen[t1.Name] = true if typstr != want { t.Errorf("%s:\n\thave %s\n\twant %s", t1.Name, typstr, want) } diff --git a/src/pkg/debug/dwarf/unit.go b/src/pkg/debug/dwarf/unit.go index eb4e7656e..02cb363b4 100644 --- a/src/pkg/debug/dwarf/unit.go +++ b/src/pkg/debug/dwarf/unit.go @@ -5,58 +5,58 @@ package dwarf import ( - "os"; - "strconv"; + "os" + "strconv" ) // DWARF debug info is split into a sequence of compilation units. // Each unit has its own abbreviation table and address size. type unit struct { - base Offset; // byte offset of header within the aggregate info - off Offset; // byte offset of data within the aggregate info - data []byte; - atable abbrevTable; - addrsize int; + base Offset // byte offset of header within the aggregate info + off Offset // byte offset of data within the aggregate info + data []byte + atable abbrevTable + addrsize int } func (d *Data) parseUnits() ([]unit, os.Error) { // Count units. - nunit := 0; - b := makeBuf(d, "info", 0, d.info, 0); + nunit := 0 + b := makeBuf(d, "info", 0, d.info, 0) for len(b.data) > 0 { - b.skip(int(b.uint32())); - nunit++; + b.skip(int(b.uint32())) + nunit++ } if b.err != nil { return nil, b.err } // Again, this time writing them down. - b = makeBuf(d, "info", 0, d.info, 0); - units := make([]unit, nunit); + b = makeBuf(d, "info", 0, d.info, 0) + units := make([]unit, nunit) for i := range units { - u := &units[i]; - u.base = b.off; - n := b.uint32(); + u := &units[i] + u.base = b.off + n := b.uint32() if vers := b.uint16(); vers != 2 { - b.error("unsupported DWARF version " + strconv.Itoa(int(vers))); - break; + b.error("unsupported DWARF version " + strconv.Itoa(int(vers))) + break } - atable, err := d.parseAbbrev(b.uint32()); + atable, err := d.parseAbbrev(b.uint32()) if err != nil { if b.err == nil { b.err = err } - break; + break } - u.atable = atable; - u.addrsize = int(b.uint8()); - u.off = b.off; - u.data = b.bytes(int(n - (2 + 4 + 1))); + u.atable = atable + u.addrsize = int(b.uint8()) + u.off = b.off + u.data = b.bytes(int(n - (2 + 4 + 1))) } if b.err != nil { return nil, b.err } - return units, nil; + return units, nil } diff --git a/src/pkg/debug/elf/elf.go b/src/pkg/debug/elf/elf.go index 70a11f6f6..f0e49851b 100644 --- a/src/pkg/debug/elf/elf.go +++ b/src/pkg/debug/elf/elf.go @@ -48,13 +48,13 @@ import "strconv" // Indexes into the Header.Ident array. const ( - EI_CLASS = 4; /* Class of machine. */ - EI_DATA = 5; /* Data format. */ - EI_VERSION = 6; /* ELF format version. */ - EI_OSABI = 7; /* Operating system / ABI identification */ - EI_ABIVERSION = 8; /* ABI version */ - EI_PAD = 9; /* Start of padding (per SVR4 ABI). */ - EI_NIDENT = 16; /* Size of e_ident array. */ + EI_CLASS = 4 /* Class of machine. */ + EI_DATA = 5 /* Data format. */ + EI_VERSION = 6 /* ELF format version. */ + EI_OSABI = 7 /* Operating system / ABI identification */ + EI_ABIVERSION = 8 /* ABI version */ + EI_PAD = 9 /* Start of padding (per SVR4 ABI). */ + EI_NIDENT = 16 /* Size of e_ident array. */ ) // Initial magic number for ELF files. @@ -64,8 +64,8 @@ const ELFMAG = "\177ELF" type Version byte const ( - EV_NONE Version = 0; - EV_CURRENT Version = 1; + EV_NONE Version = 0 + EV_CURRENT Version = 1 ) var versionStrings = []intName{ @@ -73,16 +73,16 @@ var versionStrings = []intName{ intName{1, "EV_CURRENT"}, } -func (i Version) String() string { return stringName(uint32(i), versionStrings, false) } -func (i Version) GoString() string { return stringName(uint32(i), versionStrings, true) } +func (i Version) String() string { return stringName(uint32(i), versionStrings, false) } +func (i Version) GoString() string { return stringName(uint32(i), versionStrings, true) } // Class is found in Header.Ident[EI_CLASS] and Header.Class. type Class byte const ( - ELFCLASSNONE Class = 0; /* Unknown class. */ - ELFCLASS32 Class = 1; /* 32-bit architecture. */ - ELFCLASS64 Class = 2; /* 64-bit architecture. */ + ELFCLASSNONE Class = 0 /* Unknown class. */ + ELFCLASS32 Class = 1 /* 32-bit architecture. */ + ELFCLASS64 Class = 2 /* 64-bit architecture. */ ) var classStrings = []intName{ @@ -91,16 +91,16 @@ var classStrings = []intName{ intName{2, "ELFCLASS64"}, } -func (i Class) String() string { return stringName(uint32(i), classStrings, false) } -func (i Class) GoString() string { return stringName(uint32(i), classStrings, true) } +func (i Class) String() string { return stringName(uint32(i), classStrings, false) } +func (i Class) GoString() string { return stringName(uint32(i), classStrings, true) } // Data is found in Header.Ident[EI_DATA] and Header.Data. type Data byte const ( - ELFDATANONE Data = 0; /* Unknown data format. */ - ELFDATA2LSB Data = 1; /* 2's complement little-endian. */ - ELFDATA2MSB Data = 2; /* 2's complement big-endian. */ + ELFDATANONE Data = 0 /* Unknown data format. */ + ELFDATA2LSB Data = 1 /* 2's complement little-endian. */ + ELFDATA2MSB Data = 2 /* 2's complement big-endian. */ ) var dataStrings = []intName{ @@ -109,30 +109,30 @@ var dataStrings = []intName{ intName{2, "ELFDATA2MSB"}, } -func (i Data) String() string { return stringName(uint32(i), dataStrings, false) } -func (i Data) GoString() string { return stringName(uint32(i), dataStrings, true) } +func (i Data) String() string { return stringName(uint32(i), dataStrings, false) } +func (i Data) GoString() string { return stringName(uint32(i), dataStrings, true) } // OSABI is found in Header.Ident[EI_OSABI] and Header.OSABI. type OSABI byte const ( - ELFOSABI_NONE OSABI = 0; /* UNIX System V ABI */ - ELFOSABI_HPUX OSABI = 1; /* HP-UX operating system */ - ELFOSABI_NETBSD OSABI = 2; /* NetBSD */ - ELFOSABI_LINUX OSABI = 3; /* GNU/Linux */ - ELFOSABI_HURD OSABI = 4; /* GNU/Hurd */ - ELFOSABI_86OPEN OSABI = 5; /* 86Open common IA32 ABI */ - ELFOSABI_SOLARIS OSABI = 6; /* Solaris */ - ELFOSABI_AIX OSABI = 7; /* AIX */ - ELFOSABI_IRIX OSABI = 8; /* IRIX */ - ELFOSABI_FREEBSD OSABI = 9; /* FreeBSD */ - ELFOSABI_TRU64 OSABI = 10; /* TRU64 UNIX */ - ELFOSABI_MODESTO OSABI = 11; /* Novell Modesto */ - ELFOSABI_OPENBSD OSABI = 12; /* OpenBSD */ - ELFOSABI_OPENVMS OSABI = 13; /* Open VMS */ - ELFOSABI_NSK OSABI = 14; /* HP Non-Stop Kernel */ - ELFOSABI_ARM OSABI = 97; /* ARM */ - ELFOSABI_STANDALONE OSABI = 255; /* Standalone (embedded) application */ + ELFOSABI_NONE OSABI = 0 /* UNIX System V ABI */ + ELFOSABI_HPUX OSABI = 1 /* HP-UX operating system */ + ELFOSABI_NETBSD OSABI = 2 /* NetBSD */ + ELFOSABI_LINUX OSABI = 3 /* GNU/Linux */ + ELFOSABI_HURD OSABI = 4 /* GNU/Hurd */ + ELFOSABI_86OPEN OSABI = 5 /* 86Open common IA32 ABI */ + ELFOSABI_SOLARIS OSABI = 6 /* Solaris */ + ELFOSABI_AIX OSABI = 7 /* AIX */ + ELFOSABI_IRIX OSABI = 8 /* IRIX */ + ELFOSABI_FREEBSD OSABI = 9 /* FreeBSD */ + ELFOSABI_TRU64 OSABI = 10 /* TRU64 UNIX */ + ELFOSABI_MODESTO OSABI = 11 /* Novell Modesto */ + ELFOSABI_OPENBSD OSABI = 12 /* OpenBSD */ + ELFOSABI_OPENVMS OSABI = 13 /* Open VMS */ + ELFOSABI_NSK OSABI = 14 /* HP Non-Stop Kernel */ + ELFOSABI_ARM OSABI = 97 /* ARM */ + ELFOSABI_STANDALONE OSABI = 255 /* Standalone (embedded) application */ ) var osabiStrings = []intName{ @@ -155,22 +155,22 @@ var osabiStrings = []intName{ intName{255, "ELFOSABI_STANDALONE"}, } -func (i OSABI) String() string { return stringName(uint32(i), osabiStrings, false) } -func (i OSABI) GoString() string { return stringName(uint32(i), osabiStrings, true) } +func (i OSABI) String() string { return stringName(uint32(i), osabiStrings, false) } +func (i OSABI) GoString() string { return stringName(uint32(i), osabiStrings, true) } // Type is found in Header.Type. type Type uint16 const ( - ET_NONE Type = 0; /* Unknown type. */ - ET_REL Type = 1; /* Relocatable. */ - ET_EXEC Type = 2; /* Executable. */ - ET_DYN Type = 3; /* Shared object. */ - ET_CORE Type = 4; /* Core file. */ - ET_LOOS Type = 0xfe00; /* First operating system specific. */ - ET_HIOS Type = 0xfeff; /* Last operating system-specific. */ - ET_LOPROC Type = 0xff00; /* First processor-specific. */ - ET_HIPROC Type = 0xffff; /* Last processor-specific. */ + ET_NONE Type = 0 /* Unknown type. */ + ET_REL Type = 1 /* Relocatable. */ + ET_EXEC Type = 2 /* Executable. */ + ET_DYN Type = 3 /* Shared object. */ + ET_CORE Type = 4 /* Core file. */ + ET_LOOS Type = 0xfe00 /* First operating system specific. */ + ET_HIOS Type = 0xfeff /* Last operating system-specific. */ + ET_LOPROC Type = 0xff00 /* First processor-specific. */ + ET_HIPROC Type = 0xffff /* Last processor-specific. */ ) var typeStrings = []intName{ @@ -185,62 +185,62 @@ var typeStrings = []intName{ intName{0xffff, "ET_HIPROC"}, } -func (i Type) String() string { return stringName(uint32(i), typeStrings, false) } -func (i Type) GoString() string { return stringName(uint32(i), typeStrings, true) } +func (i Type) String() string { return stringName(uint32(i), typeStrings, false) } +func (i Type) GoString() string { return stringName(uint32(i), typeStrings, true) } // Machine is found in Header.Machine. type Machine uint16 const ( - EM_NONE Machine = 0; /* Unknown machine. */ - EM_M32 Machine = 1; /* AT&T WE32100. */ - EM_SPARC Machine = 2; /* Sun SPARC. */ - EM_386 Machine = 3; /* Intel i386. */ - EM_68K Machine = 4; /* Motorola 68000. */ - EM_88K Machine = 5; /* Motorola 88000. */ - EM_860 Machine = 7; /* Intel i860. */ - EM_MIPS Machine = 8; /* MIPS R3000 Big-Endian only. */ - EM_S370 Machine = 9; /* IBM System/370. */ - EM_MIPS_RS3_LE Machine = 10; /* MIPS R3000 Little-Endian. */ - EM_PARISC Machine = 15; /* HP PA-RISC. */ - EM_VPP500 Machine = 17; /* Fujitsu VPP500. */ - EM_SPARC32PLUS Machine = 18; /* SPARC v8plus. */ - EM_960 Machine = 19; /* Intel 80960. */ - EM_PPC Machine = 20; /* PowerPC 32-bit. */ - EM_PPC64 Machine = 21; /* PowerPC 64-bit. */ - EM_S390 Machine = 22; /* IBM System/390. */ - EM_V800 Machine = 36; /* NEC V800. */ - EM_FR20 Machine = 37; /* Fujitsu FR20. */ - EM_RH32 Machine = 38; /* TRW RH-32. */ - EM_RCE Machine = 39; /* Motorola RCE. */ - EM_ARM Machine = 40; /* ARM. */ - EM_SH Machine = 42; /* Hitachi SH. */ - EM_SPARCV9 Machine = 43; /* SPARC v9 64-bit. */ - EM_TRICORE Machine = 44; /* Siemens TriCore embedded processor. */ - EM_ARC Machine = 45; /* Argonaut RISC Core. */ - EM_H8_300 Machine = 46; /* Hitachi H8/300. */ - EM_H8_300H Machine = 47; /* Hitachi H8/300H. */ - EM_H8S Machine = 48; /* Hitachi H8S. */ - EM_H8_500 Machine = 49; /* Hitachi H8/500. */ - EM_IA_64 Machine = 50; /* Intel IA-64 Processor. */ - EM_MIPS_X Machine = 51; /* Stanford MIPS-X. */ - EM_COLDFIRE Machine = 52; /* Motorola ColdFire. */ - EM_68HC12 Machine = 53; /* Motorola M68HC12. */ - EM_MMA Machine = 54; /* Fujitsu MMA. */ - EM_PCP Machine = 55; /* Siemens PCP. */ - EM_NCPU Machine = 56; /* Sony nCPU. */ - EM_NDR1 Machine = 57; /* Denso NDR1 microprocessor. */ - EM_STARCORE Machine = 58; /* Motorola Star*Core processor. */ - EM_ME16 Machine = 59; /* Toyota ME16 processor. */ - EM_ST100 Machine = 60; /* STMicroelectronics ST100 processor. */ - EM_TINYJ Machine = 61; /* Advanced Logic Corp. TinyJ processor. */ - EM_X86_64 Machine = 62; /* Advanced Micro Devices x86-64 */ + EM_NONE Machine = 0 /* Unknown machine. */ + EM_M32 Machine = 1 /* AT&T WE32100. */ + EM_SPARC Machine = 2 /* Sun SPARC. */ + EM_386 Machine = 3 /* Intel i386. */ + EM_68K Machine = 4 /* Motorola 68000. */ + EM_88K Machine = 5 /* Motorola 88000. */ + EM_860 Machine = 7 /* Intel i860. */ + EM_MIPS Machine = 8 /* MIPS R3000 Big-Endian only. */ + EM_S370 Machine = 9 /* IBM System/370. */ + EM_MIPS_RS3_LE Machine = 10 /* MIPS R3000 Little-Endian. */ + EM_PARISC Machine = 15 /* HP PA-RISC. */ + EM_VPP500 Machine = 17 /* Fujitsu VPP500. */ + EM_SPARC32PLUS Machine = 18 /* SPARC v8plus. */ + EM_960 Machine = 19 /* Intel 80960. */ + EM_PPC Machine = 20 /* PowerPC 32-bit. */ + EM_PPC64 Machine = 21 /* PowerPC 64-bit. */ + EM_S390 Machine = 22 /* IBM System/390. */ + EM_V800 Machine = 36 /* NEC V800. */ + EM_FR20 Machine = 37 /* Fujitsu FR20. */ + EM_RH32 Machine = 38 /* TRW RH-32. */ + EM_RCE Machine = 39 /* Motorola RCE. */ + EM_ARM Machine = 40 /* ARM. */ + EM_SH Machine = 42 /* Hitachi SH. */ + EM_SPARCV9 Machine = 43 /* SPARC v9 64-bit. */ + EM_TRICORE Machine = 44 /* Siemens TriCore embedded processor. */ + EM_ARC Machine = 45 /* Argonaut RISC Core. */ + EM_H8_300 Machine = 46 /* Hitachi H8/300. */ + EM_H8_300H Machine = 47 /* Hitachi H8/300H. */ + EM_H8S Machine = 48 /* Hitachi H8S. */ + EM_H8_500 Machine = 49 /* Hitachi H8/500. */ + EM_IA_64 Machine = 50 /* Intel IA-64 Processor. */ + EM_MIPS_X Machine = 51 /* Stanford MIPS-X. */ + EM_COLDFIRE Machine = 52 /* Motorola ColdFire. */ + EM_68HC12 Machine = 53 /* Motorola M68HC12. */ + EM_MMA Machine = 54 /* Fujitsu MMA. */ + EM_PCP Machine = 55 /* Siemens PCP. */ + EM_NCPU Machine = 56 /* Sony nCPU. */ + EM_NDR1 Machine = 57 /* Denso NDR1 microprocessor. */ + EM_STARCORE Machine = 58 /* Motorola Star*Core processor. */ + EM_ME16 Machine = 59 /* Toyota ME16 processor. */ + EM_ST100 Machine = 60 /* STMicroelectronics ST100 processor. */ + EM_TINYJ Machine = 61 /* Advanced Logic Corp. TinyJ processor. */ + EM_X86_64 Machine = 62 /* Advanced Micro Devices x86-64 */ /* Non-standard or deprecated. */ - EM_486 Machine = 6; /* Intel i486. */ - EM_MIPS_RS4_BE Machine = 10; /* MIPS R4000 Big-Endian */ - EM_ALPHA_STD Machine = 41; /* Digital Alpha (standard value). */ - EM_ALPHA Machine = 0x9026; /* Alpha (written in the absence of an ABI) */ + EM_486 Machine = 6 /* Intel i486. */ + EM_MIPS_RS4_BE Machine = 10 /* MIPS R4000 Big-Endian */ + EM_ALPHA_STD Machine = 41 /* Digital Alpha (standard value). */ + EM_ALPHA Machine = 0x9026 /* Alpha (written in the absence of an ABI) */ ) var machineStrings = []intName{ @@ -295,23 +295,23 @@ var machineStrings = []intName{ intName{0x9026, "EM_ALPHA"}, } -func (i Machine) String() string { return stringName(uint32(i), machineStrings, false) } -func (i Machine) GoString() string { return stringName(uint32(i), machineStrings, true) } +func (i Machine) String() string { return stringName(uint32(i), machineStrings, false) } +func (i Machine) GoString() string { return stringName(uint32(i), machineStrings, true) } // Special section indices. type SectionIndex int const ( - SHN_UNDEF SectionIndex = 0; /* Undefined, missing, irrelevant. */ - SHN_LORESERVE SectionIndex = 0xff00; /* First of reserved range. */ - SHN_LOPROC SectionIndex = 0xff00; /* First processor-specific. */ - SHN_HIPROC SectionIndex = 0xff1f; /* Last processor-specific. */ - SHN_LOOS SectionIndex = 0xff20; /* First operating system-specific. */ - SHN_HIOS SectionIndex = 0xff3f; /* Last operating system-specific. */ - SHN_ABS SectionIndex = 0xfff1; /* Absolute values. */ - SHN_COMMON SectionIndex = 0xfff2; /* Common data. */ - SHN_XINDEX SectionIndex = 0xffff; /* Escape -- index stored elsewhere. */ - SHN_HIRESERVE SectionIndex = 0xffff; /* Last of reserved range. */ + SHN_UNDEF SectionIndex = 0 /* Undefined, missing, irrelevant. */ + SHN_LORESERVE SectionIndex = 0xff00 /* First of reserved range. */ + SHN_LOPROC SectionIndex = 0xff00 /* First processor-specific. */ + SHN_HIPROC SectionIndex = 0xff1f /* Last processor-specific. */ + SHN_LOOS SectionIndex = 0xff20 /* First operating system-specific. */ + SHN_HIOS SectionIndex = 0xff3f /* Last operating system-specific. */ + SHN_ABS SectionIndex = 0xfff1 /* Absolute values. */ + SHN_COMMON SectionIndex = 0xfff2 /* Common data. */ + SHN_XINDEX SectionIndex = 0xffff /* Escape -- index stored elsewhere. */ + SHN_HIRESERVE SectionIndex = 0xffff /* Last of reserved range. */ ) var shnStrings = []intName{ @@ -323,36 +323,36 @@ var shnStrings = []intName{ intName{0xffff, "SHN_XINDEX"}, } -func (i SectionIndex) String() string { return stringName(uint32(i), shnStrings, false) } -func (i SectionIndex) GoString() string { return stringName(uint32(i), shnStrings, true) } +func (i SectionIndex) String() string { return stringName(uint32(i), shnStrings, false) } +func (i SectionIndex) GoString() string { return stringName(uint32(i), shnStrings, true) } // Section type. type SectionType uint32 const ( - SHT_NULL SectionType = 0; /* inactive */ - SHT_PROGBITS SectionType = 1; /* program defined information */ - SHT_SYMTAB SectionType = 2; /* symbol table section */ - SHT_STRTAB SectionType = 3; /* string table section */ - SHT_RELA SectionType = 4; /* relocation section with addends */ - SHT_HASH SectionType = 5; /* symbol hash table section */ - SHT_DYNAMIC SectionType = 6; /* dynamic section */ - SHT_NOTE SectionType = 7; /* note section */ - SHT_NOBITS SectionType = 8; /* no space section */ - SHT_REL SectionType = 9; /* relocation section - no addends */ - SHT_SHLIB SectionType = 10; /* reserved - purpose unknown */ - SHT_DYNSYM SectionType = 11; /* dynamic symbol table section */ - SHT_INIT_ARRAY SectionType = 14; /* Initialization function pointers. */ - SHT_FINI_ARRAY SectionType = 15; /* Termination function pointers. */ - SHT_PREINIT_ARRAY SectionType = 16; /* Pre-initialization function ptrs. */ - SHT_GROUP SectionType = 17; /* Section group. */ - SHT_SYMTAB_SHNDX SectionType = 18; /* Section indexes (see SHN_XINDEX). */ - SHT_LOOS SectionType = 0x60000000; /* First of OS specific semantics */ - SHT_HIOS SectionType = 0x6fffffff; /* Last of OS specific semantics */ - SHT_LOPROC SectionType = 0x70000000; /* reserved range for processor */ - SHT_HIPROC SectionType = 0x7fffffff; /* specific section header types */ - SHT_LOUSER SectionType = 0x80000000; /* reserved range for application */ - SHT_HIUSER SectionType = 0xffffffff; /* specific indexes */ + SHT_NULL SectionType = 0 /* inactive */ + SHT_PROGBITS SectionType = 1 /* program defined information */ + SHT_SYMTAB SectionType = 2 /* symbol table section */ + SHT_STRTAB SectionType = 3 /* string table section */ + SHT_RELA SectionType = 4 /* relocation section with addends */ + SHT_HASH SectionType = 5 /* symbol hash table section */ + SHT_DYNAMIC SectionType = 6 /* dynamic section */ + SHT_NOTE SectionType = 7 /* note section */ + SHT_NOBITS SectionType = 8 /* no space section */ + SHT_REL SectionType = 9 /* relocation section - no addends */ + SHT_SHLIB SectionType = 10 /* reserved - purpose unknown */ + SHT_DYNSYM SectionType = 11 /* dynamic symbol table section */ + SHT_INIT_ARRAY SectionType = 14 /* Initialization function pointers. */ + SHT_FINI_ARRAY SectionType = 15 /* Termination function pointers. */ + SHT_PREINIT_ARRAY SectionType = 16 /* Pre-initialization function ptrs. */ + SHT_GROUP SectionType = 17 /* Section group. */ + SHT_SYMTAB_SHNDX SectionType = 18 /* Section indexes (see SHN_XINDEX). */ + SHT_LOOS SectionType = 0x60000000 /* First of OS specific semantics */ + SHT_HIOS SectionType = 0x6fffffff /* Last of OS specific semantics */ + SHT_LOPROC SectionType = 0x70000000 /* reserved range for processor */ + SHT_HIPROC SectionType = 0x7fffffff /* specific section header types */ + SHT_LOUSER SectionType = 0x80000000 /* reserved range for application */ + SHT_HIUSER SectionType = 0xffffffff /* specific indexes */ ) var shtStrings = []intName{ @@ -381,25 +381,25 @@ var shtStrings = []intName{ intName{0xffffffff, "SHT_HIUSER"}, } -func (i SectionType) String() string { return stringName(uint32(i), shtStrings, false) } -func (i SectionType) GoString() string { return stringName(uint32(i), shtStrings, true) } +func (i SectionType) String() string { return stringName(uint32(i), shtStrings, false) } +func (i SectionType) GoString() string { return stringName(uint32(i), shtStrings, true) } // Section flags. type SectionFlag uint32 const ( - SHF_WRITE SectionFlag = 0x1; /* Section contains writable data. */ - SHF_ALLOC SectionFlag = 0x2; /* Section occupies memory. */ - SHF_EXECINSTR SectionFlag = 0x4; /* Section contains instructions. */ - SHF_MERGE SectionFlag = 0x10; /* Section may be merged. */ - SHF_STRINGS SectionFlag = 0x20; /* Section contains strings. */ - SHF_INFO_LINK SectionFlag = 0x40; /* sh_info holds section index. */ - SHF_LINK_ORDER SectionFlag = 0x80; /* Special ordering requirements. */ - SHF_OS_NONCONFORMING SectionFlag = 0x100; /* OS-specific processing required. */ - SHF_GROUP SectionFlag = 0x200; /* Member of section group. */ - SHF_TLS SectionFlag = 0x400; /* Section contains TLS data. */ - SHF_MASKOS SectionFlag = 0x0ff00000; /* OS-specific semantics. */ - SHF_MASKPROC SectionFlag = 0xf0000000; /* Processor-specific semantics. */ + SHF_WRITE SectionFlag = 0x1 /* Section contains writable data. */ + SHF_ALLOC SectionFlag = 0x2 /* Section occupies memory. */ + SHF_EXECINSTR SectionFlag = 0x4 /* Section contains instructions. */ + SHF_MERGE SectionFlag = 0x10 /* Section may be merged. */ + SHF_STRINGS SectionFlag = 0x20 /* Section contains strings. */ + SHF_INFO_LINK SectionFlag = 0x40 /* sh_info holds section index. */ + SHF_LINK_ORDER SectionFlag = 0x80 /* Special ordering requirements. */ + SHF_OS_NONCONFORMING SectionFlag = 0x100 /* OS-specific processing required. */ + SHF_GROUP SectionFlag = 0x200 /* Member of section group. */ + SHF_TLS SectionFlag = 0x400 /* Section contains TLS data. */ + SHF_MASKOS SectionFlag = 0x0ff00000 /* OS-specific semantics. */ + SHF_MASKPROC SectionFlag = 0xf0000000 /* Processor-specific semantics. */ ) var shfStrings = []intName{ @@ -415,25 +415,25 @@ var shfStrings = []intName{ intName{0x400, "SHF_TLS"}, } -func (i SectionFlag) String() string { return flagName(uint32(i), shfStrings, false) } -func (i SectionFlag) GoString() string { return flagName(uint32(i), shfStrings, true) } +func (i SectionFlag) String() string { return flagName(uint32(i), shfStrings, false) } +func (i SectionFlag) GoString() string { return flagName(uint32(i), shfStrings, true) } // Prog.Type type ProgType int const ( - PT_NULL ProgType = 0; /* Unused entry. */ - PT_LOAD ProgType = 1; /* Loadable segment. */ - PT_DYNAMIC ProgType = 2; /* Dynamic linking information segment. */ - PT_INTERP ProgType = 3; /* Pathname of interpreter. */ - PT_NOTE ProgType = 4; /* Auxiliary information. */ - PT_SHLIB ProgType = 5; /* Reserved (not used). */ - PT_PHDR ProgType = 6; /* Location of program header itself. */ - PT_TLS ProgType = 7; /* Thread local storage segment */ - PT_LOOS ProgType = 0x60000000; /* First OS-specific. */ - PT_HIOS ProgType = 0x6fffffff; /* Last OS-specific. */ - PT_LOPROC ProgType = 0x70000000; /* First processor-specific type. */ - PT_HIPROC ProgType = 0x7fffffff; /* Last processor-specific type. */ + PT_NULL ProgType = 0 /* Unused entry. */ + PT_LOAD ProgType = 1 /* Loadable segment. */ + PT_DYNAMIC ProgType = 2 /* Dynamic linking information segment. */ + PT_INTERP ProgType = 3 /* Pathname of interpreter. */ + PT_NOTE ProgType = 4 /* Auxiliary information. */ + PT_SHLIB ProgType = 5 /* Reserved (not used). */ + PT_PHDR ProgType = 6 /* Location of program header itself. */ + PT_TLS ProgType = 7 /* Thread local storage segment */ + PT_LOOS ProgType = 0x60000000 /* First OS-specific. */ + PT_HIOS ProgType = 0x6fffffff /* Last OS-specific. */ + PT_LOPROC ProgType = 0x70000000 /* First processor-specific type. */ + PT_HIPROC ProgType = 0x7fffffff /* Last processor-specific type. */ ) var ptStrings = []intName{ @@ -451,18 +451,18 @@ var ptStrings = []intName{ intName{0x7fffffff, "PT_HIPROC"}, } -func (i ProgType) String() string { return stringName(uint32(i), ptStrings, false) } -func (i ProgType) GoString() string { return stringName(uint32(i), ptStrings, true) } +func (i ProgType) String() string { return stringName(uint32(i), ptStrings, false) } +func (i ProgType) GoString() string { return stringName(uint32(i), ptStrings, true) } // Prog.Flag type ProgFlag uint32 const ( - PF_X ProgFlag = 0x1; /* Executable. */ - PF_W ProgFlag = 0x2; /* Writable. */ - PF_R ProgFlag = 0x4; /* Readable. */ - PF_MASKOS ProgFlag = 0x0ff00000; /* Operating system-specific. */ - PF_MASKPROC ProgFlag = 0xf0000000; /* Processor-specific. */ + PF_X ProgFlag = 0x1 /* Executable. */ + PF_W ProgFlag = 0x2 /* Writable. */ + PF_R ProgFlag = 0x4 /* Readable. */ + PF_MASKOS ProgFlag = 0x0ff00000 /* Operating system-specific. */ + PF_MASKPROC ProgFlag = 0xf0000000 /* Processor-specific. */ ) var pfStrings = []intName{ @@ -471,55 +471,55 @@ var pfStrings = []intName{ intName{0x4, "PF_R"}, } -func (i ProgFlag) String() string { return flagName(uint32(i), pfStrings, false) } -func (i ProgFlag) GoString() string { return flagName(uint32(i), pfStrings, true) } +func (i ProgFlag) String() string { return flagName(uint32(i), pfStrings, false) } +func (i ProgFlag) GoString() string { return flagName(uint32(i), pfStrings, true) } // Dyn.Tag type DynTag int const ( - DT_NULL DynTag = 0; /* Terminating entry. */ - DT_NEEDED DynTag = 1; /* String table offset of a needed shared library. */ - DT_PLTRELSZ DynTag = 2; /* Total size in bytes of PLT relocations. */ - DT_PLTGOT DynTag = 3; /* Processor-dependent address. */ - DT_HASH DynTag = 4; /* Address of symbol hash table. */ - DT_STRTAB DynTag = 5; /* Address of string table. */ - DT_SYMTAB DynTag = 6; /* Address of symbol table. */ - DT_RELA DynTag = 7; /* Address of ElfNN_Rela relocations. */ - DT_RELASZ DynTag = 8; /* Total size of ElfNN_Rela relocations. */ - DT_RELAENT DynTag = 9; /* Size of each ElfNN_Rela relocation entry. */ - DT_STRSZ DynTag = 10; /* Size of string table. */ - DT_SYMENT DynTag = 11; /* Size of each symbol table entry. */ - DT_INIT DynTag = 12; /* Address of initialization function. */ - DT_FINI DynTag = 13; /* Address of finalization function. */ - DT_SONAME DynTag = 14; /* String table offset of shared object name. */ - DT_RPATH DynTag = 15; /* String table offset of library path. [sup] */ - DT_SYMBOLIC DynTag = 16; /* Indicates "symbolic" linking. [sup] */ - DT_REL DynTag = 17; /* Address of ElfNN_Rel relocations. */ - DT_RELSZ DynTag = 18; /* Total size of ElfNN_Rel relocations. */ - DT_RELENT DynTag = 19; /* Size of each ElfNN_Rel relocation. */ - DT_PLTREL DynTag = 20; /* Type of relocation used for PLT. */ - DT_DEBUG DynTag = 21; /* Reserved (not used). */ - DT_TEXTREL DynTag = 22; /* Indicates there may be relocations in non-writable segments. [sup] */ - DT_JMPREL DynTag = 23; /* Address of PLT relocations. */ - DT_BIND_NOW DynTag = 24; /* [sup] */ - DT_INIT_ARRAY DynTag = 25; /* Address of the array of pointers to initialization functions */ - DT_FINI_ARRAY DynTag = 26; /* Address of the array of pointers to termination functions */ - DT_INIT_ARRAYSZ DynTag = 27; /* Size in bytes of the array of initialization functions. */ - DT_FINI_ARRAYSZ DynTag = 28; /* Size in bytes of the array of terminationfunctions. */ - DT_RUNPATH DynTag = 29; /* String table offset of a null-terminated library search path string. */ - DT_FLAGS DynTag = 30; /* Object specific flag values. */ - DT_ENCODING DynTag = 32; /* Values greater than or equal to DT_ENCODING + DT_NULL DynTag = 0 /* Terminating entry. */ + DT_NEEDED DynTag = 1 /* String table offset of a needed shared library. */ + DT_PLTRELSZ DynTag = 2 /* Total size in bytes of PLT relocations. */ + DT_PLTGOT DynTag = 3 /* Processor-dependent address. */ + DT_HASH DynTag = 4 /* Address of symbol hash table. */ + DT_STRTAB DynTag = 5 /* Address of string table. */ + DT_SYMTAB DynTag = 6 /* Address of symbol table. */ + DT_RELA DynTag = 7 /* Address of ElfNN_Rela relocations. */ + DT_RELASZ DynTag = 8 /* Total size of ElfNN_Rela relocations. */ + DT_RELAENT DynTag = 9 /* Size of each ElfNN_Rela relocation entry. */ + DT_STRSZ DynTag = 10 /* Size of string table. */ + DT_SYMENT DynTag = 11 /* Size of each symbol table entry. */ + DT_INIT DynTag = 12 /* Address of initialization function. */ + DT_FINI DynTag = 13 /* Address of finalization function. */ + DT_SONAME DynTag = 14 /* String table offset of shared object name. */ + DT_RPATH DynTag = 15 /* String table offset of library path. [sup] */ + DT_SYMBOLIC DynTag = 16 /* Indicates "symbolic" linking. [sup] */ + DT_REL DynTag = 17 /* Address of ElfNN_Rel relocations. */ + DT_RELSZ DynTag = 18 /* Total size of ElfNN_Rel relocations. */ + DT_RELENT DynTag = 19 /* Size of each ElfNN_Rel relocation. */ + DT_PLTREL DynTag = 20 /* Type of relocation used for PLT. */ + DT_DEBUG DynTag = 21 /* Reserved (not used). */ + DT_TEXTREL DynTag = 22 /* Indicates there may be relocations in non-writable segments. [sup] */ + DT_JMPREL DynTag = 23 /* Address of PLT relocations. */ + DT_BIND_NOW DynTag = 24 /* [sup] */ + DT_INIT_ARRAY DynTag = 25 /* Address of the array of pointers to initialization functions */ + DT_FINI_ARRAY DynTag = 26 /* Address of the array of pointers to termination functions */ + DT_INIT_ARRAYSZ DynTag = 27 /* Size in bytes of the array of initialization functions. */ + DT_FINI_ARRAYSZ DynTag = 28 /* Size in bytes of the array of terminationfunctions. */ + DT_RUNPATH DynTag = 29 /* String table offset of a null-terminated library search path string. */ + DT_FLAGS DynTag = 30 /* Object specific flag values. */ + DT_ENCODING DynTag = 32 /* Values greater than or equal to DT_ENCODING and less than DT_LOOS follow the rules for the interpretation of the d_un union as follows: even == 'd_ptr', even == 'd_val' or none */ - DT_PREINIT_ARRAY DynTag = 32; /* Address of the array of pointers to pre-initialization functions. */ - DT_PREINIT_ARRAYSZ DynTag = 33; /* Size in bytes of the array of pre-initialization functions. */ - DT_LOOS DynTag = 0x6000000d; /* First OS-specific */ - DT_HIOS DynTag = 0x6ffff000; /* Last OS-specific */ - DT_LOPROC DynTag = 0x70000000; /* First processor-specific type. */ - DT_HIPROC DynTag = 0x7fffffff; /* Last processor-specific type. */ + DT_PREINIT_ARRAY DynTag = 32 /* Address of the array of pointers to pre-initialization functions. */ + DT_PREINIT_ARRAYSZ DynTag = 33 /* Size in bytes of the array of pre-initialization functions. */ + DT_LOOS DynTag = 0x6000000d /* First OS-specific */ + DT_HIOS DynTag = 0x6ffff000 /* Last OS-specific */ + DT_LOPROC DynTag = 0x70000000 /* First processor-specific type. */ + DT_HIPROC DynTag = 0x7fffffff /* Last processor-specific type. */ ) var dtStrings = []intName{ @@ -563,23 +563,23 @@ var dtStrings = []intName{ intName{0x7fffffff, "DT_HIPROC"}, } -func (i DynTag) String() string { return stringName(uint32(i), dtStrings, false) } -func (i DynTag) GoString() string { return stringName(uint32(i), dtStrings, true) } +func (i DynTag) String() string { return stringName(uint32(i), dtStrings, false) } +func (i DynTag) GoString() string { return stringName(uint32(i), dtStrings, true) } // DT_FLAGS values. type DynFlag int const ( - DF_ORIGIN DynFlag = 0x0001; /* Indicates that the object being loaded may + DF_ORIGIN DynFlag = 0x0001 /* Indicates that the object being loaded may make reference to the $ORIGIN substitution string */ - DF_SYMBOLIC DynFlag = 0x0002; /* Indicates "symbolic" linking. */ - DF_TEXTREL DynFlag = 0x0004; /* Indicates there may be relocations in non-writable segments. */ - DF_BIND_NOW DynFlag = 0x0008; /* Indicates that the dynamic linker should + DF_SYMBOLIC DynFlag = 0x0002 /* Indicates "symbolic" linking. */ + DF_TEXTREL DynFlag = 0x0004 /* Indicates there may be relocations in non-writable segments. */ + DF_BIND_NOW DynFlag = 0x0008 /* Indicates that the dynamic linker should process all relocations for the object containing this entry before transferring control to the program. */ - DF_STATIC_TLS DynFlag = 0x0010; /* Indicates that the shared object or + DF_STATIC_TLS DynFlag = 0x0010 /* Indicates that the shared object or executable contains code using a static thread-local storage scheme. */ ) @@ -592,16 +592,16 @@ var dflagStrings = []intName{ intName{0x0010, "DF_STATIC_TLS"}, } -func (i DynFlag) String() string { return flagName(uint32(i), dflagStrings, false) } -func (i DynFlag) GoString() string { return flagName(uint32(i), dflagStrings, true) } +func (i DynFlag) String() string { return flagName(uint32(i), dflagStrings, false) } +func (i DynFlag) GoString() string { return flagName(uint32(i), dflagStrings, true) } // NType values; used in core files. type NType int const ( - NT_PRSTATUS NType = 1; /* Process status. */ - NT_FPREGSET NType = 2; /* Floating point registers. */ - NT_PRPSINFO NType = 3; /* Process state info. */ + NT_PRSTATUS NType = 1 /* Process status. */ + NT_FPREGSET NType = 2 /* Floating point registers. */ + NT_PRPSINFO NType = 3 /* Process state info. */ ) var ntypeStrings = []intName{ @@ -610,20 +610,20 @@ var ntypeStrings = []intName{ intName{3, "NT_PRPSINFO"}, } -func (i NType) String() string { return stringName(uint32(i), ntypeStrings, false) } -func (i NType) GoString() string { return stringName(uint32(i), ntypeStrings, true) } +func (i NType) String() string { return stringName(uint32(i), ntypeStrings, false) } +func (i NType) GoString() string { return stringName(uint32(i), ntypeStrings, true) } /* Symbol Binding - ELFNN_ST_BIND - st_info */ type SymBind int const ( - STB_LOCAL SymBind = 0; /* Local symbol */ - STB_GLOBAL SymBind = 1; /* Global symbol */ - STB_WEAK SymBind = 2; /* like global - lower precedence */ - STB_LOOS SymBind = 10; /* Reserved range for operating system */ - STB_HIOS SymBind = 12; /* specific semantics. */ - STB_LOPROC SymBind = 13; /* reserved range for processor */ - STB_HIPROC SymBind = 15; /* specific semantics. */ + STB_LOCAL SymBind = 0 /* Local symbol */ + STB_GLOBAL SymBind = 1 /* Global symbol */ + STB_WEAK SymBind = 2 /* like global - lower precedence */ + STB_LOOS SymBind = 10 /* Reserved range for operating system */ + STB_HIOS SymBind = 12 /* specific semantics. */ + STB_LOPROC SymBind = 13 /* reserved range for processor */ + STB_HIPROC SymBind = 15 /* specific semantics. */ ) var stbStrings = []intName{ @@ -636,24 +636,24 @@ var stbStrings = []intName{ intName{15, "STB_HIPROC"}, } -func (i SymBind) String() string { return stringName(uint32(i), stbStrings, false) } -func (i SymBind) GoString() string { return stringName(uint32(i), stbStrings, true) } +func (i SymBind) String() string { return stringName(uint32(i), stbStrings, false) } +func (i SymBind) GoString() string { return stringName(uint32(i), stbStrings, true) } /* Symbol type - ELFNN_ST_TYPE - st_info */ type SymType int const ( - STT_NOTYPE SymType = 0; /* Unspecified type. */ - STT_OBJECT SymType = 1; /* Data object. */ - STT_FUNC SymType = 2; /* Function. */ - STT_SECTION SymType = 3; /* Section. */ - STT_FILE SymType = 4; /* Source file. */ - STT_COMMON SymType = 5; /* Uninitialized common block. */ - STT_TLS SymType = 6; /* TLS object. */ - STT_LOOS SymType = 10; /* Reserved range for operating system */ - STT_HIOS SymType = 12; /* specific semantics. */ - STT_LOPROC SymType = 13; /* reserved range for processor */ - STT_HIPROC SymType = 15; /* specific semantics. */ + STT_NOTYPE SymType = 0 /* Unspecified type. */ + STT_OBJECT SymType = 1 /* Data object. */ + STT_FUNC SymType = 2 /* Function. */ + STT_SECTION SymType = 3 /* Section. */ + STT_FILE SymType = 4 /* Source file. */ + STT_COMMON SymType = 5 /* Uninitialized common block. */ + STT_TLS SymType = 6 /* TLS object. */ + STT_LOOS SymType = 10 /* Reserved range for operating system */ + STT_HIOS SymType = 12 /* specific semantics. */ + STT_LOPROC SymType = 13 /* reserved range for processor */ + STT_HIPROC SymType = 15 /* specific semantics. */ ) var sttStrings = []intName{ @@ -670,17 +670,17 @@ var sttStrings = []intName{ intName{15, "STT_HIPROC"}, } -func (i SymType) String() string { return stringName(uint32(i), sttStrings, false) } -func (i SymType) GoString() string { return stringName(uint32(i), sttStrings, true) } +func (i SymType) String() string { return stringName(uint32(i), sttStrings, false) } +func (i SymType) GoString() string { return stringName(uint32(i), sttStrings, true) } /* Symbol visibility - ELFNN_ST_VISIBILITY - st_other */ type SymVis int const ( - STV_DEFAULT SymVis = 0x0; /* Default visibility (see binding). */ - STV_INTERNAL SymVis = 0x1; /* Special meaning in relocatable objects. */ - STV_HIDDEN SymVis = 0x2; /* Not visible. */ - STV_PROTECTED SymVis = 0x3; /* Visible but not preemptible. */ + STV_DEFAULT SymVis = 0x0 /* Default visibility (see binding). */ + STV_INTERNAL SymVis = 0x1 /* Special meaning in relocatable objects. */ + STV_HIDDEN SymVis = 0x2 /* Not visible. */ + STV_PROTECTED SymVis = 0x3 /* Visible but not preemptible. */ ) var stvStrings = []intName{ @@ -690,8 +690,8 @@ var stvStrings = []intName{ intName{0x3, "STV_PROTECTED"}, } -func (i SymVis) String() string { return stringName(uint32(i), stvStrings, false) } -func (i SymVis) GoString() string { return stringName(uint32(i), stvStrings, true) } +func (i SymVis) String() string { return stringName(uint32(i), stvStrings, false) } +func (i SymVis) GoString() string { return stringName(uint32(i), stvStrings, true) } /* * Relocation types. @@ -701,30 +701,30 @@ func (i SymVis) GoString() string { return stringName(uint32(i), stvStrings, tru type R_X86_64 int const ( - R_X86_64_NONE R_X86_64 = 0; /* No relocation. */ - R_X86_64_64 R_X86_64 = 1; /* Add 64 bit symbol value. */ - R_X86_64_PC32 R_X86_64 = 2; /* PC-relative 32 bit signed sym value. */ - R_X86_64_GOT32 R_X86_64 = 3; /* PC-relative 32 bit GOT offset. */ - R_X86_64_PLT32 R_X86_64 = 4; /* PC-relative 32 bit PLT offset. */ - R_X86_64_COPY R_X86_64 = 5; /* Copy data from shared object. */ - R_X86_64_GLOB_DAT R_X86_64 = 6; /* Set GOT entry to data address. */ - R_X86_64_JMP_SLOT R_X86_64 = 7; /* Set GOT entry to code address. */ - R_X86_64_RELATIVE R_X86_64 = 8; /* Add load address of shared object. */ - R_X86_64_GOTPCREL R_X86_64 = 9; /* Add 32 bit signed pcrel offset to GOT. */ - R_X86_64_32 R_X86_64 = 10; /* Add 32 bit zero extended symbol value */ - R_X86_64_32S R_X86_64 = 11; /* Add 32 bit sign extended symbol value */ - R_X86_64_16 R_X86_64 = 12; /* Add 16 bit zero extended symbol value */ - R_X86_64_PC16 R_X86_64 = 13; /* Add 16 bit signed extended pc relative symbol value */ - R_X86_64_8 R_X86_64 = 14; /* Add 8 bit zero extended symbol value */ - R_X86_64_PC8 R_X86_64 = 15; /* Add 8 bit signed extended pc relative symbol value */ - R_X86_64_DTPMOD64 R_X86_64 = 16; /* ID of module containing symbol */ - R_X86_64_DTPOFF64 R_X86_64 = 17; /* Offset in TLS block */ - R_X86_64_TPOFF64 R_X86_64 = 18; /* Offset in static TLS block */ - R_X86_64_TLSGD R_X86_64 = 19; /* PC relative offset to GD GOT entry */ - R_X86_64_TLSLD R_X86_64 = 20; /* PC relative offset to LD GOT entry */ - R_X86_64_DTPOFF32 R_X86_64 = 21; /* Offset in TLS block */ - R_X86_64_GOTTPOFF R_X86_64 = 22; /* PC relative offset to IE GOT entry */ - R_X86_64_TPOFF32 R_X86_64 = 23; /* Offset in static TLS block */ + R_X86_64_NONE R_X86_64 = 0 /* No relocation. */ + R_X86_64_64 R_X86_64 = 1 /* Add 64 bit symbol value. */ + R_X86_64_PC32 R_X86_64 = 2 /* PC-relative 32 bit signed sym value. */ + R_X86_64_GOT32 R_X86_64 = 3 /* PC-relative 32 bit GOT offset. */ + R_X86_64_PLT32 R_X86_64 = 4 /* PC-relative 32 bit PLT offset. */ + R_X86_64_COPY R_X86_64 = 5 /* Copy data from shared object. */ + R_X86_64_GLOB_DAT R_X86_64 = 6 /* Set GOT entry to data address. */ + R_X86_64_JMP_SLOT R_X86_64 = 7 /* Set GOT entry to code address. */ + R_X86_64_RELATIVE R_X86_64 = 8 /* Add load address of shared object. */ + R_X86_64_GOTPCREL R_X86_64 = 9 /* Add 32 bit signed pcrel offset to GOT. */ + R_X86_64_32 R_X86_64 = 10 /* Add 32 bit zero extended symbol value */ + R_X86_64_32S R_X86_64 = 11 /* Add 32 bit sign extended symbol value */ + R_X86_64_16 R_X86_64 = 12 /* Add 16 bit zero extended symbol value */ + R_X86_64_PC16 R_X86_64 = 13 /* Add 16 bit signed extended pc relative symbol value */ + R_X86_64_8 R_X86_64 = 14 /* Add 8 bit zero extended symbol value */ + R_X86_64_PC8 R_X86_64 = 15 /* Add 8 bit signed extended pc relative symbol value */ + R_X86_64_DTPMOD64 R_X86_64 = 16 /* ID of module containing symbol */ + R_X86_64_DTPOFF64 R_X86_64 = 17 /* Offset in TLS block */ + R_X86_64_TPOFF64 R_X86_64 = 18 /* Offset in static TLS block */ + R_X86_64_TLSGD R_X86_64 = 19 /* PC relative offset to GD GOT entry */ + R_X86_64_TLSLD R_X86_64 = 20 /* PC relative offset to LD GOT entry */ + R_X86_64_DTPOFF32 R_X86_64 = 21 /* Offset in TLS block */ + R_X86_64_GOTTPOFF R_X86_64 = 22 /* PC relative offset to IE GOT entry */ + R_X86_64_TPOFF32 R_X86_64 = 23 /* Offset in static TLS block */ ) var rx86_64Strings = []intName{ @@ -754,41 +754,41 @@ var rx86_64Strings = []intName{ intName{23, "R_X86_64_TPOFF32"}, } -func (i R_X86_64) String() string { return stringName(uint32(i), rx86_64Strings, false) } -func (i R_X86_64) GoString() string { return stringName(uint32(i), rx86_64Strings, true) } +func (i R_X86_64) String() string { return stringName(uint32(i), rx86_64Strings, false) } +func (i R_X86_64) GoString() string { return stringName(uint32(i), rx86_64Strings, true) } // Relocation types for Alpha. type R_ALPHA int const ( - R_ALPHA_NONE R_ALPHA = 0; /* No reloc */ - R_ALPHA_REFLONG R_ALPHA = 1; /* Direct 32 bit */ - R_ALPHA_REFQUAD R_ALPHA = 2; /* Direct 64 bit */ - R_ALPHA_GPREL32 R_ALPHA = 3; /* GP relative 32 bit */ - R_ALPHA_LITERAL R_ALPHA = 4; /* GP relative 16 bit w/optimization */ - R_ALPHA_LITUSE R_ALPHA = 5; /* Optimization hint for LITERAL */ - R_ALPHA_GPDISP R_ALPHA = 6; /* Add displacement to GP */ - R_ALPHA_BRADDR R_ALPHA = 7; /* PC+4 relative 23 bit shifted */ - R_ALPHA_HINT R_ALPHA = 8; /* PC+4 relative 16 bit shifted */ - R_ALPHA_SREL16 R_ALPHA = 9; /* PC relative 16 bit */ - R_ALPHA_SREL32 R_ALPHA = 10; /* PC relative 32 bit */ - R_ALPHA_SREL64 R_ALPHA = 11; /* PC relative 64 bit */ - R_ALPHA_OP_PUSH R_ALPHA = 12; /* OP stack push */ - R_ALPHA_OP_STORE R_ALPHA = 13; /* OP stack pop and store */ - R_ALPHA_OP_PSUB R_ALPHA = 14; /* OP stack subtract */ - R_ALPHA_OP_PRSHIFT R_ALPHA = 15; /* OP stack right shift */ - R_ALPHA_GPVALUE R_ALPHA = 16; - R_ALPHA_GPRELHIGH R_ALPHA = 17; - R_ALPHA_GPRELLOW R_ALPHA = 18; - R_ALPHA_IMMED_GP_16 R_ALPHA = 19; - R_ALPHA_IMMED_GP_HI32 R_ALPHA = 20; - R_ALPHA_IMMED_SCN_HI32 R_ALPHA = 21; - R_ALPHA_IMMED_BR_HI32 R_ALPHA = 22; - R_ALPHA_IMMED_LO32 R_ALPHA = 23; - R_ALPHA_COPY R_ALPHA = 24; /* Copy symbol at runtime */ - R_ALPHA_GLOB_DAT R_ALPHA = 25; /* Create GOT entry */ - R_ALPHA_JMP_SLOT R_ALPHA = 26; /* Create PLT entry */ - R_ALPHA_RELATIVE R_ALPHA = 27; /* Adjust by program base */ + R_ALPHA_NONE R_ALPHA = 0 /* No reloc */ + R_ALPHA_REFLONG R_ALPHA = 1 /* Direct 32 bit */ + R_ALPHA_REFQUAD R_ALPHA = 2 /* Direct 64 bit */ + R_ALPHA_GPREL32 R_ALPHA = 3 /* GP relative 32 bit */ + R_ALPHA_LITERAL R_ALPHA = 4 /* GP relative 16 bit w/optimization */ + R_ALPHA_LITUSE R_ALPHA = 5 /* Optimization hint for LITERAL */ + R_ALPHA_GPDISP R_ALPHA = 6 /* Add displacement to GP */ + R_ALPHA_BRADDR R_ALPHA = 7 /* PC+4 relative 23 bit shifted */ + R_ALPHA_HINT R_ALPHA = 8 /* PC+4 relative 16 bit shifted */ + R_ALPHA_SREL16 R_ALPHA = 9 /* PC relative 16 bit */ + R_ALPHA_SREL32 R_ALPHA = 10 /* PC relative 32 bit */ + R_ALPHA_SREL64 R_ALPHA = 11 /* PC relative 64 bit */ + R_ALPHA_OP_PUSH R_ALPHA = 12 /* OP stack push */ + R_ALPHA_OP_STORE R_ALPHA = 13 /* OP stack pop and store */ + R_ALPHA_OP_PSUB R_ALPHA = 14 /* OP stack subtract */ + R_ALPHA_OP_PRSHIFT R_ALPHA = 15 /* OP stack right shift */ + R_ALPHA_GPVALUE R_ALPHA = 16 + R_ALPHA_GPRELHIGH R_ALPHA = 17 + R_ALPHA_GPRELLOW R_ALPHA = 18 + R_ALPHA_IMMED_GP_16 R_ALPHA = 19 + R_ALPHA_IMMED_GP_HI32 R_ALPHA = 20 + R_ALPHA_IMMED_SCN_HI32 R_ALPHA = 21 + R_ALPHA_IMMED_BR_HI32 R_ALPHA = 22 + R_ALPHA_IMMED_LO32 R_ALPHA = 23 + R_ALPHA_COPY R_ALPHA = 24 /* Copy symbol at runtime */ + R_ALPHA_GLOB_DAT R_ALPHA = 25 /* Create GOT entry */ + R_ALPHA_JMP_SLOT R_ALPHA = 26 /* Create PLT entry */ + R_ALPHA_RELATIVE R_ALPHA = 27 /* Adjust by program base */ ) var ralphaStrings = []intName{ @@ -822,46 +822,46 @@ var ralphaStrings = []intName{ intName{27, "R_ALPHA_RELATIVE"}, } -func (i R_ALPHA) String() string { return stringName(uint32(i), ralphaStrings, false) } -func (i R_ALPHA) GoString() string { return stringName(uint32(i), ralphaStrings, true) } +func (i R_ALPHA) String() string { return stringName(uint32(i), ralphaStrings, false) } +func (i R_ALPHA) GoString() string { return stringName(uint32(i), ralphaStrings, true) } // Relocation types for ARM. type R_ARM int const ( - R_ARM_NONE R_ARM = 0; /* No relocation. */ - R_ARM_PC24 R_ARM = 1; - R_ARM_ABS32 R_ARM = 2; - R_ARM_REL32 R_ARM = 3; - R_ARM_PC13 R_ARM = 4; - R_ARM_ABS16 R_ARM = 5; - R_ARM_ABS12 R_ARM = 6; - R_ARM_THM_ABS5 R_ARM = 7; - R_ARM_ABS8 R_ARM = 8; - R_ARM_SBREL32 R_ARM = 9; - R_ARM_THM_PC22 R_ARM = 10; - R_ARM_THM_PC8 R_ARM = 11; - R_ARM_AMP_VCALL9 R_ARM = 12; - R_ARM_SWI24 R_ARM = 13; - R_ARM_THM_SWI8 R_ARM = 14; - R_ARM_XPC25 R_ARM = 15; - R_ARM_THM_XPC22 R_ARM = 16; - R_ARM_COPY R_ARM = 20; /* Copy data from shared object. */ - R_ARM_GLOB_DAT R_ARM = 21; /* Set GOT entry to data address. */ - R_ARM_JUMP_SLOT R_ARM = 22; /* Set GOT entry to code address. */ - R_ARM_RELATIVE R_ARM = 23; /* Add load address of shared object. */ - R_ARM_GOTOFF R_ARM = 24; /* Add GOT-relative symbol address. */ - R_ARM_GOTPC R_ARM = 25; /* Add PC-relative GOT table address. */ - R_ARM_GOT32 R_ARM = 26; /* Add PC-relative GOT offset. */ - R_ARM_PLT32 R_ARM = 27; /* Add PC-relative PLT offset. */ - R_ARM_GNU_VTENTRY R_ARM = 100; - R_ARM_GNU_VTINHERIT R_ARM = 101; - R_ARM_RSBREL32 R_ARM = 250; - R_ARM_THM_RPC22 R_ARM = 251; - R_ARM_RREL32 R_ARM = 252; - R_ARM_RABS32 R_ARM = 253; - R_ARM_RPC24 R_ARM = 254; - R_ARM_RBASE R_ARM = 255; + R_ARM_NONE R_ARM = 0 /* No relocation. */ + R_ARM_PC24 R_ARM = 1 + R_ARM_ABS32 R_ARM = 2 + R_ARM_REL32 R_ARM = 3 + R_ARM_PC13 R_ARM = 4 + R_ARM_ABS16 R_ARM = 5 + R_ARM_ABS12 R_ARM = 6 + R_ARM_THM_ABS5 R_ARM = 7 + R_ARM_ABS8 R_ARM = 8 + R_ARM_SBREL32 R_ARM = 9 + R_ARM_THM_PC22 R_ARM = 10 + R_ARM_THM_PC8 R_ARM = 11 + R_ARM_AMP_VCALL9 R_ARM = 12 + R_ARM_SWI24 R_ARM = 13 + R_ARM_THM_SWI8 R_ARM = 14 + R_ARM_XPC25 R_ARM = 15 + R_ARM_THM_XPC22 R_ARM = 16 + R_ARM_COPY R_ARM = 20 /* Copy data from shared object. */ + R_ARM_GLOB_DAT R_ARM = 21 /* Set GOT entry to data address. */ + R_ARM_JUMP_SLOT R_ARM = 22 /* Set GOT entry to code address. */ + R_ARM_RELATIVE R_ARM = 23 /* Add load address of shared object. */ + R_ARM_GOTOFF R_ARM = 24 /* Add GOT-relative symbol address. */ + R_ARM_GOTPC R_ARM = 25 /* Add PC-relative GOT table address. */ + R_ARM_GOT32 R_ARM = 26 /* Add PC-relative GOT offset. */ + R_ARM_PLT32 R_ARM = 27 /* Add PC-relative PLT offset. */ + R_ARM_GNU_VTENTRY R_ARM = 100 + R_ARM_GNU_VTINHERIT R_ARM = 101 + R_ARM_RSBREL32 R_ARM = 250 + R_ARM_THM_RPC22 R_ARM = 251 + R_ARM_RREL32 R_ARM = 252 + R_ARM_RABS32 R_ARM = 253 + R_ARM_RPC24 R_ARM = 254 + R_ARM_RBASE R_ARM = 255 ) var rarmStrings = []intName{ @@ -900,44 +900,44 @@ var rarmStrings = []intName{ intName{255, "R_ARM_RBASE"}, } -func (i R_ARM) String() string { return stringName(uint32(i), rarmStrings, false) } -func (i R_ARM) GoString() string { return stringName(uint32(i), rarmStrings, true) } +func (i R_ARM) String() string { return stringName(uint32(i), rarmStrings, false) } +func (i R_ARM) GoString() string { return stringName(uint32(i), rarmStrings, true) } // Relocation types for 386. type R_386 int const ( - R_386_NONE R_386 = 0; /* No relocation. */ - R_386_32 R_386 = 1; /* Add symbol value. */ - R_386_PC32 R_386 = 2; /* Add PC-relative symbol value. */ - R_386_GOT32 R_386 = 3; /* Add PC-relative GOT offset. */ - R_386_PLT32 R_386 = 4; /* Add PC-relative PLT offset. */ - R_386_COPY R_386 = 5; /* Copy data from shared object. */ - R_386_GLOB_DAT R_386 = 6; /* Set GOT entry to data address. */ - R_386_JMP_SLOT R_386 = 7; /* Set GOT entry to code address. */ - R_386_RELATIVE R_386 = 8; /* Add load address of shared object. */ - R_386_GOTOFF R_386 = 9; /* Add GOT-relative symbol address. */ - R_386_GOTPC R_386 = 10; /* Add PC-relative GOT table address. */ - R_386_TLS_TPOFF R_386 = 14; /* Negative offset in static TLS block */ - R_386_TLS_IE R_386 = 15; /* Absolute address of GOT for -ve static TLS */ - R_386_TLS_GOTIE R_386 = 16; /* GOT entry for negative static TLS block */ - R_386_TLS_LE R_386 = 17; /* Negative offset relative to static TLS */ - R_386_TLS_GD R_386 = 18; /* 32 bit offset to GOT (index,off) pair */ - R_386_TLS_LDM R_386 = 19; /* 32 bit offset to GOT (index,zero) pair */ - R_386_TLS_GD_32 R_386 = 24; /* 32 bit offset to GOT (index,off) pair */ - R_386_TLS_GD_PUSH R_386 = 25; /* pushl instruction for Sun ABI GD sequence */ - R_386_TLS_GD_CALL R_386 = 26; /* call instruction for Sun ABI GD sequence */ - R_386_TLS_GD_POP R_386 = 27; /* popl instruction for Sun ABI GD sequence */ - R_386_TLS_LDM_32 R_386 = 28; /* 32 bit offset to GOT (index,zero) pair */ - R_386_TLS_LDM_PUSH R_386 = 29; /* pushl instruction for Sun ABI LD sequence */ - R_386_TLS_LDM_CALL R_386 = 30; /* call instruction for Sun ABI LD sequence */ - R_386_TLS_LDM_POP R_386 = 31; /* popl instruction for Sun ABI LD sequence */ - R_386_TLS_LDO_32 R_386 = 32; /* 32 bit offset from start of TLS block */ - R_386_TLS_IE_32 R_386 = 33; /* 32 bit offset to GOT static TLS offset entry */ - R_386_TLS_LE_32 R_386 = 34; /* 32 bit offset within static TLS block */ - R_386_TLS_DTPMOD32 R_386 = 35; /* GOT entry containing TLS index */ - R_386_TLS_DTPOFF32 R_386 = 36; /* GOT entry containing TLS offset */ - R_386_TLS_TPOFF32 R_386 = 37; /* GOT entry of -ve static TLS offset */ + R_386_NONE R_386 = 0 /* No relocation. */ + R_386_32 R_386 = 1 /* Add symbol value. */ + R_386_PC32 R_386 = 2 /* Add PC-relative symbol value. */ + R_386_GOT32 R_386 = 3 /* Add PC-relative GOT offset. */ + R_386_PLT32 R_386 = 4 /* Add PC-relative PLT offset. */ + R_386_COPY R_386 = 5 /* Copy data from shared object. */ + R_386_GLOB_DAT R_386 = 6 /* Set GOT entry to data address. */ + R_386_JMP_SLOT R_386 = 7 /* Set GOT entry to code address. */ + R_386_RELATIVE R_386 = 8 /* Add load address of shared object. */ + R_386_GOTOFF R_386 = 9 /* Add GOT-relative symbol address. */ + R_386_GOTPC R_386 = 10 /* Add PC-relative GOT table address. */ + R_386_TLS_TPOFF R_386 = 14 /* Negative offset in static TLS block */ + R_386_TLS_IE R_386 = 15 /* Absolute address of GOT for -ve static TLS */ + R_386_TLS_GOTIE R_386 = 16 /* GOT entry for negative static TLS block */ + R_386_TLS_LE R_386 = 17 /* Negative offset relative to static TLS */ + R_386_TLS_GD R_386 = 18 /* 32 bit offset to GOT (index,off) pair */ + R_386_TLS_LDM R_386 = 19 /* 32 bit offset to GOT (index,zero) pair */ + R_386_TLS_GD_32 R_386 = 24 /* 32 bit offset to GOT (index,off) pair */ + R_386_TLS_GD_PUSH R_386 = 25 /* pushl instruction for Sun ABI GD sequence */ + R_386_TLS_GD_CALL R_386 = 26 /* call instruction for Sun ABI GD sequence */ + R_386_TLS_GD_POP R_386 = 27 /* popl instruction for Sun ABI GD sequence */ + R_386_TLS_LDM_32 R_386 = 28 /* 32 bit offset to GOT (index,zero) pair */ + R_386_TLS_LDM_PUSH R_386 = 29 /* pushl instruction for Sun ABI LD sequence */ + R_386_TLS_LDM_CALL R_386 = 30 /* call instruction for Sun ABI LD sequence */ + R_386_TLS_LDM_POP R_386 = 31 /* popl instruction for Sun ABI LD sequence */ + R_386_TLS_LDO_32 R_386 = 32 /* 32 bit offset from start of TLS block */ + R_386_TLS_IE_32 R_386 = 33 /* 32 bit offset to GOT static TLS offset entry */ + R_386_TLS_LE_32 R_386 = 34 /* 32 bit offset within static TLS block */ + R_386_TLS_DTPMOD32 R_386 = 35 /* GOT entry containing TLS index */ + R_386_TLS_DTPOFF32 R_386 = 36 /* GOT entry containing TLS offset */ + R_386_TLS_TPOFF32 R_386 = 37 /* GOT entry of -ve static TLS offset */ ) var r386Strings = []intName{ @@ -974,90 +974,90 @@ var r386Strings = []intName{ intName{37, "R_386_TLS_TPOFF32"}, } -func (i R_386) String() string { return stringName(uint32(i), r386Strings, false) } -func (i R_386) GoString() string { return stringName(uint32(i), r386Strings, true) } +func (i R_386) String() string { return stringName(uint32(i), r386Strings, false) } +func (i R_386) GoString() string { return stringName(uint32(i), r386Strings, true) } // Relocation types for PowerPC. type R_PPC int const ( - R_PPC_NONE R_PPC = 0; /* No relocation. */ - R_PPC_ADDR32 R_PPC = 1; - R_PPC_ADDR24 R_PPC = 2; - R_PPC_ADDR16 R_PPC = 3; - R_PPC_ADDR16_LO R_PPC = 4; - R_PPC_ADDR16_HI R_PPC = 5; - R_PPC_ADDR16_HA R_PPC = 6; - R_PPC_ADDR14 R_PPC = 7; - R_PPC_ADDR14_BRTAKEN R_PPC = 8; - R_PPC_ADDR14_BRNTAKEN R_PPC = 9; - R_PPC_REL24 R_PPC = 10; - R_PPC_REL14 R_PPC = 11; - R_PPC_REL14_BRTAKEN R_PPC = 12; - R_PPC_REL14_BRNTAKEN R_PPC = 13; - R_PPC_GOT16 R_PPC = 14; - R_PPC_GOT16_LO R_PPC = 15; - R_PPC_GOT16_HI R_PPC = 16; - R_PPC_GOT16_HA R_PPC = 17; - R_PPC_PLTREL24 R_PPC = 18; - R_PPC_COPY R_PPC = 19; - R_PPC_GLOB_DAT R_PPC = 20; - R_PPC_JMP_SLOT R_PPC = 21; - R_PPC_RELATIVE R_PPC = 22; - R_PPC_LOCAL24PC R_PPC = 23; - R_PPC_UADDR32 R_PPC = 24; - R_PPC_UADDR16 R_PPC = 25; - R_PPC_REL32 R_PPC = 26; - R_PPC_PLT32 R_PPC = 27; - R_PPC_PLTREL32 R_PPC = 28; - R_PPC_PLT16_LO R_PPC = 29; - R_PPC_PLT16_HI R_PPC = 30; - R_PPC_PLT16_HA R_PPC = 31; - R_PPC_SDAREL16 R_PPC = 32; - R_PPC_SECTOFF R_PPC = 33; - R_PPC_SECTOFF_LO R_PPC = 34; - R_PPC_SECTOFF_HI R_PPC = 35; - R_PPC_SECTOFF_HA R_PPC = 36; - R_PPC_TLS R_PPC = 67; - R_PPC_DTPMOD32 R_PPC = 68; - R_PPC_TPREL16 R_PPC = 69; - R_PPC_TPREL16_LO R_PPC = 70; - R_PPC_TPREL16_HI R_PPC = 71; - R_PPC_TPREL16_HA R_PPC = 72; - R_PPC_TPREL32 R_PPC = 73; - R_PPC_DTPREL16 R_PPC = 74; - R_PPC_DTPREL16_LO R_PPC = 75; - R_PPC_DTPREL16_HI R_PPC = 76; - R_PPC_DTPREL16_HA R_PPC = 77; - R_PPC_DTPREL32 R_PPC = 78; - R_PPC_GOT_TLSGD16 R_PPC = 79; - R_PPC_GOT_TLSGD16_LO R_PPC = 80; - R_PPC_GOT_TLSGD16_HI R_PPC = 81; - R_PPC_GOT_TLSGD16_HA R_PPC = 82; - R_PPC_GOT_TLSLD16 R_PPC = 83; - R_PPC_GOT_TLSLD16_LO R_PPC = 84; - R_PPC_GOT_TLSLD16_HI R_PPC = 85; - R_PPC_GOT_TLSLD16_HA R_PPC = 86; - R_PPC_GOT_TPREL16 R_PPC = 87; - R_PPC_GOT_TPREL16_LO R_PPC = 88; - R_PPC_GOT_TPREL16_HI R_PPC = 89; - R_PPC_GOT_TPREL16_HA R_PPC = 90; - R_PPC_EMB_NADDR32 R_PPC = 101; - R_PPC_EMB_NADDR16 R_PPC = 102; - R_PPC_EMB_NADDR16_LO R_PPC = 103; - R_PPC_EMB_NADDR16_HI R_PPC = 104; - R_PPC_EMB_NADDR16_HA R_PPC = 105; - R_PPC_EMB_SDAI16 R_PPC = 106; - R_PPC_EMB_SDA2I16 R_PPC = 107; - R_PPC_EMB_SDA2REL R_PPC = 108; - R_PPC_EMB_SDA21 R_PPC = 109; - R_PPC_EMB_MRKREF R_PPC = 110; - R_PPC_EMB_RELSEC16 R_PPC = 111; - R_PPC_EMB_RELST_LO R_PPC = 112; - R_PPC_EMB_RELST_HI R_PPC = 113; - R_PPC_EMB_RELST_HA R_PPC = 114; - R_PPC_EMB_BIT_FLD R_PPC = 115; - R_PPC_EMB_RELSDA R_PPC = 116; + R_PPC_NONE R_PPC = 0 /* No relocation. */ + R_PPC_ADDR32 R_PPC = 1 + R_PPC_ADDR24 R_PPC = 2 + R_PPC_ADDR16 R_PPC = 3 + R_PPC_ADDR16_LO R_PPC = 4 + R_PPC_ADDR16_HI R_PPC = 5 + R_PPC_ADDR16_HA R_PPC = 6 + R_PPC_ADDR14 R_PPC = 7 + R_PPC_ADDR14_BRTAKEN R_PPC = 8 + R_PPC_ADDR14_BRNTAKEN R_PPC = 9 + R_PPC_REL24 R_PPC = 10 + R_PPC_REL14 R_PPC = 11 + R_PPC_REL14_BRTAKEN R_PPC = 12 + R_PPC_REL14_BRNTAKEN R_PPC = 13 + R_PPC_GOT16 R_PPC = 14 + R_PPC_GOT16_LO R_PPC = 15 + R_PPC_GOT16_HI R_PPC = 16 + R_PPC_GOT16_HA R_PPC = 17 + R_PPC_PLTREL24 R_PPC = 18 + R_PPC_COPY R_PPC = 19 + R_PPC_GLOB_DAT R_PPC = 20 + R_PPC_JMP_SLOT R_PPC = 21 + R_PPC_RELATIVE R_PPC = 22 + R_PPC_LOCAL24PC R_PPC = 23 + R_PPC_UADDR32 R_PPC = 24 + R_PPC_UADDR16 R_PPC = 25 + R_PPC_REL32 R_PPC = 26 + R_PPC_PLT32 R_PPC = 27 + R_PPC_PLTREL32 R_PPC = 28 + R_PPC_PLT16_LO R_PPC = 29 + R_PPC_PLT16_HI R_PPC = 30 + R_PPC_PLT16_HA R_PPC = 31 + R_PPC_SDAREL16 R_PPC = 32 + R_PPC_SECTOFF R_PPC = 33 + R_PPC_SECTOFF_LO R_PPC = 34 + R_PPC_SECTOFF_HI R_PPC = 35 + R_PPC_SECTOFF_HA R_PPC = 36 + R_PPC_TLS R_PPC = 67 + R_PPC_DTPMOD32 R_PPC = 68 + R_PPC_TPREL16 R_PPC = 69 + R_PPC_TPREL16_LO R_PPC = 70 + R_PPC_TPREL16_HI R_PPC = 71 + R_PPC_TPREL16_HA R_PPC = 72 + R_PPC_TPREL32 R_PPC = 73 + R_PPC_DTPREL16 R_PPC = 74 + R_PPC_DTPREL16_LO R_PPC = 75 + R_PPC_DTPREL16_HI R_PPC = 76 + R_PPC_DTPREL16_HA R_PPC = 77 + R_PPC_DTPREL32 R_PPC = 78 + R_PPC_GOT_TLSGD16 R_PPC = 79 + R_PPC_GOT_TLSGD16_LO R_PPC = 80 + R_PPC_GOT_TLSGD16_HI R_PPC = 81 + R_PPC_GOT_TLSGD16_HA R_PPC = 82 + R_PPC_GOT_TLSLD16 R_PPC = 83 + R_PPC_GOT_TLSLD16_LO R_PPC = 84 + R_PPC_GOT_TLSLD16_HI R_PPC = 85 + R_PPC_GOT_TLSLD16_HA R_PPC = 86 + R_PPC_GOT_TPREL16 R_PPC = 87 + R_PPC_GOT_TPREL16_LO R_PPC = 88 + R_PPC_GOT_TPREL16_HI R_PPC = 89 + R_PPC_GOT_TPREL16_HA R_PPC = 90 + R_PPC_EMB_NADDR32 R_PPC = 101 + R_PPC_EMB_NADDR16 R_PPC = 102 + R_PPC_EMB_NADDR16_LO R_PPC = 103 + R_PPC_EMB_NADDR16_HI R_PPC = 104 + R_PPC_EMB_NADDR16_HA R_PPC = 105 + R_PPC_EMB_SDAI16 R_PPC = 106 + R_PPC_EMB_SDA2I16 R_PPC = 107 + R_PPC_EMB_SDA2REL R_PPC = 108 + R_PPC_EMB_SDA21 R_PPC = 109 + R_PPC_EMB_MRKREF R_PPC = 110 + R_PPC_EMB_RELSEC16 R_PPC = 111 + R_PPC_EMB_RELST_LO R_PPC = 112 + R_PPC_EMB_RELST_HI R_PPC = 113 + R_PPC_EMB_RELST_HA R_PPC = 114 + R_PPC_EMB_BIT_FLD R_PPC = 115 + R_PPC_EMB_RELSDA R_PPC = 116 ) var rppcStrings = []intName{ @@ -1142,69 +1142,69 @@ var rppcStrings = []intName{ intName{116, "R_PPC_EMB_RELSDA"}, } -func (i R_PPC) String() string { return stringName(uint32(i), rppcStrings, false) } -func (i R_PPC) GoString() string { return stringName(uint32(i), rppcStrings, true) } +func (i R_PPC) String() string { return stringName(uint32(i), rppcStrings, false) } +func (i R_PPC) GoString() string { return stringName(uint32(i), rppcStrings, true) } // Relocation types for SPARC. type R_SPARC int const ( - R_SPARC_NONE R_SPARC = 0; - R_SPARC_8 R_SPARC = 1; - R_SPARC_16 R_SPARC = 2; - R_SPARC_32 R_SPARC = 3; - R_SPARC_DISP8 R_SPARC = 4; - R_SPARC_DISP16 R_SPARC = 5; - R_SPARC_DISP32 R_SPARC = 6; - R_SPARC_WDISP30 R_SPARC = 7; - R_SPARC_WDISP22 R_SPARC = 8; - R_SPARC_HI22 R_SPARC = 9; - R_SPARC_22 R_SPARC = 10; - R_SPARC_13 R_SPARC = 11; - R_SPARC_LO10 R_SPARC = 12; - R_SPARC_GOT10 R_SPARC = 13; - R_SPARC_GOT13 R_SPARC = 14; - R_SPARC_GOT22 R_SPARC = 15; - R_SPARC_PC10 R_SPARC = 16; - R_SPARC_PC22 R_SPARC = 17; - R_SPARC_WPLT30 R_SPARC = 18; - R_SPARC_COPY R_SPARC = 19; - R_SPARC_GLOB_DAT R_SPARC = 20; - R_SPARC_JMP_SLOT R_SPARC = 21; - R_SPARC_RELATIVE R_SPARC = 22; - R_SPARC_UA32 R_SPARC = 23; - R_SPARC_PLT32 R_SPARC = 24; - R_SPARC_HIPLT22 R_SPARC = 25; - R_SPARC_LOPLT10 R_SPARC = 26; - R_SPARC_PCPLT32 R_SPARC = 27; - R_SPARC_PCPLT22 R_SPARC = 28; - R_SPARC_PCPLT10 R_SPARC = 29; - R_SPARC_10 R_SPARC = 30; - R_SPARC_11 R_SPARC = 31; - R_SPARC_64 R_SPARC = 32; - R_SPARC_OLO10 R_SPARC = 33; - R_SPARC_HH22 R_SPARC = 34; - R_SPARC_HM10 R_SPARC = 35; - R_SPARC_LM22 R_SPARC = 36; - R_SPARC_PC_HH22 R_SPARC = 37; - R_SPARC_PC_HM10 R_SPARC = 38; - R_SPARC_PC_LM22 R_SPARC = 39; - R_SPARC_WDISP16 R_SPARC = 40; - R_SPARC_WDISP19 R_SPARC = 41; - R_SPARC_GLOB_JMP R_SPARC = 42; - R_SPARC_7 R_SPARC = 43; - R_SPARC_5 R_SPARC = 44; - R_SPARC_6 R_SPARC = 45; - R_SPARC_DISP64 R_SPARC = 46; - R_SPARC_PLT64 R_SPARC = 47; - R_SPARC_HIX22 R_SPARC = 48; - R_SPARC_LOX10 R_SPARC = 49; - R_SPARC_H44 R_SPARC = 50; - R_SPARC_M44 R_SPARC = 51; - R_SPARC_L44 R_SPARC = 52; - R_SPARC_REGISTER R_SPARC = 53; - R_SPARC_UA64 R_SPARC = 54; - R_SPARC_UA16 R_SPARC = 55; + R_SPARC_NONE R_SPARC = 0 + R_SPARC_8 R_SPARC = 1 + R_SPARC_16 R_SPARC = 2 + R_SPARC_32 R_SPARC = 3 + R_SPARC_DISP8 R_SPARC = 4 + R_SPARC_DISP16 R_SPARC = 5 + R_SPARC_DISP32 R_SPARC = 6 + R_SPARC_WDISP30 R_SPARC = 7 + R_SPARC_WDISP22 R_SPARC = 8 + R_SPARC_HI22 R_SPARC = 9 + R_SPARC_22 R_SPARC = 10 + R_SPARC_13 R_SPARC = 11 + R_SPARC_LO10 R_SPARC = 12 + R_SPARC_GOT10 R_SPARC = 13 + R_SPARC_GOT13 R_SPARC = 14 + R_SPARC_GOT22 R_SPARC = 15 + R_SPARC_PC10 R_SPARC = 16 + R_SPARC_PC22 R_SPARC = 17 + R_SPARC_WPLT30 R_SPARC = 18 + R_SPARC_COPY R_SPARC = 19 + R_SPARC_GLOB_DAT R_SPARC = 20 + R_SPARC_JMP_SLOT R_SPARC = 21 + R_SPARC_RELATIVE R_SPARC = 22 + R_SPARC_UA32 R_SPARC = 23 + R_SPARC_PLT32 R_SPARC = 24 + R_SPARC_HIPLT22 R_SPARC = 25 + R_SPARC_LOPLT10 R_SPARC = 26 + R_SPARC_PCPLT32 R_SPARC = 27 + R_SPARC_PCPLT22 R_SPARC = 28 + R_SPARC_PCPLT10 R_SPARC = 29 + R_SPARC_10 R_SPARC = 30 + R_SPARC_11 R_SPARC = 31 + R_SPARC_64 R_SPARC = 32 + R_SPARC_OLO10 R_SPARC = 33 + R_SPARC_HH22 R_SPARC = 34 + R_SPARC_HM10 R_SPARC = 35 + R_SPARC_LM22 R_SPARC = 36 + R_SPARC_PC_HH22 R_SPARC = 37 + R_SPARC_PC_HM10 R_SPARC = 38 + R_SPARC_PC_LM22 R_SPARC = 39 + R_SPARC_WDISP16 R_SPARC = 40 + R_SPARC_WDISP19 R_SPARC = 41 + R_SPARC_GLOB_JMP R_SPARC = 42 + R_SPARC_7 R_SPARC = 43 + R_SPARC_5 R_SPARC = 44 + R_SPARC_6 R_SPARC = 45 + R_SPARC_DISP64 R_SPARC = 46 + R_SPARC_PLT64 R_SPARC = 47 + R_SPARC_HIX22 R_SPARC = 48 + R_SPARC_LOX10 R_SPARC = 49 + R_SPARC_H44 R_SPARC = 50 + R_SPARC_M44 R_SPARC = 51 + R_SPARC_L44 R_SPARC = 52 + R_SPARC_REGISTER R_SPARC = 53 + R_SPARC_UA64 R_SPARC = 54 + R_SPARC_UA16 R_SPARC = 55 ) var rsparcStrings = []intName{ @@ -1266,8 +1266,8 @@ var rsparcStrings = []intName{ intName{55, "R_SPARC_UA16"}, } -func (i R_SPARC) String() string { return stringName(uint32(i), rsparcStrings, false) } -func (i R_SPARC) GoString() string { return stringName(uint32(i), rsparcStrings, true) } +func (i R_SPARC) String() string { return stringName(uint32(i), rsparcStrings, false) } +func (i R_SPARC) GoString() string { return stringName(uint32(i), rsparcStrings, true) } /* * Magic number for the elf trampoline, chosen wisely to be an immediate @@ -1280,58 +1280,58 @@ const ARM_MAGIC_TRAMP_NUMBER = 0x5c000003 * ELF32 File header. */ type Header32 struct { - Ident [EI_NIDENT]byte; /* File identification. */ - Type uint16; /* File type. */ - Machine uint16; /* Machine architecture. */ - Version uint32; /* ELF format version. */ - Entry uint32; /* Entry point. */ - Phoff uint32; /* Program header file offset. */ - Shoff uint32; /* Section header file offset. */ - Flags uint32; /* Architecture-specific flags. */ - Ehsize uint16; /* Size of ELF header in bytes. */ - Phentsize uint16; /* Size of program header entry. */ - Phnum uint16; /* Number of program header entries. */ - Shentsize uint16; /* Size of section header entry. */ - Shnum uint16; /* Number of section header entries. */ - Shstrndx uint16; /* Section name strings section. */ + Ident [EI_NIDENT]byte /* File identification. */ + Type uint16 /* File type. */ + Machine uint16 /* Machine architecture. */ + Version uint32 /* ELF format version. */ + Entry uint32 /* Entry point. */ + Phoff uint32 /* Program header file offset. */ + Shoff uint32 /* Section header file offset. */ + Flags uint32 /* Architecture-specific flags. */ + Ehsize uint16 /* Size of ELF header in bytes. */ + Phentsize uint16 /* Size of program header entry. */ + Phnum uint16 /* Number of program header entries. */ + Shentsize uint16 /* Size of section header entry. */ + Shnum uint16 /* Number of section header entries. */ + Shstrndx uint16 /* Section name strings section. */ } /* * ELF32 Section header. */ type Section32 struct { - Name uint32; /* Section name (index into the section header string table). */ - Type uint32; /* Section type. */ - Flags uint32; /* Section flags. */ - Addr uint32; /* Address in memory image. */ - Off uint32; /* Offset in file. */ - Size uint32; /* Size in bytes. */ - Link uint32; /* Index of a related section. */ - Info uint32; /* Depends on section type. */ - Addralign uint32; /* Alignment in bytes. */ - Entsize uint32; /* Size of each entry in section. */ + Name uint32 /* Section name (index into the section header string table). */ + Type uint32 /* Section type. */ + Flags uint32 /* Section flags. */ + Addr uint32 /* Address in memory image. */ + Off uint32 /* Offset in file. */ + Size uint32 /* Size in bytes. */ + Link uint32 /* Index of a related section. */ + Info uint32 /* Depends on section type. */ + Addralign uint32 /* Alignment in bytes. */ + Entsize uint32 /* Size of each entry in section. */ } /* * ELF32 Program header. */ type Prog32 struct { - Type uint32; /* Entry type. */ - Off uint32; /* File offset of contents. */ - Vaddr uint32; /* Virtual address in memory image. */ - Paddr uint32; /* Physical address (not used). */ - Filesz uint32; /* Size of contents in file. */ - Memsz uint32; /* Size of contents in memory. */ - Flags uint32; /* Access permission flags. */ - Align uint32; /* Alignment in memory and file. */ + Type uint32 /* Entry type. */ + Off uint32 /* File offset of contents. */ + Vaddr uint32 /* Virtual address in memory image. */ + Paddr uint32 /* Physical address (not used). */ + Filesz uint32 /* Size of contents in file. */ + Memsz uint32 /* Size of contents in memory. */ + Flags uint32 /* Access permission flags. */ + Align uint32 /* Alignment in memory and file. */ } /* * ELF32 Dynamic structure. The ".dynamic" section contains an array of them. */ type Dyn32 struct { - Tag int32; /* Entry type. */ - Val uint32; /* Integer/Address value. */ + Tag int32 /* Entry type. */ + Val uint32 /* Integer/Address value. */ } /* @@ -1340,36 +1340,36 @@ type Dyn32 struct { // ELF32 Relocations that don't need an addend field. type Rel32 struct { - Off uint32; /* Location to be relocated. */ - Info uint32; /* Relocation type and symbol index. */ + Off uint32 /* Location to be relocated. */ + Info uint32 /* Relocation type and symbol index. */ } // ELF32 Relocations that need an addend field. type Rela32 struct { - Off uint32; /* Location to be relocated. */ - Info uint32; /* Relocation type and symbol index. */ - Addend int32; /* Addend. */ + Off uint32 /* Location to be relocated. */ + Info uint32 /* Relocation type and symbol index. */ + Addend int32 /* Addend. */ } -func R_SYM32(info uint32) uint32 { return uint32(info >> 8) } -func R_TYPE32(info uint32) uint32 { return uint32(info & 0xff) } -func R_INFO32(sym, typ uint32) uint32 { return sym<<8 | typ } +func R_SYM32(info uint32) uint32 { return uint32(info >> 8) } +func R_TYPE32(info uint32) uint32 { return uint32(info & 0xff) } +func R_INFO32(sym, typ uint32) uint32 { return sym<<8 | typ } // ELF32 Symbol. type Sym32 struct { - Name uint32; - Value uint32; - Size uint32; - Info uint8; - Other uint8; - Shndx uint16; + Name uint32 + Value uint32 + Size uint32 + Info uint8 + Other uint8 + Shndx uint16 } const Sym32Size = 16 -func ST_BIND(info uint8) SymBind { return SymBind(info >> 4) } -func ST_TYPE(bind SymBind, typ SymType) uint8 { return uint8(bind)<<4 | uint8(typ)&0xf } -func ST_VISIBILITY(other uint8) SymVis { return SymVis(other & 3) } +func ST_BIND(info uint8) SymBind { return SymBind(info >> 4) } +func ST_TYPE(bind SymBind, typ SymType) uint8 { return uint8(bind)<<4 | uint8(typ)&0xf } +func ST_VISIBILITY(other uint8) SymVis { return SymVis(other & 3) } /* * ELF64 @@ -1380,20 +1380,20 @@ func ST_VISIBILITY(other uint8) SymVis { return SymVis(other & 3) } */ type Header64 struct { - Ident [EI_NIDENT]byte; /* File identification. */ - Type uint16; /* File type. */ - Machine uint16; /* Machine architecture. */ - Version uint32; /* ELF format version. */ - Entry uint64; /* Entry point. */ - Phoff uint64; /* Program header file offset. */ - Shoff uint64; /* Section header file offset. */ - Flags uint32; /* Architecture-specific flags. */ - Ehsize uint16; /* Size of ELF header in bytes. */ - Phentsize uint16; /* Size of program header entry. */ - Phnum uint16; /* Number of program header entries. */ - Shentsize uint16; /* Size of section header entry. */ - Shnum uint16; /* Number of section header entries. */ - Shstrndx uint16; /* Section name strings section. */ + Ident [EI_NIDENT]byte /* File identification. */ + Type uint16 /* File type. */ + Machine uint16 /* Machine architecture. */ + Version uint32 /* ELF format version. */ + Entry uint64 /* Entry point. */ + Phoff uint64 /* Program header file offset. */ + Shoff uint64 /* Section header file offset. */ + Flags uint32 /* Architecture-specific flags. */ + Ehsize uint16 /* Size of ELF header in bytes. */ + Phentsize uint16 /* Size of program header entry. */ + Phnum uint16 /* Number of program header entries. */ + Shentsize uint16 /* Size of section header entry. */ + Shnum uint16 /* Number of section header entries. */ + Shstrndx uint16 /* Section name strings section. */ } /* @@ -1401,16 +1401,16 @@ type Header64 struct { */ type Section64 struct { - Name uint32; /* Section name (index into the section header string table). */ - Type uint32; /* Section type. */ - Flags uint64; /* Section flags. */ - Addr uint64; /* Address in memory image. */ - Off uint64; /* Offset in file. */ - Size uint64; /* Size in bytes. */ - Link uint32; /* Index of a related section. */ - Info uint32; /* Depends on section type. */ - Addralign uint64; /* Alignment in bytes. */ - Entsize uint64; /* Size of each entry in section. */ + Name uint32 /* Section name (index into the section header string table). */ + Type uint32 /* Section type. */ + Flags uint64 /* Section flags. */ + Addr uint64 /* Address in memory image. */ + Off uint64 /* Offset in file. */ + Size uint64 /* Size in bytes. */ + Link uint32 /* Index of a related section. */ + Info uint32 /* Depends on section type. */ + Addralign uint64 /* Alignment in bytes. */ + Entsize uint64 /* Size of each entry in section. */ } /* @@ -1418,14 +1418,14 @@ type Section64 struct { */ type Prog64 struct { - Type uint32; /* Entry type. */ - Flags uint32; /* Access permission flags. */ - Off uint64; /* File offset of contents. */ - Vaddr uint64; /* Virtual address in memory image. */ - Paddr uint64; /* Physical address (not used). */ - Filesz uint64; /* Size of contents in file. */ - Memsz uint64; /* Size of contents in memory. */ - Align uint64; /* Alignment in memory and file. */ + Type uint32 /* Entry type. */ + Flags uint32 /* Access permission flags. */ + Off uint64 /* File offset of contents. */ + Vaddr uint64 /* Virtual address in memory image. */ + Paddr uint64 /* Physical address (not used). */ + Filesz uint64 /* Size of contents in file. */ + Memsz uint64 /* Size of contents in memory. */ + Align uint64 /* Alignment in memory and file. */ } /* @@ -1433,8 +1433,8 @@ type Prog64 struct { */ type Dyn64 struct { - Tag int64; /* Entry type. */ - Val uint64; /* Integer/address value */ + Tag int64 /* Entry type. */ + Val uint64 /* Integer/address value */ } /* @@ -1443,39 +1443,39 @@ type Dyn64 struct { /* ELF64 relocations that don't need an addend field. */ type Rel64 struct { - Off uint64; /* Location to be relocated. */ - Info uint64; /* Relocation type and symbol index. */ + Off uint64 /* Location to be relocated. */ + Info uint64 /* Relocation type and symbol index. */ } /* ELF64 relocations that need an addend field. */ type Rela64 struct { - Off uint64; /* Location to be relocated. */ - Info uint64; /* Relocation type and symbol index. */ - Addend int64; /* Addend. */ + Off uint64 /* Location to be relocated. */ + Info uint64 /* Relocation type and symbol index. */ + Addend int64 /* Addend. */ } -func R_SYM64(info uint64) uint32 { return uint32(info >> 32) } -func R_TYPE64(info uint64) uint32 { return uint32(info) } -func R_INFO(sym, typ uint32) uint64 { return uint64(sym)<<32 | uint64(typ) } +func R_SYM64(info uint64) uint32 { return uint32(info >> 32) } +func R_TYPE64(info uint64) uint32 { return uint32(info) } +func R_INFO(sym, typ uint32) uint64 { return uint64(sym)<<32 | uint64(typ) } /* * ELF64 symbol table entries. */ type Sym64 struct { - Name uint32; /* String table index of name. */ - Info uint8; /* Type and binding information. */ - Other uint8; /* Reserved (not used). */ - Shndx uint16; /* Section index of symbol. */ - Value uint64; /* Symbol value. */ - Size uint64; /* Size of associated object. */ + Name uint32 /* String table index of name. */ + Info uint8 /* Type and binding information. */ + Other uint8 /* Reserved (not used). */ + Shndx uint16 /* Section index of symbol. */ + Value uint64 /* Symbol value. */ + Size uint64 /* Size of associated object. */ } const Sym64Size = 24 type intName struct { - i uint32; - s string; + i uint32 + s string } func stringName(i uint32, names []intName, goSyntax bool) string { @@ -1484,28 +1484,28 @@ func stringName(i uint32, names []intName, goSyntax bool) string { if goSyntax { return "elf." + n.s } - return n.s; + return n.s } } // second pass - look for smaller to add with. // assume sorted already for j := len(names) - 1; j >= 0; j-- { - n := names[j]; + n := names[j] if n.i < i { - s := n.s; + s := n.s if goSyntax { s = "elf." + s } - return s + "+" + strconv.Uitoa64(uint64(i-n.i)); + return s + "+" + strconv.Uitoa64(uint64(i-n.i)) } } - return strconv.Uitoa64(uint64(i)); + return strconv.Uitoa64(uint64(i)) } func flagName(i uint32, names []intName, goSyntax bool) string { - s := ""; + s := "" for _, n := range names { if n.i&i == n.i { if len(s) > 0 { @@ -1514,8 +1514,8 @@ func flagName(i uint32, names []intName, goSyntax bool) string { if goSyntax { s += "elf." } - s += n.s; - i -= n.i; + s += n.s + i -= n.i } } if len(s) == 0 { @@ -1524,5 +1524,5 @@ func flagName(i uint32, names []intName, goSyntax bool) string { if i != 0 { s += "+0x" + strconv.Uitob64(uint64(i), 16) } - return s; + return s } diff --git a/src/pkg/debug/elf/elf_test.go b/src/pkg/debug/elf/elf_test.go index bc2a4f687..6f827faf0 100644 --- a/src/pkg/debug/elf/elf_test.go +++ b/src/pkg/debug/elf/elf_test.go @@ -5,13 +5,13 @@ package elf import ( - "fmt"; - "testing"; + "fmt" + "testing" ) type nameTest struct { - val interface{}; - str string; + val interface{} + str string } var nameTests = []nameTest{ @@ -41,7 +41,7 @@ var nameTests = []nameTest{ func TestNames(t *testing.T) { for i, tt := range nameTests { - s := fmt.Sprint(tt.val); + s := fmt.Sprint(tt.val) if s != tt.str { t.Errorf("#%d: want %q have %q", i, s, tt.str) } diff --git a/src/pkg/debug/elf/file.go b/src/pkg/debug/elf/file.go index e610bc2eb..c7ef955e6 100644 --- a/src/pkg/debug/elf/file.go +++ b/src/pkg/debug/elf/file.go @@ -6,12 +6,12 @@ package elf import ( - "bytes"; - "debug/dwarf"; - "encoding/binary"; - "fmt"; - "io"; - "os"; + "bytes" + "debug/dwarf" + "encoding/binary" + "fmt" + "io" + "os" ) // TODO: error reporting detail @@ -22,41 +22,41 @@ import ( // A FileHeader represents an ELF file header. type FileHeader struct { - Class Class; - Data Data; - Version Version; - OSABI OSABI; - ABIVersion uint8; - ByteOrder binary.ByteOrder; - Type Type; - Machine Machine; + Class Class + Data Data + Version Version + OSABI OSABI + ABIVersion uint8 + ByteOrder binary.ByteOrder + Type Type + Machine Machine } // A File represents an open ELF file. type File struct { - FileHeader; - Sections []*Section; - Progs []*Prog; - closer io.Closer; + FileHeader + Sections []*Section + Progs []*Prog + closer io.Closer } // A SectionHeader represents a single ELF section header. type SectionHeader struct { - Name string; - Type SectionType; - Flags SectionFlag; - Addr uint64; - Offset uint64; - Size uint64; - Link uint32; - Info uint32; - Addralign uint64; - Entsize uint64; + Name string + Type SectionType + Flags SectionFlag + Addr uint64 + Offset uint64 + Size uint64 + Link uint32 + Info uint32 + Addralign uint64 + Entsize uint64 } // A Section represents a single section in an ELF file. type Section struct { - SectionHeader; + SectionHeader // Embed ReaderAt for ReadAt method. // Do not embed SectionReader directly @@ -64,34 +64,34 @@ type Section struct { // If a client wants Read and Seek it must use // Open() to avoid fighting over the seek offset // with other clients. - io.ReaderAt; - sr *io.SectionReader; + io.ReaderAt + sr *io.SectionReader } // Data reads and returns the contents of the ELF section. func (s *Section) Data() ([]byte, os.Error) { - dat := make([]byte, s.sr.Size()); - n, err := s.sr.ReadAt(dat, 0); - return dat[0:n], err; + dat := make([]byte, s.sr.Size()) + n, err := s.sr.ReadAt(dat, 0) + return dat[0:n], err } // Open returns a new ReadSeeker reading the ELF section. -func (s *Section) Open() io.ReadSeeker { return io.NewSectionReader(s.sr, 0, 1<<63-1) } +func (s *Section) Open() io.ReadSeeker { return io.NewSectionReader(s.sr, 0, 1<<63-1) } // A ProgHeader represents a single ELF program header. type ProgHeader struct { - Type ProgType; - Flags ProgFlag; - Vaddr uint64; - Paddr uint64; - Filesz uint64; - Memsz uint64; - Align uint64; + Type ProgType + Flags ProgFlag + Vaddr uint64 + Paddr uint64 + Filesz uint64 + Memsz uint64 + Align uint64 } // A Prog represents a single ELF program header in an ELF binary. type Prog struct { - ProgHeader; + ProgHeader // Embed ReaderAt for ReadAt method. // Do not embed SectionReader directly @@ -99,19 +99,19 @@ type Prog struct { // If a client wants Read and Seek it must use // Open() to avoid fighting over the seek offset // with other clients. - io.ReaderAt; - sr *io.SectionReader; + io.ReaderAt + sr *io.SectionReader } // Open returns a new ReadSeeker reading the ELF program body. -func (p *Prog) Open() io.ReadSeeker { return io.NewSectionReader(p.sr, 0, 1<<63-1) } +func (p *Prog) Open() io.ReadSeeker { return io.NewSectionReader(p.sr, 0, 1<<63-1) } // A Symbol represents an entry in an ELF symbol table section. type Symbol struct { - Name uint32; - Info, Other byte; - Section uint32; - Value, Size uint64; + Name uint32 + Info, Other byte + Section uint32 + Value, Size uint64 } /* @@ -119,53 +119,53 @@ type Symbol struct { */ type FormatError struct { - off int64; - msg string; - val interface{}; + off int64 + msg string + val interface{} } func (e *FormatError) String() string { - msg := e.msg; + msg := e.msg if e.val != nil { msg += fmt.Sprintf(" '%v' ", e.val) } - msg += fmt.Sprintf("in record at byte %#x", e.off); - return msg; + msg += fmt.Sprintf("in record at byte %#x", e.off) + return msg } // Open opens the named file using os.Open and prepares it for use as an ELF binary. func Open(name string) (*File, os.Error) { - f, err := os.Open(name, os.O_RDONLY, 0); + f, err := os.Open(name, os.O_RDONLY, 0) if err != nil { return nil, err } - ff, err := NewFile(f); + ff, err := NewFile(f) if err != nil { - f.Close(); - return nil, err; + f.Close() + return nil, err } - ff.closer = f; - return ff, nil; + ff.closer = f + return ff, nil } // Close closes the File. // If the File was created using NewFile directly instead of Open, // Close has no effect. func (f *File) Close() os.Error { - var err os.Error; + var err os.Error if f.closer != nil { - err = f.closer.Close(); - f.closer = nil; + err = f.closer.Close() + f.closer = nil } - return err; + return err } // NewFile creates a new File for acecssing an ELF binary in an underlying reader. // The ELF binary is expected to start at position 0 in the ReaderAt. func NewFile(r io.ReaderAt) (*File, os.Error) { - sr := io.NewSectionReader(r, 0, 1<<63-1); + sr := io.NewSectionReader(r, 0, 1<<63-1) // Read and decode ELF identifier - var ident [16]uint8; + var ident [16]uint8 if _, err := r.ReadAt(&ident, 0); err != nil { return nil, err } @@ -173,8 +173,8 @@ func NewFile(r io.ReaderAt) (*File, os.Error) { return nil, &FormatError{0, "bad magic number", ident[0:4]} } - f := new(File); - f.Class = Class(ident[EI_CLASS]); + f := new(File) + f.Class = Class(ident[EI_CLASS]) switch f.Class { case ELFCLASS32: case ELFCLASS64: @@ -183,7 +183,7 @@ func NewFile(r io.ReaderAt) (*File, os.Error) { return nil, &FormatError{0, "unknown ELF class", f.Class} } - f.Data = Data(ident[EI_DATA]); + f.Data = Data(ident[EI_DATA]) switch f.Data { case ELFDATA2LSB: f.ByteOrder = binary.LittleEndian @@ -193,49 +193,49 @@ func NewFile(r io.ReaderAt) (*File, os.Error) { return nil, &FormatError{0, "unknown ELF data encoding", f.Data} } - f.Version = Version(ident[EI_VERSION]); + f.Version = Version(ident[EI_VERSION]) if f.Version != EV_CURRENT { return nil, &FormatError{0, "unknown ELF version", f.Version} } - f.OSABI = OSABI(ident[EI_OSABI]); - f.ABIVersion = ident[EI_ABIVERSION]; + f.OSABI = OSABI(ident[EI_OSABI]) + f.ABIVersion = ident[EI_ABIVERSION] // Read ELF file header - var shoff int64; - var shentsize, shnum, shstrndx int; - shstrndx = -1; + var shoff int64 + var shentsize, shnum, shstrndx int + shstrndx = -1 switch f.Class { case ELFCLASS32: - hdr := new(Header32); - sr.Seek(0, 0); + hdr := new(Header32) + sr.Seek(0, 0) if err := binary.Read(sr, f.ByteOrder, hdr); err != nil { return nil, err } - f.Type = Type(hdr.Type); - f.Machine = Machine(hdr.Machine); + f.Type = Type(hdr.Type) + f.Machine = Machine(hdr.Machine) if v := Version(hdr.Version); v != f.Version { return nil, &FormatError{0, "mismatched ELF version", v} } - shoff = int64(hdr.Shoff); - shentsize = int(hdr.Shentsize); - shnum = int(hdr.Shnum); - shstrndx = int(hdr.Shstrndx); + shoff = int64(hdr.Shoff) + shentsize = int(hdr.Shentsize) + shnum = int(hdr.Shnum) + shstrndx = int(hdr.Shstrndx) case ELFCLASS64: - hdr := new(Header64); - sr.Seek(0, 0); + hdr := new(Header64) + sr.Seek(0, 0) if err := binary.Read(sr, f.ByteOrder, hdr); err != nil { return nil, err } - f.Type = Type(hdr.Type); - f.Machine = Machine(hdr.Machine); + f.Type = Type(hdr.Type) + f.Machine = Machine(hdr.Machine) if v := Version(hdr.Version); v != f.Version { return nil, &FormatError{0, "mismatched ELF version", v} } - shoff = int64(hdr.Shoff); - shentsize = int(hdr.Shentsize); - shnum = int(hdr.Shnum); - shstrndx = int(hdr.Shstrndx); + shoff = int64(hdr.Shoff) + shentsize = int(hdr.Shentsize) + shnum = int(hdr.Shnum) + shstrndx = int(hdr.Shstrndx) } if shstrndx < 0 || shstrndx >= shnum { return nil, &FormatError{0, "invalid ELF shstrndx", shstrndx} @@ -245,19 +245,19 @@ func NewFile(r io.ReaderAt) (*File, os.Error) { // TODO // Read section headers - f.Sections = make([]*Section, shnum); - names := make([]uint32, shnum); + f.Sections = make([]*Section, shnum) + names := make([]uint32, shnum) for i := 0; i < shnum; i++ { - off := shoff + int64(i)*int64(shentsize); - sr.Seek(off, 0); - s := new(Section); + off := shoff + int64(i)*int64(shentsize) + sr.Seek(off, 0) + s := new(Section) switch f.Class { case ELFCLASS32: - sh := new(Section32); + sh := new(Section32) if err := binary.Read(sr, f.ByteOrder, sh); err != nil { return nil, err } - names[i] = sh.Name; + names[i] = sh.Name s.SectionHeader = SectionHeader{ Type: SectionType(sh.Type), Flags: SectionFlag(sh.Flags), @@ -268,13 +268,13 @@ func NewFile(r io.ReaderAt) (*File, os.Error) { Info: uint32(sh.Info), Addralign: uint64(sh.Addralign), Entsize: uint64(sh.Entsize), - }; + } case ELFCLASS64: - sh := new(Section64); + sh := new(Section64) if err := binary.Read(sr, f.ByteOrder, sh); err != nil { return nil, err } - names[i] = sh.Name; + names[i] = sh.Name s.SectionHeader = SectionHeader{ Type: SectionType(sh.Type), Flags: SectionFlag(sh.Flags), @@ -285,28 +285,28 @@ func NewFile(r io.ReaderAt) (*File, os.Error) { Info: uint32(sh.Info), Addralign: uint64(sh.Addralign), Entsize: uint64(sh.Entsize), - }; + } } - s.sr = io.NewSectionReader(r, int64(s.Offset), int64(s.Size)); - s.ReaderAt = s.sr; - f.Sections[i] = s; + s.sr = io.NewSectionReader(r, int64(s.Offset), int64(s.Size)) + s.ReaderAt = s.sr + f.Sections[i] = s } // Load section header string table. - s := f.Sections[shstrndx]; - shstrtab := make([]byte, s.Size); + s := f.Sections[shstrndx] + shstrtab := make([]byte, s.Size) if _, err := r.ReadAt(shstrtab, int64(s.Offset)); err != nil { return nil, err } for i, s := range f.Sections { - var ok bool; - s.Name, ok = getString(shstrtab, int(names[i])); + var ok bool + s.Name, ok = getString(shstrtab, int(names[i])) if !ok { return nil, &FormatError{shoff + int64(i*shentsize), "bad section name index", names[i]} } } - return f, nil; + return f, nil } func (f *File) getSymbols() ([]Symbol, os.Error) { @@ -315,16 +315,16 @@ func (f *File) getSymbols() ([]Symbol, os.Error) { return f.getSymbols64() } - return nil, os.ErrorString("not implemented"); + return nil, os.ErrorString("not implemented") } // GetSymbols returns a slice of Symbols from parsing the symbol table. func (f *File) getSymbols64() ([]Symbol, os.Error) { - var symtabSection *Section; + var symtabSection *Section for _, section := range f.Sections { if section.Type == SHT_SYMTAB { - symtabSection = section; - break; + symtabSection = section + break } } @@ -332,35 +332,35 @@ func (f *File) getSymbols64() ([]Symbol, os.Error) { return nil, os.ErrorString("no symbol section") } - data, err := symtabSection.Data(); + data, err := symtabSection.Data() if err != nil { return nil, os.ErrorString("cannot load symbol section") } - symtab := bytes.NewBuffer(data); + symtab := bytes.NewBuffer(data) if symtab.Len()%Sym64Size != 0 { return nil, os.ErrorString("length of symbol section is not a multiple of Sym64Size") } // The first entry is all zeros. - var skip [Sym64Size]byte; - symtab.Read(skip[0:]); + var skip [Sym64Size]byte + symtab.Read(skip[0:]) - symbols := make([]Symbol, symtab.Len()/Sym64Size); + symbols := make([]Symbol, symtab.Len()/Sym64Size) - i := 0; - var sym Sym64; + i := 0 + var sym Sym64 for symtab.Len() > 0 { - binary.Read(symtab, f.ByteOrder, &sym); - symbols[i].Name = sym.Name; - symbols[i].Info = sym.Info; - symbols[i].Other = sym.Other; - symbols[i].Section = uint32(sym.Shndx); - symbols[i].Value = sym.Value; - symbols[i].Size = sym.Size; - i++; + binary.Read(symtab, f.ByteOrder, &sym) + symbols[i].Name = sym.Name + symbols[i].Info = sym.Info + symbols[i].Other = sym.Other + symbols[i].Section = uint32(sym.Shndx) + symbols[i].Value = sym.Value + symbols[i].Size = sym.Size + i++ } - return symbols, nil; + return symbols, nil } // getString extracts a string from an ELF string table. @@ -374,7 +374,7 @@ func getString(section []byte, start int) (string, bool) { return string(section[start:end]), true } } - return "", false; + return "", false } // Section returns a section with the given name, or nil if no such @@ -385,7 +385,7 @@ func (f *File) Section(name string) *Section { return s } } - return nil; + return nil } // applyRelocations applies relocations to dst. rels is a relocations section @@ -395,7 +395,7 @@ func (f *File) applyRelocations(dst []byte, rels []byte) os.Error { return f.applyRelocationsAMD64(dst, rels) } - return os.ErrorString("not implemented"); + return os.ErrorString("not implemented") } func (f *File) applyRelocationsAMD64(dst []byte, rels []byte) os.Error { @@ -403,23 +403,23 @@ func (f *File) applyRelocationsAMD64(dst []byte, rels []byte) os.Error { return os.ErrorString("length of relocation section is not a multiple of Sym64Size") } - symbols, err := f.getSymbols(); + symbols, err := f.getSymbols() if err != nil { return err } - b := bytes.NewBuffer(rels); - var rela Rela64; + b := bytes.NewBuffer(rels) + var rela Rela64 for b.Len() > 0 { - binary.Read(b, f.ByteOrder, &rela); - symNo := rela.Info >> 32; - t := R_X86_64(rela.Info & 0xffff); + binary.Read(b, f.ByteOrder, &rela) + symNo := rela.Info >> 32 + t := R_X86_64(rela.Info & 0xffff) if symNo >= uint64(len(symbols)) { continue } - sym := &symbols[symNo]; + sym := &symbols[symNo] if SymType(sym.Info&0xf) != STT_SECTION { // We don't handle non-section relocations for now. continue @@ -430,51 +430,51 @@ func (f *File) applyRelocationsAMD64(dst []byte, rels []byte) os.Error { if rela.Off+8 >= uint64(len(dst)) || rela.Addend < 0 { continue } - f.ByteOrder.PutUint64(dst[rela.Off:rela.Off+8], uint64(rela.Addend)); + f.ByteOrder.PutUint64(dst[rela.Off:rela.Off+8], uint64(rela.Addend)) case R_X86_64_32: if rela.Off+4 >= uint64(len(dst)) || rela.Addend < 0 { continue } - f.ByteOrder.PutUint32(dst[rela.Off:rela.Off+4], uint32(rela.Addend)); + f.ByteOrder.PutUint32(dst[rela.Off:rela.Off+4], uint32(rela.Addend)) } } - return nil; + return nil } func (f *File) DWARF() (*dwarf.Data, os.Error) { // There are many other DWARF sections, but these // are the required ones, and the debug/dwarf package // does not use the others, so don't bother loading them. - var names = [...]string{"abbrev", "info", "str"}; - var dat [len(names)][]byte; + var names = [...]string{"abbrev", "info", "str"} + var dat [len(names)][]byte for i, name := range names { - name = ".debug_" + name; - s := f.Section(name); + name = ".debug_" + name + s := f.Section(name) if s == nil { continue } - b, err := s.Data(); + b, err := s.Data() if err != nil && uint64(len(b)) < s.Size { return nil, err } - dat[i] = b; + dat[i] = b } // If there's a relocation table for .debug_info, we have to process it // now otherwise the data in .debug_info is invalid for x86-64 objects. - rela := f.Section(".rela.debug_info"); + rela := f.Section(".rela.debug_info") if rela != nil && rela.Type == SHT_RELA && f.Machine == EM_X86_64 { - data, err := rela.Data(); + data, err := rela.Data() if err != nil { return nil, err } - err = f.applyRelocations(dat[1], data); + err = f.applyRelocations(dat[1], data) if err != nil { return nil, err } } - abbrev, info, str := dat[0], dat[1], dat[2]; - return dwarf.New(abbrev, nil, nil, info, nil, nil, nil, str); + abbrev, info, str := dat[0], dat[1], dat[2] + return dwarf.New(abbrev, nil, nil, info, nil, nil, nil, str) } diff --git a/src/pkg/debug/elf/file_test.go b/src/pkg/debug/elf/file_test.go index 9cd15fbd3..49adc4dc7 100644 --- a/src/pkg/debug/elf/file_test.go +++ b/src/pkg/debug/elf/file_test.go @@ -5,16 +5,16 @@ package elf import ( - "debug/dwarf"; - "encoding/binary"; - "reflect"; - "testing"; + "debug/dwarf" + "encoding/binary" + "reflect" + "testing" ) type fileTest struct { - file string; - hdr FileHeader; - sections []SectionHeader; + file string + hdr FileHeader + sections []SectionHeader } var fileTests = []fileTest{ @@ -101,28 +101,28 @@ var fileTests = []fileTest{ func TestOpen(t *testing.T) { for i := range fileTests { - tt := &fileTests[i]; + tt := &fileTests[i] - f, err := Open(tt.file); + f, err := Open(tt.file) if err != nil { - t.Error(err); - continue; + t.Error(err) + continue } if !reflect.DeepEqual(f.FileHeader, tt.hdr) { - t.Errorf("open %s:\n\thave %#v\n\twant %#v\n", tt.file, f.FileHeader, tt.hdr); - continue; + t.Errorf("open %s:\n\thave %#v\n\twant %#v\n", tt.file, f.FileHeader, tt.hdr) + continue } for i, s := range f.Sections { if i >= len(tt.sections) { break } - sh := &tt.sections[i]; + sh := &tt.sections[i] if !reflect.DeepEqual(&s.SectionHeader, sh) { t.Errorf("open %s, section %d:\n\thave %#v\n\twant %#v\n", tt.file, i, &s.SectionHeader, sh) } } - tn := len(tt.sections); - fn := len(f.Sections); + tn := len(tt.sections) + fn := len(f.Sections) if tn != fn { t.Errorf("open %s: len(Sections) = %d, want %d", tt.file, fn, tn) } @@ -130,8 +130,8 @@ func TestOpen(t *testing.T) { } type relocationTest struct { - file string; - firstEntry *dwarf.Entry; + file string + firstEntry *dwarf.Entry } var relocationTests = []relocationTest{ @@ -151,30 +151,30 @@ var relocationTests = []relocationTest{ func TestDWARFRelocations(t *testing.T) { for i, test := range relocationTests { - f, err := Open(test.file); + f, err := Open(test.file) if err != nil { - t.Error(err); - continue; + t.Error(err) + continue } - dwarf, err := f.DWARF(); + dwarf, err := f.DWARF() if err != nil { - t.Error(err); - continue; + t.Error(err) + continue } - reader := dwarf.Reader(); + reader := dwarf.Reader() // Checking only the first entry is sufficient since it has // many different strings. If the relocation had failed, all // the string offsets would be zero and all the strings would // end up being the same. - firstEntry, err := reader.Next(); + firstEntry, err := reader.Next() if err != nil { - t.Error(err); - continue; + t.Error(err) + continue } if !reflect.DeepEqual(test.firstEntry, firstEntry) { - t.Errorf("#%d: mismatch: got:%#v want:%#v", i, firstEntry, test.firstEntry); - continue; + t.Errorf("#%d: mismatch: got:%#v want:%#v", i, firstEntry, test.firstEntry) + continue } } } diff --git a/src/pkg/debug/gosym/pclntab.go b/src/pkg/debug/gosym/pclntab.go index 6c6a18868..9d7b0d15f 100644 --- a/src/pkg/debug/gosym/pclntab.go +++ b/src/pkg/debug/gosym/pclntab.go @@ -11,9 +11,9 @@ package gosym import "encoding/binary" type LineTable struct { - Data []byte; - PC uint64; - Line int; + Data []byte + PC uint64 + Line int } // TODO(rsc): Need to pull in quantum from architecture definition. @@ -28,49 +28,49 @@ func (t *LineTable) parse(targetPC uint64, targetLine int) (b []byte, pc uint64, // // Here we process each update individually, which simplifies // the code, but makes the corner cases more confusing. - b, pc, line = t.Data, t.PC, t.Line; + b, pc, line = t.Data, t.PC, t.Line for pc <= targetPC && line != targetLine && len(b) > 0 { - code := b[0]; - b = b[1:]; + code := b[0] + b = b[1:] switch { case code == 0: if len(b) < 4 { - b = b[0:0]; - break; + b = b[0:0] + break } - val := binary.BigEndian.Uint32(b); - b = b[4:]; - line += int(val); + val := binary.BigEndian.Uint32(b) + b = b[4:] + line += int(val) case code <= 64: line += int(code) case code <= 128: line -= int(code - 64) default: - pc += quantum * uint64(code-128); - continue; + pc += quantum * uint64(code-128) + continue } - pc += quantum; + pc += quantum } - return b, pc, line; + return b, pc, line } func (t *LineTable) slice(pc uint64) *LineTable { - data, pc, line := t.parse(pc, -1); - return &LineTable{data, pc, line}; + data, pc, line := t.parse(pc, -1) + return &LineTable{data, pc, line} } func (t *LineTable) PCToLine(pc uint64) int { - _, _, line := t.parse(pc, -1); - return line; + _, _, line := t.parse(pc, -1) + return line } func (t *LineTable) LineToPC(line int, maxpc uint64) uint64 { - _, pc, line1 := t.parse(maxpc, line); + _, pc, line1 := t.parse(maxpc, line) if line1 != line { return 0 } // Subtract quantum from PC to account for post-line increment - return pc - quantum; + return pc - quantum } // NewLineTable returns a new PC/line table diff --git a/src/pkg/debug/gosym/pclntab_test.go b/src/pkg/debug/gosym/pclntab_test.go index 66609d9cf..9ab493d59 100644 --- a/src/pkg/debug/gosym/pclntab_test.go +++ b/src/pkg/debug/gosym/pclntab_test.go @@ -5,10 +5,10 @@ package gosym import ( - "debug/elf"; - "os"; - "testing"; - "syscall"; + "debug/elf" + "os" + "testing" + "syscall" ) func dotest() bool { @@ -17,40 +17,40 @@ func dotest() bool { } func getTable(t *testing.T) *Table { - f, tab := crack(os.Args[0], t); - f.Close(); - return tab; + f, tab := crack(os.Args[0], t) + f.Close() + return tab } func crack(file string, t *testing.T) (*elf.File, *Table) { // Open self - f, err := elf.Open(file); + f, err := elf.Open(file) if err != nil { t.Fatal(err) } - return parse(file, f, t); + return parse(file, f, t) } func parse(file string, f *elf.File, t *testing.T) (*elf.File, *Table) { - symdat, err := f.Section(".gosymtab").Data(); + symdat, err := f.Section(".gosymtab").Data() if err != nil { - f.Close(); - t.Fatalf("reading %s gosymtab: %v", file, err); + f.Close() + t.Fatalf("reading %s gosymtab: %v", file, err) } - pclndat, err := f.Section(".gopclntab").Data(); + pclndat, err := f.Section(".gopclntab").Data() if err != nil { - f.Close(); - t.Fatalf("reading %s gopclntab: %v", file, err); + f.Close() + t.Fatalf("reading %s gopclntab: %v", file, err) } - pcln := NewLineTable(pclndat, f.Section(".text").Addr); - tab, err := NewTable(symdat, pcln); + pcln := NewLineTable(pclndat, f.Section(".text").Addr) + tab, err := NewTable(symdat, pcln) if err != nil { - f.Close(); - t.Fatalf("parsing %s gosymtab: %v", file, err); + f.Close() + t.Fatalf("parsing %s gosymtab: %v", file, err) } - return f, tab; + return f, tab } var goarch = os.Getenv("O") @@ -60,42 +60,42 @@ func TestLineFromAline(t *testing.T) { return } - tab := getTable(t); + tab := getTable(t) // Find the sym package - pkg := tab.LookupFunc("gosym.TestLineFromAline").Obj; + pkg := tab.LookupFunc("gosym.TestLineFromAline").Obj if pkg == nil { t.Fatalf("nil pkg") } // Walk every absolute line and ensure that we hit every // source line monotonically - lastline := make(map[string]int); - final := -1; + lastline := make(map[string]int) + final := -1 for i := 0; i < 10000; i++ { - path, line := pkg.lineFromAline(i); + path, line := pkg.lineFromAline(i) // Check for end of object if path == "" { if final == -1 { final = i - 1 } - continue; + continue } else if final != -1 { t.Fatalf("reached end of package at absolute line %d, but absolute line %d mapped to %s:%d", final, i, path, line) } // It's okay to see files multiple times (e.g., sys.a) if line == 1 { - lastline[path] = 1; - continue; + lastline[path] = 1 + continue } // Check that the is the next line in path - ll, ok := lastline[path]; + ll, ok := lastline[path] if !ok { t.Errorf("file %s starts on line %d", path, line) } else if line != ll+1 { t.Errorf("expected next line of file %s to be %d, got %d", path, ll+1, line) } - lastline[path] = line; + lastline[path] = line } if final == -1 { t.Errorf("never reached end of object") @@ -107,15 +107,15 @@ func TestLineAline(t *testing.T) { return } - tab := getTable(t); + tab := getTable(t) for _, o := range tab.Files { // A source file can appear multiple times in a // object. alineFromLine will always return alines in // the first file, so track which lines we've seen. - found := make(map[string]int); + found := make(map[string]int) for i := 0; i < 1000; i++ { - path, line := o.lineFromAline(i); + path, line := o.lineFromAline(i) if path == "" { break } @@ -131,9 +131,9 @@ func TestLineAline(t *testing.T) { continue } } - found[path] = line; + found[path] = line - a, err := o.alineFromLine(path, line); + a, err := o.alineFromLine(path, line) if err != nil { t.Errorf("absolute line %d in object %s maps to %s:%d, but mapping that back gives error %s", i, o.Paths[0].Name, path, line, err) } else if a != i { @@ -151,20 +151,20 @@ func TestPCLine(t *testing.T) { return } - f, tab := crack("_test/pclinetest", t); - text := f.Section(".text"); - textdat, err := text.Data(); + f, tab := crack("_test/pclinetest", t) + text := f.Section(".text") + textdat, err := text.Data() if err != nil { t.Fatalf("reading .text: %v", err) } // Test PCToLine - sym := tab.LookupFunc("linefrompc"); - wantLine := 0; + sym := tab.LookupFunc("linefrompc") + wantLine := 0 for pc := sym.Entry; pc < sym.End; pc++ { - file, line, fn := tab.PCToLine(pc); - off := pc - text.Addr; // TODO(rsc): should not need off; bug in 8g - wantLine += int(textdat[off]); + file, line, fn := tab.PCToLine(pc) + off := pc - text.Addr // TODO(rsc): should not need off; bug in 8g + wantLine += int(textdat[off]) if fn == nil { t.Errorf("failed to get line of PC %#x", pc) } else if len(file) < 12 || file[len(file)-12:] != "pclinetest.s" || line != wantLine || fn != sym { @@ -173,24 +173,24 @@ func TestPCLine(t *testing.T) { } // Test LineToPC - sym = tab.LookupFunc("pcfromline"); - lookupline := -1; - wantLine = 0; - off := uint64(0); // TODO(rsc): should not need off; bug in 8g + sym = tab.LookupFunc("pcfromline") + lookupline := -1 + wantLine = 0 + off := uint64(0) // TODO(rsc): should not need off; bug in 8g for pc := sym.Value; pc < sym.End; pc += 2 + uint64(textdat[off]) { - file, line, fn := tab.PCToLine(pc); - off = pc - text.Addr; - wantLine += int(textdat[off]); + file, line, fn := tab.PCToLine(pc) + off = pc - text.Addr + wantLine += int(textdat[off]) if line != wantLine { - t.Errorf("expected line %d at PC %#x in pcfromline, got %d", wantLine, pc, line); - off = pc + 1 - text.Addr; - continue; + t.Errorf("expected line %d at PC %#x in pcfromline, got %d", wantLine, pc, line) + off = pc + 1 - text.Addr + continue } if lookupline == -1 { lookupline = line } for ; lookupline <= line; lookupline++ { - pc2, fn2, err := tab.LineToPC(file, lookupline); + pc2, fn2, err := tab.LineToPC(file, lookupline) if lookupline != line { // Should be nothing on this line if err == nil { @@ -202,6 +202,6 @@ func TestPCLine(t *testing.T) { t.Errorf("expected PC %#x (%s) at line %d, got PC %#x (%s)", pc, fn.Name, line, pc2, fn2.Name) } } - off = pc + 1 - text.Addr; + off = pc + 1 - text.Addr } } diff --git a/src/pkg/debug/gosym/symtab.go b/src/pkg/debug/gosym/symtab.go index 39e397ece..dea460d71 100644 --- a/src/pkg/debug/gosym/symtab.go +++ b/src/pkg/debug/gosym/symtab.go @@ -13,11 +13,11 @@ package gosym // and the Go format is the runtime source, specifically ../../runtime/symtab.c. import ( - "encoding/binary"; - "fmt"; - "os"; - "strconv"; - "strings"; + "encoding/binary" + "fmt" + "os" + "strconv" + "strings" ) /* @@ -26,16 +26,16 @@ import ( // A Sym represents a single symbol table entry. type Sym struct { - Value uint64; - Type byte; - Name string; - GoType uint64; + Value uint64 + Type byte + Name string + GoType uint64 // If this symbol if a function symbol, the corresponding Func - Func *Func; + Func *Func } // Static returns whether this symbol is static (not visible outside its file). -func (s *Sym) Static() bool { return s.Type >= 'a' } +func (s *Sym) Static() bool { return s.Type >= 'a' } // PackageName returns the package part of the symbol name, // or the empty string if there is none. @@ -43,18 +43,18 @@ func (s *Sym) PackageName() string { if i := strings.Index(s.Name, "."); i != -1 { return s.Name[0:i] } - return ""; + return "" } // ReceiverName returns the receiver type name of this symbol, // or the empty string if there is none. func (s *Sym) ReceiverName() string { - l := strings.Index(s.Name, "."); - r := strings.LastIndex(s.Name, "."); + l := strings.Index(s.Name, ".") + r := strings.LastIndex(s.Name, ".") if l == -1 || r == -1 || l == r { return "" } - return s.Name[l+1 : r]; + return s.Name[l+1 : r] } // BaseName returns the symbol name without the package or receiver name. @@ -62,25 +62,25 @@ func (s *Sym) BaseName() string { if i := strings.LastIndex(s.Name, "."); i != -1 { return s.Name[i+1:] } - return s.Name; + return s.Name } // A Func collects information about a single function. type Func struct { - Entry uint64; - *Sym; - End uint64; - Params []*Sym; - Locals []*Sym; - FrameSize int; - LineTable *LineTable; - Obj *Obj; + Entry uint64 + *Sym + End uint64 + Params []*Sym + Locals []*Sym + FrameSize int + LineTable *LineTable + Obj *Obj } // An Obj represents a single object file. type Obj struct { - Funcs []Func; - Paths []Sym; + Funcs []Func + Paths []Sym } /* @@ -91,115 +91,115 @@ type Obj struct { // symbols decoded from the program and provides methods to translate // between symbols, names, and addresses. type Table struct { - Syms []Sym; - Funcs []Func; - Files map[string]*Obj; - Objs []Obj; + Syms []Sym + Funcs []Func + Files map[string]*Obj + Objs []Obj // textEnd uint64; } type sym struct { - value uint32; - gotype uint32; - typ byte; - name []byte; + value uint32 + gotype uint32 + typ byte + name []byte } func walksymtab(data []byte, fn func(sym) os.Error) os.Error { - var s sym; - p := data; + var s sym + p := data for len(p) >= 6 { - s.value = binary.BigEndian.Uint32(p[0:4]); - typ := p[4]; + s.value = binary.BigEndian.Uint32(p[0:4]) + typ := p[4] if typ&0x80 == 0 { return &DecodingError{len(data) - len(p) + 4, "bad symbol type", typ} } - typ &^= 0x80; - s.typ = typ; - p = p[5:]; - var i int; - var nnul int; + typ &^= 0x80 + s.typ = typ + p = p[5:] + var i int + var nnul int for i = 0; i < len(p); i++ { if p[i] == 0 { - nnul = 1; - break; + nnul = 1 + break } } switch typ { case 'z', 'Z': - p = p[i+nnul:]; + p = p[i+nnul:] for i = 0; i+2 <= len(p); i += 2 { if p[i] == 0 && p[i+1] == 0 { - nnul = 2; - break; + nnul = 2 + break } } } if i+nnul+4 > len(p) { return &DecodingError{len(data), "unexpected EOF", nil} } - s.name = p[0:i]; - i += nnul; - s.gotype = binary.BigEndian.Uint32(p[i : i+4]); - p = p[i+4:]; - fn(s); + s.name = p[0:i] + i += nnul + s.gotype = binary.BigEndian.Uint32(p[i : i+4]) + p = p[i+4:] + fn(s) } - return nil; + return nil } // NewTable decodes the Go symbol table in data, // returning an in-memory representation. func NewTable(symtab []byte, pcln *LineTable) (*Table, os.Error) { - var n int; + var n int err := walksymtab(symtab, func(s sym) os.Error { - n++; - return nil; - }); + n++ + return nil + }) if err != nil { return nil, err } - var t Table; - fname := make(map[uint16]string); - t.Syms = make([]Sym, 0, n); - nf := 0; - nz := 0; - lasttyp := uint8(0); + var t Table + fname := make(map[uint16]string) + t.Syms = make([]Sym, 0, n) + nf := 0 + nz := 0 + lasttyp := uint8(0) err = walksymtab(symtab, func(s sym) os.Error { - n := len(t.Syms); - t.Syms = t.Syms[0 : n+1]; - ts := &t.Syms[n]; - ts.Type = s.typ; - ts.Value = uint64(s.value); - ts.GoType = uint64(s.gotype); + n := len(t.Syms) + t.Syms = t.Syms[0 : n+1] + ts := &t.Syms[n] + ts.Type = s.typ + ts.Value = uint64(s.value) + ts.GoType = uint64(s.gotype) switch s.typ { default: // rewrite name to use . instead of · (c2 b7) - w := 0; - b := s.name; + w := 0 + b := s.name for i := 0; i < len(b); i++ { if b[i] == 0xc2 && i+1 < len(b) && b[i+1] == 0xb7 { - i++; - b[i] = '.'; + i++ + b[i] = '.' } - b[w] = b[i]; - w++; + b[w] = b[i] + w++ } - ts.Name = string(s.name[0:w]); + ts.Name = string(s.name[0:w]) case 'z', 'Z': if lasttyp != 'z' && lasttyp != 'Z' { nz++ } for i := 0; i < len(s.name); i += 2 { - eltIdx := binary.BigEndian.Uint16(s.name[i : i+2]); - elt, ok := fname[eltIdx]; + eltIdx := binary.BigEndian.Uint16(s.name[i : i+2]) + elt, ok := fname[eltIdx] if !ok { return &DecodingError{-1, "bad filename code", eltIdx} } if n := len(ts.Name); n > 0 && ts.Name[n-1] != '/' { ts.Name += "/" } - ts.Name += elt; + ts.Name += elt } } switch s.typ { @@ -208,61 +208,61 @@ func NewTable(symtab []byte, pcln *LineTable) (*Table, os.Error) { case 'f': fname[uint16(s.value)] = ts.Name } - lasttyp = s.typ; - return nil; - }); + lasttyp = s.typ + return nil + }) if err != nil { return nil, err } - t.Funcs = make([]Func, 0, nf); - t.Objs = make([]Obj, 0, nz); - t.Files = make(map[string]*Obj); + t.Funcs = make([]Func, 0, nf) + t.Objs = make([]Obj, 0, nz) + t.Files = make(map[string]*Obj) // Count text symbols and attach frame sizes, parameters, and // locals to them. Also, find object file boundaries. - var obj *Obj; - lastf := 0; + var obj *Obj + lastf := 0 for i := 0; i < len(t.Syms); i++ { - sym := &t.Syms[i]; + sym := &t.Syms[i] switch sym.Type { - case 'Z', 'z': // path symbol + case 'Z', 'z': // path symbol // Finish the current object if obj != nil { obj.Funcs = t.Funcs[lastf:] } - lastf = len(t.Funcs); + lastf = len(t.Funcs) // Start new object - n := len(t.Objs); - t.Objs = t.Objs[0 : n+1]; - obj = &t.Objs[n]; + n := len(t.Objs) + t.Objs = t.Objs[0 : n+1] + obj = &t.Objs[n] // Count & copy path symbols - var end int; + var end int for end = i + 1; end < len(t.Syms); end++ { if c := t.Syms[end].Type; c != 'Z' && c != 'z' { break } } - obj.Paths = t.Syms[i:end]; - i = end - 1; // loop will i++ + obj.Paths = t.Syms[i:end] + i = end - 1 // loop will i++ // Record file names - depth := 0; + depth := 0 for j := range obj.Paths { - s := &obj.Paths[j]; + s := &obj.Paths[j] if s.Name == "" { depth-- } else { if depth == 0 { t.Files[s.Name] = obj } - depth++; + depth++ } } - case 'T', 't', 'L', 'l': // text symbol + case 'T', 't', 'L', 'l': // text symbol if n := len(t.Funcs); n > 0 { t.Funcs[n-1].End = sym.Value } @@ -271,8 +271,8 @@ func NewTable(symtab []byte, pcln *LineTable) (*Table, os.Error) { } // Count parameter and local (auto) syms - var np, na int; - var end int; + var np, na int + var end int countloop: for end = i + 1; end < len(t.Syms); end++ { switch t.Syms[end].Type { @@ -286,50 +286,50 @@ func NewTable(symtab []byte, pcln *LineTable) (*Table, os.Error) { } // Fill in the function symbol - n := len(t.Funcs); - t.Funcs = t.Funcs[0 : n+1]; - fn := &t.Funcs[n]; - sym.Func = fn; - fn.Params = make([]*Sym, 0, np); - fn.Locals = make([]*Sym, 0, na); - fn.Sym = sym; - fn.Entry = sym.Value; - fn.Obj = obj; + n := len(t.Funcs) + t.Funcs = t.Funcs[0 : n+1] + fn := &t.Funcs[n] + sym.Func = fn + fn.Params = make([]*Sym, 0, np) + fn.Locals = make([]*Sym, 0, na) + fn.Sym = sym + fn.Entry = sym.Value + fn.Obj = obj if pcln != nil { - fn.LineTable = pcln.slice(fn.Entry); - pcln = fn.LineTable; + fn.LineTable = pcln.slice(fn.Entry) + pcln = fn.LineTable } for j := i; j < end; j++ { - s := &t.Syms[j]; + s := &t.Syms[j] switch s.Type { case 'm': fn.FrameSize = int(s.Value) case 'p': - n := len(fn.Params); - fn.Params = fn.Params[0 : n+1]; - fn.Params[n] = s; + n := len(fn.Params) + fn.Params = fn.Params[0 : n+1] + fn.Params[n] = s case 'a': - n := len(fn.Locals); - fn.Locals = fn.Locals[0 : n+1]; - fn.Locals[n] = s; + n := len(fn.Locals) + fn.Locals = fn.Locals[0 : n+1] + fn.Locals[n] = s } } - i = end - 1; // loop will i++ + i = end - 1 // loop will i++ } } if obj != nil { obj.Funcs = t.Funcs[lastf:] } - return &t, nil; + return &t, nil } // PCToFunc returns the function containing the program counter pc, // or nil if there is no such function. func (t *Table) PCToFunc(pc uint64) *Func { - funcs := t.Funcs; + funcs := t.Funcs for len(funcs) > 0 { - m := len(funcs) / 2; - fn := &funcs[m]; + m := len(funcs) / 2 + fn := &funcs[m] switch { case pc < fn.Entry: funcs = funcs[0:m] @@ -339,7 +339,7 @@ func (t *Table) PCToFunc(pc uint64) *Func { funcs = funcs[m+1:] } } - return nil; + return nil } // PCToLine looks up line number information for a program counter. @@ -348,30 +348,30 @@ func (t *Table) PCToLine(pc uint64) (file string, line int, fn *Func) { if fn = t.PCToFunc(pc); fn == nil { return } - file, line = fn.Obj.lineFromAline(fn.LineTable.PCToLine(pc)); - return; + file, line = fn.Obj.lineFromAline(fn.LineTable.PCToLine(pc)) + return } // LineToPC looks up the first program counter on the given line in // the named file. Returns UnknownPathError or UnknownLineError if // there is an error looking up this line. func (t *Table) LineToPC(file string, line int) (pc uint64, fn *Func, err os.Error) { - obj, ok := t.Files[file]; + obj, ok := t.Files[file] if !ok { return 0, nil, UnknownFileError(file) } - abs, err := obj.alineFromLine(file, line); + abs, err := obj.alineFromLine(file, line) if err != nil { return } for i := range obj.Funcs { - f := &obj.Funcs[i]; - pc := f.LineTable.LineToPC(abs, f.End); + f := &obj.Funcs[i] + pc := f.LineTable.LineToPC(abs, f.End) if pc != 0 { return pc, f, nil } } - return 0, nil, &UnknownLineError{file, line}; + return 0, nil, &UnknownLineError{file, line} } // LookupSym returns the text, data, or bss symbol with the given name, @@ -379,7 +379,7 @@ func (t *Table) LineToPC(file string, line int) (pc uint64, fn *Func, err os.Err func (t *Table) LookupSym(name string) *Sym { // TODO(austin) Maybe make a map for i := range t.Syms { - s := &t.Syms[i]; + s := &t.Syms[i] switch s.Type { case 'T', 't', 'L', 'l', 'D', 'd', 'B', 'b': if s.Name == name { @@ -387,19 +387,19 @@ func (t *Table) LookupSym(name string) *Sym { } } } - return nil; + return nil } // LookupFunc returns the text, data, or bss symbol with the given name, // or nil if no such symbol is found. func (t *Table) LookupFunc(name string) *Func { for i := range t.Funcs { - f := &t.Funcs[i]; + f := &t.Funcs[i] if f.Sym.Name == name { return f } } - return nil; + return nil } // SymByAddr returns the text, data, or bss symbol starting at the given address. @@ -407,7 +407,7 @@ func (t *Table) LookupFunc(name string) *Func { func (t *Table) SymByAddr(addr uint64) *Sym { // TODO(austin) Maybe make a map for i := range t.Syms { - s := &t.Syms[i]; + s := &t.Syms[i] switch s.Type { case 'T', 't', 'L', 'l', 'D', 'd', 'B', 'b': if s.Value == addr { @@ -415,7 +415,7 @@ func (t *Table) SymByAddr(addr uint64) *Sym { } } } - return nil; + return nil } /* @@ -424,20 +424,20 @@ func (t *Table) SymByAddr(addr uint64) *Sym { func (o *Obj) lineFromAline(aline int) (string, int) { type stackEnt struct { - path string; - start int; - offset int; - prev *stackEnt; + path string + start int + offset int + prev *stackEnt } - noPath := &stackEnt{"", 0, 0, nil}; - tos := noPath; + noPath := &stackEnt{"", 0, 0, nil} + tos := noPath // TODO(austin) I have no idea how 'Z' symbols work, except // that they pop the stack. pathloop: for _, s := range o.Paths { - val := int(s.Value); + val := int(s.Value) switch { case val > aline: break pathloop @@ -451,8 +451,8 @@ pathloop: if tos == noPath { return "<malformed symbol table>", 0 } - tos.prev.offset += val - tos.start; - tos = tos.prev; + tos.prev.offset += val - tos.start + tos = tos.prev default: // Push @@ -463,7 +463,7 @@ pathloop: if tos == noPath { return "", 0 } - return tos.path, aline - tos.start - tos.offset + 1; + return tos.path, aline - tos.start - tos.offset + 1 } func (o *Obj) alineFromLine(path string, line int) (int, os.Error) { @@ -478,18 +478,18 @@ func (o *Obj) alineFromLine(path string, line int) (int, os.Error) { } // Find this line at this stack level - depth := 0; - var incstart int; - line += int(s.Value); + depth := 0 + var incstart int + line += int(s.Value) pathloop: for _, s := range o.Paths[i:] { - val := int(s.Value); + val := int(s.Value) switch { case depth == 1 && val >= line: return line - 1, nil case s.Name == "": - depth--; + depth-- if depth == 0 { break pathloop } else if depth == 1 { @@ -500,12 +500,12 @@ func (o *Obj) alineFromLine(path string, line int) (int, os.Error) { if depth == 1 { incstart = val } - depth++; + depth++ } } - return 0, &UnknownLineError{path, line}; + return 0, &UnknownLineError{path, line} } - return 0, UnknownFileError(path); + return 0, UnknownFileError(path) } /* @@ -516,14 +516,14 @@ func (o *Obj) alineFromLine(path string, line int) (int, os.Error) { // the symbol table. type UnknownFileError string -func (e UnknownFileError) String() string { return "unknown file: " + string(e) } +func (e UnknownFileError) String() string { return "unknown file: " + string(e) } // UnknownLineError represents a failure to map a line to a program // counter, either because the line is beyond the bounds of the file // or because there is no code on the given line. type UnknownLineError struct { - File string; - Line int; + File string + Line int } func (e *UnknownLineError) String() string { @@ -533,16 +533,16 @@ func (e *UnknownLineError) String() string { // DecodingError represents an error during the decoding of // the symbol table. type DecodingError struct { - off int; - msg string; - val interface{}; + off int + msg string + val interface{} } func (e *DecodingError) String() string { - msg := e.msg; + msg := e.msg if e.val != nil { msg += fmt.Sprintf(" '%v'", e.val) } - msg += fmt.Sprintf(" at byte %#x", e.off); - return msg; + msg += fmt.Sprintf(" at byte %#x", e.off) + return msg } diff --git a/src/pkg/debug/macho/file.go b/src/pkg/debug/macho/file.go index 233490c83..7c492ef52 100644 --- a/src/pkg/debug/macho/file.go +++ b/src/pkg/debug/macho/file.go @@ -9,53 +9,53 @@ package macho // High level access to low level data structures. import ( - "bytes"; - "debug/dwarf"; - "encoding/binary"; - "fmt"; - "io"; - "os"; + "bytes" + "debug/dwarf" + "encoding/binary" + "fmt" + "io" + "os" ) // A File represents an open Mach-O file. type File struct { - FileHeader; - ByteOrder binary.ByteOrder; - Loads []Load; - Sections []*Section; + FileHeader + ByteOrder binary.ByteOrder + Loads []Load + Sections []*Section - closer io.Closer; + closer io.Closer } // A Load represents any Mach-O load command. type Load interface { - Raw() []byte; + Raw() []byte } // A LoadBytes is the uninterpreted bytes of a Mach-O load command. type LoadBytes []byte -func (b LoadBytes) Raw() []byte { return b } +func (b LoadBytes) Raw() []byte { return b } // A SegmentHeader is the header for a Mach-O 32-bit or 64-bit load segment command. type SegmentHeader struct { - Cmd LoadCmd; - Len uint32; - Name string; - Addr uint64; - Memsz uint64; - Offset uint64; - Filesz uint64; - Maxprot uint32; - Prot uint32; - Nsect uint32; - Flag uint32; + Cmd LoadCmd + Len uint32 + Name string + Addr uint64 + Memsz uint64 + Offset uint64 + Filesz uint64 + Maxprot uint32 + Prot uint32 + Nsect uint32 + Flag uint32 } // A Segment represents a Mach-O 32-bit or 64-bit load segment command. type Segment struct { - LoadBytes; - SegmentHeader; + LoadBytes + SegmentHeader // Embed ReaderAt for ReadAt method. // Do not embed SectionReader directly @@ -63,34 +63,34 @@ type Segment struct { // If a client wants Read and Seek it must use // Open() to avoid fighting over the seek offset // with other clients. - io.ReaderAt; - sr *io.SectionReader; + io.ReaderAt + sr *io.SectionReader } // Data reads and returns the contents of the segment. func (s *Segment) Data() ([]byte, os.Error) { - dat := make([]byte, s.sr.Size()); - n, err := s.sr.ReadAt(dat, 0); - return dat[0:n], err; + dat := make([]byte, s.sr.Size()) + n, err := s.sr.ReadAt(dat, 0) + return dat[0:n], err } // Open returns a new ReadSeeker reading the segment. -func (s *Segment) Open() io.ReadSeeker { return io.NewSectionReader(s.sr, 0, 1<<63-1) } +func (s *Segment) Open() io.ReadSeeker { return io.NewSectionReader(s.sr, 0, 1<<63-1) } type SectionHeader struct { - Name string; - Seg string; - Addr uint64; - Size uint64; - Offset uint32; - Align uint32; - Reloff uint32; - Nreloc uint32; - Flags uint32; + Name string + Seg string + Addr uint64 + Size uint64 + Offset uint32 + Align uint32 + Reloff uint32 + Nreloc uint32 + Flags uint32 } type Section struct { - SectionHeader; + SectionHeader // Embed ReaderAt for ReadAt method. // Do not embed SectionReader directly @@ -98,19 +98,19 @@ type Section struct { // If a client wants Read and Seek it must use // Open() to avoid fighting over the seek offset // with other clients. - io.ReaderAt; - sr *io.SectionReader; + io.ReaderAt + sr *io.SectionReader } // Data reads and returns the contents of the Mach-O section. func (s *Section) Data() ([]byte, os.Error) { - dat := make([]byte, s.sr.Size()); - n, err := s.sr.ReadAt(dat, 0); - return dat[0:n], err; + dat := make([]byte, s.sr.Size()) + n, err := s.sr.ReadAt(dat, 0) + return dat[0:n], err } // Open returns a new ReadSeeker reading the Mach-O section. -func (s *Section) Open() io.ReadSeeker { return io.NewSectionReader(s.sr, 0, 1<<63-1) } +func (s *Section) Open() io.ReadSeeker { return io.NewSectionReader(s.sr, 0, 1<<63-1) } /* @@ -118,68 +118,68 @@ func (s *Section) Open() io.ReadSeeker { return io.NewSectionReader(s.sr, 0, 1<< */ type FormatError struct { - off int64; - msg string; - val interface{}; + off int64 + msg string + val interface{} } func (e *FormatError) String() string { - msg := e.msg; + msg := e.msg if e.val != nil { msg += fmt.Sprintf(" '%v' ", e.val) } - msg += fmt.Sprintf("in record at byte %#x", e.off); - return msg; + msg += fmt.Sprintf("in record at byte %#x", e.off) + return msg } // Open opens the named file using os.Open and prepares it for use as a Mach-O binary. func Open(name string) (*File, os.Error) { - f, err := os.Open(name, os.O_RDONLY, 0); + f, err := os.Open(name, os.O_RDONLY, 0) if err != nil { return nil, err } - ff, err := NewFile(f); + ff, err := NewFile(f) if err != nil { - f.Close(); - return nil, err; + f.Close() + return nil, err } - ff.closer = f; - return ff, nil; + ff.closer = f + return ff, nil } // Close closes the File. // If the File was created using NewFile directly instead of Open, // Close has no effect. func (f *File) Close() os.Error { - var err os.Error; + var err os.Error if f.closer != nil { - err = f.closer.Close(); - f.closer = nil; + err = f.closer.Close() + f.closer = nil } - return err; + return err } // NewFile creates a new File for acecssing a Mach-O binary in an underlying reader. // The Mach-O binary is expected to start at position 0 in the ReaderAt. func NewFile(r io.ReaderAt) (*File, os.Error) { - f := new(File); - sr := io.NewSectionReader(r, 0, 1<<63-1); + f := new(File) + sr := io.NewSectionReader(r, 0, 1<<63-1) // Read and decode Mach magic to determine byte order, size. // Magic32 and Magic64 differ only in the bottom bit. - var ident [4]uint8; + var ident [4]uint8 if _, err := r.ReadAt(&ident, 0); err != nil { return nil, err } - be := binary.BigEndian.Uint32(&ident); - le := binary.LittleEndian.Uint32(&ident); + be := binary.BigEndian.Uint32(&ident) + le := binary.LittleEndian.Uint32(&ident) switch Magic32 &^ 1 { case be &^ 1: - f.ByteOrder = binary.BigEndian; - f.Magic = be; + f.ByteOrder = binary.BigEndian + f.Magic = be case le &^ 1: - f.ByteOrder = binary.LittleEndian; - f.Magic = le; + f.ByteOrder = binary.LittleEndian + f.Magic = le } // Read entire file header. @@ -188,138 +188,138 @@ func NewFile(r io.ReaderAt) (*File, os.Error) { } // Then load commands. - offset := int64(fileHeaderSize32); + offset := int64(fileHeaderSize32) if f.Magic == Magic64 { offset = fileHeaderSize64 } - dat := make([]byte, f.Cmdsz); + dat := make([]byte, f.Cmdsz) if _, err := r.ReadAt(dat, offset); err != nil { return nil, err } - f.Loads = make([]Load, f.Ncmd); - bo := f.ByteOrder; + f.Loads = make([]Load, f.Ncmd) + bo := f.ByteOrder for i := range f.Loads { // Each load command begins with uint32 command and length. if len(dat) < 8 { return nil, &FormatError{offset, "command block too small", nil} } - cmd, siz := LoadCmd(bo.Uint32(dat[0:4])), bo.Uint32(dat[4:8]); + cmd, siz := LoadCmd(bo.Uint32(dat[0:4])), bo.Uint32(dat[4:8]) if siz < 8 || siz > uint32(len(dat)) { return nil, &FormatError{offset, "invalid command block size", nil} } - var cmddat []byte; - cmddat, dat = dat[0:siz], dat[siz:]; - offset += int64(siz); - var s *Segment; + var cmddat []byte + cmddat, dat = dat[0:siz], dat[siz:] + offset += int64(siz) + var s *Segment switch cmd { default: f.Loads[i] = LoadBytes(cmddat) case LoadCmdSegment: - var seg32 Segment32; - b := bytes.NewBuffer(cmddat); + var seg32 Segment32 + b := bytes.NewBuffer(cmddat) if err := binary.Read(b, bo, &seg32); err != nil { return nil, err } - s = new(Segment); - s.LoadBytes = cmddat; - s.Cmd = cmd; - s.Len = siz; - s.Name = cstring(&seg32.Name); - s.Addr = uint64(seg32.Addr); - s.Memsz = uint64(seg32.Memsz); - s.Offset = uint64(seg32.Offset); - s.Filesz = uint64(seg32.Filesz); - s.Maxprot = seg32.Maxprot; - s.Prot = seg32.Prot; - s.Nsect = seg32.Nsect; - s.Flag = seg32.Flag; - f.Loads[i] = s; + s = new(Segment) + s.LoadBytes = cmddat + s.Cmd = cmd + s.Len = siz + s.Name = cstring(&seg32.Name) + s.Addr = uint64(seg32.Addr) + s.Memsz = uint64(seg32.Memsz) + s.Offset = uint64(seg32.Offset) + s.Filesz = uint64(seg32.Filesz) + s.Maxprot = seg32.Maxprot + s.Prot = seg32.Prot + s.Nsect = seg32.Nsect + s.Flag = seg32.Flag + f.Loads[i] = s for i := 0; i < int(s.Nsect); i++ { - var sh32 Section32; + var sh32 Section32 if err := binary.Read(b, bo, &sh32); err != nil { return nil, err } - sh := new(Section); - sh.Name = cstring(&sh32.Name); - sh.Seg = cstring(&sh32.Seg); - sh.Addr = uint64(sh32.Addr); - sh.Size = uint64(sh32.Size); - sh.Offset = sh32.Offset; - sh.Align = sh32.Align; - sh.Reloff = sh32.Reloff; - sh.Nreloc = sh32.Nreloc; - sh.Flags = sh32.Flags; - f.pushSection(sh, r); + sh := new(Section) + sh.Name = cstring(&sh32.Name) + sh.Seg = cstring(&sh32.Seg) + sh.Addr = uint64(sh32.Addr) + sh.Size = uint64(sh32.Size) + sh.Offset = sh32.Offset + sh.Align = sh32.Align + sh.Reloff = sh32.Reloff + sh.Nreloc = sh32.Nreloc + sh.Flags = sh32.Flags + f.pushSection(sh, r) } case LoadCmdSegment64: - var seg64 Segment64; - b := bytes.NewBuffer(cmddat); + var seg64 Segment64 + b := bytes.NewBuffer(cmddat) if err := binary.Read(b, bo, &seg64); err != nil { return nil, err } - s = new(Segment); - s.LoadBytes = cmddat; - s.Cmd = cmd; - s.Len = siz; - s.Name = cstring(&seg64.Name); - s.Addr = seg64.Addr; - s.Memsz = seg64.Memsz; - s.Offset = seg64.Offset; - s.Filesz = seg64.Filesz; - s.Maxprot = seg64.Maxprot; - s.Prot = seg64.Prot; - s.Nsect = seg64.Nsect; - s.Flag = seg64.Flag; - f.Loads[i] = s; + s = new(Segment) + s.LoadBytes = cmddat + s.Cmd = cmd + s.Len = siz + s.Name = cstring(&seg64.Name) + s.Addr = seg64.Addr + s.Memsz = seg64.Memsz + s.Offset = seg64.Offset + s.Filesz = seg64.Filesz + s.Maxprot = seg64.Maxprot + s.Prot = seg64.Prot + s.Nsect = seg64.Nsect + s.Flag = seg64.Flag + f.Loads[i] = s for i := 0; i < int(s.Nsect); i++ { - var sh64 Section64; + var sh64 Section64 if err := binary.Read(b, bo, &sh64); err != nil { return nil, err } - sh := new(Section); - sh.Name = cstring(&sh64.Name); - sh.Seg = cstring(&sh64.Seg); - sh.Addr = sh64.Addr; - sh.Size = sh64.Size; - sh.Offset = sh64.Offset; - sh.Align = sh64.Align; - sh.Reloff = sh64.Reloff; - sh.Nreloc = sh64.Nreloc; - sh.Flags = sh64.Flags; - f.pushSection(sh, r); + sh := new(Section) + sh.Name = cstring(&sh64.Name) + sh.Seg = cstring(&sh64.Seg) + sh.Addr = sh64.Addr + sh.Size = sh64.Size + sh.Offset = sh64.Offset + sh.Align = sh64.Align + sh.Reloff = sh64.Reloff + sh.Nreloc = sh64.Nreloc + sh.Flags = sh64.Flags + f.pushSection(sh, r) } } if s != nil { - s.sr = io.NewSectionReader(r, int64(s.Offset), int64(s.Filesz)); - s.ReaderAt = s.sr; + s.sr = io.NewSectionReader(r, int64(s.Offset), int64(s.Filesz)) + s.ReaderAt = s.sr } } - return f, nil; + return f, nil } func (f *File) pushSection(sh *Section, r io.ReaderAt) { - n := len(f.Sections); + n := len(f.Sections) if n >= cap(f.Sections) { - m := (n + 1) * 2; - new := make([]*Section, n, m); + m := (n + 1) * 2 + new := make([]*Section, n, m) for i, sh := range f.Sections { new[i] = sh } - f.Sections = new; + f.Sections = new } - f.Sections = f.Sections[0 : n+1]; - f.Sections[n] = sh; - sh.sr = io.NewSectionReader(r, int64(sh.Offset), int64(sh.Size)); - sh.ReaderAt = sh.sr; + f.Sections = f.Sections[0 : n+1] + f.Sections[n] = sh + sh.sr = io.NewSectionReader(r, int64(sh.Offset), int64(sh.Size)) + sh.ReaderAt = sh.sr } func cstring(b []byte) string { - var i int; + var i int for i = 0; i < len(b) && b[i] != 0; i++ { } - return string(b[0:i]); + return string(b[0:i]) } // Segment returns the first Segment with the given name, or nil if no such segment exists. @@ -329,7 +329,7 @@ func (f *File) Segment(name string) *Segment { return s } } - return nil; + return nil } // Section returns the first section with the given name, or nil if no such @@ -340,7 +340,7 @@ func (f *File) Section(name string) *Section { return s } } - return nil; + return nil } // DWARF returns the DWARF debug information for the Mach-O file. @@ -348,21 +348,21 @@ func (f *File) DWARF() (*dwarf.Data, os.Error) { // There are many other DWARF sections, but these // are the required ones, and the debug/dwarf package // does not use the others, so don't bother loading them. - var names = [...]string{"abbrev", "info", "str"}; - var dat [len(names)][]byte; + var names = [...]string{"abbrev", "info", "str"} + var dat [len(names)][]byte for i, name := range names { - name = "__debug_" + name; - s := f.Section(name); + name = "__debug_" + name + s := f.Section(name) if s == nil { return nil, os.NewError("missing Mach-O section " + name) } - b, err := s.Data(); + b, err := s.Data() if err != nil && uint64(len(b)) < s.Size { return nil, err } - dat[i] = b; + dat[i] = b } - abbrev, info, str := dat[0], dat[1], dat[2]; - return dwarf.New(abbrev, nil, nil, info, nil, nil, nil, str); + abbrev, info, str := dat[0], dat[1], dat[2] + return dwarf.New(abbrev, nil, nil, info, nil, nil, nil, str) } diff --git a/src/pkg/debug/macho/file_test.go b/src/pkg/debug/macho/file_test.go index e1d75da15..d69e49cbf 100644 --- a/src/pkg/debug/macho/file_test.go +++ b/src/pkg/debug/macho/file_test.go @@ -5,15 +5,15 @@ package macho import ( - "reflect"; - "testing"; + "reflect" + "testing" ) type fileTest struct { - file string; - hdr FileHeader; - segments []*SegmentHeader; - sections []*SectionHeader; + file string + hdr FileHeader + segments []*SegmentHeader + sections []*SectionHeader } var fileTests = []fileTest{ @@ -100,41 +100,41 @@ var fileTests = []fileTest{ func TestOpen(t *testing.T) { for i := range fileTests { - tt := &fileTests[i]; + tt := &fileTests[i] - f, err := Open(tt.file); + f, err := Open(tt.file) if err != nil { - t.Error(err); - continue; + t.Error(err) + continue } if !reflect.DeepEqual(f.FileHeader, tt.hdr) { - t.Errorf("open %s:\n\thave %#v\n\twant %#v\n", tt.file, f.FileHeader, tt.hdr); - continue; + t.Errorf("open %s:\n\thave %#v\n\twant %#v\n", tt.file, f.FileHeader, tt.hdr) + continue } for i, l := range f.Loads { if i >= len(tt.segments) { break } - sh := tt.segments[i]; - s, ok := l.(*Segment); + sh := tt.segments[i] + s, ok := l.(*Segment) if sh == nil { if ok { t.Errorf("open %s, section %d: skipping %#v\n", tt.file, i, &s.SegmentHeader) } - continue; + continue } if !ok { - t.Errorf("open %s, section %d: not *Segment\n", tt.file, i); - continue; + t.Errorf("open %s, section %d: not *Segment\n", tt.file, i) + continue } - have := &s.SegmentHeader; - want := sh; + have := &s.SegmentHeader + want := sh if !reflect.DeepEqual(have, want) { t.Errorf("open %s, segment %d:\n\thave %#v\n\twant %#v\n", tt.file, i, have, want) } } - tn := len(tt.segments); - fn := len(f.Loads); + tn := len(tt.segments) + fn := len(f.Loads) if tn != fn { t.Errorf("open %s: len(Loads) = %d, want %d", tt.file, fn, tn) } @@ -143,14 +143,14 @@ func TestOpen(t *testing.T) { if i >= len(tt.sections) { break } - have := &sh.SectionHeader; - want := tt.sections[i]; + have := &sh.SectionHeader + want := tt.sections[i] if !reflect.DeepEqual(have, want) { t.Errorf("open %s, section %d:\n\thave %#v\n\twant %#v\n", tt.file, i, have, want) } } - tn = len(tt.sections); - fn = len(f.Sections); + tn = len(tt.sections) + fn = len(f.Sections) if tn != fn { t.Errorf("open %s: len(Sections) = %d, want %d", tt.file, fn, tn) } diff --git a/src/pkg/debug/macho/macho.go b/src/pkg/debug/macho/macho.go index abc59c8a6..41962d562 100644 --- a/src/pkg/debug/macho/macho.go +++ b/src/pkg/debug/macho/macho.go @@ -11,39 +11,39 @@ import "strconv" // A FileHeader represents a Mach-O file header. type FileHeader struct { - Magic uint32; - Cpu Cpu; - SubCpu uint32; - Type Type; - Ncmd uint32; - Cmdsz uint32; - Flags uint32; + Magic uint32 + Cpu Cpu + SubCpu uint32 + Type Type + Ncmd uint32 + Cmdsz uint32 + Flags uint32 } const ( - fileHeaderSize32 = 7 * 4; - fileHeaderSize64 = 8 * 4; + fileHeaderSize32 = 7 * 4 + fileHeaderSize64 = 8 * 4 ) const ( - Magic32 uint32 = 0xfeedface; - Magic64 uint32 = 0xfeedfacf; + Magic32 uint32 = 0xfeedface + Magic64 uint32 = 0xfeedfacf ) // A Type is a Mach-O file type, either an object or an executable. type Type uint32 const ( - TypeObj Type = 1; - TypeExec Type = 2; + TypeObj Type = 1 + TypeExec Type = 2 ) // A Cpu is a Mach-O cpu type. type Cpu uint32 const ( - Cpu386 Cpu = 7; - CpuAmd64 Cpu = Cpu386 + 1<<24; + Cpu386 Cpu = 7 + CpuAmd64 Cpu = Cpu386 + 1<<24 ) var cpuStrings = []intName{ @@ -51,17 +51,17 @@ var cpuStrings = []intName{ intName{uint32(CpuAmd64), "CpuAmd64"}, } -func (i Cpu) String() string { return stringName(uint32(i), cpuStrings, false) } -func (i Cpu) GoString() string { return stringName(uint32(i), cpuStrings, true) } +func (i Cpu) String() string { return stringName(uint32(i), cpuStrings, false) } +func (i Cpu) GoString() string { return stringName(uint32(i), cpuStrings, true) } // A LoadCmd is a Mach-O load command. type LoadCmd uint32 const ( - LoadCmdSegment LoadCmd = 1; - LoadCmdSegment64 LoadCmd = 25; - LoadCmdThread LoadCmd = 4; - LoadCmdUnixThread LoadCmd = 5; // thread+stack + LoadCmdSegment LoadCmd = 1 + LoadCmdSegment64 LoadCmd = 25 + LoadCmdThread LoadCmd = 4 + LoadCmdUnixThread LoadCmd = 5 // thread+stack ) var cmdStrings = []intName{ @@ -71,126 +71,126 @@ var cmdStrings = []intName{ intName{uint32(LoadCmdUnixThread), "LoadCmdUnixThread"}, } -func (i LoadCmd) String() string { return stringName(uint32(i), cmdStrings, false) } -func (i LoadCmd) GoString() string { return stringName(uint32(i), cmdStrings, true) } +func (i LoadCmd) String() string { return stringName(uint32(i), cmdStrings, false) } +func (i LoadCmd) GoString() string { return stringName(uint32(i), cmdStrings, true) } // A Segment64 is a 64-bit Mach-O segment load command. type Segment64 struct { - Cmd LoadCmd; - Len uint32; - Name [16]byte; - Addr uint64; - Memsz uint64; - Offset uint64; - Filesz uint64; - Maxprot uint32; - Prot uint32; - Nsect uint32; - Flag uint32; + Cmd LoadCmd + Len uint32 + Name [16]byte + Addr uint64 + Memsz uint64 + Offset uint64 + Filesz uint64 + Maxprot uint32 + Prot uint32 + Nsect uint32 + Flag uint32 } // A Segment32 is a 32-bit Mach-O segment load command. type Segment32 struct { - Cmd LoadCmd; - Len uint32; - Name [16]byte; - Addr uint32; - Memsz uint32; - Offset uint32; - Filesz uint32; - Maxprot uint32; - Prot uint32; - Nsect uint32; - Flag uint32; + Cmd LoadCmd + Len uint32 + Name [16]byte + Addr uint32 + Memsz uint32 + Offset uint32 + Filesz uint32 + Maxprot uint32 + Prot uint32 + Nsect uint32 + Flag uint32 } // A Section32 is a 32-bit Mach-O section header. type Section32 struct { - Name [16]byte; - Seg [16]byte; - Addr uint32; - Size uint32; - Offset uint32; - Align uint32; - Reloff uint32; - Nreloc uint32; - Flags uint32; - Reserve1 uint32; - Reserve2 uint32; + Name [16]byte + Seg [16]byte + Addr uint32 + Size uint32 + Offset uint32 + Align uint32 + Reloff uint32 + Nreloc uint32 + Flags uint32 + Reserve1 uint32 + Reserve2 uint32 } // A Section32 is a 64-bit Mach-O section header. type Section64 struct { - Name [16]byte; - Seg [16]byte; - Addr uint64; - Size uint64; - Offset uint32; - Align uint32; - Reloff uint32; - Nreloc uint32; - Flags uint32; - Reserve1 uint32; - Reserve2 uint32; - Reserve3 uint32; + Name [16]byte + Seg [16]byte + Addr uint64 + Size uint64 + Offset uint32 + Align uint32 + Reloff uint32 + Nreloc uint32 + Flags uint32 + Reserve1 uint32 + Reserve2 uint32 + Reserve3 uint32 } // A Thread is a Mach-O thread state command. type Thread struct { - Cmd LoadCmd; - Len uint32; - Type uint32; - Data []uint32; + Cmd LoadCmd + Len uint32 + Type uint32 + Data []uint32 } // Regs386 is the Mach-O 386 register structure. type Regs386 struct { - AX uint32; - BX uint32; - CX uint32; - DX uint32; - DI uint32; - SI uint32; - BP uint32; - SP uint32; - SS uint32; - FLAGS uint32; - IP uint32; - CS uint32; - DS uint32; - ES uint32; - FS uint32; - GS uint32; + AX uint32 + BX uint32 + CX uint32 + DX uint32 + DI uint32 + SI uint32 + BP uint32 + SP uint32 + SS uint32 + FLAGS uint32 + IP uint32 + CS uint32 + DS uint32 + ES uint32 + FS uint32 + GS uint32 } // RegsAMD64 is the Mach-O AMD64 register structure. type RegsAMD64 struct { - AX uint64; - BX uint64; - CX uint64; - DX uint64; - DI uint64; - SI uint64; - BP uint64; - SP uint64; - R8 uint64; - R9 uint64; - R10 uint64; - R11 uint64; - R12 uint64; - R13 uint64; - R14 uint64; - R15 uint64; - IP uint64; - FLAGS uint64; - CS uint64; - FS uint64; - GS uint64; + AX uint64 + BX uint64 + CX uint64 + DX uint64 + DI uint64 + SI uint64 + BP uint64 + SP uint64 + R8 uint64 + R9 uint64 + R10 uint64 + R11 uint64 + R12 uint64 + R13 uint64 + R14 uint64 + R15 uint64 + IP uint64 + FLAGS uint64 + CS uint64 + FS uint64 + GS uint64 } type intName struct { - i uint32; - s string; + i uint32 + s string } func stringName(i uint32, names []intName, goSyntax bool) string { @@ -199,14 +199,14 @@ func stringName(i uint32, names []intName, goSyntax bool) string { if goSyntax { return "macho." + n.s } - return n.s; + return n.s } } - return strconv.Uitoa64(uint64(i)); + return strconv.Uitoa64(uint64(i)) } func flagName(i uint32, names []intName, goSyntax bool) string { - s := ""; + s := "" for _, n := range names { if n.i&i == n.i { if len(s) > 0 { @@ -215,8 +215,8 @@ func flagName(i uint32, names []intName, goSyntax bool) string { if goSyntax { s += "macho." } - s += n.s; - i -= n.i; + s += n.s + i -= n.i } } if len(s) == 0 { @@ -225,5 +225,5 @@ func flagName(i uint32, names []intName, goSyntax bool) string { if i != 0 { s += "+0x" + strconv.Uitob64(uint64(i), 16) } - return s; + return s } diff --git a/src/pkg/debug/proc/proc.go b/src/pkg/debug/proc/proc.go index 7f8e778c6..d5341a745 100644 --- a/src/pkg/debug/proc/proc.go +++ b/src/pkg/debug/proc/proc.go @@ -13,22 +13,22 @@ package proc // and proc_darwin.go do, because deps.bash only looks at // this file. import ( - _ "container/vector"; - _ "fmt"; - _ "io"; - "os"; - _ "runtime"; - "strconv"; - _ "strings"; - _ "sync"; - _ "syscall"; + _ "container/vector" + _ "fmt" + _ "io" + "os" + _ "runtime" + "strconv" + _ "strings" + _ "sync" + _ "syscall" ) type Word uint64 // A Cause explains why a thread is stopped. type Cause interface { - String() string; + String() string } // Regs is a set of named machine registers, including a program @@ -42,33 +42,33 @@ type Cause interface { // other per-register information like how to print it. type Regs interface { // PC returns the value of the program counter. - PC() Word; + PC() Word // SetPC sets the program counter to val. - SetPC(val Word) os.Error; + SetPC(val Word) os.Error // Link returns the link register, if any. - Link() Word; + Link() Word // SetLink sets the link register to val. - SetLink(val Word) os.Error; + SetLink(val Word) os.Error // SP returns the value of the stack pointer. - SP() Word; + SP() Word // SetSP sets the stack pointer register to val. - SetSP(val Word) os.Error; + SetSP(val Word) os.Error // Names returns the names of all of the registers. - Names() []string; + Names() []string // Get returns the value of a register, where i corresponds to // the index of the register's name in the array returned by // Names. - Get(i int) Word; + Get(i int) Word // Set sets the value of a register. - Set(i int, val Word) os.Error; + Set(i int, val Word) os.Error } // Thread is a thread in the process being traced. @@ -78,15 +78,15 @@ type Thread interface { // breakpoint, this will step over the breakpoint. // // XXX What if it's stopped because of a signal? - Step() os.Error; + Step() os.Error // Stopped returns the reason that this thread is stopped. It // is an error is the thread not stopped. - Stopped() (Cause, os.Error); + Stopped() (Cause, os.Error) // Regs retrieves the current register values from this // thread. The thread must be stopped. - Regs() (Regs, os.Error); + Regs() (Regs, os.Error) // Peek reads len(out) bytes from the address addr in this // thread into out. The thread must be stopped. It returns @@ -95,7 +95,7 @@ type Thread interface { // could be short and an error will be returned. If this does // encounter unmapped memory, it will read up to the byte // preceding the unmapped area. - Peek(addr Word, out []byte) (int, os.Error); + Peek(addr Word, out []byte) (int, os.Error) // Poke writes b to the address addr in this thread. The // thread must be stopped. It returns the number of bytes @@ -104,7 +104,7 @@ type Thread interface { // short and an error will be returned. If this does // encounter unmapped memory, it will write up to the byte // preceding the unmapped area. - Poke(addr Word, b []byte) (int, os.Error); + Poke(addr Word, b []byte) (int, os.Error) } // Process is a process being traced. It consists of a set of @@ -112,37 +112,37 @@ type Thread interface { // process's state extends to all of its threads. type Process interface { // Threads returns an array of all threads in this process. - Threads() []Thread; + Threads() []Thread // AddBreakpoint creates a new breakpoint at program counter // pc. Breakpoints can only be created when the process is // stopped. It is an error if a breakpoint already exists at // pc. - AddBreakpoint(pc Word) os.Error; + AddBreakpoint(pc Word) os.Error // RemoveBreakpoint removes the breakpoint at the program // counter pc. It is an error if no breakpoint exists at pc. - RemoveBreakpoint(pc Word) os.Error; + RemoveBreakpoint(pc Word) os.Error // Stop stops all running threads in this process before // returning. - Stop() os.Error; + Stop() os.Error // Continue resumes execution of all threads in this process. // Any thread that is stopped on a breakpoint will be stepped // over that breakpoint. Any thread that is stopped because // of a signal (other than SIGSTOP or SIGTRAP) will receive // the pending signal. - Continue() os.Error; + Continue() os.Error // WaitStop waits until all threads in process p are stopped // as a result of some thread hitting a breakpoint, receiving // a signal, creating a new thread, or exiting. - WaitStop() os.Error; + WaitStop() os.Error // Detach detaches from this process. All stopped threads // will be resumed. - Detach() os.Error; + Detach() os.Error } // Stopped is a stop cause used for threads that are stopped either by @@ -151,14 +151,14 @@ type Process interface { // stop. type Stopped struct{} -func (c Stopped) String() string { return "stopped" } +func (c Stopped) String() string { return "stopped" } // Breakpoint is a stop cause resulting from a thread reaching a set // breakpoint. type Breakpoint Word // PC returns the program counter that the program is stopped at. -func (c Breakpoint) PC() Word { return Word(c) } +func (c Breakpoint) PC() Word { return Word(c) } func (c Breakpoint) String() string { return "breakpoint at 0x" + strconv.Uitob64(uint64(c.PC()), 16) @@ -169,47 +169,47 @@ func (c Breakpoint) String() string { type Signal string // Signal returns the signal being delivered to the thread. -func (c Signal) Name() string { return string(c) } +func (c Signal) Name() string { return string(c) } -func (c Signal) String() string { return c.Name() } +func (c Signal) String() string { return c.Name() } // ThreadCreate is a stop cause returned from an existing thread when // it creates a new thread. The new thread exists in a primordial // form at this point and will begin executing in earnest when the // process is continued. type ThreadCreate struct { - thread Thread; + thread Thread } -func (c *ThreadCreate) NewThread() Thread { return c.thread } +func (c *ThreadCreate) NewThread() Thread { return c.thread } -func (c *ThreadCreate) String() string { return "thread create" } +func (c *ThreadCreate) String() string { return "thread create" } // ThreadExit is a stop cause resulting from a thread exiting. When // this cause first arises, the thread will still be in the list of // process threads and its registers and memory will still be // accessible. type ThreadExit struct { - exitStatus int; - signal string; + exitStatus int + signal string } // Exited returns true if the thread exited normally. -func (c *ThreadExit) Exited() bool { return c.exitStatus != -1 } +func (c *ThreadExit) Exited() bool { return c.exitStatus != -1 } // ExitStatus returns the exit status of the thread if it exited // normally or -1 otherwise. -func (c *ThreadExit) ExitStatus() int { return c.exitStatus } +func (c *ThreadExit) ExitStatus() int { return c.exitStatus } // Signaled returns true if the thread was terminated by a signal. -func (c *ThreadExit) Signaled() bool { return c.exitStatus == -1 } +func (c *ThreadExit) Signaled() bool { return c.exitStatus == -1 } // StopSignal returns the signal that terminated the thread, or "" if // it was not terminated by a signal. -func (c *ThreadExit) StopSignal() string { return c.signal } +func (c *ThreadExit) StopSignal() string { return c.signal } func (c *ThreadExit) String() string { - res := "thread exited "; + res := "thread exited " switch { case c.Exited(): res += "with status " + strconv.Itoa(c.ExitStatus()) @@ -218,5 +218,5 @@ func (c *ThreadExit) String() string { default: res += "from unknown cause" } - return res; + return res } diff --git a/src/pkg/debug/proc/proc_linux.go b/src/pkg/debug/proc/proc_linux.go index b7192580d..7273e97d8 100644 --- a/src/pkg/debug/proc/proc_linux.go +++ b/src/pkg/debug/proc/proc_linux.go @@ -7,15 +7,15 @@ package proc // TODO(rsc): Imports here after to be in proc.go too in order // for deps.bash to get the right answer. import ( - "container/vector"; - "fmt"; - "io/ioutil"; - "os"; - "runtime"; - "strconv"; - "strings"; - "sync"; - "syscall"; + "container/vector" + "fmt" + "io/ioutil" + "os" + "runtime" + "strconv" + "strings" + "sync" + "syscall" ) // This is an implementation of the process tracing interface using @@ -35,9 +35,9 @@ import ( // as well as experimentation and examination of gdb's behavior. const ( - trace = false; - traceIP = false; - traceMem = false; + trace = false + traceIP = false + traceMem = false ) /* @@ -63,17 +63,17 @@ const ( type threadState string const ( - running threadState = "Running"; - singleStepping threadState = "SingleStepping"; // Transient - stopping threadState = "Stopping"; // Transient - stopped threadState = "Stopped"; - stoppedBreakpoint threadState = "StoppedBreakpoint"; - stoppedSignal threadState = "StoppedSignal"; - stoppedThreadCreate threadState = "StoppedThreadCreate"; - stoppedExiting threadState = "StoppedExiting"; - exiting threadState = "Exiting"; // Transient (except main thread) - exited threadState = "Exited"; - detached threadState = "Detached"; + running threadState = "Running" + singleStepping threadState = "SingleStepping" // Transient + stopping threadState = "Stopping" // Transient + stopped threadState = "Stopped" + stoppedBreakpoint threadState = "StoppedBreakpoint" + stoppedSignal threadState = "StoppedSignal" + stoppedThreadCreate threadState = "StoppedThreadCreate" + stoppedExiting threadState = "StoppedExiting" + exiting threadState = "Exiting" // Transient (except main thread) + exited threadState = "Exited" + detached threadState = "Detached" ) func (ts threadState) isRunning() bool { @@ -84,11 +84,11 @@ func (ts threadState) isStopped() bool { return ts == stopped || ts == stoppedBreakpoint || ts == stoppedSignal || ts == stoppedThreadCreate || ts == stoppedExiting } -func (ts threadState) isZombie() bool { return ts == exiting } +func (ts threadState) isZombie() bool { return ts == exiting } -func (ts threadState) isTerminal() bool { return ts == exited || ts == detached } +func (ts threadState) isTerminal() bool { return ts == exited || ts == detached } -func (ts threadState) String() string { return string(ts) } +func (ts threadState) String() string { return string(ts) } /* * Basic types @@ -98,15 +98,15 @@ func (ts threadState) String() string { return string(ts) } // including its program counter, the overwritten text if the // breakpoint is installed. type breakpoint struct { - pc uintptr; - olddata []byte; + pc uintptr + olddata []byte } func (bp *breakpoint) String() string { if bp == nil { return "<nil>" } - return fmt.Sprintf("%#x", bp.pc); + return fmt.Sprintf("%#x", bp.pc) } // bpinst386 is the breakpoint instruction used on 386 and amd64. @@ -114,15 +114,15 @@ var bpinst386 = []byte{0xcc} // A debugEvent represents a reason a thread stopped or a wait error. type debugEvent struct { - *os.Waitmsg; - t *thread; - err os.Error; + *os.Waitmsg + t *thread + err os.Error } // A debugReq is a request to execute a closure in the monitor thread. type debugReq struct { - f func() os.Error; - res chan os.Error; + f func() os.Error + res chan os.Error } // A transitionHandler specifies a function to be called when a thread @@ -131,8 +131,8 @@ type debugReq struct { // invokes a handler, it removes the handler from the handler queue. // The handler should re-add itself if needed. type transitionHandler struct { - handle func(*thread, threadState, threadState); - onErr func(os.Error); + handle func(*thread, threadState, threadState) + onErr func(os.Error) } // A process is a Linux process, which consists of a set of threads. @@ -146,36 +146,36 @@ type transitionHandler struct { // returns false, the monitor is not running (the ready channel has // been closed), and the reason it is not running will be stored in err. type process struct { - pid int; - threads map[int]*thread; - breakpoints map[uintptr]*breakpoint; - ready chan bool; - debugEvents chan *debugEvent; - debugReqs chan *debugReq; - stopReq chan os.Error; - transitionHandlers *vector.Vector; - err os.Error; + pid int + threads map[int]*thread + breakpoints map[uintptr]*breakpoint + ready chan bool + debugEvents chan *debugEvent + debugReqs chan *debugReq + stopReq chan os.Error + transitionHandlers *vector.Vector + err os.Error } // A thread represents a Linux thread in another process that is being // debugged. Each running thread has an associated goroutine that // waits for thread updates and sends them to the process monitor. type thread struct { - tid int; - proc *process; + tid int + proc *process // Whether to ignore the next SIGSTOP received by wait. - ignoreNextSigstop bool; + ignoreNextSigstop bool // Thread state. Only modified via setState. - state threadState; + state threadState // If state == StoppedBreakpoint - breakpoint *breakpoint; + breakpoint *breakpoint // If state == StoppedSignal or state == Exited - signal int; + signal int // If state == StoppedThreadCreate - newThread *thread; + newThread *thread // If state == Exited - exitStatus int; + exitStatus int } /* @@ -183,9 +183,9 @@ type thread struct { */ type badState struct { - thread *thread; - message string; - state threadState; + thread *thread + message string + state threadState } func (e *badState) String() string { @@ -200,12 +200,12 @@ func (e breakpointExistsError) String() string { type noBreakpointError Word -func (e noBreakpointError) String() string { return fmt.Sprintf("no breakpoint at PC %#x", e) } +func (e noBreakpointError) String() string { return fmt.Sprintf("no breakpoint at PC %#x", e) } type newThreadError struct { - *os.Waitmsg; - wantPid int; - wantSig int; + *os.Waitmsg + wantPid int + wantSig int } func (e *newThreadError) String() string { @@ -214,66 +214,66 @@ func (e *newThreadError) String() string { type ProcessExited struct{} -func (p ProcessExited) String() string { return "process exited" } +func (p ProcessExited) String() string { return "process exited" } /* * Ptrace wrappers */ func (t *thread) ptracePeekText(addr uintptr, out []byte) (int, os.Error) { - c, err := syscall.PtracePeekText(t.tid, addr, out); + c, err := syscall.PtracePeekText(t.tid, addr, out) if traceMem { fmt.Printf("peek(%#x) => %v, %v\n", addr, out, err) } - return c, os.NewSyscallError("ptrace(PEEKTEXT)", err); + return c, os.NewSyscallError("ptrace(PEEKTEXT)", err) } func (t *thread) ptracePokeText(addr uintptr, out []byte) (int, os.Error) { - c, err := syscall.PtracePokeText(t.tid, addr, out); + c, err := syscall.PtracePokeText(t.tid, addr, out) if traceMem { fmt.Printf("poke(%#x, %v) => %v\n", addr, out, err) } - return c, os.NewSyscallError("ptrace(POKETEXT)", err); + return c, os.NewSyscallError("ptrace(POKETEXT)", err) } func (t *thread) ptraceGetRegs(regs *syscall.PtraceRegs) os.Error { - err := syscall.PtraceGetRegs(t.tid, regs); - return os.NewSyscallError("ptrace(GETREGS)", err); + err := syscall.PtraceGetRegs(t.tid, regs) + return os.NewSyscallError("ptrace(GETREGS)", err) } func (t *thread) ptraceSetRegs(regs *syscall.PtraceRegs) os.Error { - err := syscall.PtraceSetRegs(t.tid, regs); - return os.NewSyscallError("ptrace(SETREGS)", err); + err := syscall.PtraceSetRegs(t.tid, regs) + return os.NewSyscallError("ptrace(SETREGS)", err) } func (t *thread) ptraceSetOptions(options int) os.Error { - err := syscall.PtraceSetOptions(t.tid, options); - return os.NewSyscallError("ptrace(SETOPTIONS)", err); + err := syscall.PtraceSetOptions(t.tid, options) + return os.NewSyscallError("ptrace(SETOPTIONS)", err) } func (t *thread) ptraceGetEventMsg() (uint, os.Error) { - msg, err := syscall.PtraceGetEventMsg(t.tid); - return msg, os.NewSyscallError("ptrace(GETEVENTMSG)", err); + msg, err := syscall.PtraceGetEventMsg(t.tid) + return msg, os.NewSyscallError("ptrace(GETEVENTMSG)", err) } func (t *thread) ptraceCont() os.Error { - err := syscall.PtraceCont(t.tid, 0); - return os.NewSyscallError("ptrace(CONT)", err); + err := syscall.PtraceCont(t.tid, 0) + return os.NewSyscallError("ptrace(CONT)", err) } func (t *thread) ptraceContWithSignal(sig int) os.Error { - err := syscall.PtraceCont(t.tid, sig); - return os.NewSyscallError("ptrace(CONT)", err); + err := syscall.PtraceCont(t.tid, sig) + return os.NewSyscallError("ptrace(CONT)", err) } func (t *thread) ptraceStep() os.Error { - err := syscall.PtraceSingleStep(t.tid); - return os.NewSyscallError("ptrace(SINGLESTEP)", err); + err := syscall.PtraceSingleStep(t.tid) + return os.NewSyscallError("ptrace(SINGLESTEP)", err) } func (t *thread) ptraceDetach() os.Error { - err := syscall.PtraceDetach(t.tid); - return os.NewSyscallError("ptrace(DETACH)", err); + err := syscall.PtraceDetach(t.tid) + return os.NewSyscallError("ptrace(DETACH)", err) } /* @@ -286,38 +286,38 @@ func (t *thread) logTrace(format string, args ...) { if !trace { return } - logLock.Lock(); - defer logLock.Unlock(); - fmt.Fprintf(os.Stderr, "Thread %d", t.tid); + logLock.Lock() + defer logLock.Unlock() + fmt.Fprintf(os.Stderr, "Thread %d", t.tid) if traceIP { - var regs syscall.PtraceRegs; - err := t.ptraceGetRegs(®s); + var regs syscall.PtraceRegs + err := t.ptraceGetRegs(®s) if err == nil { fmt.Fprintf(os.Stderr, "@%x", regs.PC()) } } - fmt.Fprint(os.Stderr, ": "); - fmt.Fprintf(os.Stderr, format, args); - fmt.Fprint(os.Stderr, "\n"); + fmt.Fprint(os.Stderr, ": ") + fmt.Fprintf(os.Stderr, format, args) + fmt.Fprint(os.Stderr, "\n") } func (t *thread) warn(format string, args ...) { - logLock.Lock(); - defer logLock.Unlock(); - fmt.Fprintf(os.Stderr, "Thread %d: WARNING ", t.tid); - fmt.Fprintf(os.Stderr, format, args); - fmt.Fprint(os.Stderr, "\n"); + logLock.Lock() + defer logLock.Unlock() + fmt.Fprintf(os.Stderr, "Thread %d: WARNING ", t.tid) + fmt.Fprintf(os.Stderr, format, args) + fmt.Fprint(os.Stderr, "\n") } func (p *process) logTrace(format string, args ...) { if !trace { return } - logLock.Lock(); - defer logLock.Unlock(); - fmt.Fprintf(os.Stderr, "Process %d: ", p.pid); - fmt.Fprintf(os.Stderr, format, args); - fmt.Fprint(os.Stderr, "\n"); + logLock.Lock() + defer logLock.Unlock() + fmt.Fprintf(os.Stderr, "Process %d: ", p.pid) + fmt.Fprintf(os.Stderr, format, args) + fmt.Fprint(os.Stderr, "\n") } /* @@ -334,7 +334,7 @@ func (p *process) someStoppedThread() *thread { return t } } - return nil; + return nil } // someRunningThread returns a running thread from the process. @@ -347,7 +347,7 @@ func (p *process) someRunningThread() *thread { return t } } - return nil; + return nil } /* @@ -358,32 +358,32 @@ func (p *process) someRunningThread() *thread { // // Must be called from the monitor thread. func (p *process) installBreakpoints() os.Error { - n := 0; - main := p.someStoppedThread(); + n := 0 + main := p.someStoppedThread() for _, b := range p.breakpoints { if b.olddata != nil { continue } - b.olddata = make([]byte, len(bpinst386)); - _, err := main.ptracePeekText(uintptr(b.pc), b.olddata); + b.olddata = make([]byte, len(bpinst386)) + _, err := main.ptracePeekText(uintptr(b.pc), b.olddata) if err != nil { - b.olddata = nil; - return err; + b.olddata = nil + return err } - _, err = main.ptracePokeText(uintptr(b.pc), bpinst386); + _, err = main.ptracePokeText(uintptr(b.pc), bpinst386) if err != nil { - b.olddata = nil; - return err; + b.olddata = nil + return err } - n++; + n++ } if n > 0 { p.logTrace("installed %d/%d breakpoints", n, len(p.breakpoints)) } - return nil; + return nil } // uninstallBreakpoints removes the installed breakpoints from p. @@ -393,25 +393,25 @@ func (p *process) uninstallBreakpoints() os.Error { if len(p.threads) == 0 { return nil } - n := 0; - main := p.someStoppedThread(); + n := 0 + main := p.someStoppedThread() for _, b := range p.breakpoints { if b.olddata == nil { continue } - _, err := main.ptracePokeText(uintptr(b.pc), b.olddata); + _, err := main.ptracePokeText(uintptr(b.pc), b.olddata) if err != nil { return err } - b.olddata = nil; - n++; + b.olddata = nil + n++ } if n > 0 { p.logTrace("uninstalled %d/%d breakpoints", n, len(p.breakpoints)) } - return nil; + return nil } /* @@ -425,17 +425,17 @@ func (p *process) uninstallBreakpoints() os.Error { // event. func (t *thread) wait() { for { - var ev debugEvent; - ev.t = t; - t.logTrace("beginning wait"); - ev.Waitmsg, ev.err = os.Wait(t.tid, syscall.WALL); + var ev debugEvent + ev.t = t + t.logTrace("beginning wait") + ev.Waitmsg, ev.err = os.Wait(t.tid, syscall.WALL) if ev.err == nil && ev.Pid != t.tid { panic("Wait returned pid ", ev.Pid, " wanted ", t.tid) } if ev.StopSignal() == syscall.SIGSTOP && t.ignoreNextSigstop { // Spurious SIGSTOP. See Thread.Stop(). - t.ignoreNextSigstop = false; - err := t.ptraceCont(); + t.ignoreNextSigstop = false + err := t.ptraceCont() if err == nil { continue } @@ -447,8 +447,8 @@ func (t *thread) wait() { // The monitor exited break } - t.proc.debugEvents <- &ev; - break; + t.proc.debugEvents <- &ev + break } } @@ -457,9 +457,9 @@ func (t *thread) wait() { // // Must be called from the monitor thread. func (t *thread) setState(newState threadState) { - oldState := t.state; - t.state = newState; - t.logTrace("state %v -> %v", oldState, newState); + oldState := t.state + t.state = newState + t.logTrace("state %v -> %v", oldState, newState) if !oldState.isRunning() && (newState.isRunning() || newState.isZombie()) { // Start waiting on this thread @@ -467,23 +467,23 @@ func (t *thread) setState(newState threadState) { } // Invoke state change handlers - handlers := t.proc.transitionHandlers; + handlers := t.proc.transitionHandlers if handlers.Len() == 0 { return } - t.proc.transitionHandlers = new(vector.Vector); + t.proc.transitionHandlers = new(vector.Vector) for _, h := range handlers.Data() { - h := h.(*transitionHandler); - h.handle(t, oldState, newState); + h := h.(*transitionHandler) + h.handle(t, oldState, newState) } } // sendSigstop sends a SIGSTOP to this thread. func (t *thread) sendSigstop() os.Error { - t.logTrace("sending SIGSTOP"); - err := syscall.Tgkill(t.proc.pid, t.tid, syscall.SIGSTOP); - return os.NewSyscallError("tgkill", err); + t.logTrace("sending SIGSTOP") + err := syscall.Tgkill(t.proc.pid, t.tid, syscall.SIGSTOP) + return os.NewSyscallError("tgkill", err) } // stopAsync sends SIGSTOP to all threads in state 'running'. @@ -492,14 +492,14 @@ func (t *thread) sendSigstop() os.Error { func (p *process) stopAsync() os.Error { for _, t := range p.threads { if t.state == running { - err := t.sendSigstop(); + err := t.sendSigstop() if err != nil { return err } - t.setState(stopping); + t.setState(stopping) } } - return nil; + return nil } // doTrap handles SIGTRAP debug events with a cause of 0. These can @@ -508,7 +508,7 @@ func (p *process) stopAsync() os.Error { // // TODO(austin) I think we also get this on an execve syscall. func (ev *debugEvent) doTrap() (threadState, os.Error) { - t := ev.t; + t := ev.t if t.state == singleStepping { return stopped, nil @@ -517,13 +517,13 @@ func (ev *debugEvent) doTrap() (threadState, os.Error) { // Hit a breakpoint. Linux leaves the program counter after // the breakpoint. If this is an installed breakpoint, we // need to back the PC up to the breakpoint PC. - var regs syscall.PtraceRegs; - err := t.ptraceGetRegs(®s); + var regs syscall.PtraceRegs + err := t.ptraceGetRegs(®s) if err != nil { return stopped, err } - b, ok := t.proc.breakpoints[uintptr(regs.PC())-uintptr(len(bpinst386))]; + b, ok := t.proc.breakpoints[uintptr(regs.PC())-uintptr(len(bpinst386))] if !ok { // We must have hit a breakpoint that was actually in // the program. Leave the IP where it is so we don't @@ -532,38 +532,38 @@ func (ev *debugEvent) doTrap() (threadState, os.Error) { return stoppedSignal, nil } - t.breakpoint = b; - t.logTrace("at breakpoint %v, backing up PC from %#x", b, regs.PC()); + t.breakpoint = b + t.logTrace("at breakpoint %v, backing up PC from %#x", b, regs.PC()) - regs.SetPC(uint64(b.pc)); - err = t.ptraceSetRegs(®s); + regs.SetPC(uint64(b.pc)) + err = t.ptraceSetRegs(®s) if err != nil { return stopped, err } - return stoppedBreakpoint, nil; + return stoppedBreakpoint, nil } // doPtraceClone handles SIGTRAP debug events with a PTRACE_EVENT_CLONE // cause. It initializes the new thread, adds it to the process, and // returns the appropriate thread state for the existing thread. func (ev *debugEvent) doPtraceClone() (threadState, os.Error) { - t := ev.t; + t := ev.t // Get the TID of the new thread - tid, err := t.ptraceGetEventMsg(); + tid, err := t.ptraceGetEventMsg() if err != nil { return stopped, err } - nt, err := t.proc.newThread(int(tid), syscall.SIGSTOP, true); + nt, err := t.proc.newThread(int(tid), syscall.SIGSTOP, true) if err != nil { return stopped, err } // Remember the thread - t.newThread = nt; + t.newThread = nt - return stoppedThreadCreate, nil; + return stoppedThreadCreate, nil } // doPtraceExit handles SIGTRAP debug events with a PTRACE_EVENT_EXIT @@ -571,15 +571,15 @@ func (ev *debugEvent) doPtraceClone() (threadState, os.Error) { // the process. A later WIFEXITED debug event will remove it from the // process. func (ev *debugEvent) doPtraceExit() (threadState, os.Error) { - t := ev.t; + t := ev.t // Get exit status - exitStatus, err := t.ptraceGetEventMsg(); + exitStatus, err := t.ptraceGetEventMsg() if err != nil { return stopped, err } - ws := syscall.WaitStatus(exitStatus); - t.logTrace("exited with %v", ws); + ws := syscall.WaitStatus(exitStatus) + t.logTrace("exited with %v", ws) switch { case ws.Exited(): t.exitStatus = ws.ExitStatus() @@ -589,7 +589,7 @@ func (ev *debugEvent) doPtraceExit() (threadState, os.Error) { // We still need to continue this thread and wait on this // thread's WIFEXITED event. We'll delete it then. - return stoppedExiting, nil; + return stoppedExiting, nil } // process handles a debug event. It modifies any thread or process @@ -600,20 +600,20 @@ func (ev *debugEvent) process() os.Error { return ev.err } - t := ev.t; - t.exitStatus = -1; - t.signal = -1; + t := ev.t + t.exitStatus = -1 + t.signal = -1 // Decode wait status. - var state threadState; + var state threadState switch { case ev.Stopped(): - state = stoppedSignal; - t.signal = ev.StopSignal(); - t.logTrace("stopped with %v", ev); + state = stoppedSignal + t.signal = ev.StopSignal() + t.logTrace("stopped with %v", ev) if ev.StopSignal() == syscall.SIGTRAP { // What caused the debug trap? - var err os.Error; + var err os.Error switch cause := ev.TrapCause(); cause { case 0: // Breakpoint or single stepping @@ -630,25 +630,25 @@ func (ev *debugEvent) process() os.Error { } if err != nil { - t.setState(stopped); - t.warn("failed to handle trap %v: %v", ev, err); + t.setState(stopped) + t.warn("failed to handle trap %v: %v", ev, err) } } case ev.Exited(): - state = exited; - t.proc.threads[t.tid] = nil, false; - t.logTrace("exited %v", ev); + state = exited + t.proc.threads[t.tid] = nil, false + t.logTrace("exited %v", ev) // We should have gotten the exit status in // PTRACE_EVENT_EXIT, but just in case. - t.exitStatus = ev.ExitStatus(); + t.exitStatus = ev.ExitStatus() case ev.Signaled(): - state = exited; - t.proc.threads[t.tid] = nil, false; - t.logTrace("signaled %v", ev); + state = exited + t.proc.threads[t.tid] = nil, false + t.logTrace("signaled %v", ev) // Again, this should be redundant. - t.signal = ev.Signal(); + t.signal = ev.Signal() default: panic(fmt.Sprintf("Unexpected wait status %v", ev.Waitmsg)) @@ -666,14 +666,14 @@ func (ev *debugEvent) process() os.Error { // TODO(austin) If we're in state stopping and get a SIGSTOP, // set state stopped instead of stoppedSignal. - t.setState(state); + t.setState(state) if t.proc.someRunningThread() == nil { // Nothing is running, uninstall breakpoints return t.proc.uninstallBreakpoints() } // Stop any other running threads - return t.proc.stopAsync(); + return t.proc.stopAsync() } // onStop adds a handler for state transitions from running to @@ -686,15 +686,15 @@ func (t *thread) onStop(handle func(), onErr func(os.Error)) { // stepping all threads during a continue. Maybe move // transitionHandlers to the thread, or have both per-thread // and per-process transition handlers. - h := &transitionHandler{nil, onErr}; + h := &transitionHandler{nil, onErr} h.handle = func(st *thread, old, new threadState) { if t == st && old.isRunning() && !new.isRunning() { handle() } else { t.proc.transitionHandlers.Push(h) } - }; - t.proc.transitionHandlers.Push(h); + } + t.proc.transitionHandlers.Push(h) } /* @@ -704,17 +704,17 @@ func (t *thread) onStop(handle func(), onErr func(os.Error)) { // monitor handles debug events and debug requests for p, exiting when // there are no threads left in p. func (p *process) monitor() { - var err os.Error; + var err os.Error // Linux requires that all ptrace calls come from the thread // that originally attached. Prevent the Go scheduler from // migrating us to other OS threads. - runtime.LockOSThread(); - defer runtime.UnlockOSThread(); + runtime.LockOSThread() + defer runtime.UnlockOSThread() - hadThreads := false; + hadThreads := false for err == nil { - p.ready <- true; + p.ready <- true select { case event := <-p.debugEvents: err = event.process() @@ -728,8 +728,8 @@ func (p *process) monitor() { if len(p.threads) == 0 { if err == nil && hadThreads { - p.logTrace("no more threads; monitor exiting"); - err = ProcessExited{}; + p.logTrace("no more threads; monitor exiting") + err = ProcessExited{} } } else { hadThreads = true @@ -739,13 +739,13 @@ func (p *process) monitor() { // Abort waiting handlers // TODO(austin) How do I stop the wait threads? for _, h := range p.transitionHandlers.Data() { - h := h.(*transitionHandler); - h.onErr(err); + h := h.(*transitionHandler) + h.onErr(err) } // Indicate that the monitor cannot receive any more messages - p.err = err; - close(p.ready); + p.err = err + close(p.ready) } // do executes f in the monitor thread (and, thus, atomically with @@ -756,9 +756,9 @@ func (p *process) do(f func() os.Error) os.Error { if !<-p.ready { return p.err } - req := &debugReq{f, make(chan os.Error)}; - p.debugReqs <- req; - return <-req.res; + req := &debugReq{f, make(chan os.Error)} + p.debugReqs <- req + return <-req.res } // stopMonitor stops the monitor with the given error. If the monitor @@ -777,14 +777,14 @@ func (p *process) stopMonitor(err os.Error) { */ func (t *thread) Regs() (Regs, os.Error) { - var regs syscall.PtraceRegs; + var regs syscall.PtraceRegs err := t.proc.do(func() os.Error { if !t.state.isStopped() { return &badState{t, "cannot get registers", t.state} } - return t.ptraceGetRegs(®s); - }); + return t.ptraceGetRegs(®s) + }) if err != nil { return nil, err } @@ -794,42 +794,42 @@ func (t *thread) Regs() (Regs, os.Error) { if !t.state.isStopped() { return &badState{t, "cannot get registers", t.state} } - return t.ptraceSetRegs(r); + return t.ptraceSetRegs(r) }) - }; - return newRegs(®s, setter), nil; + } + return newRegs(®s, setter), nil } func (t *thread) Peek(addr Word, out []byte) (int, os.Error) { - var c int; + var c int err := t.proc.do(func() os.Error { if !t.state.isStopped() { return &badState{t, "cannot peek text", t.state} } - var err os.Error; - c, err = t.ptracePeekText(uintptr(addr), out); - return err; - }); + var err os.Error + c, err = t.ptracePeekText(uintptr(addr), out) + return err + }) - return c, err; + return c, err } func (t *thread) Poke(addr Word, out []byte) (int, os.Error) { - var c int; + var c int err := t.proc.do(func() os.Error { if !t.state.isStopped() { return &badState{t, "cannot poke text", t.state} } - var err os.Error; - c, err = t.ptracePokeText(uintptr(addr), out); - return err; - }); + var err os.Error + c, err = t.ptracePokeText(uintptr(addr), out) + return err + }) - return c, err; + return c, err } // stepAsync starts this thread single stepping. When the single step @@ -841,30 +841,30 @@ func (t *thread) stepAsync(ready chan os.Error) os.Error { if err := t.ptraceStep(); err != nil { return err } - t.setState(singleStepping); + t.setState(singleStepping) t.onStop(func() { ready <- nil }, - func(err os.Error) { ready <- err }); - return nil; + func(err os.Error) { ready <- err }) + return nil } func (t *thread) Step() os.Error { - t.logTrace("Step {"); - defer t.logTrace("}"); + t.logTrace("Step {") + defer t.logTrace("}") - ready := make(chan os.Error); + ready := make(chan os.Error) err := t.proc.do(func() os.Error { if !t.state.isStopped() { return &badState{t, "cannot single step", t.state} } - return t.stepAsync(ready); - }); + return t.stepAsync(ready) + }) if err != nil { return err } - err = <-ready; - return err; + err = <-ready + return err } // TODO(austin) We should probably get this via C's strsignal. @@ -884,11 +884,11 @@ func sigName(signal int) string { if signal < 0 || signal >= len(sigNames) { return "<invalid>" } - return sigNames[signal]; + return sigNames[signal] } func (t *thread) Stopped() (Cause, os.Error) { - var c Cause; + var c Cause err := t.proc.do(func() os.Error { switch t.state { case stopped: @@ -913,35 +913,35 @@ func (t *thread) Stopped() (Cause, os.Error) { default: return &badState{t, "cannot get stop cause", t.state} } - return nil; - }); + return nil + }) if err != nil { return nil, err } - return c, nil; + return c, nil } func (p *process) Threads() []Thread { - var res []Thread; + var res []Thread p.do(func() os.Error { - res = make([]Thread, len(p.threads)); - i := 0; + res = make([]Thread, len(p.threads)) + i := 0 for _, t := range p.threads { // Exclude zombie threads. - st := t.state; + st := t.state if st == exiting || st == exited || st == detached { continue } - res[i] = t; - i++; + res[i] = t + i++ } - res = res[0:i]; - return nil; - }); - return res; + res = res[0:i] + return nil + }) + return res } func (p *process) AddBreakpoint(pc Word) os.Error { @@ -952,8 +952,8 @@ func (p *process) AddBreakpoint(pc Word) os.Error { if _, ok := p.breakpoints[uintptr(pc)]; ok { return breakpointExistsError(pc) } - p.breakpoints[uintptr(pc)] = &breakpoint{pc: uintptr(pc)}; - return nil; + p.breakpoints[uintptr(pc)] = &breakpoint{pc: uintptr(pc)} + return nil }) } @@ -965,22 +965,22 @@ func (p *process) RemoveBreakpoint(pc Word) os.Error { if _, ok := p.breakpoints[uintptr(pc)]; !ok { return noBreakpointError(pc) } - p.breakpoints[uintptr(pc)] = nil, false; - return nil; + p.breakpoints[uintptr(pc)] = nil, false + return nil }) } func (p *process) Continue() os.Error { // Single step any threads that are stopped at breakpoints so // we can reinstall breakpoints. - var ready chan os.Error; - count := 0; + var ready chan os.Error + count := 0 err := p.do(func() os.Error { // We make the ready channel big enough to hold all // ready message so we don't jam up the monitor if we // stop listening (e.g., if there's an error). - ready = make(chan os.Error, len(p.threads)); + ready = make(chan os.Error, len(p.threads)) for _, t := range p.threads { if !t.state.isStopped() { @@ -992,34 +992,34 @@ func (p *process) Continue() os.Error { // it could have been stopped at a breakpoint // for some other reason, or the breakpoint // could have been added since it was stopped. - var regs syscall.PtraceRegs; - err := t.ptraceGetRegs(®s); + var regs syscall.PtraceRegs + err := t.ptraceGetRegs(®s) if err != nil { return err } if b, ok := p.breakpoints[uintptr(regs.PC())]; ok { - t.logTrace("stepping over breakpoint %v", b); + t.logTrace("stepping over breakpoint %v", b) if err := t.stepAsync(ready); err != nil { return err } - count++; + count++ } } - return nil; - }); + return nil + }) if err != nil { - p.stopMonitor(err); - return err; + p.stopMonitor(err) + return err } // Wait for single stepping threads for count > 0 { - err = <-ready; + err = <-ready if err != nil { - p.stopMonitor(err); - return err; + p.stopMonitor(err) + return err } - count--; + count-- } // Continue all threads @@ -1029,18 +1029,18 @@ func (p *process) Continue() os.Error { } for _, t := range p.threads { - var err os.Error; + var err os.Error switch { case !t.state.isStopped(): continue case t.state == stoppedSignal && t.signal != syscall.SIGSTOP && t.signal != syscall.SIGTRAP: - t.logTrace("continuing with signal %d", t.signal); - err = t.ptraceContWithSignal(t.signal); + t.logTrace("continuing with signal %d", t.signal) + err = t.ptraceContWithSignal(t.signal) default: - t.logTrace("continuing"); - err = t.ptraceCont(); + t.logTrace("continuing") + err = t.ptraceCont() } if err != nil { return err @@ -1051,59 +1051,59 @@ func (p *process) Continue() os.Error { t.setState(running) } } - return nil; - }); + return nil + }) if err != nil { // TODO(austin) Do we need to stop the monitor with // this error atomically with the do-routine above? - p.stopMonitor(err); - return err; + p.stopMonitor(err) + return err } - return nil; + return nil } func (p *process) WaitStop() os.Error { // We need a non-blocking ready channel for the case where all // threads are already stopped. - ready := make(chan os.Error, 1); + ready := make(chan os.Error, 1) err := p.do(func() os.Error { // Are all of the threads already stopped? if p.someRunningThread() == nil { - ready <- nil; - return nil; + ready <- nil + return nil } // Monitor state transitions - h := &transitionHandler{}; + h := &transitionHandler{} h.handle = func(st *thread, old, new threadState) { if !new.isRunning() { if p.someRunningThread() == nil { - ready <- nil; - return; + ready <- nil + return } } - p.transitionHandlers.Push(h); - }; - h.onErr = func(err os.Error) { ready <- err }; - p.transitionHandlers.Push(h); - return nil; - }); + p.transitionHandlers.Push(h) + } + h.onErr = func(err os.Error) { ready <- err } + p.transitionHandlers.Push(h) + return nil + }) if err != nil { return err } - return <-ready; + return <-ready } func (p *process) Stop() os.Error { - err := p.do(func() os.Error { return p.stopAsync() }); + err := p.do(func() os.Error { return p.stopAsync() }) if err != nil { return err } - return p.WaitStop(); + return p.WaitStop() } func (p *process) Detach() os.Error { @@ -1123,13 +1123,13 @@ func (p *process) Detach() os.Error { return err } } - t.setState(detached); - p.threads[pid] = nil, false; + t.setState(detached) + p.threads[pid] = nil, false } - return nil; - }); + return nil + }) // TODO(austin) Wait for monitor thread to exit? - return err; + return err } // newThread creates a new thread object and waits for its initial @@ -1138,11 +1138,11 @@ func (p *process) Detach() os.Error { // // Must be run from the monitor thread. func (p *process) newThread(tid int, signal int, cloned bool) (*thread, os.Error) { - t := &thread{tid: tid, proc: p, state: stopped}; + t := &thread{tid: tid, proc: p, state: stopped} // Get the signal from the thread // TODO(austin) Thread might already be stopped if we're attaching. - w, err := os.Wait(tid, syscall.WALL); + w, err := os.Wait(tid, syscall.WALL) if err != nil { return nil, err } @@ -1151,59 +1151,59 @@ func (p *process) newThread(tid int, signal int, cloned bool) (*thread, os.Error } if !cloned { - err = t.ptraceSetOptions(syscall.PTRACE_O_TRACECLONE | syscall.PTRACE_O_TRACEEXIT); + err = t.ptraceSetOptions(syscall.PTRACE_O_TRACECLONE | syscall.PTRACE_O_TRACEEXIT) if err != nil { return nil, err } } - p.threads[tid] = t; + p.threads[tid] = t - return t, nil; + return t, nil } // attachThread attaches a running thread to the process. // // Must NOT be run from the monitor thread. func (p *process) attachThread(tid int) (*thread, os.Error) { - p.logTrace("attaching to thread %d", tid); - var thr *thread; + p.logTrace("attaching to thread %d", tid) + var thr *thread err := p.do(func() os.Error { - errno := syscall.PtraceAttach(tid); + errno := syscall.PtraceAttach(tid) if errno != 0 { return os.NewSyscallError("ptrace(ATTACH)", errno) } - var err os.Error; - thr, err = p.newThread(tid, syscall.SIGSTOP, false); - return err; - }); - return thr, err; + var err os.Error + thr, err = p.newThread(tid, syscall.SIGSTOP, false) + return err + }) + return thr, err } // attachAllThreads attaches to all threads in a process. func (p *process) attachAllThreads() os.Error { - taskPath := "/proc/" + strconv.Itoa(p.pid) + "/task"; - taskDir, err := os.Open(taskPath, os.O_RDONLY, 0); + taskPath := "/proc/" + strconv.Itoa(p.pid) + "/task" + taskDir, err := os.Open(taskPath, os.O_RDONLY, 0) if err != nil { return err } - defer taskDir.Close(); + defer taskDir.Close() // We stop threads as we attach to them; however, because new // threads can appear while we're looping over all of them, we // have to repeatly scan until we know we're attached to all // of them. for again := true; again; { - again = false; + again = false - tids, err := taskDir.Readdirnames(-1); + tids, err := taskDir.Readdirnames(-1) if err != nil { return err } for _, tidStr := range tids { - tid, err := strconv.Atoi(tidStr); + tid, err := strconv.Atoi(tidStr) if err != nil { return err } @@ -1211,39 +1211,39 @@ func (p *process) attachAllThreads() os.Error { continue } - _, err = p.attachThread(tid); + _, err = p.attachThread(tid) if err != nil { // There could have been a race, or // this process could be a zobmie. - statFile, err2 := ioutil.ReadFile(taskPath + "/" + tidStr + "/stat"); + statFile, err2 := ioutil.ReadFile(taskPath + "/" + tidStr + "/stat") if err2 != nil { switch err2 := err2.(type) { case *os.PathError: if err2.Error == os.ENOENT { // Raced with thread exit - p.logTrace("raced with thread %d exit", tid); - continue; + p.logTrace("raced with thread %d exit", tid) + continue } } // Return the original error - return err; + return err } - statParts := strings.Split(string(statFile), " ", 4); + statParts := strings.Split(string(statFile), " ", 4) if len(statParts) > 2 && statParts[2] == "Z" { // tid is a zombie - p.logTrace("thread %d is a zombie", tid); - continue; + p.logTrace("thread %d is a zombie", tid) + continue } // Return the original error - return err; + return err } - again = true; + again = true } } - return nil; + return nil } // newProcess creates a new process object and starts its monitor thread. @@ -1257,37 +1257,37 @@ func newProcess(pid int) *process { debugReqs: make(chan *debugReq), stopReq: make(chan os.Error), transitionHandlers: new(vector.Vector), - }; + } - go p.monitor(); + go p.monitor() - return p; + return p } // Attach attaches to process pid and stops all of its threads. func Attach(pid int) (Process, os.Error) { - p := newProcess(pid); + p := newProcess(pid) // Attach to all threads - err := p.attachAllThreads(); + err := p.attachAllThreads() if err != nil { - p.Detach(); + p.Detach() // TODO(austin) Detach stopped the monitor already //p.stopMonitor(err); - return nil, err; + return nil, err } - return p, nil; + return p, nil } // ForkExec forks the current process and execs argv0, stopping the // new process after the exec syscall. See os.ForkExec for additional // details. func ForkExec(argv0 string, argv []string, envv []string, dir string, fd []*os.File) (Process, os.Error) { - p := newProcess(-1); + p := newProcess(-1) // Create array of integer (system) fds. - intfd := make([]int, len(fd)); + intfd := make([]int, len(fd)) for i, f := range fd { if f == nil { intfd[i] = -1 @@ -1298,20 +1298,20 @@ func ForkExec(argv0 string, argv []string, envv []string, dir string, fd []*os.F // Fork from the monitor thread so we get the right tracer pid. err := p.do(func() os.Error { - pid, errno := syscall.PtraceForkExec(argv0, argv, envv, dir, intfd); + pid, errno := syscall.PtraceForkExec(argv0, argv, envv, dir, intfd) if errno != 0 { return &os.PathError{"fork/exec", argv0, os.Errno(errno)} } - p.pid = pid; + p.pid = pid // The process will raise SIGTRAP when it reaches execve. - _, err := p.newThread(pid, syscall.SIGTRAP, false); - return err; - }); + _, err := p.newThread(pid, syscall.SIGTRAP, false) + return err + }) if err != nil { - p.stopMonitor(err); - return nil, err; + p.stopMonitor(err) + return nil, err } - return p, nil; + return p, nil } diff --git a/src/pkg/debug/proc/proc_nacl.go b/src/pkg/debug/proc/proc_nacl.go index c4f606739..be26bbf18 100644 --- a/src/pkg/debug/proc/proc_nacl.go +++ b/src/pkg/debug/proc/proc_nacl.go @@ -5,8 +5,8 @@ package proc import ( - "os"; - "syscall"; + "os" + "syscall" ) // Process tracing is not supported on Native Client. diff --git a/src/pkg/debug/proc/regs_linux_386.go b/src/pkg/debug/proc/regs_linux_386.go index abeb45f4b..7c5478d86 100644 --- a/src/pkg/debug/proc/regs_linux_386.go +++ b/src/pkg/debug/proc/regs_linux_386.go @@ -5,14 +5,14 @@ package proc import ( - "os"; - "strconv"; - "syscall"; + "os" + "strconv" + "syscall" ) type _386Regs struct { - syscall.PtraceRegs; - setter func(*syscall.PtraceRegs) os.Error; + syscall.PtraceRegs + setter func(*syscall.PtraceRegs) os.Error } var names = [...]string{ @@ -34,11 +34,11 @@ var names = [...]string{ "gs", } -func (r *_386Regs) PC() Word { return Word(r.Eip) } +func (r *_386Regs) PC() Word { return Word(r.Eip) } func (r *_386Regs) SetPC(val Word) os.Error { - r.Eip = int32(val); - return r.setter(&r.PtraceRegs); + r.Eip = int32(val) + return r.setter(&r.PtraceRegs) } func (r *_386Regs) Link() Word { @@ -46,16 +46,16 @@ func (r *_386Regs) Link() Word { panic("No link register") } -func (r *_386Regs) SetLink(val Word) os.Error { panic("No link register") } +func (r *_386Regs) SetLink(val Word) os.Error { panic("No link register") } -func (r *_386Regs) SP() Word { return Word(r.Esp) } +func (r *_386Regs) SP() Word { return Word(r.Esp) } func (r *_386Regs) SetSP(val Word) os.Error { - r.Esp = int32(val); - return r.setter(&r.PtraceRegs); + r.Esp = int32(val) + return r.setter(&r.PtraceRegs) } -func (r *_386Regs) Names() []string { return &names } +func (r *_386Regs) Names() []string { return &names } func (r *_386Regs) Get(i int) Word { switch i { @@ -92,7 +92,7 @@ func (r *_386Regs) Get(i int) Word { case 15: return Word(r.Gs) } - panic("invalid register index ", strconv.Itoa(i)); + panic("invalid register index ", strconv.Itoa(i)) } func (r *_386Regs) Set(i int, val Word) os.Error { @@ -132,12 +132,12 @@ func (r *_386Regs) Set(i int, val Word) os.Error { default: panic("invalid register index ", strconv.Itoa(i)) } - return r.setter(&r.PtraceRegs); + return r.setter(&r.PtraceRegs) } func newRegs(regs *syscall.PtraceRegs, setter func(*syscall.PtraceRegs) os.Error) Regs { - res := _386Regs{}; - res.PtraceRegs = *regs; - res.setter = setter; - return &res; + res := _386Regs{} + res.PtraceRegs = *regs + res.setter = setter + return &res } diff --git a/src/pkg/debug/proc/regs_linux_amd64.go b/src/pkg/debug/proc/regs_linux_amd64.go index 63083a948..b070b7714 100644 --- a/src/pkg/debug/proc/regs_linux_amd64.go +++ b/src/pkg/debug/proc/regs_linux_amd64.go @@ -5,14 +5,14 @@ package proc import ( - "os"; - "strconv"; - "syscall"; + "os" + "strconv" + "syscall" ) type amd64Regs struct { - syscall.PtraceRegs; - setter func(*syscall.PtraceRegs) os.Error; + syscall.PtraceRegs + setter func(*syscall.PtraceRegs) os.Error } var names = [...]string{ @@ -48,11 +48,11 @@ var names = [...]string{ //"gs_base", } -func (r *amd64Regs) PC() Word { return Word(r.Rip) } +func (r *amd64Regs) PC() Word { return Word(r.Rip) } func (r *amd64Regs) SetPC(val Word) os.Error { - r.Rip = uint64(val); - return r.setter(&r.PtraceRegs); + r.Rip = uint64(val) + return r.setter(&r.PtraceRegs) } func (r *amd64Regs) Link() Word { @@ -64,14 +64,14 @@ func (r *amd64Regs) SetLink(val Word) os.Error { panic("No link register") } -func (r *amd64Regs) SP() Word { return Word(r.Rsp) } +func (r *amd64Regs) SP() Word { return Word(r.Rsp) } func (r *amd64Regs) SetSP(val Word) os.Error { - r.Rsp = uint64(val); - return r.setter(&r.PtraceRegs); + r.Rsp = uint64(val) + return r.setter(&r.PtraceRegs) } -func (r *amd64Regs) Names() []string { return &names } +func (r *amd64Regs) Names() []string { return &names } func (r *amd64Regs) Get(i int) Word { switch i { @@ -124,7 +124,7 @@ func (r *amd64Regs) Get(i int) Word { case 23: return Word(r.Gs) } - panic("invalid register index ", strconv.Itoa(i)); + panic("invalid register index ", strconv.Itoa(i)) } func (r *amd64Regs) Set(i int, val Word) os.Error { @@ -180,12 +180,12 @@ func (r *amd64Regs) Set(i int, val Word) os.Error { default: panic("invalid register index ", strconv.Itoa(i)) } - return r.setter(&r.PtraceRegs); + return r.setter(&r.PtraceRegs) } func newRegs(regs *syscall.PtraceRegs, setter func(*syscall.PtraceRegs) os.Error) Regs { - res := amd64Regs{}; - res.PtraceRegs = *regs; - res.setter = setter; - return &res; + res := amd64Regs{} + res.PtraceRegs = *regs + res.setter = setter + return &res } diff --git a/src/pkg/debug/proc/regs_linux_arm.go b/src/pkg/debug/proc/regs_linux_arm.go index e58ab388b..ec78cbcf2 100644 --- a/src/pkg/debug/proc/regs_linux_arm.go +++ b/src/pkg/debug/proc/regs_linux_arm.go @@ -5,35 +5,35 @@ package proc import ( - "os"; - "syscall"; + "os" + "syscall" ) // TODO(kaib): add support type armRegs struct{} -func (r *armRegs) PC() Word { return Word(0) } +func (r *armRegs) PC() Word { return Word(0) } -func (r *armRegs) SetPC(val Word) os.Error { return nil } +func (r *armRegs) SetPC(val Word) os.Error { return nil } -func (r *armRegs) Link() Word { return Word(0) } +func (r *armRegs) Link() Word { return Word(0) } -func (r *armRegs) SetLink(val Word) os.Error { return nil } +func (r *armRegs) SetLink(val Word) os.Error { return nil } -func (r *armRegs) SP() Word { return Word(0) } +func (r *armRegs) SP() Word { return Word(0) } -func (r *armRegs) SetSP(val Word) os.Error { return nil } +func (r *armRegs) SetSP(val Word) os.Error { return nil } -func (r *armRegs) Names() []string { return nil } +func (r *armRegs) Names() []string { return nil } -func (r *armRegs) Get(i int) Word { return Word(0) } +func (r *armRegs) Get(i int) Word { return Word(0) } func (r *armRegs) Set(i int, val Word) os.Error { return nil } func newRegs(regs *syscall.PtraceRegs, setter func(*syscall.PtraceRegs) os.Error) Regs { - res := armRegs{}; - return &res; + res := armRegs{} + return &res } diff --git a/src/pkg/ebnf/ebnf.go b/src/pkg/ebnf/ebnf.go index 08f3b8c7f..898a48173 100644 --- a/src/pkg/ebnf/ebnf.go +++ b/src/pkg/ebnf/ebnf.go @@ -23,12 +23,12 @@ package ebnf import ( - "container/vector"; - "go/scanner"; - "go/token"; - "os"; - "unicode"; - "utf8"; + "container/vector" + "go/scanner" + "go/token" + "os" + "unicode" + "utf8" ) @@ -37,115 +37,115 @@ import ( type ( // An Expression node represents a production expression. - Expression interface { + Expression interface { // Pos is the position of the first character of the syntactic construct - Pos() token.Position; - }; + Pos() token.Position + } // An Alternative node represents a non-empty list of alternative expressions. - Alternative []Expression; // x | y | z + Alternative []Expression // x | y | z // A Sequence node represents a non-empty list of sequential expressions. - Sequence []Expression; // x y z + Sequence []Expression // x y z // A Name node represents a production name. - Name struct { - token.Position; - String string; - }; + Name struct { + token.Position + String string + } // A Token node represents a literal. - Token struct { - token.Position; - String string; - }; + Token struct { + token.Position + String string + } // A List node represents a range of characters. - Range struct { - Begin, End *Token; // begin ... end - }; + Range struct { + Begin, End *Token // begin ... end + } // A Group node represents a grouped expression. - Group struct { - token.Position; - Body Expression; // (body) - }; + Group struct { + token.Position + Body Expression // (body) + } // An Option node represents an optional expression. - Option struct { - token.Position; - Body Expression; // [body] - }; + Option struct { + token.Position + Body Expression // [body] + } // A Repetition node represents a repeated expression. - Repetition struct { - token.Position; - Body Expression; // {body} - }; + Repetition struct { + token.Position + Body Expression // {body} + } // A Production node represents an EBNF production. - Production struct { - Name *Name; - Expr Expression; - }; + Production struct { + Name *Name + Expr Expression + } // A Grammar is a set of EBNF productions. The map // is indexed by production name. // - Grammar map[string]*Production; + Grammar map[string]*Production ) func (x Alternative) Pos() token.Position { - return x[0].Pos() // the parser always generates non-empty Alternative + return x[0].Pos() // the parser always generates non-empty Alternative } func (x Sequence) Pos() token.Position { - return x[0].Pos() // the parser always generates non-empty Sequences + return x[0].Pos() // the parser always generates non-empty Sequences } -func (x Range) Pos() token.Position { return x.Begin.Pos() } +func (x Range) Pos() token.Position { return x.Begin.Pos() } -func (p *Production) Pos() token.Position { return p.Name.Pos() } +func (p *Production) Pos() token.Position { return p.Name.Pos() } // ---------------------------------------------------------------------------- // Grammar verification func isLexical(name string) bool { - ch, _ := utf8.DecodeRuneInString(name); - return !unicode.IsUpper(ch); + ch, _ := utf8.DecodeRuneInString(name) + return !unicode.IsUpper(ch) } type verifier struct { - scanner.ErrorVector; - worklist vector.Vector; - reached Grammar; // set of productions reached from (and including) the root production - grammar Grammar; + scanner.ErrorVector + worklist vector.Vector + reached Grammar // set of productions reached from (and including) the root production + grammar Grammar } func (v *verifier) push(prod *Production) { - name := prod.Name.String; + name := prod.Name.String if _, found := v.reached[name]; !found { - v.worklist.Push(prod); - v.reached[name] = prod; + v.worklist.Push(prod) + v.reached[name] = prod } } func (v *verifier) verifyChar(x *Token) int { - s := x.String; + s := x.String if utf8.RuneCountInString(s) != 1 { - v.Error(x.Pos(), "single char expected, found "+s); - return 0; + v.Error(x.Pos(), "single char expected, found "+s) + return 0 } - ch, _ := utf8.DecodeRuneInString(s); - return ch; + ch, _ := utf8.DecodeRuneInString(s) + return ch } @@ -177,8 +177,8 @@ func (v *verifier) verifyExpr(expr Expression, lexical bool) { case *Token: // nothing to do for now case *Range: - i := v.verifyChar(x.Begin); - j := v.verifyChar(x.End); + i := v.verifyChar(x.Begin) + j := v.verifyChar(x.End) if i >= j { v.Error(x.Pos(), "decreasing character range") } @@ -196,24 +196,24 @@ func (v *verifier) verifyExpr(expr Expression, lexical bool) { func (v *verifier) verify(grammar Grammar, start string) { // find root production - root, found := grammar[start]; + root, found := grammar[start] if !found { - var noPos token.Position; - v.Error(noPos, "no start production "+start); - return; + var noPos token.Position + v.Error(noPos, "no start production "+start) + return } // initialize verifier - v.ErrorVector.Reset(); - v.worklist.Resize(0, 0); - v.reached = make(Grammar); - v.grammar = grammar; + v.ErrorVector.Reset() + v.worklist.Resize(0, 0) + v.reached = make(Grammar) + v.grammar = grammar // work through the worklist - v.push(root); + v.push(root) for v.worklist.Len() > 0 { - prod := v.worklist.Pop().(*Production); - v.verifyExpr(prod.Expr, isLexical(prod.Name.String)); + prod := v.worklist.Pop().(*Production) + v.verifyExpr(prod.Expr, isLexical(prod.Name.String)) } // check if all productions were reached @@ -233,7 +233,7 @@ func (v *verifier) verify(grammar Grammar, start string) { // - lexical productions refer only to other lexical productions // func Verify(grammar Grammar, start string) os.Error { - var v verifier; - v.verify(grammar, start); - return v.GetError(scanner.Sorted); + var v verifier + v.verify(grammar, start) + return v.GetError(scanner.Sorted) } diff --git a/src/pkg/ebnf/ebnf_test.go b/src/pkg/ebnf/ebnf_test.go index a487bdc2c..e6f670530 100644 --- a/src/pkg/ebnf/ebnf_test.go +++ b/src/pkg/ebnf/ebnf_test.go @@ -5,9 +5,9 @@ package ebnf import ( - "io/ioutil"; - "strings"; - "testing"; + "io/ioutil" + "strings" + "testing" ) @@ -41,7 +41,7 @@ var grammars = []string{ func check(t *testing.T, filename string, src []byte) { - grammar, err := Parse(filename, src); + grammar, err := Parse(filename, src) if err != nil { t.Errorf("Parse(%s) failed: %v", src, err) } @@ -65,10 +65,10 @@ var files = []string{ func TestFiles(t *testing.T) { for _, filename := range files { - src, err := ioutil.ReadFile(filename); + src, err := ioutil.ReadFile(filename) if err != nil { t.Fatal(err) } - check(t, filename, src); + check(t, filename, src) } } diff --git a/src/pkg/ebnf/parser.go b/src/pkg/ebnf/parser.go index 5193f8b26..649587879 100644 --- a/src/pkg/ebnf/parser.go +++ b/src/pkg/ebnf/parser.go @@ -5,25 +5,25 @@ package ebnf import ( - "container/vector"; - "go/scanner"; - "go/token"; - "os"; - "strconv"; + "container/vector" + "go/scanner" + "go/token" + "os" + "strconv" ) type parser struct { - scanner.ErrorVector; - scanner scanner.Scanner; - pos token.Position; // token position - tok token.Token; // one token look-ahead - lit []byte; // token literal + scanner.ErrorVector + scanner scanner.Scanner + pos token.Position // token position + tok token.Token // one token look-ahead + lit []byte // token literal } func (p *parser) next() { - p.pos, p.tok, p.lit = p.scanner.Scan(); + p.pos, p.tok, p.lit = p.scanner.Scan() if p.tok.IsKeyword() { // TODO Should keyword mapping always happen outside scanner? // Or should there be a flag to scanner to enable keyword mapping? @@ -33,90 +33,90 @@ func (p *parser) next() { func (p *parser) errorExpected(pos token.Position, msg string) { - msg = "expected " + msg; + msg = "expected " + msg if pos.Offset == p.pos.Offset { // the error happened at the current position; // make the error message more specific - msg += ", found '" + p.tok.String() + "'"; + msg += ", found '" + p.tok.String() + "'" if p.tok.IsLiteral() { msg += " " + string(p.lit) } } - p.Error(pos, msg); + p.Error(pos, msg) } func (p *parser) expect(tok token.Token) token.Position { - pos := p.pos; + pos := p.pos if p.tok != tok { p.errorExpected(pos, "'"+tok.String()+"'") } - p.next(); // make progress in any case - return pos; + p.next() // make progress in any case + return pos } func (p *parser) parseIdentifier() *Name { - pos := p.pos; - name := string(p.lit); - p.expect(token.IDENT); - return &Name{pos, name}; + pos := p.pos + name := string(p.lit) + p.expect(token.IDENT) + return &Name{pos, name} } func (p *parser) parseToken() *Token { - pos := p.pos; - value := ""; + pos := p.pos + value := "" if p.tok == token.STRING { - value, _ = strconv.Unquote(string(p.lit)); + value, _ = strconv.Unquote(string(p.lit)) // Unquote may fail with an error, but only if the scanner found // an illegal string in the first place. In this case the error // has already been reported. - p.next(); + p.next() } else { p.expect(token.STRING) } - return &Token{pos, value}; + return &Token{pos, value} } func (p *parser) parseTerm() (x Expression) { - pos := p.pos; + pos := p.pos switch p.tok { case token.IDENT: x = p.parseIdentifier() case token.STRING: - tok := p.parseToken(); - x = tok; + tok := p.parseToken() + x = tok if p.tok == token.ELLIPSIS { - p.next(); - x = &Range{tok, p.parseToken()}; + p.next() + x = &Range{tok, p.parseToken()} } case token.LPAREN: - p.next(); - x = &Group{pos, p.parseExpression()}; - p.expect(token.RPAREN); + p.next() + x = &Group{pos, p.parseExpression()} + p.expect(token.RPAREN) case token.LBRACK: - p.next(); - x = &Option{pos, p.parseExpression()}; - p.expect(token.RBRACK); + p.next() + x = &Option{pos, p.parseExpression()} + p.expect(token.RBRACK) case token.LBRACE: - p.next(); - x = &Repetition{pos, p.parseExpression()}; - p.expect(token.RBRACE); + p.next() + x = &Repetition{pos, p.parseExpression()} + p.expect(token.RBRACE) } - return x; + return x } func (p *parser) parseSequence() Expression { - var list vector.Vector; + var list vector.Vector for x := p.parseTerm(); x != nil; x = p.parseTerm() { list.Push(x) @@ -131,26 +131,26 @@ func (p *parser) parseSequence() Expression { } // convert list into a sequence - seq := make(Sequence, list.Len()); + seq := make(Sequence, list.Len()) for i := 0; i < list.Len(); i++ { seq[i] = list.At(i).(Expression) } - return seq; + return seq } func (p *parser) parseExpression() Expression { - var list vector.Vector; + var list vector.Vector for { - x := p.parseSequence(); + x := p.parseSequence() if x != nil { list.Push(x) } if p.tok != token.OR { break } - p.next(); + p.next() } // no need for an Alternative node if list.Len() < 2 @@ -162,33 +162,33 @@ func (p *parser) parseExpression() Expression { } // convert list into an Alternative node - alt := make(Alternative, list.Len()); + alt := make(Alternative, list.Len()) for i := 0; i < list.Len(); i++ { alt[i] = list.At(i).(Expression) } - return alt; + return alt } func (p *parser) parseProduction() *Production { - name := p.parseIdentifier(); - p.expect(token.ASSIGN); - expr := p.parseExpression(); - p.expect(token.PERIOD); - return &Production{name, expr}; + name := p.parseIdentifier() + p.expect(token.ASSIGN) + expr := p.parseExpression() + p.expect(token.PERIOD) + return &Production{name, expr} } func (p *parser) parse(filename string, src []byte) Grammar { // initialize parser - p.ErrorVector.Reset(); - p.scanner.Init(filename, src, p, 0); - p.next(); // initializes pos, tok, lit + p.ErrorVector.Reset() + p.scanner.Init(filename, src, p, 0) + p.next() // initializes pos, tok, lit - grammar := make(Grammar); + grammar := make(Grammar) for p.tok != token.EOF { - prod := p.parseProduction(); - name := prod.Name.String; + prod := p.parseProduction() + name := prod.Name.String if _, found := grammar[name]; !found { grammar[name] = prod } else { @@ -196,7 +196,7 @@ func (p *parser) parse(filename string, src []byte) Grammar { } } - return grammar; + return grammar } @@ -206,7 +206,7 @@ func (p *parser) parse(filename string, src []byte) Grammar { // more than once. // func Parse(filename string, src []byte) (Grammar, os.Error) { - var p parser; - grammar := p.parse(filename, src); - return grammar, p.GetError(scanner.Sorted); + var p parser + grammar := p.parse(filename, src) + return grammar, p.GetError(scanner.Sorted) } diff --git a/src/pkg/encoding/ascii85/ascii85.go b/src/pkg/encoding/ascii85/ascii85.go index ac446baf8..67d6ef7ed 100644 --- a/src/pkg/encoding/ascii85/ascii85.go +++ b/src/pkg/encoding/ascii85/ascii85.go @@ -7,9 +7,9 @@ package ascii85 import ( - "io"; - "os"; - "strconv"; + "io" + "os" + "strconv" ) /* @@ -30,74 +30,74 @@ func Encode(dst, src []byte) int { return 0 } - n := 0; + n := 0 for len(src) > 0 { - dst[0] = 0; - dst[1] = 0; - dst[2] = 0; - dst[3] = 0; - dst[4] = 0; + dst[0] = 0 + dst[1] = 0 + dst[2] = 0 + dst[3] = 0 + dst[4] = 0 // Unpack 4 bytes into uint32 to repack into base 85 5-byte. - var v uint32; + var v uint32 switch len(src) { default: - v |= uint32(src[3]); - fallthrough; + v |= uint32(src[3]) + fallthrough case 3: - v |= uint32(src[2]) << 8; - fallthrough; + v |= uint32(src[2]) << 8 + fallthrough case 2: - v |= uint32(src[1]) << 16; - fallthrough; + v |= uint32(src[1]) << 16 + fallthrough case 1: v |= uint32(src[0]) << 24 } // Special case: zero (!!!!!) shortens to z. if v == 0 && len(src) >= 4 { - dst[0] = 'z'; - dst = dst[1:]; - n++; - continue; + dst[0] = 'z' + dst = dst[1:] + n++ + continue } // Otherwise, 5 base 85 digits starting at !. for i := 4; i >= 0; i-- { - dst[i] = '!' + byte(v%85); - v /= 85; + dst[i] = '!' + byte(v%85) + v /= 85 } // If src was short, discard the low destination bytes. - m := 5; + m := 5 if len(src) < 4 { - m -= 4 - len(src); - src = nil; + m -= 4 - len(src) + src = nil } else { src = src[4:] } - dst = dst[m:]; - n += m; + dst = dst[m:] + n += m } - return n; + return n } // MaxEncodedLen returns the maximum length of an encoding of n source bytes. -func MaxEncodedLen(n int) int { return (n + 3) / 4 * 5 } +func MaxEncodedLen(n int) int { return (n + 3) / 4 * 5 } // NewEncoder returns a new ascii85 stream encoder. Data written to // the returned writer will be encoded and then written to w. // Ascii85 encodings operate in 32-bit blocks; when finished // writing, the caller must Close the returned encoder to flush any // trailing partial block. -func NewEncoder(w io.Writer) io.WriteCloser { return &encoder{w: w} } +func NewEncoder(w io.Writer) io.WriteCloser { return &encoder{w: w} } type encoder struct { - err os.Error; - w io.Writer; - buf [4]byte; // buffered data waiting to be encoded - nbuf int; // number of bytes in buf - out [1024]byte; // output buffer + err os.Error + w io.Writer + buf [4]byte // buffered data waiting to be encoded + nbuf int // number of bytes in buf + out [1024]byte // output buffer } func (e *encoder) Write(p []byte) (n int, err os.Error) { @@ -107,47 +107,47 @@ func (e *encoder) Write(p []byte) (n int, err os.Error) { // Leading fringe. if e.nbuf > 0 { - var i int; + var i int for i = 0; i < len(p) && e.nbuf < 4; i++ { - e.buf[e.nbuf] = p[i]; - e.nbuf++; + e.buf[e.nbuf] = p[i] + e.nbuf++ } - n += i; - p = p[i:]; + n += i + p = p[i:] if e.nbuf < 4 { return } - nout := Encode(&e.out, &e.buf); + nout := Encode(&e.out, &e.buf) if _, e.err = e.w.Write(e.out[0:nout]); e.err != nil { return n, e.err } - e.nbuf = 0; + e.nbuf = 0 } // Large interior chunks. for len(p) >= 4 { - nn := len(e.out) / 5 * 4; + nn := len(e.out) / 5 * 4 if nn > len(p) { nn = len(p) } - nn -= nn % 4; + nn -= nn % 4 if nn > 0 { - nout := Encode(&e.out, p[0:nn]); + nout := Encode(&e.out, p[0:nn]) if _, e.err = e.w.Write(e.out[0:nout]); e.err != nil { return n, e.err } } - n += nn; - p = p[nn:]; + n += nn + p = p[nn:] } // Trailing fringe. for i := 0; i < len(p); i++ { e.buf[i] = p[i] } - e.nbuf = len(p); - n += len(p); - return; + e.nbuf = len(p) + n += len(p) + return } // Close flushes any pending output from the encoder. @@ -155,11 +155,11 @@ func (e *encoder) Write(p []byte) (n int, err os.Error) { func (e *encoder) Close() os.Error { // If there's anything left in the buffer, flush it out if e.err == nil && e.nbuf > 0 { - nout := Encode(&e.out, e.buf[0:e.nbuf]); - e.nbuf = 0; - _, e.err = e.w.Write(e.out[0:nout]); + nout := Encode(&e.out, e.buf[0:e.nbuf]) + e.nbuf = 0 + _, e.err = e.w.Write(e.out[0:nout]) } - return e.err; + return e.err } /* @@ -187,8 +187,8 @@ func (e CorruptInputError) String() string { // NewDecoder wraps an io.Reader interface around Decode. // func Decode(dst, src []byte, flush bool) (ndst, nsrc int, err os.Error) { - var v uint32; - var nb int; + var v uint32 + var nb int for i, b := range src { if len(dst)-ndst < 4 { return @@ -197,27 +197,27 @@ func Decode(dst, src []byte, flush bool) (ndst, nsrc int, err os.Error) { case b <= ' ': continue case b == 'z' && nb == 0: - nb = 5; - v = 0; + nb = 5 + v = 0 case '!' <= b && b <= 'u': - v = v*85 + uint32(b-'!'); - nb++; + v = v*85 + uint32(b-'!') + nb++ default: return 0, 0, CorruptInputError(i) } if nb == 5 { - nsrc = i + 1; - dst[ndst] = byte(v >> 24); - dst[ndst+1] = byte(v >> 16); - dst[ndst+2] = byte(v >> 8); - dst[ndst+3] = byte(v); - ndst += 4; - nb = 0; - v = 0; + nsrc = i + 1 + dst[ndst] = byte(v >> 24) + dst[ndst+1] = byte(v >> 16) + dst[ndst+2] = byte(v >> 8) + dst[ndst+3] = byte(v) + ndst += 4 + nb = 0 + v = 0 } } if flush { - nsrc = len(src); + nsrc = len(src) if nb > 0 { // The number of output bytes in the last fragment // is the number of leftover input bytes - 1: @@ -233,27 +233,27 @@ func Decode(dst, src []byte, flush bool) (ndst, nsrc int, err os.Error) { v = v*85 + 84 } for i := 0; i < nb-1; i++ { - dst[ndst] = byte(v >> 24); - v <<= 8; - ndst++; + dst[ndst] = byte(v >> 24) + v <<= 8 + ndst++ } } } - return; + return } // NewDecoder constructs a new ascii85 stream decoder. -func NewDecoder(r io.Reader) io.Reader { return &decoder{r: r} } +func NewDecoder(r io.Reader) io.Reader { return &decoder{r: r} } type decoder struct { - err os.Error; - readErr os.Error; - r io.Reader; - end bool; // saw end of message - buf [1024]byte; // leftover input - nbuf int; - out []byte; // leftover decoded output - outbuf [1024]byte; + err os.Error + readErr os.Error + r io.Reader + end bool // saw end of message + buf [1024]byte // leftover input + nbuf int + out []byte // leftover decoded output + outbuf [1024]byte } func (d *decoder) Read(p []byte) (n int, err os.Error) { @@ -267,19 +267,19 @@ func (d *decoder) Read(p []byte) (n int, err os.Error) { for { // Copy leftover output from last decode. if len(d.out) > 0 { - n = copy(p, d.out); - d.out = d.out[n:]; - return; + n = copy(p, d.out) + d.out = d.out[n:] + return } // Decode leftover input from last read. - var nn, nsrc, ndst int; + var nn, nsrc, ndst int if d.nbuf > 0 { - ndst, nsrc, d.err = Decode(&d.outbuf, d.buf[0:d.nbuf], d.readErr != nil); + 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 = copy(&d.buf, d.buf[nsrc:d.nbuf]); - continue; // copy out and return + d.out = d.outbuf[0:ndst] + d.nbuf = copy(&d.buf, d.buf[nsrc:d.nbuf]) + continue // copy out and return } } @@ -288,13 +288,13 @@ func (d *decoder) Read(p []byte) (n int, err os.Error) { return 0, d.err } if d.readErr != nil { - d.err = d.readErr; - return 0, d.err; + d.err = d.readErr + return 0, d.err } // Read more data. - nn, d.readErr = d.r.Read(d.buf[d.nbuf:]); - d.nbuf += nn; + nn, d.readErr = d.r.Read(d.buf[d.nbuf:]) + d.nbuf += nn } - panic("unreachable"); + panic("unreachable") } diff --git a/src/pkg/encoding/ascii85/ascii85_test.go b/src/pkg/encoding/ascii85/ascii85_test.go index 5ac49c675..7eb245ee2 100644 --- a/src/pkg/encoding/ascii85/ascii85_test.go +++ b/src/pkg/encoding/ascii85/ascii85_test.go @@ -5,16 +5,16 @@ package ascii85 import ( - "bytes"; - "io/ioutil"; - "os"; - "reflect"; - "strings"; - "testing"; + "bytes" + "io/ioutil" + "os" + "reflect" + "strings" + "testing" ) type testpair struct { - decoded, encoded string; + decoded, encoded string } var pairs = []testpair{ @@ -35,88 +35,88 @@ var pairs = []testpair{ var bigtest = pairs[len(pairs)-1] func testEqual(t *testing.T, msg string, args ...) bool { - v := reflect.NewValue(args).(*reflect.StructValue); - v1 := v.Field(v.NumField() - 2); - v2 := v.Field(v.NumField() - 1); + v := reflect.NewValue(args).(*reflect.StructValue) + v1 := v.Field(v.NumField() - 2) + v2 := v.Field(v.NumField() - 1) if v1.Interface() != v2.Interface() { - t.Errorf(msg, args); - return false; + t.Errorf(msg, args) + return false } - return true; + return true } func strip85(s string) string { - t := make([]byte, len(s)); - w := 0; + t := make([]byte, len(s)) + w := 0 for r := 0; r < len(s); r++ { - c := s[r]; + c := s[r] if c > ' ' { - t[w] = c; - w++; + t[w] = c + w++ } } - return string(t[0:w]); + return string(t[0:w]) } func TestEncode(t *testing.T) { for _, p := range pairs { - buf := make([]byte, MaxEncodedLen(len(p.decoded))); - n := Encode(buf, strings.Bytes(p.decoded)); - buf = buf[0:n]; - testEqual(t, "Encode(%q) = %q, want %q", p.decoded, strip85(string(buf)), strip85(p.encoded)); + buf := make([]byte, MaxEncodedLen(len(p.decoded))) + n := Encode(buf, strings.Bytes(p.decoded)) + buf = buf[0:n] + testEqual(t, "Encode(%q) = %q, want %q", p.decoded, strip85(string(buf)), strip85(p.encoded)) } } func TestEncoder(t *testing.T) { for _, p := range pairs { - bb := &bytes.Buffer{}; - encoder := NewEncoder(bb); - encoder.Write(strings.Bytes(p.decoded)); - encoder.Close(); - testEqual(t, "Encode(%q) = %q, want %q", p.decoded, strip85(bb.String()), strip85(p.encoded)); + bb := &bytes.Buffer{} + encoder := NewEncoder(bb) + encoder.Write(strings.Bytes(p.decoded)) + encoder.Close() + testEqual(t, "Encode(%q) = %q, want %q", p.decoded, strip85(bb.String()), strip85(p.encoded)) } } func TestEncoderBuffering(t *testing.T) { - input := strings.Bytes(bigtest.decoded); + input := strings.Bytes(bigtest.decoded) for bs := 1; bs <= 12; bs++ { - bb := &bytes.Buffer{}; - encoder := NewEncoder(bb); + bb := &bytes.Buffer{} + encoder := NewEncoder(bb) for pos := 0; pos < len(input); pos += bs { - end := pos + bs; + end := pos + bs if end > len(input) { end = len(input) } - n, err := encoder.Write(input[pos:end]); - testEqual(t, "Write(%q) gave error %v, want %v", input[pos:end], err, os.Error(nil)); - testEqual(t, "Write(%q) gave length %v, want %v", input[pos:end], n, end-pos); + n, err := encoder.Write(input[pos:end]) + testEqual(t, "Write(%q) gave error %v, want %v", input[pos:end], err, os.Error(nil)) + testEqual(t, "Write(%q) gave length %v, want %v", input[pos:end], n, end-pos) } - err := encoder.Close(); - testEqual(t, "Close gave error %v, want %v", err, os.Error(nil)); - testEqual(t, "Encoding/%d of %q = %q, want %q", bs, bigtest.decoded, strip85(bb.String()), strip85(bigtest.encoded)); + err := encoder.Close() + testEqual(t, "Close gave error %v, want %v", err, os.Error(nil)) + testEqual(t, "Encoding/%d of %q = %q, want %q", bs, bigtest.decoded, strip85(bb.String()), strip85(bigtest.encoded)) } } func TestDecode(t *testing.T) { for _, p := range pairs { - dbuf := make([]byte, 4*len(p.encoded)); - ndst, nsrc, err := Decode(dbuf, strings.Bytes(p.encoded), true); - testEqual(t, "Decode(%q) = error %v, want %v", p.encoded, err, os.Error(nil)); - testEqual(t, "Decode(%q) = nsrc %v, want %v", p.encoded, nsrc, len(p.encoded)); - testEqual(t, "Decode(%q) = ndst %v, want %v", p.encoded, ndst, len(p.decoded)); - testEqual(t, "Decode(%q) = %q, want %q", p.encoded, string(dbuf[0:ndst]), p.decoded); + dbuf := make([]byte, 4*len(p.encoded)) + ndst, nsrc, err := Decode(dbuf, strings.Bytes(p.encoded), true) + testEqual(t, "Decode(%q) = error %v, want %v", p.encoded, err, os.Error(nil)) + testEqual(t, "Decode(%q) = nsrc %v, want %v", p.encoded, nsrc, len(p.encoded)) + testEqual(t, "Decode(%q) = ndst %v, want %v", p.encoded, ndst, len(p.decoded)) + testEqual(t, "Decode(%q) = %q, want %q", p.encoded, string(dbuf[0:ndst]), p.decoded) } } func TestDecoder(t *testing.T) { for _, p := range pairs { - decoder := NewDecoder(bytes.NewBufferString(p.encoded)); - dbuf, err := ioutil.ReadAll(decoder); + decoder := NewDecoder(bytes.NewBufferString(p.encoded)) + dbuf, err := ioutil.ReadAll(decoder) if err != nil { t.Fatal("Read failed", err) } - testEqual(t, "Read from %q = length %v, want %v", p.encoded, len(dbuf), len(p.decoded)); - testEqual(t, "Decoding of %q = %q, want %q", p.encoded, string(dbuf), p.decoded); + testEqual(t, "Read from %q = length %v, want %v", p.encoded, len(dbuf), len(p.decoded)) + testEqual(t, "Decoding of %q = %q, want %q", p.encoded, string(dbuf), p.decoded) if err != nil { testEqual(t, "Read from %q = %v, want %v", p.encoded, err, os.EOF) } @@ -125,31 +125,31 @@ func TestDecoder(t *testing.T) { func TestDecoderBuffering(t *testing.T) { for bs := 1; bs <= 12; bs++ { - decoder := NewDecoder(bytes.NewBufferString(bigtest.encoded)); - buf := make([]byte, len(bigtest.decoded)+12); - var total int; + decoder := NewDecoder(bytes.NewBufferString(bigtest.encoded)) + buf := make([]byte, len(bigtest.decoded)+12) + var total int for total = 0; total < len(bigtest.decoded); { - n, err := decoder.Read(buf[total : total+bs]); - testEqual(t, "Read from %q at pos %d = %d, %v, want _, %v", bigtest.encoded, total, n, err, os.Error(nil)); - total += n; + n, err := decoder.Read(buf[total : total+bs]) + testEqual(t, "Read from %q at pos %d = %d, %v, want _, %v", bigtest.encoded, total, n, err, os.Error(nil)) + total += n } - testEqual(t, "Decoding/%d of %q = %q, want %q", bs, bigtest.encoded, string(buf[0:total]), bigtest.decoded); + testEqual(t, "Decoding/%d of %q = %q, want %q", bs, bigtest.encoded, string(buf[0:total]), bigtest.decoded) } } func TestDecodeCorrupt(t *testing.T) { type corrupt struct { - e string; - p int; + e string + p int } examples := []corrupt{ corrupt{"v", 0}, corrupt{"!z!!!!!!!!!", 1}, - }; + } for _, e := range examples { - dbuf := make([]byte, 4*len(e.e)); - _, _, err := Decode(dbuf, strings.Bytes(e.e), true); + dbuf := make([]byte, 4*len(e.e)) + _, _, err := Decode(dbuf, strings.Bytes(e.e), true) switch err := err.(type) { case CorruptInputError: testEqual(t, "Corruption in %q at offset %v, want %v", e.e, int(err), e.p) @@ -160,34 +160,34 @@ func TestDecodeCorrupt(t *testing.T) { } func TestBig(t *testing.T) { - n := 3*1000 + 1; - raw := make([]byte, n); - const alpha = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"; + n := 3*1000 + 1 + raw := make([]byte, n) + const alpha = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" for i := 0; i < n; i++ { raw[i] = alpha[i%len(alpha)] } - encoded := new(bytes.Buffer); - w := NewEncoder(encoded); - nn, err := w.Write(raw); + encoded := new(bytes.Buffer) + w := NewEncoder(encoded) + nn, err := w.Write(raw) if nn != n || err != nil { t.Fatalf("Encoder.Write(raw) = %d, %v want %d, nil", nn, err, n) } - err = w.Close(); + err = w.Close() if err != nil { t.Fatalf("Encoder.Close() = %v want nil", err) } - decoded, err := ioutil.ReadAll(NewDecoder(encoded)); + decoded, err := ioutil.ReadAll(NewDecoder(encoded)) if err != nil { t.Fatalf("io.ReadAll(NewDecoder(...)): %v", err) } if !bytes.Equal(raw, decoded) { - var i int; + var i int for i = 0; i < len(decoded) && i < len(raw); i++ { if decoded[i] != raw[i] { break } } - t.Errorf("Decode(Encode(%d-byte string)) failed at offset %d", n, i); + t.Errorf("Decode(Encode(%d-byte string)) failed at offset %d", n, i) } } diff --git a/src/pkg/encoding/base64/base64.go b/src/pkg/encoding/base64/base64.go index e7b7f4da4..d4429094a 100644 --- a/src/pkg/encoding/base64/base64.go +++ b/src/pkg/encoding/base64/base64.go @@ -6,9 +6,9 @@ package base64 import ( - "io"; - "os"; - "strconv"; + "io" + "os" + "strconv" ) /* @@ -21,8 +21,8 @@ import ( // (RFC 1421). RFC 4648 also defines an alternate encoding, which is // the standard encoding with - and _ substituted for + and /. type Encoding struct { - encode string; - decodeMap [256]byte; + encode string + decodeMap [256]byte } const encodeStd = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/" @@ -31,15 +31,15 @@ const encodeURL = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz012345678 // NewEncoding returns a new Encoding defined by the given alphabet, // which must be a 64-byte string. func NewEncoding(encoder string) *Encoding { - e := new(Encoding); - e.encode = encoder; + e := new(Encoding) + e.encode = encoder for i := 0; i < len(e.decodeMap); i++ { e.decodeMap[i] = 0xFF } for i := 0; i < len(encoder); i++ { e.decodeMap[encoder[i]] = byte(i) } - return e; + return e } // StdEncoding is the standard base64 encoding, as defined in @@ -66,25 +66,25 @@ func (enc *Encoding) Encode(dst, src []byte) { } for len(src) > 0 { - dst[0] = 0; - dst[1] = 0; - dst[2] = 0; - dst[3] = 0; + dst[0] = 0 + dst[1] = 0 + dst[2] = 0 + dst[3] = 0 // Unpack 4x 6-bit source blocks into a 4 byte // destination quantum switch len(src) { default: - dst[3] |= src[2] & 0x3F; - dst[2] |= src[2] >> 6; - fallthrough; + dst[3] |= src[2] & 0x3F + dst[2] |= src[2] >> 6 + fallthrough case 2: - dst[2] |= (src[1] << 2) & 0x3F; - dst[1] |= src[1] >> 4; - fallthrough; + dst[2] |= (src[1] << 2) & 0x3F + dst[1] |= src[1] >> 4 + fallthrough case 1: - dst[1] |= (src[0] << 4) & 0x3F; - dst[0] |= src[0] >> 2; + dst[1] |= (src[0] << 4) & 0x3F + dst[0] |= src[0] >> 2 } // Encode 6-bit blocks using the base64 alphabet @@ -94,25 +94,25 @@ func (enc *Encoding) Encode(dst, src []byte) { // Pad the final quantum if len(src) < 3 { - dst[3] = '='; + dst[3] = '=' if len(src) < 2 { dst[2] = '=' } - break; + break } - src = src[3:]; - dst = dst[4:]; + src = src[3:] + dst = dst[4:] } } type encoder struct { - err os.Error; - enc *Encoding; - w io.Writer; - buf [3]byte; // buffered data waiting to be encoded - nbuf int; // number of bytes in buf - out [1024]byte; // output buffer + err os.Error + enc *Encoding + w io.Writer + buf [3]byte // buffered data waiting to be encoded + nbuf int // number of bytes in buf + out [1024]byte // output buffer } func (e *encoder) Write(p []byte) (n int, err os.Error) { @@ -122,47 +122,47 @@ func (e *encoder) Write(p []byte) (n int, err os.Error) { // Leading fringe. if e.nbuf > 0 { - var i int; + var i int for i = 0; i < len(p) && e.nbuf < 3; i++ { - e.buf[e.nbuf] = p[i]; - e.nbuf++; + e.buf[e.nbuf] = p[i] + e.nbuf++ } - n += i; - p = p[i:]; + n += i + p = p[i:] if e.nbuf < 3 { return } - e.enc.Encode(&e.out, &e.buf); + e.enc.Encode(&e.out, &e.buf) if _, e.err = e.w.Write(e.out[0:4]); e.err != nil { return n, e.err } - e.nbuf = 0; + e.nbuf = 0 } // Large interior chunks. for len(p) >= 3 { - nn := len(e.out) / 4 * 3; + nn := len(e.out) / 4 * 3 if nn > len(p) { nn = len(p) } - nn -= nn % 3; + nn -= nn % 3 if nn > 0 { - e.enc.Encode(&e.out, p[0:nn]); + e.enc.Encode(&e.out, p[0:nn]) if _, e.err = e.w.Write(e.out[0 : nn/3*4]); e.err != nil { return n, e.err } } - n += nn; - p = p[nn:]; + n += nn + p = p[nn:] } // Trailing fringe. for i := 0; i < len(p); i++ { e.buf[i] = p[i] } - e.nbuf = len(p); - n += len(p); - return; + e.nbuf = len(p) + n += len(p) + return } // Close flushes any pending output from the encoder. @@ -170,11 +170,11 @@ func (e *encoder) Write(p []byte) (n int, err os.Error) { func (e *encoder) Close() os.Error { // If there's anything left in the buffer, flush it out if e.err == nil && e.nbuf > 0 { - e.enc.Encode(&e.out, e.buf[0:e.nbuf]); - e.nbuf = 0; - _, e.err = e.w.Write(e.out[0:4]); + e.enc.Encode(&e.out, e.buf[0:e.nbuf]) + e.nbuf = 0 + _, e.err = e.w.Write(e.out[0:4]) } - return e.err; + return e.err } // NewEncoder returns a new base64 stream encoder. Data written to @@ -188,7 +188,7 @@ func NewEncoder(enc *Encoding, w io.Writer) io.WriteCloser { // EncodedLen returns the length in bytes of the base64 encoding // of an input buffer of length n. -func (enc *Encoding) EncodedLen(n int) int { return (n + 2) / 3 * 4 } +func (enc *Encoding) EncodedLen(n int) int { return (n + 2) / 3 * 4 } /* * Decoder @@ -207,23 +207,23 @@ func (e CorruptInputError) String() string { func (enc *Encoding) decode(dst, src []byte) (n int, end bool, err os.Error) { for i := 0; i < len(src)/4 && !end; i++ { // Decode quantum using the base64 alphabet - var dbuf [4]byte; - dlen := 4; + var dbuf [4]byte + dlen := 4 dbufloop: for j := 0; j < 4; j++ { - in := src[i*4+j]; + in := src[i*4+j] if in == '=' && j >= 2 && i == len(src)/4-1 { // We've reached the end and there's // padding if src[i*4+3] != '=' { return n, false, CorruptInputError(i*4 + 2) } - dlen = j; - end = true; - break dbufloop; + dlen = j + end = true + break dbufloop } - dbuf[j] = enc.decodeMap[in]; + dbuf[j] = enc.decodeMap[in] if dbuf[j] == 0xFF { return n, false, CorruptInputError(i*4 + j) } @@ -233,18 +233,18 @@ func (enc *Encoding) decode(dst, src []byte) (n int, end bool, err os.Error) { // quantum switch dlen { case 4: - dst[i*3+2] = dbuf[2]<<6 | dbuf[3]; - fallthrough; + dst[i*3+2] = dbuf[2]<<6 | dbuf[3] + fallthrough case 3: - dst[i*3+1] = dbuf[1]<<4 | dbuf[2]>>2; - fallthrough; + dst[i*3+1] = dbuf[1]<<4 | dbuf[2]>>2 + fallthrough case 2: dst[i*3+0] = dbuf[0]<<2 | dbuf[1]>>4 } - n += dlen - 1; + n += dlen - 1 } - return n, end, nil; + return n, end, nil } // Decode decodes src using the encoding enc. It writes at most @@ -256,19 +256,19 @@ func (enc *Encoding) Decode(dst, src []byte) (n int, err os.Error) { return 0, CorruptInputError(len(src) / 4 * 4) } - n, _, err = enc.decode(dst, src); - return; + n, _, err = enc.decode(dst, src) + return } type decoder struct { - err os.Error; - enc *Encoding; - r io.Reader; - end bool; // saw end of message - buf [1024]byte; // leftover input - nbuf int; - out []byte; // leftover decoded output - outbuf [1024 / 4 * 3]byte; + err os.Error + enc *Encoding + r io.Reader + end bool // saw end of message + buf [1024]byte // leftover input + nbuf int + out []byte // leftover decoded output + outbuf [1024 / 4 * 3]byte } func (d *decoder) Read(p []byte) (n int, err os.Error) { @@ -278,37 +278,37 @@ func (d *decoder) Read(p []byte) (n int, err os.Error) { // Use leftover decoded output from last read. if len(d.out) > 0 { - n = copy(p, d.out); - d.out = d.out[n:]; - return n, nil; + n = copy(p, d.out) + d.out = d.out[n:] + return n, nil } // Read a chunk. - nn := len(p) / 3 * 4; + 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; + 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; + 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 = copy(p, d.out); - d.out = d.out[n:]; + nw, d.end, d.err = d.enc.decode(&d.outbuf, d.buf[0:nr]) + d.out = d.outbuf[0:nw] + n = copy(p, d.out) + d.out = d.out[n:] } else { n, d.end, d.err = d.enc.decode(p, d.buf[0:nr]) } - d.nbuf -= nr; + d.nbuf -= nr for i := 0; i < d.nbuf; i++ { d.buf[i] = d.buf[i+nr] } @@ -316,7 +316,7 @@ func (d *decoder) Read(p []byte) (n int, err os.Error) { if d.err == nil { d.err = err } - return n, d.err; + return n, d.err } // NewDecoder constructs a new base64 stream decoder. @@ -326,4 +326,4 @@ func NewDecoder(enc *Encoding, r io.Reader) io.Reader { // DecodeLen returns the maximum length in bytes of the decoded data // corresponding to n bytes of base64-encoded data. -func (enc *Encoding) DecodedLen(n int) int { return n / 4 * 3 } +func (enc *Encoding) DecodedLen(n int) int { return n / 4 * 3 } diff --git a/src/pkg/encoding/base64/base64_test.go b/src/pkg/encoding/base64/base64_test.go index 3153a7347..fe66cff7e 100644 --- a/src/pkg/encoding/base64/base64_test.go +++ b/src/pkg/encoding/base64/base64_test.go @@ -5,16 +5,16 @@ package base64 import ( - "bytes"; - "io/ioutil"; - "os"; - "reflect"; - "strings"; - "testing"; + "bytes" + "io/ioutil" + "os" + "reflect" + "strings" + "testing" ) type testpair struct { - decoded, encoded string; + decoded, encoded string } var pairs = []testpair{ @@ -49,102 +49,102 @@ var bigtest = testpair{ } func testEqual(t *testing.T, msg string, args ...) bool { - v := reflect.NewValue(args).(*reflect.StructValue); - v1 := v.Field(v.NumField() - 2); - v2 := v.Field(v.NumField() - 1); + v := reflect.NewValue(args).(*reflect.StructValue) + v1 := v.Field(v.NumField() - 2) + v2 := v.Field(v.NumField() - 1) if v1.Interface() != v2.Interface() { - t.Errorf(msg, args); - return false; + t.Errorf(msg, args) + return false } - return true; + return true } func TestEncode(t *testing.T) { for _, p := range pairs { - buf := make([]byte, StdEncoding.EncodedLen(len(p.decoded))); - StdEncoding.Encode(buf, strings.Bytes(p.decoded)); - testEqual(t, "Encode(%q) = %q, want %q", p.decoded, string(buf), p.encoded); + buf := make([]byte, StdEncoding.EncodedLen(len(p.decoded))) + StdEncoding.Encode(buf, strings.Bytes(p.decoded)) + testEqual(t, "Encode(%q) = %q, want %q", p.decoded, string(buf), p.encoded) } } func TestEncoder(t *testing.T) { for _, p := range pairs { - bb := &bytes.Buffer{}; - encoder := NewEncoder(StdEncoding, bb); - encoder.Write(strings.Bytes(p.decoded)); - encoder.Close(); - testEqual(t, "Encode(%q) = %q, want %q", p.decoded, bb.String(), p.encoded); + bb := &bytes.Buffer{} + encoder := NewEncoder(StdEncoding, bb) + encoder.Write(strings.Bytes(p.decoded)) + encoder.Close() + testEqual(t, "Encode(%q) = %q, want %q", p.decoded, bb.String(), p.encoded) } } func TestEncoderBuffering(t *testing.T) { - input := strings.Bytes(bigtest.decoded); + input := strings.Bytes(bigtest.decoded) for bs := 1; bs <= 12; bs++ { - bb := &bytes.Buffer{}; - encoder := NewEncoder(StdEncoding, bb); + bb := &bytes.Buffer{} + encoder := NewEncoder(StdEncoding, bb) for pos := 0; pos < len(input); pos += bs { - end := pos + bs; + end := pos + bs if end > len(input) { end = len(input) } - n, err := encoder.Write(input[pos:end]); - testEqual(t, "Write(%q) gave error %v, want %v", input[pos:end], err, os.Error(nil)); - testEqual(t, "Write(%q) gave length %v, want %v", input[pos:end], n, end-pos); + n, err := encoder.Write(input[pos:end]) + testEqual(t, "Write(%q) gave error %v, want %v", input[pos:end], err, os.Error(nil)) + testEqual(t, "Write(%q) gave length %v, want %v", input[pos:end], n, end-pos) } - err := encoder.Close(); - testEqual(t, "Close gave error %v, want %v", err, os.Error(nil)); - testEqual(t, "Encoding/%d of %q = %q, want %q", bs, bigtest.decoded, bb.String(), bigtest.encoded); + err := encoder.Close() + testEqual(t, "Close gave error %v, want %v", err, os.Error(nil)) + testEqual(t, "Encoding/%d of %q = %q, want %q", bs, bigtest.decoded, bb.String(), bigtest.encoded) } } func TestDecode(t *testing.T) { for _, p := range pairs { - dbuf := make([]byte, StdEncoding.DecodedLen(len(p.encoded))); - count, end, err := StdEncoding.decode(dbuf, strings.Bytes(p.encoded)); - testEqual(t, "Decode(%q) = error %v, want %v", p.encoded, err, os.Error(nil)); - testEqual(t, "Decode(%q) = length %v, want %v", p.encoded, count, len(p.decoded)); + dbuf := make([]byte, StdEncoding.DecodedLen(len(p.encoded))) + count, end, err := StdEncoding.decode(dbuf, strings.Bytes(p.encoded)) + testEqual(t, "Decode(%q) = error %v, want %v", p.encoded, err, os.Error(nil)) + testEqual(t, "Decode(%q) = length %v, want %v", p.encoded, count, len(p.decoded)) if len(p.encoded) > 0 { testEqual(t, "Decode(%q) = end %v, want %v", p.encoded, end, (p.encoded[len(p.encoded)-1] == '=')) } - testEqual(t, "Decode(%q) = %q, want %q", p.encoded, string(dbuf[0:count]), p.decoded); + testEqual(t, "Decode(%q) = %q, want %q", p.encoded, string(dbuf[0:count]), p.decoded) } } func TestDecoder(t *testing.T) { for _, p := range pairs { - decoder := NewDecoder(StdEncoding, bytes.NewBufferString(p.encoded)); - dbuf := make([]byte, StdEncoding.DecodedLen(len(p.encoded))); - count, err := decoder.Read(dbuf); + decoder := NewDecoder(StdEncoding, bytes.NewBufferString(p.encoded)) + dbuf := make([]byte, StdEncoding.DecodedLen(len(p.encoded))) + count, err := decoder.Read(dbuf) if err != nil && err != os.EOF { t.Fatal("Read failed", err) } - testEqual(t, "Read from %q = length %v, want %v", p.encoded, count, len(p.decoded)); - testEqual(t, "Decoding of %q = %q, want %q", p.encoded, string(dbuf[0:count]), p.decoded); + testEqual(t, "Read from %q = length %v, want %v", p.encoded, count, len(p.decoded)) + testEqual(t, "Decoding of %q = %q, want %q", p.encoded, string(dbuf[0:count]), p.decoded) if err != os.EOF { count, err = decoder.Read(dbuf) } - testEqual(t, "Read from %q = %v, want %v", p.encoded, err, os.EOF); + testEqual(t, "Read from %q = %v, want %v", p.encoded, err, os.EOF) } } func TestDecoderBuffering(t *testing.T) { for bs := 1; bs <= 12; bs++ { - decoder := NewDecoder(StdEncoding, bytes.NewBufferString(bigtest.encoded)); - buf := make([]byte, len(bigtest.decoded)+12); - var total int; + decoder := NewDecoder(StdEncoding, bytes.NewBufferString(bigtest.encoded)) + buf := make([]byte, len(bigtest.decoded)+12) + var total int for total = 0; total < len(bigtest.decoded); { - n, err := decoder.Read(buf[total : total+bs]); - testEqual(t, "Read from %q at pos %d = %d, %v, want _, %v", bigtest.encoded, total, n, err, os.Error(nil)); - total += n; + n, err := decoder.Read(buf[total : total+bs]) + testEqual(t, "Read from %q at pos %d = %d, %v, want _, %v", bigtest.encoded, total, n, err, os.Error(nil)) + total += n } - testEqual(t, "Decoding/%d of %q = %q, want %q", bs, bigtest.encoded, string(buf[0:total]), bigtest.decoded); + testEqual(t, "Decoding/%d of %q = %q, want %q", bs, bigtest.encoded, string(buf[0:total]), bigtest.decoded) } } func TestDecodeCorrupt(t *testing.T) { type corrupt struct { - e string; - p int; + e string + p int } examples := []corrupt{ corrupt{"!!!!", 0}, @@ -153,11 +153,11 @@ func TestDecodeCorrupt(t *testing.T) { corrupt{"AAA=AAAA", 3}, corrupt{"AAAAA", 4}, corrupt{"AAAAAA", 4}, - }; + } for _, e := range examples { - dbuf := make([]byte, StdEncoding.DecodedLen(len(e.e))); - _, err := StdEncoding.Decode(dbuf, strings.Bytes(e.e)); + dbuf := make([]byte, StdEncoding.DecodedLen(len(e.e))) + _, err := StdEncoding.Decode(dbuf, strings.Bytes(e.e)) switch err := err.(type) { case CorruptInputError: testEqual(t, "Corruption in %q at offset %v, want %v", e.e, int(err), e.p) @@ -168,34 +168,34 @@ func TestDecodeCorrupt(t *testing.T) { } func TestBig(t *testing.T) { - n := 3*1000 + 1; - raw := make([]byte, n); - const alpha = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"; + n := 3*1000 + 1 + raw := make([]byte, n) + const alpha = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" for i := 0; i < n; i++ { raw[i] = alpha[i%len(alpha)] } - encoded := new(bytes.Buffer); - w := NewEncoder(StdEncoding, encoded); - nn, err := w.Write(raw); + encoded := new(bytes.Buffer) + w := NewEncoder(StdEncoding, encoded) + nn, err := w.Write(raw) if nn != n || err != nil { t.Fatalf("Encoder.Write(raw) = %d, %v want %d, nil", nn, err, n) } - err = w.Close(); + err = w.Close() if err != nil { t.Fatalf("Encoder.Close() = %v want nil", err) } - decoded, err := ioutil.ReadAll(NewDecoder(StdEncoding, encoded)); + decoded, err := ioutil.ReadAll(NewDecoder(StdEncoding, encoded)) if err != nil { t.Fatalf("ioutil.ReadAll(NewDecoder(...)): %v", err) } if !bytes.Equal(raw, decoded) { - var i int; + var i int for i = 0; i < len(decoded) && i < len(raw); i++ { if decoded[i] != raw[i] { break } } - t.Errorf("Decode(Encode(%d-byte string)) failed at offset %d", n, i); + t.Errorf("Decode(Encode(%d-byte string)) failed at offset %d", n, i) } } diff --git a/src/pkg/encoding/binary/binary.go b/src/pkg/encoding/binary/binary.go index 419ec03a5..36f2366d6 100644 --- a/src/pkg/encoding/binary/binary.go +++ b/src/pkg/encoding/binary/binary.go @@ -7,22 +7,22 @@ package binary import ( - "math"; - "io"; - "os"; - "reflect"; + "math" + "io" + "os" + "reflect" ) // A ByteOrder specifies how to convert byte sequences into // 16-, 32-, or 64-bit unsigned integers. type ByteOrder interface { - Uint16(b []byte) uint16; - Uint32(b []byte) uint32; - Uint64(b []byte) uint64; - PutUint16([]byte, uint16); - PutUint32([]byte, uint32); - PutUint64([]byte, uint64); - String() string; + Uint16(b []byte) uint16 + Uint32(b []byte) uint32 + Uint64(b []byte) uint64 + PutUint16([]byte, uint16) + PutUint32([]byte, uint32) + PutUint64([]byte, uint64) + String() string } // This is byte instead of struct{} so that it can be compared, @@ -34,11 +34,11 @@ var BigEndian ByteOrder = bigEndian(0) type littleEndian unused -func (littleEndian) Uint16(b []byte) uint16 { return uint16(b[0]) | uint16(b[1])<<8 } +func (littleEndian) Uint16(b []byte) uint16 { return uint16(b[0]) | uint16(b[1])<<8 } func (littleEndian) PutUint16(b []byte, v uint16) { - b[0] = byte(v); - b[1] = byte(v >> 8); + b[0] = byte(v) + b[1] = byte(v >> 8) } func (littleEndian) Uint32(b []byte) uint32 { @@ -46,10 +46,10 @@ func (littleEndian) Uint32(b []byte) uint32 { } func (littleEndian) PutUint32(b []byte, v uint32) { - b[0] = byte(v); - b[1] = byte(v >> 8); - b[2] = byte(v >> 16); - b[3] = byte(v >> 24); + b[0] = byte(v) + b[1] = byte(v >> 8) + b[2] = byte(v >> 16) + b[3] = byte(v >> 24) } func (littleEndian) Uint64(b []byte) uint64 { @@ -58,27 +58,27 @@ func (littleEndian) Uint64(b []byte) uint64 { } func (littleEndian) PutUint64(b []byte, v uint64) { - b[0] = byte(v); - b[1] = byte(v >> 8); - b[2] = byte(v >> 16); - b[3] = byte(v >> 24); - b[4] = byte(v >> 32); - b[5] = byte(v >> 40); - b[6] = byte(v >> 48); - b[7] = byte(v >> 56); + b[0] = byte(v) + b[1] = byte(v >> 8) + b[2] = byte(v >> 16) + b[3] = byte(v >> 24) + b[4] = byte(v >> 32) + b[5] = byte(v >> 40) + b[6] = byte(v >> 48) + b[7] = byte(v >> 56) } -func (littleEndian) String() string { return "LittleEndian" } +func (littleEndian) String() string { return "LittleEndian" } -func (littleEndian) GoString() string { return "binary.LittleEndian" } +func (littleEndian) GoString() string { return "binary.LittleEndian" } type bigEndian unused -func (bigEndian) Uint16(b []byte) uint16 { return uint16(b[1]) | uint16(b[0])<<8 } +func (bigEndian) Uint16(b []byte) uint16 { return uint16(b[1]) | uint16(b[0])<<8 } func (bigEndian) PutUint16(b []byte, v uint16) { - b[0] = byte(v >> 8); - b[1] = byte(v); + b[0] = byte(v >> 8) + b[1] = byte(v) } func (bigEndian) Uint32(b []byte) uint32 { @@ -86,10 +86,10 @@ func (bigEndian) Uint32(b []byte) uint32 { } func (bigEndian) PutUint32(b []byte, v uint32) { - b[0] = byte(v >> 24); - b[1] = byte(v >> 16); - b[2] = byte(v >> 8); - b[3] = byte(v); + b[0] = byte(v >> 24) + b[1] = byte(v >> 16) + b[2] = byte(v >> 8) + b[3] = byte(v) } func (bigEndian) Uint64(b []byte) uint64 { @@ -98,19 +98,19 @@ func (bigEndian) Uint64(b []byte) uint64 { } func (bigEndian) PutUint64(b []byte, v uint64) { - b[0] = byte(v >> 56); - b[1] = byte(v >> 48); - b[2] = byte(v >> 40); - b[3] = byte(v >> 32); - b[4] = byte(v >> 24); - b[5] = byte(v >> 16); - b[6] = byte(v >> 8); - b[7] = byte(v); + b[0] = byte(v >> 56) + b[1] = byte(v >> 48) + b[2] = byte(v >> 40) + b[3] = byte(v >> 32) + b[4] = byte(v >> 24) + b[5] = byte(v >> 16) + b[6] = byte(v >> 8) + b[7] = byte(v) } -func (bigEndian) String() string { return "BigEndian" } +func (bigEndian) String() string { return "BigEndian" } -func (bigEndian) GoString() string { return "binary.BigEndian" } +func (bigEndian) GoString() string { return "binary.BigEndian" } // Read reads structured binary data from r into data. // Data must be a pointer to a fixed-size value or a slice @@ -121,7 +121,7 @@ func (bigEndian) GoString() string { return "binary.BigEndian" } // r are decoded using the specified byte order and written // to successive fields of the data. func Read(r io.Reader, order ByteOrder, data interface{}) os.Error { - var v reflect.Value; + var v reflect.Value switch d := reflect.NewValue(data).(type) { case *reflect.PtrValue: v = d.Elem() @@ -130,16 +130,16 @@ func Read(r io.Reader, order ByteOrder, data interface{}) os.Error { default: return os.NewError("binary.Read: invalid type " + v.Type().String()) } - size := TotalSize(v); + size := TotalSize(v) if size < 0 { return os.NewError("binary.Read: invalid type " + v.Type().String()) } - d := &decoder{order: order, buf: make([]byte, size)}; + d := &decoder{order: order, buf: make([]byte, size)} if _, err := io.ReadFull(r, d.buf); err != nil { return err } - d.value(v); - return nil; + d.value(v) + return nil } // Write writes the binary representation of data into w. @@ -151,48 +151,48 @@ func Read(r io.Reader, order ByteOrder, data interface{}) os.Error { // w are encoded using the specified byte order and read // from successive fields of the data. func Write(w io.Writer, order ByteOrder, data interface{}) os.Error { - v := reflect.Indirect(reflect.NewValue(data)); - size := TotalSize(v); + v := reflect.Indirect(reflect.NewValue(data)) + size := TotalSize(v) if size < 0 { return os.NewError("binary.Write: invalid type " + v.Type().String()) } - buf := make([]byte, size); - e := &encoder{order: order, buf: buf}; - e.value(v); - _, err := w.Write(buf); - return err; + buf := make([]byte, size) + e := &encoder{order: order, buf: buf} + e.value(v) + _, err := w.Write(buf) + return err } func TotalSize(v reflect.Value) int { if sv, ok := v.(*reflect.SliceValue); ok { - elem := sizeof(v.Type().(*reflect.SliceType).Elem()); + elem := sizeof(v.Type().(*reflect.SliceType).Elem()) if elem < 0 { return -1 } - return sv.Len() * elem; + return sv.Len() * elem } - return sizeof(v.Type()); + return sizeof(v.Type()) } func sizeof(v reflect.Type) int { switch t := v.(type) { case *reflect.ArrayType: - n := sizeof(t.Elem()); + n := sizeof(t.Elem()) if n < 0 { return -1 } - return t.Len() * n; + return t.Len() * n case *reflect.StructType: - sum := 0; + sum := 0 for i, n := 0, t.NumField(); i < n; i++ { - s := sizeof(t.Field(i).Type); + s := sizeof(t.Field(i).Type) if s < 0 { return -1 } - sum += s; + sum += s } - return sum; + return sum case *reflect.Uint8Type: return 1 @@ -215,94 +215,94 @@ func sizeof(v reflect.Type) int { case *reflect.Float64Type: return 8 } - return -1; + return -1 } type decoder struct { - order ByteOrder; - buf []byte; + order ByteOrder + buf []byte } type encoder struct { - order ByteOrder; - buf []byte; + order ByteOrder + buf []byte } func (d *decoder) uint8() uint8 { - x := d.buf[0]; - d.buf = d.buf[1:]; - return x; + x := d.buf[0] + d.buf = d.buf[1:] + return x } func (e *encoder) uint8(x uint8) { - e.buf[0] = x; - e.buf = e.buf[1:]; + e.buf[0] = x + e.buf = e.buf[1:] } func (d *decoder) uint16() uint16 { - x := d.order.Uint16(d.buf[0:2]); - d.buf = d.buf[2:]; - return x; + x := d.order.Uint16(d.buf[0:2]) + d.buf = d.buf[2:] + return x } func (e *encoder) uint16(x uint16) { - e.order.PutUint16(e.buf[0:2], x); - e.buf = e.buf[2:]; + e.order.PutUint16(e.buf[0:2], x) + e.buf = e.buf[2:] } func (d *decoder) uint32() uint32 { - x := d.order.Uint32(d.buf[0:4]); - d.buf = d.buf[4:]; - return x; + x := d.order.Uint32(d.buf[0:4]) + d.buf = d.buf[4:] + return x } func (e *encoder) uint32(x uint32) { - e.order.PutUint32(e.buf[0:4], x); - e.buf = e.buf[4:]; + e.order.PutUint32(e.buf[0:4], x) + e.buf = e.buf[4:] } func (d *decoder) uint64() uint64 { - x := d.order.Uint64(d.buf[0:8]); - d.buf = d.buf[8:]; - return x; + x := d.order.Uint64(d.buf[0:8]) + d.buf = d.buf[8:] + return x } func (e *encoder) uint64(x uint64) { - e.order.PutUint64(e.buf[0:8], x); - e.buf = e.buf[8:]; + e.order.PutUint64(e.buf[0:8], x) + e.buf = e.buf[8:] } -func (d *decoder) int8() int8 { return int8(d.uint8()) } +func (d *decoder) int8() int8 { return int8(d.uint8()) } -func (e *encoder) int8(x int8) { e.uint8(uint8(x)) } +func (e *encoder) int8(x int8) { e.uint8(uint8(x)) } -func (d *decoder) int16() int16 { return int16(d.uint16()) } +func (d *decoder) int16() int16 { return int16(d.uint16()) } -func (e *encoder) int16(x int16) { e.uint16(uint16(x)) } +func (e *encoder) int16(x int16) { e.uint16(uint16(x)) } -func (d *decoder) int32() int32 { return int32(d.uint32()) } +func (d *decoder) int32() int32 { return int32(d.uint32()) } -func (e *encoder) int32(x int32) { e.uint32(uint32(x)) } +func (e *encoder) int32(x int32) { e.uint32(uint32(x)) } -func (d *decoder) int64() int64 { return int64(d.uint64()) } +func (d *decoder) int64() int64 { return int64(d.uint64()) } -func (e *encoder) int64(x int64) { e.uint64(uint64(x)) } +func (e *encoder) int64(x int64) { e.uint64(uint64(x)) } func (d *decoder) value(v reflect.Value) { switch v := v.(type) { case *reflect.ArrayValue: - l := v.Len(); + l := v.Len() for i := 0; i < l; i++ { d.value(v.Elem(i)) } case *reflect.StructValue: - l := v.NumField(); + l := v.NumField() for i := 0; i < l; i++ { d.value(v.Field(i)) } case *reflect.SliceValue: - l := v.Len(); + l := v.Len() for i := 0; i < l; i++ { d.value(v.Elem(i)) } @@ -333,17 +333,17 @@ func (d *decoder) value(v reflect.Value) { func (e *encoder) value(v reflect.Value) { switch v := v.(type) { case *reflect.ArrayValue: - l := v.Len(); + l := v.Len() for i := 0; i < l; i++ { e.value(v.Elem(i)) } case *reflect.StructValue: - l := v.NumField(); + l := v.NumField() for i := 0; i < l; i++ { e.value(v.Field(i)) } case *reflect.SliceValue: - l := v.Len(); + l := v.Len() for i := 0; i < l; i++ { e.value(v.Elem(i)) } diff --git a/src/pkg/encoding/binary/binary_test.go b/src/pkg/encoding/binary/binary_test.go index 33e6b0bea..12d192d1e 100644 --- a/src/pkg/encoding/binary/binary_test.go +++ b/src/pkg/encoding/binary/binary_test.go @@ -5,24 +5,24 @@ package binary import ( - "os"; - "bytes"; - "math"; - "reflect"; - "testing"; + "os" + "bytes" + "math" + "reflect" + "testing" ) type Struct struct { - Int8 int8; - Int16 int16; - Int32 int32; - Int64 int64; - Uint8 uint8; - Uint16 uint16; - Uint32 uint32; - Uint64 uint64; - Float64 float64; - Array [4]uint8; + Int8 int8 + Int16 int16 + Int32 int32 + Int64 int64 + Uint8 uint8 + Uint16 uint16 + Uint32 uint32 + Uint64 uint64 + Float64 float64 + Array [4]uint8 } var s = Struct{ @@ -69,8 +69,8 @@ var res = []int32{0x01020304, 0x05060708} func checkResult(t *testing.T, dir string, order, err os.Error, have, want interface{}) { if err != nil { - t.Errorf("%v %v: %v", dir, order, err); - return; + t.Errorf("%v %v: %v", dir, order, err) + return } if !reflect.DeepEqual(have, want) { t.Errorf("%v %v:\n\thave %+v\n\twant %+v", dir, order, have, want) @@ -78,37 +78,37 @@ func checkResult(t *testing.T, dir string, order, err os.Error, have, want inter } func testRead(t *testing.T, order ByteOrder, b []byte, s1 interface{}) { - var s2 Struct; - err := Read(bytes.NewBuffer(b), order, &s2); - checkResult(t, "Read", order, err, s2, s1); + var s2 Struct + err := Read(bytes.NewBuffer(b), order, &s2) + checkResult(t, "Read", order, err, s2, s1) } func testWrite(t *testing.T, order ByteOrder, b []byte, s1 interface{}) { - buf := new(bytes.Buffer); - err := Write(buf, order, s1); - checkResult(t, "Write", order, err, buf.Bytes(), b); + buf := new(bytes.Buffer) + err := Write(buf, order, s1) + checkResult(t, "Write", order, err, buf.Bytes(), b) } -func TestBigEndianRead(t *testing.T) { testRead(t, BigEndian, big, s) } +func TestBigEndianRead(t *testing.T) { testRead(t, BigEndian, big, s) } -func TestLittleEndianRead(t *testing.T) { testRead(t, LittleEndian, little, s) } +func TestLittleEndianRead(t *testing.T) { testRead(t, LittleEndian, little, s) } -func TestBigEndianWrite(t *testing.T) { testWrite(t, BigEndian, big, s) } +func TestBigEndianWrite(t *testing.T) { testWrite(t, BigEndian, big, s) } -func TestLittleEndianWrite(t *testing.T) { testWrite(t, LittleEndian, little, s) } +func TestLittleEndianWrite(t *testing.T) { testWrite(t, LittleEndian, little, s) } -func TestBigEndianPtrWrite(t *testing.T) { testWrite(t, BigEndian, big, &s) } +func TestBigEndianPtrWrite(t *testing.T) { testWrite(t, BigEndian, big, &s) } -func TestLittleEndianPtrWrite(t *testing.T) { testWrite(t, LittleEndian, little, &s) } +func TestLittleEndianPtrWrite(t *testing.T) { testWrite(t, LittleEndian, little, &s) } func TestReadSlice(t *testing.T) { - slice := make([]int32, 2); - err := Read(bytes.NewBuffer(src), BigEndian, slice); - checkResult(t, "ReadSlice", BigEndian, err, slice, res); + slice := make([]int32, 2) + err := Read(bytes.NewBuffer(src), BigEndian, slice) + checkResult(t, "ReadSlice", BigEndian, err, slice, res) } func TestWriteSlice(t *testing.T) { - buf := new(bytes.Buffer); - err := Write(buf, BigEndian, res); - checkResult(t, "WriteSlice", BigEndian, err, buf.Bytes(), src); + buf := new(bytes.Buffer) + err := Write(buf, BigEndian, res) + checkResult(t, "WriteSlice", BigEndian, err, buf.Bytes(), src) } diff --git a/src/pkg/encoding/git85/git.go b/src/pkg/encoding/git85/git.go index 1e5299792..25a3deac0 100644 --- a/src/pkg/encoding/git85/git.go +++ b/src/pkg/encoding/git85/git.go @@ -7,10 +7,10 @@ package git85 import ( - "bytes"; - "io"; - "os"; - "strconv"; + "bytes" + "io" + "os" + "strconv" ) type CorruptInputError int64 @@ -49,9 +49,9 @@ var decode = [256]uint8{ // The encoding splits src into chunks of at most 52 bytes // and encodes each chunk on its own line. func Encode(dst, src []byte) int { - ndst := 0; + ndst := 0 for len(src) > 0 { - n := len(src); + n := len(src) if n > 52 { n = 52 } @@ -60,23 +60,23 @@ func Encode(dst, src []byte) int { } else { dst[ndst] = byte('a' + n - 26 - 1) } - ndst++; + ndst++ for i := 0; i < n; i += 4 { - var v uint32; + var v uint32 for j := 0; j < 4 && i+j < n; j++ { v |= uint32(src[i+j]) << uint(24-j*8) } for j := 4; j >= 0; j-- { - dst[ndst+j] = encode[v%85]; - v /= 85; + dst[ndst+j] = encode[v%85] + v /= 85 } - ndst += 5; + ndst += 5 } - dst[ndst] = '\n'; - ndst++; - src = src[n:]; + dst[ndst] = '\n' + ndst++ + src = src[n:] } - return ndst; + return ndst } // EncodedLen returns the length of an encoding of n source bytes. @@ -86,7 +86,7 @@ func EncodedLen(n int) int { } // 5 bytes per 4 bytes of input, rounded up. // 2 extra bytes for each line of 52 src bytes, rounded up. - return (n+3)/4*5 + (n+51)/52*2; + return (n+3)/4*5 + (n+51)/52*2 } var newline = []byte{'\n'} @@ -97,10 +97,10 @@ var newline = []byte{'\n'} // If Decode encounters invalid input, it returns a CorruptInputError. // func Decode(dst, src []byte) (n int, err os.Error) { - ndst := 0; - nsrc := 0; + ndst := 0 + nsrc := 0 for nsrc < len(src) { - var l int; + var l int switch ch := int(src[nsrc]); { case 'A' <= ch && ch <= 'Z': l = ch - 'A' + 1 @@ -112,24 +112,24 @@ func Decode(dst, src []byte) (n int, err os.Error) { if nsrc+1+l > len(src) { return ndst, CorruptInputError(nsrc) } - el := (l + 3) / 4 * 5; // encoded len + el := (l + 3) / 4 * 5 // encoded len if nsrc+1+el+1 > len(src) || src[nsrc+1+el] != '\n' { return ndst, CorruptInputError(nsrc) } - line := src[nsrc+1 : nsrc+1+el]; + line := src[nsrc+1 : nsrc+1+el] for i := 0; i < el; i += 5 { - var v uint32; + var v uint32 for j := 0; j < 5; j++ { - ch := decode[line[i+j]]; + ch := decode[line[i+j]] if ch == 0 { return ndst, CorruptInputError(nsrc + 1 + i + j) } - v = v*85 + uint32(ch-1); + v = v*85 + uint32(ch-1) } for j := 0; j < 4; j++ { - dst[ndst] = byte(v >> 24); - v <<= 8; - ndst++; + dst[ndst] = byte(v >> 24) + v <<= 8 + ndst++ } } // Last fragment may have run too far (but there was room in dst). @@ -137,27 +137,27 @@ func Decode(dst, src []byte) (n int, err os.Error) { if l%4 != 0 { ndst -= 4 - l%4 } - nsrc += 1 + el + 1; + nsrc += 1 + el + 1 } - return ndst, nil; + return ndst, nil } -func MaxDecodedLen(n int) int { return n / 5 * 4 } +func MaxDecodedLen(n int) int { return n / 5 * 4 } // NewEncoder returns a new Git base85 stream encoder. Data written to // the returned writer will be encoded and then written to w. // The Git encoding operates on 52-byte blocks; when finished // writing, the caller must Close the returned encoder to flush any // partially written blocks. -func NewEncoder(w io.Writer) io.WriteCloser { return &encoder{w: w} } +func NewEncoder(w io.Writer) io.WriteCloser { return &encoder{w: w} } type encoder struct { - w io.Writer; - err os.Error; - buf [52]byte; - nbuf int; - out [1024]byte; - nout int; + w io.Writer + err os.Error + buf [52]byte + nbuf int + out [1024]byte + nout int } func (e *encoder) Write(p []byte) (n int, err os.Error) { @@ -167,70 +167,70 @@ func (e *encoder) Write(p []byte) (n int, err os.Error) { // Leading fringe. if e.nbuf > 0 { - var i int; + var i int for i = 0; i < len(p) && e.nbuf < 52; i++ { - e.buf[e.nbuf] = p[i]; - e.nbuf++; + e.buf[e.nbuf] = p[i] + e.nbuf++ } - n += i; - p = p[i:]; + n += i + p = p[i:] if e.nbuf < 52 { return } - nout := Encode(&e.out, &e.buf); + nout := Encode(&e.out, &e.buf) if _, e.err = e.w.Write(e.out[0:nout]); e.err != nil { return n, e.err } - e.nbuf = 0; + e.nbuf = 0 } // Large interior chunks. for len(p) >= 52 { - nn := len(e.out) / (1 + 52/4*5 + 1) * 52; + nn := len(e.out) / (1 + 52/4*5 + 1) * 52 if nn > len(p) { nn = len(p) / 52 * 52 } if nn > 0 { - nout := Encode(&e.out, p[0:nn]); + nout := Encode(&e.out, p[0:nn]) if _, e.err = e.w.Write(e.out[0:nout]); e.err != nil { return n, e.err } } - n += nn; - p = p[nn:]; + n += nn + p = p[nn:] } // Trailing fringe. for i := 0; i < len(p); i++ { e.buf[i] = p[i] } - e.nbuf = len(p); - n += len(p); - return; + e.nbuf = len(p) + n += len(p) + return } func (e *encoder) Close() os.Error { // If there's anything left in the buffer, flush it out if e.err == nil && e.nbuf > 0 { - nout := Encode(&e.out, e.buf[0:e.nbuf]); - e.nbuf = 0; - _, e.err = e.w.Write(e.out[0:nout]); + nout := Encode(&e.out, e.buf[0:e.nbuf]) + e.nbuf = 0 + _, e.err = e.w.Write(e.out[0:nout]) } - return e.err; + return e.err } // NewDecoder returns a new Git base85 stream decoder. -func NewDecoder(r io.Reader) io.Reader { return &decoder{r: r} } +func NewDecoder(r io.Reader) io.Reader { return &decoder{r: r} } type decoder struct { - r io.Reader; - err os.Error; - readErr os.Error; - buf [1024]byte; - nbuf int; - out []byte; - outbuf [1024]byte; - off int64; + r io.Reader + err os.Error + readErr os.Error + buf [1024]byte + nbuf int + out []byte + outbuf [1024]byte + off int64 } func (d *decoder) Read(p []byte) (n int, err os.Error) { @@ -241,9 +241,9 @@ func (d *decoder) Read(p []byte) (n int, err os.Error) { for { // Copy leftover output from last decode. if len(d.out) > 0 { - n = copy(p, d.out); - d.out = d.out[n:]; - return; + n = copy(p, d.out) + d.out = d.out[n:] + return } // Out of decoded output. Check errors. @@ -251,27 +251,27 @@ func (d *decoder) Read(p []byte) (n int, err os.Error) { return 0, d.err } if d.readErr != nil { - d.err = d.readErr; - return 0, d.err; + 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:]); - d.nbuf += nn; + var nn int + nn, d.readErr = d.r.Read(d.buf[d.nbuf:]) + d.nbuf += nn // Send complete lines to Decode. - nl := bytes.LastIndex(d.buf[0:d.nbuf], newline); + nl := bytes.LastIndex(d.buf[0:d.nbuf], newline) if nl < 0 { continue } - nn, d.err = Decode(&d.outbuf, d.buf[0:nl+1]); + 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 = copy(&d.buf, d.buf[nl+1:d.nbuf]); - d.off += int64(nl + 1); + d.out = d.outbuf[0:nn] + d.nbuf = copy(&d.buf, d.buf[nl+1:d.nbuf]) + d.off += int64(nl + 1) } - panic("unreacahable"); + panic("unreacahable") } diff --git a/src/pkg/encoding/git85/git_test.go b/src/pkg/encoding/git85/git_test.go index 564b4915b..4a42282fe 100644 --- a/src/pkg/encoding/git85/git_test.go +++ b/src/pkg/encoding/git85/git_test.go @@ -5,36 +5,36 @@ package git85 import ( - "bytes"; - "io/ioutil"; - "os"; - "reflect"; - "strings"; - "testing"; + "bytes" + "io/ioutil" + "os" + "reflect" + "strings" + "testing" ) type testpair struct { - decoded, encoded string; + decoded, encoded string } func testEqual(t *testing.T, msg string, args ...) bool { - v := reflect.NewValue(args).(*reflect.StructValue); - v1 := v.Field(v.NumField() - 2); - v2 := v.Field(v.NumField() - 1); + v := reflect.NewValue(args).(*reflect.StructValue) + v1 := v.Field(v.NumField() - 2) + v2 := v.Field(v.NumField() - 1) if v1.Interface() != v2.Interface() { - t.Errorf(msg, args); - return false; + t.Errorf(msg, args) + return false } - return true; + return true } func TestGitTable(t *testing.T) { - var saw [256]bool; + var saw [256]bool for i, c := range encode { if decode[c] != uint8(i+1) { t.Errorf("decode['%c'] = %d, want %d", c, decode[c], i+1) } - saw[c] = true; + saw[c] = true } for i, b := range saw { if !b && decode[i] != 0 { @@ -64,65 +64,65 @@ var gitBigtest = gitPairs[len(gitPairs)-1] func TestEncode(t *testing.T) { for _, p := range gitPairs { - buf := make([]byte, EncodedLen(len(p.decoded))); - n := Encode(buf, strings.Bytes(p.decoded)); + buf := make([]byte, EncodedLen(len(p.decoded))) + n := Encode(buf, strings.Bytes(p.decoded)) if n != len(buf) { t.Errorf("EncodedLen does not agree with Encode") } - buf = buf[0:n]; - testEqual(t, "Encode(%q) = %q, want %q", p.decoded, string(buf), p.encoded); + buf = buf[0:n] + testEqual(t, "Encode(%q) = %q, want %q", p.decoded, string(buf), p.encoded) } } func TestEncoder(t *testing.T) { for _, p := range gitPairs { - bb := &bytes.Buffer{}; - encoder := NewEncoder(bb); - encoder.Write(strings.Bytes(p.decoded)); - encoder.Close(); - testEqual(t, "Encode(%q) = %q, want %q", p.decoded, bb.String(), p.encoded); + bb := &bytes.Buffer{} + encoder := NewEncoder(bb) + encoder.Write(strings.Bytes(p.decoded)) + encoder.Close() + testEqual(t, "Encode(%q) = %q, want %q", p.decoded, bb.String(), p.encoded) } } func TestEncoderBuffering(t *testing.T) { - input := strings.Bytes(gitBigtest.decoded); + input := strings.Bytes(gitBigtest.decoded) for bs := 1; bs <= 12; bs++ { - bb := &bytes.Buffer{}; - encoder := NewEncoder(bb); + bb := &bytes.Buffer{} + encoder := NewEncoder(bb) for pos := 0; pos < len(input); pos += bs { - end := pos + bs; + end := pos + bs if end > len(input) { end = len(input) } - n, err := encoder.Write(input[pos:end]); - testEqual(t, "Write(%q) gave error %v, want %v", input[pos:end], err, os.Error(nil)); - testEqual(t, "Write(%q) gave length %v, want %v", input[pos:end], n, end-pos); + n, err := encoder.Write(input[pos:end]) + testEqual(t, "Write(%q) gave error %v, want %v", input[pos:end], err, os.Error(nil)) + testEqual(t, "Write(%q) gave length %v, want %v", input[pos:end], n, end-pos) } - err := encoder.Close(); - testEqual(t, "Close gave error %v, want %v", err, os.Error(nil)); - testEqual(t, "Encoding/%d of %q = %q, want %q", bs, gitBigtest.decoded, bb.String(), gitBigtest.encoded); + err := encoder.Close() + testEqual(t, "Close gave error %v, want %v", err, os.Error(nil)) + testEqual(t, "Encoding/%d of %q = %q, want %q", bs, gitBigtest.decoded, bb.String(), gitBigtest.encoded) } } func TestDecode(t *testing.T) { for _, p := range gitPairs { - dbuf := make([]byte, 4*len(p.encoded)); - ndst, err := Decode(dbuf, strings.Bytes(p.encoded)); - testEqual(t, "Decode(%q) = error %v, want %v", p.encoded, err, os.Error(nil)); - testEqual(t, "Decode(%q) = ndst %v, want %v", p.encoded, ndst, len(p.decoded)); - testEqual(t, "Decode(%q) = %q, want %q", p.encoded, string(dbuf[0:ndst]), p.decoded); + dbuf := make([]byte, 4*len(p.encoded)) + ndst, err := Decode(dbuf, strings.Bytes(p.encoded)) + testEqual(t, "Decode(%q) = error %v, want %v", p.encoded, err, os.Error(nil)) + testEqual(t, "Decode(%q) = ndst %v, want %v", p.encoded, ndst, len(p.decoded)) + testEqual(t, "Decode(%q) = %q, want %q", p.encoded, string(dbuf[0:ndst]), p.decoded) } } func TestDecoder(t *testing.T) { for _, p := range gitPairs { - decoder := NewDecoder(bytes.NewBufferString(p.encoded)); - dbuf, err := ioutil.ReadAll(decoder); + decoder := NewDecoder(bytes.NewBufferString(p.encoded)) + dbuf, err := ioutil.ReadAll(decoder) if err != nil { t.Fatal("Read failed", err) } - testEqual(t, "Read from %q = length %v, want %v", p.encoded, len(dbuf), len(p.decoded)); - testEqual(t, "Decoding of %q = %q, want %q", p.encoded, string(dbuf), p.decoded); + testEqual(t, "Read from %q = length %v, want %v", p.encoded, len(dbuf), len(p.decoded)) + testEqual(t, "Decoding of %q = %q, want %q", p.encoded, string(dbuf), p.decoded) if err != nil { testEqual(t, "Read from %q = %v, want %v", p.encoded, err, os.EOF) } @@ -131,31 +131,31 @@ func TestDecoder(t *testing.T) { func TestDecoderBuffering(t *testing.T) { for bs := 1; bs <= 12; bs++ { - decoder := NewDecoder(bytes.NewBufferString(gitBigtest.encoded)); - buf := make([]byte, len(gitBigtest.decoded)+12); - var total int; + decoder := NewDecoder(bytes.NewBufferString(gitBigtest.encoded)) + buf := make([]byte, len(gitBigtest.decoded)+12) + var total int for total = 0; total < len(gitBigtest.decoded); { - n, err := decoder.Read(buf[total : total+bs]); - testEqual(t, "Read from %q at pos %d = %d, %v, want _, %v", gitBigtest.encoded, total, n, err, os.Error(nil)); - total += n; + n, err := decoder.Read(buf[total : total+bs]) + testEqual(t, "Read from %q at pos %d = %d, %v, want _, %v", gitBigtest.encoded, total, n, err, os.Error(nil)) + total += n } - testEqual(t, "Decoding/%d of %q = %q, want %q", bs, gitBigtest.encoded, string(buf[0:total]), gitBigtest.decoded); + testEqual(t, "Decoding/%d of %q = %q, want %q", bs, gitBigtest.encoded, string(buf[0:total]), gitBigtest.decoded) } } func TestDecodeCorrupt(t *testing.T) { type corrupt struct { - e string; - p int; + e string + p int } examples := []corrupt{ corrupt{"v", 0}, corrupt{"!z!!!!!!!!!", 0}, - }; + } for _, e := range examples { - dbuf := make([]byte, 2*len(e.e)); - _, err := Decode(dbuf, strings.Bytes(e.e)); + dbuf := make([]byte, 2*len(e.e)) + _, err := Decode(dbuf, strings.Bytes(e.e)) switch err := err.(type) { case CorruptInputError: testEqual(t, "Corruption in %q at offset %v, want %v", e.e, int(err), e.p) @@ -166,34 +166,34 @@ func TestDecodeCorrupt(t *testing.T) { } func TestGitBig(t *testing.T) { - n := 3*1000 + 1; - raw := make([]byte, n); - const alpha = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"; + n := 3*1000 + 1 + raw := make([]byte, n) + const alpha = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" for i := 0; i < n; i++ { raw[i] = alpha[i%len(alpha)] } - encoded := new(bytes.Buffer); - w := NewEncoder(encoded); - nn, err := w.Write(raw); + encoded := new(bytes.Buffer) + w := NewEncoder(encoded) + nn, err := w.Write(raw) if nn != n || err != nil { t.Fatalf("Encoder.Write(raw) = %d, %v want %d, nil", nn, err, n) } - err = w.Close(); + err = w.Close() if err != nil { t.Fatalf("Encoder.Close() = %v want nil", err) } - decoded, err := ioutil.ReadAll(NewDecoder(encoded)); + decoded, err := ioutil.ReadAll(NewDecoder(encoded)) if err != nil { t.Fatalf("ioutil.ReadAll(NewDecoder(...)): %v", err) } if !bytes.Equal(raw, decoded) { - var i int; + var i int for i = 0; i < len(decoded) && i < len(raw); i++ { if decoded[i] != raw[i] { break } } - t.Errorf("Decode(Encode(%d-byte string)) failed at offset %d", n, i); + t.Errorf("Decode(Encode(%d-byte string)) failed at offset %d", n, i) } } diff --git a/src/pkg/encoding/hex/hex.go b/src/pkg/encoding/hex/hex.go index 17c4ae842..8a9271c23 100644 --- a/src/pkg/encoding/hex/hex.go +++ b/src/pkg/encoding/hex/hex.go @@ -6,15 +6,15 @@ package hex import ( - "os"; - "strconv"; - "strings"; + "os" + "strconv" + "strings" ) const hextable = "0123456789abcdef" // EncodedLen returns the length of an encoding of n source bytes. -func EncodedLen(n int) int { return n * 2 } +func EncodedLen(n int) int { return n * 2 } // Encode encodes src into EncodedLen(len(src)) // bytes of dst. As a convenience, it returns the number @@ -22,17 +22,17 @@ func EncodedLen(n int) int { return n * 2 } // Encode implements hexadecimal encoding. func Encode(dst, src []byte) int { for i, v := range src { - dst[i*2] = hextable[v>>4]; - dst[i*2+1] = hextable[v&0x0f]; + dst[i*2] = hextable[v>>4] + dst[i*2+1] = hextable[v&0x0f] } - return len(src) * 2; + return len(src) * 2 } // OddLengthInputError results from decoding an odd length slice. type OddLengthInputError struct{} -func (OddLengthInputError) String() string { return "odd length hex string" } +func (OddLengthInputError) String() string { return "odd length hex string" } // InvalidHexCharError results from finding an invalid character in a hex string. type InvalidHexCharError byte @@ -42,7 +42,7 @@ func (e InvalidHexCharError) String() string { } -func DecodedLen(x int) int { return x / 2 } +func DecodedLen(x int) int { return x / 2 } // Decode decodes src into DecodedLen(len(src)) bytes, returning the actual // number of bytes written to dst. @@ -55,18 +55,18 @@ func Decode(dst, src []byte) (int, os.Error) { } for i := 0; i < len(src)/2; i++ { - a, ok := fromHexChar(src[i*2]); + a, ok := fromHexChar(src[i*2]) if !ok { return 0, InvalidHexCharError(src[i*2]) } - b, ok := fromHexChar(src[i*2+1]); + b, ok := fromHexChar(src[i*2+1]) if !ok { return 0, InvalidHexCharError(src[i*2+1]) } - dst[i] = (a << 4) | b; + dst[i] = (a << 4) | b } - return len(src) / 2, nil; + return len(src) / 2, nil } // fromHexChar converts a hex character into its value and a success flag. @@ -80,23 +80,23 @@ func fromHexChar(c byte) (byte, bool) { return c - 'A' + 10, true } - return 0, false; + return 0, false } // EncodeToString returns the hexadecimal encoding of src. func EncodeToString(src []byte) string { - dst := make([]byte, EncodedLen(len(src))); - Encode(dst, src); - return string(dst); + dst := make([]byte, EncodedLen(len(src))) + Encode(dst, src) + return string(dst) } // DecodeString returns the bytes represented by the hexadecimal string s. func DecodeString(s string) ([]byte, os.Error) { - src := strings.Bytes(s); - dst := make([]byte, DecodedLen(len(src))); - _, err := Decode(dst, src); + src := strings.Bytes(s) + dst := make([]byte, DecodedLen(len(src))) + _, err := Decode(dst, src) if err != nil { return nil, err } - return dst, nil; + return dst, nil } diff --git a/src/pkg/encoding/hex/hex_test.go b/src/pkg/encoding/hex/hex_test.go index e409dbd1e..d741e595a 100644 --- a/src/pkg/encoding/hex/hex_test.go +++ b/src/pkg/encoding/hex/hex_test.go @@ -5,12 +5,12 @@ package hex import ( - "bytes"; - "testing"; + "bytes" + "testing" ) type encodeTest struct { - in, out []byte; + in, out []byte } var encodeTests = []encodeTest{ @@ -38,8 +38,8 @@ var encodeTests = []encodeTest{ func TestEncode(t *testing.T) { for i, test := range encodeTests { - dst := make([]byte, EncodedLen(len(test.in))); - n := Encode(dst, test.in); + dst := make([]byte, EncodedLen(len(test.in))) + n := Encode(dst, test.in) if n != len(dst) { t.Errorf("#%d: bad return value: got: %d want: %d", i, n, len(dst)) } @@ -50,8 +50,8 @@ func TestEncode(t *testing.T) { } type decodeTest struct { - in, out []byte; - ok bool; + in, out []byte + ok bool } var decodeTests = []decodeTest{ @@ -84,8 +84,8 @@ var decodeTests = []decodeTest{ func TestDecode(t *testing.T) { for i, test := range decodeTests { - dst := make([]byte, DecodedLen(len(test.in))); - n, err := Decode(dst, test.in); + dst := make([]byte, DecodedLen(len(test.in))) + n, err := Decode(dst, test.in) if err == nil && n != len(dst) { t.Errorf("#%d: bad return value: got:%d want:%d", i, n, len(dst)) } @@ -99,8 +99,8 @@ func TestDecode(t *testing.T) { } type encodeStringTest struct { - in []byte; - out string; + in []byte + out string } var encodeStringTests = []encodeStringTest{ @@ -112,7 +112,7 @@ var encodeStringTests = []encodeStringTest{ func TestEncodeToString(t *testing.T) { for i, test := range encodeStringTests { - s := EncodeToString(test.in); + s := EncodeToString(test.in) if s != test.out { t.Errorf("#%d got:%s want:%s", i, s, test.out) } @@ -120,9 +120,9 @@ func TestEncodeToString(t *testing.T) { } type decodeStringTest struct { - in string; - out []byte; - ok bool; + in string + out []byte + ok bool } var decodeStringTests = []decodeStringTest{ @@ -136,7 +136,7 @@ var decodeStringTests = []decodeStringTest{ func TestDecodeString(t *testing.T) { for i, test := range decodeStringTests { - dst, err := DecodeString(test.in); + dst, err := DecodeString(test.in) if test.ok != (err == nil) { t.Errorf("#%d: unexpected err value: %s", i, err) } diff --git a/src/pkg/encoding/pem/pem.go b/src/pkg/encoding/pem/pem.go index 7828d87c1..168a47168 100644 --- a/src/pkg/encoding/pem/pem.go +++ b/src/pkg/encoding/pem/pem.go @@ -8,9 +8,9 @@ package pem import ( - "bytes"; - "encoding/base64"; - "strings"; + "bytes" + "encoding/base64" + "strings" ) // A Block represents a PEM encoded structure. @@ -22,9 +22,9 @@ import ( // -----END Type----- // where Headers is a possibly empty sequence of Key: Value lines. type Block struct { - Type string; // The type, taken from the preamble (i.e. "RSA PRIVATE KEY"). - Headers map[string]string; // Optional headers. - Bytes []byte; // The decoded bytes of the contents. Typically a DER encoded ASN.1 structure. + Type string // The type, taken from the preamble (i.e. "RSA PRIVATE KEY"). + Headers map[string]string // Optional headers. + Bytes []byte // The decoded bytes of the contents. Typically a DER encoded ASN.1 structure. } // getLine results the first \r\n or \n delineated line from the given byte @@ -32,35 +32,35 @@ type Block struct { // array (also not including the new line bytes) is also returned and this will // always be smaller than the original argument. func getLine(data []byte) (line, rest []byte) { - i := bytes.Index(data, []byte{'\n'}); - var j int; + i := bytes.Index(data, []byte{'\n'}) + var j int if i < 0 { - i = len(data); - j = i; + i = len(data) + j = i } else { - j = i + 1; + j = i + 1 if i > 0 && data[i-1] == '\r' { i-- } } - return data[0:i], data[j:]; + return data[0:i], data[j:] } // removeWhitespace returns a copy of its input with all spaces, tab and // newline characters removed. func removeWhitespace(data []byte) []byte { - result := make([]byte, len(data)); - n := 0; + result := make([]byte, len(data)) + n := 0 for _, b := range data { if b == ' ' || b == '\t' || b == '\r' || b == '\n' { continue } - result[n] = b; - n++; + result[n] = b + n++ } - return result[0:n]; + return result[0:n] } var pemStart = strings.Bytes("\n-----BEGIN ") @@ -74,7 +74,7 @@ var pemEndOfLine = strings.Bytes("-----") func Decode(data []byte) (p *Block, rest []byte) { // pemStart begins with a newline. However, at the very beginning of // the byte array, we'll accept the start string without it. - rest = data; + rest = data if bytes.HasPrefix(data, pemStart[1:]) { rest = rest[len(pemStart)-1 : len(data)] } else if i := bytes.Index(data, pemStart); i >= 0 { @@ -83,16 +83,16 @@ func Decode(data []byte) (p *Block, rest []byte) { return nil, data } - typeLine, rest := getLine(rest); + typeLine, rest := getLine(rest) if !bytes.HasSuffix(typeLine, pemEndOfLine) { goto Error } - typeLine = typeLine[0 : len(typeLine)-len(pemEndOfLine)]; + typeLine = typeLine[0 : len(typeLine)-len(pemEndOfLine)] p = &Block{ Headers: make(map[string]string), Type: string(typeLine), - }; + } for { // This loop terminates because getLine's second result is @@ -100,37 +100,37 @@ func Decode(data []byte) (p *Block, rest []byte) { if len(rest) == 0 { return nil, data } - line, next := getLine(rest); + line, next := getLine(rest) - i := bytes.Index(line, []byte{':'}); + i := bytes.Index(line, []byte{':'}) if i == -1 { break } // TODO(agl): need to cope with values that spread across lines. - key, val := line[0:i], line[i+1:]; - key = bytes.TrimSpace(key); - val = bytes.TrimSpace(val); - p.Headers[string(key)] = string(val); - rest = next; + key, val := line[0:i], line[i+1:] + key = bytes.TrimSpace(key) + val = bytes.TrimSpace(val) + p.Headers[string(key)] = string(val) + rest = next } - i := bytes.Index(rest, pemEnd); + i := bytes.Index(rest, pemEnd) if i < 0 { goto Error } - base64Data := removeWhitespace(rest[0:i]); + base64Data := removeWhitespace(rest[0:i]) - p.Bytes = make([]byte, base64.StdEncoding.DecodedLen(len(base64Data))); - n, err := base64.StdEncoding.Decode(p.Bytes, base64Data); + p.Bytes = make([]byte, base64.StdEncoding.DecodedLen(len(base64Data))) + n, err := base64.StdEncoding.Decode(p.Bytes, base64Data) if err != nil { goto Error } - p.Bytes = p.Bytes[0:n]; + p.Bytes = p.Bytes[0:n] - _, rest = getLine(rest[i+len(pemEnd):]); + _, rest = getLine(rest[i+len(pemEnd):]) - return; + return Error: // If we get here then we have rejected a likely looking, but @@ -153,9 +153,9 @@ Error: // // we've failed to parse using the first BEGIN line // and now will try again, using the second BEGIN line. - p, rest = Decode(rest); + p, rest = Decode(rest) if p == nil { rest = data } - return; + return } diff --git a/src/pkg/encoding/pem/pem_test.go b/src/pkg/encoding/pem/pem_test.go index 262dadd37..47b96e97f 100644 --- a/src/pkg/encoding/pem/pem_test.go +++ b/src/pkg/encoding/pem/pem_test.go @@ -5,13 +5,13 @@ package pem import ( - "testing"; - "strings"; - "reflect"; + "testing" + "strings" + "reflect" ) type GetLineTest struct { - in, out1, out2 string; + in, out1, out2 string } var getLineTests = []GetLineTest{ @@ -27,7 +27,7 @@ var getLineTests = []GetLineTest{ func TestGetLine(t *testing.T) { for i, test := range getLineTests { - x, y := getLine(strings.Bytes(test.in)); + x, y := getLine(strings.Bytes(test.in)) if string(x) != test.out1 || string(y) != test.out2 { t.Errorf("#%d got:%+v,%+v want:%s,%s", i, x, y, test.out1, test.out2) } @@ -35,15 +35,15 @@ func TestGetLine(t *testing.T) { } func TestDecode(t *testing.T) { - result, remainder := Decode(strings.Bytes(pemData)); + result, remainder := Decode(strings.Bytes(pemData)) if !reflect.DeepEqual(result, certificate) { t.Errorf("#0 got:%#v want:%#v", result, certificate) } - result, remainder = Decode(remainder); + result, remainder = Decode(remainder) if !reflect.DeepEqual(result, privateKey) { t.Errorf("#1 got:%#v want:%#v", result, privateKey) } - result, _ = Decode(strings.Bytes(pemPrivateKey)); + result, _ = Decode(strings.Bytes(pemPrivateKey)) if !reflect.DeepEqual(result, privateKey2) { t.Errorf("#2 got:%#v want:%#v", result, privateKey2) } diff --git a/src/pkg/exec/exec.go b/src/pkg/exec/exec.go index 8a19f0e8f..8e959e03a 100644 --- a/src/pkg/exec/exec.go +++ b/src/pkg/exec/exec.go @@ -6,16 +6,16 @@ package exec import ( - "os"; - "strings"; + "os" + "strings" ) // Arguments to Run. const ( - DevNull = iota; - PassThrough; - Pipe; - MergeWithStdout; + DevNull = iota + PassThrough + Pipe + MergeWithStdout ) // A Cmd represents a running command. @@ -24,10 +24,10 @@ const ( // or else nil, depending on the arguments to Run. // Pid is the running command's operating system process ID. type Cmd struct { - Stdin *os.File; - Stdout *os.File; - Stderr *os.File; - Pid int; + Stdin *os.File + Stdout *os.File + Stderr *os.File + Pid int } // Given mode (DevNull, etc), return file for child @@ -35,12 +35,12 @@ type Cmd struct { func modeToFiles(mode, fd int) (*os.File, *os.File, os.Error) { switch mode { case DevNull: - rw := os.O_WRONLY; + rw := os.O_WRONLY if fd == 0 { rw = os.O_RDONLY } - f, err := os.Open("/dev/null", rw, 0); - return f, nil, err; + f, err := os.Open("/dev/null", rw, 0) + return f, nil, err case PassThrough: switch fd { case 0: @@ -51,16 +51,16 @@ func modeToFiles(mode, fd int) (*os.File, *os.File, os.Error) { return os.Stderr, nil, nil } case Pipe: - r, w, err := os.Pipe(); + r, w, err := os.Pipe() if err != nil { return nil, nil, err } if fd == 0 { return r, w, nil } - return w, r, nil; + return w, r, nil } - return nil, nil, os.EINVAL; + return nil, nil, os.EINVAL } // Run starts the binary prog running with @@ -79,8 +79,8 @@ func modeToFiles(mode, fd int) (*os.File, *os.File, os.Error) { // of the returned Cmd is the other end of the pipe. // Otherwise the field in Cmd is nil. func Run(argv0 string, argv, envv []string, stdin, stdout, stderr int) (p *Cmd, err os.Error) { - p = new(Cmd); - var fd [3]*os.File; + p = new(Cmd) + var fd [3]*os.File if fd[0], p.Stdin, err = modeToFiles(stdin, 0); err != nil { goto Error @@ -95,7 +95,7 @@ func Run(argv0 string, argv, envv []string, stdin, stdout, stderr int) (p *Cmd, } // Run command. - p.Pid, err = os.ForkExec(argv0, argv, envv, "", &fd); + p.Pid, err = os.ForkExec(argv0, argv, envv, "", &fd) if err != nil { goto Error } @@ -108,7 +108,7 @@ func Run(argv0 string, argv, envv []string, stdin, stdout, stderr int) (p *Cmd, if fd[2] != os.Stderr && fd[2] != fd[1] { fd[2].Close() } - return p, nil; + return p, nil Error: if fd[0] != os.Stdin && fd[0] != nil { @@ -129,7 +129,7 @@ Error: if p.Stderr != nil { p.Stderr.Close() } - return nil, err; + return nil, err } // Wait waits for the running command p, @@ -142,11 +142,11 @@ func (p *Cmd) Wait(options int) (*os.Waitmsg, os.Error) { if p.Pid <= 0 { return nil, os.ErrorString("exec: invalid use of Cmd.Wait") } - w, err := os.Wait(p.Pid, options); + w, err := os.Wait(p.Pid, options) if w != nil && (w.Exited() || w.Signaled()) { p.Pid = -1 } - return w, err; + return w, err } // Close waits for the running command p to exit, @@ -157,14 +157,14 @@ func (p *Cmd) Close() os.Error { // Loop on interrupt, but // ignore other errors -- maybe // caller has already waited for pid. - _, err := p.Wait(0); + _, err := p.Wait(0) for err == os.EINTR { _, err = p.Wait(0) } } // Close the FDs that are still open. - var err os.Error; + var err os.Error if p.Stdin != nil && p.Stdin.Fd() >= 0 { if err1 := p.Stdin.Close(); err1 != nil { err = err1 @@ -180,15 +180,15 @@ func (p *Cmd) Close() os.Error { err = err1 } } - return err; + return err } func canExec(file string) bool { - d, err := os.Stat(file); + d, err := os.Stat(file) if err != nil { return false } - return d.IsRegular() && d.Permission()&0111 != 0; + return d.IsRegular() && d.Permission()&0111 != 0 } // LookPath searches for an executable binary named file @@ -205,9 +205,9 @@ func LookPath(file string) (string, os.Error) { if canExec(file) { return file, nil } - return "", os.ENOENT; + return "", os.ENOENT } - pathenv := os.Getenv("PATH"); + pathenv := os.Getenv("PATH") for _, dir := range strings.Split(pathenv, ":", 0) { if dir == "" { // Unix shell semantics: path element "" means "." @@ -217,5 +217,5 @@ func LookPath(file string) (string, os.Error) { return dir + "/" + file, nil } } - return "", os.ENOENT; + return "", os.ENOENT } diff --git a/src/pkg/exec/exec_test.go b/src/pkg/exec/exec_test.go index 5a997fd19..9c4d2ee31 100644 --- a/src/pkg/exec/exec_test.go +++ b/src/pkg/exec/exec_test.go @@ -5,20 +5,20 @@ package exec import ( - "io"; - "io/ioutil"; - "testing"; + "io" + "io/ioutil" + "testing" ) func TestRunCat(t *testing.T) { cmd, err := Run("/bin/cat", []string{"cat"}, nil, - Pipe, Pipe, DevNull); + Pipe, Pipe, DevNull) if err != nil { t.Fatalf("opencmd /bin/cat: %v", err) } - io.WriteString(cmd.Stdin, "hello, world\n"); - cmd.Stdin.Close(); - buf, err := ioutil.ReadAll(cmd.Stdout); + io.WriteString(cmd.Stdin, "hello, world\n") + cmd.Stdin.Close() + buf, err := ioutil.ReadAll(cmd.Stdout) if err != nil { t.Fatalf("reading from /bin/cat: %v", err) } @@ -32,11 +32,11 @@ func TestRunCat(t *testing.T) { func TestRunEcho(t *testing.T) { cmd, err := Run("/bin/echo", []string{"echo", "hello", "world"}, nil, - DevNull, Pipe, DevNull); + DevNull, Pipe, DevNull) if err != nil { t.Fatalf("opencmd /bin/echo: %v", err) } - buf, err := ioutil.ReadAll(cmd.Stdout); + buf, err := ioutil.ReadAll(cmd.Stdout) if err != nil { t.Fatalf("reading from /bin/echo: %v", err) } diff --git a/src/pkg/exp/4s/4s.go b/src/pkg/exp/4s/4s.go index ffd9d5370..271af78e2 100644 --- a/src/pkg/exp/4s/4s.go +++ b/src/pkg/exp/4s/4s.go @@ -10,11 +10,11 @@ package main import ( - "exp/nacl/av"; - "exp/nacl/srpc"; - "log"; - "runtime"; - "os"; + "exp/nacl/av" + "exp/nacl/srpc" + "log" + "runtime" + "os" ) var sndc chan []uint16 @@ -22,57 +22,57 @@ var sndc chan []uint16 func main() { // Native Client requires that some calls are issued // consistently by the same OS thread. - runtime.LockOSThread(); + runtime.LockOSThread() if srpc.Enabled() { go srpc.ServeRuntime() } - args := os.Args; - p := pieces4; + args := os.Args + p := pieces4 if len(args) > 1 && args[1] == "-5" { p = pieces5 } - dx, dy := 500, 500; - w, err := av.Init(av.SubsystemVideo|av.SubsystemAudio, dx, dy); + dx, dy := 500, 500 + w, err := av.Init(av.SubsystemVideo|av.SubsystemAudio, dx, dy) if err != nil { log.Exit(err) } - sndc = make(chan []uint16, 10); - go audioServer(); - Play(p, w); + sndc = make(chan []uint16, 10) + go audioServer() + Play(p, w) } func audioServer() { // Native Client requires that all audio calls // original from a single OS thread. - runtime.LockOSThread(); + runtime.LockOSThread() - n, err := av.AudioStream(nil); + n, err := av.AudioStream(nil) if err != nil { log.Exit(err) } for { - b := <-sndc; + b := <-sndc for len(b)*2 >= n { - var a []uint16; - a, b = b[0:n/2], b[n/2:]; - n, err = av.AudioStream(a); + var a []uint16 + a, b = b[0:n/2], b[n/2:] + n, err = av.AudioStream(a) if err != nil { log.Exit(err) } - println(n, len(b)*2); + println(n, len(b)*2) } - a := make([]uint16, n/2); + a := make([]uint16, n/2) for i := range b { a[i] = b[i] } - n, err = av.AudioStream(a); + n, err = av.AudioStream(a) } } -func PlaySound(b []uint16) { sndc <- b } +func PlaySound(b []uint16) { sndc <- b } var whoosh = []uint16{ // Insert your favorite sound samples here. diff --git a/src/pkg/exp/4s/5s.go b/src/pkg/exp/4s/5s.go index 08899193e..efeb6f116 100644 --- a/src/pkg/exp/4s/5s.go +++ b/src/pkg/exp/4s/5s.go @@ -6,4 +6,4 @@ package main -func init() { pieces4 = pieces5 } +func init() { pieces4 = pieces5 } diff --git a/src/pkg/exp/4s/xs.go b/src/pkg/exp/4s/xs.go index ae994d2c3..94a6f8597 100644 --- a/src/pkg/exp/4s/xs.go +++ b/src/pkg/exp/4s/xs.go @@ -15,12 +15,12 @@ package main import ( - "exp/draw"; - "image"; - "log"; - "os"; - "rand"; - "time"; + "exp/draw" + "image" + "log" + "os" + "rand" + "time" ) /* @@ -38,57 +38,57 @@ Cursor whitearrow = { */ const ( - CNone = 0; - CBounds = 1; - CPiece = 2; - NX = 10; - NY = 20; + CNone = 0 + CBounds = 1 + CPiece = 2 + NX = 10 + NY = 20 - NCOL = 10; + NCOL = 10 - MAXN = 5; + MAXN = 5 ) var ( - N int; - display draw.Context; - screen draw.Image; - screenr draw.Rectangle; - board [NY][NX]byte; - rboard draw.Rectangle; - pscore draw.Point; - scoresz draw.Point; - pcsz = 32; - pos draw.Point; - bbr, bb2r draw.Rectangle; - bb, bbmask, bb2, bb2mask *image.RGBA; - whitemask image.Image; - br, br2 draw.Rectangle; - points int; - dt int; - DY int; - DMOUSE int; - lastmx int; - mouse draw.Mouse; - newscreen bool; - timerc <-chan int64; - suspc chan bool; - mousec chan draw.Mouse; - resizec <-chan bool; - kbdc chan int; - suspended bool; - tsleep int; - piece *Piece; - pieces []Piece; + N int + display draw.Context + screen draw.Image + screenr draw.Rectangle + board [NY][NX]byte + rboard draw.Rectangle + pscore draw.Point + scoresz draw.Point + pcsz = 32 + pos draw.Point + bbr, bb2r draw.Rectangle + bb, bbmask, bb2, bb2mask *image.RGBA + whitemask image.Image + br, br2 draw.Rectangle + points int + dt int + DY int + DMOUSE int + lastmx int + mouse draw.Mouse + newscreen bool + timerc <-chan int64 + suspc chan bool + mousec chan draw.Mouse + resizec <-chan bool + kbdc chan int + suspended bool + tsleep int + piece *Piece + pieces []Piece ) type Piece struct { - rot int; - tx int; - sz draw.Point; - d []draw.Point; - left *Piece; - right *Piece; + rot int + tx int + sz draw.Point + d []draw.Point + left *Piece + right *Piece } var txbits = [NCOL][32]byte{ @@ -145,16 +145,16 @@ var txbits = [NCOL][32]byte{ } var txpix = [NCOL]draw.Color{ - draw.Yellow, /* yellow */ - draw.Cyan, /* cyan */ - draw.Green, /* lime green */ - draw.GreyBlue, /* slate */ - draw.Red, /* red */ - draw.GreyGreen, /* olive green */ - draw.Blue, /* blue */ - draw.Color(0xFF55AAFF), /* pink */ - draw.Color(0xFFAAFFFF), /* lavender */ - draw.Color(0xBB005DFF), /* maroon */ + draw.Yellow, /* yellow */ + draw.Cyan, /* cyan */ + draw.Green, /* lime green */ + draw.GreyBlue, /* slate */ + draw.Red, /* red */ + draw.GreyGreen, /* olive green */ + draw.Blue, /* blue */ + draw.Color(0xFF55AAFF), /* pink */ + draw.Color(0xFFAAFFFF), /* lavender */ + draw.Color(0xBB005DFF), /* maroon */ } func movemouse() int { @@ -165,7 +165,7 @@ func movemouse() int { func warp(p draw.Point, x int) int { if !suspended && piece != nil { - x = pos.X + piece.sz.X*pcsz/2; + x = pos.X + piece.sz.X*pcsz/2 if p.Y < rboard.Min.Y { p.Y = rboard.Min.Y } @@ -174,12 +174,12 @@ func warp(p draw.Point, x int) int { } //moveto(mousectl, draw.Pt(x, p.Y)); } - return x; + return x } func initPieces() { for i := range pieces { - p := &pieces[i]; + p := &pieces[i] if p.rot == 3 { p.right = &pieces[i-3] } else { @@ -194,27 +194,27 @@ func initPieces() { } func collide(pt draw.Point, p *Piece) bool { - pt.X = (pt.X - rboard.Min.X) / pcsz; - pt.Y = (pt.Y - rboard.Min.Y) / pcsz; + pt.X = (pt.X - rboard.Min.X) / pcsz + pt.Y = (pt.Y - rboard.Min.Y) / pcsz for _, q := range p.d { - pt.X += q.X; - pt.Y += q.Y; + pt.X += q.X + pt.Y += q.Y if pt.X < 0 || pt.X >= NX || pt.Y < 0 || pt.Y >= NY { - return true; - continue; + return true + continue } if board[pt.Y][pt.X] != 0 { return true } } - return false; + return false } func collider(pt, pmax draw.Point) bool { - pi := (pt.X - rboard.Min.X) / pcsz; - pj := (pt.Y - rboard.Min.Y) / pcsz; - n := pmax.X / pcsz; - m := pmax.Y/pcsz + 1; + pi := (pt.X - rboard.Min.X) / pcsz + pj := (pt.Y - rboard.Min.Y) / pcsz + n := pmax.X / pcsz + m := pmax.Y/pcsz + 1 for i := pi; i < pi+n && i < NX; i++ { for j := pj; j < pj+m && j < NY; j++ { if board[j][i] != 0 { @@ -222,34 +222,34 @@ func collider(pt, pmax draw.Point) bool { } } } - return false; + return false } func setpiece(p *Piece) { - draw.Draw(bb, bbr, draw.White, nil, draw.ZP); - draw.Draw(bbmask, bbr, draw.Transparent, nil, draw.ZP); - br = draw.Rect(0, 0, 0, 0); - br2 = br; - piece = p; + draw.Draw(bb, bbr, draw.White, nil, draw.ZP) + draw.Draw(bbmask, bbr, draw.Transparent, nil, draw.ZP) + br = draw.Rect(0, 0, 0, 0) + br2 = br + piece = p if p == nil { return } - var op draw.Point; - var r draw.Rectangle; - r.Min = bbr.Min; + var op draw.Point + var r draw.Rectangle + r.Min = bbr.Min for i, pt := range p.d { - r.Min.X += pt.X * pcsz; - r.Min.Y += pt.Y * pcsz; - r.Max.X = r.Min.X + pcsz; - r.Max.Y = r.Min.Y + pcsz; + r.Min.X += pt.X * pcsz + r.Min.Y += pt.Y * pcsz + r.Max.X = r.Min.X + pcsz + r.Max.Y = r.Min.Y + pcsz if i == 0 { - draw.Draw(bb, r, draw.Black, nil, draw.ZP); - draw.Draw(bb, r.Inset(1), txpix[piece.tx], nil, draw.ZP); - draw.Draw(bbmask, r, draw.Opaque, nil, draw.ZP); - op = r.Min; + draw.Draw(bb, r, draw.Black, nil, draw.ZP) + draw.Draw(bb, r.Inset(1), txpix[piece.tx], nil, draw.ZP) + draw.Draw(bbmask, r, draw.Opaque, nil, draw.ZP) + op = r.Min } else { - draw.Draw(bb, r, bb, nil, op); - draw.Draw(bbmask, r, bbmask, nil, op); + draw.Draw(bb, r, bb, nil, op) + draw.Draw(bbmask, r, bbmask, nil, op) } if br.Max.X < r.Max.X { br.Max.X = r.Max.X @@ -258,66 +258,66 @@ func setpiece(p *Piece) { br.Max.Y = r.Max.Y } } - br.Max = br.Max.Sub(bbr.Min); - delta := draw.Pt(0, DY); - br2.Max = br.Max.Add(delta); - r = br.Add(bb2r.Min); - r2 := br2.Add(bb2r.Min); - draw.Draw(bb2, r2, draw.White, nil, draw.ZP); - draw.Draw(bb2, r.Add(delta), bb, nil, bbr.Min); - draw.Draw(bb2mask, r2, draw.Transparent, nil, draw.ZP); - draw.Draw(bb2mask, r, draw.Opaque, bbmask, bbr.Min); - draw.Draw(bb2mask, r.Add(delta), draw.Opaque, bbmask, bbr.Min); + br.Max = br.Max.Sub(bbr.Min) + delta := draw.Pt(0, DY) + br2.Max = br.Max.Add(delta) + r = br.Add(bb2r.Min) + r2 := br2.Add(bb2r.Min) + draw.Draw(bb2, r2, draw.White, nil, draw.ZP) + draw.Draw(bb2, r.Add(delta), bb, nil, bbr.Min) + draw.Draw(bb2mask, r2, draw.Transparent, nil, draw.ZP) + draw.Draw(bb2mask, r, draw.Opaque, bbmask, bbr.Min) + draw.Draw(bb2mask, r.Add(delta), draw.Opaque, bbmask, bbr.Min) } func drawpiece() { - draw.Draw(screen, br.Add(pos), bb, bbmask, bbr.Min); + draw.Draw(screen, br.Add(pos), bb, bbmask, bbr.Min) if suspended { draw.Draw(screen, br.Add(pos), draw.White, whitemask, draw.ZP) } } func undrawpiece() { - var mask image.Image; + var mask image.Image if collider(pos, br.Max) { mask = bbmask } - draw.Draw(screen, br.Add(pos), draw.White, mask, bbr.Min); + draw.Draw(screen, br.Add(pos), draw.White, mask, bbr.Min) } func rest() { - pt := pos.Sub(rboard.Min).Div(pcsz); + pt := pos.Sub(rboard.Min).Div(pcsz) for _, p := range piece.d { - pt.X += p.X; - pt.Y += p.Y; - board[pt.Y][pt.X] = byte(piece.tx + 16); + pt.X += p.X + pt.Y += p.Y + board[pt.Y][pt.X] = byte(piece.tx + 16) } } func canfit(p *Piece) bool { - var dx = [...]int{0, -1, 1, -2, 2, -3, 3, 4, -4}; - j := N + 1; + var dx = [...]int{0, -1, 1, -2, 2, -3, 3, 4, -4} + j := N + 1 if j >= 4 { - j = p.sz.X; + j = p.sz.X if j < p.sz.Y { j = p.sz.Y } - j = 2*j - 1; + j = 2*j - 1 } for i := 0; i < j; i++ { - var z draw.Point; - z.X = pos.X + dx[i]*pcsz; - z.Y = pos.Y; + var z draw.Point + z.X = pos.X + dx[i]*pcsz + z.Y = pos.Y if !collide(z, p) { - z.Y = pos.Y + pcsz - 1; + z.Y = pos.Y + pcsz - 1 if !collide(z, p) { - undrawpiece(); - pos.X = z.X; - return true; + undrawpiece() + pos.X = z.X + return true } } } - return false; + return false } func score(p int) { @@ -328,18 +328,18 @@ func score(p int) { } func drawsq(b draw.Image, p draw.Point, ptx int) { - var r draw.Rectangle; - r.Min = p; - r.Max.X = r.Min.X + pcsz; - r.Max.Y = r.Min.Y + pcsz; - draw.Draw(b, r, draw.Black, nil, draw.ZP); - draw.Draw(b, r.Inset(1), txpix[ptx], nil, draw.ZP); + var r draw.Rectangle + r.Min = p + r.Max.X = r.Min.X + pcsz + r.Max.Y = r.Min.Y + pcsz + draw.Draw(b, r, draw.Black, nil, draw.ZP) + draw.Draw(b, r.Inset(1), txpix[ptx], nil, draw.ZP) } func drawboard() { - draw.Border(screen, rboard.Inset(-2), 2, draw.Black, draw.ZP); + draw.Border(screen, rboard.Inset(-2), 2, draw.Black, draw.ZP) draw.Draw(screen, draw.Rect(rboard.Min.X, rboard.Min.Y-2, rboard.Max.X, rboard.Min.Y), - draw.White, nil, draw.ZP); + draw.White, nil, draw.ZP) for i := 0; i < NY; i++ { for j := 0; j < NX; j++ { if board[i][j] != 0 { @@ -347,7 +347,7 @@ func drawboard() { } } } - score(0); + score(0) if suspended { draw.Draw(screen, screenr, draw.White, whitemask, draw.ZP) } @@ -355,34 +355,34 @@ func drawboard() { func choosepiece() { for { - i := rand.Intn(len(pieces)); - setpiece(&pieces[i]); - pos = rboard.Min; - pos.X += rand.Intn(NX) * pcsz; + i := rand.Intn(len(pieces)) + setpiece(&pieces[i]) + pos = rboard.Min + pos.X += rand.Intn(NX) * pcsz if !collide(draw.Pt(pos.X, pos.Y+pcsz-DY), piece) { break } } - drawpiece(); - display.FlushImage(); + drawpiece() + display.FlushImage() } func movepiece() bool { - var mask image.Image; + var mask image.Image if collide(draw.Pt(pos.X, pos.Y+pcsz), piece) { return false } if collider(pos, br2.Max) { mask = bb2mask } - draw.Draw(screen, br2.Add(pos), bb2, mask, bb2r.Min); - pos.Y += DY; - display.FlushImage(); - return true; + draw.Draw(screen, br2.Add(pos), bb2, mask, bb2r.Min) + pos.Y += DY + display.FlushImage() + return true } func suspend(s bool) { - suspended = s; + suspended = s /* if suspended { setcursor(mousectl, &whitearrow); @@ -393,26 +393,26 @@ func suspend(s bool) { if !suspended { drawpiece() } - drawboard(); - display.FlushImage(); + drawboard() + display.FlushImage() } func pause(t int) { - display.FlushImage(); + display.FlushImage() for { select { case s := <-suspc: if !suspended && s { suspend(true) } else if suspended && !s { - suspend(false); - lastmx = warp(mouse.Point, lastmx); + suspend(false) + lastmx = warp(mouse.Point, lastmx) } case <-timerc: if suspended { break } - t -= tsleep; + t -= tsleep if t < 0 { return } @@ -425,93 +425,93 @@ func pause(t int) { } func horiz() bool { - var lev [MAXN]int; - h := 0; + var lev [MAXN]int + h := 0 for i := 0; i < NY; i++ { for j := 0; board[i][j] != 0; j++ { if j == NX-1 { - lev[h] = i; - h++; - break; + lev[h] = i + h++ + break } } } if h == 0 { return false } - r := rboard; - newscreen = false; + r := rboard + newscreen = false for j := 0; j < h; j++ { - r.Min.Y = rboard.Min.Y + lev[j]*pcsz; - r.Max.Y = r.Min.Y + pcsz; - draw.Draw(screen, r, draw.White, whitemask, draw.ZP); - display.FlushImage(); + r.Min.Y = rboard.Min.Y + lev[j]*pcsz + r.Max.Y = r.Min.Y + pcsz + draw.Draw(screen, r, draw.White, whitemask, draw.ZP) + display.FlushImage() } - PlaySound(whoosh); + PlaySound(whoosh) for i := 0; i < 3; i++ { - pause(250); + pause(250) if newscreen { - drawboard(); - break; + drawboard() + break } for j := 0; j < h; j++ { - r.Min.Y = rboard.Min.Y + lev[j]*pcsz; - r.Max.Y = r.Min.Y + pcsz; - draw.Draw(screen, r, draw.White, whitemask, draw.ZP); + r.Min.Y = rboard.Min.Y + lev[j]*pcsz + r.Max.Y = r.Min.Y + pcsz + draw.Draw(screen, r, draw.White, whitemask, draw.ZP) } - display.FlushImage(); + display.FlushImage() } - r = rboard; + r = rboard for j := 0; j < h; j++ { - i := NY - lev[j] - 1; - score(250 + 10*i*i); - r.Min.Y = rboard.Min.Y; - r.Max.Y = rboard.Min.Y + lev[j]*pcsz; - draw.Draw(screen, r.Add(draw.Pt(0, pcsz)), screen, nil, r.Min); - r.Max.Y = rboard.Min.Y + pcsz; - draw.Draw(screen, r, draw.White, nil, draw.ZP); + i := NY - lev[j] - 1 + score(250 + 10*i*i) + r.Min.Y = rboard.Min.Y + r.Max.Y = rboard.Min.Y + lev[j]*pcsz + draw.Draw(screen, r.Add(draw.Pt(0, pcsz)), screen, nil, r.Min) + r.Max.Y = rboard.Min.Y + pcsz + draw.Draw(screen, r, draw.White, nil, draw.ZP) for k := lev[j] - 1; k >= 0; k-- { board[k+1] = board[k] } - board[0] = [NX]byte{}; + board[0] = [NX]byte{} } - display.FlushImage(); - return true; + display.FlushImage() + return true } func mright() { if !collide(draw.Pt(pos.X+pcsz, pos.Y), piece) && !collide(draw.Pt(pos.X+pcsz, pos.Y+pcsz-DY), piece) { - undrawpiece(); - pos.X += pcsz; - drawpiece(); - display.FlushImage(); + undrawpiece() + pos.X += pcsz + drawpiece() + display.FlushImage() } } func mleft() { if !collide(draw.Pt(pos.X-pcsz, pos.Y), piece) && !collide(draw.Pt(pos.X-pcsz, pos.Y+pcsz-DY), piece) { - undrawpiece(); - pos.X -= pcsz; - drawpiece(); - display.FlushImage(); + undrawpiece() + pos.X -= pcsz + drawpiece() + display.FlushImage() } } func rright() { if canfit(piece.right) { - setpiece(piece.right); - drawpiece(); - display.FlushImage(); + setpiece(piece.right) + drawpiece() + display.FlushImage() } } func rleft() { if canfit(piece.left) { - setpiece(piece.left); - drawpiece(); - display.FlushImage(); + setpiece(piece.left) + drawpiece() + display.FlushImage() } } @@ -519,47 +519,47 @@ var fusst = 0 func drop(f bool) bool { if f { - score(5 * (rboard.Max.Y - pos.Y) / pcsz); + score(5 * (rboard.Max.Y - pos.Y) / pcsz) for movepiece() { } } - fusst = 0; - rest(); + fusst = 0 + rest() if pos.Y == rboard.Min.Y && !horiz() { return true } - horiz(); - setpiece(nil); - pause(1500); - choosepiece(); - lastmx = warp(mouse.Point, lastmx); - return false; + horiz() + setpiece(nil) + pause(1500) + choosepiece() + lastmx = warp(mouse.Point, lastmx) + return false } func play() { - var om draw.Mouse; - dt = 64; - lastmx = -1; - lastmx = movemouse(); - choosepiece(); - lastmx = warp(mouse.Point, lastmx); + var om draw.Mouse + dt = 64 + lastmx = -1 + lastmx = movemouse() + choosepiece() + lastmx = warp(mouse.Point, lastmx) for { select { case mouse = <-mousec: if suspended { - om = mouse; - break; + om = mouse + break } if lastmx < 0 { lastmx = mouse.X } if mouse.X > lastmx+DMOUSE { - mright(); - lastmx = mouse.X; + mright() + lastmx = mouse.X } if mouse.X < lastmx-DMOUSE { - mleft(); - lastmx = mouse.X; + mleft() + lastmx = mouse.X } if mouse.Buttons&^om.Buttons&1 == 1 { rleft() @@ -572,14 +572,14 @@ func play() { if mouse.Buttons&^om.Buttons&4 == 4 { rright() } - om = mouse; + om = mouse case s := <-suspc: if !suspended && s { suspend(true) } else if suspended && !s { - suspend(false); - lastmx = warp(mouse.Point, lastmx); + suspend(false) + lastmx = warp(mouse.Point, lastmx) } case <-resizec: @@ -608,25 +608,25 @@ func play() { if suspended { break } - dt -= tsleep; + dt -= tsleep if dt < 0 { - i := 1; - dt = 16 * (points + rand.Intn(10000) - 5000) / 10000; + i := 1 + dt = 16 * (points + rand.Intn(10000) - 5000) / 10000 if dt >= 32 { - i += (dt - 32) / 16; - dt = 32; + i += (dt - 32) / 16 + dt = 32 } - dt = 52 - dt; + dt = 52 - dt for ; i > 0; i-- { if movepiece() { continue } - fusst++; + fusst++ if fusst == 40 { if drop(false) { return } - break; + break } } } @@ -635,10 +635,10 @@ func play() { } func suspproc() { - mc := display.MouseChan(); - kc := display.KeyboardChan(); + mc := display.MouseChan() + kc := display.KeyboardChan() - s := false; + s := false for { select { case mouse = <-mc: @@ -649,14 +649,14 @@ func suspproc() { os.Exit(0) default: if s { - s = false; - suspc <- s; - break; + s = false + suspc <- s + break } switch r { case 'z', 'Z', 'p', 'P', 0x1B: - s = true; - suspc <- s; + s = true + suspc <- s default: kbdc <- r } @@ -669,74 +669,74 @@ func redraw(new bool) { // if new && getwindow(display, Refmesg) < 0 { // sysfatal("can't reattach to window"); // } - r := draw.Rect(0, 0, screen.Width(), screen.Height()); - pos.X = (pos.X - rboard.Min.X) / pcsz; - pos.Y = (pos.Y - rboard.Min.Y) / pcsz; - dx := r.Max.X - r.Min.X; - dy := r.Max.Y - r.Min.Y - 2*32; - DY = dx / NX; + r := draw.Rect(0, 0, screen.Width(), screen.Height()) + pos.X = (pos.X - rboard.Min.X) / pcsz + pos.Y = (pos.Y - rboard.Min.Y) / pcsz + dx := r.Max.X - r.Min.X + dy := r.Max.Y - r.Min.Y - 2*32 + DY = dx / NX if DY > dy/NY { DY = dy / NY } - DY /= 8; + DY /= 8 if DY > 4 { DY = 4 } - pcsz = DY * 8; - DMOUSE = pcsz / 3; + pcsz = DY * 8 + DMOUSE = pcsz / 3 if pcsz < 8 { log.Exitf("screen too small: %d", pcsz) } - rboard = screenr; - rboard.Min.X += (dx - pcsz*NX) / 2; - rboard.Min.Y += (dy-pcsz*NY)/2 + 32; - rboard.Max.X = rboard.Min.X + NX*pcsz; - rboard.Max.Y = rboard.Min.Y + NY*pcsz; - pscore.X = rboard.Min.X + 8; - pscore.Y = rboard.Min.Y - 32; + rboard = screenr + rboard.Min.X += (dx - pcsz*NX) / 2 + rboard.Min.Y += (dy-pcsz*NY)/2 + 32 + rboard.Max.X = rboard.Min.X + NX*pcsz + rboard.Max.Y = rboard.Min.Y + NY*pcsz + pscore.X = rboard.Min.X + 8 + pscore.Y = rboard.Min.Y - 32 // scoresz = stringsize(font, "000000"); - pos.X = pos.X*pcsz + rboard.Min.X; - pos.Y = pos.Y*pcsz + rboard.Min.Y; - bbr = draw.Rect(0, 0, N*pcsz, N*pcsz); - bb = image.NewRGBA(bbr.Max.X, bbr.Max.Y); - bbmask = image.NewRGBA(bbr.Max.X, bbr.Max.Y); // actually just a bitmap - bb2r = draw.Rect(0, 0, N*pcsz, N*pcsz+DY); - bb2 = image.NewRGBA(bb2r.Dx(), bb2r.Dy()); - bb2mask = image.NewRGBA(bb2r.Dx(), bb2r.Dy()); // actually just a bitmap - draw.Draw(screen, screenr, draw.White, nil, draw.ZP); - drawboard(); - setpiece(piece); + pos.X = pos.X*pcsz + rboard.Min.X + pos.Y = pos.Y*pcsz + rboard.Min.Y + bbr = draw.Rect(0, 0, N*pcsz, N*pcsz) + bb = image.NewRGBA(bbr.Max.X, bbr.Max.Y) + bbmask = image.NewRGBA(bbr.Max.X, bbr.Max.Y) // actually just a bitmap + bb2r = draw.Rect(0, 0, N*pcsz, N*pcsz+DY) + bb2 = image.NewRGBA(bb2r.Dx(), bb2r.Dy()) + bb2mask = image.NewRGBA(bb2r.Dx(), bb2r.Dy()) // actually just a bitmap + draw.Draw(screen, screenr, draw.White, nil, draw.ZP) + drawboard() + setpiece(piece) if piece != nil { drawpiece() } - lastmx = movemouse(); - newscreen = true; - display.FlushImage(); + lastmx = movemouse() + newscreen = true + display.FlushImage() } func quitter(c <-chan bool) { - <-c; - os.Exit(0); + <-c + os.Exit(0) } func Play(pp []Piece, ctxt draw.Context) { - display = ctxt; - screen = ctxt.Screen(); - screenr = draw.Rect(0, 0, screen.Width(), screen.Height()); - pieces = pp; - N = len(pieces[0].d); - initPieces(); - rand.Seed(int64(time.Nanoseconds() % (1e9 - 1))); - whitemask = draw.White.SetAlpha(0x7F); - tsleep = 50; - timerc = time.Tick(int64(tsleep/2) * 1e6); - suspc = make(chan bool); - mousec = make(chan draw.Mouse); - resizec = ctxt.ResizeChan(); - kbdc = make(chan int); - go quitter(ctxt.QuitChan()); - go suspproc(); - points = 0; - redraw(false); - play(); + display = ctxt + screen = ctxt.Screen() + screenr = draw.Rect(0, 0, screen.Width(), screen.Height()) + pieces = pp + N = len(pieces[0].d) + initPieces() + rand.Seed(int64(time.Nanoseconds() % (1e9 - 1))) + whitemask = draw.White.SetAlpha(0x7F) + tsleep = 50 + timerc = time.Tick(int64(tsleep/2) * 1e6) + suspc = make(chan bool) + mousec = make(chan draw.Mouse) + resizec = ctxt.ResizeChan() + kbdc = make(chan int) + go quitter(ctxt.QuitChan()) + go suspproc() + points = 0 + redraw(false) + play() } diff --git a/src/pkg/exp/datafmt/datafmt.go b/src/pkg/exp/datafmt/datafmt.go index 4ed9695ab..0a2354286 100644 --- a/src/pkg/exp/datafmt/datafmt.go +++ b/src/pkg/exp/datafmt/datafmt.go @@ -202,13 +202,13 @@ package datafmt import ( - "bytes"; - "fmt"; - "go/token"; - "io"; - "os"; - "reflect"; - "runtime"; + "bytes" + "fmt" + "go/token" + "io" + "os" + "reflect" + "runtime" ) @@ -238,35 +238,35 @@ type FormatterMap map[string]Formatter // A parsed format expression is built from the following nodes. // type ( - expr interface{}; + expr interface{} - alternatives []expr; // x | y | z + alternatives []expr // x | y | z - sequence []expr; // x y z + sequence []expr // x y z - literal [][]byte; // a list of string segments, possibly starting with '%' + literal [][]byte // a list of string segments, possibly starting with '%' - field struct { - fieldName string; // including "@", "*" - ruleName string; // "" if no rule name specified - }; + field struct { + fieldName string // including "@", "*" + ruleName string // "" if no rule name specified + } - group struct { - indent, body expr; // (indent >> body) - }; + group struct { + indent, body expr // (indent >> body) + } - option struct { - body expr; // [body] - }; + option struct { + body expr // [body] + } - repetition struct { - body, separator expr; // {body / separator} - }; + repetition struct { + body, separator expr // {body / separator} + } - custom struct { - ruleName string; - fun Formatter; - }; + custom struct { + ruleName string + fun Formatter + } ) @@ -290,7 +290,7 @@ type Format map[string]expr // the receiver, and thus can be very light-weight. // type Environment interface { - Copy() Environment; + Copy() Environment } @@ -298,24 +298,24 @@ type Environment interface { // It is provided as argument to custom formatters. // type State struct { - fmt Format; // format in use - env Environment; // user-supplied environment - errors chan os.Error; // not chan *Error (errors <- nil would be wrong!) - hasOutput bool; // true after the first literal has been written - indent bytes.Buffer; // current indentation - output bytes.Buffer; // format output - linePos token.Position; // position of line beginning (Column == 0) - default_ expr; // possibly nil - separator expr; // possibly nil + fmt Format // format in use + env Environment // user-supplied environment + errors chan os.Error // not chan *Error (errors <- nil would be wrong!) + hasOutput bool // true after the first literal has been written + indent bytes.Buffer // current indentation + output bytes.Buffer // format output + linePos token.Position // position of line beginning (Column == 0) + default_ expr // possibly nil + separator expr // possibly nil } func newState(fmt Format, env Environment, errors chan os.Error) *State { - s := new(State); - s.fmt = fmt; - s.env = env; - s.errors = errors; - s.linePos = token.Position{Line: 1}; + s := new(State) + s.fmt = fmt + s.env = env + s.errors = errors + s.linePos = token.Position{Line: 1} // if we have a default rule, cache it's expression for fast access if x, found := fmt["default"]; found { @@ -327,26 +327,26 @@ func newState(fmt Format, env Environment, errors chan os.Error) *State { s.separator = x } - return s; + return s } // Env returns the environment passed to Format.Apply. -func (s *State) Env() interface{} { return s.env } +func (s *State) Env() interface{} { return s.env } // LinePos returns the position of the current line beginning // in the state's output buffer. Line numbers start at 1. // -func (s *State) LinePos() token.Position { return s.linePos } +func (s *State) LinePos() token.Position { return s.linePos } // Pos returns the position of the next byte to be written to the // output buffer. Line numbers start at 1. // func (s *State) Pos() token.Position { - offs := s.output.Len(); - return token.Position{Line: s.linePos.Line, Column: offs - s.linePos.Offset, Offset: offs}; + offs := s.output.Len() + return token.Position{Line: s.linePos.Line, Column: offs - s.linePos.Offset, Offset: offs} } @@ -354,50 +354,50 @@ func (s *State) Pos() token.Position { // string after each newline or form feed character. It cannot return an error. // func (s *State) Write(data []byte) (int, os.Error) { - n := 0; - i0 := 0; + n := 0 + i0 := 0 for i, ch := range data { if ch == '\n' || ch == '\f' { // write text segment and indentation - n1, _ := s.output.Write(data[i0 : i+1]); - n2, _ := s.output.Write(s.indent.Bytes()); - n += n1 + n2; - i0 = i + 1; - s.linePos.Offset = s.output.Len(); - s.linePos.Line++; + n1, _ := s.output.Write(data[i0 : i+1]) + n2, _ := s.output.Write(s.indent.Bytes()) + n += n1 + n2 + i0 = i + 1 + s.linePos.Offset = s.output.Len() + s.linePos.Line++ } } - n3, _ := s.output.Write(data[i0:]); - return n + n3, nil; + n3, _ := s.output.Write(data[i0:]) + return n + n3, nil } type checkpoint struct { - env Environment; - hasOutput bool; - outputLen int; - linePos token.Position; + env Environment + hasOutput bool + outputLen int + linePos token.Position } func (s *State) save() checkpoint { - saved := checkpoint{nil, s.hasOutput, s.output.Len(), s.linePos}; + saved := checkpoint{nil, s.hasOutput, s.output.Len(), s.linePos} if s.env != nil { saved.env = s.env.Copy() } - return saved; + return saved } func (s *State) restore(m checkpoint) { - s.env = m.env; - s.output.Truncate(m.outputLen); + s.env = m.env + s.output.Truncate(m.outputLen) } func (s *State) error(msg string) { - s.errors <- os.NewError(msg); - runtime.Goexit(); + s.errors <- os.NewError(msg) + runtime.Goexit() } @@ -426,7 +426,7 @@ func typename(typ reflect.Type) string { case *reflect.PtrType: return "ptr" } - return typ.String(); + return typ.String() } func (s *State) getFormat(name string) expr { @@ -438,8 +438,8 @@ func (s *State) getFormat(name string) expr { return s.default_ } - s.error(fmt.Sprintf("no format rule for type: '%s'", name)); - return nil; + s.error(fmt.Sprintf("no format rule for type: '%s'", name)) + return nil } @@ -459,42 +459,42 @@ func (s *State) eval(fexpr expr, value reflect.Value, index int) bool { case alternatives: // append the result of the first alternative that evaluates to // a non-nil []byte to the state's output - mark := s.save(); + mark := s.save() for _, x := range t { if s.eval(x, value, index) { return true } - s.restore(mark); + s.restore(mark) } - return false; + return false case sequence: // append the result of all operands to the state's output // unless a nil result is encountered - mark := s.save(); + mark := s.save() for _, x := range t { if !s.eval(x, value, index) { - s.restore(mark); - return false; + s.restore(mark) + return false } } - return true; + return true case literal: // write separator, if any if s.hasOutput { // not the first literal if s.separator != nil { - sep := s.separator; // save current separator - s.separator = nil; // and disable it (avoid recursion) - mark := s.save(); + sep := s.separator // save current separator + s.separator = nil // and disable it (avoid recursion) + mark := s.save() if !s.eval(sep, value, index) { s.restore(mark) } - s.separator = sep; // enable it again + s.separator = sep // enable it again } } - s.hasOutput = true; + s.hasOutput = true // write literal segments for _, lit := range t { if len(lit) > 1 && lit[0] == '%' { @@ -511,7 +511,7 @@ func (s *State) eval(fexpr expr, value reflect.Value, index int) bool { s.Write(lit) } } - return true; // a literal never evaluates to nil + return true // a literal never evaluates to nil case *field: // determine field value @@ -526,13 +526,13 @@ func (s *State) eval(fexpr expr, value reflect.Value, index int) bool { if v.Len() <= index { return false } - value = v.Elem(index); + value = v.Elem(index) case *reflect.SliceValue: if v.IsNil() || v.Len() <= index { return false } - value = v.Elem(index); + value = v.Elem(index) case *reflect.MapValue: s.error("reflection support for maps incomplete") @@ -541,13 +541,13 @@ func (s *State) eval(fexpr expr, value reflect.Value, index int) bool { if v.IsNil() { return false } - value = v.Elem(); + value = v.Elem() case *reflect.InterfaceValue: if v.IsNil() { return false } - value = v.Elem(); + value = v.Elem() case *reflect.ChanValue: s.error("reflection support for chans incomplete") @@ -561,98 +561,98 @@ func (s *State) eval(fexpr expr, value reflect.Value, index int) bool { default: // value is value of named field - var field reflect.Value; + var field reflect.Value if sval, ok := value.(*reflect.StructValue); ok { - field = sval.FieldByName(t.fieldName); + field = sval.FieldByName(t.fieldName) if field == nil { // TODO consider just returning false in this case s.error(fmt.Sprintf("error: no field `%s` in `%s`", t.fieldName, value.Type())) } } - value = field; + value = field } // determine rule - ruleName := t.ruleName; + ruleName := t.ruleName if ruleName == "" { // no alternate rule name, value type determines rule ruleName = typename(value.Type()) } - fexpr = s.getFormat(ruleName); + fexpr = s.getFormat(ruleName) - mark := s.save(); + mark := s.save() if !s.eval(fexpr, value, index) { - s.restore(mark); - return false; + s.restore(mark) + return false } - return true; + return true case *group: // remember current indentation - indentLen := s.indent.Len(); + indentLen := s.indent.Len() // update current indentation - mark := s.save(); - s.eval(t.indent, value, index); + mark := s.save() + s.eval(t.indent, value, index) // if the indentation evaluates to nil, the state's output buffer // didn't change - either way it's ok to append the difference to // the current identation - s.indent.Write(s.output.Bytes()[mark.outputLen:s.output.Len()]); - s.restore(mark); + s.indent.Write(s.output.Bytes()[mark.outputLen:s.output.Len()]) + s.restore(mark) // format group body - mark = s.save(); - b := true; + mark = s.save() + b := true if !s.eval(t.body, value, index) { - s.restore(mark); - b = false; + s.restore(mark) + b = false } // reset indentation - s.indent.Truncate(indentLen); - return b; + s.indent.Truncate(indentLen) + return b case *option: // evaluate the body and append the result to the state's output // buffer unless the result is nil - mark := s.save(); - if !s.eval(t.body, value, 0) { // TODO is 0 index correct? + mark := s.save() + if !s.eval(t.body, value, 0) { // TODO is 0 index correct? s.restore(mark) } - return true; // an option never evaluates to nil + return true // an option never evaluates to nil case *repetition: // evaluate the body and append the result to the state's output // buffer until a result is nil for i := 0; ; i++ { - mark := s.save(); + mark := s.save() // write separator, if any if i > 0 && t.separator != nil { // nil result from separator is ignored - mark := s.save(); + mark := s.save() if !s.eval(t.separator, value, i) { s.restore(mark) } } if !s.eval(t.body, value, i) { - s.restore(mark); - break; + s.restore(mark) + break } } - return true; // a repetition never evaluates to nil + return true // a repetition never evaluates to nil case *custom: // invoke the custom formatter to obtain the result - mark := s.save(); + mark := s.save() if !t.fun(s, value.Interface(), t.ruleName) { - s.restore(mark); - return false; + s.restore(mark) + return false } - return true; + return true } - panic("unreachable"); - return false; + panic("unreachable") + return false } @@ -668,23 +668,23 @@ func (f Format) Eval(env Environment, args ...) ([]byte, os.Error) { return nil, os.NewError("format is nil") } - errors := make(chan os.Error); - s := newState(f, env, errors); + errors := make(chan os.Error) + s := newState(f, env, errors) go func() { - value := reflect.NewValue(args).(*reflect.StructValue); + value := reflect.NewValue(args).(*reflect.StructValue) for i := 0; i < value.NumField(); i++ { - fld := value.Field(i); - mark := s.save(); - if !s.eval(s.getFormat(typename(fld.Type())), fld, 0) { // TODO is 0 index correct? + fld := value.Field(i) + mark := s.save() + if !s.eval(s.getFormat(typename(fld.Type())), fld, 0) { // TODO is 0 index correct? s.restore(mark) } } - errors <- nil; // no errors - }(); + errors <- nil // no errors + }() - err := <-errors; - return s.output.Bytes(), err; + err := <-errors + return s.output.Bytes(), err } @@ -696,12 +696,12 @@ func (f Format) Eval(env Environment, args ...) ([]byte, os.Error) { // written and an os.Error, if any. // func (f Format) Fprint(w io.Writer, env Environment, args ...) (int, os.Error) { - data, err := f.Eval(env, args); + data, err := f.Eval(env, args) if err != nil { // TODO should we print partial result in case of error? return 0, err } - return w.Write(data); + return w.Write(data) } @@ -720,10 +720,10 @@ func (f Format) Print(args ...) (int, os.Error) { // partially formatted result followed by an error message. // func (f Format) Sprint(args ...) string { - var buf bytes.Buffer; - _, err := f.Fprint(&buf, nil, args); + var buf bytes.Buffer + _, err := f.Fprint(&buf, nil, args) if err != nil { fmt.Fprintf(&buf, "--- Sprint(%s) failed: %v", fmt.Sprint(args), err) } - return buf.String(); + return buf.String() } diff --git a/src/pkg/exp/datafmt/datafmt_test.go b/src/pkg/exp/datafmt/datafmt_test.go index 61c0a972d..d1c6222a0 100644 --- a/src/pkg/exp/datafmt/datafmt_test.go +++ b/src/pkg/exp/datafmt/datafmt_test.go @@ -5,27 +5,27 @@ package datafmt import ( - "fmt"; - "strings"; - "testing"; + "fmt" + "strings" + "testing" ) func parse(t *testing.T, form string, fmap FormatterMap) Format { - f, err := Parse("", strings.Bytes(form), fmap); + f, err := Parse("", strings.Bytes(form), fmap) if err != nil { - t.Errorf("Parse(%s): %v", form, err); - return nil; + t.Errorf("Parse(%s): %v", form, err) + return nil } - return f; + return f } func verify(t *testing.T, f Format, expected string, args ...) { if f == nil { - return // allow other tests to run + return // allow other tests to run } - result := f.Sprint(args); + result := f.Sprint(args) if result != expected { t.Errorf( "result : `%s`\nexpected: `%s`\n\n", @@ -37,54 +37,54 @@ func verify(t *testing.T, f Format, expected string, args ...) { func formatter(s *State, value interface{}, rule_name string) bool { switch rule_name { case "/": - fmt.Fprintf(s, "%d %d %d", s.Pos().Line, s.LinePos().Column, s.Pos().Column); - return true; + fmt.Fprintf(s, "%d %d %d", s.Pos().Line, s.LinePos().Column, s.Pos().Column) + return true case "blank": - s.Write([]byte{' '}); - return true; + s.Write([]byte{' '}) + return true case "int": if value.(int)&1 == 0 { fmt.Fprint(s, "even ") } else { fmt.Fprint(s, "odd ") } - return true; + return true case "nil": return false case "testing.T": - s.Write(strings.Bytes("testing.T")); - return true; + s.Write(strings.Bytes("testing.T")) + return true } - panic("unreachable"); - return false; + panic("unreachable") + return false } func TestCustomFormatters(t *testing.T) { - fmap0 := FormatterMap{"/": formatter}; - fmap1 := FormatterMap{"int": formatter, "blank": formatter, "nil": formatter}; - fmap2 := FormatterMap{"testing.T": formatter}; + fmap0 := FormatterMap{"/": formatter} + fmap1 := FormatterMap{"int": formatter, "blank": formatter, "nil": formatter} + fmap2 := FormatterMap{"testing.T": formatter} - f := parse(t, `int=`, fmap0); - verify(t, f, ``, 1, 2, 3); + f := parse(t, `int=`, fmap0) + verify(t, f, ``, 1, 2, 3) - f = parse(t, `int="#"`, nil); - verify(t, f, `###`, 1, 2, 3); + f = parse(t, `int="#"`, nil) + verify(t, f, `###`, 1, 2, 3) - f = parse(t, `int="#";string="%s"`, fmap0); - verify(t, f, "#1 0 1#1 0 7#1 0 13\n2 0 0foo2 0 8\n", 1, 2, 3, "\n", "foo", "\n"); + f = parse(t, `int="#";string="%s"`, fmap0) + verify(t, f, "#1 0 1#1 0 7#1 0 13\n2 0 0foo2 0 8\n", 1, 2, 3, "\n", "foo", "\n") - f = parse(t, ``, fmap1); - verify(t, f, `even odd even odd `, 0, 1, 2, 3); + f = parse(t, ``, fmap1) + verify(t, f, `even odd even odd `, 0, 1, 2, 3) - f = parse(t, `/ =@:blank; float="#"`, fmap1); - verify(t, f, `# # #`, 0.0, 1.0, 2.0); + f = parse(t, `/ =@:blank; float="#"`, fmap1) + verify(t, f, `# # #`, 0.0, 1.0, 2.0) - f = parse(t, `float=@:nil`, fmap1); - verify(t, f, ``, 0.0, 1.0, 2.0); + f = parse(t, `float=@:nil`, fmap1) + verify(t, f, ``, 0.0, 1.0, 2.0) - f = parse(t, `testing "testing"; ptr=*`, fmap2); - verify(t, f, `testing.T`, t); + f = parse(t, `testing "testing"; ptr=*`, fmap2) + verify(t, f, `testing.T`, t) // TODO needs more tests } @@ -94,11 +94,11 @@ func TestCustomFormatters(t *testing.T) { // Formatting of basic and simple composite types func check(t *testing.T, form, expected string, args ...) { - f := parse(t, form, nil); + f := parse(t, form, nil) if f == nil { - return // allow other tests to run + return // allow other tests to run } - result := f.Sprint(args); + result := f.Sprint(args) if result != expected { t.Errorf( "format : %s\nresult : `%s`\nexpected: `%s`\n\n", @@ -108,120 +108,120 @@ func check(t *testing.T, form, expected string, args ...) { func TestBasicTypes(t *testing.T) { - check(t, ``, ``); - check(t, `bool=":%v"`, `:true:false`, true, false); - check(t, `int="%b %d %o 0x%x"`, `101010 42 52 0x2a`, 42); - - check(t, `int="%"`, `%`, 42); - check(t, `int="%%"`, `%`, 42); - check(t, `int="**%%**"`, `**%**`, 42); - check(t, `int="%%%%%%"`, `%%%`, 42); - check(t, `int="%%%d%%"`, `%42%`, 42); - - const i = -42; - const is = `-42`; - check(t, `int ="%d"`, is, i); - check(t, `int8 ="%d"`, is, int8(i)); - check(t, `int16="%d"`, is, int16(i)); - check(t, `int32="%d"`, is, int32(i)); - check(t, `int64="%d"`, is, int64(i)); - - const u = 42; - const us = `42`; - check(t, `uint ="%d"`, us, uint(u)); - check(t, `uint8 ="%d"`, us, uint8(u)); - check(t, `uint16="%d"`, us, uint16(u)); - check(t, `uint32="%d"`, us, uint32(u)); - check(t, `uint64="%d"`, us, uint64(u)); - - const f = 3.141592; - const fs = `3.141592`; - check(t, `float ="%g"`, fs, f); - check(t, `float32="%g"`, fs, float32(f)); - check(t, `float64="%g"`, fs, float64(f)); + check(t, ``, ``) + check(t, `bool=":%v"`, `:true:false`, true, false) + check(t, `int="%b %d %o 0x%x"`, `101010 42 52 0x2a`, 42) + + check(t, `int="%"`, `%`, 42) + check(t, `int="%%"`, `%`, 42) + check(t, `int="**%%**"`, `**%**`, 42) + check(t, `int="%%%%%%"`, `%%%`, 42) + check(t, `int="%%%d%%"`, `%42%`, 42) + + const i = -42 + const is = `-42` + check(t, `int ="%d"`, is, i) + check(t, `int8 ="%d"`, is, int8(i)) + check(t, `int16="%d"`, is, int16(i)) + check(t, `int32="%d"`, is, int32(i)) + check(t, `int64="%d"`, is, int64(i)) + + const u = 42 + const us = `42` + check(t, `uint ="%d"`, us, uint(u)) + check(t, `uint8 ="%d"`, us, uint8(u)) + check(t, `uint16="%d"`, us, uint16(u)) + check(t, `uint32="%d"`, us, uint32(u)) + check(t, `uint64="%d"`, us, uint64(u)) + + const f = 3.141592 + const fs = `3.141592` + check(t, `float ="%g"`, fs, f) + check(t, `float32="%g"`, fs, float32(f)) + check(t, `float64="%g"`, fs, float64(f)) } func TestArrayTypes(t *testing.T) { - var a0 [10]int; - check(t, `array="array";`, `array`, a0); + var a0 [10]int + check(t, `array="array";`, `array`, a0) - a1 := [...]int{1, 2, 3}; - check(t, `array="array";`, `array`, a1); - check(t, `array={*}; int="%d";`, `123`, a1); - check(t, `array={* / ", "}; int="%d";`, `1, 2, 3`, a1); - check(t, `array={* / *}; int="%d";`, `12233`, a1); + a1 := [...]int{1, 2, 3} + check(t, `array="array";`, `array`, a1) + check(t, `array={*}; int="%d";`, `123`, a1) + check(t, `array={* / ", "}; int="%d";`, `1, 2, 3`, a1) + check(t, `array={* / *}; int="%d";`, `12233`, a1) - a2 := []interface{}{42, "foo", 3.14}; - check(t, `array={* / ", "}; interface=*; string="bar"; default="%v";`, `42, bar, 3.14`, a2); + a2 := []interface{}{42, "foo", 3.14} + check(t, `array={* / ", "}; interface=*; string="bar"; default="%v";`, `42, bar, 3.14`, a2) } func TestChanTypes(t *testing.T) { - var c0 chan int; - check(t, `chan="chan"`, `chan`, c0); + var c0 chan int + check(t, `chan="chan"`, `chan`, c0) - c1 := make(chan int); - go func() { c1 <- 42 }(); - check(t, `chan="chan"`, `chan`, c1); + c1 := make(chan int) + go func() { c1 <- 42 }() + check(t, `chan="chan"`, `chan`, c1) // check(t, `chan=*`, `42`, c1); // reflection support for chans incomplete } func TestFuncTypes(t *testing.T) { - var f0 func() int; - check(t, `func="func"`, `func`, f0); + var f0 func() int + check(t, `func="func"`, `func`, f0) - f1 := func() int { return 42 }; - check(t, `func="func"`, `func`, f1); + f1 := func() int { return 42 } + check(t, `func="func"`, `func`, f1) // check(t, `func=*`, `42`, f1); // reflection support for funcs incomplete } func TestInterfaceTypes(t *testing.T) { var i0 interface{} - check(t, `interface="interface"`, `interface`, i0); + check(t, `interface="interface"`, `interface`, i0) - i0 = "foo"; - check(t, `interface="interface"`, `interface`, i0); - check(t, `interface=*; string="%s"`, `foo`, i0); + i0 = "foo" + check(t, `interface="interface"`, `interface`, i0) + check(t, `interface=*; string="%s"`, `foo`, i0) } func TestMapTypes(t *testing.T) { - var m0 map[string]int; - check(t, `map="map"`, `map`, m0); + var m0 map[string]int + check(t, `map="map"`, `map`, m0) - m1 := map[string]int{}; - check(t, `map="map"`, `map`, m1); + m1 := map[string]int{} + check(t, `map="map"`, `map`, m1) // check(t, `map=*`, ``, m1); // reflection support for maps incomplete } func TestPointerTypes(t *testing.T) { - var p0 *int; - check(t, `ptr="ptr"`, `ptr`, p0); - check(t, `ptr=*`, ``, p0); - check(t, `ptr=*|"nil"`, `nil`, p0); - - x := 99991; - p1 := &x; - check(t, `ptr="ptr"`, `ptr`, p1); - check(t, `ptr=*; int="%d"`, `99991`, p1); + var p0 *int + check(t, `ptr="ptr"`, `ptr`, p0) + check(t, `ptr=*`, ``, p0) + check(t, `ptr=*|"nil"`, `nil`, p0) + + x := 99991 + p1 := &x + check(t, `ptr="ptr"`, `ptr`, p1) + check(t, `ptr=*; int="%d"`, `99991`, p1) } func TestDefaultRule(t *testing.T) { - check(t, `default="%v"`, `42foo3.14`, 42, "foo", 3.14); - check(t, `default="%v"; int="%x"`, `abcdef`, 10, 11, 12, 13, 14, 15); - check(t, `default="%v"; int="%x"`, `ab**ef`, 10, 11, "**", 14, 15); - check(t, `default="%x"; int=@:default`, `abcdef`, 10, 11, 12, 13, 14, 15); + check(t, `default="%v"`, `42foo3.14`, 42, "foo", 3.14) + check(t, `default="%v"; int="%x"`, `abcdef`, 10, 11, 12, 13, 14, 15) + check(t, `default="%v"; int="%x"`, `ab**ef`, 10, 11, "**", 14, 15) + check(t, `default="%x"; int=@:default`, `abcdef`, 10, 11, 12, 13, 14, 15) } func TestGlobalSeparatorRule(t *testing.T) { - check(t, `int="%d"; / ="-"`, `1-2-3-4`, 1, 2, 3, 4); - check(t, `int="%x%x"; / ="*"`, `aa*aa`, 10, 10); + check(t, `int="%d"; / ="-"`, `1-2-3-4`, 1, 2, 3, 4) + check(t, `int="%x%x"; / ="*"`, `aa*aa`, 10, 10) } @@ -229,22 +229,22 @@ func TestGlobalSeparatorRule(t *testing.T) { // Formatting of a struct type T1 struct { - a int; + a int } const F1 = `datafmt "datafmt";` + `int = "%d";` + `datafmt.T1 = "<" a ">";` -func TestStruct1(t *testing.T) { check(t, F1, "<42>", T1{42}) } +func TestStruct1(t *testing.T) { check(t, F1, "<42>", T1{42}) } // ---------------------------------------------------------------------------- // Formatting of a struct with an optional field (ptr) type T2 struct { - s string; - p *T1; + s string + p *T1 } const F2a = F1 + @@ -258,9 +258,9 @@ const F2b = F1 + `datafmt.T2 = s ("-" p "-" | "empty");` func TestStruct2(t *testing.T) { - check(t, F2a, "foo", T2{"foo", nil}); - check(t, F2a, "bar-<17>-", T2{"bar", &T1{17}}); - check(t, F2b, "fooempty", T2{"foo", nil}); + check(t, F2a, "foo", T2{"foo", nil}) + check(t, F2a, "bar-<17>-", T2{"bar", &T1{17}}) + check(t, F2b, "fooempty", T2{"foo", nil}) } @@ -268,8 +268,8 @@ func TestStruct2(t *testing.T) { // Formatting of a struct with a repetitive field (slice) type T3 struct { - s string; - a []int; + s string + a []int } const F3a = `datafmt "datafmt";` + @@ -286,10 +286,10 @@ const F3b = `datafmt "datafmt";` + `datafmt.T3 = s [a:empty ": " {a / "-"}]` func TestStruct3(t *testing.T) { - check(t, F3a, "foo", T3{"foo", nil}); - check(t, F3a, "foo 00, 11, 22", T3{"foo", []int{0, 1, 2}}); - check(t, F3b, "bar", T3{"bar", nil}); - check(t, F3b, "bal: 2-3-5", T3{"bal", []int{2, 3, 5}}); + check(t, F3a, "foo", T3{"foo", nil}) + check(t, F3a, "foo 00, 11, 22", T3{"foo", []int{0, 1, 2}}) + check(t, F3b, "bar", T3{"bar", nil}) + check(t, F3b, "bal: 2-3-5", T3{"bal", []int{2, 3, 5}}) } @@ -297,8 +297,8 @@ func TestStruct3(t *testing.T) { // Formatting of a struct with alternative field type T4 struct { - x *int; - a []int; + x *int + a []int } const F4a = `datafmt "datafmt";` + @@ -318,11 +318,11 @@ const F4b = `datafmt "datafmt";` + `datafmt.T4 = "<" (a:empty {a / ", "} | "-") ">" ` func TestStruct4(t *testing.T) { - x := 7; - check(t, F4a, "<->", T4{nil, nil}); - check(t, F4a, "<7>", T4{&x, nil}); - check(t, F4b, "<->", T4{nil, nil}); - check(t, F4b, "<2, 3, 7>", T4{nil, []int{2, 3, 7}}); + x := 7 + check(t, F4a, "<->", T4{nil, nil}) + check(t, F4a, "<7>", T4{&x, nil}) + check(t, F4b, "<->", T4{nil, nil}) + check(t, F4b, "<2, 3, 7>", T4{nil, []int{2, 3, 7}}) } @@ -330,8 +330,8 @@ func TestStruct4(t *testing.T) { // Formatting a struct (documentation example) type Point struct { - name string; - x, y int; + name string + x, y int } const FPoint = `datafmt "datafmt";` + @@ -341,8 +341,8 @@ const FPoint = `datafmt "datafmt";` + `datafmt.Point = name "{" x ", " y:hexInt "}";` func TestStructPoint(t *testing.T) { - p := Point{"foo", 3, 15}; - check(t, FPoint, "---foo---{3, 0xf}", p); + p := Point{"foo", 3, 15} + check(t, FPoint, "---foo---{3, 0xf}", p) } @@ -352,7 +352,7 @@ func TestStructPoint(t *testing.T) { const FSlice = `int = "%b";` + `array = { * / ", " }` -func TestSlice(t *testing.T) { check(t, FSlice, "10, 11, 101, 111", []int{2, 3, 5, 7}) } +func TestSlice(t *testing.T) { check(t, FSlice, "10, 11, 101, 111", []int{2, 3, 5, 7}) } // TODO add more tests diff --git a/src/pkg/exp/datafmt/parser.go b/src/pkg/exp/datafmt/parser.go index c8144d9f2..653771674 100644 --- a/src/pkg/exp/datafmt/parser.go +++ b/src/pkg/exp/datafmt/parser.go @@ -5,83 +5,83 @@ package datafmt import ( - "container/vector"; - "go/scanner"; - "go/token"; - "os"; - "strconv"; - "strings"; + "container/vector" + "go/scanner" + "go/token" + "os" + "strconv" + "strings" ) // ---------------------------------------------------------------------------- // Parsing type parser struct { - scanner.ErrorVector; - scanner scanner.Scanner; - pos token.Position; // token position - tok token.Token; // one token look-ahead - lit []byte; // token literal - - packs map[string]string; // PackageName -> ImportPath - rules map[string]expr; // RuleName -> Expression + scanner.ErrorVector + scanner scanner.Scanner + pos token.Position // token position + tok token.Token // one token look-ahead + lit []byte // token literal + + packs map[string]string // PackageName -> ImportPath + rules map[string]expr // RuleName -> Expression } func (p *parser) next() { - p.pos, p.tok, p.lit = p.scanner.Scan(); + p.pos, p.tok, p.lit = p.scanner.Scan() switch p.tok { case token.CHAN, token.FUNC, token.INTERFACE, token.MAP, token.STRUCT: // Go keywords for composite types are type names // returned by reflect. Accept them as identifiers. - p.tok = token.IDENT // p.lit is already set correctly + p.tok = token.IDENT // p.lit is already set correctly } } func (p *parser) init(filename string, src []byte) { - p.ErrorVector.Reset(); - p.scanner.Init(filename, src, p, scanner.AllowIllegalChars); // return '@' as token.ILLEGAL w/o error message - p.next(); // initializes pos, tok, lit - p.packs = make(map[string]string); - p.rules = make(map[string]expr); + p.ErrorVector.Reset() + p.scanner.Init(filename, src, p, scanner.AllowIllegalChars) // return '@' as token.ILLEGAL w/o error message + p.next() // initializes pos, tok, lit + p.packs = make(map[string]string) + p.rules = make(map[string]expr) } func (p *parser) errorExpected(pos token.Position, msg string) { - msg = "expected " + msg; + msg = "expected " + msg if pos.Offset == p.pos.Offset { // the error happened at the current position; // make the error message more specific - msg += ", found '" + p.tok.String() + "'"; + msg += ", found '" + p.tok.String() + "'" if p.tok.IsLiteral() { msg += " " + string(p.lit) } } - p.Error(pos, msg); + p.Error(pos, msg) } func (p *parser) expect(tok token.Token) token.Position { - pos := p.pos; + pos := p.pos if p.tok != tok { p.errorExpected(pos, "'"+tok.String()+"'") } - p.next(); // make progress in any case - return pos; + p.next() // make progress in any case + return pos } func (p *parser) parseIdentifier() string { - name := string(p.lit); - p.expect(token.IDENT); - return name; + name := string(p.lit) + p.expect(token.IDENT) + return name } func (p *parser) parseTypeName() (string, bool) { - pos := p.pos; - name, isIdent := p.parseIdentifier(), true; + pos := p.pos + name, isIdent := p.parseIdentifier(), true if p.tok == token.PERIOD { // got a package name, lookup package if importPath, found := p.packs[name]; found { @@ -89,10 +89,10 @@ func (p *parser) parseTypeName() (string, bool) { } else { p.Error(pos, "package not declared: "+name) } - p.next(); - name, isIdent = name+"."+p.parseIdentifier(), false; + p.next() + name, isIdent = name+"."+p.parseIdentifier(), false } - return name, isIdent; + return name, isIdent } @@ -102,99 +102,99 @@ func (p *parser) parseTypeName() (string, bool) { // single identifier only (and thus could be a package name). // func (p *parser) parseRuleName() (string, bool) { - name, isIdent := "", false; + name, isIdent := "", false switch p.tok { case token.IDENT: name, isIdent = p.parseTypeName() case token.DEFAULT: - name = "default"; - p.next(); + name = "default" + p.next() case token.QUO: - name = "/"; - p.next(); + name = "/" + p.next() default: - p.errorExpected(p.pos, "rule name"); - p.next(); // make progress in any case + p.errorExpected(p.pos, "rule name") + p.next() // make progress in any case } - return name, isIdent; + return name, isIdent } func (p *parser) parseString() string { - s := ""; + s := "" if p.tok == token.STRING { - s, _ = strconv.Unquote(string(p.lit)); + s, _ = strconv.Unquote(string(p.lit)) // Unquote may fail with an error, but only if the scanner found // an illegal string in the first place. In this case the error // has already been reported. - p.next(); - return s; + p.next() + return s } else { p.expect(token.STRING) } - return s; + return s } func (p *parser) parseLiteral() literal { - s := strings.Bytes(p.parseString()); + s := strings.Bytes(p.parseString()) // A string literal may contain %-format specifiers. To simplify // and speed up printing of the literal, split it into segments // that start with "%" possibly followed by a last segment that // starts with some other character. - var list vector.Vector; - i0 := 0; + var list vector.Vector + i0 := 0 for i := 0; i < len(s); i++ { if s[i] == '%' && i+1 < len(s) { // the next segment starts with a % format if i0 < i { // the current segment is not empty, split it off - list.Push(s[i0:i]); - i0 = i; + list.Push(s[i0:i]) + i0 = i } - i++; // skip %; let loop skip over char after % + i++ // skip %; let loop skip over char after % } } // the final segment may start with any character // (it is empty iff the string is empty) - list.Push(s[i0:]); + list.Push(s[i0:]) // convert list into a literal - lit := make(literal, list.Len()); + lit := make(literal, list.Len()) for i := 0; i < list.Len(); i++ { lit[i] = list.At(i).([]byte) } - return lit; + return lit } func (p *parser) parseField() expr { - var fname string; + var fname string switch p.tok { case token.ILLEGAL: if string(p.lit) != "@" { return nil } - fname = "@"; - p.next(); + fname = "@" + p.next() case token.MUL: - fname = "*"; - p.next(); + fname = "*" + p.next() case token.IDENT: fname = p.parseIdentifier() default: return nil } - var ruleName string; + var ruleName string if p.tok == token.COLON { - p.next(); - ruleName, _ = p.parseRuleName(); + p.next() + ruleName, _ = p.parseRuleName() } - return &field{fname, ruleName}; + return &field{fname, ruleName} } @@ -204,40 +204,40 @@ func (p *parser) parseOperand() (x expr) { x = p.parseLiteral() case token.LPAREN: - p.next(); - x = p.parseExpression(); + p.next() + x = p.parseExpression() if p.tok == token.SHR { - p.next(); - x = &group{x, p.parseExpression()}; + p.next() + x = &group{x, p.parseExpression()} } - p.expect(token.RPAREN); + p.expect(token.RPAREN) case token.LBRACK: - p.next(); - x = &option{p.parseExpression()}; - p.expect(token.RBRACK); + p.next() + x = &option{p.parseExpression()} + p.expect(token.RBRACK) case token.LBRACE: - p.next(); - x = p.parseExpression(); - var div expr; + p.next() + x = p.parseExpression() + var div expr if p.tok == token.QUO { - p.next(); - div = p.parseExpression(); + p.next() + div = p.parseExpression() } - x = &repetition{x, div}; - p.expect(token.RBRACE); + x = &repetition{x, div} + p.expect(token.RBRACE) default: - x = p.parseField() // may be nil + x = p.parseField() // may be nil } - return x; + return x } func (p *parser) parseSequence() expr { - var list vector.Vector; + var list vector.Vector for x := p.parseOperand(); x != nil; x = p.parseOperand() { list.Push(x) @@ -252,26 +252,26 @@ func (p *parser) parseSequence() expr { } // convert list into a sequence - seq := make(sequence, list.Len()); + seq := make(sequence, list.Len()) for i := 0; i < list.Len(); i++ { seq[i] = list.At(i).(expr) } - return seq; + return seq } func (p *parser) parseExpression() expr { - var list vector.Vector; + var list vector.Vector for { - x := p.parseSequence(); + x := p.parseSequence() if x != nil { list.Push(x) } if p.tok != token.OR { break } - p.next(); + p.next() } // no need for an alternatives if list.Len() < 2 @@ -283,23 +283,23 @@ func (p *parser) parseExpression() expr { } // convert list into a alternatives - alt := make(alternatives, list.Len()); + alt := make(alternatives, list.Len()) for i := 0; i < list.Len(); i++ { alt[i] = list.At(i).(expr) } - return alt; + return alt } func (p *parser) parseFormat() { for p.tok != token.EOF { - pos := p.pos; + pos := p.pos - name, isIdent := p.parseRuleName(); + name, isIdent := p.parseRuleName() switch p.tok { case token.STRING: // package declaration - importPath := p.parseString(); + importPath := p.parseString() // add package declaration if !isIdent { @@ -312,8 +312,8 @@ func (p *parser) parseFormat() { case token.ASSIGN: // format rule - p.next(); - x := p.parseExpression(); + p.next() + x := p.parseExpression() // add rule if _, found := p.rules[name]; !found { @@ -323,8 +323,8 @@ func (p *parser) parseFormat() { } default: - p.errorExpected(p.pos, "package declaration or format rule"); - p.next(); // make progress in any case + p.errorExpected(p.pos, "package declaration or format rule") + p.next() // make progress in any case } if p.tok == token.SEMICOLON { @@ -333,23 +333,23 @@ func (p *parser) parseFormat() { break } } - p.expect(token.EOF); + p.expect(token.EOF) } func remap(p *parser, name string) string { - i := strings.Index(name, "."); + i := strings.Index(name, ".") if i >= 0 { - packageName, suffix := name[0:i], name[i:]; + packageName, suffix := name[0:i], name[i:] // lookup package if importPath, found := p.packs[packageName]; found { name = importPath + suffix } else { - var invalidPos token.Position; - p.Error(invalidPos, "package not declared: "+packageName); + var invalidPos token.Position + p.Error(invalidPos, "package not declared: "+packageName) } } - return name; + return name } @@ -360,20 +360,20 @@ func remap(p *parser, name string) string { // func Parse(filename string, src []byte, fmap FormatterMap) (Format, os.Error) { // parse source - var p parser; - p.init(filename, src); - p.parseFormat(); + var p parser + p.init(filename, src) + p.parseFormat() // add custom formatters, if any for name, form := range fmap { - name = remap(&p, name); + name = remap(&p, name) if _, found := p.rules[name]; !found { p.rules[name] = &custom{name, form} } else { - var invalidPos token.Position; - p.Error(invalidPos, "formatter already declared: "+name); + var invalidPos token.Position + p.Error(invalidPos, "formatter already declared: "+name) } } - return p.rules, p.GetError(scanner.NoMultiples); + return p.rules, p.GetError(scanner.NoMultiples) } diff --git a/src/pkg/exp/draw/arith.go b/src/pkg/exp/draw/arith.go index 59830bba5..6ed1c4a5a 100644 --- a/src/pkg/exp/draw/arith.go +++ b/src/pkg/exp/draw/arith.go @@ -6,7 +6,7 @@ package draw // A Point is an X, Y coordinate pair. type Point struct { - X, Y int; + X, Y int } // ZP is the zero Point. @@ -14,35 +14,35 @@ var ZP Point // A Rectangle contains the Points with Min.X <= X < Max.X, Min.Y <= Y < Max.Y. type Rectangle struct { - Min, Max Point; + Min, Max Point } // ZR is the zero Rectangle. var ZR Rectangle // Pt is shorthand for Point{X, Y}. -func Pt(X, Y int) Point { return Point{X, Y} } +func Pt(X, Y int) Point { return Point{X, Y} } // Rect is shorthand for Rectangle{Pt(x0, y0), Pt(x1, y1)}. -func Rect(x0, y0, x1, y1 int) Rectangle { return Rectangle{Point{x0, y0}, Point{x1, y1}} } +func Rect(x0, y0, x1, y1 int) Rectangle { return Rectangle{Point{x0, y0}, Point{x1, y1}} } // Rpt is shorthand for Rectangle{min, max}. -func Rpt(min, max Point) Rectangle { return Rectangle{min, max} } +func Rpt(min, max Point) Rectangle { return Rectangle{min, max} } // Add returns the sum of p and q: Pt(p.X+q.X, p.Y+q.Y). -func (p Point) Add(q Point) Point { return Point{p.X + q.X, p.Y + q.Y} } +func (p Point) Add(q Point) Point { return Point{p.X + q.X, p.Y + q.Y} } // Sub returns the difference of p and q: Pt(p.X-q.X, p.Y-q.Y). -func (p Point) Sub(q Point) Point { return Point{p.X - q.X, p.Y - q.Y} } +func (p Point) Sub(q Point) Point { return Point{p.X - q.X, p.Y - q.Y} } // Mul returns p scaled by k: Pt(p.X*k p.Y*k). -func (p Point) Mul(k int) Point { return Point{p.X * k, p.Y * k} } +func (p Point) Mul(k int) Point { return Point{p.X * k, p.Y * k} } // Div returns p divided by k: Pt(p.X/k, p.Y/k). -func (p Point) Div(k int) Point { return Point{p.X / k, p.Y / k} } +func (p Point) Div(k int) Point { return Point{p.X / k, p.Y / k} } // Eq returns true if p and q are equal. -func (p Point) Eq(q Point) bool { return p.X == q.X && p.Y == q.Y } +func (p Point) Eq(q Point) bool { return p.X == q.X && p.Y == q.Y } // Inset returns the rectangle r inset by n: Rect(r.Min.X+n, r.Min.Y+n, r.Max.X-n, r.Max.Y-n). func (r Rectangle) Inset(n int) Rectangle { @@ -50,10 +50,10 @@ func (r Rectangle) Inset(n int) Rectangle { } // Add returns the rectangle r translated by p: Rpt(r.Min.Add(p), r.Max.Add(p)). -func (r Rectangle) Add(p Point) Rectangle { return Rectangle{r.Min.Add(p), r.Max.Add(p)} } +func (r Rectangle) Add(p Point) Rectangle { return Rectangle{r.Min.Add(p), r.Max.Add(p)} } // Sub returns the rectangle r translated by -p: Rpt(r.Min.Sub(p), r.Max.Sub(p)). -func (r Rectangle) Sub(p Point) Rectangle { return Rectangle{r.Min.Sub(p), r.Max.Sub(p)} } +func (r Rectangle) Sub(p Point) Rectangle { return Rectangle{r.Min.Sub(p), r.Max.Sub(p)} } // Canon returns a canonical version of r: the returned rectangle // has Min.X <= Max.X and Min.Y <= Max.Y. @@ -64,7 +64,7 @@ func (r Rectangle) Canon() Rectangle { if r.Max.Y < r.Min.Y { r.Max.Y = r.Min.Y } - return r; + return r } // Overlaps returns true if r and r1 cross; that is, it returns true if they share any point. @@ -74,7 +74,7 @@ func (r Rectangle) Overlaps(r1 Rectangle) bool { } // Empty retruns true if r contains no points. -func (r Rectangle) Empty() bool { return r.Max.X <= r.Min.X || r.Max.Y <= r.Min.Y } +func (r Rectangle) Empty() bool { return r.Max.X <= r.Min.X || r.Max.Y <= r.Min.Y } // InRect returns true if all the points in r are also in r1. func (r Rectangle) In(r1 Rectangle) bool { @@ -85,7 +85,7 @@ func (r Rectangle) In(r1 Rectangle) bool { return false } return r1.Min.X <= r.Min.X && r.Max.X <= r1.Max.X && - r1.Min.Y <= r.Min.Y && r.Max.Y <= r1.Max.Y; + r1.Min.Y <= r.Min.Y && r.Max.Y <= r1.Max.Y } // Combine returns the smallest rectangle containing all points from r and from r1. @@ -108,7 +108,7 @@ func (r Rectangle) Combine(r1 Rectangle) Rectangle { if r.Max.Y < r1.Max.Y { r.Max.Y = r1.Max.Y } - return r; + return r } // Clip returns the largest rectangle containing only points shared by r and r1. @@ -131,11 +131,11 @@ func (r Rectangle) Clip(r1 Rectangle) Rectangle { if r.Max.Y > r1.Max.Y { r.Max.Y = r1.Max.Y } - return r; + return r } // Dx returns the width of the rectangle r: r.Max.X - r.Min.X. -func (r Rectangle) Dx() int { return r.Max.X - r.Min.X } +func (r Rectangle) Dx() int { return r.Max.X - r.Min.X } // Dy returns the width of the rectangle r: r.Max.Y - r.Min.Y. -func (r Rectangle) Dy() int { return r.Max.Y - r.Min.Y } +func (r Rectangle) Dy() int { return r.Max.Y - r.Min.Y } diff --git a/src/pkg/exp/draw/color.go b/src/pkg/exp/draw/color.go index 1ebb3a21b..f0e759709 100644 --- a/src/pkg/exp/draw/color.go +++ b/src/pkg/exp/draw/color.go @@ -19,91 +19,91 @@ var _ image.Color = Black var _ image.Image = Black var ( - Opaque Color = 0xFFFFFFFF; - Transparent Color = 0x00000000; - Black Color = 0x000000FF; - White Color = 0xFFFFFFFF; - Red Color = 0xFF0000FF; - Green Color = 0x00FF00FF; - Blue Color = 0x0000FFFF; - Cyan Color = 0x00FFFFFF; - Magenta Color = 0xFF00FFFF; - Yellow Color = 0xFFFF00FF; - PaleYellow Color = 0xFFFFAAFF; - DarkYellow Color = 0xEEEE9EFF; - DarkGreen Color = 0x448844FF; - PaleGreen Color = 0xAAFFAAFF; - MedGreen Color = 0x88CC88FF; - DarkBlue Color = 0x000055FF; - PaleBlueGreen Color = 0xAAFFFFFF; - PaleBlue Color = 0x0000BBFF; - BlueGreen Color = 0x008888FF; - GreyGreen Color = 0x55AAAAFF; - PaleGreyGreen Color = 0x9EEEEEFF; - YellowGreen Color = 0x99994CFF; - MedBlue Color = 0x000099FF; - GreyBlue Color = 0x005DBBFF; - PaleGreyBlue Color = 0x4993DDFF; - PurpleBlue Color = 0x8888CCFF; + Opaque Color = 0xFFFFFFFF + Transparent Color = 0x00000000 + Black Color = 0x000000FF + White Color = 0xFFFFFFFF + Red Color = 0xFF0000FF + Green Color = 0x00FF00FF + Blue Color = 0x0000FFFF + Cyan Color = 0x00FFFFFF + Magenta Color = 0xFF00FFFF + Yellow Color = 0xFFFF00FF + PaleYellow Color = 0xFFFFAAFF + DarkYellow Color = 0xEEEE9EFF + DarkGreen Color = 0x448844FF + PaleGreen Color = 0xAAFFAAFF + MedGreen Color = 0x88CC88FF + DarkBlue Color = 0x000055FF + PaleBlueGreen Color = 0xAAFFFFFF + PaleBlue Color = 0x0000BBFF + BlueGreen Color = 0x008888FF + GreyGreen Color = 0x55AAAAFF + PaleGreyGreen Color = 0x9EEEEEFF + YellowGreen Color = 0x99994CFF + MedBlue Color = 0x000099FF + GreyBlue Color = 0x005DBBFF + PaleGreyBlue Color = 0x4993DDFF + PurpleBlue Color = 0x8888CCFF ) func (c Color) RGBA() (r, g, b, a uint32) { - x := uint32(c); - r, g, b, a = x>>24, (x>>16)&0xFF, (x>>8)&0xFF, x&0xFF; - r |= r << 8; - r |= r << 16; - g |= g << 8; - g |= g << 16; - b |= b << 8; - b |= b << 16; - a |= a << 8; - a |= a << 16; - return; + x := uint32(c) + r, g, b, a = x>>24, (x>>16)&0xFF, (x>>8)&0xFF, x&0xFF + r |= r << 8 + r |= r << 16 + g |= g << 8 + g |= g << 16 + b |= b << 8 + b |= b << 16 + a |= a << 8 + a |= a << 16 + return } // SetAlpha returns the color obtained by changing // c's alpha value to a and scaling r, g, and b appropriately. func (c Color) SetAlpha(a uint8) Color { - r, g, b, oa := c>>24, (c>>16)&0xFF, (c>>8)&0xFF, c&0xFF; + r, g, b, oa := c>>24, (c>>16)&0xFF, (c>>8)&0xFF, c&0xFF if oa == 0 { return 0 } - r = r * Color(a) / oa; + r = r * Color(a) / oa if r < 0 { r = 0 } if r > 0xFF { r = 0xFF } - g = g * Color(a) / oa; + g = g * Color(a) / oa if g < 0 { g = 0 } if g > 0xFF { g = 0xFF } - b = b * Color(a) / oa; + b = b * Color(a) / oa if b < 0 { b = 0 } if b > 0xFF { b = 0xFF } - return r<<24 | g<<16 | b<<8 | Color(a); + return r<<24 | g<<16 | b<<8 | Color(a) } -func (c Color) Width() int { return 1e9 } +func (c Color) Width() int { return 1e9 } -func (c Color) Height() int { return 1e9 } +func (c Color) Height() int { return 1e9 } -func (c Color) At(x, y int) image.Color { return c } +func (c Color) At(x, y int) image.Color { return c } func toColor(color image.Color) image.Color { if c, ok := color.(Color); ok { return c } - r, g, b, a := color.RGBA(); - return Color(r>>24<<24 | g>>24<<16 | b>>24<<8 | a>>24); + r, g, b, a := color.RGBA() + return Color(r>>24<<24 | g>>24<<16 | b>>24<<8 | a>>24) } -func (c Color) ColorModel() image.ColorModel { return image.ColorModelFunc(toColor) } +func (c Color) ColorModel() image.ColorModel { return image.ColorModelFunc(toColor) } diff --git a/src/pkg/exp/draw/draw.go b/src/pkg/exp/draw/draw.go index d01cdcc16..59adf1f6a 100644 --- a/src/pkg/exp/draw/draw.go +++ b/src/pkg/exp/draw/draw.go @@ -14,8 +14,8 @@ import "image" // A draw.Image is an image.Image with a Set method to change a single pixel. type Image interface { - image.Image; - Set(x, y int, c image.Color); + image.Image + Set(x, y int, c image.Color) } // Draw aligns r.Min in dst with pt in src and mask @@ -27,7 +27,7 @@ type Image interface { func Draw(dst Image, r Rectangle, src, mask image.Image, pt Point) { // Plenty of room for optimizations here. - dx, dy := src.Width(), src.Height(); + dx, dy := src.Width(), src.Height() if mask != nil { if dx > mask.Width() { dx = mask.Width() @@ -36,8 +36,8 @@ func Draw(dst Image, r Rectangle, src, mask image.Image, pt Point) { dy = mask.Width() } } - dx -= pt.X; - dy -= pt.Y; + dx -= pt.X + dy -= pt.Y if r.Dx() > dx { r.Max.X = r.Min.X + dx } @@ -45,57 +45,57 @@ func Draw(dst Image, r Rectangle, src, mask image.Image, pt Point) { r.Max.Y = r.Min.Y + dy } - x0, x1, dx := r.Min.X, r.Max.X, 1; - y0, y1, dy := r.Min.Y, r.Max.Y, 1; + x0, x1, dx := r.Min.X, r.Max.X, 1 + y0, y1, dy := r.Min.Y, r.Max.Y, 1 if image.Image(dst) == src && r.Overlaps(r.Add(pt.Sub(r.Min))) { // Rectangles overlap: process backward? if pt.Y < r.Min.Y || pt.Y == r.Min.Y && pt.X < r.Min.X { - x0, x1, dx = x1-1, x0-1, -1; - y0, y1, dy = y1-1, y0-1, -1; + x0, x1, dx = x1-1, x0-1, -1 + y0, y1, dy = y1-1, y0-1, -1 } } - var out *image.RGBA64Color; + var out *image.RGBA64Color for y := y0; y != y1; y += dy { for x := x0; x != x1; x += dx { - sx := pt.X + x - r.Min.X; - sy := pt.Y + y - r.Min.Y; + sx := pt.X + x - r.Min.X + sy := pt.Y + y - r.Min.Y if mask == nil { - dst.Set(x, y, src.At(sx, sy)); - continue; + dst.Set(x, y, src.At(sx, sy)) + continue } - _, _, _, ma := mask.At(sx, sy).RGBA(); + _, _, _, ma := mask.At(sx, sy).RGBA() switch ma { case 0: continue case 0xFFFFFFFF: dst.Set(x, y, src.At(sx, sy)) default: - dr, dg, db, da := dst.At(x, y).RGBA(); - dr >>= 16; - dg >>= 16; - db >>= 16; - da >>= 16; - sr, sg, sb, sa := src.At(sx, sy).RGBA(); - sr >>= 16; - sg >>= 16; - sb >>= 16; - sa >>= 16; - ma >>= 16; - const M = 1<<16 - 1; - a := sa * ma / M; - dr = (dr*(M-a) + sr*ma) / M; - dg = (dg*(M-a) + sg*ma) / M; - db = (db*(M-a) + sb*ma) / M; - da = (da*(M-a) + sa*ma) / M; + dr, dg, db, da := dst.At(x, y).RGBA() + dr >>= 16 + dg >>= 16 + db >>= 16 + da >>= 16 + sr, sg, sb, sa := src.At(sx, sy).RGBA() + sr >>= 16 + sg >>= 16 + sb >>= 16 + sa >>= 16 + ma >>= 16 + const M = 1<<16 - 1 + a := sa * ma / M + dr = (dr*(M-a) + sr*ma) / M + dg = (dg*(M-a) + sg*ma) / M + db = (db*(M-a) + sb*ma) / M + da = (da*(M-a) + sa*ma) / M if out == nil { out = new(image.RGBA64Color) } - out.R = uint16(dr); - out.G = uint16(dg); - out.B = uint16(db); - out.A = uint16(da); - dst.Set(x, y, out); + out.R = uint16(dr) + out.G = uint16(dg) + out.B = uint16(db) + out.A = uint16(da) + dst.Set(x, y, out) } } } @@ -106,20 +106,20 @@ func Draw(dst Image, r Rectangle, src, mask image.Image, pt Point) { // operation ``src over dst.'' If w is positive, the border extends w pixels inside r. // If w is negative, the border extends w pixels outside r. func Border(dst Image, r Rectangle, w int, src image.Image, sp Point) { - i := w; + i := w if i > 0 { // inside r - Draw(dst, Rect(r.Min.X, r.Min.Y, r.Max.X, r.Min.Y+i), src, nil, sp); // top - Draw(dst, Rect(r.Min.X, r.Min.Y+i, r.Min.X+i, r.Max.Y-i), src, nil, sp.Add(Pt(0, i))); // left - Draw(dst, Rect(r.Max.X-i, r.Min.Y+i, r.Max.X, r.Max.Y-i), src, nil, sp.Add(Pt(r.Dx()-i, i))); // right - Draw(dst, Rect(r.Min.X, r.Max.Y-i, r.Max.X, r.Max.Y), src, nil, sp.Add(Pt(0, r.Dy()-i))); // bottom - return; + Draw(dst, Rect(r.Min.X, r.Min.Y, r.Max.X, r.Min.Y+i), src, nil, sp) // top + Draw(dst, Rect(r.Min.X, r.Min.Y+i, r.Min.X+i, r.Max.Y-i), src, nil, sp.Add(Pt(0, i))) // left + Draw(dst, Rect(r.Max.X-i, r.Min.Y+i, r.Max.X, r.Max.Y-i), src, nil, sp.Add(Pt(r.Dx()-i, i))) // right + Draw(dst, Rect(r.Min.X, r.Max.Y-i, r.Max.X, r.Max.Y), src, nil, sp.Add(Pt(0, r.Dy()-i))) // bottom + return } // outside r; - i = -i; - Draw(dst, Rect(r.Min.X-i, r.Min.Y-i, r.Max.X+i, r.Min.Y), src, nil, sp.Add(Pt(-i, -i))); // top - Draw(dst, Rect(r.Min.X-i, r.Min.Y, r.Min.X, r.Max.Y), src, nil, sp.Add(Pt(-i, 0))); // left - Draw(dst, Rect(r.Max.X, r.Min.Y, r.Max.X+i, r.Max.Y), src, nil, sp.Add(Pt(r.Dx(), 0))); // right - Draw(dst, Rect(r.Min.X-i, r.Max.Y, r.Max.X+i, r.Max.Y+i), src, nil, sp.Add(Pt(-i, 0))); // bottom + i = -i + Draw(dst, Rect(r.Min.X-i, r.Min.Y-i, r.Max.X+i, r.Min.Y), src, nil, sp.Add(Pt(-i, -i))) // top + Draw(dst, Rect(r.Min.X-i, r.Min.Y, r.Min.X, r.Max.Y), src, nil, sp.Add(Pt(-i, 0))) // left + Draw(dst, Rect(r.Max.X, r.Min.Y, r.Max.X+i, r.Max.Y), src, nil, sp.Add(Pt(r.Dx(), 0))) // right + Draw(dst, Rect(r.Min.X-i, r.Max.Y, r.Max.X+i, r.Max.Y+i), src, nil, sp.Add(Pt(-i, 0))) // bottom } diff --git a/src/pkg/exp/draw/event.go b/src/pkg/exp/draw/event.go index 8a148bd48..155922d1c 100644 --- a/src/pkg/exp/draw/event.go +++ b/src/pkg/exp/draw/event.go @@ -7,10 +7,10 @@ package draw // A Context represents a single graphics window. type Context interface { // Screen returns an editable Image of window. - Screen() Image; + Screen() Image // FlushImage flushes changes made to Screen() back to screen. - FlushImage(); + FlushImage() // KeyboardChan returns a channel carrying keystrokes. // An event is sent each time a key is pressed or released. @@ -18,29 +18,29 @@ type Context interface { // The value -k represents key k being released. // The specific set of key values is not specified, // but ordinary character represent themselves. - KeyboardChan() <-chan int; + KeyboardChan() <-chan int // MouseChan returns a channel carrying mouse events. // A new event is sent each time the mouse moves or a // button is pressed or released. - MouseChan() <-chan Mouse; + MouseChan() <-chan Mouse // ResizeChan returns a channel carrying resize events. // An event is sent each time the window is resized; // the client should respond by calling Screen() to obtain // the new screen image. // The value sent on the channel is always ``true'' and can be ignored. - ResizeChan() <-chan bool; + ResizeChan() <-chan bool // QuitChan returns a channel carrying quit requests. // After reading a value from the quit channel, the application // should exit. - QuitChan() <-chan bool; + QuitChan() <-chan bool } // A Mouse represents the state of the mouse. type Mouse struct { - Buttons int; // bit mask of buttons: 1<<0 is left, 1<<1 middle, 1<<2 right - Point; // location of cursor - Nsec int64; // time stamp + Buttons int // bit mask of buttons: 1<<0 is left, 1<<1 middle, 1<<2 right + Point // location of cursor + Nsec int64 // time stamp } diff --git a/src/pkg/exp/draw/x11/auth.go b/src/pkg/exp/draw/x11/auth.go index 8a90bf364..82dd58c28 100644 --- a/src/pkg/exp/draw/x11/auth.go +++ b/src/pkg/exp/draw/x11/auth.go @@ -5,92 +5,92 @@ package x11 import ( - "bufio"; - "io"; - "os"; + "bufio" + "io" + "os" ) // Reads the DISPLAY environment variable, and returns the "12" in ":12.0". func getDisplay() string { - d := os.Getenv("DISPLAY"); + d := os.Getenv("DISPLAY") if len(d) < 1 || d[0] != ':' { return "" } - i := 1; + i := 1 for ; i < len(d); i++ { if d[i] < '0' || d[i] > '9' { break } } - return d[1:i]; + return d[1:i] } // Reads a big-endian uint16 from r, using b as a scratch buffer. func readU16BE(r io.Reader, b []byte) (uint16, os.Error) { - _, err := io.ReadFull(r, b[0:2]); + _, err := io.ReadFull(r, b[0:2]) if err != nil { return 0, err } - return uint16(b[0])<<8 + uint16(b[1]), nil; + return uint16(b[0])<<8 + uint16(b[1]), nil } // Reads a length-prefixed string from r, using b as a scratch buffer. func readStr(r io.Reader, b []byte) (s string, err os.Error) { - n, err := readU16BE(r, b); + n, err := readU16BE(r, b) if err != nil { return } if int(n) > len(b) { return s, os.NewError("Xauthority entry too long for buffer") } - _, err = io.ReadFull(r, b[0:n]); + _, err = io.ReadFull(r, b[0:n]) if err != nil { return } - return string(b[0:n]), nil; + return string(b[0:n]), nil } // Reads the ~/.Xauthority file and returns the name/data pair for the DISPLAY. // b is a scratch buffer to use, and should be at least 256 bytes long (i.e. it should be able to hold a hostname). func readAuth(b []byte) (name, data string, err os.Error) { // As per /usr/include/X11/Xauth.h. - const familyLocal = 256; + const familyLocal = 256 - home := os.Getenv("HOME"); + home := os.Getenv("HOME") if len(home) == 0 { - err = os.NewError("unknown HOME"); - return; + err = os.NewError("unknown HOME") + return } - r, err := os.Open(home+"/.Xauthority", os.O_RDONLY, 0444); + r, err := os.Open(home+"/.Xauthority", os.O_RDONLY, 0444) if err != nil { return } - defer r.Close(); - br := bufio.NewReader(r); + defer r.Close() + br := bufio.NewReader(r) - hostname, err := os.Hostname(); + hostname, err := os.Hostname() if err != nil { return } - display := getDisplay(); + display := getDisplay() for { - family, err := readU16BE(br, b[0:2]); + family, err := readU16BE(br, b[0:2]) if err != nil { return } - addr, err := readStr(br, b[0:]); + addr, err := readStr(br, b[0:]) if err != nil { return } - disp, err := readStr(br, b[0:]); + disp, err := readStr(br, b[0:]) if err != nil { return } - name0, err := readStr(br, b[0:]); + name0, err := readStr(br, b[0:]) if err != nil { return } - data0, err := readStr(br, b[0:]); + data0, err := readStr(br, b[0:]) if err != nil { return } @@ -98,5 +98,5 @@ func readAuth(b []byte) (name, data string, err os.Error) { return name0, data0, nil } } - panic("unreachable"); + panic("unreachable") } diff --git a/src/pkg/exp/draw/x11/conn.go b/src/pkg/exp/draw/x11/conn.go index cb764d11c..f7eb740e1 100644 --- a/src/pkg/exp/draw/x11/conn.go +++ b/src/pkg/exp/draw/x11/conn.go @@ -11,51 +11,51 @@ package x11 // BUG(nigeltao): This is a toy library and not ready for production use. import ( - "bufio"; - "exp/draw"; - "image"; - "io"; - "net"; - "os"; + "bufio" + "exp/draw" + "image" + "io" + "net" + "os" ) -type resID uint32 // X resource IDs. +type resID uint32 // X resource IDs. // TODO(nigeltao): Handle window resizes. const ( - windowHeight = 600; - windowWidth = 800; + windowHeight = 600 + windowWidth = 800 ) type conn struct { // TODO(nigeltao): Figure out which goroutine should be responsible for closing c, // or if there is a race condition if one goroutine calls c.Close whilst another one // is reading from r, or writing to w. - c io.Closer; - r *bufio.Reader; - w *bufio.Writer; + c io.Closer + r *bufio.Reader + w *bufio.Writer - gc, window, root, visual resID; + gc, window, root, visual resID - img *image.RGBA; - kbd chan int; - mouse chan draw.Mouse; - resize chan bool; - quit chan bool; - mouseState draw.Mouse; + img *image.RGBA + kbd chan int + mouse chan draw.Mouse + resize chan bool + quit chan bool + mouseState draw.Mouse - buf [256]byte; // General purpose scratch buffer. + buf [256]byte // General purpose scratch buffer. - flush chan bool; - flushBuf0 [24]byte; - flushBuf1 [4 * 1024]byte; + flush chan bool + flushBuf0 [24]byte + flushBuf1 [4 * 1024]byte } // flusher runs in its own goroutine, serving both FlushImage calls directly from the exp/draw client // and indirectly from X expose events. It paints c.img to the X server via PutImage requests. func (c *conn) flusher() { for { - _ = <-c.flush; + _ = <-c.flush if closed(c.flush) { return } @@ -65,57 +65,57 @@ func (c *conn) flusher() { // the entire image in one X request. This approach could easily be optimized (or the // X protocol may have an escape sequence to delimit very large requests). // TODO(nigeltao): See what XCB's xcb_put_image does in this situation. - w, h := c.img.Width(), c.img.Height(); - units := 6 + w; + w, h := c.img.Width(), c.img.Height() + units := 6 + w if units > 0xffff || h > 0xffff { // This window is too large for X. - close(c.flush); - return; + close(c.flush) + return } - c.flushBuf0[0] = 0x48; // PutImage opcode. - c.flushBuf0[1] = 0x02; // XCB_IMAGE_FORMAT_Z_PIXMAP. - c.flushBuf0[2] = uint8(units); - c.flushBuf0[3] = uint8(units >> 8); - setU32LE(c.flushBuf0[4:8], uint32(c.window)); - setU32LE(c.flushBuf0[8:12], uint32(c.gc)); - setU32LE(c.flushBuf0[12:16], 1<<16|uint32(w)); - c.flushBuf0[21] = 0x18; // depth = 24 bits. + c.flushBuf0[0] = 0x48 // PutImage opcode. + c.flushBuf0[1] = 0x02 // XCB_IMAGE_FORMAT_Z_PIXMAP. + c.flushBuf0[2] = uint8(units) + c.flushBuf0[3] = uint8(units >> 8) + setU32LE(c.flushBuf0[4:8], uint32(c.window)) + setU32LE(c.flushBuf0[8:12], uint32(c.gc)) + setU32LE(c.flushBuf0[12:16], 1<<16|uint32(w)) + c.flushBuf0[21] = 0x18 // depth = 24 bits. for y := 0; y < h; y++ { - setU32LE(c.flushBuf0[16:20], uint32(y<<16)); - _, err := c.w.Write(c.flushBuf0[0:24]); + setU32LE(c.flushBuf0[16:20], uint32(y<<16)) + _, err := c.w.Write(c.flushBuf0[0:24]) if err != nil { - close(c.flush); - return; + close(c.flush) + return } for x := 0; x < w; { - nx := w - x; + nx := w - x if nx > len(c.flushBuf1)/4 { nx = len(c.flushBuf1) / 4 } for i := 0; i < nx; i++ { - r, g, b, _ := c.img.At(x, y).RGBA(); - c.flushBuf1[4*i+0] = uint8(b >> 24); - c.flushBuf1[4*i+1] = uint8(g >> 24); - c.flushBuf1[4*i+2] = uint8(r >> 24); - x++; + r, g, b, _ := c.img.At(x, y).RGBA() + c.flushBuf1[4*i+0] = uint8(b >> 24) + c.flushBuf1[4*i+1] = uint8(g >> 24) + c.flushBuf1[4*i+2] = uint8(r >> 24) + x++ } - _, err := c.w.Write(c.flushBuf1[0 : 4*nx]); + _, err := c.w.Write(c.flushBuf1[0 : 4*nx]) if err != nil { - close(c.flush); - return; + close(c.flush) + return } } } if c.w.Flush() != nil { - close(c.flush); - return; + close(c.flush) + return } } } -func (c *conn) Screen() draw.Image { return c.img } +func (c *conn) Screen() draw.Image { return c.img } func (c *conn) FlushImage() { // We do the send (the <- operator) in an expression context, rather than in @@ -124,19 +124,19 @@ func (c *conn) FlushImage() { _ = c.flush <- false } -func (c *conn) KeyboardChan() <-chan int { return c.kbd } +func (c *conn) KeyboardChan() <-chan int { return c.kbd } -func (c *conn) MouseChan() <-chan draw.Mouse { return c.mouse } +func (c *conn) MouseChan() <-chan draw.Mouse { return c.mouse } -func (c *conn) ResizeChan() <-chan bool { return c.resize } +func (c *conn) ResizeChan() <-chan bool { return c.resize } -func (c *conn) QuitChan() <-chan bool { return c.quit } +func (c *conn) QuitChan() <-chan bool { return c.quit } // pumper runs in its own goroutine, reading X events and demuxing them over the kbd / mouse / resize / quit chans. func (c *conn) pumper() { for { // X events are always 32 bytes long. - _, err := io.ReadFull(c.r, c.buf[0:32]); + _, err := io.ReadFull(c.r, c.buf[0:32]) if err != nil { // TODO(nigeltao): should draw.Context expose err? // TODO(nigeltao): should we do c.quit<-true? Should c.quit be a buffered channel? @@ -145,12 +145,12 @@ func (c *conn) pumper() { break } switch c.buf[0] { - case 0x02, 0x03: // Key press, key release. + case 0x02, 0x03: // Key press, key release. // BUG(nigeltao): Keycode to keysym mapping is not implemented. // The keycode is in c.buf[1], but as keymaps aren't implemented yet, we'll use the // space character as a placeholder. - keysym := int(' '); + keysym := int(' ') // TODO(nigeltao): Should we send KeyboardChan ints for Shift/Ctrl/Alt? Should Shift-A send // the same int down the channel as the sent on just the A key? // TODO(nigeltao): How should IME events (e.g. key presses that should generate CJK text) work? Or @@ -158,29 +158,29 @@ func (c *conn) pumper() { if c.buf[0] == 0x03 { keysym = -keysym } - c.kbd <- keysym; - case 0x04, 0x05: // Button press, button release. - mask := 1 << (c.buf[1] - 1); + c.kbd <- keysym + case 0x04, 0x05: // Button press, button release. + mask := 1 << (c.buf[1] - 1) if c.buf[0] == 0x04 { c.mouseState.Buttons |= mask } else { c.mouseState.Buttons &^= mask } // TODO(nigeltao): update mouseState's timestamp. - c.mouse <- c.mouseState; - case 0x06: // Motion notify. - c.mouseState.Point.X = int(c.buf[25])<<8 | int(c.buf[24]); - c.mouseState.Point.Y = int(c.buf[27])<<8 | int(c.buf[26]); + c.mouse <- c.mouseState + case 0x06: // Motion notify. + c.mouseState.Point.X = int(c.buf[25])<<8 | int(c.buf[24]) + c.mouseState.Point.Y = int(c.buf[27])<<8 | int(c.buf[26]) // TODO(nigeltao): update mouseState's timestamp. - c.mouse <- c.mouseState; - case 0x0c: // Expose. + c.mouse <- c.mouseState + case 0x0c: // Expose. // A single user action could trigger multiple expose events (e.g. if moving another // window with XShape'd rounded corners over our window). In that case, the X server // will send a count (in bytes 16-17) of the number of additional expose events coming. // We could parse each event for the (x, y, width, height) and maintain a minimal dirty // rectangle, but for now, the simplest approach is to paint the entire window, when // receiving the final event in the series. - count := int(c.buf[17])<<8 | int(c.buf[16]); + count := int(c.buf[17])<<8 | int(c.buf[16]) if count == 0 { // TODO(nigeltao): Should we ignore the very first expose event? A freshly mapped window // will trigger expose, but until the first c.FlushImage call, there's probably nothing to @@ -192,14 +192,14 @@ func (c *conn) pumper() { // What about EnterNotify (0x07) and LeaveNotify (0x08)? } } - close(c.flush); + close(c.flush) // TODO(nigeltao): Is this the right place for c.c.Close()? // TODO(nigeltao): Should we explicitly close our kbd/mouse/resize/quit chans? } // Authenticate ourselves with the X server. func (c *conn) authenticate() os.Error { - key, value, err := readAuth(c.buf[0:]); + key, value, err := readAuth(c.buf[0:]) if err != nil { return err } @@ -210,69 +210,69 @@ func (c *conn) authenticate() os.Error { // 0x006c means little-endian. 0x000b, 0x0000 means X major version 11, minor version 0. // 0x0012 and 0x0010 means the auth key and value have lenths 18 and 16. // The final 0x0000 is padding, so that the string length is a multiple of 4. - _, err = io.WriteString(c.w, "\x6c\x00\x0b\x00\x00\x00\x12\x00\x10\x00\x00\x00"); + _, err = io.WriteString(c.w, "\x6c\x00\x0b\x00\x00\x00\x12\x00\x10\x00\x00\x00") if err != nil { return err } - _, err = io.WriteString(c.w, key); + _, err = io.WriteString(c.w, key) if err != nil { return err } // Again, the 0x0000 is padding. - _, err = io.WriteString(c.w, "\x00\x00"); + _, err = io.WriteString(c.w, "\x00\x00") if err != nil { return err } - _, err = io.WriteString(c.w, value); + _, err = io.WriteString(c.w, value) if err != nil { return err } - err = c.w.Flush(); + err = c.w.Flush() if err != nil { return err } - return nil; + return nil } // Reads a uint8 from r, using b as a scratch buffer. func readU8(r io.Reader, b []byte) (uint8, os.Error) { - _, err := io.ReadFull(r, b[0:1]); + _, err := io.ReadFull(r, b[0:1]) if err != nil { return 0, err } - return uint8(b[0]), nil; + return uint8(b[0]), nil } // Reads a little-endian uint16 from r, using b as a scratch buffer. func readU16LE(r io.Reader, b []byte) (uint16, os.Error) { - _, err := io.ReadFull(r, b[0:2]); + _, err := io.ReadFull(r, b[0:2]) if err != nil { return 0, err } - return uint16(b[0]) | uint16(b[1])<<8, nil; + return uint16(b[0]) | uint16(b[1])<<8, nil } // Reads a little-endian uint32 from r, using b as a scratch buffer. func readU32LE(r io.Reader, b []byte) (uint32, os.Error) { - _, err := io.ReadFull(r, b[0:4]); + _, err := io.ReadFull(r, b[0:4]) if err != nil { return 0, err } - return uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24, nil; + return uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24, nil } // Sets b[0:4] to be the big-endian representation of u. func setU32LE(b []byte, u uint32) { - b[0] = byte((u >> 0) & 0xff); - b[1] = byte((u >> 8) & 0xff); - b[2] = byte((u >> 16) & 0xff); - b[3] = byte((u >> 24) & 0xff); + b[0] = byte((u >> 0) & 0xff) + b[1] = byte((u >> 8) & 0xff) + b[2] = byte((u >> 16) & 0xff) + b[3] = byte((u >> 24) & 0xff) } // Check that we have an agreeable X pixmap Format. func checkPixmapFormats(r io.Reader, b []byte, n int) (agree bool, err os.Error) { for i := 0; i < n; i++ { - _, err = io.ReadFull(r, b[0:8]); + _, err = io.ReadFull(r, b[0:8]) if err != nil { return } @@ -281,35 +281,35 @@ func checkPixmapFormats(r io.Reader, b []byte, n int) (agree bool, err os.Error) agree = true } } - return; + return } // Check that we have an agreeable X Depth (i.e. one that has an agreeable X VisualType). func checkDepths(r io.Reader, b []byte, n int, visual uint32) (agree bool, err os.Error) { for i := 0; i < n; i++ { - depth, err := readU16LE(r, b); + depth, err := readU16LE(r, b) if err != nil { return } - depth &= 0xff; - visualsLen, err := readU16LE(r, b); + depth &= 0xff + visualsLen, err := readU16LE(r, b) if err != nil { return } // Ignore 4 bytes of padding. - _, err = io.ReadFull(r, b[0:4]); + _, err = io.ReadFull(r, b[0:4]) if err != nil { return } for j := 0; j < int(visualsLen); j++ { // Read 24 bytes: visual(4), class(1), bits per rgb value(1), colormap entries(2), // red mask(4), green mask(4), blue mask(4), padding(4). - v, err := readU32LE(r, b); - _, err = readU32LE(r, b); - rm, err := readU32LE(r, b); - gm, err := readU32LE(r, b); - bm, err := readU32LE(r, b); - _, err = readU32LE(r, b); + v, err := readU32LE(r, b) + _, err = readU32LE(r, b) + rm, err := readU32LE(r, b) + gm, err := readU32LE(r, b) + bm, err := readU32LE(r, b) + _, err = readU32LE(r, b) if err != nil { return } @@ -318,47 +318,47 @@ func checkDepths(r io.Reader, b []byte, n int, visual uint32) (agree bool, err o } } } - return; + return } // Check that we have an agreeable X Screen. func checkScreens(r io.Reader, b []byte, n int) (root, visual uint32, err os.Error) { for i := 0; i < n; i++ { - root0, err := readU32LE(r, b); + root0, err := readU32LE(r, b) if err != nil { return } // Ignore the next 7x4 bytes, which is: colormap, whitepixel, blackpixel, current input masks, // width and height (pixels), width and height (mm), min and max installed maps. - _, err = io.ReadFull(r, b[0:28]); + _, err = io.ReadFull(r, b[0:28]) if err != nil { return } - visual0, err := readU32LE(r, b); + visual0, err := readU32LE(r, b) if err != nil { return } // Next 4 bytes: backing stores, save unders, root depth, allowed depths length. - x, err := readU32LE(r, b); + x, err := readU32LE(r, b) if err != nil { return } - nDepths := int(x >> 24); - agree, err := checkDepths(r, b, nDepths, visual0); + nDepths := int(x >> 24) + agree, err := checkDepths(r, b, nDepths, visual0) if err != nil { return } if agree && root == 0 { - root = root0; - visual = visual0; + root = root0 + visual = visual0 } } - return; + return } // Perform the protocol handshake with the X server, and ensure that the server provides a compatible Screen, Depth, etcetera. func (c *conn) handshake() os.Error { - _, err := io.ReadFull(c.r, c.buf[0:8]); + _, err := io.ReadFull(c.r, c.buf[0:8]) if err != nil { return err } @@ -367,17 +367,17 @@ func (c *conn) handshake() os.Error { return os.NewError("unsupported X version") } // Ignore the release number. - _, err = io.ReadFull(c.r, c.buf[0:4]); + _, err = io.ReadFull(c.r, c.buf[0:4]) if err != nil { return err } // Read the resource ID base. - resourceIdBase, err := readU32LE(c.r, c.buf[0:4]); + resourceIdBase, err := readU32LE(c.r, c.buf[0:4]) if err != nil { return err } // Read the resource ID mask. - resourceIdMask, err := readU32LE(c.r, c.buf[0:4]); + resourceIdMask, err := readU32LE(c.r, c.buf[0:4]) if err != nil { return err } @@ -385,12 +385,12 @@ func (c *conn) handshake() os.Error { return os.NewError("X resource ID mask is too small") } // Ignore the motion buffer size. - _, err = io.ReadFull(c.r, c.buf[0:4]); + _, err = io.ReadFull(c.r, c.buf[0:4]) if err != nil { return err } // Read the vendor length. - vendorLen, err := readU16LE(c.r, c.buf[0:2]); + vendorLen, err := readU16LE(c.r, c.buf[0:2]) if err != nil { return err } @@ -400,7 +400,7 @@ func (c *conn) handshake() os.Error { return os.NewError("unsupported X vendor") } // Read the maximum request length. - maxReqLen, err := readU16LE(c.r, c.buf[0:2]); + maxReqLen, err := readU16LE(c.r, c.buf[0:2]) if err != nil { return err } @@ -408,24 +408,24 @@ func (c *conn) handshake() os.Error { return os.NewError("unsupported X maximum request length") } // Read the roots length. - rootsLen, err := readU8(c.r, c.buf[0:1]); + rootsLen, err := readU8(c.r, c.buf[0:1]) if err != nil { return err } // Read the pixmap formats length. - pixmapFormatsLen, err := readU8(c.r, c.buf[0:1]); + pixmapFormatsLen, err := readU8(c.r, c.buf[0:1]) if err != nil { return err } // Ignore some things that we don't care about (totalling 30 bytes): // imageByteOrder(1), bitmapFormatBitOrder(1), bitmapFormatScanlineUnit(1) bitmapFormatScanlinePad(1), // minKeycode(1), maxKeycode(1), padding(4), vendor(20, hard-coded above). - _, err = io.ReadFull(c.r, c.buf[0:30]); + _, err = io.ReadFull(c.r, c.buf[0:30]) if err != nil { return err } // Check that we have an agreeable pixmap format. - agree, err := checkPixmapFormats(c.r, c.buf[0:8], int(pixmapFormatsLen)); + agree, err := checkPixmapFormats(c.r, c.buf[0:8], int(pixmapFormatsLen)) if err != nil { return err } @@ -433,83 +433,83 @@ func (c *conn) handshake() os.Error { return os.NewError("unsupported X pixmap formats") } // Check that we have an agreeable screen. - root, visual, err := checkScreens(c.r, c.buf[0:24], int(rootsLen)); + root, visual, err := checkScreens(c.r, c.buf[0:24], int(rootsLen)) if err != nil { return err } if root == 0 || visual == 0 { return os.NewError("unsupported X screen") } - c.gc = resID(resourceIdBase); - c.window = resID(resourceIdBase + 1); - c.root = resID(root); - c.visual = resID(visual); - return nil; + c.gc = resID(resourceIdBase) + c.window = resID(resourceIdBase + 1) + c.root = resID(root) + c.visual = resID(visual) + return nil } // Returns a new draw.Context, backed by a newly created and mapped X11 window. func NewWindow() (draw.Context, os.Error) { - display := getDisplay(); + display := getDisplay() if len(display) == 0 { return nil, os.NewError("unsupported DISPLAY") } - s, err := net.Dial("unix", "", "/tmp/.X11-unix/X"+display); + s, err := net.Dial("unix", "", "/tmp/.X11-unix/X"+display) if err != nil { return nil, err } - c := new(conn); - c.c = s; - c.r = bufio.NewReader(s); - c.w = bufio.NewWriter(s); - err = c.authenticate(); + c := new(conn) + c.c = s + c.r = bufio.NewReader(s) + c.w = bufio.NewWriter(s) + err = c.authenticate() if err != nil { return nil, err } - err = c.handshake(); + err = c.handshake() if err != nil { return nil, err } // Now that we're connected, show a window, via three X protocol messages. // First, create a graphics context (GC). - setU32LE(c.buf[0:4], 0x00060037); // 0x37 is the CreateGC opcode, and the message is 6 x 4 bytes long. - setU32LE(c.buf[4:8], uint32(c.gc)); - setU32LE(c.buf[8:12], uint32(c.root)); - setU32LE(c.buf[12:16], 0x00010004); // Bit 2 is XCB_GC_FOREGROUND, bit 16 is XCB_GC_GRAPHICS_EXPOSURES. - setU32LE(c.buf[16:20], 0x00000000); // The Foreground is black. - setU32LE(c.buf[20:24], 0x00000000); // GraphicsExposures' value is unused. + setU32LE(c.buf[0:4], 0x00060037) // 0x37 is the CreateGC opcode, and the message is 6 x 4 bytes long. + setU32LE(c.buf[4:8], uint32(c.gc)) + setU32LE(c.buf[8:12], uint32(c.root)) + setU32LE(c.buf[12:16], 0x00010004) // Bit 2 is XCB_GC_FOREGROUND, bit 16 is XCB_GC_GRAPHICS_EXPOSURES. + setU32LE(c.buf[16:20], 0x00000000) // The Foreground is black. + setU32LE(c.buf[20:24], 0x00000000) // GraphicsExposures' value is unused. // Second, create the window. - setU32LE(c.buf[24:28], 0x000a0001); // 0x01 is the CreateWindow opcode, and the message is 10 x 4 bytes long. - setU32LE(c.buf[28:32], uint32(c.window)); - setU32LE(c.buf[32:36], uint32(c.root)); - setU32LE(c.buf[36:40], 0x00000000); // Initial (x, y) is (0, 0). - setU32LE(c.buf[40:44], windowHeight<<16|windowWidth); - setU32LE(c.buf[44:48], 0x00010000); // Border width is 0, XCB_WINDOW_CLASS_INPUT_OUTPUT is 1. - setU32LE(c.buf[48:52], uint32(c.visual)); - setU32LE(c.buf[52:56], 0x00000802); // Bit 1 is XCB_CW_BACK_PIXEL, bit 11 is XCB_CW_EVENT_MASK. - setU32LE(c.buf[56:60], 0x00000000); // The Back-Pixel is black. - setU32LE(c.buf[60:64], 0x0000804f); // Key/button press and release, pointer motion, and expose event masks. + setU32LE(c.buf[24:28], 0x000a0001) // 0x01 is the CreateWindow opcode, and the message is 10 x 4 bytes long. + setU32LE(c.buf[28:32], uint32(c.window)) + setU32LE(c.buf[32:36], uint32(c.root)) + setU32LE(c.buf[36:40], 0x00000000) // Initial (x, y) is (0, 0). + setU32LE(c.buf[40:44], windowHeight<<16|windowWidth) + setU32LE(c.buf[44:48], 0x00010000) // Border width is 0, XCB_WINDOW_CLASS_INPUT_OUTPUT is 1. + setU32LE(c.buf[48:52], uint32(c.visual)) + setU32LE(c.buf[52:56], 0x00000802) // Bit 1 is XCB_CW_BACK_PIXEL, bit 11 is XCB_CW_EVENT_MASK. + setU32LE(c.buf[56:60], 0x00000000) // The Back-Pixel is black. + setU32LE(c.buf[60:64], 0x0000804f) // Key/button press and release, pointer motion, and expose event masks. // Third, map the window. - setU32LE(c.buf[64:68], 0x00020008); // 0x08 is the MapWindow opcode, and the message is 2 x 4 bytes long. - setU32LE(c.buf[68:72], uint32(c.window)); + setU32LE(c.buf[64:68], 0x00020008) // 0x08 is the MapWindow opcode, and the message is 2 x 4 bytes long. + setU32LE(c.buf[68:72], uint32(c.window)) // Write the bytes. - _, err = c.w.Write(c.buf[0:72]); + _, err = c.w.Write(c.buf[0:72]) if err != nil { return nil, err } - err = c.w.Flush(); + err = c.w.Flush() if err != nil { return nil, err } - c.img = image.NewRGBA(windowWidth, windowHeight); + c.img = image.NewRGBA(windowWidth, windowHeight) // TODO(nigeltao): Should these channels be buffered? - c.kbd = make(chan int); - c.mouse = make(chan draw.Mouse); - c.resize = make(chan bool); - c.quit = make(chan bool); - c.flush = make(chan bool, 1); - go c.flusher(); - go c.pumper(); - return c, nil; + c.kbd = make(chan int) + c.mouse = make(chan draw.Mouse) + c.resize = make(chan bool) + c.quit = make(chan bool) + c.flush = make(chan bool, 1) + go c.flusher() + go c.pumper() + return c, nil } diff --git a/src/pkg/exp/eval/abort.go b/src/pkg/exp/eval/abort.go index fd16d7eaa..bfa89fa29 100644 --- a/src/pkg/exp/eval/abort.go +++ b/src/pkg/exp/eval/abort.go @@ -5,9 +5,9 @@ package eval import ( - "fmt"; - "os"; - "runtime"; + "fmt" + "os" + "runtime" ) // Abort aborts the thread's current computation, @@ -16,46 +16,46 @@ func (t *Thread) Abort(err os.Error) { if t.abort == nil { panicln("abort:", err.String()) } - t.abort <- err; - runtime.Goexit(); + t.abort <- err + runtime.Goexit() } // Try executes a computation; if the computation // Aborts, Try returns the error passed to abort. func (t *Thread) Try(f func(t *Thread)) os.Error { - oc := t.abort; - c := make(chan os.Error); - t.abort = c; + oc := t.abort + c := make(chan os.Error) + t.abort = c go func() { - f(t); - c <- nil; - }(); - err := <-c; - t.abort = oc; - return err; + f(t) + c <- nil + }() + err := <-c + t.abort = oc + return err } type DivByZeroError struct{} -func (DivByZeroError) String() string { return "divide by zero" } +func (DivByZeroError) String() string { return "divide by zero" } type NilPointerError struct{} -func (NilPointerError) String() string { return "nil pointer dereference" } +func (NilPointerError) String() string { return "nil pointer dereference" } type IndexError struct { - Idx, Len int64; + Idx, Len int64 } func (e IndexError) String() string { if e.Idx < 0 { return fmt.Sprintf("negative index: %d", e.Idx) } - return fmt.Sprintf("index %d exceeds length %d", e.Idx, e.Len); + return fmt.Sprintf("index %d exceeds length %d", e.Idx, e.Len) } type SliceError struct { - Lo, Hi, Cap int64; + Lo, Hi, Cap int64 } func (e SliceError) String() string { @@ -63,13 +63,13 @@ func (e SliceError) String() string { } type KeyError struct { - Key interface{}; + Key interface{} } -func (e KeyError) String() string { return fmt.Sprintf("key '%v' not found in map", e.Key) } +func (e KeyError) String() string { return fmt.Sprintf("key '%v' not found in map", e.Key) } type NegativeLengthError struct { - Len int64; + Len int64 } func (e NegativeLengthError) String() string { @@ -77,7 +77,7 @@ func (e NegativeLengthError) String() string { } type NegativeCapacityError struct { - Len int64; + Len int64 } func (e NegativeCapacityError) String() string { diff --git a/src/pkg/exp/eval/bridge.go b/src/pkg/exp/eval/bridge.go index fed27930f..43a6fd30d 100644 --- a/src/pkg/exp/eval/bridge.go +++ b/src/pkg/exp/eval/bridge.go @@ -5,9 +5,9 @@ package eval import ( - "log"; - "go/token"; - "reflect"; + "log" + "go/token" + "reflect" ) /* @@ -15,8 +15,8 @@ import ( */ var ( - evalTypes = make(map[reflect.Type]Type); - nativeTypes = make(map[Type]reflect.Type); + evalTypes = make(map[reflect.Type]Type) + nativeTypes = make(map[Type]reflect.Type) ) // TypeFromNative converts a regular Go type into a the corresponding @@ -26,14 +26,14 @@ func TypeFromNative(t reflect.Type) Type { return et } - var nt *NamedType; + var nt *NamedType if t.Name() != "" { - name := t.PkgPath() + "·" + t.Name(); - nt = &NamedType{token.Position{}, name, nil, true, make(map[string]Method)}; - evalTypes[t] = nt; + name := t.PkgPath() + "·" + t.Name() + nt = &NamedType{token.Position{}, name, nil, true, make(map[string]Method)} + evalTypes[t] = nt } - var et Type; + var et Type switch t := t.(type) { case *reflect.BoolType: et = BoolType @@ -73,24 +73,24 @@ func TypeFromNative(t reflect.Type) Type { case *reflect.ChanType: log.Crashf("%T not implemented", t) case *reflect.FuncType: - nin := t.NumIn(); + nin := t.NumIn() // Variadic functions have DotDotDotType at the end - varidic := false; + varidic := false if nin > 0 { if _, ok := t.In(nin - 1).(*reflect.DotDotDotType); ok { - varidic = true; - nin--; + varidic = true + nin-- } } - in := make([]Type, nin); + in := make([]Type, nin) for i := range in { in[i] = TypeFromNative(t.In(i)) } - out := make([]Type, t.NumOut()); + out := make([]Type, t.NumOut()) for i := range out { out[i] = TypeFromNative(t.Out(i)) } - et = NewFuncType(in, varidic, out); + et = NewFuncType(in, varidic, out) case *reflect.InterfaceType: log.Crashf("%T not implemented", t) case *reflect.MapType: @@ -100,16 +100,16 @@ func TypeFromNative(t reflect.Type) Type { case *reflect.SliceType: et = NewSliceType(TypeFromNative(t.Elem())) case *reflect.StructType: - n := t.NumField(); - fields := make([]StructField, n); + n := t.NumField() + fields := make([]StructField, n) for i := 0; i < n; i++ { - sf := t.Field(i); + sf := t.Field(i) // TODO(austin) What to do about private fields? - fields[i].Name = sf.Name; - fields[i].Type = TypeFromNative(sf.Type); - fields[i].Anonymous = sf.Anonymous; + fields[i].Name = sf.Name + fields[i].Type = TypeFromNative(sf.Type) + fields[i].Anonymous = sf.Anonymous } - et = NewStructType(fields); + et = NewStructType(fields) case *reflect.UnsafePointerType: log.Crashf("%T not implemented", t) default: @@ -118,35 +118,35 @@ func TypeFromNative(t reflect.Type) Type { if nt != nil { if _, ok := et.(*NamedType); !ok { - nt.Complete(et); - et = nt; + nt.Complete(et) + et = nt } } - nativeTypes[et] = t; - evalTypes[t] = et; + nativeTypes[et] = t + evalTypes[t] = et - return et; + return et } // TypeOfNative returns the interpreter Type of a regular Go value. -func TypeOfNative(v interface{}) Type { return TypeFromNative(reflect.Typeof(v)) } +func TypeOfNative(v interface{}) Type { return TypeFromNative(reflect.Typeof(v)) } /* * Function bridging */ type nativeFunc struct { - fn func(*Thread, []Value, []Value); - in, out int; + fn func(*Thread, []Value, []Value) + in, out int } func (f *nativeFunc) NewFrame() *Frame { - vars := make([]Value, f.in+f.out); - return &Frame{nil, vars}; + vars := make([]Value, f.in+f.out) + return &Frame{nil, vars} } -func (f *nativeFunc) Call(t *Thread) { f.fn(t, t.f.Vars[0:f.in], t.f.Vars[f.in:f.in+f.out]) } +func (f *nativeFunc) Call(t *Thread) { f.fn(t, t.f.Vars[0:f.in], t.f.Vars[f.in:f.in+f.out]) } // FuncFromNative creates an interpreter function from a native // function that takes its in and out arguments as slices of @@ -161,6 +161,6 @@ func FuncFromNative(fn func(*Thread, []Value, []Value), t *FuncType) FuncValue { // the type will be given as a nil pointer to a function with the // desired signature. func FuncFromNativeTyped(fn func(*Thread, []Value, []Value), t interface{}) (*FuncType, FuncValue) { - ft := TypeOfNative(t).(*FuncType); - return ft, FuncFromNative(fn, ft); + ft := TypeOfNative(t).(*FuncType) + return ft, FuncFromNative(fn, ft) } diff --git a/src/pkg/exp/eval/compiler.go b/src/pkg/exp/eval/compiler.go index f349b836f..6bde3b567 100644 --- a/src/pkg/exp/eval/compiler.go +++ b/src/pkg/exp/eval/compiler.go @@ -5,14 +5,14 @@ package eval import ( - "fmt"; - "go/scanner"; - "go/token"; + "fmt" + "go/scanner" + "go/token" ) type positioned interface { - Pos() token.Position; + Pos() token.Position } @@ -22,28 +22,28 @@ type positioned interface { // TODO(austin) This might actually represent package level, in which // case it should be package compiler. type compiler struct { - errors scanner.ErrorHandler; - numErrors int; - silentErrors int; + errors scanner.ErrorHandler + numErrors int + silentErrors int } func (a *compiler) diagAt(pos positioned, format string, args ...) { - a.errors.Error(pos.Pos(), fmt.Sprintf(format, args)); - a.numErrors++; + a.errors.Error(pos.Pos(), fmt.Sprintf(format, args)) + a.numErrors++ } -func (a *compiler) numError() int { return a.numErrors + a.silentErrors } +func (a *compiler) numError() int { return a.numErrors + a.silentErrors } // The universal scope func newUniverse() *Scope { - sc := &Scope{nil, 0}; + sc := &Scope{nil, 0} sc.block = &block{ offset: 0, scope: sc, global: true, defs: make(map[string]Def), - }; - return sc; + } + return sc } var universe *Scope = newUniverse() @@ -51,46 +51,46 @@ var universe *Scope = newUniverse() // TODO(austin) These can all go in stmt.go now type label struct { - name string; - desc string; + name string + desc string // The PC goto statements should jump to, or nil if this label // cannot be goto'd (such as an anonymous for loop label). - gotoPC *uint; + gotoPC *uint // The PC break statements should jump to, or nil if a break // statement is invalid. - breakPC *uint; + breakPC *uint // The PC continue statements should jump to, or nil if a // continue statement is invalid. - continuePC *uint; + continuePC *uint // The position where this label was resolved. If it has not // been resolved yet, an invalid position. - resolved token.Position; + resolved token.Position // The position where this label was first jumped to. - used token.Position; + used token.Position } // A funcCompiler captures information used throughout the compilation // of a single function body. type funcCompiler struct { - *compiler; - fnType *FuncType; + *compiler + fnType *FuncType // Whether the out variables are named. This affects what // kinds of return statements are legal. - outVarsNamed bool; - *codeBuf; - flow *flowBuf; - labels map[string]*label; + outVarsNamed bool + *codeBuf + flow *flowBuf + labels map[string]*label } // A blockCompiler captures information used throughout the compilation // of a single block within a function. type blockCompiler struct { - *funcCompiler; - block *block; + *funcCompiler + block *block // The label of this block, used for finding break and // continue labels. - label *label; + label *label // The blockCompiler for the block enclosing this one, or nil // for a function-level block. - parent *blockCompiler; + parent *blockCompiler } diff --git a/src/pkg/exp/eval/eval_test.go b/src/pkg/exp/eval/eval_test.go index afd91bfb2..93a643b5a 100644 --- a/src/pkg/exp/eval/eval_test.go +++ b/src/pkg/exp/eval/eval_test.go @@ -5,19 +5,19 @@ package eval import ( - "bignum"; - "flag"; - "fmt"; - "log"; - "os"; - "reflect"; - "testing"; + "bignum" + "flag" + "fmt" + "log" + "os" + "reflect" + "testing" ) // Print each statement or expression before parsing it var noisy = false -func init() { flag.BoolVar(&noisy, "noisy", false, "chatter during eval tests") } +func init() { flag.BoolVar(&noisy, "noisy", false, "chatter during eval tests") } /* * Generic statement/expression test framework @@ -26,60 +26,60 @@ func init() { flag.BoolVar(&noisy, "noisy", false, "chatter during eval tests") type test []job type job struct { - code string; - cerr string; - rterr string; - val Value; - noval bool; + code string + cerr string + rterr string + val Value + noval bool } func runTests(t *testing.T, baseName string, tests []test) { for i, test := range tests { - name := fmt.Sprintf("%s[%d]", baseName, i); - test.run(t, name); + name := fmt.Sprintf("%s[%d]", baseName, i) + test.run(t, name) } } func (a test) run(t *testing.T, name string) { - w := newTestWorld(); + w := newTestWorld() for _, j := range a { - src := j.code; + src := j.code if noisy { println("code:", src) } - code, err := w.Compile(src); + code, err := w.Compile(src) if err != nil { if j.cerr == "" { - t.Errorf("%s: Compile %s: %v", name, src, err); - break; + t.Errorf("%s: Compile %s: %v", name, src, err) + break } if !match(t, err, j.cerr) { - t.Errorf("%s: Compile %s = error %s; want %v", name, src, err, j.cerr); - break; + t.Errorf("%s: Compile %s = error %s; want %v", name, src, err, j.cerr) + break } - continue; + continue } if j.cerr != "" { - t.Errorf("%s: Compile %s succeeded; want %s", name, src, j.cerr); - break; + t.Errorf("%s: Compile %s succeeded; want %s", name, src, j.cerr) + break } - val, err := code.Run(); + val, err := code.Run() if err != nil { if j.rterr == "" { - t.Errorf("%s: Run %s: %v", name, src, err); - break; + t.Errorf("%s: Run %s: %v", name, src, err) + break } if !match(t, err, j.rterr) { - t.Errorf("%s: Run %s = error %s; want %v", name, src, err, j.rterr); - break; + t.Errorf("%s: Run %s = error %s; want %v", name, src, err, j.rterr) + break } - continue; + continue } if j.rterr != "" { - t.Errorf("%s: Run %s succeeded; want %s", name, src, j.rterr); - break; + t.Errorf("%s: Run %s succeeded; want %s", name, src, j.rterr) + break } if !j.noval && !reflect.DeepEqual(val, j.val) { @@ -89,11 +89,11 @@ func (a test) run(t *testing.T, name string) { } func match(t *testing.T, err os.Error, pat string) bool { - ok, errstr := testing.MatchString(pat, err.String()); + ok, errstr := testing.MatchString(pat, err.String()) if errstr != "" { t.Fatalf("compile regexp %s: %v", pat, errstr) } - return ok; + return ok } @@ -102,10 +102,10 @@ func match(t *testing.T, err os.Error, pat string) bool { */ // Expression compile error -func CErr(expr string, cerr string) test { return test([]job{job{code: expr, cerr: cerr}}) } +func CErr(expr string, cerr string) test { return test([]job{job{code: expr, cerr: cerr}}) } // Expression runtime error -func RErr(expr string, rterr string) test { return test([]job{job{code: expr, rterr: rterr}}) } +func RErr(expr string, rterr string) test { return test([]job{job{code: expr, rterr: rterr}}) } // Expression value func Val(expr string, val interface{}) test { @@ -113,7 +113,7 @@ func Val(expr string, val interface{}) test { } // Statement runs without error -func Run(stmts string) test { return test([]job{job{code: stmts, noval: true}}) } +func Run(stmts string) test { return test([]job{job{code: stmts, noval: true}}) } // Two statements without error. // TODO(rsc): Should be possible with Run but the parser @@ -148,55 +148,55 @@ type vstruct []interface{} type varray []interface{} type vslice struct { - arr varray; - len, cap int; + arr varray + len, cap int } func toValue(val interface{}) Value { switch val := val.(type) { case bool: - r := boolV(val); - return &r; + r := boolV(val) + return &r case uint8: - r := uint8V(val); - return &r; + r := uint8V(val) + return &r case uint: - r := uintV(val); - return &r; + r := uintV(val) + return &r case int: - r := intV(val); - return &r; + r := intV(val) + return &r case *bignum.Integer: return &idealIntV{val} case float: - r := floatV(val); - return &r; + r := floatV(val) + return &r case *bignum.Rational: return &idealFloatV{val} case string: - r := stringV(val); - return &r; + r := stringV(val) + return &r case vstruct: - elems := make([]Value, len(val)); + elems := make([]Value, len(val)) for i, e := range val { elems[i] = toValue(e) } - r := structV(elems); - return &r; + r := structV(elems) + return &r case varray: - elems := make([]Value, len(val)); + elems := make([]Value, len(val)) for i, e := range val { elems[i] = toValue(e) } - r := arrayV(elems); - return &r; + r := arrayV(elems) + return &r case vslice: return &sliceV{Slice{toValue(val.arr).(ArrayValue), int64(val.len), int64(val.cap)}} case Func: return &funcV{val} } - log.Crashf("toValue(%T) not implemented", val); - panic(); + log.Crashf("toValue(%T) not implemented", val) + panic() } /* @@ -205,50 +205,50 @@ func toValue(val interface{}) Value { type testFunc struct{} -func (*testFunc) NewFrame() *Frame { return &Frame{nil, &[2]Value{}} } +func (*testFunc) NewFrame() *Frame { return &Frame{nil, &[2]Value{}} } func (*testFunc) Call(t *Thread) { - n := t.f.Vars[0].(IntValue).Get(t); + n := t.f.Vars[0].(IntValue).Get(t) - res := n + 1; + res := n + 1 - t.f.Vars[1].(IntValue).Set(t, res); + t.f.Vars[1].(IntValue).Set(t, res) } type oneTwoFunc struct{} -func (*oneTwoFunc) NewFrame() *Frame { return &Frame{nil, &[2]Value{}} } +func (*oneTwoFunc) NewFrame() *Frame { return &Frame{nil, &[2]Value{}} } func (*oneTwoFunc) Call(t *Thread) { - t.f.Vars[0].(IntValue).Set(t, 1); - t.f.Vars[1].(IntValue).Set(t, 2); + t.f.Vars[0].(IntValue).Set(t, 1) + t.f.Vars[1].(IntValue).Set(t, 2) } type voidFunc struct{} -func (*voidFunc) NewFrame() *Frame { return &Frame{nil, []Value{}} } +func (*voidFunc) NewFrame() *Frame { return &Frame{nil, []Value{}} } -func (*voidFunc) Call(t *Thread) {} +func (*voidFunc) Call(t *Thread) {} func newTestWorld() *World { - w := NewWorld(); - - def := func(name string, t Type, val interface{}) { w.DefineVar(name, t, toValue(val)) }; - - w.DefineConst("c", IdealIntType, toValue(bignum.Int(1))); - def("i", IntType, 1); - def("i2", IntType, 2); - def("u", UintType, uint(1)); - def("f", FloatType, 1.0); - def("s", StringType, "abc"); - def("t", NewStructType([]StructField{StructField{"a", IntType, false}}), vstruct{1}); - def("ai", NewArrayType(2, IntType), varray{1, 2}); - def("aai", NewArrayType(2, NewArrayType(2, IntType)), varray{varray{1, 2}, varray{3, 4}}); - def("aai2", NewArrayType(2, NewArrayType(2, IntType)), varray{varray{5, 6}, varray{7, 8}}); - def("fn", NewFuncType([]Type{IntType}, false, []Type{IntType}), &testFunc{}); - def("oneTwo", NewFuncType([]Type{}, false, []Type{IntType, IntType}), &oneTwoFunc{}); - def("void", NewFuncType([]Type{}, false, []Type{}), &voidFunc{}); - def("sli", NewSliceType(IntType), vslice{varray{1, 2, 3}, 2, 3}); - - return w; + w := NewWorld() + + def := func(name string, t Type, val interface{}) { w.DefineVar(name, t, toValue(val)) } + + w.DefineConst("c", IdealIntType, toValue(bignum.Int(1))) + def("i", IntType, 1) + def("i2", IntType, 2) + def("u", UintType, uint(1)) + def("f", FloatType, 1.0) + def("s", StringType, "abc") + def("t", NewStructType([]StructField{StructField{"a", IntType, false}}), vstruct{1}) + def("ai", NewArrayType(2, IntType), varray{1, 2}) + def("aai", NewArrayType(2, NewArrayType(2, IntType)), varray{varray{1, 2}, varray{3, 4}}) + def("aai2", NewArrayType(2, NewArrayType(2, IntType)), varray{varray{5, 6}, varray{7, 8}}) + def("fn", NewFuncType([]Type{IntType}, false, []Type{IntType}), &testFunc{}) + def("oneTwo", NewFuncType([]Type{}, false, []Type{IntType, IntType}), &oneTwoFunc{}) + def("void", NewFuncType([]Type{}, false, []Type{}), &voidFunc{}) + def("sli", NewSliceType(IntType), vslice{varray{1, 2, 3}, 2, 3}) + + return w } diff --git a/src/pkg/exp/eval/expr.go b/src/pkg/exp/eval/expr.go index 1f1bf0634..8e161e522 100644 --- a/src/pkg/exp/eval/expr.go +++ b/src/pkg/exp/eval/expr.go @@ -5,53 +5,53 @@ package eval import ( - "bignum"; - "go/ast"; - "go/token"; - "log"; - "strconv"; - "strings"; - "os"; + "bignum" + "go/ast" + "go/token" + "log" + "strconv" + "strings" + "os" ) // An expr is the result of compiling an expression. It stores the // type of the expression and its evaluator function. type expr struct { - *exprInfo; - t Type; + *exprInfo + t Type // Evaluate this node as the given type. - eval interface{}; + eval interface{} // Map index expressions permit special forms of assignment, // for which we need to know the Map and key. - evalMapValue func(t *Thread) (Map, interface{}); + evalMapValue func(t *Thread) (Map, interface{}) // Evaluate to the "address of" this value; that is, the // settable Value object. nil for expressions whose address // cannot be taken. - evalAddr func(t *Thread) Value; + evalAddr func(t *Thread) Value // Execute this expression as a statement. Only expressions // that are valid expression statements should set this. - exec func(t *Thread); + exec func(t *Thread) // If this expression is a type, this is its compiled type. // This is only permitted in the function position of a call // expression. In this case, t should be nil. - valType Type; + valType Type // A short string describing this expression for error // messages. - desc string; + desc string } // exprInfo stores information needed to compile any expression node. // Each expr also stores its exprInfo so further expressions can be // compiled from it. type exprInfo struct { - *compiler; - pos token.Position; + *compiler + pos token.Position } func (a *exprInfo) newExpr(t Type, desc string) *expr { @@ -84,7 +84,7 @@ func (a *expr) convertTo(t Type) *expr { log.Crashf("attempted to convert from %v, expected ideal", a.t) } - var rat *bignum.Rational; + var rat *bignum.Rational // XXX(Spec) The spec says "It is erroneous". // @@ -94,14 +94,14 @@ func (a *expr) convertTo(t Type) *expr { // by the type of the variable. switch a.t { case IdealFloatType: - rat = a.asIdealFloat()(); + rat = a.asIdealFloat()() if t.isInteger() && !rat.IsInt() { - a.diag("constant %v truncated to integer", ratToString(rat)); - return nil; + a.diag("constant %v truncated to integer", ratToString(rat)) + return nil } case IdealIntType: - i := a.asIdealInt()(); - rat = bignum.MakeRat(i, bignum.Nat(1)); + i := a.asIdealInt()() + rat = bignum.MakeRat(i, bignum.Nat(1)) default: log.Crashf("unexpected ideal type %v", a.t) } @@ -109,43 +109,43 @@ func (a *expr) convertTo(t Type) *expr { // Check bounds if t, ok := t.lit().(BoundedType); ok { if rat.Cmp(t.minVal()) < 0 { - a.diag("constant %v underflows %v", ratToString(rat), t); - return nil; + a.diag("constant %v underflows %v", ratToString(rat), t) + return nil } if rat.Cmp(t.maxVal()) > 0 { - a.diag("constant %v overflows %v", ratToString(rat), t); - return nil; + a.diag("constant %v overflows %v", ratToString(rat), t) + return nil } } // Convert rat to type t. - res := a.newExpr(t, a.desc); + res := a.newExpr(t, a.desc) switch t := t.lit().(type) { case *uintType: - n, d := rat.Value(); - f := n.Quo(bignum.MakeInt(false, d)); - v := f.Abs().Value(); - res.eval = func(*Thread) uint64 { return v }; + n, d := rat.Value() + f := n.Quo(bignum.MakeInt(false, d)) + v := f.Abs().Value() + res.eval = func(*Thread) uint64 { return v } case *intType: - n, d := rat.Value(); - f := n.Quo(bignum.MakeInt(false, d)); - v := f.Value(); - res.eval = func(*Thread) int64 { return v }; + n, d := rat.Value() + f := n.Quo(bignum.MakeInt(false, d)) + v := f.Value() + res.eval = func(*Thread) int64 { return v } case *idealIntType: - n, d := rat.Value(); - f := n.Quo(bignum.MakeInt(false, d)); - res.eval = func() *bignum.Integer { return f }; + n, d := rat.Value() + f := n.Quo(bignum.MakeInt(false, d)) + res.eval = func() *bignum.Integer { return f } case *floatType: - n, d := rat.Value(); - v := float64(n.Value()) / float64(d.Value()); - res.eval = func(*Thread) float64 { return v }; + n, d := rat.Value() + v := float64(n.Value()) / float64(d.Value()) + res.eval = func(*Thread) float64 { return v } case *idealFloatType: res.eval = func() *bignum.Rational { return rat } default: log.Crashf("cannot convert to type %T", t) } - return res; + return res } // convertToInt converts this expression to an integer, if possible, @@ -156,35 +156,35 @@ func (a *expr) convertTo(t Type) *expr { func (a *expr) convertToInt(max int64, negErr string, errOp string) *expr { switch a.t.lit().(type) { case *idealIntType: - val := a.asIdealInt()(); + val := a.asIdealInt()() if negErr != "" && val.IsNeg() { - a.diag("negative %s: %s", negErr, val); - return nil; + a.diag("negative %s: %s", negErr, val) + return nil } - bound := max; + bound := max if negErr == "slice" { bound++ } if max != -1 && val.Cmp(bignum.Int(bound)) >= 0 { - a.diag("index %s exceeds length %d", val, max); - return nil; + a.diag("index %s exceeds length %d", val, max) + return nil } - return a.convertTo(IntType); + return a.convertTo(IntType) case *uintType: // Convert to int - na := a.newExpr(IntType, a.desc); - af := a.asUint(); - na.eval = func(t *Thread) int64 { return int64(af(t)) }; - return na; + na := a.newExpr(IntType, a.desc) + af := a.asUint() + na.eval = func(t *Thread) int64 { return int64(af(t)) } + return na case *intType: // Good as is return a } - a.diag("illegal operand type for %s\n\t%v", errOp, a.t); - return nil; + a.diag("illegal operand type for %s\n\t%v", errOp, a.t) + return nil } // derefArray returns an expression of array type if the given @@ -193,14 +193,14 @@ func (a *expr) convertToInt(max int64, negErr string, errOp string) *expr { func (a *expr) derefArray() *expr { if pt, ok := a.t.lit().(*PtrType); ok { if _, ok := pt.Elem.lit().(*ArrayType); ok { - deref := a.compileStarExpr(a); + deref := a.compileStarExpr(a) if deref == nil { log.Crashf("failed to dereference *array") } - return deref; + return deref } } - return a; + return a } /* @@ -221,25 +221,25 @@ func (a *expr) derefArray() *expr { // Assigning a single expression with multi-valued type to a // multi-valued type. type assignCompiler struct { - *compiler; - pos token.Position; + *compiler + pos token.Position // The RHS expressions. This may include nil's for // expressions that failed to compile. - rs []*expr; + rs []*expr // The (possibly unary) MultiType of the RHS. - rmt *MultiType; + rmt *MultiType // Whether this is an unpack assignment (case 3). - isUnpack bool; + isUnpack bool // Whether map special assignment forms are allowed. - allowMap bool; + allowMap bool // Whether this is a "r, ok = a[x]" assignment. - isMapUnpack bool; + isMapUnpack bool // The operation name to use in error messages, such as // "assignment" or "function call". - errOp string; + errOp string // The name to use for positions in error messages, such as // "argument". - errPosName string; + errPosName string } // Type check the RHS of an assignment, returning a new assignCompiler @@ -254,48 +254,48 @@ func (a *compiler) checkAssign(pos token.Position, rs []*expr, errOp, errPosName rs: rs, errOp: errOp, errPosName: errPosName, - }; + } // Is this an unpack? if len(rs) == 1 && rs[0] != nil { if rmt, isUnpack := rs[0].t.(*MultiType); isUnpack { - c.rmt = rmt; - c.isUnpack = true; - return c, true; + c.rmt = rmt + c.isUnpack = true + return c, true } } // Create MultiType for RHS and check that all RHS expressions // are single-valued. - rts := make([]Type, len(rs)); - ok := true; + rts := make([]Type, len(rs)) + ok := true for i, r := range rs { if r == nil { - ok = false; - continue; + ok = false + continue } if _, isMT := r.t.(*MultiType); isMT { - r.diag("multi-valued expression not allowed in %s", errOp); - ok = false; - continue; + r.diag("multi-valued expression not allowed in %s", errOp) + ok = false + continue } - rts[i] = r.t; + rts[i] = r.t } - c.rmt = NewMultiType(rts); - return c, ok; + c.rmt = NewMultiType(rts) + return c, ok } func (a *assignCompiler) allowMapForms(nls int) { - a.allowMap = true; + a.allowMap = true // Update unpacking info if this is r, ok = a[x] if nls == 2 && len(a.rs) == 1 && a.rs[0] != nil && a.rs[0].evalMapValue != nil { - a.isUnpack = true; - a.rmt = NewMultiType([]Type{a.rs[0].t, BoolType}); - a.isMapUnpack = true; + a.isUnpack = true + a.rmt = NewMultiType([]Type{a.rs[0].t, BoolType}) + a.isMapUnpack = true } } @@ -304,8 +304,8 @@ func (a *assignCompiler) allowMapForms(nls int) { // evaluate the RHS expressions. The l-value must have exactly the // type given by lt. Returns nil if type checking fails. func (a *assignCompiler) compile(b *block, lt Type) (func(Value, *Thread)) { - lmt, isMT := lt.(*MultiType); - rmt, isUnpack := a.rmt, a.isUnpack; + lmt, isMT := lt.(*MultiType) + rmt, isUnpack := a.rmt, a.isUnpack // Create unary MultiType for single LHS if !isMT { @@ -313,61 +313,61 @@ func (a *assignCompiler) compile(b *block, lt Type) (func(Value, *Thread)) { } // Check that the assignment count matches - lcount := len(lmt.Elems); - rcount := len(rmt.Elems); + lcount := len(lmt.Elems) + rcount := len(rmt.Elems) if lcount != rcount { - msg := "not enough"; - pos := a.pos; + msg := "not enough" + pos := a.pos if rcount > lcount { - msg = "too many"; + msg = "too many" if lcount > 0 { pos = a.rs[lcount-1].pos } } - a.diagAt(&pos, "%s %ss for %s\n\t%s\n\t%s", msg, a.errPosName, a.errOp, lt, rmt); - return nil; + a.diagAt(&pos, "%s %ss for %s\n\t%s\n\t%s", msg, a.errPosName, a.errOp, lt, rmt) + return nil } - bad := false; + bad := false // If this is an unpack, create a temporary to store the // multi-value and replace the RHS with expressions to pull // out values from the temporary. Technically, this is only // necessary when we need to perform assignment conversions. - var effect func(*Thread); + var effect func(*Thread) if isUnpack { // This leaks a slot, but is definitely safe. - temp := b.DefineTemp(a.rmt); - tempIdx := temp.Index; + temp := b.DefineTemp(a.rmt) + tempIdx := temp.Index if tempIdx < 0 { panicln("tempidx", tempIdx) } if a.isMapUnpack { - rf := a.rs[0].evalMapValue; - vt := a.rmt.Elems[0]; + rf := a.rs[0].evalMapValue + vt := a.rmt.Elems[0] effect = func(t *Thread) { - m, k := rf(t); - v := m.Elem(t, k); - found := boolV(true); + m, k := rf(t) + v := m.Elem(t, k) + found := boolV(true) if v == nil { - found = boolV(false); - v = vt.Zero(); + found = boolV(false) + v = vt.Zero() } - t.f.Vars[tempIdx] = multiV([]Value{v, &found}); - }; + t.f.Vars[tempIdx] = multiV([]Value{v, &found}) + } } else { - rf := a.rs[0].asMulti(); - effect = func(t *Thread) { t.f.Vars[tempIdx] = multiV(rf(t)) }; + rf := a.rs[0].asMulti() + effect = func(t *Thread) { t.f.Vars[tempIdx] = multiV(rf(t)) } } - orig := a.rs[0]; - a.rs = make([]*expr, len(a.rmt.Elems)); + orig := a.rs[0] + a.rs = make([]*expr, len(a.rmt.Elems)) for i, t := range a.rmt.Elems { if t.isIdeal() { log.Crashf("Right side of unpack contains ideal: %s", rmt) } - a.rs[i] = orig.newExpr(t, orig.desc); - index := i; - a.rs[i].genValue(func(t *Thread) Value { return t.f.Vars[tempIdx].(multiV)[index] }); + a.rs[i] = orig.newExpr(t, orig.desc) + index := i + a.rs[i].genValue(func(t *Thread) Value { return t.f.Vars[tempIdx].(multiV)[index] }) } } // Now len(a.rs) == len(a.rmt) and we've reduced any unpacking @@ -378,18 +378,18 @@ func (a *assignCompiler) compile(b *block, lt Type) (func(Value, *Thread)) { // Values of any type may always be assigned to variables of // compatible static type. for i, lt := range lmt.Elems { - rt := rmt.Elems[i]; + rt := rmt.Elems[i] // When [an ideal is] (used in an expression) assigned // to a variable or typed constant, the destination // must be able to represent the assigned value. if rt.isIdeal() { - a.rs[i] = a.rs[i].convertTo(lmt.Elems[i]); + a.rs[i] = a.rs[i].convertTo(lmt.Elems[i]) if a.rs[i] == nil { - bad = true; - continue; + bad = true + continue } - rt = a.rs[i].t; + rt = a.rs[i].t } // A pointer p to an array can be assigned to a slice @@ -399,11 +399,11 @@ func (a *assignCompiler) compile(b *block, lt Type) (func(Value, *Thread)) { if at, ok := rpt.Elem.lit().(*ArrayType); ok { if lst, ok := lt.lit().(*SliceType); ok { if lst.Elem.compat(at.Elem, false) && (rt.lit() == Type(rt) || lt.lit() == Type(lt)) { - rf := a.rs[i].asPtr(); - a.rs[i] = a.rs[i].newExpr(lt, a.rs[i].desc); - len := at.Len; - a.rs[i].eval = func(t *Thread) Slice { return Slice{rf(t).(ArrayValue), len, len} }; - rt = a.rs[i].t; + rf := a.rs[i].asPtr() + a.rs[i] = a.rs[i].newExpr(lt, a.rs[i].desc) + len := at.Len + a.rs[i].eval = func(t *Thread) Slice { return Slice{rf(t).(ArrayValue), len, len} } + rt = a.rs[i].t } } } @@ -415,7 +415,7 @@ func (a *assignCompiler) compile(b *block, lt Type) (func(Value, *Thread)) { } else { a.rs[i].diag("illegal operand types in %s %d of %s\n\t%v\n\t%v", a.errPosName, i+1, a.errOp, lt, rt) } - bad = true; + bad = true } } if bad { @@ -428,7 +428,7 @@ func (a *assignCompiler) compile(b *block, lt Type) (func(Value, *Thread)) { return genAssign(lt, a.rs[0]) } // Case 2 or 3 - as := make([]func(lv Value, t *Thread), len(a.rs)); + as := make([]func(lv Value, t *Thread), len(a.rs)) for i, r := range a.rs { as[i] = genAssign(lmt.Elems[i], r) } @@ -436,22 +436,22 @@ func (a *assignCompiler) compile(b *block, lt Type) (func(Value, *Thread)) { if effect != nil { effect(t) } - lmv := lv.(multiV); + lmv := lv.(multiV) for i, a := range as { a(lmv[i], t) } - }; + } } // compileAssign compiles an assignment operation without the full // generality of an assignCompiler. See assignCompiler for a // description of the arguments. func (a *compiler) compileAssign(pos token.Position, b *block, lt Type, rs []*expr, errOp, errPosName string) (func(Value, *Thread)) { - ac, ok := a.checkAssign(pos, rs, errOp, errPosName); + ac, ok := a.checkAssign(pos, rs, errOp, errPosName) if !ok { return nil } - return ac.compile(b, lt); + return ac.compile(b, lt) } /* @@ -462,11 +462,11 @@ func (a *compiler) compileAssign(pos token.Position, b *block, lt Type, rs []*ex // of a single expression. It does not embed funcCompiler because // expressions can appear at top level. type exprCompiler struct { - *compiler; + *compiler // The block this expression is being compiled in. - block *block; + block *block // Whether this expression is used in a constant context. - constant bool; + constant bool } // compile compiles an expression AST. callCtx should be true if this @@ -474,7 +474,7 @@ type exprCompiler struct { // the returned expression to be a type or a built-in function (which // otherwise result in errors). func (a *exprCompiler) compile(x ast.Expr, callCtx bool) *expr { - ei := &exprInfo{a.compiler, x.Pos()}; + ei := &exprInfo{a.compiler, x.Pos()} switch x := x.(type) { // Literals @@ -496,21 +496,21 @@ func (a *exprCompiler) compile(x ast.Expr, callCtx bool) *expr { goto notimpl case *ast.FuncLit: - decl := ei.compileFuncType(a.block, x.Type); + decl := ei.compileFuncType(a.block, x.Type) if decl == nil { // TODO(austin) Try compiling the body, // perhaps with dummy argument definitions return nil } - fn := ei.compileFunc(a.block, decl, x.Body); + fn := ei.compileFunc(a.block, decl, x.Body) if fn == nil { return nil } if a.constant { - a.diagAt(x, "function literal used in constant expression"); - return nil; + a.diagAt(x, "function literal used in constant expression") + return nil } - return ei.compileFuncLit(decl, fn); + return ei.compileFuncLit(decl, fn) // Types case *ast.ArrayType: @@ -535,24 +535,24 @@ func (a *exprCompiler) compile(x ast.Expr, callCtx bool) *expr { // Remaining expressions case *ast.BadExpr: // Error already reported by parser - a.silentErrors++; - return nil; + a.silentErrors++ + return nil case *ast.BinaryExpr: - l, r := a.compile(x.X, false), a.compile(x.Y, false); + l, r := a.compile(x.X, false), a.compile(x.Y, false) if l == nil || r == nil { return nil } - return ei.compileBinaryExpr(x.Op, l, r); + return ei.compileBinaryExpr(x.Op, l, r) case *ast.CallExpr: - l := a.compile(x.Fun, true); - args := make([]*expr, len(x.Args)); - bad := false; + l := a.compile(x.Fun, true) + args := make([]*expr, len(x.Args)) + bad := false for i, arg := range x.Args { if i == 0 && l != nil && (l.t == Type(makeType) || l.t == Type(newType)) { - argei := &exprInfo{a.compiler, arg.Pos()}; - args[i] = argei.exprFromType(a.compileType(a.block, arg)); + argei := &exprInfo{a.compiler, arg.Pos()} + args[i] = argei.exprFromType(a.compileType(a.block, arg)) } else { args[i] = a.compile(arg, false) } @@ -564,13 +564,13 @@ func (a *exprCompiler) compile(x ast.Expr, callCtx bool) *expr { return nil } if a.constant { - a.diagAt(x, "function call in constant context"); - return nil; + a.diagAt(x, "function call in constant context") + return nil } if l.valType != nil { - a.diagAt(x, "type conversions not implemented"); - return nil; + a.diagAt(x, "type conversions not implemented") + return nil } else if ft, ok := l.t.(*FuncType); ok && ft.builtin != "" { return ei.compileBuiltinCallExpr(a.block, ft, args) } else { @@ -581,25 +581,25 @@ func (a *exprCompiler) compile(x ast.Expr, callCtx bool) *expr { return ei.compileIdent(a.block, a.constant, callCtx, x.Value) case *ast.IndexExpr: - l, r := a.compile(x.X, false), a.compile(x.Index, false); + l, r := a.compile(x.X, false), a.compile(x.Index, false) if l == nil || r == nil { return nil } - return ei.compileIndexExpr(l, r); + return ei.compileIndexExpr(l, r) case *ast.SliceExpr: - end := x.End; + end := x.End if end == nil { // TODO: set end to len(x.X) panic("unimplemented") } - arr := a.compile(x.X, false); - lo := a.compile(x.Index, false); - hi := a.compile(end, false); + arr := a.compile(x.X, false) + lo := a.compile(x.Index, false) + hi := a.compile(end, false) if arr == nil || lo == nil || hi == nil { return nil } - return ei.compileSliceExpr(arr, lo, hi); + return ei.compileSliceExpr(arr, lo, hi) case *ast.KeyValueExpr: goto notimpl @@ -608,16 +608,16 @@ func (a *exprCompiler) compile(x ast.Expr, callCtx bool) *expr { return a.compile(x.X, callCtx) case *ast.SelectorExpr: - v := a.compile(x.X, false); + v := a.compile(x.X, false) if v == nil { return nil } - return ei.compileSelectorExpr(v, x.Sel.Value); + return ei.compileSelectorExpr(v, x.Sel.Value) case *ast.StarExpr: // We pass down our call context because this could be // a pointer type (and thus a type conversion) - v := a.compile(x.X, callCtx); + v := a.compile(x.X, callCtx) if v == nil { return nil } @@ -625,13 +625,13 @@ func (a *exprCompiler) compile(x ast.Expr, callCtx bool) *expr { // Turns out this was a pointer type, not a dereference return ei.exprFromType(NewPtrType(v.valType)) } - return ei.compileStarExpr(v); + return ei.compileStarExpr(v) case *ast.StringList: - strings := make([]*expr, len(x.Strings)); - bad := false; + strings := make([]*expr, len(x.Strings)) + bad := false for i, s := range x.Strings { - strings[i] = a.compile(s, false); + strings[i] = a.compile(s, false) if strings[i] == nil { bad = true } @@ -639,7 +639,7 @@ func (a *exprCompiler) compile(x ast.Expr, callCtx bool) *expr { if bad { return nil } - return ei.compileStringList(strings); + return ei.compileStringList(strings) case *ast.StructType: goto notimpl @@ -648,138 +648,138 @@ func (a *exprCompiler) compile(x ast.Expr, callCtx bool) *expr { goto notimpl case *ast.UnaryExpr: - v := a.compile(x.X, false); + v := a.compile(x.X, false) if v == nil { return nil } - return ei.compileUnaryExpr(x.Op, v); + return ei.compileUnaryExpr(x.Op, v) } - log.Crashf("unexpected ast node type %T", x); - panic(); + log.Crashf("unexpected ast node type %T", x) + panic() typeexpr: if !callCtx { - a.diagAt(x, "type used as expression"); - return nil; + a.diagAt(x, "type used as expression") + return nil } - return ei.exprFromType(a.compileType(a.block, x)); + return ei.exprFromType(a.compileType(a.block, x)) notimpl: - a.diagAt(x, "%T expression node not implemented", x); - return nil; + a.diagAt(x, "%T expression node not implemented", x) + return nil } func (a *exprInfo) exprFromType(t Type) *expr { if t == nil { return nil } - expr := a.newExpr(nil, "type"); - expr.valType = t; - return expr; + expr := a.newExpr(nil, "type") + expr.valType = t + return expr } func (a *exprInfo) compileIdent(b *block, constant bool, callCtx bool, name string) *expr { - bl, level, def := b.Lookup(name); + bl, level, def := b.Lookup(name) if def == nil { - a.diag("%s: undefined", name); - return nil; + a.diag("%s: undefined", name) + return nil } switch def := def.(type) { case *Constant: - expr := a.newExpr(def.Type, "constant"); + expr := a.newExpr(def.Type, "constant") if ft, ok := def.Type.(*FuncType); ok && ft.builtin != "" { // XXX(Spec) I don't think anything says that // built-in functions can't be used as values. if !callCtx { - a.diag("built-in function %s cannot be used as a value", ft.builtin); - return nil; + a.diag("built-in function %s cannot be used as a value", ft.builtin) + return nil } // Otherwise, we leave the evaluators empty // because this is handled specially } else { expr.genConstant(def.Value) } - return expr; + return expr case *Variable: if constant { - a.diag("variable %s used in constant expression", name); - return nil; + a.diag("variable %s used in constant expression", name) + return nil } if bl.global { return a.compileGlobalVariable(def) } - return a.compileVariable(level, def); + return a.compileVariable(level, def) case Type: if callCtx { return a.exprFromType(def) } - a.diag("type %v used as expression", name); - return nil; + a.diag("type %v used as expression", name) + return nil } - log.Crashf("name %s has unknown type %T", name, def); - panic(); + log.Crashf("name %s has unknown type %T", name, def) + panic() } func (a *exprInfo) compileVariable(level int, v *Variable) *expr { if v.Type == nil { // Placeholder definition from an earlier error - a.silentErrors++; - return nil; + a.silentErrors++ + return nil } - expr := a.newExpr(v.Type, "variable"); - expr.genIdentOp(level, v.Index); - return expr; + expr := a.newExpr(v.Type, "variable") + expr.genIdentOp(level, v.Index) + return expr } func (a *exprInfo) compileGlobalVariable(v *Variable) *expr { if v.Type == nil { // Placeholder definition from an earlier error - a.silentErrors++; - return nil; + a.silentErrors++ + return nil } if v.Init == nil { v.Init = v.Type.Zero() } - expr := a.newExpr(v.Type, "variable"); - val := v.Init; - expr.genValue(func(t *Thread) Value { return val }); - return expr; + expr := a.newExpr(v.Type, "variable") + val := v.Init + expr.genValue(func(t *Thread) Value { return val }) + return expr } func (a *exprInfo) compileIdealInt(i *bignum.Integer, desc string) *expr { - expr := a.newExpr(IdealIntType, desc); - expr.eval = func() *bignum.Integer { return i }; - return expr; + expr := a.newExpr(IdealIntType, desc) + expr.eval = func() *bignum.Integer { return i } + return expr } func (a *exprInfo) compileIntLit(lit string) *expr { - i, _, _ := bignum.IntFromString(lit, 0); - return a.compileIdealInt(i, "integer literal"); + i, _, _ := bignum.IntFromString(lit, 0) + return a.compileIdealInt(i, "integer literal") } func (a *exprInfo) compileCharLit(lit string) *expr { if lit[0] != '\'' { // Caught by parser - a.silentErrors++; - return nil; + a.silentErrors++ + return nil } - v, _, tail, err := strconv.UnquoteChar(lit[1:], '\''); + v, _, tail, err := strconv.UnquoteChar(lit[1:], '\'') if err != nil || tail != "'" { // Caught by parser - a.silentErrors++; - return nil; + a.silentErrors++ + return nil } - return a.compileIdealInt(bignum.Int(int64(v)), "character literal"); + return a.compileIdealInt(bignum.Int(int64(v)), "character literal") } func (a *exprInfo) compileFloatLit(lit string) *expr { - f, _, n := bignum.RatFromString(lit, 0); + f, _, n := bignum.RatFromString(lit, 0) if n != len(lit) { log.Crashf("malformed float literal %s at %v passed parser", lit, a.pos) } - expr := a.newExpr(IdealFloatType, "float literal"); - expr.eval = func() *bignum.Rational { return f }; - return expr; + expr := a.newExpr(IdealFloatType, "float literal") + expr.eval = func() *bignum.Rational { return f } + return expr } func (a *exprInfo) compileString(s string) *expr { @@ -787,47 +787,47 @@ func (a *exprInfo) compileString(s string) *expr { // compatible with type string. // TODO(austin) Use unnamed string type. - expr := a.newExpr(StringType, "string literal"); - expr.eval = func(*Thread) string { return s }; - return expr; + expr := a.newExpr(StringType, "string literal") + expr.eval = func(*Thread) string { return s } + return expr } func (a *exprInfo) compileStringLit(lit string) *expr { - s, err := strconv.Unquote(lit); + s, err := strconv.Unquote(lit) if err != nil { - a.diag("illegal string literal, %v", err); - return nil; + a.diag("illegal string literal, %v", err) + return nil } - return a.compileString(s); + return a.compileString(s) } func (a *exprInfo) compileStringList(list []*expr) *expr { - ss := make([]string, len(list)); + ss := make([]string, len(list)) for i, s := range list { ss[i] = s.asString()(nil) } - return a.compileString(strings.Join(ss, "")); + return a.compileString(strings.Join(ss, "")) } func (a *exprInfo) compileFuncLit(decl *FuncDecl, fn func(*Thread) Func) *expr { - expr := a.newExpr(decl.Type, "function literal"); - expr.eval = fn; - return expr; + expr := a.newExpr(decl.Type, "function literal") + expr.eval = fn + return expr } func (a *exprInfo) compileSelectorExpr(v *expr, name string) *expr { // mark marks a field that matches the selector name. It // tracks the best depth found so far and whether more than // one field has been found at that depth. - bestDepth := -1; - ambig := false; - amberr := ""; + bestDepth := -1 + ambig := false + amberr := "" mark := func(depth int, pathName string) { switch { case bestDepth == -1 || depth < bestDepth: - bestDepth = depth; - ambig = false; - amberr = ""; + bestDepth = depth + ambig = false + amberr = "" case depth == bestDepth: ambig = true @@ -835,10 +835,10 @@ func (a *exprInfo) compileSelectorExpr(v *expr, name string) *expr { default: log.Crashf("Marked field at depth %d, but already found one at depth %d", depth, bestDepth) } - amberr += "\n\t" + pathName[1:]; - }; + amberr += "\n\t" + pathName[1:] + } - visited := make(map[Type]bool); + visited := make(map[Type]bool) // find recursively searches for the named field, starting at // type t. If it finds the named field, it returns a function @@ -850,7 +850,7 @@ func (a *exprInfo) compileSelectorExpr(v *expr, name string) *expr { // TODO(austin) Now that the expression compiler works on // semantic values instead of AST's, there should be a much // better way of doing this. - var find func(Type, int, string) (func(*expr) *expr); + var find func(Type, int, string) (func(*expr) *expr) find = func(t Type, depth int, pathName string) (func(*expr) *expr) { // Don't bother looking if we've found something shallower if bestDepth != -1 && bestDepth < depth { @@ -861,37 +861,37 @@ func (a *exprInfo) compileSelectorExpr(v *expr, name string) *expr { if _, ok := visited[t]; ok { return nil } - visited[t] = true; + visited[t] = true // Implicit dereference - deref := false; + deref := false if ti, ok := t.(*PtrType); ok { - deref = true; - t = ti.Elem; + deref = true + t = ti.Elem } // If it's a named type, look for methods if ti, ok := t.(*NamedType); ok { - _, ok := ti.methods[name]; + _, ok := ti.methods[name] if ok { - mark(depth, pathName+"."+name); - log.Crash("Methods not implemented"); + mark(depth, pathName+"."+name) + log.Crash("Methods not implemented") } - t = ti.Def; + t = ti.Def } // If it's a struct type, check fields and embedded types - var builder func(*expr) *expr; + var builder func(*expr) *expr if t, ok := t.(*StructType); ok { for i, f := range t.Elems { - var sub func(*expr) *expr; + var sub func(*expr) *expr switch { case f.Name == name: - mark(depth, pathName+"."+name); - sub = func(e *expr) *expr { return e }; + mark(depth, pathName+"."+name) + sub = func(e *expr) *expr { return e } case f.Anonymous: - sub = find(f.Type, depth+1, pathName+"."+f.Name); + sub = find(f.Type, depth+1, pathName+"."+f.Name) if sub == nil { continue } @@ -902,48 +902,48 @@ func (a *exprInfo) compileSelectorExpr(v *expr, name string) *expr { // We found something. Create a // builder for accessing this field. - ft := f.Type; - index := i; + ft := f.Type + index := i builder = func(parent *expr) *expr { if deref { parent = a.compileStarExpr(parent) } - expr := a.newExpr(ft, "selector expression"); - pf := parent.asStruct(); - evalAddr := func(t *Thread) Value { return pf(t).Field(t, index) }; - expr.genValue(evalAddr); - return sub(expr); - }; + expr := a.newExpr(ft, "selector expression") + pf := parent.asStruct() + evalAddr := func(t *Thread) Value { return pf(t).Field(t, index) } + expr.genValue(evalAddr) + return sub(expr) + } } } - return builder; - }; + return builder + } - builder := find(v.t, 0, ""); + builder := find(v.t, 0, "") if builder == nil { - a.diag("type %v has no field or method %s", v.t, name); - return nil; + a.diag("type %v has no field or method %s", v.t, name) + return nil } if ambig { - a.diag("field %s is ambiguous in type %v%s", name, v.t, amberr); - return nil; + a.diag("field %s is ambiguous in type %v%s", name, v.t, amberr) + return nil } - return builder(v); + return builder(v) } func (a *exprInfo) compileSliceExpr(arr, lo, hi *expr) *expr { // Type check object - arr = arr.derefArray(); + arr = arr.derefArray() - var at Type; - var maxIndex int64 = -1; + var at Type + var maxIndex int64 = -1 switch lt := arr.t.lit().(type) { case *ArrayType: - at = NewSliceType(lt.Elem); - maxIndex = lt.Len; + at = NewSliceType(lt.Elem) + maxIndex = lt.Len case *SliceType: at = lt @@ -952,105 +952,105 @@ func (a *exprInfo) compileSliceExpr(arr, lo, hi *expr) *expr { at = lt default: - a.diag("cannot slice %v", arr.t); - return nil; + a.diag("cannot slice %v", arr.t) + return nil } // Type check index and convert to int // XXX(Spec) It's unclear if ideal floats with no // fractional part are allowed here. 6g allows it. I // believe that's wrong. - lo = lo.convertToInt(maxIndex, "slice", "slice"); - hi = hi.convertToInt(maxIndex, "slice", "slice"); + lo = lo.convertToInt(maxIndex, "slice", "slice") + hi = hi.convertToInt(maxIndex, "slice", "slice") if lo == nil || hi == nil { return nil } - expr := a.newExpr(at, "slice expression"); + expr := a.newExpr(at, "slice expression") // Compile - lof := lo.asInt(); - hif := hi.asInt(); + lof := lo.asInt() + hif := hi.asInt() switch lt := arr.t.lit().(type) { case *ArrayType: - arrf := arr.asArray(); - bound := lt.Len; + arrf := arr.asArray() + bound := lt.Len expr.eval = func(t *Thread) Slice { - arr, lo, hi := arrf(t), lof(t), hif(t); + arr, lo, hi := arrf(t), lof(t), hif(t) if lo > hi || hi > bound || lo < 0 { t.Abort(SliceError{lo, hi, bound}) } - return Slice{arr.Sub(lo, bound-lo), hi - lo, bound - lo}; - }; + return Slice{arr.Sub(lo, bound-lo), hi - lo, bound - lo} + } case *SliceType: - arrf := arr.asSlice(); + arrf := arr.asSlice() expr.eval = func(t *Thread) Slice { - arr, lo, hi := arrf(t), lof(t), hif(t); + arr, lo, hi := arrf(t), lof(t), hif(t) if lo > hi || hi > arr.Cap || lo < 0 { t.Abort(SliceError{lo, hi, arr.Cap}) } - return Slice{arr.Base.Sub(lo, arr.Cap-lo), hi - lo, arr.Cap - lo}; - }; + return Slice{arr.Base.Sub(lo, arr.Cap-lo), hi - lo, arr.Cap - lo} + } case *stringType: - arrf := arr.asString(); + arrf := arr.asString() // TODO(austin) This pulls over the whole string in a // remote setting, instead of creating a substring backed // by remote memory. expr.eval = func(t *Thread) string { - arr, lo, hi := arrf(t), lof(t), hif(t); + arr, lo, hi := arrf(t), lof(t), hif(t) if lo > hi || hi > int64(len(arr)) || lo < 0 { t.Abort(SliceError{lo, hi, int64(len(arr))}) } - return arr[lo:hi]; - }; + return arr[lo:hi] + } default: log.Crashf("unexpected left operand type %T", arr.t.lit()) } - return expr; + return expr } func (a *exprInfo) compileIndexExpr(l, r *expr) *expr { // Type check object - l = l.derefArray(); + l = l.derefArray() - var at Type; - intIndex := false; - var maxIndex int64 = -1; + var at Type + intIndex := false + var maxIndex int64 = -1 switch lt := l.t.lit().(type) { case *ArrayType: - at = lt.Elem; - intIndex = true; - maxIndex = lt.Len; + at = lt.Elem + intIndex = true + maxIndex = lt.Len case *SliceType: - at = lt.Elem; - intIndex = true; + at = lt.Elem + intIndex = true case *stringType: - at = Uint8Type; - intIndex = true; + at = Uint8Type + intIndex = true case *MapType: - at = lt.Elem; + at = lt.Elem if r.t.isIdeal() { - r = r.convertTo(lt.Key); + r = r.convertTo(lt.Key) if r == nil { return nil } } if !lt.Key.compat(r.t, false) { - a.diag("cannot use %s as index into %s", r.t, lt); - return nil; + a.diag("cannot use %s as index into %s", r.t, lt) + return nil } default: - a.diag("cannot index into %v", l.t); - return nil; + a.diag("cannot index into %v", l.t) + return nil } // Type check index and convert to int if necessary @@ -1058,83 +1058,83 @@ func (a *exprInfo) compileIndexExpr(l, r *expr) *expr { // XXX(Spec) It's unclear if ideal floats with no // fractional part are allowed here. 6g allows it. I // believe that's wrong. - r = r.convertToInt(maxIndex, "index", "index"); + r = r.convertToInt(maxIndex, "index", "index") if r == nil { return nil } } - expr := a.newExpr(at, "index expression"); + expr := a.newExpr(at, "index expression") // Compile switch lt := l.t.lit().(type) { case *ArrayType: - lf := l.asArray(); - rf := r.asInt(); - bound := lt.Len; + lf := l.asArray() + rf := r.asInt() + bound := lt.Len expr.genValue(func(t *Thread) Value { - l, r := lf(t), rf(t); + l, r := lf(t), rf(t) if r < 0 || r >= bound { t.Abort(IndexError{r, bound}) } - return l.Elem(t, r); - }); + return l.Elem(t, r) + }) case *SliceType: - lf := l.asSlice(); - rf := r.asInt(); + lf := l.asSlice() + rf := r.asInt() expr.genValue(func(t *Thread) Value { - l, r := lf(t), rf(t); + l, r := lf(t), rf(t) if l.Base == nil { t.Abort(NilPointerError{}) } if r < 0 || r >= l.Len { t.Abort(IndexError{r, l.Len}) } - return l.Base.Elem(t, r); - }); + return l.Base.Elem(t, r) + }) case *stringType: - lf := l.asString(); - rf := r.asInt(); + lf := l.asString() + rf := r.asInt() // TODO(austin) This pulls over the whole string in a // remote setting, instead of just the one character. expr.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); + l, r := lf(t), rf(t) if r < 0 || r >= int64(len(l)) { t.Abort(IndexError{r, int64(len(l))}) } - return uint64(l[r]); - }; + return uint64(l[r]) + } case *MapType: - lf := l.asMap(); - rf := r.asInterface(); + lf := l.asMap() + rf := r.asInterface() expr.genValue(func(t *Thread) Value { - m := lf(t); - k := rf(t); + m := lf(t) + k := rf(t) if m == nil { t.Abort(NilPointerError{}) } - e := m.Elem(t, k); + e := m.Elem(t, k) if e == nil { t.Abort(KeyError{k}) } - return e; - }); + return e + }) // genValue makes things addressable, but map values // aren't addressable. - expr.evalAddr = nil; + expr.evalAddr = nil expr.evalMapValue = func(t *Thread) (Map, interface{}) { // TODO(austin) Key check? nil check? return lf(t), rf(t) - }; + } default: log.Crashf("unexpected left operand type %T", l.t.lit()) } - return expr; + return expr } func (a *exprInfo) compileCallExpr(b *block, l *expr, as []*expr) *expr { @@ -1148,10 +1148,10 @@ func (a *exprInfo) compileCallExpr(b *block, l *expr, as []*expr) *expr { // type of that type is still whatever it's defined to. Thus, // in "type Foo int", Foo is still an integer type and in // "type Foo func()", Foo is a function type. - lt, ok := l.t.lit().(*FuncType); + lt, ok := l.t.lit().(*FuncType) if !ok { - a.diag("cannot call non-function type %v", l.t); - return nil; + a.diag("cannot call non-function type %v", l.t) + return nil } // The arguments must be single-valued expressions assignment @@ -1159,14 +1159,14 @@ func (a *exprInfo) compileCallExpr(b *block, l *expr, as []*expr) *expr { // // XXX(Spec) The spec is wrong. It can also be a single // multi-valued expression. - nin := len(lt.In); - assign := a.compileAssign(a.pos, b, NewMultiType(lt.In), as, "function call", "argument"); + nin := len(lt.In) + assign := a.compileAssign(a.pos, b, NewMultiType(lt.In), as, "function call", "argument") if assign == nil { return nil } - var t Type; - nout := len(lt.Out); + var t Type + nout := len(lt.Out) switch nout { case 0: t = EmptyType @@ -1175,10 +1175,10 @@ func (a *exprInfo) compileCallExpr(b *block, l *expr, as []*expr) *expr { default: t = NewMultiType(lt.Out) } - expr := a.newExpr(t, "function call"); + expr := a.newExpr(t, "function call") // Gather argument and out types to initialize frame variables - vts := make([]Type, nin+nout); + vts := make([]Type, nin+nout) for i, t := range lt.In { vts[i] = t } @@ -1187,103 +1187,103 @@ func (a *exprInfo) compileCallExpr(b *block, l *expr, as []*expr) *expr { } // Compile - lf := l.asFunc(); + lf := l.asFunc() call := func(t *Thread) []Value { - fun := lf(t); - fr := fun.NewFrame(); + fun := lf(t) + fr := fun.NewFrame() for i, t := range vts { fr.Vars[i] = t.Zero() } - assign(multiV(fr.Vars[0:nin]), t); - oldf := t.f; - t.f = fr; - fun.Call(t); - t.f = oldf; - return fr.Vars[nin : nin+nout]; - }; - expr.genFuncCall(call); + assign(multiV(fr.Vars[0:nin]), t) + oldf := t.f + t.f = fr + fun.Call(t) + t.f = oldf + return fr.Vars[nin : nin+nout] + } + expr.genFuncCall(call) - return expr; + return expr } func (a *exprInfo) compileBuiltinCallExpr(b *block, ft *FuncType, as []*expr) *expr { checkCount := func(min, max int) bool { if len(as) < min { - a.diag("not enough arguments to %s", ft.builtin); - return false; + a.diag("not enough arguments to %s", ft.builtin) + return false } else if len(as) > max { - a.diag("too many arguments to %s", ft.builtin); - return false; + a.diag("too many arguments to %s", ft.builtin) + return false } - return true; - }; + return true + } switch ft { case capType: if !checkCount(1, 1) { return nil } - arg := as[0].derefArray(); - expr := a.newExpr(IntType, "function call"); + arg := as[0].derefArray() + expr := a.newExpr(IntType, "function call") switch t := arg.t.lit().(type) { case *ArrayType: // TODO(austin) It would be nice if this could // be a constant int. - v := t.Len; - expr.eval = func(t *Thread) int64 { return v }; + v := t.Len + expr.eval = func(t *Thread) int64 { return v } case *SliceType: - vf := arg.asSlice(); - expr.eval = func(t *Thread) int64 { return vf(t).Cap }; + vf := arg.asSlice() + expr.eval = func(t *Thread) int64 { return vf(t).Cap } //case *ChanType: default: - a.diag("illegal argument type for cap function\n\t%v", arg.t); - return nil; + a.diag("illegal argument type for cap function\n\t%v", arg.t) + return nil } - return expr; + return expr case lenType: if !checkCount(1, 1) { return nil } - arg := as[0].derefArray(); - expr := a.newExpr(IntType, "function call"); + arg := as[0].derefArray() + expr := a.newExpr(IntType, "function call") switch t := arg.t.lit().(type) { case *stringType: - vf := arg.asString(); - expr.eval = func(t *Thread) int64 { return int64(len(vf(t))) }; + vf := arg.asString() + expr.eval = func(t *Thread) int64 { return int64(len(vf(t))) } case *ArrayType: // TODO(austin) It would be nice if this could // be a constant int. - v := t.Len; - expr.eval = func(t *Thread) int64 { return v }; + v := t.Len + expr.eval = func(t *Thread) int64 { return v } case *SliceType: - vf := arg.asSlice(); - expr.eval = func(t *Thread) int64 { return vf(t).Len }; + vf := arg.asSlice() + expr.eval = func(t *Thread) int64 { return vf(t).Len } case *MapType: - vf := arg.asMap(); + vf := arg.asMap() expr.eval = func(t *Thread) int64 { // XXX(Spec) What's the len of an // uninitialized map? - m := vf(t); + m := vf(t) if m == nil { return 0 } - return m.Len(t); - }; + return m.Len(t) + } //case *ChanType: default: - a.diag("illegal argument type for len function\n\t%v", arg.t); - return nil; + a.diag("illegal argument type for len function\n\t%v", arg.t) + return nil } - return expr; + return expr case makeType: if !checkCount(1, 3) { @@ -1292,21 +1292,21 @@ func (a *exprInfo) compileBuiltinCallExpr(b *block, ft *FuncType, as []*expr) *e // XXX(Spec) What are the types of the // arguments? Do they have to be ints? 6g // accepts any integral type. - var lenexpr, capexpr *expr; - var lenf, capf func(*Thread) int64; + var lenexpr, capexpr *expr + var lenf, capf func(*Thread) int64 if len(as) > 1 { - lenexpr = as[1].convertToInt(-1, "length", "make function"); + lenexpr = as[1].convertToInt(-1, "length", "make function") if lenexpr == nil { return nil } - lenf = lenexpr.asInt(); + lenf = lenexpr.asInt() } if len(as) > 2 { - capexpr = as[2].convertToInt(-1, "capacity", "make function"); + capexpr = as[2].convertToInt(-1, "capacity", "make function") if capexpr == nil { return nil } - capf = capexpr.asInt(); + capf = capexpr.asInt() } switch t := as[0].valType.lit().(type) { @@ -1319,18 +1319,18 @@ func (a *exprInfo) compileBuiltinCallExpr(b *block, ft *FuncType, as []*expr) *e if !checkCount(2, 3) { return nil } - et := t.Elem; - expr := a.newExpr(t, "function call"); + et := t.Elem + expr := a.newExpr(t, "function call") expr.eval = func(t *Thread) Slice { - l := lenf(t); + l := lenf(t) // XXX(Spec) What if len or cap is // negative? The runtime panics. if l < 0 { t.Abort(NegativeLengthError{l}) } - c := l; + c := l if capf != nil { - c = capf(t); + c = capf(t) if c < 0 { t.Abort(NegativeCapacityError{c}) } @@ -1341,13 +1341,13 @@ func (a *exprInfo) compileBuiltinCallExpr(b *block, ft *FuncType, as []*expr) *e c = l } } - base := arrayV(make([]Value, c)); + base := arrayV(make([]Value, c)) for i := int64(0); i < c; i++ { base[i] = et.Zero() } - return Slice{&base, l, c}; - }; - return expr; + return Slice{&base, l, c} + } + return expr case *MapType: // A new, empty map value is made using the @@ -1357,52 +1357,52 @@ func (a *exprInfo) compileBuiltinCallExpr(b *block, ft *FuncType, as []*expr) *e if !checkCount(1, 2) { return nil } - expr := a.newExpr(t, "function call"); + expr := a.newExpr(t, "function call") expr.eval = func(t *Thread) Map { if lenf == nil { return make(evalMap) } - l := lenf(t); - return make(evalMap, l); - }; - return expr; + l := lenf(t) + return make(evalMap, l) + } + return expr //case *ChanType: default: - a.diag("illegal argument type for make function\n\t%v", as[0].valType); - return nil; + a.diag("illegal argument type for make function\n\t%v", as[0].valType) + return nil } case closeType, closedType: - a.diag("built-in function %s not implemented", ft.builtin); - return nil; + a.diag("built-in function %s not implemented", ft.builtin) + return nil case newType: if !checkCount(1, 1) { return nil } - t := as[0].valType; - expr := a.newExpr(NewPtrType(t), "new"); - expr.eval = func(*Thread) Value { return t.Zero() }; - return expr; + t := as[0].valType + expr := a.newExpr(NewPtrType(t), "new") + expr.eval = func(*Thread) Value { return t.Zero() } + return expr case panicType, paniclnType, printType, printlnType: - evals := make([]func(*Thread) interface{}, len(as)); + evals := make([]func(*Thread) interface{}, len(as)) for i, x := range as { evals[i] = x.asInterface() } - spaces := ft == paniclnType || ft == printlnType; - newline := ft != printType; + spaces := ft == paniclnType || ft == printlnType + newline := ft != printType printer := func(t *Thread) { for i, eval := range evals { if i > 0 && spaces { print(" ") } - v := eval(t); + v := eval(t) type stringer interface { - String() string; + String() string } switch v1 := v.(type) { case bool: @@ -1424,67 +1424,67 @@ func (a *exprInfo) compileBuiltinCallExpr(b *block, ft *FuncType, as []*expr) *e if newline { print("\n") } - }; - expr := a.newExpr(EmptyType, "print"); - expr.exec = printer; + } + expr := a.newExpr(EmptyType, "print") + expr.exec = printer if ft == panicType || ft == paniclnType { expr.exec = func(t *Thread) { - printer(t); - t.Abort(os.NewError("panic")); + printer(t) + t.Abort(os.NewError("panic")) } } - return expr; + return expr } - log.Crashf("unexpected built-in function '%s'", ft.builtin); - panic(); + log.Crashf("unexpected built-in function '%s'", ft.builtin) + panic() } func (a *exprInfo) compileStarExpr(v *expr) *expr { switch vt := v.t.lit().(type) { case *PtrType: - expr := a.newExpr(vt.Elem, "indirect expression"); - vf := v.asPtr(); + expr := a.newExpr(vt.Elem, "indirect expression") + vf := v.asPtr() expr.genValue(func(t *Thread) Value { - v := vf(t); + v := vf(t) if v == nil { t.Abort(NilPointerError{}) } - return v; - }); - return expr; + return v + }) + return expr } - a.diagOpType(token.MUL, v.t); - return nil; + a.diagOpType(token.MUL, v.t) + return nil } var unaryOpDescs = make(map[token.Token]string) func (a *exprInfo) compileUnaryExpr(op token.Token, v *expr) *expr { // Type check - var t Type; + var t Type switch op { case token.ADD, token.SUB: if !v.t.isInteger() && !v.t.isFloat() { - a.diagOpType(op, v.t); - return nil; + a.diagOpType(op, v.t) + return nil } - t = v.t; + t = v.t case token.NOT: if !v.t.isBoolean() { - a.diagOpType(op, v.t); - return nil; + a.diagOpType(op, v.t) + return nil } - t = BoolType; + t = BoolType case token.XOR: if !v.t.isInteger() { - a.diagOpType(op, v.t); - return nil; + a.diagOpType(op, v.t) + return nil } - t = v.t; + t = v.t case token.AND: // The unary prefix address-of operator & generates @@ -1492,15 +1492,15 @@ func (a *exprInfo) compileUnaryExpr(op token.Token, v *expr) *expr { // variable, pointer indirection, field selector, or // array or slice indexing operation. if v.evalAddr == nil { - a.diag("cannot take the address of %s", v.desc); - return nil; + a.diag("cannot take the address of %s", v.desc) + return nil } // TODO(austin) Implement "It is illegal to take the // address of a function result variable" once I have // function result variables. - t = NewPtrType(v.t); + t = NewPtrType(v.t) case token.ARROW: log.Crashf("Unary op %v not implemented", op) @@ -1509,19 +1509,19 @@ func (a *exprInfo) compileUnaryExpr(op token.Token, v *expr) *expr { log.Crashf("unknown unary operator %v", op) } - desc, ok := unaryOpDescs[op]; + desc, ok := unaryOpDescs[op] if !ok { - desc = "unary " + op.String() + " expression"; - unaryOpDescs[op] = desc; + desc = "unary " + op.String() + " expression" + unaryOpDescs[op] = desc } // Compile - expr := a.newExpr(t, desc); + expr := a.newExpr(t, desc) switch op { case token.ADD: // Just compile it out - expr = v; - expr.desc = desc; + expr = v + expr.desc = desc case token.SUB: expr.genUnaryOpNeg(v) @@ -1533,22 +1533,22 @@ func (a *exprInfo) compileUnaryExpr(op token.Token, v *expr) *expr { expr.genUnaryOpXor(v) case token.AND: - vf := v.evalAddr; - expr.eval = func(t *Thread) Value { return vf(t) }; + vf := v.evalAddr + expr.eval = func(t *Thread) Value { return vf(t) } default: log.Crashf("Compilation of unary op %v not implemented", op) } - return expr; + return expr } var binOpDescs = make(map[token.Token]string) func (a *exprInfo) compileBinaryExpr(op token.Token, l, r *expr) *expr { // Save the original types of l.t and r.t for error messages. - origlt := l.t; - origrt := r.t; + origlt := l.t + origrt := r.t // XXX(Spec) What is the exact definition of a "named type"? @@ -1594,38 +1594,38 @@ func (a *exprInfo) compileBinaryExpr(op token.Token, l, r *expr) *expr { // Useful type predicates // TODO(austin) CL 33668 mandates identical types except for comparisons. - compat := func() bool { return l.t.compat(r.t, false) }; - integers := func() bool { return l.t.isInteger() && r.t.isInteger() }; - floats := func() bool { return l.t.isFloat() && r.t.isFloat() }; + compat := func() bool { return l.t.compat(r.t, false) } + integers := func() bool { return l.t.isInteger() && r.t.isInteger() } + floats := func() bool { return l.t.isFloat() && r.t.isFloat() } strings := func() bool { // TODO(austin) Deal with named types return l.t == StringType && r.t == StringType - }; - booleans := func() bool { return l.t.isBoolean() && r.t.isBoolean() }; + } + booleans := func() bool { return l.t.isBoolean() && r.t.isBoolean() } // Type check - var t Type; + var t Type switch op { case token.ADD: if !compat() || (!integers() && !floats() && !strings()) { - a.diagOpTypes(op, origlt, origrt); - return nil; + a.diagOpTypes(op, origlt, origrt) + return nil } - t = l.t; + t = l.t case token.SUB, token.MUL, token.QUO: if !compat() || (!integers() && !floats()) { - a.diagOpTypes(op, origlt, origrt); - return nil; + a.diagOpTypes(op, origlt, origrt) + return nil } - t = l.t; + t = l.t case token.REM, token.AND, token.OR, token.XOR, token.AND_NOT: if !compat() || !integers() { - a.diagOpTypes(op, origlt, origrt); - return nil; + a.diagOpTypes(op, origlt, origrt) + return nil } - t = l.t; + t = l.t case token.SHL, token.SHR: // XXX(Spec) Is it okay for the right operand to be an @@ -1636,8 +1636,8 @@ func (a *exprInfo) compileBinaryExpr(op token.Token, l, r *expr) *expr { // (§Arithmetic operators)" suggests so and 6g agrees. if !l.t.isInteger() || !(r.t.isInteger() || r.t.isIdeal()) { - a.diagOpTypes(op, origlt, origrt); - return nil; + a.diagOpTypes(op, origlt, origrt) + return nil } // The right operand in a shift operation must be @@ -1645,7 +1645,7 @@ func (a *exprInfo) compileBinaryExpr(op token.Token, l, r *expr) *expr { // number that can be safely converted into an // unsigned integer type. if r.t.isIdeal() { - r2 := r.convertTo(UintType); + r2 := r.convertTo(UintType) if r2 == nil { return nil } @@ -1659,14 +1659,14 @@ func (a *exprInfo) compileBinaryExpr(op token.Token, l, r *expr) *expr { // If both are ideal, but the right side isn't // an ideal int, convert it to simplify things. if l.t.isIdeal() && !r.t.isInteger() { - r = r.convertTo(IdealIntType); + r = r.convertTo(IdealIntType) if r == nil { log.Crashf("conversion to uintType succeeded, but conversion to idealIntType failed") } } } else if _, ok := r.t.lit().(*uintType); !ok { - a.diag("right operand of shift must be unsigned"); - return nil; + a.diag("right operand of shift must be unsigned") + return nil } if l.t.isIdeal() && !r.t.isIdeal() { @@ -1675,7 +1675,7 @@ func (a *exprInfo) compileBinaryExpr(op token.Token, l, r *expr) *expr { // converted to an int. 6g propagates the // type down from assignments as a hint. - l = l.convertTo(IntType); + l = l.convertTo(IntType) if l == nil { return nil } @@ -1686,7 +1686,7 @@ func (a *exprInfo) compileBinaryExpr(op token.Token, l, r *expr) *expr { // 2) int SHIFT uint // 3) ideal int SHIFT ideal int - t = l.t; + t = l.t case token.LOR, token.LAND: if !booleans() { @@ -1698,14 +1698,14 @@ func (a *exprInfo) compileBinaryExpr(op token.Token, l, r *expr) *expr { // the type of the left operand, and NOT an unnamed // boolean type. - t = BoolType; + t = BoolType case token.ARROW: // The operands in channel sends differ in type: one // is always a channel and the other is a variable or // value of the channel's element type. - log.Crash("Binary op <- not implemented"); - t = BoolType; + log.Crash("Binary op <- not implemented") + t = BoolType case token.LSS, token.GTR, token.LEQ, token.GEQ: // XXX(Spec) It's really unclear what types which @@ -1717,10 +1717,10 @@ func (a *exprInfo) compileBinaryExpr(op token.Token, l, r *expr) *expr { // are some restrictions on when it applies to slices. if !compat() || (!integers() && !floats() && !strings()) { - a.diagOpTypes(op, origlt, origrt); - return nil; + a.diagOpTypes(op, origlt, origrt) + return nil } - t = BoolType; + t = BoolType case token.EQL, token.NEQ: // XXX(Spec) The rules for type checking comparison @@ -1760,25 +1760,25 @@ func (a *exprInfo) compileBinaryExpr(op token.Token, l, r *expr) *expr { // TODO(austin) Deal with remaining special cases if !compat() { - a.diagOpTypes(op, origlt, origrt); - return nil; + a.diagOpTypes(op, origlt, origrt) + return nil } // Arrays and structs may not be compared to anything. switch l.t.(type) { case *ArrayType, *StructType: - a.diagOpTypes(op, origlt, origrt); - return nil; + a.diagOpTypes(op, origlt, origrt) + return nil } - t = BoolType; + t = BoolType default: log.Crashf("unknown binary operator %v", op) } - desc, ok := binOpDescs[op]; + desc, ok := binOpDescs[op] if !ok { - desc = op.String() + " expression"; - binOpDescs[op] = desc; + desc = op.String() + " expression" + binOpDescs[op] = desc } // Check for ideal divide by zero @@ -1787,14 +1787,14 @@ func (a *exprInfo) compileBinaryExpr(op token.Token, l, r *expr) *expr { if r.t.isIdeal() { if (r.t.isInteger() && r.asIdealInt()().IsZero()) || (r.t.isFloat() && r.asIdealFloat()().IsZero()) { - a.diag("divide by zero"); - return nil; + a.diag("divide by zero") + return nil } } } // Compile - expr := a.newExpr(t, desc); + expr := a.newExpr(t, desc) switch op { case token.ADD: expr.genBinOpAdd(l, r) @@ -1825,26 +1825,26 @@ func (a *exprInfo) compileBinaryExpr(op token.Token, l, r *expr) *expr { case token.SHL: if l.t.isIdeal() { - lv := l.asIdealInt()(); - rv := r.asIdealInt()(); - const maxShift = 99999; + lv := l.asIdealInt()() + rv := r.asIdealInt()() + const maxShift = 99999 if rv.Cmp(bignum.Int(maxShift)) > 0 { - a.diag("left shift by %v; exceeds implementation limit of %v", rv, maxShift); - expr.t = nil; - return nil; + a.diag("left shift by %v; exceeds implementation limit of %v", rv, maxShift) + expr.t = nil + return nil } - val := lv.Shl(uint(rv.Value())); - expr.eval = func() *bignum.Integer { return val }; + val := lv.Shl(uint(rv.Value())) + expr.eval = func() *bignum.Integer { return val } } else { expr.genBinOpShl(l, r) } case token.SHR: if l.t.isIdeal() { - lv := l.asIdealInt()(); - rv := r.asIdealInt()(); - val := lv.Shr(uint(rv.Value())); - expr.eval = func() *bignum.Integer { return val }; + lv := l.asIdealInt()() + rv := r.asIdealInt()() + val := lv.Shr(uint(rv.Value())) + expr.eval = func() *bignum.Integer { return val } } else { expr.genBinOpShr(l, r) } @@ -1877,28 +1877,28 @@ func (a *exprInfo) compileBinaryExpr(op token.Token, l, r *expr) *expr { log.Crashf("Compilation of binary op %v not implemented", op) } - return expr; + return expr } // TODO(austin) This is a hack to eliminate a circular dependency // between type.go and expr.go func (a *compiler) compileArrayLen(b *block, expr ast.Expr) (int64, bool) { - lenExpr := a.compileExpr(b, true, expr); + lenExpr := a.compileExpr(b, true, expr) if lenExpr == nil { return 0, false } // XXX(Spec) Are ideal floats with no fractional part okay? if lenExpr.t.isIdeal() { - lenExpr = lenExpr.convertTo(IntType); + lenExpr = lenExpr.convertTo(IntType) if lenExpr == nil { return 0, false } } if !lenExpr.t.isInteger() { - a.diagAt(expr, "array size must be an integer"); - return 0, false; + a.diagAt(expr, "array size must be an integer") + return 0, false } switch lenExpr.t.lit().(type) { @@ -1907,18 +1907,18 @@ func (a *compiler) compileArrayLen(b *block, expr ast.Expr) (int64, bool) { case *uintType: return int64(lenExpr.asUint()(nil)), true } - log.Crashf("unexpected integer type %T", lenExpr.t); - return 0, false; + log.Crashf("unexpected integer type %T", lenExpr.t) + return 0, false } func (a *compiler) compileExpr(b *block, constant bool, expr ast.Expr) *expr { - ec := &exprCompiler{a, b, constant}; - nerr := a.numError(); - e := ec.compile(expr, false); + ec := &exprCompiler{a, b, constant} + nerr := a.numError() + e := ec.compile(expr, false) if e == nil && nerr == a.numError() { log.Crashf("expression compilation failed without reporting errors") } - return e; + return e } // extractEffect separates out any effects that the expression may @@ -1931,21 +1931,21 @@ func (a *compiler) compileExpr(b *block, constant bool, expr ast.Expr) *expr { // results. func (a *expr) extractEffect(b *block, errOp string) (func(*Thread), *expr) { // Create "&a" if a is addressable - rhs := a; + rhs := a if a.evalAddr != nil { rhs = a.compileUnaryExpr(token.AND, rhs) } // Create temp - ac, ok := a.checkAssign(a.pos, []*expr{rhs}, errOp, ""); + ac, ok := a.checkAssign(a.pos, []*expr{rhs}, errOp, "") if !ok { return nil, nil } if len(ac.rmt.Elems) != 1 { - a.diag("multi-valued expression not allowed in %s", errOp); - return nil, nil; + a.diag("multi-valued expression not allowed in %s", errOp) + return nil, nil } - tempType := ac.rmt.Elems[0]; + tempType := ac.rmt.Elems[0] if tempType.isIdeal() { // It's too bad we have to duplicate this rule. switch { @@ -1957,30 +1957,30 @@ func (a *expr) extractEffect(b *block, errOp string) (func(*Thread), *expr) { log.Crashf("unexpected ideal type %v", tempType) } } - temp := b.DefineTemp(tempType); - tempIdx := temp.Index; + temp := b.DefineTemp(tempType) + tempIdx := temp.Index // Create "temp := rhs" - assign := ac.compile(b, tempType); + assign := ac.compile(b, tempType) if assign == nil { log.Crashf("compileAssign type check failed") } effect := func(t *Thread) { - tempVal := tempType.Zero(); - t.f.Vars[tempIdx] = tempVal; - assign(tempVal, t); - }; + tempVal := tempType.Zero() + t.f.Vars[tempIdx] = tempVal + assign(tempVal, t) + } // Generate "temp" or "*temp" - getTemp := a.compileVariable(0, temp); + getTemp := a.compileVariable(0, temp) if a.evalAddr == nil { return effect, getTemp } - deref := a.compileStarExpr(getTemp); + deref := a.compileStarExpr(getTemp) if deref == nil { return nil, nil } - return effect, deref; + return effect, deref } diff --git a/src/pkg/exp/eval/expr1.go b/src/pkg/exp/eval/expr1.go index ed2081c71..a77e40fb0 100644 --- a/src/pkg/exp/eval/expr1.go +++ b/src/pkg/exp/eval/expr1.go @@ -4,19 +4,19 @@ package eval import ( - "bignum"; - "log"; + "bignum" + "log" ) /* * "As" functions. These retrieve evaluator functions from an * expr, panicking if the requested evaluator has the wrong type. */ -func (a *expr) asBool() (func(*Thread) bool) { return a.eval.(func(*Thread) bool) } +func (a *expr) asBool() (func(*Thread) bool) { return a.eval.(func(*Thread) bool) } func (a *expr) asUint() (func(*Thread) uint64) { return a.eval.(func(*Thread) uint64) } -func (a *expr) asInt() (func(*Thread) int64) { return a.eval.(func(*Thread) int64) } +func (a *expr) asInt() (func(*Thread) int64) { return a.eval.(func(*Thread) int64) } func (a *expr) asIdealInt() (func() *bignum.Integer) { return a.eval.(func() *bignum.Integer) } @@ -35,12 +35,12 @@ func (a *expr) asArray() (func(*Thread) ArrayValue) { func (a *expr) asStruct() (func(*Thread) StructValue) { return a.eval.(func(*Thread) StructValue) } -func (a *expr) asPtr() (func(*Thread) Value) { return a.eval.(func(*Thread) Value) } -func (a *expr) asFunc() (func(*Thread) Func) { return a.eval.(func(*Thread) Func) } +func (a *expr) asPtr() (func(*Thread) Value) { return a.eval.(func(*Thread) Value) } +func (a *expr) asFunc() (func(*Thread) Func) { return a.eval.(func(*Thread) Func) } func (a *expr) asSlice() (func(*Thread) Slice) { return a.eval.(func(*Thread) Slice) } -func (a *expr) asMap() (func(*Thread) Map) { return a.eval.(func(*Thread) Map) } +func (a *expr) asMap() (func(*Thread) Map) { return a.eval.(func(*Thread) Map) } func (a *expr) asMulti() (func(*Thread) []Value) { return a.eval.(func(*Thread) []Value) } @@ -76,7 +76,7 @@ func (a *expr) asInterface() (func(*Thread) interface{}) { default: log.Crashf("unexpected expression node type %T at %v", a.eval, a.pos) } - panic(); + panic() } /* @@ -92,13 +92,13 @@ func (a *expr) genConstant(v Value) { case *intType: a.eval = func(t *Thread) int64 { return v.(IntValue).Get(t) } case *idealIntType: - val := v.(IdealIntValue).Get(); - a.eval = func() *bignum.Integer { return val }; + val := v.(IdealIntValue).Get() + a.eval = func() *bignum.Integer { return val } case *floatType: a.eval = func(t *Thread) float64 { return v.(FloatValue).Get(t) } case *idealFloatType: - val := v.(IdealFloatValue).Get(); - a.eval = func() *bignum.Rational { return val }; + val := v.(IdealFloatValue).Get() + a.eval = func() *bignum.Rational { return val } case *stringType: a.eval = func(t *Thread) string { return v.(StringValue).Get(t) } case *ArrayType: @@ -119,7 +119,7 @@ func (a *expr) genConstant(v Value) { } func (a *expr) genIdentOp(level, index int) { - a.evalAddr = func(t *Thread) Value { return t.f.Get(level, index) }; + a.evalAddr = func(t *Thread) Value { return t.f.Get(level, index) } switch a.t.lit().(type) { case *boolType: a.eval = func(t *Thread) bool { return t.f.Get(level, index).(BoolValue).Get(t) } @@ -149,7 +149,7 @@ func (a *expr) genIdentOp(level, index int) { } func (a *expr) genFuncCall(call func(t *Thread) []Value) { - a.exec = func(t *Thread) { call(t) }; + a.exec = func(t *Thread) { call(t) } switch a.t.lit().(type) { case *boolType: a.eval = func(t *Thread) bool { return call(t)[0].(BoolValue).Get(t) } @@ -181,7 +181,7 @@ func (a *expr) genFuncCall(call func(t *Thread) []Value) { } func (a *expr) genValue(vf func(*Thread) Value) { - a.evalAddr = vf; + a.evalAddr = vf switch a.t.lit().(type) { case *boolType: a.eval = func(t *Thread) bool { return vf(t).(BoolValue).Get(t) } @@ -213,31 +213,31 @@ func (a *expr) genValue(vf func(*Thread) Value) { func (a *expr) genUnaryOpNeg(v *expr) { switch a.t.lit().(type) { case *uintType: - vf := v.asUint(); + vf := v.asUint() a.eval = func(t *Thread) uint64 { - v := vf(t); - return -v; - }; + v := vf(t) + return -v + } case *intType: - vf := v.asInt(); + vf := v.asInt() a.eval = func(t *Thread) int64 { - v := vf(t); - return -v; - }; + v := vf(t) + return -v + } case *idealIntType: - v := v.asIdealInt()(); - val := v.Neg(); - a.eval = func() *bignum.Integer { return val }; + v := v.asIdealInt()() + val := v.Neg() + a.eval = func() *bignum.Integer { return val } case *floatType: - vf := v.asFloat(); + vf := v.asFloat() a.eval = func(t *Thread) float64 { - v := vf(t); - return -v; - }; + v := vf(t) + return -v + } case *idealFloatType: - v := v.asIdealFloat()(); - val := v.Neg(); - a.eval = func() *bignum.Rational { return val }; + v := v.asIdealFloat()() + val := v.Neg() + a.eval = func() *bignum.Rational { return val } default: log.Crashf("unexpected type %v at %v", a.t, a.pos) } @@ -246,11 +246,11 @@ func (a *expr) genUnaryOpNeg(v *expr) { func (a *expr) genUnaryOpNot(v *expr) { switch a.t.lit().(type) { case *boolType: - vf := v.asBool(); + vf := v.asBool() a.eval = func(t *Thread) bool { - v := vf(t); - return !v; - }; + v := vf(t) + return !v + } default: log.Crashf("unexpected type %v at %v", a.t, a.pos) } @@ -259,169 +259,169 @@ func (a *expr) genUnaryOpNot(v *expr) { func (a *expr) genUnaryOpXor(v *expr) { switch a.t.lit().(type) { case *uintType: - vf := v.asUint(); + vf := v.asUint() a.eval = func(t *Thread) uint64 { - v := vf(t); - return ^v; - }; + v := vf(t) + return ^v + } case *intType: - vf := v.asInt(); + vf := v.asInt() a.eval = func(t *Thread) int64 { - v := vf(t); - return ^v; - }; + v := vf(t) + return ^v + } case *idealIntType: - v := v.asIdealInt()(); - val := v.Neg().Sub(bignum.Int(1)); - a.eval = func() *bignum.Integer { return val }; + v := v.asIdealInt()() + val := v.Neg().Sub(bignum.Int(1)) + a.eval = func() *bignum.Integer { return val } default: log.Crashf("unexpected type %v at %v", a.t, a.pos) } } func (a *expr) genBinOpLogAnd(l, r *expr) { - lf := l.asBool(); - rf := r.asBool(); - a.eval = func(t *Thread) bool { return lf(t) && rf(t) }; + lf := l.asBool() + rf := r.asBool() + a.eval = func(t *Thread) bool { return lf(t) && rf(t) } } func (a *expr) genBinOpLogOr(l, r *expr) { - lf := l.asBool(); - rf := r.asBool(); - a.eval = func(t *Thread) bool { return lf(t) || rf(t) }; + lf := l.asBool() + rf := r.asBool() + a.eval = func(t *Thread) bool { return lf(t) || rf(t) } } func (a *expr) genBinOpAdd(l, r *expr) { switch t := l.t.lit().(type) { case *uintType: - lf := l.asUint(); - rf := r.asUint(); + lf := l.asUint() + rf := r.asUint() switch t.Bits { case 8: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l + r; - return uint64(uint8(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l + r + return uint64(uint8(ret)) } case 16: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l + r; - return uint64(uint16(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l + r + return uint64(uint16(ret)) } case 32: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l + r; - return uint64(uint32(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l + r + return uint64(uint32(ret)) } case 64: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l + r; - return uint64(uint64(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l + r + return uint64(uint64(ret)) } case 0: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l + r; - return uint64(uint(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l + r + return uint64(uint(ret)) } default: log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *intType: - lf := l.asInt(); - rf := r.asInt(); + lf := l.asInt() + rf := r.asInt() switch t.Bits { case 8: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l + r; - return int64(int8(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l + r + return int64(int8(ret)) } case 16: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l + r; - return int64(int16(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l + r + return int64(int16(ret)) } case 32: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l + r; - return int64(int32(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l + r + return int64(int32(ret)) } case 64: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l + r; - return int64(int64(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l + r + return int64(int64(ret)) } case 0: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l + r; - return int64(int(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l + r + return int64(int(ret)) } default: log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *idealIntType: - l := l.asIdealInt()(); - r := r.asIdealInt()(); - val := l.Add(r); - a.eval = func() *bignum.Integer { return val }; + l := l.asIdealInt()() + r := r.asIdealInt()() + val := l.Add(r) + a.eval = func() *bignum.Integer { return val } case *floatType: - lf := l.asFloat(); - rf := r.asFloat(); + lf := l.asFloat() + rf := r.asFloat() switch t.Bits { case 32: a.eval = func(t *Thread) float64 { - l, r := lf(t), rf(t); - var ret float64; - ret = l + r; - return float64(float32(ret)); + l, r := lf(t), rf(t) + var ret float64 + ret = l + r + return float64(float32(ret)) } case 64: a.eval = func(t *Thread) float64 { - l, r := lf(t), rf(t); - var ret float64; - ret = l + r; - return float64(float64(ret)); + l, r := lf(t), rf(t) + var ret float64 + ret = l + r + return float64(float64(ret)) } case 0: a.eval = func(t *Thread) float64 { - l, r := lf(t), rf(t); - var ret float64; - ret = l + r; - return float64(float(ret)); + l, r := lf(t), rf(t) + var ret float64 + ret = l + r + return float64(float(ret)) } default: log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *idealFloatType: - l := l.asIdealFloat()(); - r := r.asIdealFloat()(); - val := l.Add(r); - a.eval = func() *bignum.Rational { return val }; + l := l.asIdealFloat()() + r := r.asIdealFloat()() + val := l.Add(r) + a.eval = func() *bignum.Rational { return val } case *stringType: - lf := l.asString(); - rf := r.asString(); + lf := l.asString() + rf := r.asString() a.eval = func(t *Thread) string { - l, r := lf(t), rf(t); - return l + r; - }; + l, r := lf(t), rf(t) + return l + r + } default: log.Crashf("unexpected type %v at %v", l.t, a.pos) } @@ -430,127 +430,127 @@ func (a *expr) genBinOpAdd(l, r *expr) { func (a *expr) genBinOpSub(l, r *expr) { switch t := l.t.lit().(type) { case *uintType: - lf := l.asUint(); - rf := r.asUint(); + lf := l.asUint() + rf := r.asUint() switch t.Bits { case 8: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l - r; - return uint64(uint8(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l - r + return uint64(uint8(ret)) } case 16: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l - r; - return uint64(uint16(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l - r + return uint64(uint16(ret)) } case 32: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l - r; - return uint64(uint32(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l - r + return uint64(uint32(ret)) } case 64: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l - r; - return uint64(uint64(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l - r + return uint64(uint64(ret)) } case 0: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l - r; - return uint64(uint(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l - r + return uint64(uint(ret)) } default: log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *intType: - lf := l.asInt(); - rf := r.asInt(); + lf := l.asInt() + rf := r.asInt() switch t.Bits { case 8: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l - r; - return int64(int8(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l - r + return int64(int8(ret)) } case 16: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l - r; - return int64(int16(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l - r + return int64(int16(ret)) } case 32: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l - r; - return int64(int32(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l - r + return int64(int32(ret)) } case 64: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l - r; - return int64(int64(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l - r + return int64(int64(ret)) } case 0: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l - r; - return int64(int(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l - r + return int64(int(ret)) } default: log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *idealIntType: - l := l.asIdealInt()(); - r := r.asIdealInt()(); - val := l.Sub(r); - a.eval = func() *bignum.Integer { return val }; + l := l.asIdealInt()() + r := r.asIdealInt()() + val := l.Sub(r) + a.eval = func() *bignum.Integer { return val } case *floatType: - lf := l.asFloat(); - rf := r.asFloat(); + lf := l.asFloat() + rf := r.asFloat() switch t.Bits { case 32: a.eval = func(t *Thread) float64 { - l, r := lf(t), rf(t); - var ret float64; - ret = l - r; - return float64(float32(ret)); + l, r := lf(t), rf(t) + var ret float64 + ret = l - r + return float64(float32(ret)) } case 64: a.eval = func(t *Thread) float64 { - l, r := lf(t), rf(t); - var ret float64; - ret = l - r; - return float64(float64(ret)); + l, r := lf(t), rf(t) + var ret float64 + ret = l - r + return float64(float64(ret)) } case 0: a.eval = func(t *Thread) float64 { - l, r := lf(t), rf(t); - var ret float64; - ret = l - r; - return float64(float(ret)); + l, r := lf(t), rf(t) + var ret float64 + ret = l - r + return float64(float(ret)) } default: log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *idealFloatType: - l := l.asIdealFloat()(); - r := r.asIdealFloat()(); - val := l.Sub(r); - a.eval = func() *bignum.Rational { return val }; + l := l.asIdealFloat()() + r := r.asIdealFloat()() + val := l.Sub(r) + a.eval = func() *bignum.Rational { return val } default: log.Crashf("unexpected type %v at %v", l.t, a.pos) } @@ -559,127 +559,127 @@ func (a *expr) genBinOpSub(l, r *expr) { func (a *expr) genBinOpMul(l, r *expr) { switch t := l.t.lit().(type) { case *uintType: - lf := l.asUint(); - rf := r.asUint(); + lf := l.asUint() + rf := r.asUint() switch t.Bits { case 8: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l * r; - return uint64(uint8(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l * r + return uint64(uint8(ret)) } case 16: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l * r; - return uint64(uint16(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l * r + return uint64(uint16(ret)) } case 32: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l * r; - return uint64(uint32(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l * r + return uint64(uint32(ret)) } case 64: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l * r; - return uint64(uint64(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l * r + return uint64(uint64(ret)) } case 0: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l * r; - return uint64(uint(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l * r + return uint64(uint(ret)) } default: log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *intType: - lf := l.asInt(); - rf := r.asInt(); + lf := l.asInt() + rf := r.asInt() switch t.Bits { case 8: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l * r; - return int64(int8(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l * r + return int64(int8(ret)) } case 16: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l * r; - return int64(int16(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l * r + return int64(int16(ret)) } case 32: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l * r; - return int64(int32(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l * r + return int64(int32(ret)) } case 64: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l * r; - return int64(int64(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l * r + return int64(int64(ret)) } case 0: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l * r; - return int64(int(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l * r + return int64(int(ret)) } default: log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *idealIntType: - l := l.asIdealInt()(); - r := r.asIdealInt()(); - val := l.Mul(r); - a.eval = func() *bignum.Integer { return val }; + l := l.asIdealInt()() + r := r.asIdealInt()() + val := l.Mul(r) + a.eval = func() *bignum.Integer { return val } case *floatType: - lf := l.asFloat(); - rf := r.asFloat(); + lf := l.asFloat() + rf := r.asFloat() switch t.Bits { case 32: a.eval = func(t *Thread) float64 { - l, r := lf(t), rf(t); - var ret float64; - ret = l * r; - return float64(float32(ret)); + l, r := lf(t), rf(t) + var ret float64 + ret = l * r + return float64(float32(ret)) } case 64: a.eval = func(t *Thread) float64 { - l, r := lf(t), rf(t); - var ret float64; - ret = l * r; - return float64(float64(ret)); + l, r := lf(t), rf(t) + var ret float64 + ret = l * r + return float64(float64(ret)) } case 0: a.eval = func(t *Thread) float64 { - l, r := lf(t), rf(t); - var ret float64; - ret = l * r; - return float64(float(ret)); + l, r := lf(t), rf(t) + var ret float64 + ret = l * r + return float64(float(ret)) } default: log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *idealFloatType: - l := l.asIdealFloat()(); - r := r.asIdealFloat()(); - val := l.Mul(r); - a.eval = func() *bignum.Rational { return val }; + l := l.asIdealFloat()() + r := r.asIdealFloat()() + val := l.Mul(r) + a.eval = func() *bignum.Rational { return val } default: log.Crashf("unexpected type %v at %v", l.t, a.pos) } @@ -688,166 +688,166 @@ func (a *expr) genBinOpMul(l, r *expr) { func (a *expr) genBinOpQuo(l, r *expr) { switch t := l.t.lit().(type) { case *uintType: - lf := l.asUint(); - rf := r.asUint(); + lf := l.asUint() + rf := r.asUint() switch t.Bits { case 8: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; + l, r := lf(t), rf(t) + var ret uint64 if r == 0 { t.Abort(DivByZeroError{}) } - ret = l / r; - return uint64(uint8(ret)); + ret = l / r + return uint64(uint8(ret)) } case 16: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; + l, r := lf(t), rf(t) + var ret uint64 if r == 0 { t.Abort(DivByZeroError{}) } - ret = l / r; - return uint64(uint16(ret)); + ret = l / r + return uint64(uint16(ret)) } case 32: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; + l, r := lf(t), rf(t) + var ret uint64 if r == 0 { t.Abort(DivByZeroError{}) } - ret = l / r; - return uint64(uint32(ret)); + ret = l / r + return uint64(uint32(ret)) } case 64: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; + l, r := lf(t), rf(t) + var ret uint64 if r == 0 { t.Abort(DivByZeroError{}) } - ret = l / r; - return uint64(uint64(ret)); + ret = l / r + return uint64(uint64(ret)) } case 0: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; + l, r := lf(t), rf(t) + var ret uint64 if r == 0 { t.Abort(DivByZeroError{}) } - ret = l / r; - return uint64(uint(ret)); + ret = l / r + return uint64(uint(ret)) } default: log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *intType: - lf := l.asInt(); - rf := r.asInt(); + lf := l.asInt() + rf := r.asInt() switch t.Bits { case 8: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; + l, r := lf(t), rf(t) + var ret int64 if r == 0 { t.Abort(DivByZeroError{}) } - ret = l / r; - return int64(int8(ret)); + ret = l / r + return int64(int8(ret)) } case 16: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; + l, r := lf(t), rf(t) + var ret int64 if r == 0 { t.Abort(DivByZeroError{}) } - ret = l / r; - return int64(int16(ret)); + ret = l / r + return int64(int16(ret)) } case 32: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; + l, r := lf(t), rf(t) + var ret int64 if r == 0 { t.Abort(DivByZeroError{}) } - ret = l / r; - return int64(int32(ret)); + ret = l / r + return int64(int32(ret)) } case 64: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; + l, r := lf(t), rf(t) + var ret int64 if r == 0 { t.Abort(DivByZeroError{}) } - ret = l / r; - return int64(int64(ret)); + ret = l / r + return int64(int64(ret)) } case 0: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; + l, r := lf(t), rf(t) + var ret int64 if r == 0 { t.Abort(DivByZeroError{}) } - ret = l / r; - return int64(int(ret)); + ret = l / r + return int64(int(ret)) } default: log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *idealIntType: - l := l.asIdealInt()(); - r := r.asIdealInt()(); - val := l.Quo(r); - a.eval = func() *bignum.Integer { return val }; + l := l.asIdealInt()() + r := r.asIdealInt()() + val := l.Quo(r) + a.eval = func() *bignum.Integer { return val } case *floatType: - lf := l.asFloat(); - rf := r.asFloat(); + lf := l.asFloat() + rf := r.asFloat() switch t.Bits { case 32: a.eval = func(t *Thread) float64 { - l, r := lf(t), rf(t); - var ret float64; + l, r := lf(t), rf(t) + var ret float64 if r == 0 { t.Abort(DivByZeroError{}) } - ret = l / r; - return float64(float32(ret)); + ret = l / r + return float64(float32(ret)) } case 64: a.eval = func(t *Thread) float64 { - l, r := lf(t), rf(t); - var ret float64; + l, r := lf(t), rf(t) + var ret float64 if r == 0 { t.Abort(DivByZeroError{}) } - ret = l / r; - return float64(float64(ret)); + ret = l / r + return float64(float64(ret)) } case 0: a.eval = func(t *Thread) float64 { - l, r := lf(t), rf(t); - var ret float64; + l, r := lf(t), rf(t) + var ret float64 if r == 0 { t.Abort(DivByZeroError{}) } - ret = l / r; - return float64(float(ret)); + ret = l / r + return float64(float(ret)) } default: log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *idealFloatType: - l := l.asIdealFloat()(); - r := r.asIdealFloat()(); - val := l.Quo(r); - a.eval = func() *bignum.Rational { return val }; + l := l.asIdealFloat()() + r := r.asIdealFloat()() + val := l.Quo(r) + a.eval = func() *bignum.Rational { return val } default: log.Crashf("unexpected type %v at %v", l.t, a.pos) } @@ -856,124 +856,124 @@ func (a *expr) genBinOpQuo(l, r *expr) { func (a *expr) genBinOpRem(l, r *expr) { switch t := l.t.lit().(type) { case *uintType: - lf := l.asUint(); - rf := r.asUint(); + lf := l.asUint() + rf := r.asUint() switch t.Bits { case 8: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; + l, r := lf(t), rf(t) + var ret uint64 if r == 0 { t.Abort(DivByZeroError{}) } - ret = l % r; - return uint64(uint8(ret)); + ret = l % r + return uint64(uint8(ret)) } case 16: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; + l, r := lf(t), rf(t) + var ret uint64 if r == 0 { t.Abort(DivByZeroError{}) } - ret = l % r; - return uint64(uint16(ret)); + ret = l % r + return uint64(uint16(ret)) } case 32: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; + l, r := lf(t), rf(t) + var ret uint64 if r == 0 { t.Abort(DivByZeroError{}) } - ret = l % r; - return uint64(uint32(ret)); + ret = l % r + return uint64(uint32(ret)) } case 64: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; + l, r := lf(t), rf(t) + var ret uint64 if r == 0 { t.Abort(DivByZeroError{}) } - ret = l % r; - return uint64(uint64(ret)); + ret = l % r + return uint64(uint64(ret)) } case 0: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; + l, r := lf(t), rf(t) + var ret uint64 if r == 0 { t.Abort(DivByZeroError{}) } - ret = l % r; - return uint64(uint(ret)); + ret = l % r + return uint64(uint(ret)) } default: log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *intType: - lf := l.asInt(); - rf := r.asInt(); + lf := l.asInt() + rf := r.asInt() switch t.Bits { case 8: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; + l, r := lf(t), rf(t) + var ret int64 if r == 0 { t.Abort(DivByZeroError{}) } - ret = l % r; - return int64(int8(ret)); + ret = l % r + return int64(int8(ret)) } case 16: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; + l, r := lf(t), rf(t) + var ret int64 if r == 0 { t.Abort(DivByZeroError{}) } - ret = l % r; - return int64(int16(ret)); + ret = l % r + return int64(int16(ret)) } case 32: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; + l, r := lf(t), rf(t) + var ret int64 if r == 0 { t.Abort(DivByZeroError{}) } - ret = l % r; - return int64(int32(ret)); + ret = l % r + return int64(int32(ret)) } case 64: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; + l, r := lf(t), rf(t) + var ret int64 if r == 0 { t.Abort(DivByZeroError{}) } - ret = l % r; - return int64(int64(ret)); + ret = l % r + return int64(int64(ret)) } case 0: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; + l, r := lf(t), rf(t) + var ret int64 if r == 0 { t.Abort(DivByZeroError{}) } - ret = l % r; - return int64(int(ret)); + ret = l % r + return int64(int(ret)) } default: log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *idealIntType: - l := l.asIdealInt()(); - r := r.asIdealInt()(); - val := l.Rem(r); - a.eval = func() *bignum.Integer { return val }; + l := l.asIdealInt()() + r := r.asIdealInt()() + val := l.Rem(r) + a.eval = func() *bignum.Integer { return val } default: log.Crashf("unexpected type %v at %v", l.t, a.pos) } @@ -982,94 +982,94 @@ func (a *expr) genBinOpRem(l, r *expr) { func (a *expr) genBinOpAnd(l, r *expr) { switch t := l.t.lit().(type) { case *uintType: - lf := l.asUint(); - rf := r.asUint(); + lf := l.asUint() + rf := r.asUint() switch t.Bits { case 8: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l & r; - return uint64(uint8(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l & r + return uint64(uint8(ret)) } case 16: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l & r; - return uint64(uint16(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l & r + return uint64(uint16(ret)) } case 32: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l & r; - return uint64(uint32(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l & r + return uint64(uint32(ret)) } case 64: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l & r; - return uint64(uint64(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l & r + return uint64(uint64(ret)) } case 0: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l & r; - return uint64(uint(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l & r + return uint64(uint(ret)) } default: log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *intType: - lf := l.asInt(); - rf := r.asInt(); + lf := l.asInt() + rf := r.asInt() switch t.Bits { case 8: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l & r; - return int64(int8(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l & r + return int64(int8(ret)) } case 16: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l & r; - return int64(int16(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l & r + return int64(int16(ret)) } case 32: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l & r; - return int64(int32(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l & r + return int64(int32(ret)) } case 64: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l & r; - return int64(int64(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l & r + return int64(int64(ret)) } case 0: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l & r; - return int64(int(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l & r + return int64(int(ret)) } default: log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *idealIntType: - l := l.asIdealInt()(); - r := r.asIdealInt()(); - val := l.And(r); - a.eval = func() *bignum.Integer { return val }; + l := l.asIdealInt()() + r := r.asIdealInt()() + val := l.And(r) + a.eval = func() *bignum.Integer { return val } default: log.Crashf("unexpected type %v at %v", l.t, a.pos) } @@ -1078,94 +1078,94 @@ func (a *expr) genBinOpAnd(l, r *expr) { func (a *expr) genBinOpOr(l, r *expr) { switch t := l.t.lit().(type) { case *uintType: - lf := l.asUint(); - rf := r.asUint(); + lf := l.asUint() + rf := r.asUint() switch t.Bits { case 8: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l | r; - return uint64(uint8(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l | r + return uint64(uint8(ret)) } case 16: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l | r; - return uint64(uint16(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l | r + return uint64(uint16(ret)) } case 32: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l | r; - return uint64(uint32(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l | r + return uint64(uint32(ret)) } case 64: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l | r; - return uint64(uint64(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l | r + return uint64(uint64(ret)) } case 0: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l | r; - return uint64(uint(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l | r + return uint64(uint(ret)) } default: log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *intType: - lf := l.asInt(); - rf := r.asInt(); + lf := l.asInt() + rf := r.asInt() switch t.Bits { case 8: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l | r; - return int64(int8(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l | r + return int64(int8(ret)) } case 16: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l | r; - return int64(int16(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l | r + return int64(int16(ret)) } case 32: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l | r; - return int64(int32(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l | r + return int64(int32(ret)) } case 64: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l | r; - return int64(int64(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l | r + return int64(int64(ret)) } case 0: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l | r; - return int64(int(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l | r + return int64(int(ret)) } default: log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *idealIntType: - l := l.asIdealInt()(); - r := r.asIdealInt()(); - val := l.Or(r); - a.eval = func() *bignum.Integer { return val }; + l := l.asIdealInt()() + r := r.asIdealInt()() + val := l.Or(r) + a.eval = func() *bignum.Integer { return val } default: log.Crashf("unexpected type %v at %v", l.t, a.pos) } @@ -1174,94 +1174,94 @@ func (a *expr) genBinOpOr(l, r *expr) { func (a *expr) genBinOpXor(l, r *expr) { switch t := l.t.lit().(type) { case *uintType: - lf := l.asUint(); - rf := r.asUint(); + lf := l.asUint() + rf := r.asUint() switch t.Bits { case 8: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l ^ r; - return uint64(uint8(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l ^ r + return uint64(uint8(ret)) } case 16: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l ^ r; - return uint64(uint16(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l ^ r + return uint64(uint16(ret)) } case 32: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l ^ r; - return uint64(uint32(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l ^ r + return uint64(uint32(ret)) } case 64: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l ^ r; - return uint64(uint64(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l ^ r + return uint64(uint64(ret)) } case 0: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l ^ r; - return uint64(uint(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l ^ r + return uint64(uint(ret)) } default: log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *intType: - lf := l.asInt(); - rf := r.asInt(); + lf := l.asInt() + rf := r.asInt() switch t.Bits { case 8: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l ^ r; - return int64(int8(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l ^ r + return int64(int8(ret)) } case 16: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l ^ r; - return int64(int16(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l ^ r + return int64(int16(ret)) } case 32: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l ^ r; - return int64(int32(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l ^ r + return int64(int32(ret)) } case 64: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l ^ r; - return int64(int64(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l ^ r + return int64(int64(ret)) } case 0: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l ^ r; - return int64(int(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l ^ r + return int64(int(ret)) } default: log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *idealIntType: - l := l.asIdealInt()(); - r := r.asIdealInt()(); - val := l.Xor(r); - a.eval = func() *bignum.Integer { return val }; + l := l.asIdealInt()() + r := r.asIdealInt()() + val := l.Xor(r) + a.eval = func() *bignum.Integer { return val } default: log.Crashf("unexpected type %v at %v", l.t, a.pos) } @@ -1270,94 +1270,94 @@ func (a *expr) genBinOpXor(l, r *expr) { func (a *expr) genBinOpAndNot(l, r *expr) { switch t := l.t.lit().(type) { case *uintType: - lf := l.asUint(); - rf := r.asUint(); + lf := l.asUint() + rf := r.asUint() switch t.Bits { case 8: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l &^ r; - return uint64(uint8(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l &^ r + return uint64(uint8(ret)) } case 16: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l &^ r; - return uint64(uint16(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l &^ r + return uint64(uint16(ret)) } case 32: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l &^ r; - return uint64(uint32(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l &^ r + return uint64(uint32(ret)) } case 64: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l &^ r; - return uint64(uint64(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l &^ r + return uint64(uint64(ret)) } case 0: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l &^ r; - return uint64(uint(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l &^ r + return uint64(uint(ret)) } default: log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *intType: - lf := l.asInt(); - rf := r.asInt(); + lf := l.asInt() + rf := r.asInt() switch t.Bits { case 8: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l &^ r; - return int64(int8(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l &^ r + return int64(int8(ret)) } case 16: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l &^ r; - return int64(int16(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l &^ r + return int64(int16(ret)) } case 32: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l &^ r; - return int64(int32(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l &^ r + return int64(int32(ret)) } case 64: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l &^ r; - return int64(int64(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l &^ r + return int64(int64(ret)) } case 0: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l &^ r; - return int64(int(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l &^ r + return int64(int(ret)) } default: log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *idealIntType: - l := l.asIdealInt()(); - r := r.asIdealInt()(); - val := l.AndNot(r); - a.eval = func() *bignum.Integer { return val }; + l := l.asIdealInt()() + r := r.asIdealInt()() + val := l.AndNot(r) + a.eval = func() *bignum.Integer { return val } default: log.Crashf("unexpected type %v at %v", l.t, a.pos) } @@ -1366,85 +1366,85 @@ func (a *expr) genBinOpAndNot(l, r *expr) { func (a *expr) genBinOpShl(l, r *expr) { switch t := l.t.lit().(type) { case *uintType: - lf := l.asUint(); - rf := r.asUint(); + lf := l.asUint() + rf := r.asUint() switch t.Bits { case 8: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l << r; - return uint64(uint8(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l << r + return uint64(uint8(ret)) } case 16: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l << r; - return uint64(uint16(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l << r + return uint64(uint16(ret)) } case 32: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l << r; - return uint64(uint32(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l << r + return uint64(uint32(ret)) } case 64: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l << r; - return uint64(uint64(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l << r + return uint64(uint64(ret)) } case 0: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l << r; - return uint64(uint(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l << r + return uint64(uint(ret)) } default: log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *intType: - lf := l.asInt(); - rf := r.asUint(); + lf := l.asInt() + rf := r.asUint() switch t.Bits { case 8: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l << r; - return int64(int8(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l << r + return int64(int8(ret)) } case 16: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l << r; - return int64(int16(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l << r + return int64(int16(ret)) } case 32: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l << r; - return int64(int32(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l << r + return int64(int32(ret)) } case 64: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l << r; - return int64(int64(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l << r + return int64(int64(ret)) } case 0: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l << r; - return int64(int(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l << r + return int64(int(ret)) } default: log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) @@ -1457,85 +1457,85 @@ func (a *expr) genBinOpShl(l, r *expr) { func (a *expr) genBinOpShr(l, r *expr) { switch t := l.t.lit().(type) { case *uintType: - lf := l.asUint(); - rf := r.asUint(); + lf := l.asUint() + rf := r.asUint() switch t.Bits { case 8: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l >> r; - return uint64(uint8(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l >> r + return uint64(uint8(ret)) } case 16: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l >> r; - return uint64(uint16(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l >> r + return uint64(uint16(ret)) } case 32: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l >> r; - return uint64(uint32(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l >> r + return uint64(uint32(ret)) } case 64: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l >> r; - return uint64(uint64(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l >> r + return uint64(uint64(ret)) } case 0: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l >> r; - return uint64(uint(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l >> r + return uint64(uint(ret)) } default: log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *intType: - lf := l.asInt(); - rf := r.asUint(); + lf := l.asInt() + rf := r.asUint() switch t.Bits { case 8: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l >> r; - return int64(int8(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l >> r + return int64(int8(ret)) } case 16: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l >> r; - return int64(int16(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l >> r + return int64(int16(ret)) } case 32: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l >> r; - return int64(int32(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l >> r + return int64(int32(ret)) } case 64: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l >> r; - return int64(int64(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l >> r + return int64(int64(ret)) } case 0: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l >> r; - return int64(int(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l >> r + return int64(int(ret)) } default: log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) @@ -1548,43 +1548,43 @@ func (a *expr) genBinOpShr(l, r *expr) { func (a *expr) genBinOpLss(l, r *expr) { switch t := l.t.lit().(type) { case *uintType: - lf := l.asUint(); - rf := r.asUint(); + lf := l.asUint() + rf := r.asUint() a.eval = func(t *Thread) bool { - l, r := lf(t), rf(t); - return l < r; - }; + l, r := lf(t), rf(t) + return l < r + } case *intType: - lf := l.asInt(); - rf := r.asInt(); + lf := l.asInt() + rf := r.asInt() a.eval = func(t *Thread) bool { - l, r := lf(t), rf(t); - return l < r; - }; + l, r := lf(t), rf(t) + return l < r + } case *idealIntType: - l := l.asIdealInt()(); - r := r.asIdealInt()(); - val := l.Cmp(r) < 0; - a.eval = func(t *Thread) bool { return val }; + l := l.asIdealInt()() + r := r.asIdealInt()() + val := l.Cmp(r) < 0 + a.eval = func(t *Thread) bool { return val } case *floatType: - lf := l.asFloat(); - rf := r.asFloat(); + lf := l.asFloat() + rf := r.asFloat() a.eval = func(t *Thread) bool { - l, r := lf(t), rf(t); - return l < r; - }; + l, r := lf(t), rf(t) + return l < r + } case *idealFloatType: - l := l.asIdealFloat()(); - r := r.asIdealFloat()(); - val := l.Cmp(r) < 0; - a.eval = func(t *Thread) bool { return val }; + l := l.asIdealFloat()() + r := r.asIdealFloat()() + val := l.Cmp(r) < 0 + a.eval = func(t *Thread) bool { return val } case *stringType: - lf := l.asString(); - rf := r.asString(); + lf := l.asString() + rf := r.asString() a.eval = func(t *Thread) bool { - l, r := lf(t), rf(t); - return l < r; - }; + l, r := lf(t), rf(t) + return l < r + } default: log.Crashf("unexpected type %v at %v", l.t, a.pos) } @@ -1593,43 +1593,43 @@ func (a *expr) genBinOpLss(l, r *expr) { func (a *expr) genBinOpGtr(l, r *expr) { switch t := l.t.lit().(type) { case *uintType: - lf := l.asUint(); - rf := r.asUint(); + lf := l.asUint() + rf := r.asUint() a.eval = func(t *Thread) bool { - l, r := lf(t), rf(t); - return l > r; - }; + l, r := lf(t), rf(t) + return l > r + } case *intType: - lf := l.asInt(); - rf := r.asInt(); + lf := l.asInt() + rf := r.asInt() a.eval = func(t *Thread) bool { - l, r := lf(t), rf(t); - return l > r; - }; + l, r := lf(t), rf(t) + return l > r + } case *idealIntType: - l := l.asIdealInt()(); - r := r.asIdealInt()(); - val := l.Cmp(r) > 0; - a.eval = func(t *Thread) bool { return val }; + l := l.asIdealInt()() + r := r.asIdealInt()() + val := l.Cmp(r) > 0 + a.eval = func(t *Thread) bool { return val } case *floatType: - lf := l.asFloat(); - rf := r.asFloat(); + lf := l.asFloat() + rf := r.asFloat() a.eval = func(t *Thread) bool { - l, r := lf(t), rf(t); - return l > r; - }; + l, r := lf(t), rf(t) + return l > r + } case *idealFloatType: - l := l.asIdealFloat()(); - r := r.asIdealFloat()(); - val := l.Cmp(r) > 0; - a.eval = func(t *Thread) bool { return val }; + l := l.asIdealFloat()() + r := r.asIdealFloat()() + val := l.Cmp(r) > 0 + a.eval = func(t *Thread) bool { return val } case *stringType: - lf := l.asString(); - rf := r.asString(); + lf := l.asString() + rf := r.asString() a.eval = func(t *Thread) bool { - l, r := lf(t), rf(t); - return l > r; - }; + l, r := lf(t), rf(t) + return l > r + } default: log.Crashf("unexpected type %v at %v", l.t, a.pos) } @@ -1638,43 +1638,43 @@ func (a *expr) genBinOpGtr(l, r *expr) { func (a *expr) genBinOpLeq(l, r *expr) { switch t := l.t.lit().(type) { case *uintType: - lf := l.asUint(); - rf := r.asUint(); + lf := l.asUint() + rf := r.asUint() a.eval = func(t *Thread) bool { - l, r := lf(t), rf(t); - return l <= r; - }; + l, r := lf(t), rf(t) + return l <= r + } case *intType: - lf := l.asInt(); - rf := r.asInt(); + lf := l.asInt() + rf := r.asInt() a.eval = func(t *Thread) bool { - l, r := lf(t), rf(t); - return l <= r; - }; + l, r := lf(t), rf(t) + return l <= r + } case *idealIntType: - l := l.asIdealInt()(); - r := r.asIdealInt()(); - val := l.Cmp(r) <= 0; - a.eval = func(t *Thread) bool { return val }; + l := l.asIdealInt()() + r := r.asIdealInt()() + val := l.Cmp(r) <= 0 + a.eval = func(t *Thread) bool { return val } case *floatType: - lf := l.asFloat(); - rf := r.asFloat(); + lf := l.asFloat() + rf := r.asFloat() a.eval = func(t *Thread) bool { - l, r := lf(t), rf(t); - return l <= r; - }; + l, r := lf(t), rf(t) + return l <= r + } case *idealFloatType: - l := l.asIdealFloat()(); - r := r.asIdealFloat()(); - val := l.Cmp(r) <= 0; - a.eval = func(t *Thread) bool { return val }; + l := l.asIdealFloat()() + r := r.asIdealFloat()() + val := l.Cmp(r) <= 0 + a.eval = func(t *Thread) bool { return val } case *stringType: - lf := l.asString(); - rf := r.asString(); + lf := l.asString() + rf := r.asString() a.eval = func(t *Thread) bool { - l, r := lf(t), rf(t); - return l <= r; - }; + l, r := lf(t), rf(t) + return l <= r + } default: log.Crashf("unexpected type %v at %v", l.t, a.pos) } @@ -1683,43 +1683,43 @@ func (a *expr) genBinOpLeq(l, r *expr) { func (a *expr) genBinOpGeq(l, r *expr) { switch t := l.t.lit().(type) { case *uintType: - lf := l.asUint(); - rf := r.asUint(); + lf := l.asUint() + rf := r.asUint() a.eval = func(t *Thread) bool { - l, r := lf(t), rf(t); - return l >= r; - }; + l, r := lf(t), rf(t) + return l >= r + } case *intType: - lf := l.asInt(); - rf := r.asInt(); + lf := l.asInt() + rf := r.asInt() a.eval = func(t *Thread) bool { - l, r := lf(t), rf(t); - return l >= r; - }; + l, r := lf(t), rf(t) + return l >= r + } case *idealIntType: - l := l.asIdealInt()(); - r := r.asIdealInt()(); - val := l.Cmp(r) >= 0; - a.eval = func(t *Thread) bool { return val }; + l := l.asIdealInt()() + r := r.asIdealInt()() + val := l.Cmp(r) >= 0 + a.eval = func(t *Thread) bool { return val } case *floatType: - lf := l.asFloat(); - rf := r.asFloat(); + lf := l.asFloat() + rf := r.asFloat() a.eval = func(t *Thread) bool { - l, r := lf(t), rf(t); - return l >= r; - }; + l, r := lf(t), rf(t) + return l >= r + } case *idealFloatType: - l := l.asIdealFloat()(); - r := r.asIdealFloat()(); - val := l.Cmp(r) >= 0; - a.eval = func(t *Thread) bool { return val }; + l := l.asIdealFloat()() + r := r.asIdealFloat()() + val := l.Cmp(r) >= 0 + a.eval = func(t *Thread) bool { return val } case *stringType: - lf := l.asString(); - rf := r.asString(); + lf := l.asString() + rf := r.asString() a.eval = func(t *Thread) bool { - l, r := lf(t), rf(t); - return l >= r; - }; + l, r := lf(t), rf(t) + return l >= r + } default: log.Crashf("unexpected type %v at %v", l.t, a.pos) } @@ -1728,71 +1728,71 @@ func (a *expr) genBinOpGeq(l, r *expr) { func (a *expr) genBinOpEql(l, r *expr) { switch t := l.t.lit().(type) { case *boolType: - lf := l.asBool(); - rf := r.asBool(); + lf := l.asBool() + rf := r.asBool() a.eval = func(t *Thread) bool { - l, r := lf(t), rf(t); - return l == r; - }; + l, r := lf(t), rf(t) + return l == r + } case *uintType: - lf := l.asUint(); - rf := r.asUint(); + lf := l.asUint() + rf := r.asUint() a.eval = func(t *Thread) bool { - l, r := lf(t), rf(t); - return l == r; - }; + l, r := lf(t), rf(t) + return l == r + } case *intType: - lf := l.asInt(); - rf := r.asInt(); + lf := l.asInt() + rf := r.asInt() a.eval = func(t *Thread) bool { - l, r := lf(t), rf(t); - return l == r; - }; + l, r := lf(t), rf(t) + return l == r + } case *idealIntType: - l := l.asIdealInt()(); - r := r.asIdealInt()(); - val := l.Cmp(r) == 0; - a.eval = func(t *Thread) bool { return val }; + l := l.asIdealInt()() + r := r.asIdealInt()() + val := l.Cmp(r) == 0 + a.eval = func(t *Thread) bool { return val } case *floatType: - lf := l.asFloat(); - rf := r.asFloat(); + lf := l.asFloat() + rf := r.asFloat() a.eval = func(t *Thread) bool { - l, r := lf(t), rf(t); - return l == r; - }; + l, r := lf(t), rf(t) + return l == r + } case *idealFloatType: - l := l.asIdealFloat()(); - r := r.asIdealFloat()(); - val := l.Cmp(r) == 0; - a.eval = func(t *Thread) bool { return val }; + l := l.asIdealFloat()() + r := r.asIdealFloat()() + val := l.Cmp(r) == 0 + a.eval = func(t *Thread) bool { return val } case *stringType: - lf := l.asString(); - rf := r.asString(); + lf := l.asString() + rf := r.asString() a.eval = func(t *Thread) bool { - l, r := lf(t), rf(t); - return l == r; - }; + l, r := lf(t), rf(t) + return l == r + } case *PtrType: - lf := l.asPtr(); - rf := r.asPtr(); + lf := l.asPtr() + rf := r.asPtr() a.eval = func(t *Thread) bool { - l, r := lf(t), rf(t); - return l == r; - }; + l, r := lf(t), rf(t) + return l == r + } case *FuncType: - lf := l.asFunc(); - rf := r.asFunc(); + lf := l.asFunc() + rf := r.asFunc() a.eval = func(t *Thread) bool { - l, r := lf(t), rf(t); - return l == r; - }; + l, r := lf(t), rf(t) + return l == r + } case *MapType: - lf := l.asMap(); - rf := r.asMap(); + lf := l.asMap() + rf := r.asMap() a.eval = func(t *Thread) bool { - l, r := lf(t), rf(t); - return l == r; - }; + l, r := lf(t), rf(t) + return l == r + } default: log.Crashf("unexpected type %v at %v", l.t, a.pos) } @@ -1801,71 +1801,71 @@ func (a *expr) genBinOpEql(l, r *expr) { func (a *expr) genBinOpNeq(l, r *expr) { switch t := l.t.lit().(type) { case *boolType: - lf := l.asBool(); - rf := r.asBool(); + lf := l.asBool() + rf := r.asBool() a.eval = func(t *Thread) bool { - l, r := lf(t), rf(t); - return l != r; - }; + l, r := lf(t), rf(t) + return l != r + } case *uintType: - lf := l.asUint(); - rf := r.asUint(); + lf := l.asUint() + rf := r.asUint() a.eval = func(t *Thread) bool { - l, r := lf(t), rf(t); - return l != r; - }; + l, r := lf(t), rf(t) + return l != r + } case *intType: - lf := l.asInt(); - rf := r.asInt(); + lf := l.asInt() + rf := r.asInt() a.eval = func(t *Thread) bool { - l, r := lf(t), rf(t); - return l != r; - }; + l, r := lf(t), rf(t) + return l != r + } case *idealIntType: - l := l.asIdealInt()(); - r := r.asIdealInt()(); - val := l.Cmp(r) != 0; - a.eval = func(t *Thread) bool { return val }; + l := l.asIdealInt()() + r := r.asIdealInt()() + val := l.Cmp(r) != 0 + a.eval = func(t *Thread) bool { return val } case *floatType: - lf := l.asFloat(); - rf := r.asFloat(); + lf := l.asFloat() + rf := r.asFloat() a.eval = func(t *Thread) bool { - l, r := lf(t), rf(t); - return l != r; - }; + l, r := lf(t), rf(t) + return l != r + } case *idealFloatType: - l := l.asIdealFloat()(); - r := r.asIdealFloat()(); - val := l.Cmp(r) != 0; - a.eval = func(t *Thread) bool { return val }; + l := l.asIdealFloat()() + r := r.asIdealFloat()() + val := l.Cmp(r) != 0 + a.eval = func(t *Thread) bool { return val } case *stringType: - lf := l.asString(); - rf := r.asString(); + lf := l.asString() + rf := r.asString() a.eval = func(t *Thread) bool { - l, r := lf(t), rf(t); - return l != r; - }; + l, r := lf(t), rf(t) + return l != r + } case *PtrType: - lf := l.asPtr(); - rf := r.asPtr(); + lf := l.asPtr() + rf := r.asPtr() a.eval = func(t *Thread) bool { - l, r := lf(t), rf(t); - return l != r; - }; + l, r := lf(t), rf(t) + return l != r + } case *FuncType: - lf := l.asFunc(); - rf := r.asFunc(); + lf := l.asFunc() + rf := r.asFunc() a.eval = func(t *Thread) bool { - l, r := lf(t), rf(t); - return l != r; - }; + l, r := lf(t), rf(t) + return l != r + } case *MapType: - lf := l.asMap(); - rf := r.asMap(); + lf := l.asMap() + rf := r.asMap() a.eval = func(t *Thread) bool { - l, r := lf(t), rf(t); - return l != r; - }; + l, r := lf(t), rf(t) + return l != r + } default: log.Crashf("unexpected type %v at %v", l.t, a.pos) } @@ -1874,40 +1874,40 @@ func (a *expr) genBinOpNeq(l, r *expr) { func genAssign(lt Type, r *expr) (func(lv Value, t *Thread)) { switch lt.lit().(type) { case *boolType: - rf := r.asBool(); - return func(lv Value, t *Thread) { lv.(BoolValue).Set(t, rf(t)) }; + rf := r.asBool() + return func(lv Value, t *Thread) { lv.(BoolValue).Set(t, rf(t)) } case *uintType: - rf := r.asUint(); - return func(lv Value, t *Thread) { lv.(UintValue).Set(t, rf(t)) }; + rf := r.asUint() + return func(lv Value, t *Thread) { lv.(UintValue).Set(t, rf(t)) } case *intType: - rf := r.asInt(); - return func(lv Value, t *Thread) { lv.(IntValue).Set(t, rf(t)) }; + rf := r.asInt() + return func(lv Value, t *Thread) { lv.(IntValue).Set(t, rf(t)) } case *floatType: - rf := r.asFloat(); - return func(lv Value, t *Thread) { lv.(FloatValue).Set(t, rf(t)) }; + rf := r.asFloat() + return func(lv Value, t *Thread) { lv.(FloatValue).Set(t, rf(t)) } case *stringType: - rf := r.asString(); - return func(lv Value, t *Thread) { lv.(StringValue).Set(t, rf(t)) }; + rf := r.asString() + return func(lv Value, t *Thread) { lv.(StringValue).Set(t, rf(t)) } case *ArrayType: - rf := r.asArray(); - return func(lv Value, t *Thread) { lv.Assign(t, rf(t)) }; + rf := r.asArray() + return func(lv Value, t *Thread) { lv.Assign(t, rf(t)) } case *StructType: - rf := r.asStruct(); - return func(lv Value, t *Thread) { lv.Assign(t, rf(t)) }; + rf := r.asStruct() + return func(lv Value, t *Thread) { lv.Assign(t, rf(t)) } case *PtrType: - rf := r.asPtr(); - return func(lv Value, t *Thread) { lv.(PtrValue).Set(t, rf(t)) }; + rf := r.asPtr() + return func(lv Value, t *Thread) { lv.(PtrValue).Set(t, rf(t)) } case *FuncType: - rf := r.asFunc(); - return func(lv Value, t *Thread) { lv.(FuncValue).Set(t, rf(t)) }; + rf := r.asFunc() + return func(lv Value, t *Thread) { lv.(FuncValue).Set(t, rf(t)) } case *SliceType: - rf := r.asSlice(); - return func(lv Value, t *Thread) { lv.(SliceValue).Set(t, rf(t)) }; + rf := r.asSlice() + return func(lv Value, t *Thread) { lv.(SliceValue).Set(t, rf(t)) } case *MapType: - rf := r.asMap(); - return func(lv Value, t *Thread) { lv.(MapValue).Set(t, rf(t)) }; + rf := r.asMap() + return func(lv Value, t *Thread) { lv.(MapValue).Set(t, rf(t)) } default: log.Crashf("unexpected left operand type %v at %v", lt, r.pos) } - panic(); + panic() } diff --git a/src/pkg/exp/eval/expr_test.go b/src/pkg/exp/eval/expr_test.go index 4d3e2776a..5cfbc8232 100644 --- a/src/pkg/exp/eval/expr_test.go +++ b/src/pkg/exp/eval/expr_test.go @@ -5,8 +5,8 @@ package eval import ( - "bignum"; - "testing"; + "bignum" + "testing" ) var undefined = "undefined" @@ -340,4 +340,4 @@ var exprTests = []test{ CErr("fn==oneTwo", opTypes), } -func TestExpr(t *testing.T) { runTests(t, "exprTests", exprTests) } +func TestExpr(t *testing.T) { runTests(t, "exprTests", exprTests) } diff --git a/src/pkg/exp/eval/func.go b/src/pkg/exp/eval/func.go index 992706641..e672d0783 100644 --- a/src/pkg/exp/eval/func.go +++ b/src/pkg/exp/eval/func.go @@ -11,25 +11,25 @@ import "os" */ type Thread struct { - abort chan os.Error; - pc uint; + abort chan os.Error + pc uint // The execution frame of this function. This remains the // same throughout a function invocation. - f *Frame; + f *Frame } type code []func(*Thread) func (i code) exec(t *Thread) { - opc := t.pc; - t.pc = 0; - l := uint(len(i)); + opc := t.pc + t.pc = 0 + l := uint(len(i)) for t.pc < l { - pc := t.pc; - t.pc++; - i[pc](t); + pc := t.pc + t.pc++ + i[pc](t) } - t.pc = opc; + t.pc = opc } /* @@ -37,33 +37,33 @@ func (i code) exec(t *Thread) { */ type codeBuf struct { - instrs code; + instrs code } -func newCodeBuf() *codeBuf { return &codeBuf{make(code, 0, 16)} } +func newCodeBuf() *codeBuf { return &codeBuf{make(code, 0, 16)} } func (b *codeBuf) push(instr func(*Thread)) { - n := len(b.instrs); + n := len(b.instrs) if n >= cap(b.instrs) { - a := make(code, n, n*2); + a := make(code, n, n*2) for i := range b.instrs { a[i] = b.instrs[i] } - b.instrs = a; + b.instrs = a } - b.instrs = b.instrs[0 : n+1]; - b.instrs[n] = instr; + b.instrs = b.instrs[0 : n+1] + b.instrs[n] = instr } -func (b *codeBuf) nextPC() uint { return uint(len(b.instrs)) } +func (b *codeBuf) nextPC() uint { return uint(len(b.instrs)) } func (b *codeBuf) get() code { // Freeze this buffer into an array of exactly the right size - a := make(code, len(b.instrs)); + a := make(code, len(b.instrs)) for i := range b.instrs { a[i] = b.instrs[i] } - return code(a); + return code(a) } /* @@ -71,11 +71,11 @@ func (b *codeBuf) get() code { */ type evalFunc struct { - outer *Frame; - frameSize int; - code code; + outer *Frame + frameSize int + code code } -func (f *evalFunc) NewFrame() *Frame { return f.outer.child(f.frameSize) } +func (f *evalFunc) NewFrame() *Frame { return f.outer.child(f.frameSize) } -func (f *evalFunc) Call(t *Thread) { f.code.exec(t) } +func (f *evalFunc) Call(t *Thread) { f.code.exec(t) } diff --git a/src/pkg/exp/eval/gen.go b/src/pkg/exp/eval/gen.go index df49b21d3..2acc2c956 100644 --- a/src/pkg/exp/eval/gen.go +++ b/src/pkg/exp/eval/gen.go @@ -7,58 +7,58 @@ package main // generate operator implementations import ( - "log"; - "os"; - "template"; + "log" + "os" + "template" ) type Op struct { - Name string; - Expr string; - Body string; // overrides Expr - ConstExpr string; - AsRightName string; - ReturnType string; - Types []*Type; + Name string + Expr string + Body string // overrides Expr + ConstExpr string + AsRightName string + ReturnType string + Types []*Type } type Size struct { - Bits int; - Sized string; + Bits int + Sized string } type Type struct { - Repr string; - Value string; - Native string; - As string; - IsIdeal bool; - HasAssign bool; - Sizes []Size; + Repr string + Value string + Native string + As string + IsIdeal bool + HasAssign bool + Sizes []Size } var ( - boolType = &Type{Repr: "*boolType", Value: "BoolValue", Native: "bool", As: "asBool"}; - uintType = &Type{Repr: "*uintType", Value: "UintValue", Native: "uint64", As: "asUint", + boolType = &Type{Repr: "*boolType", Value: "BoolValue", Native: "bool", As: "asBool"} + uintType = &Type{Repr: "*uintType", Value: "UintValue", Native: "uint64", As: "asUint", Sizes: []Size{Size{8, "uint8"}, Size{16, "uint16"}, Size{32, "uint32"}, Size{64, "uint64"}, Size{0, "uint"}}, - }; - intType = &Type{Repr: "*intType", Value: "IntValue", Native: "int64", As: "asInt", + } + intType = &Type{Repr: "*intType", Value: "IntValue", Native: "int64", As: "asInt", Sizes: []Size{Size{8, "int8"}, Size{16, "int16"}, Size{32, "int32"}, Size{64, "int64"}, Size{0, "int"}}, - }; - idealIntType = &Type{Repr: "*idealIntType", Value: "IdealIntValue", Native: "*bignum.Integer", As: "asIdealInt", IsIdeal: true}; - floatType = &Type{Repr: "*floatType", Value: "FloatValue", Native: "float64", As: "asFloat", + } + idealIntType = &Type{Repr: "*idealIntType", Value: "IdealIntValue", Native: "*bignum.Integer", As: "asIdealInt", IsIdeal: true} + floatType = &Type{Repr: "*floatType", Value: "FloatValue", Native: "float64", As: "asFloat", Sizes: []Size{Size{32, "float32"}, Size{64, "float64"}, Size{0, "float"}}, - }; - idealFloatType = &Type{Repr: "*idealFloatType", Value: "IdealFloatValue", Native: "*bignum.Rational", As: "asIdealFloat", IsIdeal: true}; - stringType = &Type{Repr: "*stringType", Value: "StringValue", Native: "string", As: "asString"}; - arrayType = &Type{Repr: "*ArrayType", Value: "ArrayValue", Native: "ArrayValue", As: "asArray", HasAssign: true}; - structType = &Type{Repr: "*StructType", Value: "StructValue", Native: "StructValue", As: "asStruct", HasAssign: true}; - ptrType = &Type{Repr: "*PtrType", Value: "PtrValue", Native: "Value", As: "asPtr"}; - funcType = &Type{Repr: "*FuncType", Value: "FuncValue", Native: "Func", As: "asFunc"}; - sliceType = &Type{Repr: "*SliceType", Value: "SliceValue", Native: "Slice", As: "asSlice"}; - mapType = &Type{Repr: "*MapType", Value: "MapValue", Native: "Map", As: "asMap"}; + } + idealFloatType = &Type{Repr: "*idealFloatType", Value: "IdealFloatValue", Native: "*bignum.Rational", As: "asIdealFloat", IsIdeal: true} + stringType = &Type{Repr: "*stringType", Value: "StringValue", Native: "string", As: "asString"} + arrayType = &Type{Repr: "*ArrayType", Value: "ArrayValue", Native: "ArrayValue", As: "asArray", HasAssign: true} + structType = &Type{Repr: "*StructType", Value: "StructValue", Native: "StructValue", As: "asStruct", HasAssign: true} + ptrType = &Type{Repr: "*PtrType", Value: "PtrValue", Native: "Value", As: "asPtr"} + funcType = &Type{Repr: "*FuncType", Value: "FuncValue", Native: "Func", As: "asFunc"} + sliceType = &Type{Repr: "*SliceType", Value: "SliceValue", Native: "Slice", As: "asSlice"} + mapType = &Type{Repr: "*MapType", Value: "MapValue", Native: "Map", As: "asMap"} - all = []*Type{ + all = []*Type{ boolType, uintType, intType, @@ -72,13 +72,13 @@ var ( funcType, sliceType, mapType, - }; - bools = all[0:1]; - integers = all[1:4]; - shiftable = all[1:3]; - numbers = all[1:6]; - addable = all[1:7]; - cmpable = []*Type{ + } + bools = all[0:1] + integers = all[1:4] + shiftable = all[1:3] + numbers = all[1:6] + addable = all[1:7] + cmpable = []*Type{ boolType, uintType, intType, @@ -89,7 +89,7 @@ var ( ptrType, funcType, mapType, - }; + } ) var unOps = []Op{ @@ -131,9 +131,9 @@ var binOps = []Op{ } type Data struct { - UnaryOps []Op; - BinaryOps []Op; - Types []*Type; + UnaryOps []Op + BinaryOps []Op + Types []*Type } var data = Data{ @@ -362,13 +362,13 @@ func genAssign(lt Type, r *expr) (func(lv Value, t *Thread)) { ` func main() { - t := template.New(nil); - t.SetDelims("«", "»"); - err := t.Parse(templateStr); + t := template.New(nil) + t.SetDelims("«", "»") + err := t.Parse(templateStr) if err != nil { log.Exit(err) } - err = t.Execute(data, os.Stdout); + err = t.Execute(data, os.Stdout) if err != nil { log.Exit(err) } diff --git a/src/pkg/exp/eval/main.go b/src/pkg/exp/eval/main.go index 376af6b86..e7c58ef5b 100644 --- a/src/pkg/exp/eval/main.go +++ b/src/pkg/exp/eval/main.go @@ -5,32 +5,32 @@ package main import ( - "./_obj/eval"; - "bufio"; - "flag"; - "go/parser"; - "go/scanner"; - "io"; - "os"; + "./_obj/eval" + "bufio" + "flag" + "go/parser" + "go/scanner" + "io" + "os" ) var filename = flag.String("f", "", "file to run") func main() { - flag.Parse(); - w := eval.NewWorld(); + flag.Parse() + w := eval.NewWorld() if *filename != "" { - data, err := ioutil.ReadFile(*filename); + data, err := ioutil.ReadFile(*filename) if err != nil { - println(err.String()); - os.Exit(1); + println(err.String()) + os.Exit(1) } - file, err := parser.ParseFile(*filename, data, 0); + file, err := parser.ParseFile(*filename, data, 0) if err != nil { - println(err.String()); - os.Exit(1); + println(err.String()) + os.Exit(1) } - code, err := w.CompileDeclList(file.Decls); + code, err := w.CompileDeclList(file.Decls) if err != nil { if list, ok := err.(scanner.ErrorList); ok { for _, e := range list { @@ -39,50 +39,50 @@ func main() { } else { println(err.String()) } - os.Exit(1); + os.Exit(1) } - _, err := code.Run(); + _, err := code.Run() if err != nil { - println(err.String()); - os.Exit(1); + println(err.String()) + os.Exit(1) } - code, err = w.Compile("init()"); + code, err = w.Compile("init()") if code != nil { - _, err := code.Run(); + _, err := code.Run() if err != nil { - println(err.String()); - os.Exit(1); + println(err.String()) + os.Exit(1) } } - code, err = w.Compile("main()"); + code, err = w.Compile("main()") if err != nil { - println(err.String()); - os.Exit(1); + println(err.String()) + os.Exit(1) } - _, err = code.Run(); + _, err = code.Run() if err != nil { - println(err.String()); - os.Exit(1); + println(err.String()) + os.Exit(1) } - os.Exit(0); + os.Exit(0) } - r := bufio.NewReader(os.Stdin); + r := bufio.NewReader(os.Stdin) for { - print("; "); - line, err := r.ReadString('\n'); + print("; ") + line, err := r.ReadString('\n') if err != nil { break } - code, err := w.Compile(line); + code, err := w.Compile(line) if err != nil { - println(err.String()); - continue; + println(err.String()) + continue } - v, err := code.Run(); + v, err := code.Run() if err != nil { - println(err.String()); - continue; + println(err.String()) + continue } if v != nil { println(v.String()) diff --git a/src/pkg/exp/eval/scope.go b/src/pkg/exp/eval/scope.go index 971b92d53..84c4c92b8 100644 --- a/src/pkg/exp/eval/scope.go +++ b/src/pkg/exp/eval/scope.go @@ -5,8 +5,8 @@ package eval import ( - "go/token"; - "log"; + "go/token" + "log" ) /* @@ -15,25 +15,25 @@ import ( // A definition can be a *Variable, *Constant, or Type. type Def interface { - Pos() token.Position; + Pos() token.Position } type Variable struct { - token.Position; + token.Position // Index of this variable in the Frame structure - Index int; + Index int // Static type of this variable - Type Type; + Type Type // Value of this variable. This is only used by Scope.NewFrame; // therefore, it is useful for global scopes but cannot be used // in function scopes. - Init Value; + Init Value } type Constant struct { - token.Position; - Type Type; - Value Value; + token.Position + Type Type + Value Value } // A block represents a definition block in which a name may not be @@ -41,35 +41,35 @@ type Constant struct { type block struct { // The block enclosing this one, including blocks in other // scopes. - outer *block; + outer *block // The nested block currently being compiled, or nil. - inner *block; + inner *block // The Scope containing this block. - scope *Scope; + scope *Scope // The Variables, Constants, and Types defined in this block. - defs map[string]Def; + defs map[string]Def // The index of the first variable defined in this block. // This must be greater than the index of any variable defined // in any parent of this block within the same Scope at the // time this block is entered. - offset int; + offset int // The number of Variables defined in this block. - numVars int; + numVars int // If global, do not allocate new vars and consts in // the frame; assume that the refs will be compiled in // using defs[name].Init. - global bool; + global bool } // A Scope is the compile-time analogue of a Frame, which captures // some subtree of blocks. type Scope struct { // The root block of this scope. - *block; + *block // The maximum number of variables required at any point in // this Scope. This determines the number of slots needed in // Frame's created from this Scope at run-time. - maxVars int; + maxVars int } func (b *block) enterChild() *block { @@ -81,9 +81,9 @@ func (b *block) enterChild() *block { scope: b.scope, defs: make(map[string]Def), offset: b.offset + b.numVars, - }; - b.inner = sub; - return sub; + } + b.inner = sub + return sub } func (b *block) exit() { @@ -98,66 +98,66 @@ func (b *block) exit() { log.Crash("Exit of parent block without exit of child block") } } - b.outer.inner = nil; + b.outer.inner = nil } func (b *block) ChildScope() *Scope { if b.inner != nil && b.inner.scope == b.scope { log.Crash("Failed to exit child block before entering a child scope") } - sub := b.enterChild(); - sub.offset = 0; - sub.scope = &Scope{sub, 0}; - return sub.scope; + sub := b.enterChild() + sub.offset = 0 + sub.scope = &Scope{sub, 0} + return sub.scope } func (b *block) DefineVar(name string, pos token.Position, t Type) (*Variable, Def) { if prev, ok := b.defs[name]; ok { return nil, prev } - v := b.defineSlot(t, false); - v.Position = pos; - b.defs[name] = v; - return v, nil; + v := b.defineSlot(t, false) + v.Position = pos + b.defs[name] = v + return v, nil } -func (b *block) DefineTemp(t Type) *Variable { return b.defineSlot(t, true) } +func (b *block) DefineTemp(t Type) *Variable { return b.defineSlot(t, true) } func (b *block) defineSlot(t Type, temp bool) *Variable { if b.inner != nil && b.inner.scope == b.scope { log.Crash("Failed to exit child block before defining variable") } - index := -1; + index := -1 if !b.global || temp { - index = b.offset + b.numVars; - b.numVars++; + index = b.offset + b.numVars + b.numVars++ if index >= b.scope.maxVars { b.scope.maxVars = index + 1 } } - v := &Variable{token.Position{}, index, t, nil}; - return v; + v := &Variable{token.Position{}, index, t, nil} + return v } func (b *block) DefineConst(name string, pos token.Position, t Type, v Value) (*Constant, Def) { if prev, ok := b.defs[name]; ok { return nil, prev } - c := &Constant{pos, t, v}; - b.defs[name] = c; - return c, nil; + c := &Constant{pos, t, v} + b.defs[name] = c + return c, nil } func (b *block) DefineType(name string, pos token.Position, t Type) Type { if _, ok := b.defs[name]; ok { return nil } - nt := &NamedType{pos, name, nil, true, make(map[string]Method)}; + nt := &NamedType{pos, name, nil, true, make(map[string]Method)} if t != nil { nt.Complete(t) } - b.defs[name] = nt; - return nt; + b.defs[name] = nt + return nt } func (b *block) Lookup(name string) (bl *block, level int, def Def) { @@ -168,27 +168,27 @@ func (b *block) Lookup(name string) (bl *block, level int, def Def) { if b.outer != nil && b.scope != b.outer.scope { level++ } - b = b.outer; + b = b.outer } - return nil, 0, nil; + return nil, 0, nil } -func (s *Scope) NewFrame(outer *Frame) *Frame { return outer.child(s.maxVars) } +func (s *Scope) NewFrame(outer *Frame) *Frame { return outer.child(s.maxVars) } /* * Frames */ type Frame struct { - Outer *Frame; - Vars []Value; + Outer *Frame + Vars []Value } func (f *Frame) Get(level int, index int) Value { for ; level > 0; level-- { f = f.Outer } - return f.Vars[index]; + return f.Vars[index] } func (f *Frame) child(numVars int) *Frame { diff --git a/src/pkg/exp/eval/stmt.go b/src/pkg/exp/eval/stmt.go index 60c6b9ee6..53757f7de 100644 --- a/src/pkg/exp/eval/stmt.go +++ b/src/pkg/exp/eval/stmt.go @@ -5,15 +5,15 @@ package eval import ( - "bignum"; - "log"; - "go/ast"; - "go/token"; + "bignum" + "log" + "go/ast" + "go/token" ) const ( - returnPC = ^uint(0); - badPC = ^uint(1); + returnPC = ^uint(0) + badPC = ^uint(1) ) /* @@ -21,10 +21,10 @@ const ( */ type stmtCompiler struct { - *blockCompiler; - pos token.Position; + *blockCompiler + pos token.Position // This statement's label, or nil if it is not labeled. - stmtLabel *label; + stmtLabel *label } func (a *stmtCompiler) diag(format string, args ...) { @@ -38,39 +38,39 @@ func (a *stmtCompiler) diag(format string, args ...) { type flowEnt struct { // Whether this flow entry is conditional. If true, flow can // continue to the next PC. - cond bool; + cond bool // True if this will terminate flow (e.g., a return statement). // cond must be false and jumps must be nil if this is true. - term bool; + term bool // PC's that can be reached from this flow entry. - jumps []*uint; + jumps []*uint // Whether this flow entry has been visited by reachesEnd. - visited bool; + visited bool } type flowBlock struct { // If this is a goto, the target label. - target string; + target string // The inner-most block containing definitions. - block *block; + block *block // The numVars from each block leading to the root of the // scope, starting at block. - numVars []int; + numVars []int } type flowBuf struct { - cb *codeBuf; + cb *codeBuf // ents is a map from PC's to flow entries. Any PC missing // from this map is assumed to reach only PC+1. - ents map[uint]*flowEnt; + ents map[uint]*flowEnt // gotos is a map from goto positions to information on the // block at the point of the goto. - gotos map[*token.Position]*flowBlock; + gotos map[*token.Position]*flowBlock // labels is a map from label name to information on the block // at the point of the label. labels are tracked by name, // since mutliple labels at the same PC can have different // blocks. - labels map[string]*flowBlock; + labels map[string]*flowBlock } func newFlowBuf(cb *codeBuf) *flowBuf { @@ -80,16 +80,16 @@ func newFlowBuf(cb *codeBuf) *flowBuf { // put creates a flow control point for the next PC in the code buffer. // This should be done before pushing the instruction into the code buffer. func (f *flowBuf) put(cond bool, term bool, jumps []*uint) { - pc := f.cb.nextPC(); + pc := f.cb.nextPC() if ent, ok := f.ents[pc]; ok { log.Crashf("Flow entry already exists at PC %d: %+v", pc, ent) } - f.ents[pc] = &flowEnt{cond, term, jumps, false}; + f.ents[pc] = &flowEnt{cond, term, jumps, false} } // putTerm creates a flow control point at the next PC that // unconditionally terminates execution. -func (f *flowBuf) putTerm() { f.put(false, true, nil) } +func (f *flowBuf) putTerm() { f.put(false, true, nil) } // put1 creates a flow control point at the next PC that jumps to one // PC and, if cond is true, can also continue to the PC following the @@ -105,20 +105,20 @@ func newFlowBlock(target string, b *block) *flowBlock { } // Count parents leading to the root of the scope - n := 0; + n := 0 for bp := b; bp.scope == b.scope; bp = bp.outer { n++ } // Capture numVars from each block to the root of the scope - numVars := make([]int, n); - i := 0; + numVars := make([]int, n) + i := 0 for bp := b; i < n; bp = bp.outer { - numVars[i] = bp.numVars; - i++; + numVars[i] = bp.numVars + i++ } - return &flowBlock{target, b, numVars}; + return &flowBlock{target, b, numVars} } // putGoto captures the block at a goto statement. This should be @@ -136,13 +136,13 @@ func (f *flowBuf) putLabel(name string, b *block) { // reached from the given program counter. Error reporting is the // caller's responsibility. func (f *flowBuf) reachesEnd(pc uint) bool { - endPC := f.cb.nextPC(); + endPC := f.cb.nextPC() if pc > endPC { log.Crashf("Reached bad PC %d past end PC %d", pc, endPC) } for ; pc < endPC; pc++ { - ent, ok := f.ents[pc]; + ent, ok := f.ents[pc] if !ok { continue } @@ -150,7 +150,7 @@ func (f *flowBuf) reachesEnd(pc uint) bool { if ent.visited { return false } - ent.visited = true; + ent.visited = true if ent.term { return false @@ -168,9 +168,9 @@ func (f *flowBuf) reachesEnd(pc uint) bool { if ent.cond { continue } - return false; + return false } - return true; + return true } // gotosObeyScopes returns true if no goto statement causes any @@ -178,28 +178,28 @@ func (f *flowBuf) reachesEnd(pc uint) bool { // the goto. Reports any errors using the given compiler. func (f *flowBuf) gotosObeyScopes(a *compiler) { for pos, src := range f.gotos { - tgt := f.labels[src.target]; + tgt := f.labels[src.target] // The target block must be a parent of this block - numVars := src.numVars; - b := src.block; + numVars := src.numVars + b := src.block for len(numVars) > 0 && b != tgt.block { - b = b.outer; - numVars = numVars[1:]; + b = b.outer + numVars = numVars[1:] } if b != tgt.block { // We jumped into a deeper block - a.diagAt(pos, "goto causes variables to come into scope"); - return; + a.diagAt(pos, "goto causes variables to come into scope") + return } // There must be no variables in the target block that // did not exist at the jump - tgtNumVars := tgt.numVars; + tgtNumVars := tgt.numVars for i := range numVars { if tgtNumVars[i] > numVars[i] { - a.diagAt(pos, "goto causes variables to come into scope"); - return; + a.diagAt(pos, "goto causes variables to come into scope") + return } } } @@ -210,25 +210,25 @@ func (f *flowBuf) gotosObeyScopes(a *compiler) { */ func (a *stmtCompiler) defineVar(ident *ast.Ident, t Type) *Variable { - v, prev := a.block.DefineVar(ident.Value, ident.Pos(), t); + v, prev := a.block.DefineVar(ident.Value, ident.Pos(), t) if prev != nil { // TODO(austin) It's silly that we have to capture // Pos() in a variable. - pos := prev.Pos(); + pos := prev.Pos() if pos.IsValid() { a.diagAt(ident, "variable %s redeclared in this block\n\tprevious declaration at %s", ident.Value, &pos) } else { a.diagAt(ident, "variable %s redeclared in this block", ident.Value) } - return nil; + return nil } // Initialize the variable - index := v.Index; + index := v.Index if v.Index >= 0 { a.push(func(v *Thread) { v.f.Vars[index] = t.Zero() }) } - return v; + return v } // TODO(austin) Move doAssign to here @@ -242,7 +242,7 @@ func (a *stmtCompiler) compile(s ast.Stmt) { log.Crash("Child scope still entered") } - notimpl := false; + notimpl := false switch s := s.(type) { case *ast.BadStmt: // Error already reported by parser. @@ -340,30 +340,30 @@ func (a *stmtCompiler) compileDeclStmt(s *ast.DeclStmt) { default: log.Crashf("Unexpected Decl type %T", s.Decl) } - a.compileDecl(s.Decl); + a.compileDecl(s.Decl) } func (a *stmtCompiler) compileVarDecl(decl *ast.GenDecl) { for _, spec := range decl.Specs { - spec := spec.(*ast.ValueSpec); + spec := spec.(*ast.ValueSpec) if spec.Values == nil { // Declaration without assignment if spec.Type == nil { // Parser should have caught log.Crash("Type and Values nil") } - t := a.compileType(a.block, spec.Type); + t := a.compileType(a.block, spec.Type) // Define placeholders even if type compile failed for _, n := range spec.Names { a.defineVar(n, t) } } else { // Declaration with assignment - lhs := make([]ast.Expr, len(spec.Names)); + lhs := make([]ast.Expr, len(spec.Names)) for i, n := range spec.Names { lhs[i] = n } - a.doAssign(lhs, spec.Values, decl.Tok, spec.Type); + a.doAssign(lhs, spec.Values, decl.Tok, spec.Type) } } } @@ -375,27 +375,27 @@ func (a *stmtCompiler) compileDecl(decl ast.Decl) { a.silentErrors++ case *ast.FuncDecl: - decl := a.compileFuncType(a.block, d.Type); + decl := a.compileFuncType(a.block, d.Type) if decl == nil { return } // Declare and initialize v before compiling func // so that body can refer to itself. - c, prev := a.block.DefineConst(d.Name.Value, a.pos, decl.Type, decl.Type.Zero()); + c, prev := a.block.DefineConst(d.Name.Value, a.pos, decl.Type, decl.Type.Zero()) if prev != nil { - pos := prev.Pos(); + pos := prev.Pos() if pos.IsValid() { a.diagAt(d.Name, "identifier %s redeclared in this block\n\tprevious declaration at %s", d.Name.Value, &pos) } else { a.diagAt(d.Name, "identifier %s redeclared in this block", d.Name.Value) } } - fn := a.compileFunc(a.block, decl, d.Body); + fn := a.compileFunc(a.block, decl, d.Body) if c == nil || fn == nil { return } - var zeroThread Thread; - c.Value.(FuncValue).Set(nil, fn(&zeroThread)); + var zeroThread Thread + c.Value.(FuncValue).Set(nil, fn(&zeroThread)) case *ast.GenDecl: switch d.Tok { @@ -416,119 +416,119 @@ func (a *stmtCompiler) compileDecl(decl ast.Decl) { func (a *stmtCompiler) compileLabeledStmt(s *ast.LabeledStmt) { // Define label - l, ok := a.labels[s.Label.Value]; + l, ok := a.labels[s.Label.Value] if ok { if l.resolved.IsValid() { a.diag("label %s redeclared in this block\n\tprevious declaration at %s", s.Label.Value, &l.resolved) } } else { - pc := badPC; - l = &label{name: s.Label.Value, gotoPC: &pc}; - a.labels[l.name] = l; + pc := badPC + l = &label{name: s.Label.Value, gotoPC: &pc} + a.labels[l.name] = l } - l.desc = "regular label"; - l.resolved = s.Pos(); + l.desc = "regular label" + l.resolved = s.Pos() // Set goto PC - *l.gotoPC = a.nextPC(); + *l.gotoPC = a.nextPC() // Define flow entry so we can check for jumps over declarations. - a.flow.putLabel(l.name, a.block); + a.flow.putLabel(l.name, a.block) // Compile the statement. Reuse our stmtCompiler for simplicity. - sc := &stmtCompiler{a.blockCompiler, s.Stmt.Pos(), l}; - sc.compile(s.Stmt); + sc := &stmtCompiler{a.blockCompiler, s.Stmt.Pos(), l} + sc.compile(s.Stmt) } func (a *stmtCompiler) compileExprStmt(s *ast.ExprStmt) { - bc := a.enterChild(); - defer bc.exit(); + bc := a.enterChild() + defer bc.exit() - e := a.compileExpr(bc.block, false, s.X); + e := a.compileExpr(bc.block, false, s.X) if e == nil { return } if e.exec == nil { - a.diag("%s cannot be used as expression statement", e.desc); - return; + a.diag("%s cannot be used as expression statement", e.desc) + return } - a.push(e.exec); + a.push(e.exec) } func (a *stmtCompiler) compileIncDecStmt(s *ast.IncDecStmt) { // Create temporary block for extractEffect - bc := a.enterChild(); - defer bc.exit(); + bc := a.enterChild() + defer bc.exit() - l := a.compileExpr(bc.block, false, s.X); + l := a.compileExpr(bc.block, false, s.X) if l == nil { return } if l.evalAddr == nil { - l.diag("cannot assign to %s", l.desc); - return; + l.diag("cannot assign to %s", l.desc) + return } if !(l.t.isInteger() || l.t.isFloat()) { - l.diagOpType(s.Tok, l.t); - return; + l.diagOpType(s.Tok, l.t) + return } - var op token.Token; - var desc string; + var op token.Token + var desc string switch s.Tok { case token.INC: - op = token.ADD; - desc = "increment statement"; + op = token.ADD + desc = "increment statement" case token.DEC: - op = token.SUB; - desc = "decrement statement"; + op = token.SUB + desc = "decrement statement" default: log.Crashf("Unexpected IncDec token %v", s.Tok) } - effect, l := l.extractEffect(bc.block, desc); + effect, l := l.extractEffect(bc.block, desc) - one := l.newExpr(IdealIntType, "constant"); - one.pos = s.Pos(); - one.eval = func() *bignum.Integer { return bignum.Int(1) }; + one := l.newExpr(IdealIntType, "constant") + one.pos = s.Pos() + one.eval = func() *bignum.Integer { return bignum.Int(1) } - binop := l.compileBinaryExpr(op, l, one); + binop := l.compileBinaryExpr(op, l, one) if binop == nil { return } - assign := a.compileAssign(s.Pos(), bc.block, l.t, []*expr{binop}, "", ""); + assign := a.compileAssign(s.Pos(), bc.block, l.t, []*expr{binop}, "", "") if assign == nil { log.Crashf("compileAssign type check failed") } - lf := l.evalAddr; + lf := l.evalAddr a.push(func(v *Thread) { - effect(v); - assign(lf(v), v); - }); + effect(v) + assign(lf(v), v) + }) } func (a *stmtCompiler) doAssign(lhs []ast.Expr, rhs []ast.Expr, tok token.Token, declTypeExpr ast.Expr) { - nerr := a.numError(); + nerr := a.numError() // Compile right side first so we have the types when // compiling the left side and so we don't see definitions // made on the left side. - rs := make([]*expr, len(rhs)); + rs := make([]*expr, len(rhs)) for i, re := range rhs { rs[i] = a.compileExpr(a.block, false, re) } - errOp := "assignment"; + errOp := "assignment" if tok == token.DEFINE || tok == token.VAR { errOp = "declaration" } - ac, ok := a.checkAssign(a.pos, rs, errOp, "value"); - ac.allowMapForms(len(lhs)); + ac, ok := a.checkAssign(a.pos, rs, errOp, "value") + ac.allowMapForms(len(lhs)) // If this is a definition and the LHS is too big, we won't be // able to produce the usual error message because we can't @@ -538,35 +538,35 @@ func (a *stmtCompiler) doAssign(lhs []ast.Expr, rhs []ast.Expr, tok token.Token, } // Compile left type if there is one - var declType Type; + var declType Type if declTypeExpr != nil { declType = a.compileType(a.block, declTypeExpr) } // Compile left side - ls := make([]*expr, len(lhs)); - nDefs := 0; + ls := make([]*expr, len(lhs)) + nDefs := 0 for i, le := range lhs { // If this is a definition, get the identifier and its type - var ident *ast.Ident; - var lt Type; + var ident *ast.Ident + var lt Type switch tok { case token.DEFINE: // Check that it's an identifier - ident, ok = le.(*ast.Ident); + ident, ok = le.(*ast.Ident) if !ok { - a.diagAt(le, "left side of := must be a name"); + a.diagAt(le, "left side of := must be a name") // Suppress new defitions errors - nDefs++; - continue; + nDefs++ + continue } // Is this simply an assignment? if _, ok := a.block.defs[ident.Value]; ok { - ident = nil; - break; + ident = nil + break } - nDefs++; + nDefs++ case token.VAR: ident = le.(*ast.Ident) @@ -623,7 +623,7 @@ func (a *stmtCompiler) doAssign(lhs []ast.Expr, rhs []ast.Expr, tok token.Token, } // Compile LHS - ls[i] = a.compileExpr(a.block, false, le); + ls[i] = a.compileExpr(a.block, false, le) if ls[i] == nil { continue } @@ -635,23 +635,23 @@ func (a *stmtCompiler) doAssign(lhs []ast.Expr, rhs []ast.Expr, tok token.Token, // TODO(austin) Now that the expression // compiler uses semantic values, this might // be easier to implement as a function call. - sub := ls[i]; - ls[i] = ls[i].newExpr(sub.t, sub.desc); - ls[i].evalMapValue = sub.evalMapValue; - mvf := sub.evalMapValue; - et := sub.t; + sub := ls[i] + ls[i] = ls[i].newExpr(sub.t, sub.desc) + ls[i].evalMapValue = sub.evalMapValue + mvf := sub.evalMapValue + et := sub.t ls[i].evalAddr = func(t *Thread) Value { - m, k := mvf(t); - e := m.Elem(t, k); + m, k := mvf(t) + e := m.Elem(t, k) if e == nil { - e = et.Zero(); - m.SetElem(t, k, e); + e = et.Zero() + m.SetElem(t, k, e) } - return e; - }; + return e + } } else if ls[i].evalAddr == nil { - ls[i].diag("cannot assign to %s", ls[i].desc); - continue; + ls[i].diag("cannot assign to %s", ls[i].desc) + continue } } @@ -660,8 +660,8 @@ func (a *stmtCompiler) doAssign(lhs []ast.Expr, rhs []ast.Expr, tok token.Token, // with the same type, and at least one of the variables is // new. if tok == token.DEFINE && nDefs == 0 { - a.diag("at least one new variable must be declared"); - return; + a.diag("at least one new variable must be declared") + return } // If there have been errors, our arrays are full of nil's so @@ -672,27 +672,27 @@ func (a *stmtCompiler) doAssign(lhs []ast.Expr, rhs []ast.Expr, tok token.Token, // Check for 'a[x] = r, ok' if len(ls) == 1 && len(rs) == 2 && ls[0].evalMapValue != nil { - a.diag("a[x] = r, ok form not implemented"); - return; + a.diag("a[x] = r, ok form not implemented") + return } // Create assigner - var lt Type; - n := len(lhs); + var lt Type + n := len(lhs) if n == 1 { lt = ls[0].t } else { - lts := make([]Type, len(ls)); + lts := make([]Type, len(ls)) for i, l := range ls { if l != nil { lts[i] = l.t } } - lt = NewMultiType(lts); + lt = NewMultiType(lts) } - bc := a.enterChild(); - defer bc.exit(); - assign := ac.compile(bc.block, lt); + bc := a.enterChild() + defer bc.exit() + assign := ac.compile(bc.block, lt) if assign == nil { return } @@ -700,38 +700,38 @@ func (a *stmtCompiler) doAssign(lhs []ast.Expr, rhs []ast.Expr, tok token.Token, // Compile if n == 1 { // Don't need temporaries and can avoid []Value. - lf := ls[0].evalAddr; - a.push(func(t *Thread) { assign(lf(t), t) }); + lf := ls[0].evalAddr + a.push(func(t *Thread) { assign(lf(t), t) }) } else if tok == token.VAR || (tok == token.DEFINE && nDefs == n) { // Don't need temporaries - lfs := make([]func(*Thread) Value, n); + lfs := make([]func(*Thread) Value, n) for i, l := range ls { lfs[i] = l.evalAddr } a.push(func(t *Thread) { - dest := make([]Value, n); + dest := make([]Value, n) for i, lf := range lfs { dest[i] = lf(t) } - assign(multiV(dest), t); - }); + assign(multiV(dest), t) + }) } else { // Need temporaries - lmt := lt.(*MultiType); - lfs := make([]func(*Thread) Value, n); + lmt := lt.(*MultiType) + lfs := make([]func(*Thread) Value, n) for i, l := range ls { lfs[i] = l.evalAddr } a.push(func(t *Thread) { - temp := lmt.Zero().(multiV); - assign(temp, t); + temp := lmt.Zero().(multiV) + assign(temp, t) // Copy to destination for i := 0; i < n; i++ { // TODO(austin) Need to evaluate LHS // before RHS lfs[i](t).Assign(t, temp[i]) } - }); + }) } } @@ -752,42 +752,42 @@ var assignOpToOp = map[token.Token]token.Token{ func (a *stmtCompiler) doAssignOp(s *ast.AssignStmt) { if len(s.Lhs) != 1 || len(s.Rhs) != 1 { - a.diag("tuple assignment cannot be combined with an arithmetic operation"); - return; + a.diag("tuple assignment cannot be combined with an arithmetic operation") + return } // Create temporary block for extractEffect - bc := a.enterChild(); - defer bc.exit(); + bc := a.enterChild() + defer bc.exit() - l := a.compileExpr(bc.block, false, s.Lhs[0]); - r := a.compileExpr(bc.block, false, s.Rhs[0]); + l := a.compileExpr(bc.block, false, s.Lhs[0]) + r := a.compileExpr(bc.block, false, s.Rhs[0]) if l == nil || r == nil { return } if l.evalAddr == nil { - l.diag("cannot assign to %s", l.desc); - return; + l.diag("cannot assign to %s", l.desc) + return } - effect, l := l.extractEffect(bc.block, "operator-assignment"); + effect, l := l.extractEffect(bc.block, "operator-assignment") - binop := r.compileBinaryExpr(assignOpToOp[s.Tok], l, r); + binop := r.compileBinaryExpr(assignOpToOp[s.Tok], l, r) if binop == nil { return } - assign := a.compileAssign(s.Pos(), bc.block, l.t, []*expr{binop}, "assignment", "value"); + assign := a.compileAssign(s.Pos(), bc.block, l.t, []*expr{binop}, "assignment", "value") if assign == nil { log.Crashf("compileAssign type check failed") } - lf := l.evalAddr; + lf := l.evalAddr a.push(func(t *Thread) { - effect(t); - assign(lf(t), t); - }); + effect(t) + assign(lf(t), t) + }) } func (a *stmtCompiler) compileAssignStmt(s *ast.AssignStmt) { @@ -802,25 +802,25 @@ func (a *stmtCompiler) compileAssignStmt(s *ast.AssignStmt) { func (a *stmtCompiler) compileReturnStmt(s *ast.ReturnStmt) { if a.fnType == nil { - a.diag("cannot return at the top level"); - return; + a.diag("cannot return at the top level") + return } if len(s.Results) == 0 && (len(a.fnType.Out) == 0 || a.outVarsNamed) { // Simple case. Simply exit from the function. - a.flow.putTerm(); - a.push(func(v *Thread) { v.pc = returnPC }); - return; + a.flow.putTerm() + a.push(func(v *Thread) { v.pc = returnPC }) + return } - bc := a.enterChild(); - defer bc.exit(); + bc := a.enterChild() + defer bc.exit() // Compile expressions - bad := false; - rs := make([]*expr, len(s.Results)); + bad := false + rs := make([]*expr, len(s.Results)) for i, re := range s.Results { - rs[i] = a.compileExpr(bc.block, false, re); + rs[i] = a.compileExpr(bc.block, false, re) if rs[i] == nil { bad = true } @@ -835,38 +835,38 @@ func (a *stmtCompiler) compileReturnStmt(s *ast.ReturnStmt) { // is a single call to a multi-valued function, the values // returned from the called function will be returned from // this one. - assign := a.compileAssign(s.Pos(), bc.block, NewMultiType(a.fnType.Out), rs, "return", "value"); + assign := a.compileAssign(s.Pos(), bc.block, NewMultiType(a.fnType.Out), rs, "return", "value") // XXX(Spec) "The result types of the current function and the // called function must match." Match is fuzzy. It should // say that they must be assignment compatible. // Compile - start := len(a.fnType.In); - nout := len(a.fnType.Out); - a.flow.putTerm(); + start := len(a.fnType.In) + nout := len(a.fnType.Out) + a.flow.putTerm() a.push(func(t *Thread) { - assign(multiV(t.f.Vars[start:start+nout]), t); - t.pc = returnPC; - }); + assign(multiV(t.f.Vars[start:start+nout]), t) + t.pc = returnPC + }) } func (a *stmtCompiler) findLexicalLabel(name *ast.Ident, pred func(*label) bool, errOp, errCtx string) *label { - bc := a.blockCompiler; + bc := a.blockCompiler for ; bc != nil; bc = bc.parent { if bc.label == nil { continue } - l := bc.label; + l := bc.label if name == nil && pred(l) { return l } if name != nil && l.name == name.Value { if !pred(l) { - a.diag("cannot %s to %s %s", errOp, l.desc, l.name); - return nil; + a.diag("cannot %s to %s %s", errOp, l.desc, l.name) + return nil } - return l; + return l } } if name == nil { @@ -874,54 +874,54 @@ func (a *stmtCompiler) findLexicalLabel(name *ast.Ident, pred func(*label) bool, } else { a.diag("%s label %s not defined", errOp, name.Value) } - return nil; + return nil } func (a *stmtCompiler) compileBranchStmt(s *ast.BranchStmt) { - var pc *uint; + var pc *uint switch s.Tok { case token.BREAK: - l := a.findLexicalLabel(s.Label, func(l *label) bool { return l.breakPC != nil }, "break", "for loop, switch, or select"); + l := a.findLexicalLabel(s.Label, func(l *label) bool { return l.breakPC != nil }, "break", "for loop, switch, or select") if l == nil { return } - pc = l.breakPC; + pc = l.breakPC case token.CONTINUE: - l := a.findLexicalLabel(s.Label, func(l *label) bool { return l.continuePC != nil }, "continue", "for loop"); + l := a.findLexicalLabel(s.Label, func(l *label) bool { return l.continuePC != nil }, "continue", "for loop") if l == nil { return } - pc = l.continuePC; + pc = l.continuePC case token.GOTO: - l, ok := a.labels[s.Label.Value]; + l, ok := a.labels[s.Label.Value] if !ok { - pc := badPC; - l = &label{name: s.Label.Value, desc: "unresolved label", gotoPC: &pc, used: s.Pos()}; - a.labels[l.name] = l; + pc := badPC + l = &label{name: s.Label.Value, desc: "unresolved label", gotoPC: &pc, used: s.Pos()} + a.labels[l.name] = l } - pc = l.gotoPC; - a.flow.putGoto(s.Pos(), l.name, a.block); + pc = l.gotoPC + a.flow.putGoto(s.Pos(), l.name, a.block) case token.FALLTHROUGH: - a.diag("fallthrough outside switch"); - return; + a.diag("fallthrough outside switch") + return default: log.Crash("Unexpected branch token %v", s.Tok) } - a.flow.put1(false, pc); - a.push(func(v *Thread) { v.pc = *pc }); + a.flow.put1(false, pc) + a.push(func(v *Thread) { v.pc = *pc }) } func (a *stmtCompiler) compileBlockStmt(s *ast.BlockStmt) { - bc := a.enterChild(); - bc.compileStmts(s); - bc.exit(); + bc := a.enterChild() + bc.compileStmts(s) + bc.exit() } func (a *stmtCompiler) compileIfStmt(s *ast.IfStmt) { @@ -935,59 +935,59 @@ func (a *stmtCompiler) compileIfStmt(s *ast.IfStmt) { // says when there's a non-block else clause, because that // else claus has to execute in a scope that is *not* the // surrounding scope. - bc := a.enterChild(); - defer bc.exit(); + bc := a.enterChild() + defer bc.exit() // Compile init statement, if any if s.Init != nil { bc.compileStmt(s.Init) } - elsePC := badPC; - endPC := badPC; + elsePC := badPC + endPC := badPC // Compile condition, if any. If there is no condition, we // fall through to the body. if s.Cond != nil { - e := bc.compileExpr(bc.block, false, s.Cond); + e := bc.compileExpr(bc.block, false, s.Cond) switch { case e == nil: // Error reported by compileExpr case !e.t.isBoolean(): e.diag("'if' condition must be boolean\n\t%v", e.t) default: - eval := e.asBool(); - a.flow.put1(true, &elsePC); + eval := e.asBool() + a.flow.put1(true, &elsePC) a.push(func(t *Thread) { if !eval(t) { t.pc = elsePC } - }); + }) } } // Compile body - body := bc.enterChild(); - body.compileStmts(s.Body); - body.exit(); + body := bc.enterChild() + body.compileStmts(s.Body) + body.exit() // Compile else if s.Else != nil { // Skip over else if we executed the body - a.flow.put1(false, &endPC); - a.push(func(v *Thread) { v.pc = endPC }); - elsePC = a.nextPC(); - bc.compileStmt(s.Else); + a.flow.put1(false, &endPC) + a.push(func(v *Thread) { v.pc = endPC }) + elsePC = a.nextPC() + bc.compileStmt(s.Else) } else { elsePC = a.nextPC() } - endPC = a.nextPC(); + endPC = a.nextPC() } func (a *stmtCompiler) compileSwitchStmt(s *ast.SwitchStmt) { // Create implicit scope around switch - bc := a.enterChild(); - defer bc.exit(); + bc := a.enterChild() + defer bc.exit() // Compile init statement, if any if s.Init != nil { @@ -995,46 +995,46 @@ func (a *stmtCompiler) compileSwitchStmt(s *ast.SwitchStmt) { } // Compile condition, if any, and extract its effects - var cond *expr; - condbc := bc.enterChild(); + var cond *expr + condbc := bc.enterChild() if s.Tag != nil { - e := condbc.compileExpr(condbc.block, false, s.Tag); + e := condbc.compileExpr(condbc.block, false, s.Tag) if e != nil { - var effect func(*Thread); - effect, cond = e.extractEffect(condbc.block, "switch"); - a.push(effect); + var effect func(*Thread) + effect, cond = e.extractEffect(condbc.block, "switch") + a.push(effect) } } // Count cases - ncases := 0; - hasDefault := false; + ncases := 0 + hasDefault := false for _, c := range s.Body.List { - clause, ok := c.(*ast.CaseClause); + clause, ok := c.(*ast.CaseClause) if !ok { - a.diagAt(clause, "switch statement must contain case clauses"); - continue; + a.diagAt(clause, "switch statement must contain case clauses") + continue } if clause.Values == nil { if hasDefault { a.diagAt(clause, "switch statement contains more than one default case") } - hasDefault = true; + hasDefault = true } else { ncases += len(clause.Values) } } // Compile case expressions - cases := make([]func(*Thread) bool, ncases); - i := 0; + cases := make([]func(*Thread) bool, ncases) + i := 0 for _, c := range s.Body.List { - clause, ok := c.(*ast.CaseClause); + clause, ok := c.(*ast.CaseClause) if !ok { continue } for _, v := range clause.Values { - e := condbc.compileExpr(condbc.block, false, v); + e := condbc.compileExpr(condbc.block, false, v) switch { case e == nil: // Error reported by compileExpr @@ -1045,45 +1045,45 @@ func (a *stmtCompiler) compileSwitchStmt(s *ast.SwitchStmt) { case cond != nil: // Create comparison // TOOD(austin) This produces bad error messages - compare := e.compileBinaryExpr(token.EQL, cond, e); + compare := e.compileBinaryExpr(token.EQL, cond, e) if compare != nil { cases[i] = compare.asBool() } } - i++; + i++ } } // Emit condition - casePCs := make([]*uint, ncases+1); - endPC := badPC; + casePCs := make([]*uint, ncases+1) + endPC := badPC - a.flow.put(false, false, casePCs); + a.flow.put(false, false, casePCs) a.push(func(t *Thread) { for i, c := range cases { if c(t) { - t.pc = *casePCs[i]; - return; + t.pc = *casePCs[i] + return } } - t.pc = *casePCs[ncases]; - }); - condbc.exit(); + t.pc = *casePCs[ncases] + }) + condbc.exit() // Compile cases - i = 0; + i = 0 for _, c := range s.Body.List { - clause, ok := c.(*ast.CaseClause); + clause, ok := c.(*ast.CaseClause) if !ok { continue } // Save jump PC's - pc := a.nextPC(); + pc := a.nextPC() if clause.Values != nil { for _ = range clause.Values { - casePCs[i] = &pc; - i++; + casePCs[i] = &pc + i++ } } else { // Default clause @@ -1091,7 +1091,7 @@ func (a *stmtCompiler) compileSwitchStmt(s *ast.SwitchStmt) { } // Compile body - fall := false; + fall := false for j, s := range clause.Body { if br, ok := s.(*ast.BranchStmt); ok && br.Tok == token.FALLTHROUGH { // println("Found fallthrough"); @@ -1104,24 +1104,24 @@ func (a *stmtCompiler) compileSwitchStmt(s *ast.SwitchStmt) { // empty blocks to be empty // statements. if _, ok := s2.(*ast.EmptyStmt); !ok { - a.diagAt(s, "fallthrough statement must be final statement in case"); - break; + a.diagAt(s, "fallthrough statement must be final statement in case") + break } } - fall = true; + fall = true } else { bc.compileStmt(s) } } // Jump out of switch, unless there was a fallthrough if !fall { - a.flow.put1(false, &endPC); - a.push(func(v *Thread) { v.pc = endPC }); + a.flow.put1(false, &endPC) + a.push(func(v *Thread) { v.pc = endPC }) } } // Get end PC - endPC = a.nextPC(); + endPC = a.nextPC() if !hasDefault { casePCs[ncases] = &endPC } @@ -1129,40 +1129,40 @@ func (a *stmtCompiler) compileSwitchStmt(s *ast.SwitchStmt) { func (a *stmtCompiler) compileForStmt(s *ast.ForStmt) { // Wrap the entire for in a block. - bc := a.enterChild(); - defer bc.exit(); + bc := a.enterChild() + defer bc.exit() // Compile init statement, if any if s.Init != nil { bc.compileStmt(s.Init) } - bodyPC := badPC; - postPC := badPC; - checkPC := badPC; - endPC := badPC; + bodyPC := badPC + postPC := badPC + checkPC := badPC + endPC := badPC // Jump to condition check. We generate slightly less code by // placing the condition check after the body. - a.flow.put1(false, &checkPC); - a.push(func(v *Thread) { v.pc = checkPC }); + a.flow.put1(false, &checkPC) + a.push(func(v *Thread) { v.pc = checkPC }) // Compile body - bodyPC = a.nextPC(); - body := bc.enterChild(); + bodyPC = a.nextPC() + body := bc.enterChild() if a.stmtLabel != nil { body.label = a.stmtLabel } else { body.label = &label{resolved: s.Pos()} } - body.label.desc = "for loop"; - body.label.breakPC = &endPC; - body.label.continuePC = &postPC; - body.compileStmts(s.Body); - body.exit(); + body.label.desc = "for loop" + body.label.breakPC = &endPC + body.label.continuePC = &postPC + body.compileStmts(s.Body) + body.exit() // Compile post, if any - postPC = a.nextPC(); + postPC = a.nextPC() if s.Post != nil { // TODO(austin) Does the parser disallow short // declarations in s.Post? @@ -1170,30 +1170,30 @@ func (a *stmtCompiler) compileForStmt(s *ast.ForStmt) { } // Compile condition check, if any - checkPC = a.nextPC(); + checkPC = a.nextPC() if s.Cond == nil { // If the condition is absent, it is equivalent to true. - a.flow.put1(false, &bodyPC); - a.push(func(v *Thread) { v.pc = bodyPC }); + a.flow.put1(false, &bodyPC) + a.push(func(v *Thread) { v.pc = bodyPC }) } else { - e := bc.compileExpr(bc.block, false, s.Cond); + e := bc.compileExpr(bc.block, false, s.Cond) switch { case e == nil: // Error reported by compileExpr case !e.t.isBoolean(): a.diag("'for' condition must be boolean\n\t%v", e.t) default: - eval := e.asBool(); - a.flow.put1(true, &bodyPC); + eval := e.asBool() + a.flow.put1(true, &bodyPC) a.push(func(t *Thread) { if eval(t) { t.pc = bodyPC } - }); + }) } } - endPC = a.nextPC(); + endPC = a.nextPC() } /* @@ -1201,8 +1201,8 @@ func (a *stmtCompiler) compileForStmt(s *ast.ForStmt) { */ func (a *blockCompiler) compileStmt(s ast.Stmt) { - sc := &stmtCompiler{a, s.Pos(), nil}; - sc.compile(s); + sc := &stmtCompiler{a, s.Pos(), nil} + sc.compile(s) } func (a *blockCompiler) compileStmts(block *ast.BlockStmt) { @@ -1212,15 +1212,15 @@ func (a *blockCompiler) compileStmts(block *ast.BlockStmt) { } func (a *blockCompiler) enterChild() *blockCompiler { - block := a.block.enterChild(); + block := a.block.enterChild() return &blockCompiler{ funcCompiler: a.funcCompiler, block: block, parent: a, - }; + } } -func (a *blockCompiler) exit() { a.block.exit() } +func (a *blockCompiler) exit() { a.block.exit() } /* * Function compiler @@ -1231,8 +1231,8 @@ func (a *compiler) compileFunc(b *block, decl *FuncDecl, body *ast.BlockStmt) (f // // The scope of a parameter or result is the body of the // corresponding function. - bodyScope := b.ChildScope(); - defer bodyScope.exit(); + bodyScope := b.ChildScope() + defer bodyScope.exit() for i, t := range decl.Type.In { if decl.InNames[i] != nil { bodyScope.DefineVar(decl.InNames[i].Value, decl.InNames[i].Pos(), t) @@ -1249,7 +1249,7 @@ func (a *compiler) compileFunc(b *block, decl *FuncDecl, body *ast.BlockStmt) (f } // Create block context - cb := newCodeBuf(); + cb := newCodeBuf() fc := &funcCompiler{ compiler: a, fnType: decl.Type, @@ -1257,16 +1257,16 @@ func (a *compiler) compileFunc(b *block, decl *FuncDecl, body *ast.BlockStmt) (f codeBuf: cb, flow: newFlowBuf(cb), labels: make(map[string]*label), - }; + } bc := &blockCompiler{ funcCompiler: fc, block: bodyScope.block, - }; + } // Compile body - nerr := a.numError(); - bc.compileStmts(body); - fc.checkLabels(); + nerr := a.numError() + bc.compileStmts(body) + fc.checkLabels() if nerr != a.numError() { return nil } @@ -1275,19 +1275,19 @@ func (a *compiler) compileFunc(b *block, decl *FuncDecl, body *ast.BlockStmt) (f // this if there were no errors compiling the body. if len(decl.Type.Out) > 0 && fc.flow.reachesEnd(0) { // XXX(Spec) Not specified. - a.diagAt(&body.Rbrace, "function ends without a return statement"); - return nil; + a.diagAt(&body.Rbrace, "function ends without a return statement") + return nil } - code := fc.get(); - maxVars := bodyScope.maxVars; - return func(t *Thread) Func { return &evalFunc{t.f, maxVars, code} }; + code := fc.get() + maxVars := bodyScope.maxVars + return func(t *Thread) Func { return &evalFunc{t.f, maxVars, code} } } // Checks that labels were resolved and that all jumps obey scoping // rules. Reports an error and set fc.err if any check fails. func (a *funcCompiler) checkLabels() { - nerr := a.numError(); + nerr := a.numError() for _, l := range a.labels { if !l.resolved.IsValid() { a.diagAt(&l.used, "label %s not defined", l.name) @@ -1301,5 +1301,5 @@ func (a *funcCompiler) checkLabels() { // Executing the "goto" statement must not cause any variables // to come into scope that were not already in scope at the // point of the goto. - a.flow.gotosObeyScopes(a.compiler); + a.flow.gotosObeyScopes(a.compiler) } diff --git a/src/pkg/exp/eval/stmt_test.go b/src/pkg/exp/eval/stmt_test.go index 0adea1e62..57c3dd7e9 100644 --- a/src/pkg/exp/eval/stmt_test.go +++ b/src/pkg/exp/eval/stmt_test.go @@ -344,4 +344,4 @@ var stmtTests = []test{ Run2("func f1(){}", "f1()"), } -func TestStmt(t *testing.T) { runTests(t, "stmtTests", stmtTests) } +func TestStmt(t *testing.T) { runTests(t, "stmtTests", stmtTests) } diff --git a/src/pkg/exp/eval/type.go b/src/pkg/exp/eval/type.go index 84a586178..d8f00e93c 100644 --- a/src/pkg/exp/eval/type.go +++ b/src/pkg/exp/eval/type.go @@ -5,13 +5,13 @@ package eval import ( - "bignum"; - "go/ast"; - "go/token"; - "log"; - "reflect"; - "sort"; - "unsafe"; // For Sizeof + "bignum" + "go/ast" + "go/token" + "log" + "reflect" + "sort" + "unsafe" // For Sizeof ) @@ -36,33 +36,33 @@ type Type interface { // compatible if their definitions are conversion compatible. // // TODO(austin) Deal with recursive types - compat(o Type, conv bool) bool; + compat(o Type, conv bool) bool // lit returns this type's literal. If this is a named type, // this is the unnamed underlying type. Otherwise, this is an // identity operation. - lit() Type; + lit() Type // isBoolean returns true if this is a boolean type. - isBoolean() bool; + isBoolean() bool // isInteger returns true if this is an integer type. - isInteger() bool; + isInteger() bool // isFloat returns true if this is a floating type. - isFloat() bool; + isFloat() bool // isIdeal returns true if this is an ideal int or float. - isIdeal() bool; + isIdeal() bool // Zero returns a new zero value of this type. - Zero() Value; + Zero() Value // String returns the string representation of this type. - String() string; + String() string // The position where this type was defined, if any. - Pos() token.Position; + Pos() token.Position } type BoundedType interface { - Type; + Type // minVal returns the smallest value of this type. - minVal() *bignum.Rational; + minVal() *bignum.Rational // maxVal returns the largest value of this type. - maxVal() *bignum.Rational; + maxVal() *bignum.Rational } var universePos = token.Position{"<universe>", 0, 0, 0} @@ -72,30 +72,30 @@ var universePos = token.Position{"<universe>", 0, 0, 0} */ type typeArrayMapEntry struct { - key []Type; - v interface{}; - next *typeArrayMapEntry; + key []Type + v interface{} + next *typeArrayMapEntry } type typeArrayMap map[uintptr]*typeArrayMapEntry func hashTypeArray(key []Type) uintptr { - hash := uintptr(0); + hash := uintptr(0) for _, t := range key { - hash = hash * 33; + hash = hash * 33 if t == nil { continue } - addr := reflect.NewValue(t).(*reflect.PtrValue).Get(); - hash ^= addr; + addr := reflect.NewValue(t).(*reflect.PtrValue).Get() + hash ^= addr } - return hash; + return hash } -func newTypeArrayMap() typeArrayMap { return make(map[uintptr]*typeArrayMapEntry) } +func newTypeArrayMap() typeArrayMap { return make(map[uintptr]*typeArrayMapEntry) } func (m typeArrayMap) Get(key []Type) interface{} { - ent, ok := m[hashTypeArray(key)]; + ent, ok := m[hashTypeArray(key)] if !ok { return nil } @@ -111,19 +111,19 @@ nextEnt: } } // Found it - return ent.v; + return ent.v } - return nil; + return nil } func (m typeArrayMap) Put(key []Type, v interface{}) interface{} { - hash := hashTypeArray(key); - ent, _ := m[hash]; + hash := hashTypeArray(key) + ent, _ := m[hash] - new := &typeArrayMapEntry{key, v, ent}; - m[hash] = new; - return v; + new := &typeArrayMapEntry{key, v, ent} + m[hash] = new + return v } /* @@ -132,34 +132,34 @@ func (m typeArrayMap) Put(key []Type, v interface{}) interface{} { type commonType struct{} -func (commonType) isBoolean() bool { return false } +func (commonType) isBoolean() bool { return false } -func (commonType) isInteger() bool { return false } +func (commonType) isInteger() bool { return false } -func (commonType) isFloat() bool { return false } +func (commonType) isFloat() bool { return false } -func (commonType) isIdeal() bool { return false } +func (commonType) isIdeal() bool { return false } -func (commonType) Pos() token.Position { return token.Position{} } +func (commonType) Pos() token.Position { return token.Position{} } /* * Bool */ type boolType struct { - commonType; + commonType } var BoolType = universe.DefineType("bool", universePos, &boolType{}) func (t *boolType) compat(o Type, conv bool) bool { - _, ok := o.lit().(*boolType); - return ok; + _, ok := o.lit().(*boolType) + return ok } -func (t *boolType) lit() Type { return t } +func (t *boolType) lit() Type { return t } -func (t *boolType) isBoolean() bool { return true } +func (t *boolType) isBoolean() bool { return true } func (boolType) String() string { // Use angle brackets as a convention for printing the @@ -169,8 +169,8 @@ func (boolType) String() string { } func (t *boolType) Zero() Value { - res := boolV(false); - return &res; + res := boolV(false) + return &res } /* @@ -178,66 +178,66 @@ func (t *boolType) Zero() Value { */ type uintType struct { - commonType; + commonType // 0 for architecture-dependent types - Bits uint; + Bits uint // true for uintptr, false for all others - Ptr bool; - name string; + Ptr bool + name string } var ( - Uint8Type = universe.DefineType("uint8", universePos, &uintType{commonType{}, 8, false, "uint8"}); - Uint16Type = universe.DefineType("uint16", universePos, &uintType{commonType{}, 16, false, "uint16"}); - Uint32Type = universe.DefineType("uint32", universePos, &uintType{commonType{}, 32, false, "uint32"}); - Uint64Type = universe.DefineType("uint64", universePos, &uintType{commonType{}, 64, false, "uint64"}); + Uint8Type = universe.DefineType("uint8", universePos, &uintType{commonType{}, 8, false, "uint8"}) + Uint16Type = universe.DefineType("uint16", universePos, &uintType{commonType{}, 16, false, "uint16"}) + Uint32Type = universe.DefineType("uint32", universePos, &uintType{commonType{}, 32, false, "uint32"}) + Uint64Type = universe.DefineType("uint64", universePos, &uintType{commonType{}, 64, false, "uint64"}) - UintType = universe.DefineType("uint", universePos, &uintType{commonType{}, 0, false, "uint"}); - UintptrType = universe.DefineType("uintptr", universePos, &uintType{commonType{}, 0, true, "uintptr"}); + UintType = universe.DefineType("uint", universePos, &uintType{commonType{}, 0, false, "uint"}) + UintptrType = universe.DefineType("uintptr", universePos, &uintType{commonType{}, 0, true, "uintptr"}) ) func (t *uintType) compat(o Type, conv bool) bool { - t2, ok := o.lit().(*uintType); - return ok && t == t2; + t2, ok := o.lit().(*uintType) + return ok && t == t2 } -func (t *uintType) lit() Type { return t } +func (t *uintType) lit() Type { return t } -func (t *uintType) isInteger() bool { return true } +func (t *uintType) isInteger() bool { return true } -func (t *uintType) String() string { return "<" + t.name + ">" } +func (t *uintType) String() string { return "<" + t.name + ">" } func (t *uintType) Zero() Value { switch t.Bits { case 0: if t.Ptr { - res := uintptrV(0); - return &res; + res := uintptrV(0) + return &res } else { - res := uintV(0); - return &res; + res := uintV(0) + return &res } case 8: - res := uint8V(0); - return &res; + res := uint8V(0) + return &res case 16: - res := uint16V(0); - return &res; + res := uint16V(0) + return &res case 32: - res := uint32V(0); - return &res; + res := uint32V(0) + return &res case 64: - res := uint64V(0); - return &res; + res := uint64V(0) + return &res } - panic("unexpected uint bit count: ", t.Bits); + panic("unexpected uint bit count: ", t.Bits) } -func (t *uintType) minVal() *bignum.Rational { return bignum.Rat(0, 1) } +func (t *uintType) minVal() *bignum.Rational { return bignum.Rat(0, 1) } func (t *uintType) maxVal() *bignum.Rational { - bits := t.Bits; + bits := t.Bits if bits == 0 { if t.Ptr { bits = uint(8 * unsafe.Sizeof(uintptr(0))) @@ -245,7 +245,7 @@ func (t *uintType) maxVal() *bignum.Rational { bits = uint(8 * unsafe.Sizeof(uint(0))) } } - return bignum.MakeRat(bignum.Int(1).Shl(bits).Add(bignum.Int(-1)), bignum.Nat(1)); + return bignum.MakeRat(bignum.Int(1).Shl(bits).Add(bignum.Int(-1)), bignum.Nat(1)) } /* @@ -253,7 +253,7 @@ func (t *uintType) maxVal() *bignum.Rational { */ type intType struct { - commonType; + commonType // XXX(Spec) Numeric types: "There is also a set of // architecture-independent basic numeric types whose size @@ -261,66 +261,66 @@ type intType struct { // architecture-dependent? // 0 for architecture-dependent types - Bits uint; - name string; + Bits uint + name string } var ( - Int8Type = universe.DefineType("int8", universePos, &intType{commonType{}, 8, "int8"}); - Int16Type = universe.DefineType("int16", universePos, &intType{commonType{}, 16, "int16"}); - Int32Type = universe.DefineType("int32", universePos, &intType{commonType{}, 32, "int32"}); - Int64Type = universe.DefineType("int64", universePos, &intType{commonType{}, 64, "int64"}); + Int8Type = universe.DefineType("int8", universePos, &intType{commonType{}, 8, "int8"}) + Int16Type = universe.DefineType("int16", universePos, &intType{commonType{}, 16, "int16"}) + Int32Type = universe.DefineType("int32", universePos, &intType{commonType{}, 32, "int32"}) + Int64Type = universe.DefineType("int64", universePos, &intType{commonType{}, 64, "int64"}) - IntType = universe.DefineType("int", universePos, &intType{commonType{}, 0, "int"}); + IntType = universe.DefineType("int", universePos, &intType{commonType{}, 0, "int"}) ) func (t *intType) compat(o Type, conv bool) bool { - t2, ok := o.lit().(*intType); - return ok && t == t2; + t2, ok := o.lit().(*intType) + return ok && t == t2 } -func (t *intType) lit() Type { return t } +func (t *intType) lit() Type { return t } -func (t *intType) isInteger() bool { return true } +func (t *intType) isInteger() bool { return true } -func (t *intType) String() string { return "<" + t.name + ">" } +func (t *intType) String() string { return "<" + t.name + ">" } func (t *intType) Zero() Value { switch t.Bits { case 8: - res := int8V(0); - return &res; + res := int8V(0) + return &res case 16: - res := int16V(0); - return &res; + res := int16V(0) + return &res case 32: - res := int32V(0); - return &res; + res := int32V(0) + return &res case 64: - res := int64V(0); - return &res; + res := int64V(0) + return &res case 0: - res := intV(0); - return &res; + res := intV(0) + return &res } - panic("unexpected int bit count: ", t.Bits); + panic("unexpected int bit count: ", t.Bits) } func (t *intType) minVal() *bignum.Rational { - bits := t.Bits; + bits := t.Bits if bits == 0 { bits = uint(8 * unsafe.Sizeof(int(0))) } - return bignum.MakeRat(bignum.Int(-1).Shl(bits-1), bignum.Nat(1)); + return bignum.MakeRat(bignum.Int(-1).Shl(bits-1), bignum.Nat(1)) } func (t *intType) maxVal() *bignum.Rational { - bits := t.Bits; + bits := t.Bits if bits == 0 { bits = uint(8 * unsafe.Sizeof(int(0))) } - return bignum.MakeRat(bignum.Int(1).Shl(bits-1).Add(bignum.Int(-1)), bignum.Nat(1)); + return bignum.MakeRat(bignum.Int(1).Shl(bits-1).Add(bignum.Int(-1)), bignum.Nat(1)) } /* @@ -328,69 +328,69 @@ func (t *intType) maxVal() *bignum.Rational { */ type idealIntType struct { - commonType; + commonType } var IdealIntType Type = &idealIntType{} func (t *idealIntType) compat(o Type, conv bool) bool { - _, ok := o.lit().(*idealIntType); - return ok; + _, ok := o.lit().(*idealIntType) + return ok } -func (t *idealIntType) lit() Type { return t } +func (t *idealIntType) lit() Type { return t } -func (t *idealIntType) isInteger() bool { return true } +func (t *idealIntType) isInteger() bool { return true } -func (t *idealIntType) isIdeal() bool { return true } +func (t *idealIntType) isIdeal() bool { return true } -func (t *idealIntType) String() string { return "ideal integer" } +func (t *idealIntType) String() string { return "ideal integer" } -func (t *idealIntType) Zero() Value { return &idealIntV{bignum.Int(0)} } +func (t *idealIntType) Zero() Value { return &idealIntV{bignum.Int(0)} } /* * Float */ type floatType struct { - commonType; + commonType // 0 for architecture-dependent type - Bits uint; + Bits uint - name string; + name string } var ( - Float32Type = universe.DefineType("float32", universePos, &floatType{commonType{}, 32, "float32"}); - Float64Type = universe.DefineType("float64", universePos, &floatType{commonType{}, 64, "float64"}); - FloatType = universe.DefineType("float", universePos, &floatType{commonType{}, 0, "float"}); + Float32Type = universe.DefineType("float32", universePos, &floatType{commonType{}, 32, "float32"}) + Float64Type = universe.DefineType("float64", universePos, &floatType{commonType{}, 64, "float64"}) + FloatType = universe.DefineType("float", universePos, &floatType{commonType{}, 0, "float"}) ) func (t *floatType) compat(o Type, conv bool) bool { - t2, ok := o.lit().(*floatType); - return ok && t == t2; + t2, ok := o.lit().(*floatType) + return ok && t == t2 } -func (t *floatType) lit() Type { return t } +func (t *floatType) lit() Type { return t } -func (t *floatType) isFloat() bool { return true } +func (t *floatType) isFloat() bool { return true } -func (t *floatType) String() string { return "<" + t.name + ">" } +func (t *floatType) String() string { return "<" + t.name + ">" } func (t *floatType) Zero() Value { switch t.Bits { case 32: - res := float32V(0); - return &res; + res := float32V(0) + return &res case 64: - res := float64V(0); - return &res; + res := float64V(0) + return &res case 0: - res := floatV(0); - return &res; + res := floatV(0) + return &res } - panic("unexpected float bit count: ", t.Bits); + panic("unexpected float bit count: ", t.Bits) } var maxFloat32Val = bignum.MakeRat(bignum.Int(0xffffff).Shl(127-23), bignum.Nat(1)) @@ -399,7 +399,7 @@ var minFloat32Val = maxFloat32Val.Neg() var minFloat64Val = maxFloat64Val.Neg() func (t *floatType) minVal() *bignum.Rational { - bits := t.Bits; + bits := t.Bits if bits == 0 { bits = uint(8 * unsafe.Sizeof(float(0))) } @@ -409,12 +409,12 @@ func (t *floatType) minVal() *bignum.Rational { case 64: return minFloat64Val } - log.Crashf("unexpected floating point bit count: %d", bits); - panic(); + log.Crashf("unexpected floating point bit count: %d", bits) + panic() } func (t *floatType) maxVal() *bignum.Rational { - bits := t.Bits; + bits := t.Bits if bits == 0 { bits = uint(8 * unsafe.Sizeof(float(0))) } @@ -424,8 +424,8 @@ func (t *floatType) maxVal() *bignum.Rational { case 64: return maxFloat64Val } - log.Crashf("unexpected floating point bit count: %d", bits); - panic(); + log.Crashf("unexpected floating point bit count: %d", bits) + panic() } /* @@ -433,48 +433,48 @@ func (t *floatType) maxVal() *bignum.Rational { */ type idealFloatType struct { - commonType; + commonType } var IdealFloatType Type = &idealFloatType{} func (t *idealFloatType) compat(o Type, conv bool) bool { - _, ok := o.lit().(*idealFloatType); - return ok; + _, ok := o.lit().(*idealFloatType) + return ok } -func (t *idealFloatType) lit() Type { return t } +func (t *idealFloatType) lit() Type { return t } -func (t *idealFloatType) isFloat() bool { return true } +func (t *idealFloatType) isFloat() bool { return true } -func (t *idealFloatType) isIdeal() bool { return true } +func (t *idealFloatType) isIdeal() bool { return true } -func (t *idealFloatType) String() string { return "ideal float" } +func (t *idealFloatType) String() string { return "ideal float" } -func (t *idealFloatType) Zero() Value { return &idealFloatV{bignum.Rat(1, 0)} } +func (t *idealFloatType) Zero() Value { return &idealFloatV{bignum.Rat(1, 0)} } /* * String */ type stringType struct { - commonType; + commonType } var StringType = universe.DefineType("string", universePos, &stringType{}) func (t *stringType) compat(o Type, conv bool) bool { - _, ok := o.lit().(*stringType); - return ok; + _, ok := o.lit().(*stringType) + return ok } -func (t *stringType) lit() Type { return t } +func (t *stringType) lit() Type { return t } -func (t *stringType) String() string { return "<string>" } +func (t *stringType) String() string { return "<string>" } func (t *stringType) Zero() Value { - res := stringV(""); - return &res; + res := stringV("") + return &res } /* @@ -482,9 +482,9 @@ func (t *stringType) Zero() Value { */ type ArrayType struct { - commonType; - Len int64; - Elem Type; + commonType + Len int64 + Elem Type } var arrayTypes = make(map[int64]map[Type]*ArrayType) @@ -493,33 +493,33 @@ var arrayTypes = make(map[int64]map[Type]*ArrayType) // and the same array length. func NewArrayType(len int64, elem Type) *ArrayType { - ts, ok := arrayTypes[len]; + ts, ok := arrayTypes[len] if !ok { - ts = make(map[Type]*ArrayType); - arrayTypes[len] = ts; + ts = make(map[Type]*ArrayType) + arrayTypes[len] = ts } - t, ok := ts[elem]; + t, ok := ts[elem] if !ok { - t = &ArrayType{commonType{}, len, elem}; - ts[elem] = t; + t = &ArrayType{commonType{}, len, elem} + ts[elem] = t } - return t; + return t } func (t *ArrayType) compat(o Type, conv bool) bool { - t2, ok := o.lit().(*ArrayType); + t2, ok := o.lit().(*ArrayType) if !ok { return false } - return t.Len == t2.Len && t.Elem.compat(t2.Elem, conv); + return t.Len == t2.Len && t.Elem.compat(t2.Elem, conv) } -func (t *ArrayType) lit() Type { return t } +func (t *ArrayType) lit() Type { return t } -func (t *ArrayType) String() string { return "[]" + t.Elem.String() } +func (t *ArrayType) String() string { return "[]" + t.Elem.String() } func (t *ArrayType) Zero() Value { - res := arrayV(make([]Value, t.Len)); + res := arrayV(make([]Value, t.Len)) // TODO(austin) It's unfortunate that each element is // separately heap allocated. We could add ZeroArray to // everything, though that doesn't help with multidimensional @@ -528,7 +528,7 @@ func (t *ArrayType) Zero() Value { for i := int64(0); i < t.Len; i++ { res[i] = t.Elem.Zero() } - return &res; + return &res } /* @@ -536,14 +536,14 @@ func (t *ArrayType) Zero() Value { */ type StructField struct { - Name string; - Type Type; - Anonymous bool; + Name string + Type Type + Anonymous bool } type StructType struct { - commonType; - Elems []StructField; + commonType + Elems []StructField } var structTypes = newTypeArrayMap() @@ -555,18 +555,18 @@ var structTypes = newTypeArrayMap() func NewStructType(fields []StructField) *StructType { // Start by looking up just the types - fts := make([]Type, len(fields)); + fts := make([]Type, len(fields)) for i, f := range fields { fts[i] = f.Type } - tMapI := structTypes.Get(fts); + tMapI := structTypes.Get(fts) if tMapI == nil { tMapI = structTypes.Put(fts, make(map[string]*StructType)) } - tMap := tMapI.(map[string]*StructType); + tMap := tMapI.(map[string]*StructType) // Construct key for field names - key := ""; + key := "" for _, f := range fields { // XXX(Spec) It's not clear if struct { T } and struct // { T T } are either identical or compatible. The @@ -579,7 +579,7 @@ func NewStructType(fields []StructField) *StructType { if f.Anonymous { key += "!" } - key += f.Name + " "; + key += f.Name + " " } // XXX(Spec) Do the tags also have to be identical for the @@ -587,17 +587,17 @@ func NewStructType(fields []StructField) *StructType { // otherwise, this is the only case where two distinct type // objects can represent identical types. - t, ok := tMap[key]; + t, ok := tMap[key] if !ok { // Create new struct type - t = &StructType{commonType{}, fields}; - tMap[key] = t; + t = &StructType{commonType{}, fields} + tMap[key] = t } - return t; + return t } func (t *StructType) compat(o Type, conv bool) bool { - t2, ok := o.lit().(*StructType); + t2, ok := o.lit().(*StructType) if !ok { return false } @@ -605,7 +605,7 @@ func (t *StructType) compat(o Type, conv bool) bool { return false } for i, e := range t.Elems { - e2 := t2.Elems[i]; + e2 := t2.Elems[i] // XXX(Spec) An anonymous and a non-anonymous field // are neither identical nor compatible. if e.Anonymous != e2.Anonymous || @@ -614,13 +614,13 @@ func (t *StructType) compat(o Type, conv bool) bool { return false } } - return true; + return true } -func (t *StructType) lit() Type { return t } +func (t *StructType) lit() Type { return t } func (t *StructType) String() string { - s := "struct {"; + s := "struct {" for i, f := range t.Elems { if i > 0 { s += "; " @@ -628,17 +628,17 @@ func (t *StructType) String() string { if !f.Anonymous { s += f.Name + " " } - s += f.Type.String(); + s += f.Type.String() } - return s + "}"; + return s + "}" } func (t *StructType) Zero() Value { - res := structV(make([]Value, len(t.Elems))); + res := structV(make([]Value, len(t.Elems))) for i, f := range t.Elems { res[i] = f.Type.Zero() } - return &res; + return &res } /* @@ -646,8 +646,8 @@ func (t *StructType) Zero() Value { */ type PtrType struct { - commonType; - Elem Type; + commonType + Elem Type } var ptrTypes = make(map[Type]*PtrType) @@ -655,39 +655,39 @@ var ptrTypes = make(map[Type]*PtrType) // Two pointer types are identical if they have identical base types. func NewPtrType(elem Type) *PtrType { - t, ok := ptrTypes[elem]; + t, ok := ptrTypes[elem] if !ok { - t = &PtrType{commonType{}, elem}; - ptrTypes[elem] = t; + t = &PtrType{commonType{}, elem} + ptrTypes[elem] = t } - return t; + return t } func (t *PtrType) compat(o Type, conv bool) bool { - t2, ok := o.lit().(*PtrType); + t2, ok := o.lit().(*PtrType) if !ok { return false } - return t.Elem.compat(t2.Elem, conv); + return t.Elem.compat(t2.Elem, conv) } -func (t *PtrType) lit() Type { return t } +func (t *PtrType) lit() Type { return t } -func (t *PtrType) String() string { return "*" + t.Elem.String() } +func (t *PtrType) String() string { return "*" + t.Elem.String() } -func (t *PtrType) Zero() Value { return &ptrV{nil} } +func (t *PtrType) Zero() Value { return &ptrV{nil} } /* * Function */ type FuncType struct { - commonType; + commonType // TODO(austin) Separate receiver Type for methods? - In []Type; - Variadic bool; - Out []Type; - builtin string; + In []Type + Variadic bool + Out []Type + builtin string } var funcTypes = newTypeArrayMap() @@ -695,16 +695,16 @@ var variadicFuncTypes = newTypeArrayMap() // Create singleton function types for magic built-in functions var ( - capType = &FuncType{builtin: "cap"}; - closeType = &FuncType{builtin: "close"}; - closedType = &FuncType{builtin: "closed"}; - lenType = &FuncType{builtin: "len"}; - makeType = &FuncType{builtin: "make"}; - newType = &FuncType{builtin: "new"}; - panicType = &FuncType{builtin: "panic"}; - paniclnType = &FuncType{builtin: "panicln"}; - printType = &FuncType{builtin: "print"}; - printlnType = &FuncType{builtin: "println"}; + capType = &FuncType{builtin: "cap"} + closeType = &FuncType{builtin: "close"} + closedType = &FuncType{builtin: "closed"} + lenType = &FuncType{builtin: "len"} + makeType = &FuncType{builtin: "make"} + newType = &FuncType{builtin: "new"} + panicType = &FuncType{builtin: "panic"} + paniclnType = &FuncType{builtin: "panicln"} + printType = &FuncType{builtin: "print"} + printlnType = &FuncType{builtin: "println"} ) // Two function types are identical if they have the same number of @@ -713,29 +713,29 @@ var ( // type. Parameter and result names are not required to match. func NewFuncType(in []Type, variadic bool, out []Type) *FuncType { - inMap := funcTypes; + inMap := funcTypes if variadic { inMap = variadicFuncTypes } - outMapI := inMap.Get(in); + outMapI := inMap.Get(in) if outMapI == nil { outMapI = inMap.Put(in, newTypeArrayMap()) } - outMap := outMapI.(typeArrayMap); + outMap := outMapI.(typeArrayMap) - tI := outMap.Get(out); + tI := outMap.Get(out) if tI != nil { return tI.(*FuncType) } - t := &FuncType{commonType{}, in, variadic, out, ""}; - outMap.Put(out, t); - return t; + t := &FuncType{commonType{}, in, variadic, out, ""} + outMap.Put(out, t) + return t } func (t *FuncType) compat(o Type, conv bool) bool { - t2, ok := o.lit().(*FuncType); + t2, ok := o.lit().(*FuncType) if !ok { return false } @@ -752,13 +752,13 @@ func (t *FuncType) compat(o Type, conv bool) bool { return false } } - return true; + return true } -func (t *FuncType) lit() Type { return t } +func (t *FuncType) lit() Type { return t } func typeListString(ts []Type, ns []*ast.Ident) string { - s := ""; + s := "" for i, t := range ts { if i > 0 { s += ", " @@ -773,61 +773,61 @@ func typeListString(ts []Type, ns []*ast.Ident) string { s += t.String() } } - return s; + return s } func (t *FuncType) String() string { if t.builtin != "" { return "built-in function " + t.builtin } - args := typeListString(t.In, nil); + args := typeListString(t.In, nil) if t.Variadic { if len(args) > 0 { args += ", " } - args += "..."; + args += "..." } - s := "func(" + args + ")"; + s := "func(" + args + ")" if len(t.Out) > 0 { s += " (" + typeListString(t.Out, nil) + ")" } - return s; + return s } -func (t *FuncType) Zero() Value { return &funcV{nil} } +func (t *FuncType) Zero() Value { return &funcV{nil} } type FuncDecl struct { - Type *FuncType; - Name *ast.Ident; // nil for function literals + Type *FuncType + Name *ast.Ident // nil for function literals // InNames will be one longer than Type.In if this function is // variadic. - InNames []*ast.Ident; - OutNames []*ast.Ident; + InNames []*ast.Ident + OutNames []*ast.Ident } func (t *FuncDecl) String() string { - s := "func"; + s := "func" if t.Name != nil { s += " " + t.Name.Value } - s += funcTypeString(t.Type, t.InNames, t.OutNames); - return s; + s += funcTypeString(t.Type, t.InNames, t.OutNames) + return s } func funcTypeString(ft *FuncType, ins []*ast.Ident, outs []*ast.Ident) string { - s := "("; - s += typeListString(ft.In, ins); + s := "(" + s += typeListString(ft.In, ins) if ft.Variadic { if len(ft.In) > 0 { s += ", " } - s += "..."; + s += "..." } - s += ")"; + s += ")" if len(ft.Out) > 0 { s += " (" + typeListString(ft.Out, outs) + ")" } - return s; + return s } /* @@ -839,76 +839,76 @@ func funcTypeString(ft *FuncType, ins []*ast.Ident, outs []*ast.Ident) string { // interfaces are. type InterfaceType struct { - commonType; + commonType // TODO(austin) This should be a map from names to // *FuncType's. We only need the sorted list for generating // the type map key. It's detrimental for everything else. - methods []IMethod; + methods []IMethod } type IMethod struct { - Name string; - Type *FuncType; + Name string + Type *FuncType } var interfaceTypes = newTypeArrayMap() func NewInterfaceType(methods []IMethod, embeds []*InterfaceType) *InterfaceType { // Count methods of embedded interfaces - nMethods := len(methods); + nMethods := len(methods) for _, e := range embeds { nMethods += len(e.methods) } // Combine methods - allMethods := make([]IMethod, nMethods); + allMethods := make([]IMethod, nMethods) for i, m := range methods { allMethods[i] = m } - n := len(methods); + n := len(methods) for _, e := range embeds { for _, m := range e.methods { - allMethods[n] = m; - n++; + allMethods[n] = m + n++ } } // Sort methods - sort.Sort(iMethodSorter(allMethods)); + sort.Sort(iMethodSorter(allMethods)) - mts := make([]Type, len(allMethods)); + mts := make([]Type, len(allMethods)) for i, m := range methods { mts[i] = m.Type } - tMapI := interfaceTypes.Get(mts); + tMapI := interfaceTypes.Get(mts) if tMapI == nil { tMapI = interfaceTypes.Put(mts, make(map[string]*InterfaceType)) } - tMap := tMapI.(map[string]*InterfaceType); + tMap := tMapI.(map[string]*InterfaceType) - key := ""; + key := "" for _, m := range allMethods { key += m.Name + " " } - t, ok := tMap[key]; + t, ok := tMap[key] if !ok { - t = &InterfaceType{commonType{}, allMethods}; - tMap[key] = t; + t = &InterfaceType{commonType{}, allMethods} + tMap[key] = t } - return t; + return t } type iMethodSorter []IMethod -func (s iMethodSorter) Less(a, b int) bool { return s[a].Name < s[b].Name } +func (s iMethodSorter) Less(a, b int) bool { return s[a].Name < s[b].Name } -func (s iMethodSorter) Swap(a, b int) { s[a], s[b] = s[b], s[a] } +func (s iMethodSorter) Swap(a, b int) { s[a], s[b] = s[b], s[a] } -func (s iMethodSorter) Len() int { return len(s) } +func (s iMethodSorter) Len() int { return len(s) } func (t *InterfaceType) compat(o Type, conv bool) bool { - t2, ok := o.lit().(*InterfaceType); + t2, ok := o.lit().(*InterfaceType) if !ok { return false } @@ -916,27 +916,27 @@ func (t *InterfaceType) compat(o Type, conv bool) bool { return false } for i, e := range t.methods { - e2 := t2.methods[i]; + e2 := t2.methods[i] if e.Name != e2.Name || !e.Type.compat(e2.Type, conv) { return false } } - return true; + return true } -func (t *InterfaceType) lit() Type { return t } +func (t *InterfaceType) lit() Type { return t } func (t *InterfaceType) String() string { // TODO(austin) Instead of showing embedded interfaces, this // shows their methods. - s := "interface {"; + s := "interface {" for i, m := range t.methods { if i > 0 { s += "; " } - s += m.Name + funcTypeString(m.Type, nil, nil); + s += m.Name + funcTypeString(m.Type, nil, nil) } - return s + "}"; + return s + "}" } // implementedBy tests if o implements t, returning nil, true if it does. @@ -960,24 +960,24 @@ func (t *InterfaceType) implementedBy(o Type) (*IMethod, bool) { switch o := o.(type) { case *NamedType: for _, tm := range t.methods { - sm, ok := o.methods[tm.Name]; + sm, ok := o.methods[tm.Name] if !ok || sm.decl.Type != tm.Type { return &tm, false } } - return nil, true; + return nil, true case *InterfaceType: - var ti, oi int; + var ti, oi int for ti < len(t.methods) && oi < len(o.methods) { - tm, om := &t.methods[ti], &o.methods[oi]; + tm, om := &t.methods[ti], &o.methods[oi] switch { case tm.Name == om.Name: if tm.Type != om.Type { return tm, false } - ti++; - oi++; + ti++ + oi++ case tm.Name > om.Name: oi++ default: @@ -987,21 +987,21 @@ func (t *InterfaceType) implementedBy(o Type) (*IMethod, bool) { if ti < len(t.methods) { return &t.methods[ti], false } - return nil, true; + return nil, true } - return &t.methods[0], false; + return &t.methods[0], false } -func (t *InterfaceType) Zero() Value { return &interfaceV{} } +func (t *InterfaceType) Zero() Value { return &interfaceV{} } /* * Slice */ type SliceType struct { - commonType; - Elem Type; + commonType + Elem Type } var sliceTypes = make(map[Type]*SliceType) @@ -1009,25 +1009,25 @@ var sliceTypes = make(map[Type]*SliceType) // Two slice types are identical if they have identical element types. func NewSliceType(elem Type) *SliceType { - t, ok := sliceTypes[elem]; + t, ok := sliceTypes[elem] if !ok { - t = &SliceType{commonType{}, elem}; - sliceTypes[elem] = t; + t = &SliceType{commonType{}, elem} + sliceTypes[elem] = t } - return t; + return t } func (t *SliceType) compat(o Type, conv bool) bool { - t2, ok := o.lit().(*SliceType); + t2, ok := o.lit().(*SliceType) if !ok { return false } - return t.Elem.compat(t2.Elem, conv); + return t.Elem.compat(t2.Elem, conv) } -func (t *SliceType) lit() Type { return t } +func (t *SliceType) lit() Type { return t } -func (t *SliceType) String() string { return "[]" + t.Elem.String() } +func (t *SliceType) String() string { return "[]" + t.Elem.String() } func (t *SliceType) Zero() Value { // The value of an uninitialized slice is nil. The length and @@ -1040,38 +1040,38 @@ func (t *SliceType) Zero() Value { */ type MapType struct { - commonType; - Key Type; - Elem Type; + commonType + Key Type + Elem Type } var mapTypes = make(map[Type]map[Type]*MapType) func NewMapType(key Type, elem Type) *MapType { - ts, ok := mapTypes[key]; + ts, ok := mapTypes[key] if !ok { - ts = make(map[Type]*MapType); - mapTypes[key] = ts; + ts = make(map[Type]*MapType) + mapTypes[key] = ts } - t, ok := ts[elem]; + t, ok := ts[elem] if !ok { - t = &MapType{commonType{}, key, elem}; - ts[elem] = t; + t = &MapType{commonType{}, key, elem} + ts[elem] = t } - return t; + return t } func (t *MapType) compat(o Type, conv bool) bool { - t2, ok := o.lit().(*MapType); + t2, ok := o.lit().(*MapType) if !ok { return false } - return t.Elem.compat(t2.Elem, conv) && t.Key.compat(t2.Key, conv); + return t.Elem.compat(t2.Elem, conv) && t.Key.compat(t2.Key, conv) } -func (t *MapType) lit() Type { return t } +func (t *MapType) lit() Type { return t } -func (t *MapType) String() string { return "map[" + t.Key.String() + "] " + t.Elem.String() } +func (t *MapType) String() string { return "map[" + t.Key.String() + "] " + t.Elem.String() } func (t *MapType) Zero() Value { // The value of an uninitialized map is nil. @@ -1089,20 +1089,20 @@ type ChanType struct { */ type Method struct { - decl *FuncDecl; - fn Func; + decl *FuncDecl + fn Func } type NamedType struct { - token.Position; - Name string; + token.Position + Name string // Underlying type. If incomplete is true, this will be nil. // If incomplete is false and this is still nil, then this is // a placeholder type representing an error. - Def Type; + Def Type // True while this type is being defined. - incomplete bool; - methods map[string]Method; + incomplete bool + methods map[string]Method } // TODO(austin) This is temporarily needed by the debugger's remote @@ -1120,12 +1120,12 @@ func (t *NamedType) Complete(def Type) { if ndef, ok := def.(*NamedType); ok { def = ndef.Def } - t.Def = def; - t.incomplete = false; + t.Def = def + t.incomplete = false } func (t *NamedType) compat(o Type, conv bool) bool { - t2, ok := o.(*NamedType); + t2, ok := o.(*NamedType) if ok { if conv { // Two named types are conversion compatible @@ -1141,22 +1141,22 @@ func (t *NamedType) compat(o Type, conv bool) bool { } // A named and an unnamed type are compatible if the // respective type literals are compatible. - return o.compat(t.Def, conv); + return o.compat(t.Def, conv) } -func (t *NamedType) lit() Type { return t.Def.lit() } +func (t *NamedType) lit() Type { return t.Def.lit() } -func (t *NamedType) isBoolean() bool { return t.Def.isBoolean() } +func (t *NamedType) isBoolean() bool { return t.Def.isBoolean() } -func (t *NamedType) isInteger() bool { return t.Def.isInteger() } +func (t *NamedType) isInteger() bool { return t.Def.isInteger() } -func (t *NamedType) isFloat() bool { return t.Def.isFloat() } +func (t *NamedType) isFloat() bool { return t.Def.isFloat() } -func (t *NamedType) isIdeal() bool { return false } +func (t *NamedType) isIdeal() bool { return false } -func (t *NamedType) String() string { return t.Name } +func (t *NamedType) String() string { return t.Name } -func (t *NamedType) Zero() Value { return t.Def.Zero() } +func (t *NamedType) Zero() Value { return t.Def.Zero() } /* * Multi-valued type @@ -1166,8 +1166,8 @@ func (t *NamedType) Zero() Value { return t.Def.Zero() } // to a tuple type. It's not generally accessible within the // language. type MultiType struct { - commonType; - Elems []Type; + commonType + Elems []Type } var multiTypes = newTypeArrayMap() @@ -1177,13 +1177,13 @@ func NewMultiType(elems []Type) *MultiType { return t.(*MultiType) } - t := &MultiType{commonType{}, elems}; - multiTypes.Put(elems, t); - return t; + t := &MultiType{commonType{}, elems} + multiTypes.Put(elems, t) + return t } func (t *MultiType) compat(o Type, conv bool) bool { - t2, ok := o.lit().(*MultiType); + t2, ok := o.lit().(*MultiType) if !ok { return false } @@ -1195,26 +1195,26 @@ func (t *MultiType) compat(o Type, conv bool) bool { return false } } - return true; + return true } var EmptyType Type = NewMultiType([]Type{}) -func (t *MultiType) lit() Type { return t } +func (t *MultiType) lit() Type { return t } func (t *MultiType) String() string { if len(t.Elems) == 0 { return "<none>" } - return typeListString(t.Elems, nil); + return typeListString(t.Elems, nil) } func (t *MultiType) Zero() Value { - res := make([]Value, len(t.Elems)); + res := make([]Value, len(t.Elems)) for i, t := range t.Elems { res[i] = t.Zero() } - return multiV(res); + return multiV(res) } /* @@ -1227,17 +1227,17 @@ func init() { // Make byte an alias for the named type uint8. Type aliases // are otherwise impossible in Go, so just hack it here. - universe.defs["byte"] = universe.defs["uint8"]; + universe.defs["byte"] = universe.defs["uint8"] // Built-in functions - universe.DefineConst("cap", universePos, capType, nil); - universe.DefineConst("close", universePos, closeType, nil); - universe.DefineConst("closed", universePos, closedType, nil); - universe.DefineConst("len", universePos, lenType, nil); - universe.DefineConst("make", universePos, makeType, nil); - universe.DefineConst("new", universePos, newType, nil); - universe.DefineConst("panic", universePos, panicType, nil); - universe.DefineConst("panicln", universePos, paniclnType, nil); - universe.DefineConst("print", universePos, printType, nil); - universe.DefineConst("println", universePos, printlnType, nil); + universe.DefineConst("cap", universePos, capType, nil) + universe.DefineConst("close", universePos, closeType, nil) + universe.DefineConst("closed", universePos, closedType, nil) + universe.DefineConst("len", universePos, lenType, nil) + universe.DefineConst("make", universePos, makeType, nil) + universe.DefineConst("new", universePos, newType, nil) + universe.DefineConst("panic", universePos, panicType, nil) + universe.DefineConst("panicln", universePos, paniclnType, nil) + universe.DefineConst("print", universePos, printType, nil) + universe.DefineConst("println", universePos, printlnType, nil) } diff --git a/src/pkg/exp/eval/typec.go b/src/pkg/exp/eval/typec.go index a2823b40d..b4bc09a82 100644 --- a/src/pkg/exp/eval/typec.go +++ b/src/pkg/exp/eval/typec.go @@ -5,9 +5,9 @@ package eval import ( - "go/ast"; - "go/token"; - "log"; + "go/ast" + "go/token" + "log" ) @@ -16,78 +16,78 @@ import ( */ type typeCompiler struct { - *compiler; - block *block; + *compiler + block *block // Check to be performed after a type declaration is compiled. // // TODO(austin) This will probably have to change after we // eliminate forward declarations. - lateCheck func() bool; + lateCheck func() bool } func (a *typeCompiler) compileIdent(x *ast.Ident, allowRec bool) Type { - _, _, def := a.block.Lookup(x.Value); + _, _, def := a.block.Lookup(x.Value) if def == nil { - a.diagAt(x, "%s: undefined", x.Value); - return nil; + a.diagAt(x, "%s: undefined", x.Value) + return nil } switch def := def.(type) { case *Constant: - a.diagAt(x, "constant %v used as type", x.Value); - return nil; + a.diagAt(x, "constant %v used as type", x.Value) + return nil case *Variable: - a.diagAt(x, "variable %v used as type", x.Value); - return nil; + a.diagAt(x, "variable %v used as type", x.Value) + return nil case *NamedType: if !allowRec && def.incomplete { - a.diagAt(x, "illegal recursive type"); - return nil; + a.diagAt(x, "illegal recursive type") + return nil } if !def.incomplete && def.Def == nil { // Placeholder type from an earlier error return nil } - return def; + return def case Type: return def } - log.Crashf("name %s has unknown type %T", x.Value, def); - return nil; + log.Crashf("name %s has unknown type %T", x.Value, def) + return nil } func (a *typeCompiler) compileArrayType(x *ast.ArrayType, allowRec bool) Type { // Compile element type - elem := a.compileType(x.Elt, allowRec); + elem := a.compileType(x.Elt, allowRec) // Compile length expression if x.Len == nil { if elem == nil { return nil } - return NewSliceType(elem); + return NewSliceType(elem) } if _, ok := x.Len.(*ast.Ellipsis); ok { - a.diagAt(x.Len, "... array initailizers not implemented"); - return nil; + a.diagAt(x.Len, "... array initailizers not implemented") + return nil } - l, ok := a.compileArrayLen(a.block, x.Len); + l, ok := a.compileArrayLen(a.block, x.Len) if !ok { return nil } if l < 0 { - a.diagAt(x.Len, "array length must be non-negative"); - return nil; + a.diagAt(x.Len, "array length must be non-negative") + return nil } if elem == nil { return nil } - return NewArrayType(l, elem); + return NewArrayType(l, elem) } func countFields(fs []*ast.Field) int { - n := 0; + n := 0 for _, f := range fs { if f.Names == nil { n++ @@ -95,42 +95,42 @@ func countFields(fs []*ast.Field) int { n += len(f.Names) } } - return n; + return n } func (a *typeCompiler) compileFields(fs []*ast.Field, allowRec bool) ([]Type, []*ast.Ident, []token.Position, bool) { - n := countFields(fs); - ts := make([]Type, n); - ns := make([]*ast.Ident, n); - ps := make([]token.Position, n); + n := countFields(fs) + ts := make([]Type, n) + ns := make([]*ast.Ident, n) + ps := make([]token.Position, n) - bad := false; - i := 0; + bad := false + i := 0 for _, f := range fs { - t := a.compileType(f.Type, allowRec); + t := a.compileType(f.Type, allowRec) if t == nil { bad = true } if f.Names == nil { - ns[i] = nil; - ts[i] = t; - ps[i] = f.Type.Pos(); - i++; - continue; + ns[i] = nil + ts[i] = t + ps[i] = f.Type.Pos() + i++ + continue } for _, n := range f.Names { - ns[i] = n; - ts[i] = t; - ps[i] = n.Pos(); - i++; + ns[i] = n + ts[i] = t + ps[i] = n.Pos() + i++ } } - return ts, ns, ps, bad; + return ts, ns, ps, bad } func (a *typeCompiler) compileStructType(x *ast.StructType, allowRec bool) Type { - ts, names, poss, bad := a.compileFields(x.Fields, allowRec); + ts, names, poss, bad := a.compileFields(x.Fields, allowRec) // XXX(Spec) The spec claims that field identifiers must be // unique, but 6g only checks this when they are accessed. I @@ -141,11 +141,11 @@ func (a *typeCompiler) compileStructType(x *ast.StructType, allowRec bool) Type // There's separate language in the spec about checking // uniqueness of field names inherited from anonymous fields // at use time. - fields := make([]StructField, len(ts)); - nameSet := make(map[string]token.Position, len(ts)); + fields := make([]StructField, len(ts)) + nameSet := make(map[string]token.Position, len(ts)) for i := range fields { // Compute field name and check anonymous fields - var name string; + var name string if names[i] != nil { name = names[i].Value } else { @@ -153,18 +153,18 @@ func (a *typeCompiler) compileStructType(x *ast.StructType, allowRec bool) Type continue } - var nt *NamedType; + var nt *NamedType // [For anonymous fields,] the unqualified // type name acts as the field identifier. switch t := ts[i].(type) { case *NamedType: - name = t.Name; - nt = t; + name = t.Name + nt = t case *PtrType: switch t := t.Elem.(type) { case *NamedType: - name = t.Name; - nt = t; + name = t.Name + nt = t } } // [An anonymous field] must be specified as a @@ -172,50 +172,50 @@ func (a *typeCompiler) compileStructType(x *ast.StructType, allowRec bool) Type // *T, and T itself, may not be a pointer or // interface type. if nt == nil { - a.diagAt(&poss[i], "embedded type must T or *T, where T is a named type"); - bad = true; - continue; + a.diagAt(&poss[i], "embedded type must T or *T, where T is a named type") + bad = true + continue } // The check for embedded pointer types must // be deferred because of things like // type T *struct { T } - lateCheck := a.lateCheck; + lateCheck := a.lateCheck a.lateCheck = func() bool { if _, ok := nt.lit().(*PtrType); ok { - a.diagAt(&poss[i], "embedded type %v is a pointer type", nt); - return false; + a.diagAt(&poss[i], "embedded type %v is a pointer type", nt) + return false } - return lateCheck(); - }; + return lateCheck() + } } // Check name uniqueness if prev, ok := nameSet[name]; ok { - a.diagAt(&poss[i], "field %s redeclared\n\tprevious declaration at %s", name, &prev); - bad = true; - continue; + a.diagAt(&poss[i], "field %s redeclared\n\tprevious declaration at %s", name, &prev) + bad = true + continue } - nameSet[name] = poss[i]; + nameSet[name] = poss[i] // Create field - fields[i].Name = name; - fields[i].Type = ts[i]; - fields[i].Anonymous = (names[i] == nil); + fields[i].Name = name + fields[i].Type = ts[i] + fields[i].Anonymous = (names[i] == nil) } if bad { return nil } - return NewStructType(fields); + return NewStructType(fields) } func (a *typeCompiler) compilePtrType(x *ast.StarExpr) Type { - elem := a.compileType(x.X, true); + elem := a.compileType(x.X, true) if elem == nil { return nil } - return NewPtrType(elem); + return NewPtrType(elem) } func (a *typeCompiler) compileFuncType(x *ast.FuncType, allowRec bool) *FuncDecl { @@ -224,56 +224,56 @@ func (a *typeCompiler) compileFuncType(x *ast.FuncType, allowRec bool) *FuncDecl // The types of parameters and results must be complete. // // TODO(austin) It's not clear they actually have to be complete. - in, inNames, _, inBad := a.compileFields(x.Params, allowRec); - out, outNames, _, outBad := a.compileFields(x.Results, allowRec); + in, inNames, _, inBad := a.compileFields(x.Params, allowRec) + out, outNames, _, outBad := a.compileFields(x.Results, allowRec) if inBad || outBad { return nil } - return &FuncDecl{NewFuncType(in, false, out), nil, inNames, outNames}; + return &FuncDecl{NewFuncType(in, false, out), nil, inNames, outNames} } func (a *typeCompiler) compileInterfaceType(x *ast.InterfaceType, allowRec bool) *InterfaceType { - ts, names, poss, bad := a.compileFields(x.Methods, allowRec); + ts, names, poss, bad := a.compileFields(x.Methods, allowRec) - methods := make([]IMethod, len(ts)); - nameSet := make(map[string]token.Position, len(ts)); - embeds := make([]*InterfaceType, len(ts)); + methods := make([]IMethod, len(ts)) + nameSet := make(map[string]token.Position, len(ts)) + embeds := make([]*InterfaceType, len(ts)) - var nm, ne int; + var nm, ne int for i := range ts { if ts[i] == nil { continue } if names[i] != nil { - name := names[i].Value; - methods[nm].Name = name; - methods[nm].Type = ts[i].(*FuncType); - nm++; + name := names[i].Value + methods[nm].Name = name + methods[nm].Type = ts[i].(*FuncType) + nm++ if prev, ok := nameSet[name]; ok { - a.diagAt(&poss[i], "method %s redeclared\n\tprevious declaration at %s", name, &prev); - bad = true; - continue; + a.diagAt(&poss[i], "method %s redeclared\n\tprevious declaration at %s", name, &prev) + bad = true + continue } - nameSet[name] = poss[i]; + nameSet[name] = poss[i] } else { // Embedded interface - it, ok := ts[i].lit().(*InterfaceType); + it, ok := ts[i].lit().(*InterfaceType) if !ok { - a.diagAt(&poss[i], "embedded type must be an interface"); - bad = true; - continue; + a.diagAt(&poss[i], "embedded type must be an interface") + bad = true + continue } - embeds[ne] = it; - ne++; + embeds[ne] = it + ne++ for _, m := range it.methods { if prev, ok := nameSet[m.Name]; ok { - a.diagAt(&poss[i], "method %s redeclared\n\tprevious declaration at %s", m.Name, &prev); - bad = true; - continue; + a.diagAt(&poss[i], "method %s redeclared\n\tprevious declaration at %s", m.Name, &prev) + bad = true + continue } - nameSet[m.Name] = poss[i]; + nameSet[m.Name] = poss[i] } } } @@ -282,15 +282,15 @@ func (a *typeCompiler) compileInterfaceType(x *ast.InterfaceType, allowRec bool) return nil } - methods = methods[0:nm]; - embeds = embeds[0:ne]; + methods = methods[0:nm] + embeds = embeds[0:ne] - return NewInterfaceType(methods, embeds); + return NewInterfaceType(methods, embeds) } func (a *typeCompiler) compileMapType(x *ast.MapType) Type { - key := a.compileType(x.Key, true); - val := a.compileType(x.Value, true); + key := a.compileType(x.Key, true) + val := a.compileType(x.Value, true) if key == nil || val == nil { return nil } @@ -298,24 +298,24 @@ func (a *typeCompiler) compileMapType(x *ast.MapType) Type { // that can be map keys except for function types. switch key.lit().(type) { case *StructType: - a.diagAt(x, "map key cannot be a struct type"); - return nil; + a.diagAt(x, "map key cannot be a struct type") + return nil case *ArrayType: - a.diagAt(x, "map key cannot be an array type"); - return nil; + a.diagAt(x, "map key cannot be an array type") + return nil case *SliceType: - a.diagAt(x, "map key cannot be a slice type"); - return nil; + a.diagAt(x, "map key cannot be a slice type") + return nil } - return NewMapType(key, val); + return NewMapType(key, val) } func (a *typeCompiler) compileType(x ast.Expr, allowRec bool) Type { switch x := x.(type) { case *ast.BadExpr: // Error already reported by parser - a.silentErrors++; - return nil; + a.silentErrors++ + return nil case *ast.Ident: return a.compileIdent(x, allowRec) @@ -330,11 +330,11 @@ func (a *typeCompiler) compileType(x ast.Expr, allowRec bool) Type { return a.compilePtrType(x) case *ast.FuncType: - fd := a.compileFuncType(x, allowRec); + fd := a.compileFuncType(x, allowRec) if fd == nil { return nil } - return fd.Type; + return fd.Type case *ast.InterfaceType: return a.compileInterfaceType(x, allowRec) @@ -349,44 +349,44 @@ func (a *typeCompiler) compileType(x ast.Expr, allowRec bool) Type { return a.compileType(x.X, allowRec) case *ast.Ellipsis: - a.diagAt(x, "illegal use of ellipsis"); - return nil; + a.diagAt(x, "illegal use of ellipsis") + return nil } - a.diagAt(x, "expression used as type"); - return nil; + a.diagAt(x, "expression used as type") + return nil notimpl: - a.diagAt(x, "compileType: %T not implemented", x); - return nil; + a.diagAt(x, "compileType: %T not implemented", x) + return nil } /* * Type compiler interface */ -func noLateCheck() bool { return true } +func noLateCheck() bool { return true } func (a *compiler) compileType(b *block, typ ast.Expr) Type { - tc := &typeCompiler{a, b, noLateCheck}; - t := tc.compileType(typ, false); + tc := &typeCompiler{a, b, noLateCheck} + t := tc.compileType(typ, false) if !tc.lateCheck() { t = nil } - return t; + return t } func (a *compiler) compileTypeDecl(b *block, decl *ast.GenDecl) bool { - ok := true; + ok := true for _, spec := range decl.Specs { - spec := spec.(*ast.TypeSpec); + spec := spec.(*ast.TypeSpec) // Create incomplete type for this type - nt := b.DefineType(spec.Name.Value, spec.Name.Pos(), nil); + nt := b.DefineType(spec.Name.Value, spec.Name.Pos(), nil) if nt != nil { nt.(*NamedType).incomplete = true } // Compile type - tc := &typeCompiler{a, b, noLateCheck}; - t := tc.compileType(spec.Type, false); + tc := &typeCompiler{a, b, noLateCheck} + t := tc.compileType(spec.Type, false) if t == nil { // Create a placeholder type ok = false @@ -397,23 +397,23 @@ func (a *compiler) compileTypeDecl(b *block, decl *ast.GenDecl) bool { } // Perform late type checking with complete type if !tc.lateCheck() { - ok = false; + ok = false if nt != nil { // Make the type a placeholder nt.(*NamedType).Def = nil } } } - return ok; + return ok } func (a *compiler) compileFuncType(b *block, typ *ast.FuncType) *FuncDecl { - tc := &typeCompiler{a, b, noLateCheck}; - res := tc.compileFuncType(typ, false); + tc := &typeCompiler{a, b, noLateCheck} + res := tc.compileFuncType(typ, false) if res != nil { if !tc.lateCheck() { res = nil } } - return res; + return res } diff --git a/src/pkg/exp/eval/util.go b/src/pkg/exp/eval/util.go index bee767d88..6508346dd 100644 --- a/src/pkg/exp/eval/util.go +++ b/src/pkg/exp/eval/util.go @@ -5,35 +5,35 @@ package eval import ( - "bignum"; + "bignum" ) // TODO(austin): Maybe add to bignum in more general form func ratToString(rat *bignum.Rational) string { - n, dnat := rat.Value(); - d := bignum.MakeInt(false, dnat); - w, frac := n.QuoRem(d); - out := w.String(); + n, dnat := rat.Value() + d := bignum.MakeInt(false, dnat) + w, frac := n.QuoRem(d) + out := w.String() if frac.IsZero() { return out } - r := frac.Abs(); - r = r.Mul(bignum.Nat(1e6)); - dec, tail := r.DivMod(dnat); + r := frac.Abs() + r = r.Mul(bignum.Nat(1e6)) + dec, tail := r.DivMod(dnat) // Round last digit if tail.Cmp(dnat.Div(bignum.Nat(2))) >= 0 { dec = dec.Add(bignum.Nat(1)) } // Strip zeros - ten := bignum.Nat(10); + ten := bignum.Nat(10) for !dec.IsZero() { - dec2, r2 := dec.DivMod(ten); + dec2, r2 := dec.DivMod(ten) if !r2.IsZero() { break } - dec = dec2; + dec = dec2 } - out += "." + dec.String(); - return out; + out += "." + dec.String() + return out } diff --git a/src/pkg/exp/eval/value.go b/src/pkg/exp/eval/value.go index 3f823bb3e..1558d11dd 100644 --- a/src/pkg/exp/eval/value.go +++ b/src/pkg/exp/eval/value.go @@ -5,134 +5,134 @@ package eval import ( - "bignum"; - "fmt"; + "bignum" + "fmt" ) type Value interface { - String() string; + String() string // Assign copies another value into this one. It should // assume that the other value satisfies the same specific // value interface (BoolValue, etc.), but must not assume // anything about its specific type. - Assign(t *Thread, o Value); + Assign(t *Thread, o Value) } type BoolValue interface { - Value; - Get(*Thread) bool; - Set(*Thread, bool); + Value + Get(*Thread) bool + Set(*Thread, bool) } type UintValue interface { - Value; - Get(*Thread) uint64; - Set(*Thread, uint64); + Value + Get(*Thread) uint64 + Set(*Thread, uint64) } type IntValue interface { - Value; - Get(*Thread) int64; - Set(*Thread, int64); + Value + Get(*Thread) int64 + Set(*Thread, int64) } // TODO(austin) IdealIntValue and IdealFloatValue should not exist // because ideals are not l-values. type IdealIntValue interface { - Value; - Get() *bignum.Integer; + Value + Get() *bignum.Integer } type FloatValue interface { - Value; - Get(*Thread) float64; - Set(*Thread, float64); + Value + Get(*Thread) float64 + Set(*Thread, float64) } type IdealFloatValue interface { - Value; - Get() *bignum.Rational; + Value + Get() *bignum.Rational } type StringValue interface { - Value; - Get(*Thread) string; - Set(*Thread, string); + Value + Get(*Thread) string + Set(*Thread, string) } type ArrayValue interface { - Value; + Value // TODO(austin) Get() is here for uniformity, but is // completely useless. If a lot of other types have similarly // useless Get methods, just special-case these uses. - Get(*Thread) ArrayValue; - Elem(*Thread, int64) Value; + Get(*Thread) ArrayValue + Elem(*Thread, int64) Value // Sub returns an ArrayValue backed by the same array that // starts from element i and has length len. - Sub(i int64, len int64) ArrayValue; + Sub(i int64, len int64) ArrayValue } type StructValue interface { - Value; + Value // TODO(austin) This is another useless Get() - Get(*Thread) StructValue; - Field(*Thread, int) Value; + Get(*Thread) StructValue + Field(*Thread, int) Value } type PtrValue interface { - Value; - Get(*Thread) Value; - Set(*Thread, Value); + Value + Get(*Thread) Value + Set(*Thread, Value) } type Func interface { - NewFrame() *Frame; - Call(*Thread); + NewFrame() *Frame + Call(*Thread) } type FuncValue interface { - Value; - Get(*Thread) Func; - Set(*Thread, Func); + Value + Get(*Thread) Func + Set(*Thread, Func) } type Interface struct { - Type Type; - Value Value; + Type Type + Value Value } type InterfaceValue interface { - Value; - Get(*Thread) Interface; - Set(*Thread, Interface); + Value + Get(*Thread) Interface + Set(*Thread, Interface) } type Slice struct { - Base ArrayValue; - Len, Cap int64; + Base ArrayValue + Len, Cap int64 } type SliceValue interface { - Value; - Get(*Thread) Slice; - Set(*Thread, Slice); + Value + Get(*Thread) Slice + Set(*Thread, Slice) } type Map interface { - Len(*Thread) int64; + Len(*Thread) int64 // Retrieve an element from the map, returning nil if it does // not exist. - Elem(t *Thread, key interface{}) Value; + Elem(t *Thread, key interface{}) Value // Set an entry in the map. If val is nil, delete the entry. - SetElem(t *Thread, key interface{}, val Value); + SetElem(t *Thread, key interface{}, val Value) // TODO(austin) Perhaps there should be an iterator interface instead. - Iter(func(key interface{}, val Value) bool); + Iter(func(key interface{}, val Value) bool) } type MapValue interface { - Value; - Get(*Thread) Map; - Set(*Thread, Map); + Value + Get(*Thread) Map + Set(*Thread, Map) } /* @@ -141,13 +141,13 @@ type MapValue interface { type boolV bool -func (v *boolV) String() string { return fmt.Sprint(*v) } +func (v *boolV) String() string { return fmt.Sprint(*v) } -func (v *boolV) Assign(t *Thread, o Value) { *v = boolV(o.(BoolValue).Get(t)) } +func (v *boolV) Assign(t *Thread, o Value) { *v = boolV(o.(BoolValue).Get(t)) } -func (v *boolV) Get(*Thread) bool { return bool(*v) } +func (v *boolV) Get(*Thread) bool { return bool(*v) } -func (v *boolV) Set(t *Thread, x bool) { *v = boolV(x) } +func (v *boolV) Set(t *Thread, x bool) { *v = boolV(x) } /* * Uint @@ -155,63 +155,63 @@ func (v *boolV) Set(t *Thread, x bool) { *v = boolV(x) } type uint8V uint8 -func (v *uint8V) String() string { return fmt.Sprint(*v) } +func (v *uint8V) String() string { return fmt.Sprint(*v) } -func (v *uint8V) Assign(t *Thread, o Value) { *v = uint8V(o.(UintValue).Get(t)) } +func (v *uint8V) Assign(t *Thread, o Value) { *v = uint8V(o.(UintValue).Get(t)) } -func (v *uint8V) Get(*Thread) uint64 { return uint64(*v) } +func (v *uint8V) Get(*Thread) uint64 { return uint64(*v) } -func (v *uint8V) Set(t *Thread, x uint64) { *v = uint8V(x) } +func (v *uint8V) Set(t *Thread, x uint64) { *v = uint8V(x) } type uint16V uint16 -func (v *uint16V) String() string { return fmt.Sprint(*v) } +func (v *uint16V) String() string { return fmt.Sprint(*v) } -func (v *uint16V) Assign(t *Thread, o Value) { *v = uint16V(o.(UintValue).Get(t)) } +func (v *uint16V) Assign(t *Thread, o Value) { *v = uint16V(o.(UintValue).Get(t)) } -func (v *uint16V) Get(*Thread) uint64 { return uint64(*v) } +func (v *uint16V) Get(*Thread) uint64 { return uint64(*v) } -func (v *uint16V) Set(t *Thread, x uint64) { *v = uint16V(x) } +func (v *uint16V) Set(t *Thread, x uint64) { *v = uint16V(x) } type uint32V uint32 -func (v *uint32V) String() string { return fmt.Sprint(*v) } +func (v *uint32V) String() string { return fmt.Sprint(*v) } -func (v *uint32V) Assign(t *Thread, o Value) { *v = uint32V(o.(UintValue).Get(t)) } +func (v *uint32V) Assign(t *Thread, o Value) { *v = uint32V(o.(UintValue).Get(t)) } -func (v *uint32V) Get(*Thread) uint64 { return uint64(*v) } +func (v *uint32V) Get(*Thread) uint64 { return uint64(*v) } -func (v *uint32V) Set(t *Thread, x uint64) { *v = uint32V(x) } +func (v *uint32V) Set(t *Thread, x uint64) { *v = uint32V(x) } type uint64V uint64 -func (v *uint64V) String() string { return fmt.Sprint(*v) } +func (v *uint64V) String() string { return fmt.Sprint(*v) } -func (v *uint64V) Assign(t *Thread, o Value) { *v = uint64V(o.(UintValue).Get(t)) } +func (v *uint64V) Assign(t *Thread, o Value) { *v = uint64V(o.(UintValue).Get(t)) } -func (v *uint64V) Get(*Thread) uint64 { return uint64(*v) } +func (v *uint64V) Get(*Thread) uint64 { return uint64(*v) } -func (v *uint64V) Set(t *Thread, x uint64) { *v = uint64V(x) } +func (v *uint64V) Set(t *Thread, x uint64) { *v = uint64V(x) } type uintV uint -func (v *uintV) String() string { return fmt.Sprint(*v) } +func (v *uintV) String() string { return fmt.Sprint(*v) } -func (v *uintV) Assign(t *Thread, o Value) { *v = uintV(o.(UintValue).Get(t)) } +func (v *uintV) Assign(t *Thread, o Value) { *v = uintV(o.(UintValue).Get(t)) } -func (v *uintV) Get(*Thread) uint64 { return uint64(*v) } +func (v *uintV) Get(*Thread) uint64 { return uint64(*v) } -func (v *uintV) Set(t *Thread, x uint64) { *v = uintV(x) } +func (v *uintV) Set(t *Thread, x uint64) { *v = uintV(x) } type uintptrV uintptr -func (v *uintptrV) String() string { return fmt.Sprint(*v) } +func (v *uintptrV) String() string { return fmt.Sprint(*v) } -func (v *uintptrV) Assign(t *Thread, o Value) { *v = uintptrV(o.(UintValue).Get(t)) } +func (v *uintptrV) Assign(t *Thread, o Value) { *v = uintptrV(o.(UintValue).Get(t)) } -func (v *uintptrV) Get(*Thread) uint64 { return uint64(*v) } +func (v *uintptrV) Get(*Thread) uint64 { return uint64(*v) } -func (v *uintptrV) Set(t *Thread, x uint64) { *v = uintptrV(x) } +func (v *uintptrV) Set(t *Thread, x uint64) { *v = uintptrV(x) } /* * Int @@ -219,69 +219,69 @@ func (v *uintptrV) Set(t *Thread, x uint64) { *v = uintptrV(x) } type int8V int8 -func (v *int8V) String() string { return fmt.Sprint(*v) } +func (v *int8V) String() string { return fmt.Sprint(*v) } -func (v *int8V) Assign(t *Thread, o Value) { *v = int8V(o.(IntValue).Get(t)) } +func (v *int8V) Assign(t *Thread, o Value) { *v = int8V(o.(IntValue).Get(t)) } -func (v *int8V) Get(*Thread) int64 { return int64(*v) } +func (v *int8V) Get(*Thread) int64 { return int64(*v) } -func (v *int8V) Set(t *Thread, x int64) { *v = int8V(x) } +func (v *int8V) Set(t *Thread, x int64) { *v = int8V(x) } type int16V int16 -func (v *int16V) String() string { return fmt.Sprint(*v) } +func (v *int16V) String() string { return fmt.Sprint(*v) } -func (v *int16V) Assign(t *Thread, o Value) { *v = int16V(o.(IntValue).Get(t)) } +func (v *int16V) Assign(t *Thread, o Value) { *v = int16V(o.(IntValue).Get(t)) } -func (v *int16V) Get(*Thread) int64 { return int64(*v) } +func (v *int16V) Get(*Thread) int64 { return int64(*v) } -func (v *int16V) Set(t *Thread, x int64) { *v = int16V(x) } +func (v *int16V) Set(t *Thread, x int64) { *v = int16V(x) } type int32V int32 -func (v *int32V) String() string { return fmt.Sprint(*v) } +func (v *int32V) String() string { return fmt.Sprint(*v) } -func (v *int32V) Assign(t *Thread, o Value) { *v = int32V(o.(IntValue).Get(t)) } +func (v *int32V) Assign(t *Thread, o Value) { *v = int32V(o.(IntValue).Get(t)) } -func (v *int32V) Get(*Thread) int64 { return int64(*v) } +func (v *int32V) Get(*Thread) int64 { return int64(*v) } -func (v *int32V) Set(t *Thread, x int64) { *v = int32V(x) } +func (v *int32V) Set(t *Thread, x int64) { *v = int32V(x) } type int64V int64 -func (v *int64V) String() string { return fmt.Sprint(*v) } +func (v *int64V) String() string { return fmt.Sprint(*v) } -func (v *int64V) Assign(t *Thread, o Value) { *v = int64V(o.(IntValue).Get(t)) } +func (v *int64V) Assign(t *Thread, o Value) { *v = int64V(o.(IntValue).Get(t)) } -func (v *int64V) Get(*Thread) int64 { return int64(*v) } +func (v *int64V) Get(*Thread) int64 { return int64(*v) } -func (v *int64V) Set(t *Thread, x int64) { *v = int64V(x) } +func (v *int64V) Set(t *Thread, x int64) { *v = int64V(x) } type intV int -func (v *intV) String() string { return fmt.Sprint(*v) } +func (v *intV) String() string { return fmt.Sprint(*v) } -func (v *intV) Assign(t *Thread, o Value) { *v = intV(o.(IntValue).Get(t)) } +func (v *intV) Assign(t *Thread, o Value) { *v = intV(o.(IntValue).Get(t)) } -func (v *intV) Get(*Thread) int64 { return int64(*v) } +func (v *intV) Get(*Thread) int64 { return int64(*v) } -func (v *intV) Set(t *Thread, x int64) { *v = intV(x) } +func (v *intV) Set(t *Thread, x int64) { *v = intV(x) } /* * Ideal int */ type idealIntV struct { - V *bignum.Integer; + V *bignum.Integer } -func (v *idealIntV) String() string { return v.V.String() } +func (v *idealIntV) String() string { return v.V.String() } func (v *idealIntV) Assign(t *Thread, o Value) { v.V = o.(IdealIntValue).Get() } -func (v *idealIntV) Get() *bignum.Integer { return v.V } +func (v *idealIntV) Get() *bignum.Integer { return v.V } /* * Float @@ -289,49 +289,49 @@ func (v *idealIntV) Get() *bignum.Integer { return v.V } type float32V float32 -func (v *float32V) String() string { return fmt.Sprint(*v) } +func (v *float32V) String() string { return fmt.Sprint(*v) } -func (v *float32V) Assign(t *Thread, o Value) { *v = float32V(o.(FloatValue).Get(t)) } +func (v *float32V) Assign(t *Thread, o Value) { *v = float32V(o.(FloatValue).Get(t)) } -func (v *float32V) Get(*Thread) float64 { return float64(*v) } +func (v *float32V) Get(*Thread) float64 { return float64(*v) } -func (v *float32V) Set(t *Thread, x float64) { *v = float32V(x) } +func (v *float32V) Set(t *Thread, x float64) { *v = float32V(x) } type float64V float64 -func (v *float64V) String() string { return fmt.Sprint(*v) } +func (v *float64V) String() string { return fmt.Sprint(*v) } -func (v *float64V) Assign(t *Thread, o Value) { *v = float64V(o.(FloatValue).Get(t)) } +func (v *float64V) Assign(t *Thread, o Value) { *v = float64V(o.(FloatValue).Get(t)) } -func (v *float64V) Get(*Thread) float64 { return float64(*v) } +func (v *float64V) Get(*Thread) float64 { return float64(*v) } -func (v *float64V) Set(t *Thread, x float64) { *v = float64V(x) } +func (v *float64V) Set(t *Thread, x float64) { *v = float64V(x) } type floatV float -func (v *floatV) String() string { return fmt.Sprint(*v) } +func (v *floatV) String() string { return fmt.Sprint(*v) } -func (v *floatV) Assign(t *Thread, o Value) { *v = floatV(o.(FloatValue).Get(t)) } +func (v *floatV) Assign(t *Thread, o Value) { *v = floatV(o.(FloatValue).Get(t)) } -func (v *floatV) Get(*Thread) float64 { return float64(*v) } +func (v *floatV) Get(*Thread) float64 { return float64(*v) } -func (v *floatV) Set(t *Thread, x float64) { *v = floatV(x) } +func (v *floatV) Set(t *Thread, x float64) { *v = floatV(x) } /* * Ideal float */ type idealFloatV struct { - V *bignum.Rational; + V *bignum.Rational } -func (v *idealFloatV) String() string { return ratToString(v.V) } +func (v *idealFloatV) String() string { return ratToString(v.V) } func (v *idealFloatV) Assign(t *Thread, o Value) { v.V = o.(IdealFloatValue).Get() } -func (v *idealFloatV) Get() *bignum.Rational { return v.V } +func (v *idealFloatV) Get() *bignum.Rational { return v.V } /* * String @@ -339,13 +339,13 @@ func (v *idealFloatV) Get() *bignum.Rational { return v.V } type stringV string -func (v *stringV) String() string { return fmt.Sprint(*v) } +func (v *stringV) String() string { return fmt.Sprint(*v) } -func (v *stringV) Assign(t *Thread, o Value) { *v = stringV(o.(StringValue).Get(t)) } +func (v *stringV) Assign(t *Thread, o Value) { *v = stringV(o.(StringValue).Get(t)) } -func (v *stringV) Get(*Thread) string { return string(*v) } +func (v *stringV) Get(*Thread) string { return string(*v) } -func (v *stringV) Set(t *Thread, x string) { *v = stringV(x) } +func (v *stringV) Set(t *Thread, x string) { *v = stringV(x) } /* * Array @@ -354,33 +354,33 @@ func (v *stringV) Set(t *Thread, x string) { *v = stringV(x) } type arrayV []Value func (v *arrayV) String() string { - res := "{"; + res := "{" for i, e := range *v { if i > 0 { res += ", " } - res += e.String(); + res += e.String() } - return res + "}"; + return res + "}" } func (v *arrayV) Assign(t *Thread, o Value) { - oa := o.(ArrayValue); - l := int64(len(*v)); + oa := o.(ArrayValue) + l := int64(len(*v)) for i := int64(0); i < l; i++ { (*v)[i].Assign(t, oa.Elem(t, i)) } } -func (v *arrayV) Get(*Thread) ArrayValue { return v } +func (v *arrayV) Get(*Thread) ArrayValue { return v } func (v *arrayV) Elem(t *Thread, i int64) Value { return (*v)[i] } func (v *arrayV) Sub(i int64, len int64) ArrayValue { - res := (*v)[i : i+len]; - return &res; + res := (*v)[i : i+len] + return &res } /* @@ -392,25 +392,25 @@ type structV []Value // TODO(austin) Should these methods (and arrayV's) be on structV // instead of *structV? func (v *structV) String() string { - res := "{"; + res := "{" for i, v := range *v { if i > 0 { res += ", " } - res += v.String(); + res += v.String() } - return res + "}"; + return res + "}" } func (v *structV) Assign(t *Thread, o Value) { - oa := o.(StructValue); - l := len(*v); + oa := o.(StructValue) + l := len(*v) for i := 0; i < l; i++ { (*v)[i].Assign(t, oa.Field(t, i)) } } -func (v *structV) Get(*Thread) StructValue { return v } +func (v *structV) Get(*Thread) StructValue { return v } func (v *structV) Field(t *Thread, i int) Value { return (*v)[i] @@ -422,28 +422,28 @@ func (v *structV) Field(t *Thread, i int) Value { type ptrV struct { // nil if the pointer is nil - target Value; + target Value } func (v *ptrV) String() string { if v.target == nil { return "<nil>" } - return "&" + v.target.String(); + return "&" + v.target.String() } -func (v *ptrV) Assign(t *Thread, o Value) { v.target = o.(PtrValue).Get(t) } +func (v *ptrV) Assign(t *Thread, o Value) { v.target = o.(PtrValue).Get(t) } -func (v *ptrV) Get(*Thread) Value { return v.target } +func (v *ptrV) Get(*Thread) Value { return v.target } -func (v *ptrV) Set(t *Thread, x Value) { v.target = x } +func (v *ptrV) Set(t *Thread, x Value) { v.target = x } /* * Functions */ type funcV struct { - target Func; + target Func } func (v *funcV) String() string { @@ -451,32 +451,32 @@ func (v *funcV) String() string { return "func {...}" } -func (v *funcV) Assign(t *Thread, o Value) { v.target = o.(FuncValue).Get(t) } +func (v *funcV) Assign(t *Thread, o Value) { v.target = o.(FuncValue).Get(t) } -func (v *funcV) Get(*Thread) Func { return v.target } +func (v *funcV) Get(*Thread) Func { return v.target } -func (v *funcV) Set(t *Thread, x Func) { v.target = x } +func (v *funcV) Set(t *Thread, x Func) { v.target = x } /* * Interfaces */ type interfaceV struct { - Interface; + Interface } func (v *interfaceV) String() string { if v.Type == nil || v.Value == nil { return "<nil>" } - return v.Value.String(); + return v.Value.String() } func (v *interfaceV) Assign(t *Thread, o Value) { v.Interface = o.(InterfaceValue).Get(t) } -func (v *interfaceV) Get(*Thread) Interface { return v.Interface } +func (v *interfaceV) Get(*Thread) Interface { return v.Interface } func (v *interfaceV) Set(t *Thread, x Interface) { v.Interface = x @@ -487,62 +487,62 @@ func (v *interfaceV) Set(t *Thread, x Interface) { */ type sliceV struct { - Slice; + Slice } func (v *sliceV) String() string { if v.Base == nil { return "<nil>" } - return v.Base.Sub(0, v.Len).String(); + return v.Base.Sub(0, v.Len).String() } -func (v *sliceV) Assign(t *Thread, o Value) { v.Slice = o.(SliceValue).Get(t) } +func (v *sliceV) Assign(t *Thread, o Value) { v.Slice = o.(SliceValue).Get(t) } -func (v *sliceV) Get(*Thread) Slice { return v.Slice } +func (v *sliceV) Get(*Thread) Slice { return v.Slice } -func (v *sliceV) Set(t *Thread, x Slice) { v.Slice = x } +func (v *sliceV) Set(t *Thread, x Slice) { v.Slice = x } /* * Maps */ type mapV struct { - target Map; + target Map } func (v *mapV) String() string { if v.target == nil { return "<nil>" } - res := "map["; - i := 0; + res := "map[" + i := 0 v.target.Iter(func(key interface{}, val Value) bool { if i > 0 { res += ", " } - i++; - res += fmt.Sprint(key) + ":" + val.String(); - return true; - }); - return res + "]"; + i++ + res += fmt.Sprint(key) + ":" + val.String() + return true + }) + return res + "]" } -func (v *mapV) Assign(t *Thread, o Value) { v.target = o.(MapValue).Get(t) } +func (v *mapV) Assign(t *Thread, o Value) { v.target = o.(MapValue).Get(t) } -func (v *mapV) Get(*Thread) Map { return v.target } +func (v *mapV) Get(*Thread) Map { return v.target } -func (v *mapV) Set(t *Thread, x Map) { v.target = x } +func (v *mapV) Set(t *Thread, x Map) { v.target = x } type evalMap map[interface{}]Value -func (m evalMap) Len(t *Thread) int64 { return int64(len(m)) } +func (m evalMap) Len(t *Thread) int64 { return int64(len(m)) } func (m evalMap) Elem(t *Thread, key interface{}) Value { if v, ok := m[key]; ok { return v } - return nil; + return nil } func (m evalMap) SetElem(t *Thread, key interface{}, val Value) { @@ -568,18 +568,18 @@ func (m evalMap) Iter(cb func(key interface{}, val Value) bool) { type multiV []Value func (v multiV) String() string { - res := "("; + res := "(" for i, v := range v { if i > 0 { res += ", " } - res += v.String(); + res += v.String() } - return res + ")"; + return res + ")" } func (v multiV) Assign(t *Thread, o Value) { - omv := o.(multiV); + omv := o.(multiV) for i := range v { v[i].Assign(t, omv[i]) } @@ -592,10 +592,10 @@ func (v multiV) Assign(t *Thread, o Value) { // TODO(austin) Nothing complains if I accidentally define init with // arguments. Is this intentional? func init() { - s := universe; + s := universe - true := boolV(true); - s.DefineConst("true", universePos, BoolType, &true); - false := boolV(false); - s.DefineConst("false", universePos, BoolType, &false); + true := boolV(true) + s.DefineConst("true", universePos, BoolType, &true) + false := boolV(false) + s.DefineConst("false", universePos, BoolType, &false) } diff --git a/src/pkg/exp/eval/world.go b/src/pkg/exp/eval/world.go index 184e737c6..c36081b26 100644 --- a/src/pkg/exp/eval/world.go +++ b/src/pkg/exp/eval/world.go @@ -8,37 +8,37 @@ package eval import ( - "go/ast"; - parser "exp/parser"; - "go/scanner"; - "go/token"; - "os"; + "go/ast" + parser "exp/parser" + "go/scanner" + "go/token" + "os" ) type World struct { - scope *Scope; - frame *Frame; + scope *Scope + frame *Frame } func NewWorld() *World { - w := new(World); - w.scope = universe.ChildScope(); - w.scope.global = true; // this block's vars allocate directly - return w; + w := new(World) + w.scope = universe.ChildScope() + w.scope.global = true // this block's vars allocate directly + return w } type Code interface { // The type of the value Run returns, or nil if Run returns nil. - Type() Type; + Type() Type // Run runs the code; if the code is a single expression // with a value, it returns the value; otherwise it returns nil. - Run() (Value, os.Error); + Run() (Value, os.Error) } type stmtCode struct { - w *World; - code code; + w *World + code code } func (w *World) CompileStmtList(stmts []ast.Stmt) (Code, os.Error) { @@ -47,9 +47,9 @@ func (w *World) CompileStmtList(stmts []ast.Stmt) (Code, os.Error) { return w.CompileExpr(s.X) } } - errors := new(scanner.ErrorVector); - cc := &compiler{errors, 0, 0}; - cb := newCodeBuf(); + errors := new(scanner.ErrorVector) + cc := &compiler{errors, 0, 0} + cb := newCodeBuf() fc := &funcCompiler{ compiler: cc, fnType: nil, @@ -57,53 +57,53 @@ func (w *World) CompileStmtList(stmts []ast.Stmt) (Code, os.Error) { codeBuf: cb, flow: newFlowBuf(cb), labels: make(map[string]*label), - }; + } bc := &blockCompiler{ funcCompiler: fc, block: w.scope.block, - }; - nerr := cc.numError(); + } + nerr := cc.numError() for _, stmt := range stmts { bc.compileStmt(stmt) } - fc.checkLabels(); + fc.checkLabels() if nerr != cc.numError() { return nil, errors.GetError(scanner.Sorted) } - return &stmtCode{w, fc.get()}, nil; + return &stmtCode{w, fc.get()}, nil } func (w *World) CompileDeclList(decls []ast.Decl) (Code, os.Error) { - stmts := make([]ast.Stmt, len(decls)); + stmts := make([]ast.Stmt, len(decls)) for i, d := range decls { stmts[i] = &ast.DeclStmt{d} } - return w.CompileStmtList(stmts); + return w.CompileStmtList(stmts) } -func (s *stmtCode) Type() Type { return nil } +func (s *stmtCode) Type() Type { return nil } func (s *stmtCode) Run() (Value, os.Error) { - t := new(Thread); - t.f = s.w.scope.NewFrame(nil); - return nil, t.Try(func(t *Thread) { s.code.exec(t) }); + t := new(Thread) + t.f = s.w.scope.NewFrame(nil) + return nil, t.Try(func(t *Thread) { s.code.exec(t) }) } type exprCode struct { - w *World; - e *expr; - eval func(Value, *Thread); + w *World + e *expr + eval func(Value, *Thread) } func (w *World) CompileExpr(e ast.Expr) (Code, os.Error) { - errors := new(scanner.ErrorVector); - cc := &compiler{errors, 0, 0}; + errors := new(scanner.ErrorVector) + cc := &compiler{errors, 0, 0} - ec := cc.compileExpr(w.scope.block, false, e); + ec := cc.compileExpr(w.scope.block, false, e) if ec == nil { return nil, errors.GetError(scanner.Sorted) } - var eval func(Value, *Thread); + var eval func(Value, *Thread) switch t := ec.t.(type) { case *idealIntType: // nothing @@ -113,36 +113,36 @@ func (w *World) CompileExpr(e ast.Expr) (Code, os.Error) { if tm, ok := t.(*MultiType); ok && len(tm.Elems) == 0 { return &stmtCode{w, code{ec.exec}}, nil } - eval = genAssign(ec.t, ec); + eval = genAssign(ec.t, ec) } - return &exprCode{w, ec, eval}, nil; + return &exprCode{w, ec, eval}, nil } -func (e *exprCode) Type() Type { return e.e.t } +func (e *exprCode) Type() Type { return e.e.t } func (e *exprCode) Run() (Value, os.Error) { - t := new(Thread); - t.f = e.w.scope.NewFrame(nil); + t := new(Thread) + t.f = e.w.scope.NewFrame(nil) switch e.e.t.(type) { case *idealIntType: return &idealIntV{e.e.asIdealInt()()}, nil case *idealFloatType: return &idealFloatV{e.e.asIdealFloat()()}, nil } - v := e.e.t.Zero(); - eval := e.eval; - err := t.Try(func(t *Thread) { eval(v, t) }); - return v, err; + v := e.e.t.Zero() + eval := e.eval + err := t.Try(func(t *Thread) { eval(v, t) }) + return v, err } func (w *World) Compile(text string) (Code, os.Error) { - stmts, err := parser.ParseStmtList("input", text); + stmts, err := parser.ParseStmtList("input", text) if err == nil { return w.CompileStmtList(stmts) } // Otherwise try as DeclList. - decls, err1 := parser.ParseDeclList("input", text); + decls, err1 := parser.ParseDeclList("input", text) if err1 == nil { return w.CompileDeclList(decls) } @@ -150,36 +150,36 @@ func (w *World) Compile(text string) (Code, os.Error) { // Have to pick an error. // Parsing as statement list admits more forms, // its error is more likely to be useful. - return nil, err; + return nil, err } type RedefinitionError struct { - Name string; - Prev Def; + Name string + Prev Def } func (e *RedefinitionError) String() string { - res := "identifier " + e.Name + " redeclared"; - pos := e.Prev.Pos(); + res := "identifier " + e.Name + " redeclared" + pos := e.Prev.Pos() if pos.IsValid() { res += "; previous declaration at " + pos.String() } - return res; + return res } func (w *World) DefineConst(name string, t Type, val Value) os.Error { - _, prev := w.scope.DefineConst(name, token.Position{}, t, val); + _, prev := w.scope.DefineConst(name, token.Position{}, t, val) if prev != nil { return &RedefinitionError{name, prev} } - return nil; + return nil } func (w *World) DefineVar(name string, t Type, val Value) os.Error { - v, prev := w.scope.DefineVar(name, token.Position{}, t); + v, prev := w.scope.DefineVar(name, token.Position{}, t) if prev != nil { return &RedefinitionError{name, prev} } - v.Init = val; - return nil; + v.Init = val + return nil } diff --git a/src/pkg/exp/exception/exception.go b/src/pkg/exp/exception/exception.go index 45e0be3f1..e34d0f0d7 100644 --- a/src/pkg/exp/exception/exception.go +++ b/src/pkg/exp/exception/exception.go @@ -11,8 +11,8 @@ package exception import ( - "fmt"; - "runtime"; + "fmt" + "runtime" ) // A Handler function handles an arbitrary exception value x. @@ -20,7 +20,7 @@ type Handler func(x interface{}) // An Exception carries an exception value. type Exception struct { - Value interface{}; // Value may be the nil exception + Value interface{} // Value may be the nil exception } // Try invokes a function f with a Handler to throw exceptions. @@ -51,18 +51,18 @@ type Exception struct { // }) // func Try(f func(throw Handler)) *Exception { - h := make(chan *Exception); + h := make(chan *Exception) // execute try block go func() { f(func(x interface{}) { - h <- &Exception{x}; - runtime.Goexit(); - }); - h <- nil; // clean termination - }(); + h <- &Exception{x} + runtime.Goexit() + }) + h <- nil // clean termination + }() - return <-h; + return <-h } @@ -79,5 +79,5 @@ func (x *Exception) String() string { if x != nil { return fmt.Sprintf("exception: %v", x.Value) } - return ""; + return "" } diff --git a/src/pkg/exp/exception/exception_test.go b/src/pkg/exp/exception/exception_test.go index 91f742ea0..b7b106d77 100644 --- a/src/pkg/exp/exception/exception_test.go +++ b/src/pkg/exp/exception/exception_test.go @@ -7,7 +7,7 @@ package exception import "testing" func TestNoException(t *testing.T) { - e := Try(func(throw Handler) {}); + e := Try(func(throw Handler) {}) if e != nil { t.Fatalf("no exception expected, found: %v", e) } @@ -15,7 +15,7 @@ func TestNoException(t *testing.T) { func TestNilException(t *testing.T) { - e := Try(func(throw Handler) { throw(nil) }); + e := Try(func(throw Handler) { throw(nil) }) if e == nil { t.Fatalf("exception expected", e) } @@ -26,19 +26,19 @@ func TestNilException(t *testing.T) { func TestTry(t *testing.T) { - s := 0; + s := 0 for i := 1; i <= 10; i++ { e := Try(func(throw Handler) { if i%3 == 0 { - throw(i); - panic("throw returned"); + throw(i) + panic("throw returned") } - }); + }) if e != nil { s += e.Value.(int) } } - result := 3 + 6 + 9; + result := 3 + 6 + 9 if s != result { t.Fatalf("expected: %d, found: %d", result, s) } @@ -46,7 +46,7 @@ func TestTry(t *testing.T) { func TestCatch(t *testing.T) { - s := 0; + s := 0 for i := 1; i <= 10; i++ { Try(func(throw Handler) { if i%3 == 0 { @@ -54,7 +54,7 @@ func TestCatch(t *testing.T) { } }).Catch(func(x interface{}) { s += x.(int) }) } - result := 3 + 6 + 9; + result := 3 + 6 + 9 if s != result { t.Fatalf("expected: %d, found: %d", result, s) } diff --git a/src/pkg/exp/iterable/array.go b/src/pkg/exp/iterable/array.go index 371508e5d..b5c7b5c6e 100644 --- a/src/pkg/exp/iterable/array.go +++ b/src/pkg/exp/iterable/array.go @@ -9,51 +9,51 @@ package iterable type ByteArray []byte func (a ByteArray) Iter() <-chan interface{} { - ch := make(chan interface{}); + ch := make(chan interface{}) go func() { for _, e := range a { ch <- e } - close(ch); - }(); - return ch; + close(ch) + }() + return ch } type IntArray []int func (a IntArray) Iter() <-chan interface{} { - ch := make(chan interface{}); + ch := make(chan interface{}) go func() { for _, e := range a { ch <- e } - close(ch); - }(); - return ch; + close(ch) + }() + return ch } type FloatArray []float func (a FloatArray) Iter() <-chan interface{} { - ch := make(chan interface{}); + ch := make(chan interface{}) go func() { for _, e := range a { ch <- e } - close(ch); - }(); - return ch; + close(ch) + }() + return ch } type StringArray []string func (a StringArray) Iter() <-chan interface{} { - ch := make(chan interface{}); + ch := make(chan interface{}) go func() { for _, e := range a { ch <- e } - close(ch); - }(); - return ch; + close(ch) + }() + return ch } diff --git a/src/pkg/exp/iterable/iterable.go b/src/pkg/exp/iterable/iterable.go index 764900c53..b1ae0e90f 100644 --- a/src/pkg/exp/iterable/iterable.go +++ b/src/pkg/exp/iterable/iterable.go @@ -9,13 +9,13 @@ package iterable import ( - "container/list"; - "container/vector"; + "container/list" + "container/vector" ) type Iterable interface { // Iter should return a fresh channel each time it is called. - Iter() <-chan interface{}; + Iter() <-chan interface{} } func not(f func(interface{}) bool) (func(interface{}) bool) { @@ -29,7 +29,7 @@ func All(iter Iterable, f func(interface{}) bool) bool { return false } } - return true; + return true } // Any tests whether f is true for at least one element of iter. @@ -39,18 +39,18 @@ func Any(iter Iterable, f func(interface{}) bool) bool { // Data returns a slice containing the elements of iter. func Data(iter Iterable) []interface{} { - vec := new(vector.Vector); + vec := new(vector.Vector) for e := range iter.Iter() { vec.Push(e) } - return vec.Data(); + return vec.Data() } // filteredIterable is a struct that implements Iterable with each element // passed through a filter. type filteredIterable struct { - it Iterable; - f func(interface{}) bool; + it Iterable + f func(interface{}) bool } func (f *filteredIterable) iterate(out chan<- interface{}) { @@ -59,13 +59,13 @@ func (f *filteredIterable) iterate(out chan<- interface{}) { out <- e } } - close(out); + close(out) } func (f *filteredIterable) Iter() <-chan interface{} { - ch := make(chan interface{}); - go f.iterate(ch); - return ch; + ch := make(chan interface{}) + go f.iterate(ch) + return ch } // Filter returns an Iterable that returns the elements of iter that satisfy f. @@ -79,7 +79,7 @@ func Find(iter Iterable, f func(interface{}) bool) interface{} { for e := range Filter(iter, f).Iter() { return e } - return nil; + return nil } // Injector is a type representing a function that takes two arguments, @@ -96,30 +96,30 @@ type Injector func(interface{}, interface{}) interface{} // func(ax interface {}, x interface {}) interface {} { // return ax.(int) + x.(int) }).(int) func Inject(iter Iterable, initial interface{}, f Injector) interface{} { - acc := initial; + acc := initial for e := range iter.Iter() { acc = f(acc, e) } - return acc; + return acc } // mappedIterable is a helper struct that implements Iterable, returned by Map. type mappedIterable struct { - it Iterable; - f func(interface{}) interface{}; + it Iterable + f func(interface{}) interface{} } func (m *mappedIterable) iterate(out chan<- interface{}) { for e := range m.it.Iter() { out <- m.f(e) } - close(out); + close(out) } func (m *mappedIterable) Iter() <-chan interface{} { - ch := make(chan interface{}); - go m.iterate(ch); - return ch; + ch := make(chan interface{}) + go m.iterate(ch) + return ch } // Map returns an Iterable that returns the result of applying f to each @@ -139,13 +139,13 @@ type iterFunc func(chan<- interface{}) // provide the Iterable interface func (v iterFunc) Iter() <-chan interface{} { - ch := make(chan interface{}); - go v(ch); - return ch; + ch := make(chan interface{}) + go v(ch) + return ch } // Take returns an Iterable that contains the first n elements of iter. -func Take(iter Iterable, n int) Iterable { return Slice(iter, 0, n) } +func Take(iter Iterable, n int) Iterable { return Slice(iter, 0, n) } // TakeWhile returns an Iterable that contains elements from iter while f is true. func TakeWhile(iter Iterable, f func(interface{}) bool) Iterable { @@ -154,41 +154,41 @@ func TakeWhile(iter Iterable, f func(interface{}) bool) Iterable { if !f(v) { break } - ch <- v; + ch <- v } - close(ch); + close(ch) }) } // Drop returns an Iterable that returns each element of iter after the first n elements. func Drop(iter Iterable, n int) Iterable { return iterFunc(func(ch chan<- interface{}) { - m := n; + m := n for v := range iter.Iter() { if m > 0 { - m--; - continue; + m-- + continue } - ch <- v; + ch <- v } - close(ch); + close(ch) }) } // DropWhile returns an Iterable that returns each element of iter after the initial sequence for which f returns true. func DropWhile(iter Iterable, f func(interface{}) bool) Iterable { return iterFunc(func(ch chan<- interface{}) { - drop := true; + drop := true for v := range iter.Iter() { if drop { if f(v) { continue } - drop = false; + drop = false } - ch <- v; + ch <- v } - close(ch); + close(ch) }) } @@ -211,7 +211,7 @@ func Chain(args []Iterable) Iterable { ch <- v } } - close(ch); + close(ch) }) } @@ -220,23 +220,23 @@ func Chain(args []Iterable) Iterable { // the lengths of the input Iterables. func Zip(args []Iterable) Iterable { return iterFunc(func(ch chan<- interface{}) { - defer close(ch); + defer close(ch) if len(args) == 0 { return } - iters := make([]<-chan interface{}, len(args)); + iters := make([]<-chan interface{}, len(args)) for i := 0; i < len(iters); i++ { iters[i] = args[i].Iter() } for { - out := make([]interface{}, len(args)); + out := make([]interface{}, len(args)) for i, v := range iters { - out[i] = <-v; + out[i] = <-v if closed(v) { return } } - ch <- out; + ch <- out } }) } @@ -244,16 +244,16 @@ func Zip(args []Iterable) Iterable { // ZipWith returns an Iterable containing the result of executing f using arguments read from a and b. func ZipWith2(f func(c, d interface{}) interface{}, a, b Iterable) Iterable { return Map(Zip([]Iterable{a, b}), func(a1 interface{}) interface{} { - arr := a1.([]interface{}); - return f(arr[0], arr[1]); + arr := a1.([]interface{}) + return f(arr[0], arr[1]) }) } // ZipWith returns an Iterable containing the result of executing f using arguments read from a, b and c. func ZipWith3(f func(d, e, f interface{}) interface{}, a, b, c Iterable) Iterable { return Map(Zip([]Iterable{a, b, c}), func(a1 interface{}) interface{} { - arr := a1.([]interface{}); - return f(arr[0], arr[1], arr[2]); + arr := a1.([]interface{}) + return f(arr[0], arr[1], arr[2]) }) } @@ -261,8 +261,8 @@ func ZipWith3(f func(d, e, f interface{}) interface{}, a, b, c Iterable) Iterabl // with indexes in [start, stop). func Slice(iter Iterable, start, stop int) Iterable { return iterFunc(func(ch chan<- interface{}) { - defer close(ch); - i := 0; + defer close(ch) + i := 0 for v := range iter.Iter() { switch { case i >= stop: @@ -270,7 +270,7 @@ func Slice(iter Iterable, start, stop int) Iterable { case i >= start: ch <- v } - i++; + i++ } }) } @@ -290,23 +290,23 @@ func RepeatTimes(v interface{}, n int) Iterable { for i := 0; i < n; i++ { ch <- v } - close(ch); + close(ch) }) } // Group is the type for elements returned by the GroupBy function. type Group struct { - Key interface{}; // key value for matching items - Vals Iterable; // Iterable for receiving values in the group + Key interface{} // key value for matching items + Vals Iterable // Iterable for receiving values in the group } // Key defines the interface required by the GroupBy function. type Grouper interface { // Return the key for the given value - Key(interface{}) interface{}; + Key(interface{}) interface{} // Compute equality for the given keys - Equal(a, b interface{}) bool; + Equal(a, b interface{}) bool } // GroupBy combines sequences of logically identical values from iter using k @@ -317,23 +317,23 @@ type Grouper interface { func GroupBy(iter Iterable, k Grouper) Iterable { return iterFunc(func(ch chan<- interface{}) { var curkey interface{} - var lst *list.List; + var lst *list.List // Basic strategy is to read one group at a time into a list prior to emitting the Group value for v := range iter.Iter() { - kv := k.Key(v); + kv := k.Key(v) if lst == nil || !k.Equal(curkey, kv) { if lst != nil { ch <- Group{curkey, lst} } - lst = list.New(); - curkey = kv; + lst = list.New() + curkey = kv } - lst.PushBack(v); + lst.PushBack(v) } if lst != nil { ch <- Group{curkey, lst} } - close(ch); + close(ch) }) } diff --git a/src/pkg/exp/iterable/iterable_test.go b/src/pkg/exp/iterable/iterable_test.go index 242a725a9..1d60d4b91 100644 --- a/src/pkg/exp/iterable/iterable_test.go +++ b/src/pkg/exp/iterable/iterable_test.go @@ -5,42 +5,42 @@ package iterable import ( - "container/vector"; - "testing"; + "container/vector" + "testing" ) func TestArrayTypes(t *testing.T) { // Test that conversion works correctly. - bytes := ByteArray([]byte{1, 2, 3}); + bytes := ByteArray([]byte{1, 2, 3}) if x := Data(bytes)[1].(byte); x != 2 { t.Error("Data(bytes)[1].(byte) = %v, want 2", x) } - ints := IntArray([]int{1, 2, 3}); + ints := IntArray([]int{1, 2, 3}) if x := Data(ints)[2].(int); x != 3 { t.Error("Data(ints)[2].(int) = %v, want 3", x) } - floats := FloatArray([]float{1, 2, 3}); + floats := FloatArray([]float{1, 2, 3}) if x := Data(floats)[0].(float); x != 1 { t.Error("Data(floats)[0].(float) = %v, want 1", x) } - strings := StringArray([]string{"a", "b", "c"}); + strings := StringArray([]string{"a", "b", "c"}) if x := Data(strings)[1].(string); x != "b" { t.Error(`Data(strings)[1].(string) = %q, want "b"`, x) } } var ( - oneToFive = IntArray{1, 2, 3, 4, 5}; - sixToTen = IntArray{6, 7, 8, 9, 10}; - elevenToTwenty = IntArray{11, 12, 13, 14, 15, 16, 17, 18, 19, 20}; + oneToFive = IntArray{1, 2, 3, 4, 5} + sixToTen = IntArray{6, 7, 8, 9, 10} + elevenToTwenty = IntArray{11, 12, 13, 14, 15, 16, 17, 18, 19, 20} ) -func isNegative(n interface{}) bool { return n.(int) < 0 } -func isPositive(n interface{}) bool { return n.(int) > 0 } -func isAbove3(n interface{}) bool { return n.(int) > 3 } -func isEven(n interface{}) bool { return n.(int)%2 == 0 } -func doubler(n interface{}) interface{} { return n.(int) * 2 } -func addOne(n interface{}) interface{} { return n.(int) + 1 } +func isNegative(n interface{}) bool { return n.(int) < 0 } +func isPositive(n interface{}) bool { return n.(int) > 0 } +func isAbove3(n interface{}) bool { return n.(int) > 3 } +func isEven(n interface{}) bool { return n.(int)%2 == 0 } +func doubler(n interface{}) interface{} { return n.(int) * 2 } +func addOne(n interface{}) interface{} { return n.(int) + 1 } func adder(acc interface{}, n interface{}) interface{} { return acc.(int) + n.(int) } @@ -49,13 +49,13 @@ func adder(acc interface{}, n interface{}) interface{} { type integerStream struct{} func (i integerStream) Iter() <-chan interface{} { - ch := make(chan interface{}); + ch := make(chan interface{}) go func() { for i := 0; ; i++ { ch <- i } - }(); - return ch; + }() + return ch } func TestAll(t *testing.T) { @@ -78,236 +78,236 @@ func TestAny(t *testing.T) { func assertArraysAreEqual(t *testing.T, res []interface{}, expected []int) { if len(res) != len(expected) { - t.Errorf("len(res) = %v, want %v", len(res), len(expected)); - goto missing; + t.Errorf("len(res) = %v, want %v", len(res), len(expected)) + goto missing } for i := range res { if v := res[i].(int); v != expected[i] { - t.Errorf("res[%v] = %v, want %v", i, v, expected[i]); - goto missing; + t.Errorf("res[%v] = %v, want %v", i, v, expected[i]) + goto missing } } - return; + return missing: - t.Errorf("res = %v\nwant %v", res, expected); + t.Errorf("res = %v\nwant %v", res, expected) } func TestFilter(t *testing.T) { - ints := integerStream{}; - moreInts := Filter(ints, isAbove3).Iter(); - res := make([]interface{}, 3); + ints := integerStream{} + moreInts := Filter(ints, isAbove3).Iter() + res := make([]interface{}, 3) for i := 0; i < 3; i++ { res[i] = <-moreInts } - assertArraysAreEqual(t, res, []int{4, 5, 6}); + assertArraysAreEqual(t, res, []int{4, 5, 6}) } func TestFind(t *testing.T) { - ints := integerStream{}; - first := Find(ints, isAbove3); + ints := integerStream{} + first := Find(ints, isAbove3) if first.(int) != 4 { t.Errorf("Find(ints, isAbove3) = %v, want 4", first) } } func TestInject(t *testing.T) { - res := Inject(oneToFive, 0, adder); + res := Inject(oneToFive, 0, adder) if res.(int) != 15 { t.Errorf("Inject(oneToFive, 0, adder) = %v, want 15", res) } } func TestMap(t *testing.T) { - res := Data(Map(Map(oneToFive, doubler), addOne)); - assertArraysAreEqual(t, res, []int{3, 5, 7, 9, 11}); + res := Data(Map(Map(oneToFive, doubler), addOne)) + assertArraysAreEqual(t, res, []int{3, 5, 7, 9, 11}) } func TestPartition(t *testing.T) { - ti, fi := Partition(oneToFive, isEven); - assertArraysAreEqual(t, Data(ti), []int{2, 4}); - assertArraysAreEqual(t, Data(fi), []int{1, 3, 5}); + ti, fi := Partition(oneToFive, isEven) + assertArraysAreEqual(t, Data(ti), []int{2, 4}) + assertArraysAreEqual(t, Data(fi), []int{1, 3, 5}) } func TestTake(t *testing.T) { - res := Take(oneToFive, 2); - assertArraysAreEqual(t, Data(res), []int{1, 2}); - assertArraysAreEqual(t, Data(res), []int{1, 2}); // second test to ensure that .Iter() returns a new channel + res := Take(oneToFive, 2) + assertArraysAreEqual(t, Data(res), []int{1, 2}) + assertArraysAreEqual(t, Data(res), []int{1, 2}) // second test to ensure that .Iter() returns a new channel // take none - res = Take(oneToFive, 0); - assertArraysAreEqual(t, Data(res), []int{}); + res = Take(oneToFive, 0) + assertArraysAreEqual(t, Data(res), []int{}) // try to take more than available - res = Take(oneToFive, 20); - assertArraysAreEqual(t, Data(res), oneToFive); + res = Take(oneToFive, 20) + assertArraysAreEqual(t, Data(res), oneToFive) } func TestTakeWhile(t *testing.T) { // take some - res := TakeWhile(oneToFive, func(v interface{}) bool { return v.(int) <= 3 }); - assertArraysAreEqual(t, Data(res), []int{1, 2, 3}); - assertArraysAreEqual(t, Data(res), []int{1, 2, 3}); // second test to ensure that .Iter() returns a new channel + res := TakeWhile(oneToFive, func(v interface{}) bool { return v.(int) <= 3 }) + assertArraysAreEqual(t, Data(res), []int{1, 2, 3}) + assertArraysAreEqual(t, Data(res), []int{1, 2, 3}) // second test to ensure that .Iter() returns a new channel // take none - res = TakeWhile(oneToFive, func(v interface{}) bool { return v.(int) > 3000 }); - assertArraysAreEqual(t, Data(res), []int{}); + res = TakeWhile(oneToFive, func(v interface{}) bool { return v.(int) > 3000 }) + assertArraysAreEqual(t, Data(res), []int{}) // take all - res = TakeWhile(oneToFive, func(v interface{}) bool { return v.(int) < 3000 }); - assertArraysAreEqual(t, Data(res), oneToFive); + res = TakeWhile(oneToFive, func(v interface{}) bool { return v.(int) < 3000 }) + assertArraysAreEqual(t, Data(res), oneToFive) } func TestDrop(t *testing.T) { // drop none - res := Drop(oneToFive, 0); - assertArraysAreEqual(t, Data(res), oneToFive); - assertArraysAreEqual(t, Data(res), oneToFive); // second test to ensure that .Iter() returns a new channel + res := Drop(oneToFive, 0) + assertArraysAreEqual(t, Data(res), oneToFive) + assertArraysAreEqual(t, Data(res), oneToFive) // second test to ensure that .Iter() returns a new channel // drop some - res = Drop(oneToFive, 2); - assertArraysAreEqual(t, Data(res), []int{3, 4, 5}); - assertArraysAreEqual(t, Data(res), []int{3, 4, 5}); // second test to ensure that .Iter() returns a new channel + res = Drop(oneToFive, 2) + assertArraysAreEqual(t, Data(res), []int{3, 4, 5}) + assertArraysAreEqual(t, Data(res), []int{3, 4, 5}) // second test to ensure that .Iter() returns a new channel // drop more than available - res = Drop(oneToFive, 88); - assertArraysAreEqual(t, Data(res), []int{}); + res = Drop(oneToFive, 88) + assertArraysAreEqual(t, Data(res), []int{}) } func TestDropWhile(t *testing.T) { // drop some - res := DropWhile(oneToFive, func(v interface{}) bool { return v.(int) < 3 }); - assertArraysAreEqual(t, Data(res), []int{3, 4, 5}); - assertArraysAreEqual(t, Data(res), []int{3, 4, 5}); // second test to ensure that .Iter() returns a new channel + res := DropWhile(oneToFive, func(v interface{}) bool { return v.(int) < 3 }) + assertArraysAreEqual(t, Data(res), []int{3, 4, 5}) + assertArraysAreEqual(t, Data(res), []int{3, 4, 5}) // second test to ensure that .Iter() returns a new channel // test case where all elements are dropped - res = DropWhile(oneToFive, func(v interface{}) bool { return v.(int) < 100 }); - assertArraysAreEqual(t, Data(res), []int{}); + res = DropWhile(oneToFive, func(v interface{}) bool { return v.(int) < 100 }) + assertArraysAreEqual(t, Data(res), []int{}) // test case where none are dropped - res = DropWhile(oneToFive, func(v interface{}) bool { return v.(int) > 1000 }); - assertArraysAreEqual(t, Data(res), oneToFive); + res = DropWhile(oneToFive, func(v interface{}) bool { return v.(int) > 1000 }) + assertArraysAreEqual(t, Data(res), oneToFive) } func TestCycle(t *testing.T) { - res := Cycle(oneToFive); - exp := []int{1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4}; + res := Cycle(oneToFive) + exp := []int{1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4} // read the first nineteen values from the iterable - out := make([]interface{}, 19); + out := make([]interface{}, 19) for i, it := 0, res.Iter(); i < 19; i++ { out[i] = <-it } - assertArraysAreEqual(t, out, exp); + assertArraysAreEqual(t, out, exp) - res2 := Cycle(sixToTen); - exp2 := []int{6, 7, 8, 9, 10, 6, 7, 8, 9, 10, 6, 7, 8, 9, 10, 6, 7, 8, 9}; + res2 := Cycle(sixToTen) + exp2 := []int{6, 7, 8, 9, 10, 6, 7, 8, 9, 10, 6, 7, 8, 9, 10, 6, 7, 8, 9} for i, it := 0, res2.Iter(); i < 19; i++ { out[i] = <-it } - assertArraysAreEqual(t, out, exp2); + assertArraysAreEqual(t, out, exp2) // ensure first iterator was not harmed for i, it := 0, res.Iter(); i < 19; i++ { out[i] = <-it } - assertArraysAreEqual(t, out, exp); + assertArraysAreEqual(t, out, exp) } func TestChain(t *testing.T) { - exp := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20}; - res := Chain([]Iterable{oneToFive, sixToTen, elevenToTwenty}); - assertArraysAreEqual(t, Data(res), exp); + exp := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20} + res := Chain([]Iterable{oneToFive, sixToTen, elevenToTwenty}) + assertArraysAreEqual(t, Data(res), exp) // reusing the same iterator should produce the same result again - assertArraysAreEqual(t, Data(res), exp); + assertArraysAreEqual(t, Data(res), exp) // test short read from Chain - i := 0; - out := make([]interface{}, 4); + i := 0 + out := make([]interface{}, 4) for v := range res.Iter() { - out[i] = v; - i++; + out[i] = v + i++ if i == len(out) { break } } - assertArraysAreEqual(t, out, exp[0:4]); + assertArraysAreEqual(t, out, exp[0:4]) // test zero length array - res = Chain([]Iterable{}); - assertArraysAreEqual(t, Data(res), []int{}); + res = Chain([]Iterable{}) + assertArraysAreEqual(t, Data(res), []int{}) } func TestZipWith(t *testing.T) { - exp := []int{7, 9, 11, 13, 15}; + exp := []int{7, 9, 11, 13, 15} // f with 2 args and 1 return value - f := func(a, b interface{}) interface{} { return a.(int) + b.(int) }; - res := ZipWith2(f, oneToFive, sixToTen); - assertArraysAreEqual(t, Data(res), exp); + f := func(a, b interface{}) interface{} { return a.(int) + b.(int) } + res := ZipWith2(f, oneToFive, sixToTen) + assertArraysAreEqual(t, Data(res), exp) // test again to make sure returns new iter each time - assertArraysAreEqual(t, Data(res), exp); + assertArraysAreEqual(t, Data(res), exp) // test a function with 3 args - f2 := func(a, b, c interface{}) interface{} { return a.(int) + b.(int) + c.(int) }; - res = ZipWith3(f2, oneToFive, sixToTen, oneToFive); - exp = []int{8, 11, 14, 17, 20}; - assertArraysAreEqual(t, Data(res), exp); + f2 := func(a, b, c interface{}) interface{} { return a.(int) + b.(int) + c.(int) } + res = ZipWith3(f2, oneToFive, sixToTen, oneToFive) + exp = []int{8, 11, 14, 17, 20} + assertArraysAreEqual(t, Data(res), exp) // test a function with multiple values returned - f3 := func(a, b interface{}) interface{} { return ([]interface{}{a.(int) + 1, b.(int) + 1}) }; - res = ZipWith2(f3, oneToFive, sixToTen); + f3 := func(a, b interface{}) interface{} { return ([]interface{}{a.(int) + 1, b.(int) + 1}) } + res = ZipWith2(f3, oneToFive, sixToTen) - exp2 := [][]int{[]int{2, 7}, []int{3, 8}, []int{4, 9}, []int{5, 10}, []int{6, 11}}; - i := 0; + exp2 := [][]int{[]int{2, 7}, []int{3, 8}, []int{4, 9}, []int{5, 10}, []int{6, 11}} + i := 0 for v := range res.Iter() { - out := v.([]interface{}); - assertArraysAreEqual(t, out, exp2[i]); - i++; + out := v.([]interface{}) + assertArraysAreEqual(t, out, exp2[i]) + i++ } // test different length iterators--should stop after shortest is exhausted - res = ZipWith2(f, elevenToTwenty, oneToFive); - exp = []int{12, 14, 16, 18, 20}; - assertArraysAreEqual(t, Data(res), exp); + res = ZipWith2(f, elevenToTwenty, oneToFive) + exp = []int{12, 14, 16, 18, 20} + assertArraysAreEqual(t, Data(res), exp) } func TestSlice(t *testing.T) { - out := Data(Slice(elevenToTwenty, 2, 6)); - exp := []int{13, 14, 15, 16}; - assertArraysAreEqual(t, out, exp); + out := Data(Slice(elevenToTwenty, 2, 6)) + exp := []int{13, 14, 15, 16} + assertArraysAreEqual(t, out, exp) // entire iterable - out = Data(Slice(elevenToTwenty, 0, len(elevenToTwenty))); - exp = []int{11, 12, 13, 14, 15, 16, 17, 18, 19, 20}; - assertArraysAreEqual(t, out, exp); + out = Data(Slice(elevenToTwenty, 0, len(elevenToTwenty))) + exp = []int{11, 12, 13, 14, 15, 16, 17, 18, 19, 20} + assertArraysAreEqual(t, out, exp) // empty slice at offset 0 - exp = []int{}; - out = Data(Slice(elevenToTwenty, 0, 0)); - assertArraysAreEqual(t, out, exp); + exp = []int{} + out = Data(Slice(elevenToTwenty, 0, 0)) + assertArraysAreEqual(t, out, exp) // slice upper bound exceeds length of iterable - exp = []int{1, 2, 3, 4, 5}; - out = Data(Slice(oneToFive, 0, 88)); - assertArraysAreEqual(t, out, exp); + exp = []int{1, 2, 3, 4, 5} + out = Data(Slice(oneToFive, 0, 88)) + assertArraysAreEqual(t, out, exp) // slice upper bounce is lower than lower bound - exp = []int{}; - out = Data(Slice(oneToFive, 93, 4)); - assertArraysAreEqual(t, out, exp); + exp = []int{} + out = Data(Slice(oneToFive, 93, 4)) + assertArraysAreEqual(t, out, exp) // slice lower bound is greater than len of iterable - exp = []int{}; - out = Data(Slice(oneToFive, 93, 108)); - assertArraysAreEqual(t, out, exp); + exp = []int{} + out = Data(Slice(oneToFive, 93, 108)) + assertArraysAreEqual(t, out, exp) } func TestRepeat(t *testing.T) { - res := Repeat(42); - i := 0; + res := Repeat(42) + i := 0 for v := range res.Iter() { if v.(int) != 42 { t.Fatal("Repeat returned the wrong value") @@ -315,25 +315,25 @@ func TestRepeat(t *testing.T) { if i == 9 { break } - i++; + i++ } } func TestRepeatTimes(t *testing.T) { - res := RepeatTimes(84, 9); - exp := []int{84, 84, 84, 84, 84, 84, 84, 84, 84}; - assertArraysAreEqual(t, Data(res), exp); - assertArraysAreEqual(t, Data(res), exp); // second time to ensure new iter is returned + res := RepeatTimes(84, 9) + exp := []int{84, 84, 84, 84, 84, 84, 84, 84, 84} + assertArraysAreEqual(t, Data(res), exp) + assertArraysAreEqual(t, Data(res), exp) // second time to ensure new iter is returned // 0 repeat - res = RepeatTimes(7, 0); - exp = []int{}; - assertArraysAreEqual(t, Data(res), exp); + res = RepeatTimes(7, 0) + exp = []int{} + assertArraysAreEqual(t, Data(res), exp) // negative repeat - res = RepeatTimes(7, -3); - exp = []int{}; - assertArraysAreEqual(t, Data(res), exp); + res = RepeatTimes(7, -3) + exp = []int{} + assertArraysAreEqual(t, Data(res), exp) } // a type that implements Key for ints @@ -342,20 +342,20 @@ type intkey struct{} func (v intkey) Key(a interface{}) interface{} { return a } -func (v intkey) Equal(a, b interface{}) bool { return a.(int) == b.(int) } +func (v intkey) Equal(a, b interface{}) bool { return a.(int) == b.(int) } func TestGroupBy(t *testing.T) { - in := IntArray{1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5}; - exp := [][]int{[]int{1}, []int{2, 2}, []int{3, 3, 3}, []int{4, 4, 4, 4}, []int{5, 5, 5, 5, 5}}; - i := 0; + in := IntArray{1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5} + exp := [][]int{[]int{1}, []int{2, 2}, []int{3, 3, 3}, []int{4, 4, 4, 4}, []int{5, 5, 5, 5, 5}} + i := 0 for x := range GroupBy(in, intkey{}).Iter() { - gr := x.(Group); + gr := x.(Group) if gr.Key.(int) != i+1 { t.Fatal("group key wrong; expected", i+1, "but got", gr.Key.(int)) } - vals := Data(gr.Vals); - assertArraysAreEqual(t, vals, exp[i]); - i++; + vals := Data(gr.Vals) + assertArraysAreEqual(t, vals, exp[i]) + i++ } if i != 5 { t.Fatal("did not return expected number of groups") @@ -367,21 +367,21 @@ func TestGroupBy(t *testing.T) { } // test case with only uniques - var out vector.Vector; + var out vector.Vector for x := range GroupBy(elevenToTwenty, intkey{}).Iter() { out.Push(x.(Group).Key) } - assertArraysAreEqual(t, out.Data(), elevenToTwenty); + assertArraysAreEqual(t, out.Data(), elevenToTwenty) } func TestUnique(t *testing.T) { - in := IntArray([]int{1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5}); - exp := []int{1, 2, 3, 4, 5}; - res := Unique(in, intkey{}); - assertArraysAreEqual(t, Data(res), exp); - assertArraysAreEqual(t, Data(res), exp); // second time to ensure new iter is returned + in := IntArray([]int{1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5}) + exp := []int{1, 2, 3, 4, 5} + res := Unique(in, intkey{}) + assertArraysAreEqual(t, Data(res), exp) + assertArraysAreEqual(t, Data(res), exp) // second time to ensure new iter is returned // test case with only uniques - res = Unique(elevenToTwenty, intkey{}); - assertArraysAreEqual(t, Data(res), elevenToTwenty); + res = Unique(elevenToTwenty, intkey{}) + assertArraysAreEqual(t, Data(res), elevenToTwenty) } diff --git a/src/pkg/exp/nacl/av/av.go b/src/pkg/exp/nacl/av/av.go index 4c76aeb30..0ed275760 100644 --- a/src/pkg/exp/nacl/av/av.go +++ b/src/pkg/exp/nacl/av/av.go @@ -12,12 +12,12 @@ package av import ( - "exp/draw"; - "exp/nacl/srpc"; - "log"; - "os"; - "syscall"; - "unsafe"; + "exp/draw" + "exp/nacl/srpc" + "log" + "os" + "syscall" + "unsafe" ) var srpcEnabled = srpc.Enabled() @@ -26,44 +26,44 @@ var srpcEnabled = srpc.Enabled() // Subsystem values for Init. const ( - SubsystemVideo = 1 << iota; - SubsystemAudio; - SubsystemEmbed; + SubsystemVideo = 1 << iota + SubsystemAudio + SubsystemEmbed ) // SubsystemRawEvents; // Audio formats. const ( - AudioFormatStereo44K = iota; - AudioFormatStereo48K; + AudioFormatStereo44K = iota + AudioFormatStereo48K ) // A Window represents a connection to the Native Client window. // It implements draw.Context. type Window struct { - Embedded bool; // running as part of a web page? - *Image; // screen image + Embedded bool // running as part of a web page? + *Image // screen image - mousec chan draw.Mouse; - kbdc chan int; - quitc chan bool; - resizec chan bool; + mousec chan draw.Mouse + kbdc chan int + quitc chan bool + resizec chan bool } // *Window implements draw.Context var _ draw.Context = (*Window)(nil) -func (w *Window) KeyboardChan() <-chan int { return w.kbdc } +func (w *Window) KeyboardChan() <-chan int { return w.kbdc } func (w *Window) MouseChan() <-chan draw.Mouse { return w.mousec } -func (w *Window) QuitChan() <-chan bool { return w.quitc } +func (w *Window) QuitChan() <-chan bool { return w.quitc } -func (w *Window) ResizeChan() <-chan bool { return w.resizec } +func (w *Window) ResizeChan() <-chan bool { return w.resizec } -func (w *Window) Screen() draw.Image { return w.Image } +func (w *Window) Screen() draw.Image { return w.Image } // Init initializes the Native Client subsystems specified by subsys. // Init must be called before using any of the other functions @@ -77,18 +77,18 @@ func (w *Window) Screen() draw.Image { return w.Image } // If the SubsystemAudio flag is set, Init requests a connection to the // audio device carrying 44 kHz 16-bit stereo PCM audio samples. func Init(subsys int, dx, dy int) (*Window, os.Error) { - xsubsys := subsys; + xsubsys := subsys if srpcEnabled { - waitBridge(); - xsubsys &^= SubsystemVideo | SubsystemEmbed; + waitBridge() + xsubsys &^= SubsystemVideo | SubsystemEmbed } if xsubsys&SubsystemEmbed != 0 { return nil, os.NewError("not embedded") } - w := new(Window); - err := multimediaInit(xsubsys); + w := new(Window) + err := multimediaInit(xsubsys) if err != nil { return nil, err } @@ -97,33 +97,33 @@ func Init(subsys int, dx, dy int) (*Window, os.Error) { if dx, dy, err = videoInit(dx, dy); err != nil { return nil, err } - w.Image = newImage(dx, dy, bridge.pixel); - w.resizec = make(chan bool, 64); - w.kbdc = make(chan int, 64); - w.mousec = make(chan draw.Mouse, 64); - w.quitc = make(chan bool); + w.Image = newImage(dx, dy, bridge.pixel) + w.resizec = make(chan bool, 64) + w.kbdc = make(chan int, 64) + w.mousec = make(chan draw.Mouse, 64) + w.quitc = make(chan bool) } if subsys&SubsystemAudio != 0 { - var n int; + var n int if n, err = audioInit(AudioFormatStereo44K, 2048); err != nil { return nil, err } - println("audio", n); + println("audio", n) } if subsys&SubsystemVideo != 0 { go w.readEvents() } - return w, nil; + return w, nil } func (w *Window) FlushImage() { if w.Image == nil { return } - videoUpdate(w.Image.Linear); + videoUpdate(w.Image.Linear) } func multimediaInit(subsys int) (err os.Error) { @@ -132,45 +132,45 @@ func multimediaInit(subsys int) (err os.Error) { func videoInit(dx, dy int) (ndx, ndy int, err os.Error) { if srpcEnabled { - bridge.share.ready = 1; - return int(bridge.share.width), int(bridge.share.height), nil; + bridge.share.ready = 1 + return int(bridge.share.width), int(bridge.share.height), nil } if e := syscall.VideoInit(dx, dy); e != 0 { return 0, 0, os.NewSyscallError("video_init", int(e)) } - return dx, dy, nil; + return dx, dy, nil } func videoUpdate(data []Color) (err os.Error) { if srpcEnabled { - bridge.flushRPC.Call("upcall", nil); - return; + bridge.flushRPC.Call("upcall", nil) + return } - return os.NewSyscallError("video_update", syscall.VideoUpdate((*uint32)(&data[0]))); + return os.NewSyscallError("video_update", syscall.VideoUpdate((*uint32)(&data[0]))) } var noEvents = os.NewError("no events") func videoPollEvent(ev []byte) (err os.Error) { if srpcEnabled { - r := bridge.share.eq.ri; + r := bridge.share.eq.ri if r == bridge.share.eq.wi { return noEvents } - copy(ev, &bridge.share.eq.event[r]); - bridge.share.eq.ri = (r + 1) % eqsize; - return nil; + 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])); + return os.NewSyscallError("video_poll_event", syscall.VideoPollEvent(&ev[0])) } func audioInit(fmt int, want int) (got int, err os.Error) { - var x int; - e := syscall.AudioInit(fmt, want, &x); + var x int + e := syscall.AudioInit(fmt, want, &x) if e == 0 { return x, nil } - return 0, os.NewSyscallError("audio_init", e); + return 0, os.NewSyscallError("audio_init", e) } var audioSize uintptr @@ -185,8 +185,8 @@ var audioSize uintptr // func AudioStream(data []uint16) (nextSize int, err os.Error) { if audioSize == 0 { - e := os.NewSyscallError("audio_stream", syscall.AudioStream(nil, &audioSize)); - return int(audioSize), e; + e := os.NewSyscallError("audio_stream", syscall.AudioStream(nil, &audioSize)) + return int(audioSize), e } if data == nil { return int(audioSize), nil @@ -194,19 +194,19 @@ func AudioStream(data []uint16) (nextSize int, err os.Error) { if uintptr(len(data))*2 != audioSize { log.Stdoutf("invalid audio size want %d got %d", audioSize, len(data)) } - e := os.NewSyscallError("audio_stream", syscall.AudioStream(&data[0], &audioSize)); - return int(audioSize), e; + e := os.NewSyscallError("audio_stream", syscall.AudioStream(&data[0], &audioSize)) + return int(audioSize), e } // Synchronization structure to wait for bridge to become ready. var bridge struct { - c chan bool; - displayFd int; - rpcFd int; - share *videoShare; - pixel []Color; - client *srpc.Client; - flushRPC *srpc.RPC; + c chan bool + displayFd int + rpcFd int + share *videoShare + pixel []Color + client *srpc.Client + flushRPC *srpc.RPC } // Wait for bridge to become ready. @@ -214,29 +214,29 @@ var bridge struct { // so this blocks. Once the bridge is ready, multimediaBridge.Run // will drop a value into the channel. Then any calls // to waitBridge will finish, taking the value out and immediately putting it back. -func waitBridge() { bridge.c <- <-bridge.c } +func waitBridge() { bridge.c <- <-bridge.c } const eqsize = 64 // Data structure shared with host via mmap. type videoShare struct { - revision int32; // definition below is rev 100 unless noted - mapSize int32; + revision int32 // definition below is rev 100 unless noted + mapSize int32 // event queue - eq struct { - ri uint32; // read index [0,eqsize) - wi uint32; // write index [0,eqsize) - eof int32; - event [eqsize][64]byte; - }; + eq struct { + ri uint32 // read index [0,eqsize) + wi uint32 // write index [0,eqsize) + eof int32 + event [eqsize][64]byte + } // now unused - _, _, _, _ int32; + _, _, _, _ int32 // video backing store information - width, height, _, size int32; - ready int32; // rev 0x101 + width, height, _, size int32 + ready int32 // rev 0x101 } // The frame buffer data is videoShareSize bytes after @@ -249,10 +249,10 @@ type multimediaBridge struct{} // one to mmap to get the display memory, and another to use for SRPCs back // to the main process. func (multimediaBridge) Run(arg, ret []interface{}, size []int) srpc.Errno { - bridge.displayFd = arg[0].(int); - bridge.rpcFd = arg[1].(int); + bridge.displayFd = arg[0].(int) + bridge.rpcFd = arg[1].(int) - var st syscall.Stat_t; + var st syscall.Stat_t if errno := syscall.Fstat(bridge.displayFd, &st); errno != 0 { log.Exitf("mmbridge stat display: %s", os.Errno(errno)) } @@ -263,36 +263,36 @@ func (multimediaBridge) Run(arg, ret []interface{}, size []int) srpc.Errno { syscall.PROT_READ|syscall.PROT_WRITE, syscall.MAP_SHARED, uintptr(bridge.displayFd), - 0); + 0) if errno != 0 { log.Exitf("mmap display: %s", os.Errno(errno)) } - bridge.share = (*videoShare)(unsafe.Pointer(addr)); + bridge.share = (*videoShare)(unsafe.Pointer(addr)) // Overestimate frame buffer size // (must use a compile-time constant) // and then reslice. 256 megapixels (1 GB) should be enough. - fb := (*[256 * 1024 * 1024]Color)(unsafe.Pointer(addr + videoShareSize)); - bridge.pixel = fb[0 : (st.Size-videoShareSize)/4]; + fb := (*[256 * 1024 * 1024]Color)(unsafe.Pointer(addr + videoShareSize)) + bridge.pixel = fb[0 : (st.Size-videoShareSize)/4] // Configure RPC connection back to client. - var err os.Error; - bridge.client, err = srpc.NewClient(bridge.rpcFd); + var err os.Error + bridge.client, err = srpc.NewClient(bridge.rpcFd) if err != nil { log.Exitf("NewClient: %s", err) } - bridge.flushRPC = bridge.client.NewRPC(nil); + bridge.flushRPC = bridge.client.NewRPC(nil) // Notify waiters that the bridge is ready. - println("bridged", bridge.share.revision); - bridge.c <- true; + println("bridged", bridge.share.revision) + bridge.c <- true - return srpc.OK; + return srpc.OK } func init() { - bridge.c = make(chan bool, 1); + bridge.c = make(chan bool, 1) if srpcEnabled { srpc.Add("nacl_multimedia_bridge", "hh:", multimediaBridge{}) } diff --git a/src/pkg/exp/nacl/av/event.go b/src/pkg/exp/nacl/av/event.go index 32d9e98c5..11405c980 100644 --- a/src/pkg/exp/nacl/av/event.go +++ b/src/pkg/exp/nacl/av/event.go @@ -10,365 +10,365 @@ package av import ( - "encoding/binary"; - "exp/draw"; - "log"; - "os"; - "time"; + "encoding/binary" + "exp/draw" + "log" + "os" + "time" ) // An eventType identifies the type of a Native Client Event. type eventType uint8 const ( - eventActive = 1 + iota; - eventExpose; - eventKeyDown; - eventKeyUp; - eventMouseMotion; - eventMouseButtonDown; - eventMouseButtonUp; - eventQuit; - eventUnsupported; + eventActive = 1 + iota + eventExpose + eventKeyDown + eventKeyUp + eventMouseMotion + eventMouseButtonDown + eventMouseButtonUp + eventQuit + eventUnsupported ) // A key represents a key on a keyboard. type key uint16 const ( - keyUnknown = 0; - keyFirst = 0; - keyBackspace = 8; - keyTab = 9; - keyClear = 12; - keyReturn = 13; - keyPause = 19; - keyEscape = 27; - keySpace = 32; - keyExclaim = 33; - keyQuotedbl = 34; - keyHash = 35; - keyDollar = 36; - keyAmpersand = 38; - keyQuote = 39; - keyLeftparen = 40; - keyRightparen = 41; - keyAsterisk = 42; - keyPlus = 43; - keyComma = 44; - keyMinus = 45; - keyPeriod = 46; - keySlash = 47; - key0 = 48; - key1 = 49; - key2 = 50; - key3 = 51; - key4 = 52; - key5 = 53; - key6 = 54; - key7 = 55; - key8 = 56; - key9 = 57; - keyColon = 58; - keySemicolon = 59; - keyLess = 60; - keyEquals = 61; - keyGreater = 62; - keyQuestion = 63; - keyAt = 64; - keyLeftbracket = 91; - keyBackslash = 92; - keyRightbracket = 93; - keyCaret = 94; - keyUnderscore = 95; - keyBackquote = 96; - keyA = 97; - keyB = 98; - keyC = 99; - keyD = 100; - keyE = 101; - keyF = 102; - keyG = 103; - keyH = 104; - keyI = 105; - keyJ = 106; - keyK = 107; - keyL = 108; - keyM = 109; - keyN = 110; - keyO = 111; - keyP = 112; - keyQ = 113; - keyR = 114; - keyS = 115; - keyT = 116; - keyU = 117; - keyV = 118; - keyW = 119; - keyX = 120; - keyY = 121; - keyZ = 122; - keyDelete = 127; - keyWorld0 = 160; - keyWorld1 = 161; - keyWorld2 = 162; - keyWorld3 = 163; - keyWorld4 = 164; - keyWorld5 = 165; - keyWorld6 = 166; - keyWorld7 = 167; - keyWorld8 = 168; - keyWorld9 = 169; - keyWorld10 = 170; - keyWorld11 = 171; - keyWorld12 = 172; - keyWorld13 = 173; - keyWorld14 = 174; - keyWorld15 = 175; - keyWorld16 = 176; - keyWorld17 = 177; - keyWorld18 = 178; - keyWorld19 = 179; - keyWorld20 = 180; - keyWorld21 = 181; - keyWorld22 = 182; - keyWorld23 = 183; - keyWorld24 = 184; - keyWorld25 = 185; - keyWorld26 = 186; - keyWorld27 = 187; - keyWorld28 = 188; - keyWorld29 = 189; - keyWorld30 = 190; - keyWorld31 = 191; - keyWorld32 = 192; - keyWorld33 = 193; - keyWorld34 = 194; - keyWorld35 = 195; - keyWorld36 = 196; - keyWorld37 = 197; - keyWorld38 = 198; - keyWorld39 = 199; - keyWorld40 = 200; - keyWorld41 = 201; - keyWorld42 = 202; - keyWorld43 = 203; - keyWorld44 = 204; - keyWorld45 = 205; - keyWorld46 = 206; - keyWorld47 = 207; - keyWorld48 = 208; - keyWorld49 = 209; - keyWorld50 = 210; - keyWorld51 = 211; - keyWorld52 = 212; - keyWorld53 = 213; - keyWorld54 = 214; - keyWorld55 = 215; - keyWorld56 = 216; - keyWorld57 = 217; - keyWorld58 = 218; - keyWorld59 = 219; - keyWorld60 = 220; - keyWorld61 = 221; - keyWorld62 = 222; - keyWorld63 = 223; - keyWorld64 = 224; - keyWorld65 = 225; - keyWorld66 = 226; - keyWorld67 = 227; - keyWorld68 = 228; - keyWorld69 = 229; - keyWorld70 = 230; - keyWorld71 = 231; - keyWorld72 = 232; - keyWorld73 = 233; - keyWorld74 = 234; - keyWorld75 = 235; - keyWorld76 = 236; - keyWorld77 = 237; - keyWorld78 = 238; - keyWorld79 = 239; - keyWorld80 = 240; - keyWorld81 = 241; - keyWorld82 = 242; - keyWorld83 = 243; - keyWorld84 = 244; - keyWorld85 = 245; - keyWorld86 = 246; - keyWorld87 = 247; - keyWorld88 = 248; - keyWorld89 = 249; - keyWorld90 = 250; - keyWorld91 = 251; - keyWorld92 = 252; - keyWorld93 = 253; - keyWorld94 = 254; - keyWorld95 = 255; + keyUnknown = 0 + keyFirst = 0 + keyBackspace = 8 + keyTab = 9 + keyClear = 12 + keyReturn = 13 + keyPause = 19 + keyEscape = 27 + keySpace = 32 + keyExclaim = 33 + keyQuotedbl = 34 + keyHash = 35 + keyDollar = 36 + keyAmpersand = 38 + keyQuote = 39 + keyLeftparen = 40 + keyRightparen = 41 + keyAsterisk = 42 + keyPlus = 43 + keyComma = 44 + keyMinus = 45 + keyPeriod = 46 + keySlash = 47 + key0 = 48 + key1 = 49 + key2 = 50 + key3 = 51 + key4 = 52 + key5 = 53 + key6 = 54 + key7 = 55 + key8 = 56 + key9 = 57 + keyColon = 58 + keySemicolon = 59 + keyLess = 60 + keyEquals = 61 + keyGreater = 62 + keyQuestion = 63 + keyAt = 64 + keyLeftbracket = 91 + keyBackslash = 92 + keyRightbracket = 93 + keyCaret = 94 + keyUnderscore = 95 + keyBackquote = 96 + keyA = 97 + keyB = 98 + keyC = 99 + keyD = 100 + keyE = 101 + keyF = 102 + keyG = 103 + keyH = 104 + keyI = 105 + keyJ = 106 + keyK = 107 + keyL = 108 + keyM = 109 + keyN = 110 + keyO = 111 + keyP = 112 + keyQ = 113 + keyR = 114 + keyS = 115 + keyT = 116 + keyU = 117 + keyV = 118 + keyW = 119 + keyX = 120 + keyY = 121 + keyZ = 122 + keyDelete = 127 + keyWorld0 = 160 + keyWorld1 = 161 + keyWorld2 = 162 + keyWorld3 = 163 + keyWorld4 = 164 + keyWorld5 = 165 + keyWorld6 = 166 + keyWorld7 = 167 + keyWorld8 = 168 + keyWorld9 = 169 + keyWorld10 = 170 + keyWorld11 = 171 + keyWorld12 = 172 + keyWorld13 = 173 + keyWorld14 = 174 + keyWorld15 = 175 + keyWorld16 = 176 + keyWorld17 = 177 + keyWorld18 = 178 + keyWorld19 = 179 + keyWorld20 = 180 + keyWorld21 = 181 + keyWorld22 = 182 + keyWorld23 = 183 + keyWorld24 = 184 + keyWorld25 = 185 + keyWorld26 = 186 + keyWorld27 = 187 + keyWorld28 = 188 + keyWorld29 = 189 + keyWorld30 = 190 + keyWorld31 = 191 + keyWorld32 = 192 + keyWorld33 = 193 + keyWorld34 = 194 + keyWorld35 = 195 + keyWorld36 = 196 + keyWorld37 = 197 + keyWorld38 = 198 + keyWorld39 = 199 + keyWorld40 = 200 + keyWorld41 = 201 + keyWorld42 = 202 + keyWorld43 = 203 + keyWorld44 = 204 + keyWorld45 = 205 + keyWorld46 = 206 + keyWorld47 = 207 + keyWorld48 = 208 + keyWorld49 = 209 + keyWorld50 = 210 + keyWorld51 = 211 + keyWorld52 = 212 + keyWorld53 = 213 + keyWorld54 = 214 + keyWorld55 = 215 + keyWorld56 = 216 + keyWorld57 = 217 + keyWorld58 = 218 + keyWorld59 = 219 + keyWorld60 = 220 + keyWorld61 = 221 + keyWorld62 = 222 + keyWorld63 = 223 + keyWorld64 = 224 + keyWorld65 = 225 + keyWorld66 = 226 + keyWorld67 = 227 + keyWorld68 = 228 + keyWorld69 = 229 + keyWorld70 = 230 + keyWorld71 = 231 + keyWorld72 = 232 + keyWorld73 = 233 + keyWorld74 = 234 + keyWorld75 = 235 + keyWorld76 = 236 + keyWorld77 = 237 + keyWorld78 = 238 + keyWorld79 = 239 + keyWorld80 = 240 + keyWorld81 = 241 + keyWorld82 = 242 + keyWorld83 = 243 + keyWorld84 = 244 + keyWorld85 = 245 + keyWorld86 = 246 + keyWorld87 = 247 + keyWorld88 = 248 + keyWorld89 = 249 + keyWorld90 = 250 + keyWorld91 = 251 + keyWorld92 = 252 + keyWorld93 = 253 + keyWorld94 = 254 + keyWorld95 = 255 // Numeric keypad - keyKp0 = 256; - keyKp1 = 257; - keyKp2 = 258; - keyKp3 = 259; - keyKp4 = 260; - keyKp5 = 261; - keyKp6 = 262; - keyKp7 = 263; - keyKp8 = 264; - keyKp9 = 265; - keyKpPeriod = 266; - keyKpDivide = 267; - keyKpMultiply = 268; - keyKpMinus = 269; - keyKpPlus = 270; - keyKpEnter = 271; - keyKpEquals = 272; + keyKp0 = 256 + keyKp1 = 257 + keyKp2 = 258 + keyKp3 = 259 + keyKp4 = 260 + keyKp5 = 261 + keyKp6 = 262 + keyKp7 = 263 + keyKp8 = 264 + keyKp9 = 265 + keyKpPeriod = 266 + keyKpDivide = 267 + keyKpMultiply = 268 + keyKpMinus = 269 + keyKpPlus = 270 + keyKpEnter = 271 + keyKpEquals = 272 // Arrow & insert/delete pad - keyUp = 273; - keyDown = 274; - keyRight = 275; - keyLeft = 276; - keyInsert = 277; - keyHome = 278; - keyEnd = 279; - keyPageup = 280; - keyPagedown = 281; + keyUp = 273 + keyDown = 274 + keyRight = 275 + keyLeft = 276 + keyInsert = 277 + keyHome = 278 + keyEnd = 279 + keyPageup = 280 + keyPagedown = 281 // Function keys - keyF1 = 282; - keyF2 = 283; - keyF3 = 284; - keyF4 = 285; - keyF5 = 286; - keyF6 = 287; - keyF7 = 288; - keyF8 = 289; - keyF9 = 290; - keyF10 = 291; - keyF11 = 292; - keyF12 = 293; - keyF13 = 294; - keyF14 = 295; - keyF15 = 296; + keyF1 = 282 + keyF2 = 283 + keyF3 = 284 + keyF4 = 285 + keyF5 = 286 + keyF6 = 287 + keyF7 = 288 + keyF8 = 289 + keyF9 = 290 + keyF10 = 291 + keyF11 = 292 + keyF12 = 293 + keyF13 = 294 + keyF14 = 295 + keyF15 = 296 // Modifier keys - keyNumlock = 300; - keyCapslock = 301; - keyScrollock = 302; - keyRshift = 303; - keyLshift = 304; - keyRctrl = 305; - keyLctrl = 306; - keyRalt = 307; - keyLalt = 308; - keyRmeta = 309; - keyLmeta = 310; - keyLsuper = 311; - keyRsuper = 312; - keyMode = 313; - keyCompose = 314; + keyNumlock = 300 + keyCapslock = 301 + keyScrollock = 302 + keyRshift = 303 + keyLshift = 304 + keyRctrl = 305 + keyLctrl = 306 + keyRalt = 307 + keyLalt = 308 + keyRmeta = 309 + keyLmeta = 310 + keyLsuper = 311 + keyRsuper = 312 + keyMode = 313 + keyCompose = 314 // Misc keys - keyHelp = 315; - keyPrint = 316; - keySysreq = 317; - keyBreak = 318; - keyMenu = 319; - keyPower = 320; - keyEuro = 321; - keyUndo = 322; + keyHelp = 315 + keyPrint = 316 + keySysreq = 317 + keyBreak = 318 + keyMenu = 319 + keyPower = 320 + keyEuro = 321 + keyUndo = 322 // Add any other keys here - keyLast; + keyLast ) // A keymod is a set of bit flags type keymod uint16 const ( - keymodNone = 0x0000; - keymodLshift = 0x0001; - keymodRshift = 0x0002; - keymodLctrl = 0x0040; - keymodRctrl = 0x0080; - keymodLalt = 0x0100; - keymodRalt = 0x0200; - keymodLmeta = 0x0400; - keymodRmeta = 0x0800; - keymodNum = 0x1000; - keymodCaps = 0x2000; - keymodMode = 0x4000; - keymodReserved = 0x8000; + keymodNone = 0x0000 + keymodLshift = 0x0001 + keymodRshift = 0x0002 + keymodLctrl = 0x0040 + keymodRctrl = 0x0080 + keymodLalt = 0x0100 + keymodRalt = 0x0200 + keymodLmeta = 0x0400 + keymodRmeta = 0x0800 + keymodNum = 0x1000 + keymodCaps = 0x2000 + keymodMode = 0x4000 + keymodReserved = 0x8000 ) const ( - mouseButtonLeft = 1; - mouseButtonMiddle = 2; - mouseButtonRight = 3; - mouseScrollUp = 4; - mouseScrollDown = 5; + mouseButtonLeft = 1 + mouseButtonMiddle = 2 + mouseButtonRight = 3 + mouseScrollUp = 4 + mouseScrollDown = 5 ) const ( - mouseStateLeftButtonPressed = 1; - mouseStateMiddleButtonPressed = 2; - mouseStateRightButtonPressed = 4; + mouseStateLeftButtonPressed = 1 + mouseStateMiddleButtonPressed = 2 + mouseStateRightButtonPressed = 4 ) const ( - activeMouse = 1; // mouse leaving/entering - activeInputFocus = 2; // input focus lost/restored - activeApplication = 4; // application minimized/restored + activeMouse = 1 // mouse leaving/entering + activeInputFocus = 2 // input focus lost/restored + activeApplication = 4 // application minimized/restored ) const maxEventBytes = 64 type activeEvent struct { - EventType eventType; - Gain uint8; - State uint8; + EventType eventType + Gain uint8 + State uint8 } type exposeEvent struct { - EventType eventType; + EventType eventType } type keyboardEvent struct { - EventType eventType; - Device uint8; - State uint8; - Pad uint8; - ScanCode uint8; - Pad1 uint8; - Key key; - Mod keymod; - Unicode uint16; + EventType eventType + Device uint8 + State uint8 + Pad uint8 + ScanCode uint8 + Pad1 uint8 + Key key + Mod keymod + Unicode uint16 } type mouseMotionEvent struct { - EventType eventType; - Device uint8; - Buttons uint8; - Pad uint8; - X uint16; - Y uint16; - Xrel int16; - Yrel int16; + EventType eventType + Device uint8 + Buttons uint8 + Pad uint8 + X uint16 + Y uint16 + Xrel int16 + Yrel int16 } type mouseButtonEvent struct { - EventType eventType; - Device uint8; - Button uint8; - State uint8; - X uint16; - Y uint16; + EventType eventType + Device uint8 + Button uint8 + State uint8 + X uint16 + Y uint16 } type quitEvent struct { - EventType eventType; + EventType eventType } type syncEvent struct{} @@ -378,64 +378,64 @@ type event interface{} type reader []byte func (r *reader) Read(p []byte) (n int, err os.Error) { - b := *r; + b := *r if len(b) == 0 && len(p) > 0 { return 0, os.EOF } - n = copy(p, b); - *r = b[n:]; - return; + n = copy(p, b) + *r = b[n:] + return } func (w *Window) readEvents() { - buf := make([]byte, maxEventBytes); - clean := false; + buf := make([]byte, maxEventBytes) + clean := false var ( - ea *activeEvent; - ee *exposeEvent; - ke *keyboardEvent; - mme *mouseMotionEvent; - mbe *mouseButtonEvent; - qe *quitEvent; + ea *activeEvent + ee *exposeEvent + ke *keyboardEvent + mme *mouseMotionEvent + mbe *mouseButtonEvent + qe *quitEvent ) - var m draw.Mouse; + var m draw.Mouse for { if err := videoPollEvent(buf); err != nil { if !clean { clean = w.resizec <- false } - time.Sleep(10e6); // 10ms - continue; + time.Sleep(10e6) // 10ms + continue } - clean = false; - var e event; + clean = false + var e event switch buf[0] { default: - log.Stdout("unsupported event type", buf[0]); - continue; + log.Stdout("unsupported event type", buf[0]) + continue case eventActive: - ea = new(activeEvent); - e = ea; + ea = new(activeEvent) + e = ea case eventExpose: - ee = new(exposeEvent); - e = ee; + ee = new(exposeEvent) + e = ee case eventKeyDown, eventKeyUp: - ke = new(keyboardEvent); - e = ke; + ke = new(keyboardEvent) + e = ke case eventMouseMotion: - mme = new(mouseMotionEvent); - e = mme; + mme = new(mouseMotionEvent) + e = mme case eventMouseButtonDown, eventMouseButtonUp: - mbe = new(mouseButtonEvent); - e = mbe; + mbe = new(mouseButtonEvent) + e = mbe case eventQuit: - qe = new(quitEvent); - e = qe; + qe = new(quitEvent) + e = qe } - r := reader(buf); + r := reader(buf) if err := binary.Read(&r, binary.LittleEndian, e); err != nil { - log.Stdout("unpacking %T event: %s", e, err); - continue; + log.Stdout("unpacking %T event: %s", e, err) + continue } // log.Stdoutf("%#v\n", e); switch buf[0] { @@ -446,25 +446,25 @@ func (w *Window) readEvents() { case eventKeyUp: w.kbdc <- -int(ke.Key) case eventMouseMotion: - m.X = int(mme.X); - m.Y = int(mme.Y); - m.Buttons = int(mme.Buttons); - m.Nsec = time.Nanoseconds(); - _ = w.mousec <- m; + m.X = int(mme.X) + m.Y = int(mme.Y) + m.Buttons = int(mme.Buttons) + m.Nsec = time.Nanoseconds() + _ = w.mousec <- m case eventMouseButtonDown: - m.X = int(mbe.X); - m.Y = int(mbe.Y); + m.X = int(mbe.X) + m.Y = int(mbe.Y) // TODO(rsc): Remove uint cast once 8g bug is fixed. - m.Buttons |= 1 << uint(mbe.Button-1); - m.Nsec = time.Nanoseconds(); - _ = w.mousec <- m; + m.Buttons |= 1 << uint(mbe.Button-1) + m.Nsec = time.Nanoseconds() + _ = w.mousec <- m case eventMouseButtonUp: - m.X = int(mbe.X); - m.Y = int(mbe.Y); + m.X = int(mbe.X) + m.Y = int(mbe.Y) // TODO(rsc): Remove uint cast once 8g bug is fixed. - m.Buttons &^= 1 << uint(mbe.Button-1); - m.Nsec = time.Nanoseconds(); - _ = w.mousec <- m; + m.Buttons &^= 1 << uint(mbe.Button-1) + m.Nsec = time.Nanoseconds() + _ = w.mousec <- m case eventQuit: w.quitc <- true } diff --git a/src/pkg/exp/nacl/av/image.go b/src/pkg/exp/nacl/av/image.go index 8e096d165..f69f94a65 100644 --- a/src/pkg/exp/nacl/av/image.go +++ b/src/pkg/exp/nacl/av/image.go @@ -5,7 +5,7 @@ package av import ( - "image"; + "image" ) // Native Client image format: @@ -16,41 +16,41 @@ import ( // linear slice or as a two-dimensional slice of slices. // Image implements image.Image. type Image struct { - Linear []Color; - Pixel [][]Color; + Linear []Color + Pixel [][]Color } var _ image.Image = (*Image)(nil) -func (m *Image) ColorModel() image.ColorModel { return ColorModel } +func (m *Image) ColorModel() image.ColorModel { return ColorModel } func (m *Image) Width() int { if len(m.Pixel) == 0 { return 0 } - return len(m.Pixel[0]); + return len(m.Pixel[0]) } -func (m *Image) Height() int { return len(m.Pixel) } +func (m *Image) Height() int { return len(m.Pixel) } -func (m *Image) At(x, y int) image.Color { return m.Pixel[y][x] } +func (m *Image) At(x, y int) image.Color { return m.Pixel[y][x] } func (m *Image) Set(x, y int, color image.Color) { if c, ok := color.(Color); ok { m.Pixel[y][x] = c } - m.Pixel[y][x] = makeColor(color.RGBA()); + m.Pixel[y][x] = makeColor(color.RGBA()) } func newImage(dx, dy int, linear []Color) *Image { if linear == nil { linear = make([]Color, dx*dy) } - pix := make([][]Color, dy); + pix := make([][]Color, dy) for i := range pix { pix[i] = linear[dx*i : dx*(i+1)] } - return &Image{linear, pix}; + return &Image{linear, pix} } // A Color represents a Native Client color value, @@ -58,20 +58,20 @@ func newImage(dx, dy int, linear []Color) *Image { type Color uint32 func (p Color) RGBA() (r, g, b, a uint32) { - x := uint32(p); - a = x >> 24; - a |= a << 8; - a |= a << 16; - r = (x >> 16) & 0xFF; - r |= r << 8; - r |= r << 16; - g = (x >> 8) & 0xFF; - g |= g << 8; - g |= g << 16; - b = x & 0xFF; - b |= b << 8; - b |= b << 16; - return; + x := uint32(p) + a = x >> 24 + a |= a << 8 + a |= a << 16 + r = (x >> 16) & 0xFF + r |= r << 8 + r |= r << 16 + g = (x >> 8) & 0xFF + g |= g << 8 + g |= g << 16 + b = x & 0xFF + b |= b << 8 + b |= b << 16 + return } func makeColor(r, g, b, a uint32) Color { @@ -82,7 +82,7 @@ func toColor(color image.Color) image.Color { if c, ok := color.(Color); ok { return c } - return makeColor(color.RGBA()); + return makeColor(color.RGBA()) } // ColorModel is the color model corresponding to the Native Client Color. diff --git a/src/pkg/exp/nacl/srpc/client.go b/src/pkg/exp/nacl/srpc/client.go index d19b48888..9e47376f8 100644 --- a/src/pkg/exp/nacl/srpc/client.go +++ b/src/pkg/exp/nacl/srpc/client.go @@ -6,48 +6,48 @@ package srpc import ( - "bytes"; - "log"; - "os"; - "sync"; + "bytes" + "log" + "os" + "sync" ) // A Client represents the client side of an SRPC connection. type Client struct { - fd int; // fd to server - r msgReceiver; - s msgSender; - service map[string]srv; // services by name - out chan *msg; // send to out to write to connection - - mu sync.Mutex; // protects pending, idGen - pending map[uint64]*RPC; - idGen uint64; // generator for request IDs + fd int // fd to server + r msgReceiver + s msgSender + service map[string]srv // services by name + out chan *msg // send to out to write to connection + + mu sync.Mutex // protects pending, idGen + pending map[uint64]*RPC + idGen uint64 // generator for request IDs } // A srv is a single method that the server offers. type srv struct { - num uint32; // method number - fmt string; // argument format + num uint32 // method number + fmt string // argument format } // An RPC represents a single RPC issued by a client. type RPC struct { - Ret []interface{}; // Return values - Done chan *RPC; // Channel where notification of done arrives - Errno Errno; // Status code - c *Client; - id uint64; // request id + Ret []interface{} // Return values + Done chan *RPC // Channel where notification of done arrives + Errno Errno // Status code + c *Client + id uint64 // request id } // NewClient allocates a new client using the file descriptor fd. func NewClient(fd int) (c *Client, err os.Error) { - c = new(Client); - c.fd = fd; - c.r.fd = fd; - c.s.fd = fd; - c.service = make(map[string]srv); - c.pending = make(map[uint64]*RPC); + c = new(Client) + c.fd = fd + c.r.fd = fd + c.s.fd = fd + c.service = make(map[string]srv) + c.pending = make(map[uint64]*RPC) // service discovery request m := &msg{ @@ -55,54 +55,54 @@ func NewClient(fd int) (c *Client, err os.Error) { isReq: true, Ret: []interface{}{[]byte(nil)}, Size: []int{4000}, - }; - m.packRequest(); - c.s.send(m); - m, err = c.r.recv(); + } + m.packRequest() + c.s.send(m) + m, err = c.r.recv() if err != nil { return nil, err } - m.unpackResponse(); + m.unpackResponse() if m.status != OK { - log.Stderrf("NewClient service_discovery: %s", m.status); - return nil, m.status; + log.Stderrf("NewClient service_discovery: %s", m.status) + return nil, m.status } for n, line := range bytes.Split(m.Ret[0].([]byte), []byte{'\n'}, 0) { - i := bytes.Index(line, []byte{':'}); + i := bytes.Index(line, []byte{':'}) if i < 0 { continue } - c.service[string(line[0:i])] = srv{uint32(n), string(line[i+1:])}; + c.service[string(line[0:i])] = srv{uint32(n), string(line[i+1:])} } - c.out = make(chan *msg); - go c.input(); - go c.output(); - return c, nil; + c.out = make(chan *msg) + go c.input() + go c.output() + return c, nil } func (c *Client) input() { for { - m, err := c.r.recv(); + m, err := c.r.recv() if err != nil { log.Exitf("client recv: %s", err) } if m.unpackResponse(); m.status != OK { - log.Stderrf("invalid message: %s", m.status); - continue; + log.Stderrf("invalid message: %s", m.status) + continue } - c.mu.Lock(); - rpc, ok := c.pending[m.requestId]; + c.mu.Lock() + rpc, ok := c.pending[m.requestId] if ok { c.pending[m.requestId] = nil, false } - c.mu.Unlock(); + c.mu.Unlock() if !ok { - log.Stderrf("unexpected response"); - continue; + log.Stderrf("unexpected response") + continue } - rpc.Ret = m.Ret; - rpc.Done <- rpc; + rpc.Ret = m.Ret + rpc.Done <- rpc } } @@ -117,11 +117,11 @@ func (c *Client) NewRPC(done chan *RPC) *RPC { if done == nil { done = make(chan *RPC) } - c.mu.Lock(); - id := c.idGen; - c.idGen++; - c.mu.Unlock(); - return &RPC{nil, done, OK, c, id}; + c.mu.Lock() + id := c.idGen + c.idGen++ + c.mu.Unlock() + return &RPC{nil, done, OK, c, id} } // Start issues an RPC request for method name with the given arguments. @@ -129,25 +129,25 @@ func (c *Client) NewRPC(done chan *RPC) *RPC { // To wait for the RPC to finish, receive from r.Done and then // inspect r.Ret and r.Errno. func (r *RPC) Start(name string, arg []interface{}) { - var m msg; + var m msg - r.Errno = OK; - r.c.mu.Lock(); - srv, ok := r.c.service[name]; + r.Errno = OK + r.c.mu.Lock() + srv, ok := r.c.service[name] if !ok { - r.c.mu.Unlock(); - r.Errno = ErrBadRPCNumber; - r.Done <- r; - return; + r.c.mu.Unlock() + r.Errno = ErrBadRPCNumber + r.Done <- r + return } - r.c.pending[r.id] = r; - r.c.mu.Unlock(); + r.c.pending[r.id] = r + r.c.mu.Unlock() - m.protocol = protocol; - m.requestId = r.id; - m.isReq = true; - m.rpcNumber = srv.num; - m.Arg = arg; + m.protocol = protocol + m.requestId = r.id + m.isReq = true + m.rpcNumber = srv.num + m.Arg = arg // Fill in the return values and sizes to generate // the right type chars. We'll take most any size. @@ -155,15 +155,15 @@ func (r *RPC) Start(name string, arg []interface{}) { // Skip over input arguments. // We could check them against arg, but the server // will do that anyway. - i := 0; + i := 0 for srv.fmt[i] != ':' { i++ } - fmt := srv.fmt[i+1:]; + fmt := srv.fmt[i+1:] // Now the return prototypes. - m.Ret = make([]interface{}, len(fmt)-i); - m.Size = make([]int, len(fmt)-i); + m.Ret = make([]interface{}, len(fmt)-i) + m.Size = make([]int, len(fmt)-i) for i := 0; i < len(fmt); i++ { switch fmt[i] { default: @@ -171,28 +171,28 @@ func (r *RPC) Start(name string, arg []interface{}) { case 'b': m.Ret[i] = false case 'C': - m.Ret[i] = []byte(nil); - m.Size[i] = 1 << 30; + m.Ret[i] = []byte(nil) + m.Size[i] = 1 << 30 case 'd': m.Ret[i] = float64(0) case 'D': - m.Ret[i] = []float64(nil); - m.Size[i] = 1 << 30; + m.Ret[i] = []float64(nil) + m.Size[i] = 1 << 30 case 'h': m.Ret[i] = int(-1) case 'i': m.Ret[i] = int32(0) case 'I': - m.Ret[i] = []int32(nil); - m.Size[i] = 1 << 30; + m.Ret[i] = []int32(nil) + m.Size[i] = 1 << 30 case 's': - m.Ret[i] = ""; - m.Size[i] = 1 << 30; + m.Ret[i] = "" + m.Size[i] = 1 << 30 } } - m.packRequest(); - r.c.out <- &m; + m.packRequest() + r.c.out <- &m } // Call is a convenient wrapper that starts the RPC request, @@ -204,7 +204,7 @@ func (r *RPC) Start(name string, arg []interface{}) { // return r.Ret, r.Errno; // func (r *RPC) Call(name string, arg []interface{}) (ret []interface{}, err Errno) { - r.Start(name, arg); - <-r.Done; - return r.Ret, r.Errno; + r.Start(name, arg) + <-r.Done + return r.Ret, r.Errno } diff --git a/src/pkg/exp/nacl/srpc/msg.go b/src/pkg/exp/nacl/srpc/msg.go index 54ba5a4e3..52f84b884 100644 --- a/src/pkg/exp/nacl/srpc/msg.go +++ b/src/pkg/exp/nacl/srpc/msg.go @@ -7,30 +7,30 @@ package srpc import ( - "math"; - "os"; - "strconv"; - "syscall"; - "unsafe"; + "math" + "os" + "strconv" + "syscall" + "unsafe" ) // An Errno is an SRPC status code. type Errno uint32 const ( - OK Errno = 256 + iota; - ErrBreak; - ErrMessageTruncated; - ErrNoMemory; - ErrProtocolMismatch; - ErrBadRPCNumber; - ErrBadArgType; - ErrTooFewArgs; - ErrTooManyArgs; - ErrInArgTypeMismatch; - ErrOutArgTypeMismatch; - ErrInternalError; - ErrAppError; + OK Errno = 256 + iota + ErrBreak + ErrMessageTruncated + ErrNoMemory + ErrProtocolMismatch + ErrBadRPCNumber + ErrBadArgType + ErrTooFewArgs + ErrTooManyArgs + ErrInArgTypeMismatch + ErrOutArgTypeMismatch + ErrInternalError + ErrAppError ) var errstr = [...]string{ @@ -53,7 +53,7 @@ func (e Errno) String() string { if e < OK || int(e-OK) >= len(errstr) { return "Errno(" + strconv.Itoa64(int64(e)) + ")" } - return errstr[e-OK]; + return errstr[e-OK] } // A *msgHdr is the data argument to the imc_recvmsg @@ -61,56 +61,56 @@ func (e Errno) String() string { // counts trusted by the system calls, the data structure is unsafe // to expose to package clients. type msgHdr struct { - iov *iov; - niov int32; - desc *int32; - ndesc int32; - flags uint32; + iov *iov + niov int32 + desc *int32 + ndesc int32 + flags uint32 } // A single region for I/O. Just as unsafe as msgHdr. type iov struct { - base *byte; - len int32; + base *byte + len int32 } // A msg is the Go representation of a message. type msg struct { - rdata []byte; // data being consumed during message parsing - rdesc []int32; // file descriptors being consumed during message parsing - wdata []byte; // data being generated when replying + rdata []byte // data being consumed during message parsing + rdesc []int32 // file descriptors being consumed during message parsing + wdata []byte // data being generated when replying // parsed version of message - protocol uint32; - requestId uint64; - isReq bool; - rpcNumber uint32; - gotHeader bool; - status Errno; // error code sent in response - Arg []interface{}; // method arguments - Ret []interface{}; // method results - Size []int; // max sizes for arrays in method results - fmt string; // accumulated format string of arg+":"+ret + protocol uint32 + requestId uint64 + isReq bool + rpcNumber uint32 + gotHeader bool + status Errno // error code sent in response + Arg []interface{} // method arguments + Ret []interface{} // method results + Size []int // max sizes for arrays in method results + fmt string // accumulated format string of arg+":"+ret } // A msgReceiver receives messages from a file descriptor. type msgReceiver struct { - fd int; - data [128 * 1024]byte; - desc [8]int32; - hdr msgHdr; - iov iov; + fd int + data [128 * 1024]byte + desc [8]int32 + hdr msgHdr + iov iov } 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); + 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)) } @@ -118,43 +118,43 @@ func (r *msgReceiver) recv() (*msg, os.Error) { // 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); - copy(m.rdata, &r.data); + m := new(msg) + m.rdata = make([]byte, n) + 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); + m.rdesc = make([]int32, r.hdr.ndesc) for i := range m.rdesc { m.rdesc[i] = r.desc[i] } } - return m, nil; + return m, nil } // A msgSender sends messages on a file descriptor. type msgSender struct { - fd int; - hdr msgHdr; - iov iov; + fd int + hdr msgHdr + iov iov } func (s *msgSender) send(m *msg) os.Error { if len(m.wdata) > 0 { s.iov.base = &m.wdata[0] } - s.iov.len = int32(len(m.wdata)); - s.hdr.iov = &s.iov; - s.hdr.niov = 1; - s.hdr.desc = nil; - s.hdr.ndesc = 0; - _, _, e := syscall.Syscall(syscall.SYS_IMC_SENDMSG, uintptr(s.fd), uintptr(unsafe.Pointer(&s.hdr)), 0); + s.iov.len = int32(len(m.wdata)) + s.hdr.iov = &s.iov + s.hdr.niov = 1 + s.hdr.desc = nil + s.hdr.ndesc = 0 + _, _, e := syscall.Syscall(syscall.SYS_IMC_SENDMSG, uintptr(s.fd), uintptr(unsafe.Pointer(&s.hdr)), 0) if e != 0 { return os.NewSyscallError("imc_sendmsg", int(e)) } - return nil; + return nil } // Reading from msg.rdata. @@ -163,12 +163,12 @@ func (m *msg) uint8() uint8 { return 0 } if len(m.rdata) < 1 { - m.status = ErrMessageTruncated; - return 0; + m.status = ErrMessageTruncated + return 0 } - x := m.rdata[0]; - m.rdata = m.rdata[1:]; - return x; + x := m.rdata[0] + m.rdata = m.rdata[1:] + return x } func (m *msg) uint32() uint32 { @@ -176,13 +176,13 @@ func (m *msg) uint32() uint32 { return 0 } if len(m.rdata) < 4 { - m.status = ErrMessageTruncated; - return 0; + m.status = ErrMessageTruncated + return 0 } - b := m.rdata[0:4]; - x := uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24; - m.rdata = m.rdata[4:]; - return x; + b := m.rdata[0:4] + x := uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24 + m.rdata = m.rdata[4:] + return x } func (m *msg) uint64() uint64 { @@ -190,14 +190,14 @@ func (m *msg) uint64() uint64 { return 0 } if len(m.rdata) < 8 { - m.status = ErrMessageTruncated; - return 0; + m.status = ErrMessageTruncated + return 0 } - b := m.rdata[0:8]; - x := uint64(uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24); - x |= uint64(uint32(b[4])|uint32(b[5])<<8|uint32(b[6])<<16|uint32(b[7])<<24) << 32; - m.rdata = m.rdata[8:]; - return x; + b := m.rdata[0:8] + x := uint64(uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24) + x |= uint64(uint32(b[4])|uint32(b[5])<<8|uint32(b[6])<<16|uint32(b[7])<<24) << 32 + m.rdata = m.rdata[8:] + return x } func (m *msg) bytes(n int) []byte { @@ -205,54 +205,54 @@ func (m *msg) bytes(n int) []byte { return nil } if len(m.rdata) < n { - m.status = ErrMessageTruncated; - return nil; + m.status = ErrMessageTruncated + return nil } - x := m.rdata[0:n]; - m.rdata = m.rdata[n:]; - return x; + x := m.rdata[0:n] + m.rdata = m.rdata[n:] + return x } // Writing to msg.wdata. func (m *msg) grow(n int) []byte { - i := len(m.wdata); + i := len(m.wdata) if i+n > cap(m.wdata) { - a := make([]byte, i, (i+n)*2); - copy(a, m.wdata); - m.wdata = a; + a := make([]byte, i, (i+n)*2) + copy(a, m.wdata) + m.wdata = a } - m.wdata = m.wdata[0 : i+n]; - return m.wdata[i : i+n]; + m.wdata = m.wdata[0 : i+n] + return m.wdata[i : i+n] } -func (m *msg) wuint8(x uint8) { m.grow(1)[0] = x } +func (m *msg) wuint8(x uint8) { m.grow(1)[0] = x } func (m *msg) wuint32(x uint32) { - b := m.grow(4); - b[0] = byte(x); - b[1] = byte(x >> 8); - b[2] = byte(x >> 16); - b[3] = byte(x >> 24); + b := m.grow(4) + b[0] = byte(x) + b[1] = byte(x >> 8) + b[2] = byte(x >> 16) + b[3] = byte(x >> 24) } func (m *msg) wuint64(x uint64) { - b := m.grow(8); - lo := uint32(x); - b[0] = byte(lo); - b[1] = byte(lo >> 8); - b[2] = byte(lo >> 16); - b[3] = byte(lo >> 24); - hi := uint32(x >> 32); - b[4] = byte(hi); - b[5] = byte(hi >> 8); - b[6] = byte(hi >> 16); - b[7] = byte(hi >> 24); + b := m.grow(8) + lo := uint32(x) + b[0] = byte(lo) + b[1] = byte(lo >> 8) + b[2] = byte(lo >> 16) + b[3] = byte(lo >> 24) + hi := uint32(x >> 32) + b[4] = byte(hi) + b[5] = byte(hi >> 8) + b[6] = byte(hi >> 16) + b[7] = byte(hi >> 24) } -func (m *msg) wbytes(p []byte) { copy(m.grow(len(p)), p) } +func (m *msg) wbytes(p []byte) { copy(m.grow(len(p)), p) } func (m *msg) wstring(s string) { - b := m.grow(len(s)); + b := m.grow(len(s)) for i := range b { b[i] = s[i] } @@ -298,14 +298,14 @@ func (m *msg) wstring(s string) { const protocol = 0xc0da0002 func (m *msg) unpackHeader() { - m.protocol = m.uint32(); - m.requestId = m.uint64(); - m.isReq = m.uint8() != 0; - m.rpcNumber = m.uint32(); - m.gotHeader = m.status == OK; // signal that header parsed successfully + m.protocol = m.uint32() + m.requestId = m.uint64() + m.isReq = m.uint8() != 0 + m.rpcNumber = m.uint32() + m.gotHeader = m.status == OK // signal that header parsed successfully if m.gotHeader && !m.isReq { - status := Errno(m.uint32()); - m.gotHeader = m.status == OK; // still ok? + status := Errno(m.uint32()) + m.gotHeader = m.status == OK // still ok? if m.gotHeader { m.status = status } @@ -313,14 +313,14 @@ func (m *msg) unpackHeader() { } func (m *msg) packHeader() { - m.wuint32(m.protocol); - m.wuint64(m.requestId); + m.wuint32(m.protocol) + m.wuint64(m.requestId) if m.isReq { m.wuint8(1) } else { m.wuint8(0) } - m.wuint32(m.rpcNumber); + m.wuint32(m.rpcNumber) if !m.isReq { m.wuint32(uint32(m.status)) } @@ -328,44 +328,44 @@ func (m *msg) packHeader() { func (m *msg) unpackValues(v []interface{}) { for i := range v { - t := m.uint8(); - m.fmt += string(t); + t := m.uint8() + m.fmt += string(t) switch t { default: if m.status == OK { m.status = ErrBadArgType } - return; - case 'b': // bool[1] + return + case 'b': // bool[1] v[i] = m.uint8() > 0 - case 'C': // char array + case 'C': // char array v[i] = m.bytes(int(m.uint32())) - case 'd': // double + case 'd': // double v[i] = math.Float64frombits(m.uint64()) - case 'D': // double array - a := make([]float64, int(m.uint32())); + case 'D': // double array + a := make([]float64, int(m.uint32())) for j := range a { a[j] = math.Float64frombits(m.uint64()) } - v[i] = a; - case 'h': // file descriptor (handle) + v[i] = a + case 'h': // file descriptor (handle) if len(m.rdesc) == 0 { if m.status == OK { m.status = ErrBadArgType } - return; + return } - v[i] = int(m.rdesc[0]); - m.rdesc = m.rdesc[1:]; - case 'i': // int + v[i] = int(m.rdesc[0]) + m.rdesc = m.rdesc[1:] + case 'i': // int v[i] = int32(m.uint32()) - case 'I': // int array - a := make([]int32, int(m.uint32())); + case 'I': // int array + a := make([]int32, int(m.uint32())) for j := range a { a[j] = int32(m.uint32()) } - v[i] = a; - case 's': // string + v[i] = a + case 's': // string v[i] = string(m.bytes(int(m.uint32()))) } } @@ -378,57 +378,57 @@ func (m *msg) packValues(v []interface{}) { if m.status == OK { m.status = ErrInternalError } - return; + return case bool: - m.wuint8('b'); + m.wuint8('b') if x { m.wuint8(1) } else { m.wuint8(0) } case []byte: - m.wuint8('C'); - m.wuint32(uint32(len(x))); - m.wbytes(x); + m.wuint8('C') + m.wuint32(uint32(len(x))) + m.wbytes(x) case float64: - m.wuint8('d'); - m.wuint64(math.Float64bits(x)); + m.wuint8('d') + m.wuint64(math.Float64bits(x)) case []float64: - m.wuint8('D'); - m.wuint32(uint32(len(x))); + m.wuint8('D') + m.wuint32(uint32(len(x))) for _, f := range x { m.wuint64(math.Float64bits(f)) } case int32: - m.wuint8('i'); - m.wuint32(uint32(x)); + m.wuint8('i') + m.wuint32(uint32(x)) case []int32: - m.wuint8('I'); - m.wuint32(uint32(len(x))); + m.wuint8('I') + m.wuint32(uint32(len(x))) for _, i := range x { m.wuint32(uint32(i)) } case string: - m.wuint8('s'); - m.wuint32(uint32(len(x))); - m.wstring(x); + m.wuint8('s') + m.wuint32(uint32(len(x))) + m.wstring(x) } } } func (m *msg) unpackRequest() { - m.status = OK; + m.status = OK if m.unpackHeader(); m.status != OK { return } if m.protocol != protocol || !m.isReq { - m.status = ErrProtocolMismatch; - return; + m.status = ErrProtocolMismatch + return } // type-tagged argument values - m.Arg = make([]interface{}, m.uint32()); - m.unpackValues(m.Arg); + m.Arg = make([]interface{}, m.uint32()) + m.unpackValues(m.Arg) if m.status != OK { return } @@ -436,91 +436,91 @@ func (m *msg) unpackRequest() { // type-tagged expected return sizes. // fill in zero values for each return value // and save sizes. - m.fmt += ":"; - m.Ret = make([]interface{}, m.uint32()); - m.Size = make([]int, len(m.Ret)); + m.fmt += ":" + m.Ret = make([]interface{}, m.uint32()) + m.Size = make([]int, len(m.Ret)) for i := range m.Ret { - t := m.uint8(); - m.fmt += string(t); + t := m.uint8() + m.fmt += string(t) switch t { default: if m.status == OK { m.status = ErrBadArgType } - return; - case 'b': // bool[1] + return + case 'b': // bool[1] m.Ret[i] = false - case 'C': // char array - m.Size[i] = int(m.uint32()); - m.Ret[i] = []byte(nil); - case 'd': // double + case 'C': // char array + m.Size[i] = int(m.uint32()) + m.Ret[i] = []byte(nil) + case 'd': // double m.Ret[i] = float64(0) - case 'D': // double array - m.Size[i] = int(m.uint32()); - m.Ret[i] = []float64(nil); - case 'h': // file descriptor (handle) + case 'D': // double array + m.Size[i] = int(m.uint32()) + m.Ret[i] = []float64(nil) + case 'h': // file descriptor (handle) m.Ret[i] = int(-1) - case 'i': // int + case 'i': // int m.Ret[i] = int32(0) - case 'I': // int array - m.Size[i] = int(m.uint32()); - m.Ret[i] = []int32(nil); - case 's': // string - m.Size[i] = int(m.uint32()); - m.Ret[i] = ""; + case 'I': // int array + m.Size[i] = int(m.uint32()) + m.Ret[i] = []int32(nil) + case 's': // string + m.Size[i] = int(m.uint32()) + m.Ret[i] = "" } } } func (m *msg) packRequest() { - m.packHeader(); - m.wuint32(uint32(len(m.Arg))); - m.packValues(m.Arg); - m.wuint32(uint32(len(m.Ret))); + m.packHeader() + m.wuint32(uint32(len(m.Arg))) + m.packValues(m.Arg) + m.wuint32(uint32(len(m.Ret))) for i, v := range m.Ret { switch x := v.(type) { case bool: m.wuint8('b') case []byte: - m.wuint8('C'); - m.wuint32(uint32(m.Size[i])); + m.wuint8('C') + m.wuint32(uint32(m.Size[i])) case float64: m.wuint8('d') case []float64: - m.wuint8('D'); - m.wuint32(uint32(m.Size[i])); + m.wuint8('D') + m.wuint32(uint32(m.Size[i])) case int: m.wuint8('h') case int32: m.wuint8('i') case []int32: - m.wuint8('I'); - m.wuint32(uint32(m.Size[i])); + m.wuint8('I') + m.wuint32(uint32(m.Size[i])) case string: - m.wuint8('s'); - m.wuint32(uint32(m.Size[i])); + m.wuint8('s') + m.wuint32(uint32(m.Size[i])) } } } func (m *msg) unpackResponse() { - m.status = OK; + m.status = OK if m.unpackHeader(); m.status != OK { return } if m.protocol != protocol || m.isReq { - m.status = ErrProtocolMismatch; - return; + m.status = ErrProtocolMismatch + return } // type-tagged return values - m.fmt = ""; - m.Ret = make([]interface{}, m.uint32()); - m.unpackValues(m.Ret); + m.fmt = "" + m.Ret = make([]interface{}, m.uint32()) + m.unpackValues(m.Ret) } func (m *msg) packResponse() { - m.packHeader(); - m.wuint32(uint32(len(m.Ret))); - m.packValues(m.Ret); + m.packHeader() + m.wuint32(uint32(len(m.Ret))) + m.packValues(m.Ret) } diff --git a/src/pkg/exp/nacl/srpc/server.go b/src/pkg/exp/nacl/srpc/server.go index 56edfccd0..af2b855f5 100644 --- a/src/pkg/exp/nacl/srpc/server.go +++ b/src/pkg/exp/nacl/srpc/server.go @@ -7,10 +7,10 @@ package srpc import ( - "bytes"; - "log"; - "os"; - "syscall"; + "bytes" + "log" + "os" + "syscall" ) // TODO(rsc): I'd prefer to make this @@ -22,13 +22,13 @@ import ( // It reads arguments from arg, checks size for array limits, // writes return values to ret, and returns an Errno status code. type Handler interface { - Run(arg, ret []interface{}, size []int) Errno; + Run(arg, ret []interface{}, size []int) Errno } type method struct { - name string; - fmt string; - handler Handler; + name string + fmt string + handler Handler } var rpcMethod []method @@ -53,80 +53,80 @@ var rpcMethod []method // s string // func Add(name, fmt string, handler Handler) { - n := len(rpcMethod); + n := len(rpcMethod) if n >= cap(rpcMethod) { - a := make([]method, n, (n+4)*2); + a := make([]method, n, (n+4)*2) for i := range a { a[i] = rpcMethod[i] } - rpcMethod = a; + rpcMethod = a } - rpcMethod = rpcMethod[0 : n+1]; - rpcMethod[n] = method{name, fmt, handler}; + rpcMethod = rpcMethod[0 : n+1] + rpcMethod[n] = method{name, fmt, handler} } // Serve accepts new SRPC connections from the file descriptor fd // and answers RPCs issued on those connections. // It closes fd and returns an error if the imc_accept system call fails. func Serve(fd int) os.Error { - defer syscall.Close(fd); + defer syscall.Close(fd) for { - cfd, _, e := syscall.Syscall(syscall.SYS_IMC_ACCEPT, uintptr(fd), 0, 0); + cfd, _, e := syscall.Syscall(syscall.SYS_IMC_ACCEPT, uintptr(fd), 0, 0) if e != 0 { return os.NewSyscallError("imc_accept", int(e)) } - go serveLoop(int(cfd)); + go serveLoop(int(cfd)) } - panic("unreachable"); + panic("unreachable") } func serveLoop(fd int) { - c := make(chan *msg); - go sendLoop(fd, c); + c := make(chan *msg) + go sendLoop(fd, c) - var r msgReceiver; - r.fd = fd; + var r msgReceiver + r.fd = fd for { - m, err := r.recv(); + m, err := r.recv() if err != nil { break } - m.unpackRequest(); + m.unpackRequest() if !m.gotHeader { - log.Stderrf("cannot unpack header: %s", m.status); - continue; + log.Stderrf("cannot unpack header: %s", m.status) + continue } // log.Stdoutf("<- %#v", m); - m.isReq = false; // set up for response - go serveMsg(m, c); + m.isReq = false // set up for response + go serveMsg(m, c) } - close(c); + close(c) } func sendLoop(fd int, c <-chan *msg) { - var s msgSender; - s.fd = fd; + var s msgSender + s.fd = fd for m := range c { // log.Stdoutf("-> %#v", m); - m.packResponse(); - s.send(m); + m.packResponse() + s.send(m) } - syscall.Close(fd); + syscall.Close(fd) } func serveMsg(m *msg, c chan<- *msg) { if m.status != OK { - c <- m; - return; + c <- m + return } if m.rpcNumber >= uint32(len(rpcMethod)) { - m.status = ErrBadRPCNumber; - c <- m; - return; + m.status = ErrBadRPCNumber + c <- m + return } - meth := &rpcMethod[m.rpcNumber]; + meth := &rpcMethod[m.rpcNumber] if meth.fmt != m.fmt { switch { case len(m.fmt) < len(meth.fmt): @@ -137,20 +137,20 @@ func serveMsg(m *msg, c chan<- *msg) { // There's a type mismatch. // It's an in-arg mismatch if the mismatch happens // before the colon; otherwise it's an out-arg mismatch. - m.status = ErrInArgTypeMismatch; + m.status = ErrInArgTypeMismatch for i := 0; i < len(m.fmt) && m.fmt[i] == meth.fmt[i]; i++ { if m.fmt[i] == ':' { - m.status = ErrOutArgTypeMismatch; - break; + m.status = ErrOutArgTypeMismatch + break } } } - c <- m; - return; + c <- m + return } - m.status = meth.handler.Run(m.Arg, m.Ret, m.Size); - c <- m; + m.status = meth.handler.Run(m.Arg, m.Ret, m.Size) + c <- m } // ServeRuntime serves RPCs issued by the Native Client embedded runtime. @@ -164,19 +164,19 @@ func ServeRuntime() os.Error { // We are running embedded. // The fd returned by getFd is a red herring. // Accept connections on magic fd 3. - return Serve(3); + return Serve(3) } // getFd runs the srpc_get_fd system call. func getFd() (fd int, err os.Error) { - r1, _, e := syscall.Syscall(syscall.SYS_SRPC_GET_FD, 0, 0, 0); - return int(r1), os.NewSyscallError("srpc_get_fd", int(e)); + r1, _, e := syscall.Syscall(syscall.SYS_SRPC_GET_FD, 0, 0, 0) + return int(r1), os.NewSyscallError("srpc_get_fd", int(e)) } // Enabled returns true if SRPC is enabled in the Native Client runtime. func Enabled() bool { - _, err := getFd(); - return err == nil; + _, err := getFd() + return err == nil } // Service #0, service_discovery, returns a list of the other services @@ -184,18 +184,18 @@ func Enabled() bool { type serviceDiscovery struct{} func (serviceDiscovery) Run(arg, ret []interface{}, size []int) Errno { - var b bytes.Buffer; + var b bytes.Buffer for _, m := range rpcMethod { - b.WriteString(m.name); - b.WriteByte(':'); - b.WriteString(m.fmt); - b.WriteByte('\n'); + b.WriteString(m.name) + b.WriteByte(':') + b.WriteString(m.fmt) + b.WriteByte('\n') } if b.Len() > size[0] { return ErrNoMemory } - ret[0] = b.Bytes(); - return OK; + ret[0] = b.Bytes() + return OK } -func init() { Add("service_discovery", ":C", serviceDiscovery{}) } +func init() { Add("service_discovery", ":C", serviceDiscovery{}) } diff --git a/src/pkg/exp/ogle/abort.go b/src/pkg/exp/ogle/abort.go index 7773cac2b..311a7b38e 100644 --- a/src/pkg/exp/ogle/abort.go +++ b/src/pkg/exp/ogle/abort.go @@ -5,31 +5,31 @@ package ogle import ( - "os"; - "runtime"; + "os" + "runtime" ) // An aborter aborts the thread's current computation, usually // passing the error to a waiting thread. type aborter interface { - Abort(err os.Error); + Abort(err os.Error) } type ogleAborter chan os.Error func (a ogleAborter) Abort(err os.Error) { - a <- err; - runtime.Goexit(); + a <- err + runtime.Goexit() } // try executes a computation; if the computation Aborts, try returns // the error passed to abort. func try(f func(a aborter)) os.Error { - a := make(ogleAborter); + a := make(ogleAborter) go func() { - f(a); - a <- nil; - }(); - err := <-a; - return err; + f(a) + a <- nil + }() + err := <-a + return err } diff --git a/src/pkg/exp/ogle/arch.go b/src/pkg/exp/ogle/arch.go index 867ad4ca6..52b1c9757 100644 --- a/src/pkg/exp/ogle/arch.go +++ b/src/pkg/exp/ogle/arch.go @@ -5,66 +5,66 @@ package ogle import ( - "debug/proc"; - "math"; + "debug/proc" + "math" ) type Arch interface { // ToWord converts an array of up to 8 bytes in memory order // to a word. - ToWord(data []byte) proc.Word; + ToWord(data []byte) proc.Word // FromWord converts a word to an array of up to 8 bytes in // memory order. - FromWord(v proc.Word, out []byte); + FromWord(v proc.Word, out []byte) // ToFloat32 converts a word to a float. The order of this // word will be the order returned by ToWord on the memory // representation of a float, and thus may require reversing. - ToFloat32(bits uint32) float32; + ToFloat32(bits uint32) float32 // FromFloat32 converts a float to a word. This should return // a word that can be passed to FromWord to get the memory // representation of a float on this architecture. - FromFloat32(f float32) uint32; + FromFloat32(f float32) uint32 // ToFloat64 is to float64 as ToFloat32 is to float32. - ToFloat64(bits uint64) float64; + ToFloat64(bits uint64) float64 // FromFloat64 is to float64 as FromFloat32 is to float32. - FromFloat64(f float64) uint64; + FromFloat64(f float64) uint64 // IntSize returns the number of bytes in an 'int'. - IntSize() int; + IntSize() int // PtrSize returns the number of bytes in a 'uintptr'. - PtrSize() int; + PtrSize() int // FloatSize returns the number of bytes in a 'float'. - FloatSize() int; + FloatSize() int // Align rounds offset up to the appropriate offset for a // basic type with the given width. - Align(offset, width int) int; + Align(offset, width int) int // G returns the current G pointer. - G(regs proc.Regs) proc.Word; + G(regs proc.Regs) proc.Word // ClosureSize returns the number of bytes expected by // ParseClosure. - ClosureSize() int; + ClosureSize() int // ParseClosure takes ClosureSize bytes read from a return PC // in a remote process, determines if the code is a closure, // and returns the frame size of the closure if it is. - ParseClosure(data []byte) (frame int, ok bool); + ParseClosure(data []byte) (frame int, ok bool) } type ArchLSB struct{} func (ArchLSB) ToWord(data []byte) proc.Word { - var v proc.Word; + var v proc.Word for i, b := range data { v |= proc.Word(b) << (uint(i) * 8) } - return v; + return v } func (ArchLSB) FromWord(v proc.Word, out []byte) { for i := range out { - out[i] = byte(v); - v >>= 8; + out[i] = byte(v) + v >>= 8 } } @@ -74,11 +74,11 @@ func (ArchLSB) ToFloat32(bits uint32) float32 { return math.Float32frombits(bits) } -func (ArchLSB) FromFloat32(f float32) uint32 { return math.Float32bits(f) } +func (ArchLSB) FromFloat32(f float32) uint32 { return math.Float32bits(f) } -func (ArchLSB) ToFloat64(bits uint64) float64 { return math.Float64frombits(bits) } +func (ArchLSB) ToFloat64(bits uint64) float64 { return math.Float64frombits(bits) } -func (ArchLSB) FromFloat64(f float64) uint64 { return math.Float64bits(f) } +func (ArchLSB) FromFloat64(f float64) uint64 { return math.Float64bits(f) } type ArchAlignedMultiple struct{} @@ -87,39 +87,39 @@ func (ArchAlignedMultiple) Align(offset, width int) int { } type amd64 struct { - ArchLSB; - ArchAlignedMultiple; - gReg int; + ArchLSB + ArchAlignedMultiple + gReg int } -func (a *amd64) IntSize() int { return 4 } +func (a *amd64) IntSize() int { return 4 } -func (a *amd64) PtrSize() int { return 8 } +func (a *amd64) PtrSize() int { return 8 } -func (a *amd64) FloatSize() int { return 4 } +func (a *amd64) FloatSize() int { return 4 } func (a *amd64) G(regs proc.Regs) proc.Word { // See src/pkg/runtime/mkasmh if a.gReg == -1 { - ns := regs.Names(); + ns := regs.Names() for i, n := range ns { if n == "r15" { - a.gReg = i; - break; + a.gReg = i + break } } } - return regs.Get(a.gReg); + return regs.Get(a.gReg) } -func (a *amd64) ClosureSize() int { return 8 } +func (a *amd64) ClosureSize() int { return 8 } func (a *amd64) ParseClosure(data []byte) (int, bool) { if data[0] == 0x48 && data[1] == 0x81 && data[2] == 0xc4 && data[7] == 0xc3 { return int(a.ToWord(data[3:7]) + 8), true } - return 0, false; + return 0, false } var Amd64 = &amd64{gReg: -1} diff --git a/src/pkg/exp/ogle/cmd.go b/src/pkg/exp/ogle/cmd.go index 2e75fe519..45b47ef5b 100644 --- a/src/pkg/exp/ogle/cmd.go +++ b/src/pkg/exp/ogle/cmd.go @@ -6,52 +6,52 @@ package ogle import ( - "bufio"; - "debug/elf"; - "debug/proc"; - "exp/eval"; - "fmt"; - "go/scanner"; - "go/token"; - "os"; - "strconv"; - "strings"; + "bufio" + "debug/elf" + "debug/proc" + "exp/eval" + "fmt" + "go/scanner" + "go/token" + "os" + "strconv" + "strings" ) var world *eval.World var curProc *Process func Main() { - world = eval.NewWorld(); - defineFuncs(); - r := bufio.NewReader(os.Stdin); + world = eval.NewWorld() + defineFuncs() + r := bufio.NewReader(os.Stdin) for { - print("; "); - line, err := r.ReadSlice('\n'); + print("; ") + line, err := r.ReadSlice('\n') if err != nil { break } // Try line as a command - cmd, rest := getCmd(line); + cmd, rest := getCmd(line) if cmd != nil { - err := cmd.handler(rest); + err := cmd.handler(rest) if err != nil { scanner.PrintError(os.Stderr, err) } - continue; + continue } // Try line as code - code, err := world.Compile(string(line)); + code, err := world.Compile(string(line)) if err != nil { - scanner.PrintError(os.Stderr, err); - continue; + scanner.PrintError(os.Stderr, err) + continue } - v, err := code.Run(); + v, err := code.Run() if err != nil { - fmt.Fprintf(os.Stderr, err.String()); - continue; + fmt.Fprintf(os.Stderr, err.String()) + continue } if v != nil { println(v.String()) @@ -61,11 +61,11 @@ func Main() { // newScanner creates a new scanner that scans that given input bytes. func newScanner(input []byte) (*scanner.Scanner, *scanner.ErrorVector) { - sc := new(scanner.Scanner); - ev := new(scanner.ErrorVector); - sc.Init("input", input, ev, 0); + sc := new(scanner.Scanner) + ev := new(scanner.ErrorVector) + sc.Init("input", input, ev, 0) - return sc, ev; + return sc, ev } /* @@ -75,12 +75,12 @@ func newScanner(input []byte) (*scanner.Scanner, *scanner.ErrorVector) { // A UsageError occurs when a command is called with illegal arguments. type UsageError string -func (e UsageError) String() string { return string(e) } +func (e UsageError) String() string { return string(e) } // A cmd represents a single command with a handler. type cmd struct { - cmd string; - handler func([]byte) os.Error; + cmd string + handler func([]byte) os.Error } var cmds = []cmd{ @@ -92,19 +92,19 @@ var cmds = []cmd{ // successful, it returns the command and the bytes remaining after // the command, which should be passed to the command. func getCmd(line []byte) (*cmd, []byte) { - sc, _ := newScanner(line); - pos, tok, lit := sc.Scan(); + sc, _ := newScanner(line) + pos, tok, lit := sc.Scan() if sc.ErrorCount != 0 || tok != token.IDENT { return nil, nil } - slit := string(lit); + slit := string(lit) for i := range cmds { if cmds[i].cmd == slit { return &cmds[i], line[pos.Offset+len(lit):] } } - return nil, nil; + return nil, nil } // cmdLoad starts or attaches to a process. Its form is similar to @@ -124,7 +124,7 @@ func getCmd(line []byte) (*cmd, []byte) { // // load always sets the current process to the loaded process. func cmdLoad(args []byte) os.Error { - ident, path, err := parseLoad(args); + ident, path, err := parseLoad(args) if err != nil { return err } @@ -136,99 +136,99 @@ func cmdLoad(args []byte) os.Error { } // Parse argument and start or attach to process - var fname string; - var tproc proc.Process; + var fname string + var tproc proc.Process if len(path) >= 4 && path[0:4] == "pid:" { - pid, err := strconv.Atoi(path[4:]); + pid, err := strconv.Atoi(path[4:]) if err != nil { return err } - fname, err = os.Readlink(fmt.Sprintf("/proc/%d/exe", pid)); + fname, err = os.Readlink(fmt.Sprintf("/proc/%d/exe", pid)) if err != nil { return err } - tproc, err = proc.Attach(pid); + tproc, err = proc.Attach(pid) if err != nil { return err } - println("Attached to", pid); + println("Attached to", pid) } else { - parts := strings.Split(path, " ", 0); + parts := strings.Split(path, " ", 0) if len(parts) == 0 { fname = "" } else { fname = parts[0] } - tproc, err = proc.ForkExec(fname, parts, os.Environ(), "", []*os.File{os.Stdin, os.Stdout, os.Stderr}); + tproc, err = proc.ForkExec(fname, parts, os.Environ(), "", []*os.File{os.Stdin, os.Stdout, os.Stderr}) if err != nil { return err } - println("Started", path); + println("Started", path) // TODO(austin) If we fail after this point, kill tproc // before detaching. } // Get symbols - f, err := os.Open(fname, os.O_RDONLY, 0); + f, err := os.Open(fname, os.O_RDONLY, 0) if err != nil { - tproc.Detach(); - return err; + tproc.Detach() + return err } - defer f.Close(); - elf, err := elf.NewFile(f); + defer f.Close() + elf, err := elf.NewFile(f) if err != nil { - tproc.Detach(); - return err; + tproc.Detach() + return err } - curProc, err = NewProcessElf(tproc, elf); + curProc, err = NewProcessElf(tproc, elf) if err != nil { - tproc.Detach(); - return err; + tproc.Detach() + return err } // Prepare new process - curProc.OnGoroutineCreate().AddHandler(EventPrint); - curProc.OnGoroutineExit().AddHandler(EventPrint); + curProc.OnGoroutineCreate().AddHandler(EventPrint) + curProc.OnGoroutineExit().AddHandler(EventPrint) - err = curProc.populateWorld(world); + err = curProc.populateWorld(world) if err != nil { - tproc.Detach(); - return err; + tproc.Detach() + return err } - return nil; + return nil } func parseLoad(args []byte) (ident string, path string, err os.Error) { - err = UsageError("Usage: load [sym] \"path\""); - sc, ev := newScanner(args); + err = UsageError("Usage: load [sym] \"path\"") + sc, ev := newScanner(args) - var toks [4]token.Token; - var lits [4][]byte; + var toks [4]token.Token + var lits [4][]byte for i := range toks { _, toks[i], lits[i] = sc.Scan() } if sc.ErrorCount != 0 { - err = ev.GetError(scanner.NoMultiples); - return; + err = ev.GetError(scanner.NoMultiples) + return } - i := 0; + i := 0 switch toks[i] { case token.PERIOD, token.IDENT: - ident = string(lits[i]); - i++; + ident = string(lits[i]) + i++ } if toks[i] != token.STRING { return } - path, uerr := strconv.Unquote(string(lits[i])); + path, uerr := strconv.Unquote(string(lits[i])) if uerr != nil { - err = uerr; - return; + err = uerr + return } - i++; + i++ if toks[i] == token.SEMICOLON { i++ @@ -237,13 +237,13 @@ func parseLoad(args []byte) (ident string, path string, err os.Error) { return } - return ident, path, nil; + return ident, path, nil } // cmdBt prints a backtrace for the current goroutine. It takes no // arguments. func cmdBt(args []byte) os.Error { - err := parseNoArgs(args, "Usage: bt"); + err := parseNoArgs(args, "Usage: bt") if err != nil { return err } @@ -252,10 +252,10 @@ func cmdBt(args []byte) os.Error { return NoCurrentGoroutine{} } - f := curProc.curGoroutine.frame; + f := curProc.curGoroutine.frame if f == nil { - fmt.Println("No frames on stack"); - return nil; + fmt.Println("No frames on stack") + return nil } for f.Inner() != nil { @@ -268,8 +268,8 @@ func cmdBt(args []byte) os.Error { } else { fmt.Printf(" ") } - fmt.Printf("%8x %v\n", f.pc, f); - f, err = f.Outer(); + fmt.Printf("%8x %v\n", f.pc, f) + f, err = f.Outer() if err != nil { return err } @@ -278,20 +278,20 @@ func cmdBt(args []byte) os.Error { } } - fmt.Println("..."); - return nil; + fmt.Println("...") + return nil } func parseNoArgs(args []byte, usage string) os.Error { - sc, ev := newScanner(args); - _, tok, _ := sc.Scan(); + sc, ev := newScanner(args) + _, tok, _ := sc.Scan() if sc.ErrorCount != 0 { return ev.GetError(scanner.NoMultiples) } if tok != token.EOF { return UsageError(usage) } - return nil; + return nil } /* @@ -300,12 +300,12 @@ func parseNoArgs(args []byte, usage string) os.Error { // defineFuncs populates world with the built-in functions. func defineFuncs() { - t, v := eval.FuncFromNativeTyped(fnOut, fnOutSig); - world.DefineConst("Out", t, v); - t, v = eval.FuncFromNativeTyped(fnContWait, fnContWaitSig); - world.DefineConst("ContWait", t, v); - t, v = eval.FuncFromNativeTyped(fnBpSet, fnBpSetSig); - world.DefineConst("BpSet", t, v); + t, v := eval.FuncFromNativeTyped(fnOut, fnOutSig) + world.DefineConst("Out", t, v) + t, v = eval.FuncFromNativeTyped(fnContWait, fnContWaitSig) + world.DefineConst("ContWait", t, v) + t, v = eval.FuncFromNativeTyped(fnBpSet, fnBpSetSig) + world.DefineConst("BpSet", t, v) } // printCurFrame prints the current stack frame, as it would appear in @@ -314,47 +314,47 @@ func printCurFrame() { if curProc == nil || curProc.curGoroutine == nil { return } - f := curProc.curGoroutine.frame; + f := curProc.curGoroutine.frame if f == nil { return } - fmt.Printf("=> %8x %v\n", f.pc, f); + fmt.Printf("=> %8x %v\n", f.pc, f) } // fnOut moves the current frame to the caller of the current frame. -func fnOutSig() {} +func fnOutSig() {} func fnOut(t *eval.Thread, args []eval.Value, res []eval.Value) { if curProc == nil { t.Abort(NoCurrentGoroutine{}) } - err := curProc.Out(); + err := curProc.Out() if err != nil { t.Abort(err) } // TODO(austin) Only in the command form - printCurFrame(); + printCurFrame() } // fnContWait continues the current process and waits for a stopping event. -func fnContWaitSig() {} +func fnContWaitSig() {} func fnContWait(t *eval.Thread, args []eval.Value, res []eval.Value) { if curProc == nil { t.Abort(NoCurrentGoroutine{}) } - err := curProc.ContWait(); + err := curProc.ContWait() if err != nil { t.Abort(err) } // TODO(austin) Only in the command form - ev := curProc.Event(); + ev := curProc.Event() if ev != nil { fmt.Printf("%v\n", ev) } - printCurFrame(); + printCurFrame() } // fnBpSet sets a breakpoint at the entry to the named function. -func fnBpSetSig(string) {} +func fnBpSetSig(string) {} func fnBpSet(t *eval.Thread, args []eval.Value, res []eval.Value) { // TODO(austin) This probably shouldn't take a symbol name. // Perhaps it should take an interface that provides PC's. @@ -363,10 +363,10 @@ func fnBpSet(t *eval.Thread, args []eval.Value, res []eval.Value) { if curProc == nil { t.Abort(NoCurrentGoroutine{}) } - name := args[0].(eval.StringValue).Get(t); - fn := curProc.syms.LookupFunc(name); + name := args[0].(eval.StringValue).Get(t) + fn := curProc.syms.LookupFunc(name) if fn == nil { t.Abort(UsageError("no such function " + name)) } - curProc.OnBreakpoint(proc.Word(fn.Entry)).AddHandler(EventStop); + curProc.OnBreakpoint(proc.Word(fn.Entry)).AddHandler(EventStop) } diff --git a/src/pkg/exp/ogle/event.go b/src/pkg/exp/ogle/event.go index 18f547915..d7092ded3 100644 --- a/src/pkg/exp/ogle/event.go +++ b/src/pkg/exp/ogle/event.go @@ -5,9 +5,9 @@ package ogle import ( - "debug/proc"; - "fmt"; - "os"; + "debug/proc" + "fmt" + "os" ) /* @@ -32,19 +32,19 @@ type EventHandler func(e Event) (EventAction, os.Error) type EventAction int const ( - EARemoveSelf EventAction = 0x100; - EADefault EventAction = iota; - EAStop; - EAContinue; + EARemoveSelf EventAction = 0x100 + EADefault EventAction = iota + EAStop + EAContinue ) // A EventHook allows event handlers to be added and removed. type EventHook interface { - AddHandler(EventHandler); - RemoveHandler(EventHandler); - NumHandler() int; - handle(e Event) (EventAction, os.Error); - String() string; + AddHandler(EventHandler) + RemoveHandler(EventHandler) + NumHandler() int + handle(e Event) (EventAction, os.Error) + String() string } // EventHook is almost, but not quite, suitable for user-defined @@ -53,26 +53,26 @@ type EventHook interface { // provide a public interface for posting events to hooks. type Event interface { - Process() *Process; - Goroutine() *Goroutine; - String() string; + Process() *Process + Goroutine() *Goroutine + String() string } type commonHook struct { // Head of handler chain - head *handler; + head *handler // Number of non-internal handlers - len int; + len int } type handler struct { - eh EventHandler; + eh EventHandler // True if this handler must be run before user-defined // handlers in order to ensure correctness. - internal bool; + internal bool // True if this handler has been removed from the chain. - removed bool; - next *handler; + removed bool + next *handler } func (h *commonHook) AddHandler(eh EventHandler) { @@ -81,56 +81,56 @@ func (h *commonHook) AddHandler(eh EventHandler) { func (h *commonHook) addHandler(eh EventHandler, internal bool) { // Ensure uniqueness of handlers - h.RemoveHandler(eh); + h.RemoveHandler(eh) if !internal { h.len++ } // Add internal handlers to the beginning if internal || h.head == nil { - h.head = &handler{eh, internal, false, h.head}; - return; + h.head = &handler{eh, internal, false, h.head} + return } // Add handler after internal handlers // TODO(austin) This should probably go on the end instead - prev := h.head; + prev := h.head for prev.next != nil && prev.internal { prev = prev.next } - prev.next = &handler{eh, internal, false, prev.next}; + prev.next = &handler{eh, internal, false, prev.next} } func (h *commonHook) RemoveHandler(eh EventHandler) { - plink := &h.head; + plink := &h.head for l := *plink; l != nil; plink, l = &l.next, l.next { if l.eh == eh { if !l.internal { h.len-- } - l.removed = true; - *plink = l.next; - break; + l.removed = true + *plink = l.next + break } } } -func (h *commonHook) NumHandler() int { return h.len } +func (h *commonHook) NumHandler() int { return h.len } func (h *commonHook) handle(e Event) (EventAction, os.Error) { - action := EADefault; - plink := &h.head; + action := EADefault + plink := &h.head for l := *plink; l != nil; plink, l = &l.next, l.next { if l.removed { continue } - a, err := l.eh(e); + a, err := l.eh(e) if a&EARemoveSelf == EARemoveSelf { if !l.internal { h.len-- } - l.removed = true; - *plink = l.next; - a &^= EARemoveSelf; + l.removed = true + *plink = l.next + a &^= EARemoveSelf } if err != nil { return EAStop, err @@ -139,19 +139,19 @@ func (h *commonHook) handle(e Event) (EventAction, os.Error) { action = a } } - return action, nil; + return action, nil } type commonEvent struct { // The process of this event - p *Process; + p *Process // The goroutine of this event. - t *Goroutine; + t *Goroutine } -func (e *commonEvent) Process() *Process { return e.p } +func (e *commonEvent) Process() *Process { return e.p } -func (e *commonEvent) Goroutine() *Goroutine { return e.t } +func (e *commonEvent) Goroutine() *Goroutine { return e.t } /* * Standard event handlers @@ -161,8 +161,8 @@ func (e *commonEvent) Goroutine() *Goroutine { return e.t } // occur. It will not cause the process to stop. func EventPrint(ev Event) (EventAction, os.Error) { // TODO(austin) Include process name here? - fmt.Fprintf(os.Stderr, "*** %v\n", ev.String()); - return EADefault, nil; + fmt.Fprintf(os.Stderr, "*** %v\n", ev.String()) + return EADefault, nil } // EventStop is a standard event handler that causes the process to stop. @@ -175,18 +175,18 @@ func EventStop(ev Event) (EventAction, os.Error) { */ type breakpointHook struct { - commonHook; - p *Process; - pc proc.Word; + commonHook + p *Process + pc proc.Word } // A Breakpoint event occurs when a process reaches a particular // program counter. When this event is handled, the current goroutine // will be the goroutine that reached the program counter. type Breakpoint struct { - commonEvent; - osThread proc.Thread; - pc proc.Word; + commonEvent + osThread proc.Thread + pc proc.Word } func (h *breakpointHook) AddHandler(eh EventHandler) { @@ -200,20 +200,20 @@ func (h *breakpointHook) addHandler(eh EventHandler, internal bool) { if cur, ok := h.p.breakpointHooks[h.pc]; ok { h = cur } - oldhead := h.head; - h.commonHook.addHandler(eh, internal); + oldhead := h.head + h.commonHook.addHandler(eh, internal) if oldhead == nil && h.head != nil { - h.p.proc.AddBreakpoint(h.pc); - h.p.breakpointHooks[h.pc] = h; + h.p.proc.AddBreakpoint(h.pc) + h.p.breakpointHooks[h.pc] = h } } func (h *breakpointHook) RemoveHandler(eh EventHandler) { - oldhead := h.head; - h.commonHook.RemoveHandler(eh); + oldhead := h.head + h.commonHook.RemoveHandler(eh) if oldhead != nil && h.head == nil { - h.p.proc.RemoveBreakpoint(h.pc); - h.p.breakpointHooks[h.pc] = nil, false; + h.p.proc.RemoveBreakpoint(h.pc) + h.p.breakpointHooks[h.pc] = nil, false } } @@ -223,7 +223,7 @@ func (h *breakpointHook) String() string { return fmt.Sprintf("breakpoint at %#x", h.pc) } -func (b *Breakpoint) PC() proc.Word { return b.pc } +func (b *Breakpoint) PC() proc.Word { return b.pc } func (b *Breakpoint) String() string { // TODO(austin) Include process name and goroutine @@ -236,40 +236,40 @@ func (b *Breakpoint) String() string { */ type goroutineCreateHook struct { - commonHook; + commonHook } -func (h *goroutineCreateHook) String() string { return "goroutine create" } +func (h *goroutineCreateHook) String() string { return "goroutine create" } // A GoroutineCreate event occurs when a process creates a new // goroutine. When this event is handled, the current goroutine will // be the newly created goroutine. type GoroutineCreate struct { - commonEvent; - parent *Goroutine; + commonEvent + parent *Goroutine } // Parent returns the goroutine that created this goroutine. May be // nil if this event is the creation of the first goroutine. -func (e *GoroutineCreate) Parent() *Goroutine { return e.parent } +func (e *GoroutineCreate) Parent() *Goroutine { return e.parent } func (e *GoroutineCreate) String() string { // TODO(austin) Include process name if e.parent == nil { return fmt.Sprintf("%v created", e.t) } - return fmt.Sprintf("%v created by %v", e.t, e.parent); + return fmt.Sprintf("%v created by %v", e.t, e.parent) } type goroutineExitHook struct { - commonHook; + commonHook } -func (h *goroutineExitHook) String() string { return "goroutine exit" } +func (h *goroutineExitHook) String() string { return "goroutine exit" } // A GoroutineExit event occurs when a Go goroutine exits. type GoroutineExit struct { - commonEvent; + commonEvent } func (e *GoroutineExit) String() string { diff --git a/src/pkg/exp/ogle/frame.go b/src/pkg/exp/ogle/frame.go index 6c93f27c7..1538362ba 100644 --- a/src/pkg/exp/ogle/frame.go +++ b/src/pkg/exp/ogle/frame.go @@ -5,10 +5,10 @@ package ogle import ( - "debug/gosym"; - "debug/proc"; - "fmt"; - "os"; + "debug/gosym" + "debug/proc" + "fmt" + "os" ) // A Frame represents a single frame on a remote call stack. @@ -16,30 +16,30 @@ type Frame struct { // pc is the PC of the next instruction that will execute in // this frame. For lower frames, this is the instruction // following the CALL instruction. - pc, sp, fp proc.Word; + pc, sp, fp proc.Word // The runtime.Stktop of the active stack segment - stk remoteStruct; + stk remoteStruct // The function this stack frame is in - fn *gosym.Func; + fn *gosym.Func // The path and line of the CALL or current instruction. Note // that this differs slightly from the meaning of Frame.pc. - path string; - line int; + path string + line int // The inner and outer frames of this frame. outer is filled // in lazily. - inner, outer *Frame; + inner, outer *Frame } // newFrame returns the top-most Frame of the given g's thread. func newFrame(g remoteStruct) (*Frame, os.Error) { - var f *Frame; - err := try(func(a aborter) { f = aNewFrame(a, g) }); - return f, err; + var f *Frame + err := try(func(a aborter) { f = aNewFrame(a, g) }) + return f, err } func aNewFrame(a aborter, g remoteStruct) *Frame { - p := g.r.p; - var pc, sp proc.Word; + p := g.r.p + var pc, sp proc.Word // Is this G alive? switch g.field(p.f.G.Status).(remoteInt).aGet(a) { @@ -54,39 +54,39 @@ func aNewFrame(a aborter, g remoteStruct) *Frame { // is difficult because the state isn't updated atomically // with scheduling changes. for _, t := range p.proc.Threads() { - regs, err := t.Regs(); + regs, err := t.Regs() if err != nil { // TODO(austin) What to do? continue } - thisg := p.G(regs); + thisg := p.G(regs) if thisg == g.addr().base { // Found this G's OS thread - pc = regs.PC(); - sp = regs.SP(); + pc = regs.PC() + sp = regs.SP() // If this thread crashed, try to recover it if pc == 0 { - pc = p.peekUintptr(a, pc); - sp += 8; + pc = p.peekUintptr(a, pc) + sp += 8 } - break; + break } } if pc == 0 && sp == 0 { // G is not mapped to an OS thread. Use the // scheduler's stored PC and SP. - sched := g.field(p.f.G.Sched).(remoteStruct); - pc = proc.Word(sched.field(p.f.Gobuf.Pc).(remoteUint).aGet(a)); - sp = proc.Word(sched.field(p.f.Gobuf.Sp).(remoteUint).aGet(a)); + sched := g.field(p.f.G.Sched).(remoteStruct) + pc = proc.Word(sched.field(p.f.Gobuf.Pc).(remoteUint).aGet(a)) + sp = proc.Word(sched.field(p.f.Gobuf.Sp).(remoteUint).aGet(a)) } // Get Stktop - stk := g.field(p.f.G.Stackbase).(remotePtr).aGet(a).(remoteStruct); + stk := g.field(p.f.G.Stackbase).(remotePtr).aGet(a).(remoteStruct) - return prepareFrame(a, pc, sp, stk, nil); + return prepareFrame(a, pc, sp, stk, nil) } // prepareFrame creates a Frame from the PC and SP within that frame, @@ -94,47 +94,47 @@ func aNewFrame(a aborter, g remoteStruct) *Frame { // traversing stack breaks and unwinding closures. func prepareFrame(a aborter, pc, sp proc.Word, stk remoteStruct, inner *Frame) *Frame { // Based on src/pkg/runtime/amd64/traceback.c:traceback - p := stk.r.p; - top := inner == nil; + p := stk.r.p + top := inner == nil // Get function - var path string; - var line int; - var fn *gosym.Func; + var path string + var line int + var fn *gosym.Func for i := 0; i < 100; i++ { // Traverse segmented stack breaks if p.sys.lessstack != nil && pc == proc.Word(p.sys.lessstack.Value) { // Get stk->gobuf.pc - pc = proc.Word(stk.field(p.f.Stktop.Gobuf).(remoteStruct).field(p.f.Gobuf.Pc).(remoteUint).aGet(a)); + pc = proc.Word(stk.field(p.f.Stktop.Gobuf).(remoteStruct).field(p.f.Gobuf.Pc).(remoteUint).aGet(a)) // Get stk->gobuf.sp - sp = proc.Word(stk.field(p.f.Stktop.Gobuf).(remoteStruct).field(p.f.Gobuf.Sp).(remoteUint).aGet(a)); + sp = proc.Word(stk.field(p.f.Stktop.Gobuf).(remoteStruct).field(p.f.Gobuf.Sp).(remoteUint).aGet(a)) // Get stk->stackbase - stk = stk.field(p.f.Stktop.Stackbase).(remotePtr).aGet(a).(remoteStruct); - continue; + stk = stk.field(p.f.Stktop.Stackbase).(remotePtr).aGet(a).(remoteStruct) + continue } // Get the PC of the call instruction - callpc := pc; + callpc := pc if !top && (p.sys.goexit == nil || pc != proc.Word(p.sys.goexit.Value)) { callpc-- } // Look up function - path, line, fn = p.syms.PCToLine(uint64(callpc)); + path, line, fn = p.syms.PCToLine(uint64(callpc)) if fn != nil { break } // Closure? - var buf = make([]byte, p.ClosureSize()); + var buf = make([]byte, p.ClosureSize()) if _, err := p.Peek(pc, buf); err != nil { break } - spdelta, ok := p.ParseClosure(buf); + spdelta, ok := p.ParseClosure(buf) if ok { - sp += proc.Word(spdelta); - pc = p.peekUintptr(a, sp-proc.Word(p.PtrSize())); + sp += proc.Word(spdelta) + pc = p.peekUintptr(a, sp-proc.Word(p.PtrSize())) } } if fn == nil { @@ -142,7 +142,7 @@ func prepareFrame(a aborter, pc, sp proc.Word, stk remoteStruct, inner *Frame) * } // Compute frame pointer - var fp proc.Word; + var fp proc.Word if fn.FrameSize < p.PtrSize() { fp = sp + proc.Word(p.PtrSize()) } else { @@ -160,15 +160,15 @@ func prepareFrame(a aborter, pc, sp proc.Word, stk remoteStruct, inner *Frame) * fp -= proc.Word(fn.FrameSize - p.PtrSize()) } - return &Frame{pc, sp, fp, stk, fn, path, line, inner, nil}; + return &Frame{pc, sp, fp, stk, fn, path, line, inner, nil} } // Outer returns the Frame that called this Frame, or nil if this is // the outermost frame. func (f *Frame) Outer() (*Frame, os.Error) { - var fr *Frame; - err := try(func(a aborter) { fr = f.aOuter(a) }); - return fr, err; + var fr *Frame + err := try(func(a aborter) { fr = f.aOuter(a) }) + return fr, err } func (f *Frame) aOuter(a aborter) *Frame { @@ -177,9 +177,9 @@ func (f *Frame) aOuter(a aborter) *Frame { return f.outer } - p := f.stk.r.p; + p := f.stk.r.p - sp := f.fp; + sp := f.fp if f.fn == p.sys.newproc && f.fn == p.sys.deferproc { // TODO(rsc) The compiler inserts two push/pop's // around calls to go and defer. Russ says this @@ -188,25 +188,25 @@ func (f *Frame) aOuter(a aborter) *Frame { sp += proc.Word(2 * p.PtrSize()) } - pc := p.peekUintptr(a, f.fp-proc.Word(p.PtrSize())); + pc := p.peekUintptr(a, f.fp-proc.Word(p.PtrSize())) if pc < 0x1000 { return nil } // TODO(austin) Register this frame for shoot-down. - f.outer = prepareFrame(a, pc, sp, f.stk, f); - return f.outer; + f.outer = prepareFrame(a, pc, sp, f.stk, f) + return f.outer } // Inner returns the Frame called by this Frame, or nil if this is the // innermost frame. -func (f *Frame) Inner() *Frame { return f.inner } +func (f *Frame) Inner() *Frame { return f.inner } func (f *Frame) String() string { - res := f.fn.Name; + res := f.fn.Name if f.pc > proc.Word(f.fn.Value) { res += fmt.Sprintf("+%#x", f.pc-proc.Word(f.fn.Entry)) } - return res + fmt.Sprintf(" %s:%d", f.path, f.line); + return res + fmt.Sprintf(" %s:%d", f.path, f.line) } diff --git a/src/pkg/exp/ogle/goroutine.go b/src/pkg/exp/ogle/goroutine.go index 0c0075249..5104ec6d4 100644 --- a/src/pkg/exp/ogle/goroutine.go +++ b/src/pkg/exp/ogle/goroutine.go @@ -5,17 +5,17 @@ package ogle import ( - "debug/proc"; - "exp/eval"; - "fmt"; - "os"; + "debug/proc" + "exp/eval" + "fmt" + "os" ) // A Goroutine represents a goroutine in a remote process. type Goroutine struct { - g remoteStruct; - frame *Frame; - dead bool; + g remoteStruct + frame *Frame + dead bool } func (t *Goroutine) String() string { @@ -24,94 +24,94 @@ func (t *Goroutine) String() string { } // TODO(austin) Give threads friendly ID's, possibly including // the name of the entry function. - return fmt.Sprintf("thread %#x", t.g.addr().base); + return fmt.Sprintf("thread %#x", t.g.addr().base) } // isG0 returns true if this thread if the internal idle thread -func (t *Goroutine) isG0() bool { return t.g.addr().base == t.g.r.p.sys.g0.addr().base } +func (t *Goroutine) isG0() bool { return t.g.addr().base == t.g.r.p.sys.g0.addr().base } func (t *Goroutine) resetFrame() (err os.Error) { // TODO(austin) Reuse any live part of the current frame stack // so existing references to Frame's keep working. - t.frame, err = newFrame(t.g); - return; + t.frame, err = newFrame(t.g) + return } // Out selects the caller frame of the current frame. func (t *Goroutine) Out() os.Error { - f, err := t.frame.Outer(); + f, err := t.frame.Outer() if f != nil { t.frame = f } - return err; + return err } // In selects the frame called by the current frame. func (t *Goroutine) In() os.Error { - f := t.frame.Inner(); + f := t.frame.Inner() if f != nil { t.frame = f } - return nil; + return nil } func readylockedBP(ev Event) (EventAction, os.Error) { - b := ev.(*Breakpoint); - p := b.Process(); + b := ev.(*Breakpoint) + p := b.Process() // The new g is the only argument to this function, so the // stack will have the return address, then the G*. - regs, err := b.osThread.Regs(); + regs, err := b.osThread.Regs() if err != nil { return EAStop, err } - sp := regs.SP(); - addr := sp + proc.Word(p.PtrSize()); - arg := remotePtr{remote{addr, p}, p.runtime.G}; - var gp eval.Value; - err = try(func(a aborter) { gp = arg.aGet(a) }); + sp := regs.SP() + addr := sp + proc.Word(p.PtrSize()) + arg := remotePtr{remote{addr, p}, p.runtime.G} + var gp eval.Value + err = try(func(a aborter) { gp = arg.aGet(a) }) if err != nil { return EAStop, err } if gp == nil { return EAStop, UnknownGoroutine{b.osThread, 0} } - gs := gp.(remoteStruct); - g := &Goroutine{gs, nil, false}; - p.goroutines[gs.addr().base] = g; + gs := gp.(remoteStruct) + g := &Goroutine{gs, nil, false} + p.goroutines[gs.addr().base] = g // Enqueue goroutine creation event - parent := b.Goroutine(); + parent := b.Goroutine() if parent.isG0() { parent = nil } - p.postEvent(&GoroutineCreate{commonEvent{p, g}, parent}); + p.postEvent(&GoroutineCreate{commonEvent{p, g}, parent}) // If we don't have any thread selected, select this one if p.curGoroutine == nil { p.curGoroutine = g } - return EADefault, nil; + return EADefault, nil } func goexitBP(ev Event) (EventAction, os.Error) { - b := ev.(*Breakpoint); - p := b.Process(); + b := ev.(*Breakpoint) + p := b.Process() - g := b.Goroutine(); - g.dead = true; + g := b.Goroutine() + g.dead = true - addr := g.g.addr().base; - p.goroutines[addr] = nil, false; + addr := g.g.addr().base + p.goroutines[addr] = nil, false // Enqueue thread exit event - p.postEvent(&GoroutineExit{commonEvent{p, g}}); + p.postEvent(&GoroutineExit{commonEvent{p, g}}) // If we just exited our selected goroutine, selected another if p.curGoroutine == g { p.selectSomeGoroutine() } - return EADefault, nil; + return EADefault, nil } diff --git a/src/pkg/exp/ogle/main.go b/src/pkg/exp/ogle/main.go index 39e002978..1999eccca 100644 --- a/src/pkg/exp/ogle/main.go +++ b/src/pkg/exp/ogle/main.go @@ -6,4 +6,4 @@ package main import "exp/ogle" -func main() { ogle.Main() } +func main() { ogle.Main() } diff --git a/src/pkg/exp/ogle/process.go b/src/pkg/exp/ogle/process.go index efe3c4da4..63f42a9d4 100644 --- a/src/pkg/exp/ogle/process.go +++ b/src/pkg/exp/ogle/process.go @@ -5,14 +5,14 @@ package ogle import ( - "debug/elf"; - "debug/gosym"; - "debug/proc"; - "exp/eval"; - "fmt"; - "log"; - "os"; - "reflect"; + "debug/elf" + "debug/gosym" + "debug/proc" + "exp/eval" + "fmt" + "log" + "os" + "reflect" ) // A FormatError indicates a failure to process information in or @@ -20,7 +20,7 @@ import ( // in the object file or runtime structures. type FormatError string -func (e FormatError) String() string { return string(e) } +func (e FormatError) String() string { return string(e) } // An UnknownArchitecture occurs when trying to load an object file // that indicates an architecture not supported by the debugger. @@ -34,13 +34,13 @@ func (e UnknownArchitecture) String() string { // memory or registers of a process that is not stopped. type ProcessNotStopped struct{} -func (e ProcessNotStopped) String() string { return "process not stopped" } +func (e ProcessNotStopped) String() string { return "process not stopped" } // An UnknownGoroutine error is an internal error representing an // unrecognized G structure pointer. type UnknownGoroutine struct { - OSThread proc.Thread; - Goroutine proc.Word; + OSThread proc.Thread + Goroutine proc.Word } func (e UnknownGoroutine) String() string { @@ -52,50 +52,50 @@ func (e UnknownGoroutine) String() string { // process). type NoCurrentGoroutine struct{} -func (e NoCurrentGoroutine) String() string { return "no current goroutine" } +func (e NoCurrentGoroutine) String() string { return "no current goroutine" } // A Process represents a remote attached process. type Process struct { - Arch; - proc proc.Process; + Arch + proc proc.Process // The symbol table of this process - syms *gosym.Table; + syms *gosym.Table // A possibly-stopped OS thread, or nil - threadCache proc.Thread; + threadCache proc.Thread // Types parsed from the remote process - types map[proc.Word]*remoteType; + types map[proc.Word]*remoteType // Types and values from the remote runtime package - runtime runtimeValues; + runtime runtimeValues // Runtime field indexes - f runtimeIndexes; + f runtimeIndexes // Globals from the sys package (or from no package) - sys struct { - lessstack, goexit, newproc, deferproc, newprocreadylocked *gosym.Func; - allg remotePtr; - g0 remoteStruct; - }; + sys struct { + lessstack, goexit, newproc, deferproc, newprocreadylocked *gosym.Func + allg remotePtr + g0 remoteStruct + } // Event queue - posted []Event; - pending []Event; - event Event; + posted []Event + pending []Event + event Event // Event hooks - breakpointHooks map[proc.Word]*breakpointHook; - goroutineCreateHook *goroutineCreateHook; - goroutineExitHook *goroutineExitHook; + breakpointHooks map[proc.Word]*breakpointHook + goroutineCreateHook *goroutineCreateHook + goroutineExitHook *goroutineExitHook // Current goroutine, or nil if there are no goroutines - curGoroutine *Goroutine; + curGoroutine *Goroutine // Goroutines by the address of their G structure - goroutines map[proc.Word]*Goroutine; + goroutines map[proc.Word]*Goroutine } /* @@ -114,10 +114,10 @@ func NewProcess(tproc proc.Process, arch Arch, syms *gosym.Table) (*Process, os. goroutineCreateHook: new(goroutineCreateHook), goroutineExitHook: new(goroutineExitHook), goroutines: make(map[proc.Word]*Goroutine), - }; + } // Fill in remote runtime - p.bootstrap(); + p.bootstrap() switch { case p.sys.allg.addr().base == 0: @@ -131,127 +131,127 @@ func NewProcess(tproc proc.Process, arch Arch, syms *gosym.Table) (*Process, os. } // Get current goroutines - p.goroutines[p.sys.g0.addr().base] = &Goroutine{p.sys.g0, nil, false}; + p.goroutines[p.sys.g0.addr().base] = &Goroutine{p.sys.g0, nil, false} err := try(func(a aborter) { - g := p.sys.allg.aGet(a); + g := p.sys.allg.aGet(a) for g != nil { - gs := g.(remoteStruct); - fmt.Printf("*** Found goroutine at %#x\n", gs.addr().base); - p.goroutines[gs.addr().base] = &Goroutine{gs, nil, false}; - g = gs.field(p.f.G.Alllink).(remotePtr).aGet(a); + gs := g.(remoteStruct) + fmt.Printf("*** Found goroutine at %#x\n", gs.addr().base) + p.goroutines[gs.addr().base] = &Goroutine{gs, nil, false} + g = gs.field(p.f.G.Alllink).(remotePtr).aGet(a) } - }); + }) if err != nil { return nil, err } // Create internal breakpoints to catch new and exited goroutines - p.OnBreakpoint(proc.Word(p.sys.newprocreadylocked.Entry)).(*breakpointHook).addHandler(readylockedBP, true); - p.OnBreakpoint(proc.Word(p.sys.goexit.Entry)).(*breakpointHook).addHandler(goexitBP, true); + p.OnBreakpoint(proc.Word(p.sys.newprocreadylocked.Entry)).(*breakpointHook).addHandler(readylockedBP, true) + p.OnBreakpoint(proc.Word(p.sys.goexit.Entry)).(*breakpointHook).addHandler(goexitBP, true) // Select current frames for _, g := range p.goroutines { g.resetFrame() } - p.selectSomeGoroutine(); + p.selectSomeGoroutine() - return p, nil; + return p, nil } func elfGoSyms(f *elf.File) (*gosym.Table, os.Error) { - text := f.Section(".text"); - symtab := f.Section(".gosymtab"); - pclntab := f.Section(".gopclntab"); + text := f.Section(".text") + symtab := f.Section(".gosymtab") + pclntab := f.Section(".gopclntab") if text == nil || symtab == nil || pclntab == nil { return nil, nil } - symdat, err := symtab.Data(); + symdat, err := symtab.Data() if err != nil { return nil, err } - pclndat, err := pclntab.Data(); + pclndat, err := pclntab.Data() if err != nil { return nil, err } - pcln := gosym.NewLineTable(pclndat, text.Addr); - tab, err := gosym.NewTable(symdat, pcln); + pcln := gosym.NewLineTable(pclndat, text.Addr) + tab, err := gosym.NewTable(symdat, pcln) if err != nil { return nil, err } - return tab, nil; + return tab, nil } // NewProcessElf constructs a new remote process around a traced // process and the process' ELF object. func NewProcessElf(tproc proc.Process, f *elf.File) (*Process, os.Error) { - syms, err := elfGoSyms(f); + syms, err := elfGoSyms(f) if err != nil { return nil, err } if syms == nil { return nil, FormatError("Failed to find symbol table") } - var arch Arch; + var arch Arch switch f.Machine { case elf.EM_X86_64: arch = Amd64 default: return nil, UnknownArchitecture(f.Machine) } - return NewProcess(tproc, arch, syms); + return NewProcess(tproc, arch, syms) } // bootstrap constructs the runtime structure of a remote process. func (p *Process) bootstrap() { // Manually construct runtime types - p.runtime.String = newManualType(eval.TypeOfNative(rt1String{}), p.Arch); - p.runtime.Slice = newManualType(eval.TypeOfNative(rt1Slice{}), p.Arch); - p.runtime.Eface = newManualType(eval.TypeOfNative(rt1Eface{}), p.Arch); - - p.runtime.Type = newManualType(eval.TypeOfNative(rt1Type{}), p.Arch); - p.runtime.CommonType = newManualType(eval.TypeOfNative(rt1CommonType{}), p.Arch); - p.runtime.UncommonType = newManualType(eval.TypeOfNative(rt1UncommonType{}), p.Arch); - p.runtime.StructField = newManualType(eval.TypeOfNative(rt1StructField{}), p.Arch); - p.runtime.StructType = newManualType(eval.TypeOfNative(rt1StructType{}), p.Arch); - p.runtime.PtrType = newManualType(eval.TypeOfNative(rt1PtrType{}), p.Arch); - p.runtime.ArrayType = newManualType(eval.TypeOfNative(rt1ArrayType{}), p.Arch); - p.runtime.SliceType = newManualType(eval.TypeOfNative(rt1SliceType{}), p.Arch); - - p.runtime.Stktop = newManualType(eval.TypeOfNative(rt1Stktop{}), p.Arch); - p.runtime.Gobuf = newManualType(eval.TypeOfNative(rt1Gobuf{}), p.Arch); - p.runtime.G = newManualType(eval.TypeOfNative(rt1G{}), p.Arch); + p.runtime.String = newManualType(eval.TypeOfNative(rt1String{}), p.Arch) + p.runtime.Slice = newManualType(eval.TypeOfNative(rt1Slice{}), p.Arch) + p.runtime.Eface = newManualType(eval.TypeOfNative(rt1Eface{}), p.Arch) + + p.runtime.Type = newManualType(eval.TypeOfNative(rt1Type{}), p.Arch) + p.runtime.CommonType = newManualType(eval.TypeOfNative(rt1CommonType{}), p.Arch) + p.runtime.UncommonType = newManualType(eval.TypeOfNative(rt1UncommonType{}), p.Arch) + p.runtime.StructField = newManualType(eval.TypeOfNative(rt1StructField{}), p.Arch) + p.runtime.StructType = newManualType(eval.TypeOfNative(rt1StructType{}), p.Arch) + p.runtime.PtrType = newManualType(eval.TypeOfNative(rt1PtrType{}), p.Arch) + p.runtime.ArrayType = newManualType(eval.TypeOfNative(rt1ArrayType{}), p.Arch) + p.runtime.SliceType = newManualType(eval.TypeOfNative(rt1SliceType{}), p.Arch) + + p.runtime.Stktop = newManualType(eval.TypeOfNative(rt1Stktop{}), p.Arch) + p.runtime.Gobuf = newManualType(eval.TypeOfNative(rt1Gobuf{}), p.Arch) + p.runtime.G = newManualType(eval.TypeOfNative(rt1G{}), p.Arch) // Get addresses of type.*runtime.XType for discrimination. - rtv := reflect.Indirect(reflect.NewValue(&p.runtime)).(*reflect.StructValue); - rtvt := rtv.Type().(*reflect.StructType); + rtv := reflect.Indirect(reflect.NewValue(&p.runtime)).(*reflect.StructValue) + rtvt := rtv.Type().(*reflect.StructType) for i := 0; i < rtv.NumField(); i++ { - n := rtvt.Field(i).Name; + n := rtvt.Field(i).Name if n[0] != 'P' || n[1] < 'A' || n[1] > 'Z' { continue } - sym := p.syms.LookupSym("type.*runtime." + n[1:]); + sym := p.syms.LookupSym("type.*runtime." + n[1:]) if sym == nil { continue } - rtv.Field(i).(*reflect.Uint64Value).Set(sym.Value); + rtv.Field(i).(*reflect.Uint64Value).Set(sym.Value) } // Get runtime field indexes - fillRuntimeIndexes(&p.runtime, &p.f); + fillRuntimeIndexes(&p.runtime, &p.f) // Fill G status - p.runtime.runtimeGStatus = rt1GStatus; + p.runtime.runtimeGStatus = rt1GStatus // Get globals - p.sys.lessstack = p.syms.LookupFunc("sys.lessstack"); - p.sys.goexit = p.syms.LookupFunc("goexit"); - p.sys.newproc = p.syms.LookupFunc("sys.newproc"); - p.sys.deferproc = p.syms.LookupFunc("sys.deferproc"); - p.sys.newprocreadylocked = p.syms.LookupFunc("newprocreadylocked"); + p.sys.lessstack = p.syms.LookupFunc("sys.lessstack") + p.sys.goexit = p.syms.LookupFunc("goexit") + p.sys.newproc = p.syms.LookupFunc("sys.newproc") + p.sys.deferproc = p.syms.LookupFunc("sys.deferproc") + p.sys.newprocreadylocked = p.syms.LookupFunc("newprocreadylocked") if allg := p.syms.LookupSym("allg"); allg != nil { p.sys.allg = remotePtr{remote{proc.Word(allg.Value), p}, p.runtime.G} } @@ -263,11 +263,11 @@ func (p *Process) bootstrap() { func (p *Process) selectSomeGoroutine() { // Once we have friendly goroutine ID's, there might be a more // reasonable behavior for this. - p.curGoroutine = nil; + p.curGoroutine = nil for _, g := range p.goroutines { if !g.isG0() && g.frame != nil { - p.curGoroutine = g; - return; + p.curGoroutine = g + return } } } @@ -285,27 +285,27 @@ func (p *Process) someStoppedOSThread() proc.Thread { for _, t := range p.proc.Threads() { if _, err := t.Stopped(); err == nil { - p.threadCache = t; - return t; + p.threadCache = t + return t } } - return nil; + return nil } func (p *Process) Peek(addr proc.Word, out []byte) (int, os.Error) { - thr := p.someStoppedOSThread(); + thr := p.someStoppedOSThread() if thr == nil { return 0, ProcessNotStopped{} } - return thr.Peek(addr, out); + return thr.Peek(addr, out) } func (p *Process) Poke(addr proc.Word, b []byte) (int, os.Error) { - thr := p.someStoppedOSThread(); + thr := p.someStoppedOSThread() if thr == nil { return 0, ProcessNotStopped{} } - return thr.Poke(addr, b); + return thr.Poke(addr, b) } func (p *Process) peekUintptr(a aborter, addr proc.Word) proc.Word { @@ -323,7 +323,7 @@ func (p *Process) OnBreakpoint(pc proc.Word) EventHook { return bp } // The breakpoint will register itself when a handler is added - return &breakpointHook{commonHook{nil, 0}, p, pc}; + return &breakpointHook{commonHook{nil, 0}, p, pc} } // OnGoroutineCreate returns the hook that is run when a goroutine is created. @@ -332,27 +332,27 @@ func (p *Process) OnGoroutineCreate() EventHook { } // OnGoroutineExit returns the hook that is run when a goroutine exits. -func (p *Process) OnGoroutineExit() EventHook { return p.goroutineExitHook } +func (p *Process) OnGoroutineExit() EventHook { return p.goroutineExitHook } // osThreadToGoroutine looks up the goroutine running on an OS thread. func (p *Process) osThreadToGoroutine(t proc.Thread) (*Goroutine, os.Error) { - regs, err := t.Regs(); + regs, err := t.Regs() if err != nil { return nil, err } - g := p.G(regs); - gt, ok := p.goroutines[g]; + g := p.G(regs) + gt, ok := p.goroutines[g] if !ok { return nil, UnknownGoroutine{t, g} } - return gt, nil; + return gt, nil } // causesToEvents translates the stop causes of the underlying process // into an event queue. func (p *Process) causesToEvents() ([]Event, os.Error) { // Count causes we're interested in - nev := 0; + nev := 0 for _, t := range p.proc.Threads() { if c, err := t.Stopped(); err == nil { switch c := c.(type) { @@ -366,87 +366,87 @@ func (p *Process) causesToEvents() ([]Event, os.Error) { } // Translate causes to events - events := make([]Event, nev); - i := 0; + events := make([]Event, nev) + i := 0 for _, t := range p.proc.Threads() { if c, err := t.Stopped(); err == nil { switch c := c.(type) { case proc.Breakpoint: - gt, err := p.osThreadToGoroutine(t); + gt, err := p.osThreadToGoroutine(t) if err != nil { return nil, err } - events[i] = &Breakpoint{commonEvent{p, gt}, t, proc.Word(c)}; - i++; + events[i] = &Breakpoint{commonEvent{p, gt}, t, proc.Word(c)} + i++ case proc.Signal: // TODO(austin) } } } - return events, nil; + return events, nil } // postEvent appends an event to the posted queue. These events will // be processed before any currently pending events. func (p *Process) postEvent(ev Event) { - n := len(p.posted); - m := n * 2; + n := len(p.posted) + m := n * 2 if m == 0 { m = 4 } - posted := make([]Event, n+1, m); + posted := make([]Event, n+1, m) for i, p := range p.posted { posted[i] = p } - posted[n] = ev; - p.posted = posted; + posted[n] = ev + p.posted = posted } // processEvents processes events in the event queue until no events // remain, a handler returns EAStop, or a handler returns an error. // It returns either EAStop or EAContinue and possibly an error. func (p *Process) processEvents() (EventAction, os.Error) { - var ev Event; + var ev Event for len(p.posted) > 0 { - ev, p.posted = p.posted[0], p.posted[1:]; - action, err := p.processEvent(ev); + ev, p.posted = p.posted[0], p.posted[1:] + action, err := p.processEvent(ev) if action == EAStop { return action, err } } for len(p.pending) > 0 { - ev, p.pending = p.pending[0], p.pending[1:]; - action, err := p.processEvent(ev); + ev, p.pending = p.pending[0], p.pending[1:] + action, err := p.processEvent(ev) if action == EAStop { return action, err } } - return EAContinue, nil; + return EAContinue, nil } // processEvent processes a single event, without manipulating the // event queues. It returns either EAStop or EAContinue and possibly // an error. func (p *Process) processEvent(ev Event) (EventAction, os.Error) { - p.event = ev; + p.event = ev - var action EventAction; - var err os.Error; + var action EventAction + var err os.Error switch ev := p.event.(type) { case *Breakpoint: - hook, ok := p.breakpointHooks[ev.pc]; + hook, ok := p.breakpointHooks[ev.pc] if !ok { break } - p.curGoroutine = ev.Goroutine(); - action, err = hook.handle(ev); + p.curGoroutine = ev.Goroutine() + action, err = hook.handle(ev) case *GoroutineCreate: - p.curGoroutine = ev.Goroutine(); - action, err = p.goroutineCreateHook.handle(ev); + p.curGoroutine = ev.Goroutine() + action, err = p.goroutineCreateHook.handle(ev) case *GoroutineExit: action, err = p.goroutineExitHook.handle(ev) @@ -460,14 +460,14 @@ func (p *Process) processEvent(ev Event) (EventAction, os.Error) { } else if action == EAStop { return EAStop, nil } - return EAContinue, nil; + return EAContinue, nil } // Event returns the last event that caused the process to stop. This // may return nil if the process has never been stopped by an event. // // TODO(austin) Return nil if the user calls p.Stop()? -func (p *Process) Event() Event { return p.event } +func (p *Process) Event() Event { return p.event } /* * Process control @@ -489,29 +489,29 @@ func (p *Process) Event() Event { return p.event } // that stops the process. func (p *Process) ContWait() os.Error { for { - a, err := p.processEvents(); + a, err := p.processEvents() if err != nil { return err } else if a == EAStop { break } - err = p.proc.Continue(); + err = p.proc.Continue() if err != nil { return err } - err = p.proc.WaitStop(); + err = p.proc.WaitStop() if err != nil { return err } for _, g := range p.goroutines { g.resetFrame() } - p.pending, err = p.causesToEvents(); + p.pending, err = p.causesToEvents() if err != nil { return err } } - return nil; + return nil } // Out selects the caller frame of the current frame. @@ -519,7 +519,7 @@ func (p *Process) Out() os.Error { if p.curGoroutine == nil { return NoCurrentGoroutine{} } - return p.curGoroutine.Out(); + return p.curGoroutine.Out() } // In selects the frame called by the current frame. @@ -527,5 +527,5 @@ func (p *Process) In() os.Error { if p.curGoroutine == nil { return NoCurrentGoroutine{} } - return p.curGoroutine.In(); + return p.curGoroutine.In() } diff --git a/src/pkg/exp/ogle/rruntime.go b/src/pkg/exp/ogle/rruntime.go index 1a7881476..b13344a5f 100644 --- a/src/pkg/exp/ogle/rruntime.go +++ b/src/pkg/exp/ogle/rruntime.go @@ -5,9 +5,9 @@ package ogle import ( - "debug/proc"; - "exp/eval"; - "reflect"; + "debug/proc" + "exp/eval" + "reflect" ) // This file contains remote runtime definitions. Using reflection, @@ -31,19 +31,19 @@ import ( */ type rt1String struct { - str uintptr; - len int; + str uintptr + len int } type rt1Slice struct { - array uintptr; - len int; - cap int; + array uintptr + len int + cap int } type rt1Eface struct { - typ uintptr; - ptr uintptr; + typ uintptr + ptr uintptr } /* @@ -53,17 +53,17 @@ type rt1Eface struct { */ type rt1UncommonType struct { - name *string; - pkgPath *string; + name *string + pkgPath *string //methods []method; } type rt1CommonType struct { - size uintptr; - hash uint32; - alg, align, fieldAlign uint8; - string *string; - uncommonType *rt1UncommonType; + size uintptr + hash uint32 + alg, align, fieldAlign uint8 + string *string + uncommonType *rt1UncommonType } type rt1Type struct { @@ -71,37 +71,37 @@ type rt1Type struct { // discriminator as an opaque pointer and taking advantage of // the commonType prologue on all Type's makes type parsing // much simpler. - typ uintptr; - ptr *rt1CommonType; + typ uintptr + ptr *rt1CommonType } type rt1StructField struct { - name *string; - pkgPath *string; - typ *rt1Type; - tag *string; - offset uintptr; + name *string + pkgPath *string + typ *rt1Type + tag *string + offset uintptr } type rt1StructType struct { - rt1CommonType; - fields []rt1StructField; + rt1CommonType + fields []rt1StructField } type rt1PtrType struct { - rt1CommonType; - elem *rt1Type; + rt1CommonType + elem *rt1Type } type rt1SliceType struct { - rt1CommonType; - elem *rt1Type; + rt1CommonType + elem *rt1Type } type rt1ArrayType struct { - rt1CommonType; - elem *rt1Type; - len uintptr; + rt1CommonType + elem *rt1Type + len uintptr } /* @@ -113,30 +113,30 @@ type rt1ArrayType struct { // Fields beginning with _ are only for padding type rt1Stktop struct { - stackguard uintptr; - stackbase *rt1Stktop; - gobuf rt1Gobuf; - _args uint32; - _fp uintptr; + stackguard uintptr + stackbase *rt1Stktop + gobuf rt1Gobuf + _args uint32 + _fp uintptr } type rt1Gobuf struct { - sp uintptr; - pc uintptr; - g *rt1G; - r0 uintptr; + sp uintptr + pc uintptr + g *rt1G + r0 uintptr } type rt1G struct { - _stackguard uintptr; - stackbase *rt1Stktop; - _defer uintptr; - sched rt1Gobuf; - _stack0 uintptr; - _entry uintptr; - alllink *rt1G; - _param uintptr; - status int16; + _stackguard uintptr + stackbase *rt1Stktop + _defer uintptr + sched rt1Gobuf + _stack0 uintptr + _entry uintptr + alllink *rt1G + _param uintptr + status int16 // Incomplete } @@ -156,67 +156,67 @@ var rt1GStatus = runtimeGStatus{ // exactly and the names of the index fields must be the capitalized // version of the names of the fields in the runtime structures above. type runtimeIndexes struct { - String struct { - Str, Len int; - }; - Slice struct { - Array, Len, Cap int; - }; - Eface struct { - Typ, Ptr int; - }; + String struct { + Str, Len int + } + Slice struct { + Array, Len, Cap int + } + Eface struct { + Typ, Ptr int + } - UncommonType struct { - Name, PkgPath int; - }; - CommonType struct { - Size, Hash, Alg, Align, FieldAlign, String, UncommonType int; - }; - Type struct { - Typ, Ptr int; - }; - StructField struct { - Name, PkgPath, Typ, Tag, Offset int; - }; - StructType struct { - Fields int; - }; - PtrType struct { - Elem int; - }; - SliceType struct { - Elem int; - }; - ArrayType struct { - Elem, Len int; - }; + UncommonType struct { + Name, PkgPath int + } + CommonType struct { + Size, Hash, Alg, Align, FieldAlign, String, UncommonType int + } + Type struct { + Typ, Ptr int + } + StructField struct { + Name, PkgPath, Typ, Tag, Offset int + } + StructType struct { + Fields int + } + PtrType struct { + Elem int + } + SliceType struct { + Elem int + } + ArrayType struct { + Elem, Len int + } - Stktop struct { - Stackguard, Stackbase, Gobuf int; - }; - Gobuf struct { - Sp, Pc, G int; - }; - G struct { - Stackbase, Sched, Status, Alllink int; - }; + Stktop struct { + Stackguard, Stackbase, Gobuf int + } + Gobuf struct { + Sp, Pc, G int + } + G struct { + Stackbase, Sched, Status, Alllink int + } } // Values of G status codes type runtimeGStatus struct { - Gidle, Grunnable, Grunning, Gsyscall, Gwaiting, Gmoribund, Gdead int64; + Gidle, Grunnable, Grunning, Gsyscall, Gwaiting, Gmoribund, Gdead int64 } // runtimeValues stores the types and values that correspond to those // in the remote runtime package. type runtimeValues struct { // Runtime data headers - String, Slice, Eface *remoteType; + String, Slice, Eface *remoteType // Runtime type structures Type, CommonType, UncommonType, StructField, StructType, PtrType, - ArrayType, SliceType *remoteType; + ArrayType, SliceType *remoteType // Runtime scheduler structures - Stktop, Gobuf, G *remoteType; + Stktop, Gobuf, G *remoteType // Addresses of *runtime.XType types. These are the // discriminators on the runtime.Type interface. We use local // reflection to fill these in from the remote symbol table, @@ -227,45 +227,45 @@ type runtimeValues struct { PFloat32Type, PFloat64Type, PFloatType, PArrayType, PStringType, PStructType, PPtrType, PFuncType, PInterfaceType, PSliceType, PMapType, PChanType, - PDotDotDotType, PUnsafePointerType proc.Word; + PDotDotDotType, PUnsafePointerType proc.Word // G status values - runtimeGStatus; + runtimeGStatus } // fillRuntimeIndexes fills a runtimeIndexes structure will the field // indexes gathered from the remoteTypes recorded in a runtimeValues // structure. func fillRuntimeIndexes(runtime *runtimeValues, out *runtimeIndexes) { - outv := reflect.Indirect(reflect.NewValue(out)).(*reflect.StructValue); - outt := outv.Type().(*reflect.StructType); - runtimev := reflect.Indirect(reflect.NewValue(runtime)).(*reflect.StructValue); + outv := reflect.Indirect(reflect.NewValue(out)).(*reflect.StructValue) + outt := outv.Type().(*reflect.StructType) + runtimev := reflect.Indirect(reflect.NewValue(runtime)).(*reflect.StructValue) // out contains fields corresponding to each runtime type for i := 0; i < outt.NumField(); i++ { // Find the interpreter type for this runtime type - name := outt.Field(i).Name; - et := runtimev.FieldByName(name).Interface().(*remoteType).Type.(*eval.StructType); + name := outt.Field(i).Name + et := runtimev.FieldByName(name).Interface().(*remoteType).Type.(*eval.StructType) // Get the field indexes of the interpreter struct type - indexes := make(map[string]int, len(et.Elems)); + indexes := make(map[string]int, len(et.Elems)) for j, f := range et.Elems { if f.Anonymous { continue } - name := f.Name; + name := f.Name if name[0] >= 'a' && name[0] <= 'z' { name = string(name[0]+'A'-'a') + name[1:] } - indexes[name] = j; + indexes[name] = j } // Fill this field of out - outStructv := outv.Field(i).(*reflect.StructValue); - outStructt := outStructv.Type().(*reflect.StructType); + outStructv := outv.Field(i).(*reflect.StructValue) + outStructt := outStructv.Type().(*reflect.StructType) for j := 0; j < outStructt.NumField(); j++ { - f := outStructv.Field(j).(*reflect.IntValue); - name := outStructt.Field(j).Name; - f.Set(indexes[name]); + f := outStructv.Field(j).(*reflect.IntValue) + name := outStructt.Field(j).Name + f.Set(indexes[name]) } } } diff --git a/src/pkg/exp/ogle/rtype.go b/src/pkg/exp/ogle/rtype.go index 8814792ef..b20acbad5 100644 --- a/src/pkg/exp/ogle/rtype.go +++ b/src/pkg/exp/ogle/rtype.go @@ -5,25 +5,25 @@ package ogle import ( - "debug/proc"; - "exp/eval"; - "fmt"; - "log"; + "debug/proc" + "exp/eval" + "fmt" + "log" ) const debugParseRemoteType = false // A remoteType is the local representation of a type in a remote process. type remoteType struct { - eval.Type; + eval.Type // The size of values of this type in bytes. - size int; + size int // The field alignment of this type. Only used for // manually-constructed types. - fieldAlign int; + fieldAlign int // The maker function to turn a remote address of a value of // this type into an interpreter Value. - mk maker; + mk maker } var manualTypes = make(map[Arch]map[eval.Type]*remoteType) @@ -38,76 +38,76 @@ func newManualType(t eval.Type, arch Arch) *remoteType { } // Get the type map for this architecture - typeMap, _ := manualTypes[arch]; + typeMap, _ := manualTypes[arch] if typeMap == nil { - typeMap = make(map[eval.Type]*remoteType); - manualTypes[arch] = typeMap; + typeMap = make(map[eval.Type]*remoteType) + manualTypes[arch] = typeMap // Construct basic types for this architecture basicType := func(t eval.Type, mk maker, size int, fieldAlign int) { - t = t.(*eval.NamedType).Def; + t = t.(*eval.NamedType).Def if fieldAlign == 0 { fieldAlign = size } - typeMap[t] = &remoteType{t, size, fieldAlign, mk}; - }; - basicType(eval.Uint8Type, mkUint8, 1, 0); - basicType(eval.Uint32Type, mkUint32, 4, 0); - basicType(eval.UintptrType, mkUintptr, arch.PtrSize(), 0); - basicType(eval.Int16Type, mkInt16, 2, 0); - basicType(eval.Int32Type, mkInt32, 4, 0); - basicType(eval.IntType, mkInt, arch.IntSize(), 0); - basicType(eval.StringType, mkString, arch.PtrSize()+arch.IntSize(), arch.PtrSize()); + typeMap[t] = &remoteType{t, size, fieldAlign, mk} + } + basicType(eval.Uint8Type, mkUint8, 1, 0) + basicType(eval.Uint32Type, mkUint32, 4, 0) + basicType(eval.UintptrType, mkUintptr, arch.PtrSize(), 0) + basicType(eval.Int16Type, mkInt16, 2, 0) + basicType(eval.Int32Type, mkInt32, 4, 0) + basicType(eval.IntType, mkInt, arch.IntSize(), 0) + basicType(eval.StringType, mkString, arch.PtrSize()+arch.IntSize(), arch.PtrSize()) } if rt, ok := typeMap[t]; ok { return rt } - var rt *remoteType; + var rt *remoteType switch t := t.(type) { case *eval.PtrType: - var elem *remoteType; - mk := func(r remote) eval.Value { return remotePtr{r, elem} }; - rt = &remoteType{t, arch.PtrSize(), arch.PtrSize(), mk}; + var elem *remoteType + mk := func(r remote) eval.Value { return remotePtr{r, elem} } + rt = &remoteType{t, arch.PtrSize(), arch.PtrSize(), mk} // Construct the element type after registering the // type to break cycles. - typeMap[eval.Type(t)] = rt; - elem = newManualType(t.Elem, arch); + typeMap[eval.Type(t)] = rt + elem = newManualType(t.Elem, arch) case *eval.ArrayType: - elem := newManualType(t.Elem, arch); - mk := func(r remote) eval.Value { return remoteArray{r, t.Len, elem} }; - rt = &remoteType{t, elem.size * int(t.Len), elem.fieldAlign, mk}; + elem := newManualType(t.Elem, arch) + mk := func(r remote) eval.Value { return remoteArray{r, t.Len, elem} } + rt = &remoteType{t, elem.size * int(t.Len), elem.fieldAlign, mk} case *eval.SliceType: - elem := newManualType(t.Elem, arch); - mk := func(r remote) eval.Value { return remoteSlice{r, elem} }; - rt = &remoteType{t, arch.PtrSize() + 2*arch.IntSize(), arch.PtrSize(), mk}; + elem := newManualType(t.Elem, arch) + mk := func(r remote) eval.Value { return remoteSlice{r, elem} } + rt = &remoteType{t, arch.PtrSize() + 2*arch.IntSize(), arch.PtrSize(), mk} case *eval.StructType: - layout := make([]remoteStructField, len(t.Elems)); - offset := 0; - fieldAlign := 0; + layout := make([]remoteStructField, len(t.Elems)) + offset := 0 + fieldAlign := 0 for i, f := range t.Elems { - elem := newManualType(f.Type, arch); + elem := newManualType(f.Type, arch) if fieldAlign == 0 { fieldAlign = elem.fieldAlign } - offset = arch.Align(offset, elem.fieldAlign); - layout[i].offset = offset; - layout[i].fieldType = elem; - offset += elem.size; + offset = arch.Align(offset, elem.fieldAlign) + layout[i].offset = offset + layout[i].fieldType = elem + offset += elem.size } - mk := func(r remote) eval.Value { return remoteStruct{r, layout} }; - rt = &remoteType{t, offset, fieldAlign, mk}; + mk := func(r remote) eval.Value { return remoteStruct{r, layout} } + rt = &remoteType{t, offset, fieldAlign, mk} default: log.Crashf("cannot manually construct type %T", t) } - typeMap[t] = rt; - return rt; + typeMap[t] = rt + return rt } var prtIndent = "" @@ -115,8 +115,8 @@ var prtIndent = "" // parseRemoteType parses a Type structure in a remote process to // construct the corresponding interpreter type and remote type. func parseRemoteType(a aborter, rs remoteStruct) *remoteType { - addr := rs.addr().base; - p := rs.addr().p; + addr := rs.addr().base + p := rs.addr().p // We deal with circular types by discovering cycles at // NamedTypes. If a type cycles back to something other than @@ -128,154 +128,154 @@ func parseRemoteType(a aborter, rs remoteStruct) *remoteType { // first time we encounter the type and re-use that structure // the second time we encounter it. - rt, ok := p.types[addr]; + rt, ok := p.types[addr] if ok && rt.Type != nil { return rt } else if !ok { - rt = &remoteType{}; - p.types[addr] = rt; + rt = &remoteType{} + p.types[addr] = rt } if debugParseRemoteType { - sym := p.syms.SymByAddr(uint64(addr)); - name := "<unknown>"; + sym := p.syms.SymByAddr(uint64(addr)) + name := "<unknown>" if sym != nil { name = sym.Name } - log.Stderrf("%sParsing type at %#x (%s)", prtIndent, addr, name); - prtIndent += " "; - defer func() { prtIndent = prtIndent[0 : len(prtIndent)-1] }(); + log.Stderrf("%sParsing type at %#x (%s)", prtIndent, addr, name) + prtIndent += " " + defer func() { prtIndent = prtIndent[0 : len(prtIndent)-1] }() } // Get Type header - itype := proc.Word(rs.field(p.f.Type.Typ).(remoteUint).aGet(a)); - typ := rs.field(p.f.Type.Ptr).(remotePtr).aGet(a).(remoteStruct); + itype := proc.Word(rs.field(p.f.Type.Typ).(remoteUint).aGet(a)) + typ := rs.field(p.f.Type.Ptr).(remotePtr).aGet(a).(remoteStruct) // Is this a named type? - var nt *eval.NamedType; - uncommon := typ.field(p.f.CommonType.UncommonType).(remotePtr).aGet(a); + var nt *eval.NamedType + uncommon := typ.field(p.f.CommonType.UncommonType).(remotePtr).aGet(a) if uncommon != nil { - name := uncommon.(remoteStruct).field(p.f.UncommonType.Name).(remotePtr).aGet(a); + name := uncommon.(remoteStruct).field(p.f.UncommonType.Name).(remotePtr).aGet(a) if name != nil { // TODO(austin) Declare type in appropriate remote package - nt = eval.NewNamedType(name.(remoteString).aGet(a)); - rt.Type = nt; + nt = eval.NewNamedType(name.(remoteString).aGet(a)) + rt.Type = nt } } // Create type - var t eval.Type; - var mk maker; + var t eval.Type + var mk maker switch itype { case p.runtime.PBoolType: - t = eval.BoolType; - mk = mkBool; + t = eval.BoolType + mk = mkBool case p.runtime.PUint8Type: - t = eval.Uint8Type; - mk = mkUint8; + t = eval.Uint8Type + mk = mkUint8 case p.runtime.PUint16Type: - t = eval.Uint16Type; - mk = mkUint16; + t = eval.Uint16Type + mk = mkUint16 case p.runtime.PUint32Type: - t = eval.Uint32Type; - mk = mkUint32; + t = eval.Uint32Type + mk = mkUint32 case p.runtime.PUint64Type: - t = eval.Uint64Type; - mk = mkUint64; + t = eval.Uint64Type + mk = mkUint64 case p.runtime.PUintType: - t = eval.UintType; - mk = mkUint; + t = eval.UintType + mk = mkUint case p.runtime.PUintptrType: - t = eval.UintptrType; - mk = mkUintptr; + t = eval.UintptrType + mk = mkUintptr case p.runtime.PInt8Type: - t = eval.Int8Type; - mk = mkInt8; + t = eval.Int8Type + mk = mkInt8 case p.runtime.PInt16Type: - t = eval.Int16Type; - mk = mkInt16; + t = eval.Int16Type + mk = mkInt16 case p.runtime.PInt32Type: - t = eval.Int32Type; - mk = mkInt32; + t = eval.Int32Type + mk = mkInt32 case p.runtime.PInt64Type: - t = eval.Int64Type; - mk = mkInt64; + t = eval.Int64Type + mk = mkInt64 case p.runtime.PIntType: - t = eval.IntType; - mk = mkInt; + t = eval.IntType + mk = mkInt case p.runtime.PFloat32Type: - t = eval.Float32Type; - mk = mkFloat32; + t = eval.Float32Type + mk = mkFloat32 case p.runtime.PFloat64Type: - t = eval.Float64Type; - mk = mkFloat64; + t = eval.Float64Type + mk = mkFloat64 case p.runtime.PFloatType: - t = eval.FloatType; - mk = mkFloat; + t = eval.FloatType + mk = mkFloat case p.runtime.PStringType: - t = eval.StringType; - mk = mkString; + t = eval.StringType + mk = mkString case p.runtime.PArrayType: // Cast to an ArrayType - typ := p.runtime.ArrayType.mk(typ.addr()).(remoteStruct); - len := int64(typ.field(p.f.ArrayType.Len).(remoteUint).aGet(a)); - elem := parseRemoteType(a, typ.field(p.f.ArrayType.Elem).(remotePtr).aGet(a).(remoteStruct)); - t = eval.NewArrayType(len, elem.Type); - mk = func(r remote) eval.Value { return remoteArray{r, len, elem} }; + typ := p.runtime.ArrayType.mk(typ.addr()).(remoteStruct) + len := int64(typ.field(p.f.ArrayType.Len).(remoteUint).aGet(a)) + elem := parseRemoteType(a, typ.field(p.f.ArrayType.Elem).(remotePtr).aGet(a).(remoteStruct)) + t = eval.NewArrayType(len, elem.Type) + mk = func(r remote) eval.Value { return remoteArray{r, len, elem} } case p.runtime.PStructType: // Cast to a StructType - typ := p.runtime.StructType.mk(typ.addr()).(remoteStruct); - fs := typ.field(p.f.StructType.Fields).(remoteSlice).aGet(a); + typ := p.runtime.StructType.mk(typ.addr()).(remoteStruct) + fs := typ.field(p.f.StructType.Fields).(remoteSlice).aGet(a) - fields := make([]eval.StructField, fs.Len); - layout := make([]remoteStructField, fs.Len); + fields := make([]eval.StructField, fs.Len) + layout := make([]remoteStructField, fs.Len) for i := range fields { - f := fs.Base.(remoteArray).elem(int64(i)).(remoteStruct); - elemrs := f.field(p.f.StructField.Typ).(remotePtr).aGet(a).(remoteStruct); - elem := parseRemoteType(a, elemrs); - fields[i].Type = elem.Type; - name := f.field(p.f.StructField.Name).(remotePtr).aGet(a); + f := fs.Base.(remoteArray).elem(int64(i)).(remoteStruct) + elemrs := f.field(p.f.StructField.Typ).(remotePtr).aGet(a).(remoteStruct) + elem := parseRemoteType(a, elemrs) + fields[i].Type = elem.Type + name := f.field(p.f.StructField.Name).(remotePtr).aGet(a) if name == nil { fields[i].Anonymous = true } else { fields[i].Name = name.(remoteString).aGet(a) } - layout[i].offset = int(f.field(p.f.StructField.Offset).(remoteUint).aGet(a)); - layout[i].fieldType = elem; + layout[i].offset = int(f.field(p.f.StructField.Offset).(remoteUint).aGet(a)) + layout[i].fieldType = elem } - t = eval.NewStructType(fields); - mk = func(r remote) eval.Value { return remoteStruct{r, layout} }; + t = eval.NewStructType(fields) + mk = func(r remote) eval.Value { return remoteStruct{r, layout} } case p.runtime.PPtrType: // Cast to a PtrType - typ := p.runtime.PtrType.mk(typ.addr()).(remoteStruct); - elem := parseRemoteType(a, typ.field(p.f.PtrType.Elem).(remotePtr).aGet(a).(remoteStruct)); - t = eval.NewPtrType(elem.Type); - mk = func(r remote) eval.Value { return remotePtr{r, elem} }; + typ := p.runtime.PtrType.mk(typ.addr()).(remoteStruct) + elem := parseRemoteType(a, typ.field(p.f.PtrType.Elem).(remotePtr).aGet(a).(remoteStruct)) + t = eval.NewPtrType(elem.Type) + mk = func(r remote) eval.Value { return remotePtr{r, elem} } case p.runtime.PSliceType: // Cast to a SliceType - typ := p.runtime.SliceType.mk(typ.addr()).(remoteStruct); - elem := parseRemoteType(a, typ.field(p.f.SliceType.Elem).(remotePtr).aGet(a).(remoteStruct)); - t = eval.NewSliceType(elem.Type); - mk = func(r remote) eval.Value { return remoteSlice{r, elem} }; + typ := p.runtime.SliceType.mk(typ.addr()).(remoteStruct) + elem := parseRemoteType(a, typ.field(p.f.SliceType.Elem).(remotePtr).aGet(a).(remoteStruct)) + t = eval.NewSliceType(elem.Type) + mk = func(r remote) eval.Value { return remoteSlice{r, elem} } case p.runtime.PMapType, p.runtime.PChanType, p.runtime.PFuncType, p.runtime.PInterfaceType, p.runtime.PUnsafePointerType, p.runtime.PDotDotDotType: // TODO(austin) - t = eval.UintptrType; - mk = mkUintptr; + t = eval.UintptrType + mk = mkUintptr default: - sym := p.syms.SymByAddr(uint64(itype)); - name := "<unknown symbol>"; + sym := p.syms.SymByAddr(uint64(itype)) + name := "<unknown symbol>" if sym != nil { name = sym.Name } - err := fmt.Sprintf("runtime type at %#x has unexpected type %#x (%s)", addr, itype, name); - a.Abort(FormatError(err)); + err := fmt.Sprintf("runtime type at %#x has unexpected type %#x (%s)", addr, itype, name) + a.Abort(FormatError(err)) } // Fill in the remote type @@ -284,8 +284,8 @@ func parseRemoteType(a aborter, rs remoteStruct) *remoteType { } else { rt.Type = t } - rt.size = int(typ.field(p.f.CommonType.Size).(remoteUint).aGet(a)); - rt.mk = mk; + rt.size = int(typ.field(p.f.CommonType.Size).(remoteUint).aGet(a)) + rt.mk = mk - return rt; + return rt } diff --git a/src/pkg/exp/ogle/rvalue.go b/src/pkg/exp/ogle/rvalue.go index ac5ec2be3..ba915ed5c 100644 --- a/src/pkg/exp/ogle/rvalue.go +++ b/src/pkg/exp/ogle/rvalue.go @@ -5,9 +5,9 @@ package ogle import ( - "debug/proc"; - "exp/eval"; - "fmt"; + "debug/proc" + "exp/eval" + "fmt" ) // A RemoteMismatchError occurs when an operation that requires two @@ -16,26 +16,26 @@ import ( // point to something in another process. type RemoteMismatchError string -func (e RemoteMismatchError) String() string { return string(e) } +func (e RemoteMismatchError) String() string { return string(e) } // A ReadOnlyError occurs when attempting to set or assign to a // read-only value. type ReadOnlyError string -func (e ReadOnlyError) String() string { return string(e) } +func (e ReadOnlyError) String() string { return string(e) } // A maker is a function that converts a remote address into an // interpreter Value. type maker func(remote) eval.Value type remoteValue interface { - addr() remote; + addr() remote } // remote represents an address in a remote process. type remote struct { - base proc.Word; - p *Process; + base proc.Word + p *Process } func (v remote) Get(a aborter, size int) uint64 { @@ -55,34 +55,34 @@ func (v remote) Get(a aborter, size int) uint64 { // // TODO(austin) We need to prevent the remote garbage // collector from collecting objects out from under us. - var arr [8]byte; - buf := arr[0:size]; - _, err := v.p.Peek(v.base, buf); + var arr [8]byte + buf := arr[0:size] + _, err := v.p.Peek(v.base, buf) if err != nil { a.Abort(err) } - return uint64(v.p.ToWord(buf)); + return uint64(v.p.ToWord(buf)) } func (v remote) Set(a aborter, size int, x uint64) { - var arr [8]byte; - buf := arr[0:size]; - v.p.FromWord(proc.Word(x), buf); - _, err := v.p.Poke(v.base, buf); + var arr [8]byte + buf := arr[0:size] + v.p.FromWord(proc.Word(x), buf) + _, err := v.p.Poke(v.base, buf) if err != nil { a.Abort(err) } } -func (v remote) plus(x proc.Word) remote { return remote{v.base + x, v.p} } +func (v remote) plus(x proc.Word) remote { return remote{v.base + x, v.p} } func tryRVString(f func(a aborter) string) string { - var s string; - err := try(func(a aborter) { s = f(a) }); + var s string + err := try(func(a aborter) { s = f(a) }) if err != nil { return fmt.Sprintf("<error: %v>", err) } - return s; + return s } /* @@ -90,7 +90,7 @@ func tryRVString(f func(a aborter) string) string { */ type remoteBool struct { - r remote; + r remote } func (v remoteBool) String() string { @@ -101,9 +101,9 @@ func (v remoteBool) Assign(t *eval.Thread, o eval.Value) { v.Set(t, o.(eval.BoolValue).Get(t)) } -func (v remoteBool) Get(t *eval.Thread) bool { return v.aGet(t) } +func (v remoteBool) Get(t *eval.Thread) bool { return v.aGet(t) } -func (v remoteBool) aGet(a aborter) bool { return v.r.Get(a, 1) != 0 } +func (v remoteBool) aGet(a aborter) bool { return v.r.Get(a, 1) != 0 } func (v remoteBool) Set(t *eval.Thread, x bool) { v.aSet(t, x) @@ -117,17 +117,17 @@ func (v remoteBool) aSet(a aborter, x bool) { } } -func (v remoteBool) addr() remote { return v.r } +func (v remoteBool) addr() remote { return v.r } -func mkBool(r remote) eval.Value { return remoteBool{r} } +func mkBool(r remote) eval.Value { return remoteBool{r} } /* * Uint */ type remoteUint struct { - r remote; - size int; + r remote + size int } func (v remoteUint) String() string { @@ -142,35 +142,35 @@ func (v remoteUint) Get(t *eval.Thread) uint64 { return v.aGet(t) } -func (v remoteUint) aGet(a aborter) uint64 { return v.r.Get(a, v.size) } +func (v remoteUint) aGet(a aborter) uint64 { return v.r.Get(a, v.size) } func (v remoteUint) Set(t *eval.Thread, x uint64) { v.aSet(t, x) } -func (v remoteUint) aSet(a aborter, x uint64) { v.r.Set(a, v.size, x) } +func (v remoteUint) aSet(a aborter, x uint64) { v.r.Set(a, v.size, x) } -func (v remoteUint) addr() remote { return v.r } +func (v remoteUint) addr() remote { return v.r } -func mkUint8(r remote) eval.Value { return remoteUint{r, 1} } +func mkUint8(r remote) eval.Value { return remoteUint{r, 1} } -func mkUint16(r remote) eval.Value { return remoteUint{r, 2} } +func mkUint16(r remote) eval.Value { return remoteUint{r, 2} } -func mkUint32(r remote) eval.Value { return remoteUint{r, 4} } +func mkUint32(r remote) eval.Value { return remoteUint{r, 4} } -func mkUint64(r remote) eval.Value { return remoteUint{r, 8} } +func mkUint64(r remote) eval.Value { return remoteUint{r, 8} } -func mkUint(r remote) eval.Value { return remoteUint{r, r.p.IntSize()} } +func mkUint(r remote) eval.Value { return remoteUint{r, r.p.IntSize()} } -func mkUintptr(r remote) eval.Value { return remoteUint{r, r.p.PtrSize()} } +func mkUintptr(r remote) eval.Value { return remoteUint{r, r.p.PtrSize()} } /* * Int */ type remoteInt struct { - r remote; - size int; + r remote + size int } func (v remoteInt) String() string { @@ -181,35 +181,35 @@ func (v remoteInt) Assign(t *eval.Thread, o eval.Value) { v.Set(t, o.(eval.IntValue).Get(t)) } -func (v remoteInt) Get(t *eval.Thread) int64 { return v.aGet(t) } +func (v remoteInt) Get(t *eval.Thread) int64 { return v.aGet(t) } -func (v remoteInt) aGet(a aborter) int64 { return int64(v.r.Get(a, v.size)) } +func (v remoteInt) aGet(a aborter) int64 { return int64(v.r.Get(a, v.size)) } func (v remoteInt) Set(t *eval.Thread, x int64) { v.aSet(t, x) } -func (v remoteInt) aSet(a aborter, x int64) { v.r.Set(a, v.size, uint64(x)) } +func (v remoteInt) aSet(a aborter, x int64) { v.r.Set(a, v.size, uint64(x)) } -func (v remoteInt) addr() remote { return v.r } +func (v remoteInt) addr() remote { return v.r } -func mkInt8(r remote) eval.Value { return remoteInt{r, 1} } +func mkInt8(r remote) eval.Value { return remoteInt{r, 1} } -func mkInt16(r remote) eval.Value { return remoteInt{r, 2} } +func mkInt16(r remote) eval.Value { return remoteInt{r, 2} } -func mkInt32(r remote) eval.Value { return remoteInt{r, 4} } +func mkInt32(r remote) eval.Value { return remoteInt{r, 4} } -func mkInt64(r remote) eval.Value { return remoteInt{r, 8} } +func mkInt64(r remote) eval.Value { return remoteInt{r, 8} } -func mkInt(r remote) eval.Value { return remoteInt{r, r.p.IntSize()} } +func mkInt(r remote) eval.Value { return remoteInt{r, r.p.IntSize()} } /* * Float */ type remoteFloat struct { - r remote; - size int; + r remote + size int } func (v remoteFloat) String() string { @@ -225,14 +225,14 @@ func (v remoteFloat) Get(t *eval.Thread) float64 { } func (v remoteFloat) aGet(a aborter) float64 { - bits := v.r.Get(a, v.size); + bits := v.r.Get(a, v.size) switch v.size { case 4: return float64(v.r.p.ToFloat32(uint32(bits))) case 8: return v.r.p.ToFloat64(bits) } - panic("Unexpected float size ", v.size); + panic("Unexpected float size ", v.size) } func (v remoteFloat) Set(t *eval.Thread, x float64) { @@ -240,7 +240,7 @@ func (v remoteFloat) Set(t *eval.Thread, x float64) { } func (v remoteFloat) aSet(a aborter, x float64) { - var bits uint64; + var bits uint64 switch v.size { case 4: bits = uint64(v.r.p.FromFloat32(float32(x))) @@ -249,23 +249,23 @@ func (v remoteFloat) aSet(a aborter, x float64) { default: panic("Unexpected float size ", v.size) } - v.r.Set(a, v.size, bits); + v.r.Set(a, v.size, bits) } -func (v remoteFloat) addr() remote { return v.r } +func (v remoteFloat) addr() remote { return v.r } -func mkFloat32(r remote) eval.Value { return remoteFloat{r, 4} } +func mkFloat32(r remote) eval.Value { return remoteFloat{r, 4} } -func mkFloat64(r remote) eval.Value { return remoteFloat{r, 8} } +func mkFloat64(r remote) eval.Value { return remoteFloat{r, 8} } -func mkFloat(r remote) eval.Value { return remoteFloat{r, r.p.FloatSize()} } +func mkFloat(r remote) eval.Value { return remoteFloat{r, r.p.FloatSize()} } /* * String */ type remoteString struct { - r remote; + r remote } func (v remoteString) String() string { @@ -281,16 +281,16 @@ func (v remoteString) Get(t *eval.Thread) string { } func (v remoteString) aGet(a aborter) string { - rs := v.r.p.runtime.String.mk(v.r).(remoteStruct); - str := proc.Word(rs.field(v.r.p.f.String.Str).(remoteUint).aGet(a)); - len := rs.field(v.r.p.f.String.Len).(remoteInt).aGet(a); + rs := v.r.p.runtime.String.mk(v.r).(remoteStruct) + str := proc.Word(rs.field(v.r.p.f.String.Str).(remoteUint).aGet(a)) + len := rs.field(v.r.p.f.String.Len).(remoteInt).aGet(a) - bytes := make([]uint8, len); - _, err := v.r.p.Peek(str, bytes); + bytes := make([]uint8, len) + _, err := v.r.p.Peek(str, bytes) if err != nil { a.Abort(err) } - return string(bytes); + return string(bytes) } func (v remoteString) Set(t *eval.Thread, x string) { @@ -303,33 +303,33 @@ func (v remoteString) aSet(a aborter, x string) { a.Abort(ReadOnlyError("remote strings cannot be assigned to")) } -func mkString(r remote) eval.Value { return remoteString{r} } +func mkString(r remote) eval.Value { return remoteString{r} } /* * Array */ type remoteArray struct { - r remote; - len int64; - elemType *remoteType; + r remote + len int64 + elemType *remoteType } func (v remoteArray) String() string { - res := "{"; + res := "{" for i := int64(0); i < v.len; i++ { if i > 0 { res += ", " } - res += v.elem(i).String(); + res += v.elem(i).String() } - return res + "}"; + return res + "}" } func (v remoteArray) Assign(t *eval.Thread, o eval.Value) { // TODO(austin) Could do a bigger memcpy if o is a // remoteArray in the same Process. - oa := o.(eval.ArrayValue); + oa := o.(eval.ArrayValue) for i := int64(0); i < v.len; i++ { v.Elem(t, i).Assign(t, oa.Elem(t, i)) } @@ -356,30 +356,30 @@ func (v remoteArray) Sub(i int64, len int64) eval.ArrayValue { */ type remoteStruct struct { - r remote; - layout []remoteStructField; + r remote + layout []remoteStructField } type remoteStructField struct { - offset int; - fieldType *remoteType; + offset int + fieldType *remoteType } func (v remoteStruct) String() string { - res := "{"; + res := "{" for i := range v.layout { if i > 0 { res += ", " } - res += v.field(i).String(); + res += v.field(i).String() } - return res + "}"; + return res + "}" } func (v remoteStruct) Assign(t *eval.Thread, o eval.Value) { // TODO(austin) Could do a bigger memcpy. - oa := o.(eval.StructValue); - l := len(v.layout); + oa := o.(eval.StructValue) + l := len(v.layout) for i := 0; i < l; i++ { v.Field(t, i).Assign(t, oa.Field(t, i)) } @@ -394,11 +394,11 @@ func (v remoteStruct) Field(t *eval.Thread, i int) eval.Value { } func (v remoteStruct) field(i int) eval.Value { - f := &v.layout[i]; - return f.fieldType.mk(v.r.plus(proc.Word(f.offset))); + f := &v.layout[i] + return f.fieldType.mk(v.r.plus(proc.Word(f.offset))) } -func (v remoteStruct) addr() remote { return v.r } +func (v remoteStruct) addr() remote { return v.r } /* * Pointer @@ -409,17 +409,17 @@ func (v remoteStruct) addr() remote { return v.r } // remotePtr.Get() will be structs. type remotePtr struct { - r remote; - elemType *remoteType; + r remote + elemType *remoteType } func (v remotePtr) String() string { return tryRVString(func(a aborter) string { - e := v.aGet(a); + e := v.aGet(a) if e == nil { return "<nil>" } - return "&" + e.String(); + return "&" + e.String() }) } @@ -432,11 +432,11 @@ func (v remotePtr) Get(t *eval.Thread) eval.Value { } func (v remotePtr) aGet(a aborter) eval.Value { - addr := proc.Word(v.r.Get(a, v.r.p.PtrSize())); + addr := proc.Word(v.r.Get(a, v.r.p.PtrSize())) if addr == 0 { return nil } - return v.elemType.mk(remote{addr, v.r.p}); + return v.elemType.mk(remote{addr, v.r.p}) } func (v remotePtr) Set(t *eval.Thread, x eval.Value) { @@ -445,34 +445,34 @@ func (v remotePtr) Set(t *eval.Thread, x eval.Value) { func (v remotePtr) aSet(a aborter, x eval.Value) { if x == nil { - v.r.Set(a, v.r.p.PtrSize(), 0); - return; + v.r.Set(a, v.r.p.PtrSize(), 0) + return } - xr, ok := x.(remoteValue); + xr, ok := x.(remoteValue) if !ok || v.r.p != xr.addr().p { a.Abort(RemoteMismatchError("remote pointer must point within the same process")) } - v.r.Set(a, v.r.p.PtrSize(), uint64(xr.addr().base)); + v.r.Set(a, v.r.p.PtrSize(), uint64(xr.addr().base)) } -func (v remotePtr) addr() remote { return v.r } +func (v remotePtr) addr() remote { return v.r } /* * Slice */ type remoteSlice struct { - r remote; - elemType *remoteType; + r remote + elemType *remoteType } func (v remoteSlice) String() string { return tryRVString(func(a aborter) string { - b := v.aGet(a).Base; + b := v.aGet(a).Base if b == nil { return "<nil>" } - return b.String(); + return b.String() }) } @@ -485,14 +485,14 @@ func (v remoteSlice) Get(t *eval.Thread) eval.Slice { } func (v remoteSlice) aGet(a aborter) eval.Slice { - rs := v.r.p.runtime.Slice.mk(v.r).(remoteStruct); - base := proc.Word(rs.field(v.r.p.f.Slice.Array).(remoteUint).aGet(a)); - nel := rs.field(v.r.p.f.Slice.Len).(remoteInt).aGet(a); - cap := rs.field(v.r.p.f.Slice.Cap).(remoteInt).aGet(a); + rs := v.r.p.runtime.Slice.mk(v.r).(remoteStruct) + base := proc.Word(rs.field(v.r.p.f.Slice.Array).(remoteUint).aGet(a)) + nel := rs.field(v.r.p.f.Slice.Len).(remoteInt).aGet(a) + cap := rs.field(v.r.p.f.Slice.Cap).(remoteInt).aGet(a) if base == 0 { return eval.Slice{nil, nel, cap} } - return eval.Slice{remoteArray{remote{base, v.r.p}, nel, v.elemType}, nel, cap}; + return eval.Slice{remoteArray{remote{base, v.r.p}, nel, v.elemType}, nel, cap} } func (v remoteSlice) Set(t *eval.Thread, x eval.Slice) { @@ -500,16 +500,16 @@ func (v remoteSlice) Set(t *eval.Thread, x eval.Slice) { } func (v remoteSlice) aSet(a aborter, x eval.Slice) { - rs := v.r.p.runtime.Slice.mk(v.r).(remoteStruct); + rs := v.r.p.runtime.Slice.mk(v.r).(remoteStruct) if x.Base == nil { rs.field(v.r.p.f.Slice.Array).(remoteUint).aSet(a, 0) } else { - ar, ok := x.Base.(remoteArray); + ar, ok := x.Base.(remoteArray) if !ok || v.r.p != ar.r.p { a.Abort(RemoteMismatchError("remote slice must point within the same process")) } - rs.field(v.r.p.f.Slice.Array).(remoteUint).aSet(a, uint64(ar.r.base)); + rs.field(v.r.p.f.Slice.Array).(remoteUint).aSet(a, uint64(ar.r.base)) } - rs.field(v.r.p.f.Slice.Len).(remoteInt).aSet(a, x.Len); - rs.field(v.r.p.f.Slice.Cap).(remoteInt).aSet(a, x.Cap); + rs.field(v.r.p.f.Slice.Len).(remoteInt).aSet(a, x.Len) + rs.field(v.r.p.f.Slice.Cap).(remoteInt).aSet(a, x.Cap) } diff --git a/src/pkg/exp/ogle/vars.go b/src/pkg/exp/ogle/vars.go index 7ceeb5101..e6298bc48 100644 --- a/src/pkg/exp/ogle/vars.go +++ b/src/pkg/exp/ogle/vars.go @@ -5,11 +5,11 @@ package ogle import ( - "debug/gosym"; - "debug/proc"; - "exp/eval"; - "log"; - "os"; + "debug/gosym" + "debug/proc" + "exp/eval" + "log" + "os" ) /* @@ -19,8 +19,8 @@ import ( // A NotOnStack error occurs when attempting to access a variable in a // remote frame where that remote frame is not on the current stack. type NotOnStack struct { - Fn *gosym.Func; - Goroutine *Goroutine; + Fn *gosym.Func + Goroutine *Goroutine } func (e NotOnStack) String() string { @@ -33,9 +33,9 @@ func (e NotOnStack) String() string { // stack and returns a structure containing the local variables of // that function. type remoteFramePtr struct { - p *Process; - fn *gosym.Func; - rt *remoteType; + p *Process + fn *gosym.Func + rt *remoteType } func (v remoteFramePtr) String() string { @@ -48,7 +48,7 @@ func (v remoteFramePtr) Assign(t *eval.Thread, o eval.Value) { } func (v remoteFramePtr) Get(t *eval.Thread) eval.Value { - g := v.p.curGoroutine; + g := v.p.curGoroutine if g == nil || g.frame == nil { t.Abort(NoCurrentGoroutine{}) } @@ -59,11 +59,11 @@ func (v remoteFramePtr) Get(t *eval.Thread) eval.Value { } // TODO(austin): Register for shootdown with f - return v.rt.mk(remote{f.fp, v.p}); + return v.rt.mk(remote{f.fp, v.p}) } - t.Abort(NotOnStack{v.fn, g}); - panic(); + t.Abort(NotOnStack{v.fn, g}) + panic() } func (v remoteFramePtr) Set(t *eval.Thread, x eval.Value) { @@ -87,10 +87,10 @@ func (v remoteFramePtr) Set(t *eval.Thread, x eval.Value) { // represents a package in a remote process. It's essentially a // regular struct, except it cannot be assigned to. type remotePackage struct { - defs []eval.Value; + defs []eval.Value } -func (v remotePackage) String() string { return "<remote package>" } +func (v remotePackage) String() string { return "<remote package>" } func (v remotePackage) Assign(t *eval.Thread, o eval.Value) { t.Abort(ReadOnlyError("remote packages cannot be assigned to")) @@ -113,10 +113,10 @@ func (v remotePackage) Field(t *eval.Thread, i int) eval.Value { // fields for each global and function in that package. func (p *Process) populateWorld(w *eval.World) os.Error { type def struct { - t eval.Type; - v eval.Value; + t eval.Type + v eval.Value } - packages := make(map[string]map[string]def); + packages := make(map[string]map[string]def) for _, s := range p.syms.Syms { if s.ReceiverName() != "" { @@ -125,27 +125,27 @@ func (p *Process) populateWorld(w *eval.World) os.Error { } // Package - pkgName := s.PackageName(); + pkgName := s.PackageName() switch pkgName { case "", "type", "extratype", "string", "go": // "go" is really "go.string" continue } - pkg, ok := packages[pkgName]; + pkg, ok := packages[pkgName] if !ok { - pkg = make(map[string]def); - packages[pkgName] = pkg; + pkg = make(map[string]def) + packages[pkgName] = pkg } // Symbol name - name := s.BaseName(); + name := s.BaseName() if _, ok := pkg[name]; ok { - log.Stderrf("Multiple definitions of symbol %s", s.Name); - continue; + log.Stderrf("Multiple definitions of symbol %s", s.Name) + continue } // Symbol type - rt, err := p.typeOfSym(&s); + rt, err := p.typeOfSym(&s) if err != nil { return err } @@ -157,19 +157,19 @@ func (p *Process) populateWorld(w *eval.World) os.Error { if rt == nil { continue } - pkg[name] = def{rt.Type, rt.mk(remote{proc.Word(s.Value), p})}; + pkg[name] = def{rt.Type, rt.mk(remote{proc.Word(s.Value), p})} case 'T', 't', 'L', 'l': // Function - s := s.Func; + s := s.Func // TODO(austin): Ideally, this would *also* be // callable. How does that interact with type // conversion syntax? - rt, err := p.makeFrameType(s); + rt, err := p.makeFrameType(s) if err != nil { return err } - pkg[name] = def{eval.NewPtrType(rt.Type), remoteFramePtr{p, s, rt}}; + pkg[name] = def{eval.NewPtrType(rt.Type), remoteFramePtr{p, s, rt}} } } @@ -177,25 +177,25 @@ func (p *Process) populateWorld(w *eval.World) os.Error { // Define packages for pkgName, defs := range packages { - fields := make([]eval.StructField, len(defs)); - vals := make([]eval.Value, len(defs)); - i := 0; + fields := make([]eval.StructField, len(defs)) + vals := make([]eval.Value, len(defs)) + i := 0 for name, def := range defs { - fields[i].Name = name; - fields[i].Type = def.t; - vals[i] = def.v; - i++; + fields[i].Name = name + fields[i].Type = def.t + vals[i] = def.v + i++ } - pkgType := eval.NewStructType(fields); - pkgVal := remotePackage{vals}; + pkgType := eval.NewStructType(fields) + pkgVal := remotePackage{vals} - err := w.DefineConst(pkgName, pkgType, pkgVal); + err := w.DefineConst(pkgName, pkgType, pkgVal) if err != nil { log.Stderrf("while defining package %s: %v", pkgName, err) } } - return nil; + return nil } // typeOfSym returns the type associated with a symbol. If the symbol @@ -204,23 +204,23 @@ func (p *Process) typeOfSym(s *gosym.Sym) (*remoteType, os.Error) { if s.GoType == 0 { return nil, nil } - addr := proc.Word(s.GoType); - var rt *remoteType; - err := try(func(a aborter) { rt = parseRemoteType(a, p.runtime.Type.mk(remote{addr, p}).(remoteStruct)) }); + addr := proc.Word(s.GoType) + var rt *remoteType + err := try(func(a aborter) { rt = parseRemoteType(a, p.runtime.Type.mk(remote{addr, p}).(remoteStruct)) }) if err != nil { return nil, err } - return rt, nil; + return rt, nil } // makeFrameType constructs a struct type for the frame of a function. // The offsets in this struct type are such that the struct can be // instantiated at this function's frame pointer. func (p *Process) makeFrameType(s *gosym.Func) (*remoteType, os.Error) { - n := len(s.Params) + len(s.Locals); - fields := make([]eval.StructField, n); - layout := make([]remoteStructField, n); - i := 0; + n := len(s.Params) + len(s.Locals) + fields := make([]eval.StructField, n) + layout := make([]remoteStructField, n) + i := 0 // TODO(austin): There can be multiple locals/parameters with // the same name. We probably need liveness information to do @@ -230,7 +230,7 @@ func (p *Process) makeFrameType(s *gosym.Func) (*remoteType, os.Error) { // things like "i", where there's an obvious right answer. for _, param := range s.Params { - rt, err := p.typeOfSym(param); + rt, err := p.typeOfSym(param) if err != nil { return nil, err } @@ -240,33 +240,33 @@ func (p *Process) makeFrameType(s *gosym.Func) (*remoteType, os.Error) { } // TODO(austin): Why do local variables carry their // package name? - fields[i].Name = param.BaseName(); - fields[i].Type = rt.Type; + fields[i].Name = param.BaseName() + fields[i].Type = rt.Type // Parameters have positive offsets from FP - layout[i].offset = int(param.Value); - layout[i].fieldType = rt; - i++; + layout[i].offset = int(param.Value) + layout[i].fieldType = rt + i++ } for _, local := range s.Locals { - rt, err := p.typeOfSym(local); + rt, err := p.typeOfSym(local) if err != nil { return nil, err } if rt == nil { continue } - fields[i].Name = local.BaseName(); - fields[i].Type = rt.Type; + fields[i].Name = local.BaseName() + fields[i].Type = rt.Type // Locals have negative offsets from FP - PtrSize - layout[i].offset = -int(local.Value) - p.PtrSize(); - layout[i].fieldType = rt; - i++; + layout[i].offset = -int(local.Value) - p.PtrSize() + layout[i].fieldType = rt + i++ } - fields = fields[0:i]; - layout = layout[0:i]; - t := eval.NewStructType(fields); - mk := func(r remote) eval.Value { return remoteStruct{r, layout} }; - return &remoteType{t, 0, 0, mk}, nil; + fields = fields[0:i] + layout = layout[0:i] + t := eval.NewStructType(fields) + mk := func(r remote) eval.Value { return remoteStruct{r, layout} } + return &remoteType{t, 0, 0, mk}, nil } diff --git a/src/pkg/exp/parser/interface.go b/src/pkg/exp/parser/interface.go index ca01de200..495c0c29e 100644 --- a/src/pkg/exp/parser/interface.go +++ b/src/pkg/exp/parser/interface.go @@ -7,15 +7,15 @@ package oldParser import ( - "bytes"; - "fmt"; - "go/ast"; - "go/scanner"; - "io"; - "io/ioutil"; - "os"; - pathutil "path"; - "strings"; + "bytes" + "fmt" + "go/ast" + "go/scanner" + "io" + "io/ioutil" + "os" + pathutil "path" + "strings" ) @@ -36,18 +36,18 @@ func readSource(filename string, src interface{}) ([]byte, os.Error) { return s.Bytes(), nil } case io.Reader: - var buf bytes.Buffer; - _, err := io.Copy(&buf, s); + var buf bytes.Buffer + _, err := io.Copy(&buf, s) if err != nil { return nil, err } - return buf.Bytes(), nil; + return buf.Bytes(), nil default: return nil, os.ErrorString("invalid source") } } - return ioutil.ReadFile(filename); + return ioutil.ReadFile(filename) } @@ -57,14 +57,14 @@ func readSource(filename string, src interface{}) ([]byte, os.Error) { // may be nil or contain a partial AST. // func ParseExpr(filename string, src interface{}) (ast.Expr, os.Error) { - data, err := readSource(filename, src); + data, err := readSource(filename, src) if err != nil { return nil, err } - var p parser; - p.init(filename, data, 0); - return p.parseExpr(), p.GetError(scanner.Sorted); + var p parser + p.init(filename, data, 0) + return p.parseExpr(), p.GetError(scanner.Sorted) } @@ -74,14 +74,14 @@ func ParseExpr(filename string, src interface{}) (ast.Expr, os.Error) { // list may be nil or contain partial ASTs. // func ParseStmtList(filename string, src interface{}) ([]ast.Stmt, os.Error) { - data, err := readSource(filename, src); + data, err := readSource(filename, src) if err != nil { return nil, err } - var p parser; - p.init(filename, data, 0); - return p.parseStmtList(), p.GetError(scanner.Sorted); + var p parser + p.init(filename, data, 0) + return p.parseStmtList(), p.GetError(scanner.Sorted) } @@ -91,14 +91,14 @@ func ParseStmtList(filename string, src interface{}) ([]ast.Stmt, os.Error) { // list may be nil or contain partial ASTs. // func ParseDeclList(filename string, src interface{}) ([]ast.Decl, os.Error) { - data, err := readSource(filename, src); + data, err := readSource(filename, src) if err != nil { return nil, err } - var p parser; - p.init(filename, data, 0); - return p.parseDeclList(), p.GetError(scanner.Sorted); + var p parser + p.init(filename, data, 0) + return p.parseDeclList(), p.GetError(scanner.Sorted) } @@ -121,14 +121,14 @@ func ParseDeclList(filename string, src interface{}) ([]ast.Decl, os.Error) { // are returned via a scanner.ErrorList which is sorted by file position. // func ParseFile(filename string, src interface{}, mode uint) (*ast.File, os.Error) { - data, err := readSource(filename, src); + data, err := readSource(filename, src) if err != nil { return nil, err } - var p parser; - p.init(filename, data, mode); - return p.parseFile(), p.GetError(scanner.NoMultiples); + var p parser + p.init(filename, data, mode) + return p.parseFile(), p.GetError(scanner.NoMultiples) } @@ -139,13 +139,13 @@ func ParseFile(filename string, src interface{}, mode uint) (*ast.File, os.Error // flags that control the amount of source text parsed are ignored. // func ParsePkgFile(pkgname, filename string, mode uint) (*ast.File, os.Error) { - src, err := ioutil.ReadFile(filename); + src, err := ioutil.ReadFile(filename) if err != nil { return nil, err } if pkgname != "" { - prog, err := ParseFile(filename, src, PackageClauseOnly); + prog, err := ParseFile(filename, src, PackageClauseOnly) if err != nil { return nil, err } @@ -155,7 +155,7 @@ func ParsePkgFile(pkgname, filename string, mode uint) (*ast.File, os.Error) { } // ignore flags that control partial parsing - return ParseFile(filename, src, mode&^(PackageClauseOnly|ImportsOnly)); + return ParseFile(filename, src, mode&^(PackageClauseOnly|ImportsOnly)) } @@ -167,27 +167,27 @@ func ParsePkgFile(pkgname, filename string, mode uint) (*ast.File, os.Error) { // Mode flags that control the amount of source text parsed are ignored. // func ParsePackage(path string, filter func(*os.Dir) bool, mode uint) (*ast.Package, os.Error) { - fd, err := os.Open(path, os.O_RDONLY, 0); + fd, err := os.Open(path, os.O_RDONLY, 0) if err != nil { return nil, err } - defer fd.Close(); + defer fd.Close() - list, err := fd.Readdir(-1); + list, err := fd.Readdir(-1) if err != nil { return nil, err } - name := ""; - files := make(map[string]*ast.File); + name := "" + files := make(map[string]*ast.File) for i := 0; i < len(list); i++ { - entry := &list[i]; + entry := &list[i] if filter == nil || filter(entry) { - src, err := ParsePkgFile(name, pathutil.Join(path, entry.Name), mode); + src, err := ParsePkgFile(name, pathutil.Join(path, entry.Name), mode) if err != nil { return nil, err } - files[entry.Name] = src; + files[entry.Name] = src if name == "" { name = src.Name.Value } @@ -198,5 +198,5 @@ func ParsePackage(path string, filter func(*os.Dir) bool, mode uint) (*ast.Packa return nil, os.NewError(path + ": no package found") } - return &ast.Package{name, path, files}, nil; + return &ast.Package{name, path, files}, nil } diff --git a/src/pkg/exp/parser/parser.go b/src/pkg/exp/parser/parser.go index 32360b5d6..199334b1b 100644 --- a/src/pkg/exp/parser/parser.go +++ b/src/pkg/exp/parser/parser.go @@ -15,11 +15,11 @@ package oldParser import ( - "container/vector"; - "fmt"; - "go/ast"; - "go/scanner"; - "go/token"; + "container/vector" + "fmt" + "go/ast" + "go/scanner" + "go/token" ) @@ -32,42 +32,42 @@ var noPos token.Position // parser functionality. // const ( - PackageClauseOnly uint = 1 << iota; // parsing stops after package clause - ImportsOnly; // parsing stops after import declarations - ParseComments; // parse comments and add them to AST - Trace; // print a trace of parsed productions + PackageClauseOnly uint = 1 << iota // parsing stops after package clause + ImportsOnly // parsing stops after import declarations + ParseComments // parse comments and add them to AST + Trace // print a trace of parsed productions ) // The parser structure holds the parser's internal state. type parser struct { - scanner.ErrorVector; - scanner scanner.Scanner; + scanner.ErrorVector + scanner scanner.Scanner // Tracing/debugging - mode uint; // parsing mode - trace bool; // == (mode & Trace != 0) - indent uint; // indentation used for tracing output + mode uint // parsing mode + trace bool // == (mode & Trace != 0) + indent uint // indentation used for tracing output // Comments - comments *ast.CommentGroup; // list of collected comments - lastComment *ast.CommentGroup; // last comment in the comments list - leadComment *ast.CommentGroup; // the last lead comment - lineComment *ast.CommentGroup; // the last line comment + comments *ast.CommentGroup // list of collected comments + lastComment *ast.CommentGroup // last comment in the comments list + leadComment *ast.CommentGroup // the last lead comment + lineComment *ast.CommentGroup // the last line comment // Next token - pos token.Position; // token position - tok token.Token; // one token look-ahead - lit []byte; // token literal + pos token.Position // token position + tok token.Token // one token look-ahead + lit []byte // token literal // Non-syntactic parser control - optSemi bool; // true if semicolon separator is optional in statement list - exprLev int; // < 0: in control clause, >= 0: in expression + optSemi bool // true if semicolon separator is optional in statement list + exprLev int // < 0: in control clause, >= 0: in expression // Scopes - pkgScope *ast.Scope; - fileScope *ast.Scope; - topScope *ast.Scope; + pkgScope *ast.Scope + fileScope *ast.Scope + topScope *ast.Scope } @@ -76,15 +76,15 @@ func scannerMode(mode uint) uint { if mode&ParseComments != 0 { return scanner.ScanComments } - return 0; + return 0 } func (p *parser) init(filename string, src []byte, mode uint) { - p.scanner.Init(filename, src, p, scannerMode(mode)); - p.mode = mode; - p.trace = mode&Trace != 0; // for convenience (p.trace is used frequently) - p.next(); + p.scanner.Init(filename, src, p, scannerMode(mode)) + p.mode = mode + p.trace = mode&Trace != 0 // for convenience (p.trace is used frequently) + p.next() } @@ -93,29 +93,29 @@ func (p *parser) init(filename string, src []byte, mode uint) { func (p *parser) printTrace(a ...) { const dots = ". . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . " + - ". . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . "; - const n = uint(len(dots)); - fmt.Printf("%5d:%3d: ", p.pos.Line, p.pos.Column); - i := 2 * p.indent; + ". . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . " + const n = uint(len(dots)) + fmt.Printf("%5d:%3d: ", p.pos.Line, p.pos.Column) + i := 2 * p.indent for ; i > n; i -= n { fmt.Print(dots) } - fmt.Print(dots[0:i]); - fmt.Println(a); + fmt.Print(dots[0:i]) + fmt.Println(a) } func trace(p *parser, msg string) *parser { - p.printTrace(msg, "("); - p.indent++; - return p; + p.printTrace(msg, "(") + p.indent++ + return p } // Usage pattern: defer un(trace(p, "...")); func un(p *parser) { - p.indent--; - p.printTrace(")"); + p.indent-- + p.printTrace(")") } @@ -126,7 +126,7 @@ func (p *parser) next0() { // very first token (p.pos.Line == 0) is not initialized (it // is token.ILLEGAL), so don't print it . if p.trace && p.pos.Line > 0 { - s := p.tok.String(); + s := p.tok.String() switch { case p.tok.IsLiteral(): p.printTrace(s, string(p.lit)) @@ -137,8 +137,8 @@ func (p *parser) next0() { } } - p.pos, p.tok, p.lit = p.scanner.Scan(); - p.optSemi = false; + p.pos, p.tok, p.lit = p.scanner.Scan() + p.optSemi = false } @@ -146,7 +146,7 @@ func (p *parser) next0() { func (p *parser) consumeComment() (comment *ast.Comment, endline int) { // /*-style comments may end on a different line than where they start. // Scan the comment for '\n' chars and adjust endline accordingly. - endline = p.pos.Line; + endline = p.pos.Line if p.lit[1] == '*' { for _, b := range p.lit { if b == '\n' { @@ -155,10 +155,10 @@ func (p *parser) consumeComment() (comment *ast.Comment, endline int) { } } - comment = &ast.Comment{p.pos, p.lit}; - p.next0(); + comment = &ast.Comment{p.pos, p.lit} + p.next0() - return; + return } @@ -168,30 +168,30 @@ func (p *parser) consumeComment() (comment *ast.Comment, endline int) { // a comment group. // func (p *parser) consumeCommentGroup() int { - list := new(vector.Vector); - endline := p.pos.Line; + list := new(vector.Vector) + endline := p.pos.Line for p.tok == token.COMMENT && endline+1 >= p.pos.Line { - var comment *ast.Comment; - comment, endline = p.consumeComment(); - list.Push(comment); + var comment *ast.Comment + comment, endline = p.consumeComment() + list.Push(comment) } // convert list - group := make([]*ast.Comment, list.Len()); + group := make([]*ast.Comment, list.Len()) for i := 0; i < list.Len(); i++ { group[i] = list.At(i).(*ast.Comment) } // add comment group to the comments list - g := &ast.CommentGroup{group, nil}; + g := &ast.CommentGroup{group, nil} if p.lastComment != nil { p.lastComment.Next = g } else { p.comments = g } - p.lastComment = g; + p.lastComment = g - return endline; + return endline } @@ -211,16 +211,16 @@ func (p *parser) consumeCommentGroup() int { // stored in the AST. // func (p *parser) next() { - p.leadComment = nil; - p.lineComment = nil; - line := p.pos.Line; // current line - p.next0(); + p.leadComment = nil + p.lineComment = nil + line := p.pos.Line // current line + p.next0() if p.tok == token.COMMENT { if p.pos.Line == line { // The comment is on same line as previous token; it // cannot be a lead comment but may be a line comment. - endline := p.consumeCommentGroup(); + endline := p.consumeCommentGroup() if p.pos.Line != endline { // The next token is on a different line, thus // the last comment group is a line comment. @@ -229,7 +229,7 @@ func (p *parser) next() { } // consume successor comments, if any - endline := -1; + endline := -1 for p.tok == token.COMMENT { endline = p.consumeCommentGroup() } @@ -244,26 +244,26 @@ func (p *parser) next() { func (p *parser) errorExpected(pos token.Position, msg string) { - msg = "expected " + msg; + msg = "expected " + msg if pos.Offset == p.pos.Offset { // the error happened at the current position; // make the error message more specific - msg += ", found '" + p.tok.String() + "'"; + msg += ", found '" + p.tok.String() + "'" if p.tok.IsLiteral() { msg += " " + string(p.lit) } } - p.Error(pos, msg); + p.Error(pos, msg) } func (p *parser) expect(tok token.Token) token.Position { - pos := p.pos; + pos := p.pos if p.tok != tok { p.errorExpected(pos, "'"+tok.String()+"'") } - p.next(); // make progress in any case - return pos; + p.next() // make progress in any case + return pos } @@ -271,13 +271,13 @@ func (p *parser) expect(tok token.Token) token.Position { // Scope support func openScope(p *parser) *parser { - p.topScope = ast.NewScope(p.topScope); - return p; + p.topScope = ast.NewScope(p.topScope) + return p } // Usage pattern: defer close(openScope(p)); -func close(p *parser) { p.topScope = p.topScope.Outer } +func close(p *parser) { p.topScope = p.topScope.Outer } func (p *parser) declare(ident *ast.Ident) { @@ -299,12 +299,12 @@ func (p *parser) declareList(idents []*ast.Ident) { func (p *parser) parseIdent() *ast.Ident { if p.tok == token.IDENT { - x := &ast.Ident{p.pos, string(p.lit)}; - p.next(); - return x; + x := &ast.Ident{p.pos, string(p.lit)} + p.next() + return x } - p.expect(token.IDENT); // use expect() error handling - return &ast.Ident{p.pos, ""}; + p.expect(token.IDENT) // use expect() error handling + return &ast.Ident{p.pos, ""} } @@ -313,20 +313,20 @@ func (p *parser) parseIdentList() []*ast.Ident { defer un(trace(p, "IdentList")) } - list := new(vector.Vector); - list.Push(p.parseIdent()); + list := new(vector.Vector) + list.Push(p.parseIdent()) for p.tok == token.COMMA { - p.next(); - list.Push(p.parseIdent()); + p.next() + list.Push(p.parseIdent()) } // convert vector - idents := make([]*ast.Ident, list.Len()); + idents := make([]*ast.Ident, list.Len()) for i := 0; i < list.Len(); i++ { idents[i] = list.At(i).(*ast.Ident) } - return idents; + return idents } @@ -335,20 +335,20 @@ func (p *parser) parseExprList() []ast.Expr { defer un(trace(p, "ExpressionList")) } - list := new(vector.Vector); - list.Push(p.parseExpr()); + list := new(vector.Vector) + list.Push(p.parseExpr()) for p.tok == token.COMMA { - p.next(); - list.Push(p.parseExpr()); + p.next() + list.Push(p.parseExpr()) } // convert list - exprs := make([]ast.Expr, list.Len()); + exprs := make([]ast.Expr, list.Len()) for i := 0; i < list.Len(); i++ { exprs[i] = list.At(i).(ast.Expr) } - return exprs; + return exprs } @@ -360,15 +360,15 @@ func (p *parser) parseType() ast.Expr { defer un(trace(p, "Type")) } - typ := p.tryType(); + typ := p.tryType() if typ == nil { - p.errorExpected(p.pos, "type"); - p.next(); // make progress - return &ast.BadExpr{p.pos}; + p.errorExpected(p.pos, "type") + p.next() // make progress + return &ast.BadExpr{p.pos} } - return typ; + return typ } @@ -377,14 +377,14 @@ func (p *parser) parseQualifiedIdent() ast.Expr { defer un(trace(p, "QualifiedIdent")) } - var x ast.Expr = p.parseIdent(); + var x ast.Expr = p.parseIdent() if p.tok == token.PERIOD { // first identifier is a package identifier - p.next(); - sel := p.parseIdent(); - x = &ast.SelectorExpr{x, sel}; + p.next() + sel := p.parseIdent() + x = &ast.SelectorExpr{x, sel} } - return x; + return x } @@ -393,7 +393,7 @@ func (p *parser) parseTypeName() ast.Expr { defer un(trace(p, "TypeName")) } - return p.parseQualifiedIdent(); + return p.parseQualifiedIdent() } @@ -402,33 +402,33 @@ func (p *parser) parseArrayType(ellipsisOk bool) ast.Expr { defer un(trace(p, "ArrayType")) } - lbrack := p.expect(token.LBRACK); - var len ast.Expr; + lbrack := p.expect(token.LBRACK) + var len ast.Expr if ellipsisOk && p.tok == token.ELLIPSIS { - len = &ast.Ellipsis{p.pos}; - p.next(); + len = &ast.Ellipsis{p.pos} + p.next() } else if p.tok != token.RBRACK { len = p.parseExpr() } - p.expect(token.RBRACK); - elt := p.parseType(); + p.expect(token.RBRACK) + elt := p.parseType() - return &ast.ArrayType{lbrack, len, elt}; + return &ast.ArrayType{lbrack, len, elt} } func (p *parser) makeIdentList(list *vector.Vector) []*ast.Ident { - idents := make([]*ast.Ident, list.Len()); + idents := make([]*ast.Ident, list.Len()) for i := 0; i < list.Len(); i++ { - ident, isIdent := list.At(i).(*ast.Ident); + ident, isIdent := list.At(i).(*ast.Ident) if !isIdent { - pos := list.At(i).(ast.Expr).Pos(); - p.errorExpected(pos, "identifier"); - idents[i] = &ast.Ident{pos, ""}; + pos := list.At(i).(ast.Expr).Pos() + p.errorExpected(pos, "identifier") + idents[i] = &ast.Ident{pos, ""} } - idents[i] = ident; + idents[i] = ident } - return idents; + return idents } @@ -437,13 +437,13 @@ func (p *parser) parseFieldDecl() *ast.Field { defer un(trace(p, "FieldDecl")) } - doc := p.leadComment; + doc := p.leadComment // a list of identifiers looks like a list of type names - list := new(vector.Vector); + list := new(vector.Vector) for { // TODO(gri): do not allow ()'s here - list.Push(p.parseType()); + list.Push(p.parseType()) if p.tok == token.COMMA { p.next() } else { @@ -452,16 +452,16 @@ func (p *parser) parseFieldDecl() *ast.Field { } // if we had a list of identifiers, it must be followed by a type - typ := p.tryType(); + typ := p.tryType() // optional tag - var tag []*ast.BasicLit; + var tag []*ast.BasicLit if p.tok == token.STRING { tag = p.parseStringList(nil) } // analyze case - var idents []*ast.Ident; + var idents []*ast.Ident if typ != nil { // IdentifierList Type idents = p.makeIdentList(list) @@ -471,12 +471,12 @@ func (p *parser) parseFieldDecl() *ast.Field { // TODO(gri): check that this looks like a type typ = list.At(0).(ast.Expr) } else { - p.errorExpected(p.pos, "anonymous field"); - typ = &ast.BadExpr{p.pos}; + p.errorExpected(p.pos, "anonymous field") + typ = &ast.BadExpr{p.pos} } } - return &ast.Field{doc, idents, typ, tag, nil}; + return &ast.Field{doc, idents, typ, tag, nil} } @@ -485,27 +485,27 @@ func (p *parser) parseStructType() *ast.StructType { defer un(trace(p, "StructType")) } - pos := p.expect(token.STRUCT); - lbrace := p.expect(token.LBRACE); - list := new(vector.Vector); + pos := p.expect(token.STRUCT) + lbrace := p.expect(token.LBRACE) + list := new(vector.Vector) for p.tok == token.IDENT || p.tok == token.MUL { - f := p.parseFieldDecl(); + f := p.parseFieldDecl() if p.tok != token.RBRACE { p.expect(token.SEMICOLON) } - f.Comment = p.lineComment; - list.Push(f); + f.Comment = p.lineComment + list.Push(f) } - rbrace := p.expect(token.RBRACE); - p.optSemi = true; + rbrace := p.expect(token.RBRACE) + p.optSemi = true // convert vector - fields := make([]*ast.Field, list.Len()); + fields := make([]*ast.Field, list.Len()) for i := list.Len() - 1; i >= 0; i-- { fields[i] = list.At(i).(*ast.Field) } - return &ast.StructType{pos, lbrace, fields, rbrace, false}; + return &ast.StructType{pos, lbrace, fields, rbrace, false} } @@ -514,35 +514,35 @@ func (p *parser) parsePointerType() *ast.StarExpr { defer un(trace(p, "PointerType")) } - star := p.expect(token.MUL); - base := p.parseType(); + star := p.expect(token.MUL) + base := p.parseType() - return &ast.StarExpr{star, base}; + return &ast.StarExpr{star, base} } func (p *parser) tryParameterType(ellipsisOk bool) ast.Expr { if ellipsisOk && p.tok == token.ELLIPSIS { - pos := p.pos; - p.next(); + pos := p.pos + p.next() if p.tok != token.RPAREN { // "..." always must be at the very end of a parameter list p.Error(pos, "expected type, found '...'") } - return &ast.Ellipsis{pos}; + return &ast.Ellipsis{pos} } - return p.tryType(); + return p.tryType() } func (p *parser) parseParameterType(ellipsisOk bool) ast.Expr { - typ := p.tryParameterType(ellipsisOk); + typ := p.tryParameterType(ellipsisOk) if typ == nil { - p.errorExpected(p.pos, "type"); - p.next(); // make progress - typ = &ast.BadExpr{p.pos}; + p.errorExpected(p.pos, "type") + p.next() // make progress + typ = &ast.BadExpr{p.pos} } - return typ; + return typ } @@ -552,10 +552,10 @@ func (p *parser) parseParameterDecl(ellipsisOk bool) (*vector.Vector, ast.Expr) } // a list of identifiers looks like a list of type names - list := new(vector.Vector); + list := new(vector.Vector) for { // TODO(gri): do not allow ()'s here - list.Push(p.parseParameterType(ellipsisOk)); + list.Push(p.parseParameterType(ellipsisOk)) if p.tok == token.COMMA { p.next() } else { @@ -564,9 +564,9 @@ func (p *parser) parseParameterDecl(ellipsisOk bool) (*vector.Vector, ast.Expr) } // if we had a list of identifiers, it must be followed by a type - typ := p.tryParameterType(ellipsisOk); + typ := p.tryParameterType(ellipsisOk) - return list, typ; + return list, typ } @@ -575,18 +575,18 @@ func (p *parser) parseParameterList(ellipsisOk bool) []*ast.Field { defer un(trace(p, "ParameterList")) } - list, typ := p.parseParameterDecl(ellipsisOk); + list, typ := p.parseParameterDecl(ellipsisOk) if typ != nil { // IdentifierList Type - idents := p.makeIdentList(list); - list.Resize(0, 0); - list.Push(&ast.Field{nil, idents, typ, nil, nil}); + idents := p.makeIdentList(list) + list.Resize(0, 0) + list.Push(&ast.Field{nil, idents, typ, nil, nil}) for p.tok == token.COMMA { - p.next(); - idents := p.parseIdentList(); - typ := p.parseParameterType(ellipsisOk); - list.Push(&ast.Field{nil, idents, typ, nil, nil}); + p.next() + idents := p.parseIdentList() + typ := p.parseParameterType(ellipsisOk) + list.Push(&ast.Field{nil, idents, typ, nil, nil}) } } else { @@ -598,12 +598,12 @@ func (p *parser) parseParameterList(ellipsisOk bool) []*ast.Field { } // convert list - params := make([]*ast.Field, list.Len()); + params := make([]*ast.Field, list.Len()) for i := 0; i < list.Len(); i++ { params[i] = list.At(i).(*ast.Field) } - return params; + return params } @@ -612,14 +612,14 @@ func (p *parser) parseParameters(ellipsisOk bool) []*ast.Field { defer un(trace(p, "Parameters")) } - var params []*ast.Field; - p.expect(token.LPAREN); + var params []*ast.Field + p.expect(token.LPAREN) if p.tok != token.RPAREN { params = p.parseParameterList(ellipsisOk) } - p.expect(token.RPAREN); + p.expect(token.RPAREN) - return params; + return params } @@ -628,18 +628,18 @@ func (p *parser) parseResult() []*ast.Field { defer un(trace(p, "Result")) } - var results []*ast.Field; + var results []*ast.Field if p.tok == token.LPAREN { results = p.parseParameters(false) } else if p.tok != token.FUNC { - typ := p.tryType(); + typ := p.tryType() if typ != nil { - results = make([]*ast.Field, 1); - results[0] = &ast.Field{Type: typ}; + results = make([]*ast.Field, 1) + results[0] = &ast.Field{Type: typ} } } - return results; + return results } @@ -648,10 +648,10 @@ func (p *parser) parseSignature() (params []*ast.Field, results []*ast.Field) { defer un(trace(p, "Signature")) } - params = p.parseParameters(true); - results = p.parseResult(); + params = p.parseParameters(true) + results = p.parseResult() - return; + return } @@ -660,10 +660,10 @@ func (p *parser) parseFuncType() *ast.FuncType { defer un(trace(p, "FuncType")) } - pos := p.expect(token.FUNC); - params, results := p.parseSignature(); + pos := p.expect(token.FUNC) + params, results := p.parseSignature() - return &ast.FuncType{pos, params, results}; + return &ast.FuncType{pos, params, results} } @@ -672,21 +672,21 @@ func (p *parser) parseMethodSpec() *ast.Field { defer un(trace(p, "MethodSpec")) } - doc := p.leadComment; - var idents []*ast.Ident; - var typ ast.Expr; - x := p.parseQualifiedIdent(); + doc := p.leadComment + var idents []*ast.Ident + var typ ast.Expr + x := p.parseQualifiedIdent() if ident, isIdent := x.(*ast.Ident); isIdent && p.tok == token.LPAREN { // method - idents = []*ast.Ident{ident}; - params, results := p.parseSignature(); - typ = &ast.FuncType{noPos, params, results}; + idents = []*ast.Ident{ident} + params, results := p.parseSignature() + typ = &ast.FuncType{noPos, params, results} } else { // embedded interface typ = x } - return &ast.Field{doc, idents, typ, nil, nil}; + return &ast.Field{doc, idents, typ, nil, nil} } @@ -695,27 +695,27 @@ func (p *parser) parseInterfaceType() *ast.InterfaceType { defer un(trace(p, "InterfaceType")) } - pos := p.expect(token.INTERFACE); - lbrace := p.expect(token.LBRACE); - list := new(vector.Vector); + pos := p.expect(token.INTERFACE) + lbrace := p.expect(token.LBRACE) + list := new(vector.Vector) for p.tok == token.IDENT { - m := p.parseMethodSpec(); + m := p.parseMethodSpec() if p.tok != token.RBRACE { p.expect(token.SEMICOLON) } - m.Comment = p.lineComment; - list.Push(m); + m.Comment = p.lineComment + list.Push(m) } - rbrace := p.expect(token.RBRACE); - p.optSemi = true; + rbrace := p.expect(token.RBRACE) + p.optSemi = true // convert vector - methods := make([]*ast.Field, list.Len()); + methods := make([]*ast.Field, list.Len()) for i := list.Len() - 1; i >= 0; i-- { methods[i] = list.At(i).(*ast.Field) } - return &ast.InterfaceType{pos, lbrace, methods, rbrace, false}; + return &ast.InterfaceType{pos, lbrace, methods, rbrace, false} } @@ -724,13 +724,13 @@ func (p *parser) parseMapType() *ast.MapType { defer un(trace(p, "MapType")) } - pos := p.expect(token.MAP); - p.expect(token.LBRACK); - key := p.parseType(); - p.expect(token.RBRACK); - value := p.parseType(); + pos := p.expect(token.MAP) + p.expect(token.LBRACK) + key := p.parseType() + p.expect(token.RBRACK) + value := p.parseType() - return &ast.MapType{pos, key, value}; + return &ast.MapType{pos, key, value} } @@ -739,22 +739,22 @@ func (p *parser) parseChanType() *ast.ChanType { defer un(trace(p, "ChanType")) } - pos := p.pos; - dir := ast.SEND | ast.RECV; + pos := p.pos + dir := ast.SEND | ast.RECV if p.tok == token.CHAN { - p.next(); + p.next() if p.tok == token.ARROW { - p.next(); - dir = ast.SEND; + p.next() + dir = ast.SEND } } else { - p.expect(token.ARROW); - p.expect(token.CHAN); - dir = ast.RECV; + p.expect(token.ARROW) + p.expect(token.CHAN) + dir = ast.RECV } - value := p.parseType(); + value := p.parseType() - return &ast.ChanType{pos, dir, value}; + return &ast.ChanType{pos, dir, value} } @@ -777,30 +777,30 @@ func (p *parser) tryRawType(ellipsisOk bool) ast.Expr { case token.CHAN, token.ARROW: return p.parseChanType() case token.LPAREN: - lparen := p.pos; - p.next(); - typ := p.parseType(); - rparen := p.expect(token.RPAREN); - return &ast.ParenExpr{lparen, typ, rparen}; + lparen := p.pos + p.next() + typ := p.parseType() + rparen := p.expect(token.RPAREN) + return &ast.ParenExpr{lparen, typ, rparen} } // no type found - return nil; + return nil } -func (p *parser) tryType() ast.Expr { return p.tryRawType(false) } +func (p *parser) tryType() ast.Expr { return p.tryRawType(false) } // ---------------------------------------------------------------------------- // Blocks func makeStmtList(list *vector.Vector) []ast.Stmt { - stats := make([]ast.Stmt, list.Len()); + stats := make([]ast.Stmt, list.Len()) for i := 0; i < list.Len(); i++ { stats[i] = list.At(i).(ast.Stmt) } - return stats; + return stats } @@ -809,24 +809,24 @@ func (p *parser) parseStmtList() []ast.Stmt { defer un(trace(p, "StatementList")) } - list := new(vector.Vector); - expectSemi := false; + list := new(vector.Vector) + expectSemi := false for p.tok != token.CASE && p.tok != token.DEFAULT && p.tok != token.RBRACE && p.tok != token.EOF { if expectSemi { - p.expect(token.SEMICOLON); - expectSemi = false; + p.expect(token.SEMICOLON) + expectSemi = false } - list.Push(p.parseStmt()); + list.Push(p.parseStmt()) if p.tok == token.SEMICOLON { p.next() } else if p.optSemi { - p.optSemi = false // "consume" optional semicolon + p.optSemi = false // "consume" optional semicolon } else { expectSemi = true } } - return makeStmtList(list); + return makeStmtList(list) } @@ -835,14 +835,14 @@ func (p *parser) parseBlockStmt(idents []*ast.Ident) *ast.BlockStmt { defer un(trace(p, "BlockStmt")) } - defer close(openScope(p)); + defer close(openScope(p)) - lbrace := p.expect(token.LBRACE); - list := p.parseStmtList(); - rbrace := p.expect(token.RBRACE); - p.optSemi = true; + lbrace := p.expect(token.LBRACE) + list := p.parseStmtList() + rbrace := p.expect(token.RBRACE) + p.optSemi = true - return &ast.BlockStmt{lbrace, list, rbrace}; + return &ast.BlockStmt{lbrace, list, rbrace} } @@ -854,23 +854,23 @@ func (p *parser) parseStringList(x *ast.BasicLit) []*ast.BasicLit { defer un(trace(p, "StringList")) } - list := new(vector.Vector); + list := new(vector.Vector) if x != nil { list.Push(x) } for p.tok == token.STRING { - list.Push(&ast.BasicLit{p.pos, token.STRING, p.lit}); - p.next(); + list.Push(&ast.BasicLit{p.pos, token.STRING, p.lit}) + p.next() } // convert list - strings := make([]*ast.BasicLit, list.Len()); + strings := make([]*ast.BasicLit, list.Len()) for i := 0; i < list.Len(); i++ { strings[i] = list.At(i).(*ast.BasicLit) } - return strings; + return strings } @@ -879,18 +879,18 @@ func (p *parser) parseFuncTypeOrLit() ast.Expr { defer un(trace(p, "FuncTypeOrLit")) } - typ := p.parseFuncType(); + typ := p.parseFuncType() if p.tok != token.LBRACE { // function type only return typ } - p.exprLev++; - body := p.parseBlockStmt(nil); - p.optSemi = false; // function body requires separating ";" - p.exprLev--; + p.exprLev++ + body := p.parseBlockStmt(nil) + p.optSemi = false // function body requires separating ";" + p.exprLev-- - return &ast.FuncLit{typ, body}; + return &ast.FuncLit{typ, body} } @@ -907,35 +907,35 @@ func (p *parser) parseOperand() ast.Expr { return p.parseIdent() case token.INT, token.FLOAT, token.CHAR, token.STRING: - x := &ast.BasicLit{p.pos, p.tok, p.lit}; - p.next(); + x := &ast.BasicLit{p.pos, p.tok, p.lit} + p.next() if p.tok == token.STRING && p.tok == token.STRING { return &ast.StringList{p.parseStringList(x)} } - return x; + return x case token.LPAREN: - lparen := p.pos; - p.next(); - p.exprLev++; - x := p.parseExpr(); - p.exprLev--; - rparen := p.expect(token.RPAREN); - return &ast.ParenExpr{lparen, x, rparen}; + lparen := p.pos + p.next() + p.exprLev++ + x := p.parseExpr() + p.exprLev-- + rparen := p.expect(token.RPAREN) + return &ast.ParenExpr{lparen, x, rparen} case token.FUNC: return p.parseFuncTypeOrLit() default: - t := p.tryRawType(true); // could be type for composite literal or conversion + t := p.tryRawType(true) // could be type for composite literal or conversion if t != nil { return t } } - p.errorExpected(p.pos, "operand"); - p.next(); // make progress - return &ast.BadExpr{p.pos}; + p.errorExpected(p.pos, "operand") + p.next() // make progress + return &ast.BadExpr{p.pos} } @@ -944,25 +944,25 @@ func (p *parser) parseSelectorOrTypeAssertion(x ast.Expr) ast.Expr { defer un(trace(p, "SelectorOrTypeAssertion")) } - p.expect(token.PERIOD); + p.expect(token.PERIOD) if p.tok == token.IDENT { // selector - sel := p.parseIdent(); - return &ast.SelectorExpr{x, sel}; + sel := p.parseIdent() + return &ast.SelectorExpr{x, sel} } // type assertion - p.expect(token.LPAREN); - var typ ast.Expr; + p.expect(token.LPAREN) + var typ ast.Expr if p.tok == token.TYPE { // type switch: typ == nil p.next() } else { typ = p.parseType() } - p.expect(token.RPAREN); + p.expect(token.RPAREN) - return &ast.TypeAssertExpr{x, typ}; + return &ast.TypeAssertExpr{x, typ} } @@ -971,23 +971,23 @@ func (p *parser) parseIndexOrSlice(x ast.Expr) ast.Expr { defer un(trace(p, "IndexOrSlice")) } - p.expect(token.LBRACK); - p.exprLev++; - index := p.parseExpr(); + p.expect(token.LBRACK) + p.exprLev++ + index := p.parseExpr() if p.tok == token.COLON { - p.next(); - var end ast.Expr; + p.next() + var end ast.Expr if p.tok != token.RBRACK { end = p.parseExpr() } - x = &ast.SliceExpr{x, index, end}; + x = &ast.SliceExpr{x, index, end} } else { x = &ast.IndexExpr{x, index} } - p.exprLev--; - p.expect(token.RBRACK); + p.exprLev-- + p.expect(token.RBRACK) - return x; + return x } @@ -996,16 +996,16 @@ func (p *parser) parseCallOrConversion(fun ast.Expr) *ast.CallExpr { defer un(trace(p, "CallOrConversion")) } - lparen := p.expect(token.LPAREN); - p.exprLev++; - var args []ast.Expr; + lparen := p.expect(token.LPAREN) + p.exprLev++ + var args []ast.Expr if p.tok != token.RPAREN { args = p.parseExprList() } - p.exprLev--; - rparen := p.expect(token.RPAREN); + p.exprLev-- + rparen := p.expect(token.RPAREN) - return &ast.CallExpr{fun, lparen, args, rparen}; + return &ast.CallExpr{fun, lparen, args, rparen} } @@ -1014,14 +1014,14 @@ func (p *parser) parseElement() ast.Expr { defer un(trace(p, "Element")) } - x := p.parseExpr(); + x := p.parseExpr() if p.tok == token.COLON { - colon := p.pos; - p.next(); - x = &ast.KeyValueExpr{x, colon, p.parseExpr()}; + colon := p.pos + p.next() + x = &ast.KeyValueExpr{x, colon, p.parseExpr()} } - return x; + return x } @@ -1030,9 +1030,9 @@ func (p *parser) parseElementList() []ast.Expr { defer un(trace(p, "ElementList")) } - list := new(vector.Vector); + list := new(vector.Vector) for p.tok != token.RBRACE && p.tok != token.EOF { - list.Push(p.parseElement()); + list.Push(p.parseElement()) if p.tok == token.COMMA { p.next() } else { @@ -1041,12 +1041,12 @@ func (p *parser) parseElementList() []ast.Expr { } // convert list - elts := make([]ast.Expr, list.Len()); + elts := make([]ast.Expr, list.Len()) for i := 0; i < list.Len(); i++ { elts[i] = list.At(i).(ast.Expr) } - return elts; + return elts } @@ -1055,13 +1055,13 @@ func (p *parser) parseCompositeLit(typ ast.Expr) ast.Expr { defer un(trace(p, "CompositeLit")) } - lbrace := p.expect(token.LBRACE); - var elts []ast.Expr; + lbrace := p.expect(token.LBRACE) + var elts []ast.Expr if p.tok != token.RBRACE { elts = p.parseElementList() } - rbrace := p.expect(token.RBRACE); - return &ast.CompositeLit{typ, lbrace, elts, rbrace}; + rbrace := p.expect(token.RBRACE) + return &ast.CompositeLit{typ, lbrace, elts, rbrace} } @@ -1087,24 +1087,24 @@ func (p *parser) checkExpr(x ast.Expr) ast.Expr { case *ast.TypeAssertExpr: if t.Type == nil { // the form X.(type) is only allowed in type switch expressions - p.errorExpected(x.Pos(), "expression"); - x = &ast.BadExpr{x.Pos()}; + p.errorExpected(x.Pos(), "expression") + x = &ast.BadExpr{x.Pos()} } case *ast.CallExpr: case *ast.StarExpr: case *ast.UnaryExpr: if t.Op == token.RANGE { // the range operator is only allowed at the top of a for statement - p.errorExpected(x.Pos(), "expression"); - x = &ast.BadExpr{x.Pos()}; + p.errorExpected(x.Pos(), "expression") + x = &ast.BadExpr{x.Pos()} } case *ast.BinaryExpr: default: // all other nodes are not proper expressions - p.errorExpected(x.Pos(), "expression"); - x = &ast.BadExpr{x.Pos()}; + p.errorExpected(x.Pos(), "expression") + x = &ast.BadExpr{x.Pos()} } - return x; + return x } @@ -1115,13 +1115,13 @@ func isTypeName(x ast.Expr) bool { case *ast.BadExpr: case *ast.Ident: case *ast.ParenExpr: - return isTypeName(t.X) // TODO(gri): should (TypeName) be illegal? + return isTypeName(t.X) // TODO(gri): should (TypeName) be illegal? case *ast.SelectorExpr: return isTypeName(t.X) default: - return false // all other nodes are not type names + return false // all other nodes are not type names } - return true; + return true } @@ -1139,9 +1139,9 @@ func isCompositeLitType(x ast.Expr) bool { case *ast.StructType: case *ast.MapType: default: - return false // all other nodes are not legal composite literal types + return false // all other nodes are not legal composite literal types } - return true; + return true } @@ -1154,18 +1154,18 @@ func (p *parser) checkExprOrType(x ast.Expr) ast.Expr { case *ast.UnaryExpr: if t.Op == token.RANGE { // the range operator is only allowed at the top of a for statement - p.errorExpected(x.Pos(), "expression"); - x = &ast.BadExpr{x.Pos()}; + p.errorExpected(x.Pos(), "expression") + x = &ast.BadExpr{x.Pos()} } case *ast.ArrayType: if len, isEllipsis := t.Len.(*ast.Ellipsis); isEllipsis { - p.Error(len.Pos(), "expected array length, found '...'"); - x = &ast.BadExpr{x.Pos()}; + p.Error(len.Pos(), "expected array length, found '...'") + x = &ast.BadExpr{x.Pos()} } } // all other nodes are expressions or types - return x; + return x } @@ -1174,8 +1174,8 @@ func (p *parser) parsePrimaryExpr() ast.Expr { defer un(trace(p, "PrimaryExpr")) } - x := p.parseOperand(); -L: for { + x := p.parseOperand() +L: for { switch p.tok { case token.PERIOD: x = p.parseSelectorOrTypeAssertion(p.checkExpr(x)) @@ -1194,7 +1194,7 @@ L: for { } } - return x; + return x } @@ -1205,20 +1205,20 @@ func (p *parser) parseUnaryExpr() ast.Expr { switch p.tok { case token.ADD, token.SUB, token.NOT, token.XOR, token.ARROW, token.AND, token.RANGE: - pos, op := p.pos, p.tok; - p.next(); - x := p.parseUnaryExpr(); - return &ast.UnaryExpr{pos, op, p.checkExpr(x)}; + pos, op := p.pos, p.tok + p.next() + x := p.parseUnaryExpr() + return &ast.UnaryExpr{pos, op, p.checkExpr(x)} case token.MUL: // unary "*" expression or pointer type - pos := p.pos; - p.next(); - x := p.parseUnaryExpr(); - return &ast.StarExpr{pos, p.checkExprOrType(x)}; + pos := p.pos + p.next() + x := p.parseUnaryExpr() + return &ast.StarExpr{pos, p.checkExprOrType(x)} } - return p.parsePrimaryExpr(); + return p.parsePrimaryExpr() } @@ -1227,17 +1227,17 @@ func (p *parser) parseBinaryExpr(prec1 int) ast.Expr { defer un(trace(p, "BinaryExpr")) } - x := p.parseUnaryExpr(); + x := p.parseUnaryExpr() for prec := p.tok.Precedence(); prec >= prec1; prec-- { for p.tok.Precedence() == prec { - pos, op := p.pos, p.tok; - p.next(); - y := p.parseBinaryExpr(prec + 1); - x = &ast.BinaryExpr{p.checkExpr(x), pos, op, p.checkExpr(y)}; + pos, op := p.pos, p.tok + p.next() + y := p.parseBinaryExpr(prec + 1) + x = &ast.BinaryExpr{p.checkExpr(x), pos, op, p.checkExpr(y)} } } - return x; + return x } @@ -1248,7 +1248,7 @@ func (p *parser) parseExpr() ast.Expr { defer un(trace(p, "Expression")) } - return p.parseBinaryExpr(token.LowestPrec + 1); + return p.parseBinaryExpr(token.LowestPrec + 1) } @@ -1261,19 +1261,19 @@ func (p *parser) parseSimpleStmt(labelOk bool) ast.Stmt { defer un(trace(p, "SimpleStmt")) } - x := p.parseExprList(); + x := p.parseExprList() switch p.tok { case token.COLON: // labeled statement - p.next(); + p.next() if labelOk && len(x) == 1 { if label, isIdent := x[0].(*ast.Ident); isIdent { return &ast.LabeledStmt{label, p.parseStmt()} } } - p.Error(x[0].Pos(), "illegal label declaration"); - return &ast.BadStmt{x[0].Pos()}; + p.Error(x[0].Pos(), "illegal label declaration") + return &ast.BadStmt{x[0].Pos()} case token.DEFINE, token.ASSIGN, token.ADD_ASSIGN, @@ -1281,13 +1281,13 @@ func (p *parser) parseSimpleStmt(labelOk bool) ast.Stmt { token.REM_ASSIGN, token.AND_ASSIGN, token.OR_ASSIGN, token.XOR_ASSIGN, token.SHL_ASSIGN, token.SHR_ASSIGN, token.AND_NOT_ASSIGN: // assignment statement - pos, tok := p.pos, p.tok; - p.next(); - y := p.parseExprList(); + pos, tok := p.pos, p.tok + p.next() + y := p.parseExprList() if len(x) > 1 && len(y) > 1 && len(x) != len(y) { p.Error(x[0].Pos(), "arity of lhs doesn't match rhs") } - return &ast.AssignStmt{x, pos, tok, y}; + return &ast.AssignStmt{x, pos, tok, y} } if len(x) > 1 { @@ -1297,23 +1297,23 @@ func (p *parser) parseSimpleStmt(labelOk bool) ast.Stmt { if p.tok == token.INC || p.tok == token.DEC { // increment or decrement - s := &ast.IncDecStmt{x[0], p.tok}; - p.next(); // consume "++" or "--" - return s; + s := &ast.IncDecStmt{x[0], p.tok} + p.next() // consume "++" or "--" + return s } // expression - return &ast.ExprStmt{x[0]}; + return &ast.ExprStmt{x[0]} } func (p *parser) parseCallExpr() *ast.CallExpr { - x := p.parseExpr(); + x := p.parseExpr() if call, isCall := x.(*ast.CallExpr); isCall { return call } - p.errorExpected(x.Pos(), "function/method call"); - return nil; + p.errorExpected(x.Pos(), "function/method call") + return nil } @@ -1322,12 +1322,12 @@ func (p *parser) parseGoStmt() ast.Stmt { defer un(trace(p, "GoStmt")) } - pos := p.expect(token.GO); - call := p.parseCallExpr(); + pos := p.expect(token.GO) + call := p.parseCallExpr() if call != nil { return &ast.GoStmt{pos, call} } - return &ast.BadStmt{pos}; + return &ast.BadStmt{pos} } @@ -1336,12 +1336,12 @@ func (p *parser) parseDeferStmt() ast.Stmt { defer un(trace(p, "DeferStmt")) } - pos := p.expect(token.DEFER); - call := p.parseCallExpr(); + pos := p.expect(token.DEFER) + call := p.parseCallExpr() if call != nil { return &ast.DeferStmt{pos, call} } - return &ast.BadStmt{pos}; + return &ast.BadStmt{pos} } @@ -1350,14 +1350,14 @@ func (p *parser) parseReturnStmt() *ast.ReturnStmt { defer un(trace(p, "ReturnStmt")) } - pos := p.pos; - p.expect(token.RETURN); - var x []ast.Expr; + pos := p.pos + p.expect(token.RETURN) + var x []ast.Expr if p.tok != token.SEMICOLON && p.tok != token.CASE && p.tok != token.DEFAULT && p.tok != token.RBRACE { x = p.parseExprList() } - return &ast.ReturnStmt{pos, x}; + return &ast.ReturnStmt{pos, x} } @@ -1366,13 +1366,13 @@ func (p *parser) parseBranchStmt(tok token.Token) *ast.BranchStmt { defer un(trace(p, "BranchStmt")) } - s := &ast.BranchStmt{p.pos, tok, nil}; - p.expect(tok); + s := &ast.BranchStmt{p.pos, tok, nil} + p.expect(tok) if tok != token.FALLTHROUGH && p.tok == token.IDENT { s.Label = p.parseIdent() } - return s; + return s } @@ -1383,27 +1383,27 @@ func (p *parser) makeExpr(s ast.Stmt) ast.Expr { if es, isExpr := s.(*ast.ExprStmt); isExpr { return p.checkExpr(es.X) } - p.Error(s.Pos(), "expected condition, found simple statement"); - return &ast.BadExpr{s.Pos()}; + p.Error(s.Pos(), "expected condition, found simple statement") + return &ast.BadExpr{s.Pos()} } func (p *parser) parseControlClause(isForStmt bool) (s1, s2, s3 ast.Stmt) { if p.tok != token.LBRACE { - prevLev := p.exprLev; - p.exprLev = -1; + prevLev := p.exprLev + p.exprLev = -1 if p.tok != token.SEMICOLON { s1 = p.parseSimpleStmt(false) } if p.tok == token.SEMICOLON { - p.next(); + p.next() if p.tok != token.LBRACE && p.tok != token.SEMICOLON { s2 = p.parseSimpleStmt(false) } if isForStmt { // for statements have a 3rd section - p.expect(token.SEMICOLON); + p.expect(token.SEMICOLON) if p.tok != token.LBRACE { s3 = p.parseSimpleStmt(false) } @@ -1412,10 +1412,10 @@ func (p *parser) parseControlClause(isForStmt bool) (s1, s2, s3 ast.Stmt) { s1, s2 = nil, s1 } - p.exprLev = prevLev; + p.exprLev = prevLev } - return s1, s2, s3; + return s1, s2, s3 } @@ -1425,18 +1425,18 @@ func (p *parser) parseIfStmt() *ast.IfStmt { } // IfStmt block - defer close(openScope(p)); + defer close(openScope(p)) - pos := p.expect(token.IF); - s1, s2, _ := p.parseControlClause(false); - body := p.parseBlockStmt(nil); - var else_ ast.Stmt; + pos := p.expect(token.IF) + s1, s2, _ := p.parseControlClause(false) + body := p.parseBlockStmt(nil) + var else_ ast.Stmt if p.tok == token.ELSE { - p.next(); - else_ = p.parseStmt(); + p.next() + else_ = p.parseStmt() } - return &ast.IfStmt{pos, s1, p.makeExpr(s2), body, else_}; + return &ast.IfStmt{pos, s1, p.makeExpr(s2), body, else_} } @@ -1446,22 +1446,22 @@ func (p *parser) parseCaseClause() *ast.CaseClause { } // CaseClause block - defer close(openScope(p)); + defer close(openScope(p)) // SwitchCase - pos := p.pos; - var x []ast.Expr; + pos := p.pos + var x []ast.Expr if p.tok == token.CASE { - p.next(); - x = p.parseExprList(); + p.next() + x = p.parseExprList() } else { p.expect(token.DEFAULT) } - colon := p.expect(token.COLON); - body := p.parseStmtList(); + colon := p.expect(token.COLON) + body := p.parseStmtList() - return &ast.CaseClause{pos, x, colon, body}; + return &ast.CaseClause{pos, x, colon, body} } @@ -1470,20 +1470,20 @@ func (p *parser) parseTypeList() []ast.Expr { defer un(trace(p, "TypeList")) } - list := new(vector.Vector); - list.Push(p.parseType()); + list := new(vector.Vector) + list.Push(p.parseType()) for p.tok == token.COMMA { - p.next(); - list.Push(p.parseType()); + p.next() + list.Push(p.parseType()) } // convert list - exprs := make([]ast.Expr, list.Len()); + exprs := make([]ast.Expr, list.Len()) for i := 0; i < list.Len(); i++ { exprs[i] = list.At(i).(ast.Expr) } - return exprs; + return exprs } @@ -1493,22 +1493,22 @@ func (p *parser) parseTypeCaseClause() *ast.TypeCaseClause { } // TypeCaseClause block - defer close(openScope(p)); + defer close(openScope(p)) // TypeSwitchCase - pos := p.pos; - var types []ast.Expr; + pos := p.pos + var types []ast.Expr if p.tok == token.CASE { - p.next(); - types = p.parseTypeList(); + p.next() + types = p.parseTypeList() } else { p.expect(token.DEFAULT) } - colon := p.expect(token.COLON); - body := p.parseStmtList(); + colon := p.expect(token.COLON) + body := p.parseStmtList() - return &ast.TypeCaseClause{pos, types, colon, body}; + return &ast.TypeCaseClause{pos, types, colon, body} } @@ -1518,11 +1518,11 @@ func isExprSwitch(s ast.Stmt) bool { } if e, ok := s.(*ast.ExprStmt); ok { if a, ok := e.X.(*ast.TypeAssertExpr); ok { - return a.Type != nil // regular type assertion + return a.Type != nil // regular type assertion } - return true; + return true } - return false; + return false } @@ -1532,34 +1532,34 @@ func (p *parser) parseSwitchStmt() ast.Stmt { } // SwitchStmt block - defer close(openScope(p)); + defer close(openScope(p)) - pos := p.expect(token.SWITCH); - s1, s2, _ := p.parseControlClause(false); + pos := p.expect(token.SWITCH) + s1, s2, _ := p.parseControlClause(false) if isExprSwitch(s2) { - lbrace := p.expect(token.LBRACE); - cases := new(vector.Vector); + lbrace := p.expect(token.LBRACE) + cases := new(vector.Vector) for p.tok == token.CASE || p.tok == token.DEFAULT { cases.Push(p.parseCaseClause()) } - rbrace := p.expect(token.RBRACE); - p.optSemi = true; - body := &ast.BlockStmt{lbrace, makeStmtList(cases), rbrace}; - return &ast.SwitchStmt{pos, s1, p.makeExpr(s2), body}; + rbrace := p.expect(token.RBRACE) + p.optSemi = true + body := &ast.BlockStmt{lbrace, makeStmtList(cases), rbrace} + return &ast.SwitchStmt{pos, s1, p.makeExpr(s2), body} } // type switch // TODO(gri): do all the checks! - lbrace := p.expect(token.LBRACE); - cases := new(vector.Vector); + lbrace := p.expect(token.LBRACE) + cases := new(vector.Vector) for p.tok == token.CASE || p.tok == token.DEFAULT { cases.Push(p.parseTypeCaseClause()) } - rbrace := p.expect(token.RBRACE); - p.optSemi = true; - body := &ast.BlockStmt{lbrace, makeStmtList(cases), rbrace}; - return &ast.TypeSwitchStmt{pos, s1, s2, body}; + rbrace := p.expect(token.RBRACE) + p.optSemi = true + body := &ast.BlockStmt{lbrace, makeStmtList(cases), rbrace} + return &ast.TypeSwitchStmt{pos, s1, s2, body} } @@ -1569,29 +1569,29 @@ func (p *parser) parseCommClause() *ast.CommClause { } // CommClause block - defer close(openScope(p)); + defer close(openScope(p)) // CommCase - pos := p.pos; - var tok token.Token; - var lhs, rhs ast.Expr; + pos := p.pos + var tok token.Token + var lhs, rhs ast.Expr if p.tok == token.CASE { - p.next(); + p.next() if p.tok == token.ARROW { // RecvExpr without assignment rhs = p.parseExpr() } else { // SendExpr or RecvExpr - rhs = p.parseExpr(); + rhs = p.parseExpr() if p.tok == token.ASSIGN || p.tok == token.DEFINE { // RecvExpr with assignment - tok = p.tok; - p.next(); - lhs = rhs; + tok = p.tok + p.next() + lhs = rhs if p.tok == token.ARROW { rhs = p.parseExpr() } else { - p.expect(token.ARROW) // use expect() error handling + p.expect(token.ARROW) // use expect() error handling } } // else SendExpr @@ -1600,10 +1600,10 @@ func (p *parser) parseCommClause() *ast.CommClause { p.expect(token.DEFAULT) } - colon := p.expect(token.COLON); - body := p.parseStmtList(); + colon := p.expect(token.COLON) + body := p.parseStmtList() - return &ast.CommClause{pos, tok, lhs, rhs, colon, body}; + return &ast.CommClause{pos, tok, lhs, rhs, colon, body} } @@ -1612,17 +1612,17 @@ func (p *parser) parseSelectStmt() *ast.SelectStmt { defer un(trace(p, "SelectStmt")) } - pos := p.expect(token.SELECT); - lbrace := p.expect(token.LBRACE); - cases := new(vector.Vector); + pos := p.expect(token.SELECT) + lbrace := p.expect(token.LBRACE) + cases := new(vector.Vector) for p.tok == token.CASE || p.tok == token.DEFAULT { cases.Push(p.parseCommClause()) } - rbrace := p.expect(token.RBRACE); - p.optSemi = true; - body := &ast.BlockStmt{lbrace, makeStmtList(cases), rbrace}; + rbrace := p.expect(token.RBRACE) + p.optSemi = true + body := &ast.BlockStmt{lbrace, makeStmtList(cases), rbrace} - return &ast.SelectStmt{pos, body}; + return &ast.SelectStmt{pos, body} } @@ -1632,49 +1632,49 @@ func (p *parser) parseForStmt() ast.Stmt { } // ForStmt block - defer close(openScope(p)); + defer close(openScope(p)) - pos := p.expect(token.FOR); - s1, s2, s3 := p.parseControlClause(true); - body := p.parseBlockStmt(nil); + pos := p.expect(token.FOR) + s1, s2, s3 := p.parseControlClause(true) + body := p.parseBlockStmt(nil) if as, isAssign := s2.(*ast.AssignStmt); isAssign { // possibly a for statement with a range clause; check assignment operator if as.Tok != token.ASSIGN && as.Tok != token.DEFINE { - p.errorExpected(as.TokPos, "'=' or ':='"); - return &ast.BadStmt{pos}; + p.errorExpected(as.TokPos, "'=' or ':='") + return &ast.BadStmt{pos} } // check lhs - var key, value ast.Expr; + var key, value ast.Expr switch len(as.Lhs) { case 2: - value = as.Lhs[1]; - fallthrough; + value = as.Lhs[1] + fallthrough case 1: key = as.Lhs[0] default: - p.errorExpected(as.Lhs[0].Pos(), "1 or 2 expressions"); - return &ast.BadStmt{pos}; + p.errorExpected(as.Lhs[0].Pos(), "1 or 2 expressions") + return &ast.BadStmt{pos} } // check rhs if len(as.Rhs) != 1 { - p.errorExpected(as.Rhs[0].Pos(), "1 expressions"); - return &ast.BadStmt{pos}; + p.errorExpected(as.Rhs[0].Pos(), "1 expressions") + return &ast.BadStmt{pos} } if rhs, isUnary := as.Rhs[0].(*ast.UnaryExpr); isUnary && rhs.Op == token.RANGE { // rhs is range expression; check lhs return &ast.RangeStmt{pos, key, value, as.TokPos, as.Tok, rhs.X, body} } else { - p.errorExpected(s2.Pos(), "range clause"); - return &ast.BadStmt{pos}; + p.errorExpected(s2.Pos(), "range clause") + return &ast.BadStmt{pos} } } else { // regular for statement return &ast.ForStmt{pos, s1, p.makeExpr(s2), s3, body} } - panic(); // unreachable - return nil; + panic() // unreachable + return nil } @@ -1685,13 +1685,13 @@ func (p *parser) parseStmt() ast.Stmt { switch p.tok { case token.CONST, token.TYPE, token.VAR: - decl, _ := p.parseDecl(false); // do not consume trailing semicolon - return &ast.DeclStmt{decl}; + decl, _ := p.parseDecl(false) // do not consume trailing semicolon + return &ast.DeclStmt{decl} case // tokens that may start a top-level expression - token.IDENT, token.INT, token.FLOAT, token.CHAR, token.STRING, token.FUNC, token.LPAREN, // operand - token.LBRACK, token.STRUCT, // composite type - token.MUL, token.AND, token.ARROW, token.ADD, token.SUB, token.XOR: // unary operators + token.IDENT, token.INT, token.FLOAT, token.CHAR, token.STRING, token.FUNC, token.LPAREN, // operand + token.LBRACK, token.STRUCT, // composite type + token.MUL, token.AND, token.ARROW, token.ADD, token.SUB, token.XOR: // unary operators return p.parseSimpleStmt(true) case token.GO: return p.parseGoStmt() @@ -1717,9 +1717,9 @@ func (p *parser) parseStmt() ast.Stmt { } // no statement found - p.errorExpected(p.pos, "statement"); - p.next(); // make progress - return &ast.BadStmt{p.pos}; + p.errorExpected(p.pos, "statement") + p.next() // make progress + return &ast.BadStmt{p.pos} } @@ -1734,10 +1734,10 @@ type parseSpecFunction func(p *parser, doc *ast.CommentGroup, getSemi bool) (spe // func (p *parser) parseComment(getSemi bool) (comment *ast.CommentGroup, gotSemi bool) { if getSemi && p.tok == token.SEMICOLON { - p.next(); - gotSemi = true; + p.next() + gotSemi = true } - return p.lineComment, gotSemi; + return p.lineComment, gotSemi } @@ -1746,24 +1746,24 @@ func parseImportSpec(p *parser, doc *ast.CommentGroup, getSemi bool) (spec ast.S defer un(trace(p, "ImportSpec")) } - var ident *ast.Ident; + var ident *ast.Ident if p.tok == token.PERIOD { - ident = &ast.Ident{p.pos, "."}; - p.next(); + ident = &ast.Ident{p.pos, "."} + p.next() } else if p.tok == token.IDENT { ident = p.parseIdent() } - var path []*ast.BasicLit; + var path []*ast.BasicLit if p.tok == token.STRING { path = p.parseStringList(nil) } else { - p.expect(token.STRING) // use expect() error handling + p.expect(token.STRING) // use expect() error handling } - comment, gotSemi := p.parseComment(getSemi); + comment, gotSemi := p.parseComment(getSemi) - return &ast.ImportSpec{doc, ident, path, comment}, gotSemi; + return &ast.ImportSpec{doc, ident, path, comment}, gotSemi } @@ -1772,16 +1772,16 @@ func parseConstSpec(p *parser, doc *ast.CommentGroup, getSemi bool) (spec ast.Sp defer un(trace(p, "ConstSpec")) } - idents := p.parseIdentList(); - typ := p.tryType(); - var values []ast.Expr; + idents := p.parseIdentList() + typ := p.tryType() + var values []ast.Expr if typ != nil || p.tok == token.ASSIGN { - p.expect(token.ASSIGN); - values = p.parseExprList(); + p.expect(token.ASSIGN) + values = p.parseExprList() } - comment, gotSemi := p.parseComment(getSemi); + comment, gotSemi := p.parseComment(getSemi) - return &ast.ValueSpec{doc, idents, typ, values, comment}, gotSemi; + return &ast.ValueSpec{doc, idents, typ, values, comment}, gotSemi } @@ -1790,11 +1790,11 @@ func parseTypeSpec(p *parser, doc *ast.CommentGroup, getSemi bool) (spec ast.Spe defer un(trace(p, "TypeSpec")) } - ident := p.parseIdent(); - typ := p.parseType(); - comment, gotSemi := p.parseComment(getSemi); + ident := p.parseIdent() + typ := p.parseType() + comment, gotSemi := p.parseComment(getSemi) - return &ast.TypeSpec{doc, ident, typ, comment}, gotSemi; + return &ast.TypeSpec{doc, ident, typ, comment}, gotSemi } @@ -1803,16 +1803,16 @@ func parseVarSpec(p *parser, doc *ast.CommentGroup, getSemi bool) (spec ast.Spec defer un(trace(p, "VarSpec")) } - idents := p.parseIdentList(); - typ := p.tryType(); - var values []ast.Expr; + idents := p.parseIdentList() + typ := p.tryType() + var values []ast.Expr if typ == nil || p.tok == token.ASSIGN { - p.expect(token.ASSIGN); - values = p.parseExprList(); + p.expect(token.ASSIGN) + values = p.parseExprList() } - comment, gotSemi := p.parseComment(getSemi); + comment, gotSemi := p.parseComment(getSemi) - return &ast.ValueSpec{doc, idents, typ, values, comment}, gotSemi; + return &ast.ValueSpec{doc, idents, typ, values, comment}, gotSemi } @@ -1821,42 +1821,42 @@ func (p *parser) parseGenDecl(keyword token.Token, f parseSpecFunction, getSemi defer un(trace(p, keyword.String()+"Decl")) } - doc := p.leadComment; - pos := p.expect(keyword); - var lparen, rparen token.Position; - list := new(vector.Vector); + doc := p.leadComment + pos := p.expect(keyword) + var lparen, rparen token.Position + list := new(vector.Vector) if p.tok == token.LPAREN { - lparen = p.pos; - p.next(); + lparen = p.pos + p.next() for p.tok != token.RPAREN && p.tok != token.EOF { - doc := p.leadComment; - spec, semi := f(p, doc, true); // consume semicolon if any - list.Push(spec); + doc := p.leadComment + spec, semi := f(p, doc, true) // consume semicolon if any + list.Push(spec) if !semi { break } } - rparen = p.expect(token.RPAREN); + rparen = p.expect(token.RPAREN) if getSemi && p.tok == token.SEMICOLON { - p.next(); - gotSemi = true; + p.next() + gotSemi = true } else { p.optSemi = true } } else { - spec, semi := f(p, nil, getSemi); - list.Push(spec); - gotSemi = semi; + spec, semi := f(p, nil, getSemi) + list.Push(spec) + gotSemi = semi } // convert vector - specs := make([]ast.Spec, list.Len()); + specs := make([]ast.Spec, list.Len()) for i := 0; i < list.Len(); i++ { specs[i] = list.At(i).(ast.Spec) } - return &ast.GenDecl{doc, pos, keyword, lparen, specs, rparen}, gotSemi; + return &ast.GenDecl{doc, pos, keyword, lparen, specs, rparen}, gotSemi } @@ -1865,19 +1865,19 @@ func (p *parser) parseReceiver() *ast.Field { defer un(trace(p, "Receiver")) } - pos := p.pos; - par := p.parseParameters(false); + pos := p.pos + par := p.parseParameters(false) // must have exactly one receiver if len(par) != 1 || len(par) == 1 && len(par[0].Names) > 1 { - p.errorExpected(pos, "exactly one receiver"); - return &ast.Field{Type: &ast.BadExpr{noPos}}; + p.errorExpected(pos, "exactly one receiver") + return &ast.Field{Type: &ast.BadExpr{noPos}} } - recv := par[0]; + recv := par[0] // recv type must be TypeName or *TypeName - base := recv.Type; + base := recv.Type if ptr, isPtr := base.(*ast.StarExpr); isPtr { base = ptr.X } @@ -1885,7 +1885,7 @@ func (p *parser) parseReceiver() *ast.Field { p.errorExpected(base.Pos(), "type name") } - return recv; + return recv } @@ -1894,23 +1894,23 @@ func (p *parser) parseFunctionDecl() *ast.FuncDecl { defer un(trace(p, "FunctionDecl")) } - doc := p.leadComment; - pos := p.expect(token.FUNC); + doc := p.leadComment + pos := p.expect(token.FUNC) - var recv *ast.Field; + var recv *ast.Field if p.tok == token.LPAREN { recv = p.parseReceiver() } - ident := p.parseIdent(); - params, results := p.parseSignature(); + ident := p.parseIdent() + params, results := p.parseSignature() - var body *ast.BlockStmt; + var body *ast.BlockStmt if p.tok == token.LBRACE { body = p.parseBlockStmt(nil) } - return &ast.FuncDecl{doc, recv, ident, &ast.FuncType{pos, params, results}, body}; + return &ast.FuncDecl{doc, recv, ident, &ast.FuncType{pos, params, results}, body} } @@ -1919,7 +1919,7 @@ func (p *parser) parseDecl(getSemi bool) (decl ast.Decl, gotSemi bool) { defer un(trace(p, "Declaration")) } - var f parseSpecFunction; + var f parseSpecFunction switch p.tok { case token.CONST: f = parseConstSpec @@ -1931,20 +1931,20 @@ func (p *parser) parseDecl(getSemi bool) (decl ast.Decl, gotSemi bool) { f = parseVarSpec case token.FUNC: - decl = p.parseFunctionDecl(); - _, gotSemi := p.parseComment(getSemi); - return decl, gotSemi; + decl = p.parseFunctionDecl() + _, gotSemi := p.parseComment(getSemi) + return decl, gotSemi default: - pos := p.pos; - p.errorExpected(pos, "declaration"); - decl = &ast.BadDecl{pos}; - gotSemi = getSemi && p.tok == token.SEMICOLON; - p.next(); // make progress in any case - return decl, gotSemi; + pos := p.pos + p.errorExpected(pos, "declaration") + decl = &ast.BadDecl{pos} + gotSemi = getSemi && p.tok == token.SEMICOLON + p.next() // make progress in any case + return decl, gotSemi } - return p.parseGenDecl(p.tok, f, getSemi); + return p.parseGenDecl(p.tok, f, getSemi) } @@ -1953,19 +1953,19 @@ func (p *parser) parseDeclList() []ast.Decl { defer un(trace(p, "DeclList")) } - list := new(vector.Vector); + list := new(vector.Vector) for p.tok != token.EOF { - decl, _ := p.parseDecl(true); // consume optional semicolon - list.Push(decl); + decl, _ := p.parseDecl(true) // consume optional semicolon + list.Push(decl) } // convert vector - decls := make([]ast.Decl, list.Len()); + decls := make([]ast.Decl, list.Len()) for i := 0; i < list.Len(); i++ { decls[i] = list.At(i).(ast.Decl) } - return decls; + return decls } @@ -1978,47 +1978,47 @@ func (p *parser) parseFile() *ast.File { } // file block - defer close(openScope(p)); + defer close(openScope(p)) // package clause - doc := p.leadComment; - pos := p.expect(token.PACKAGE); - ident := p.parseIdent(); + doc := p.leadComment + pos := p.expect(token.PACKAGE) + ident := p.parseIdent() // Common error: semicolon after package clause. // Accept and report it for better error synchronization. if p.tok == token.SEMICOLON { - p.Error(p.pos, "expected declaration, found ';'"); - p.next(); + p.Error(p.pos, "expected declaration, found ';'") + p.next() } - var decls []ast.Decl; + var decls []ast.Decl // Don't bother parsing the rest if we had errors already. // Likely not a Go source file at all. if p.ErrorCount() == 0 && p.mode&PackageClauseOnly == 0 { // import decls - list := new(vector.Vector); + list := new(vector.Vector) for p.tok == token.IMPORT { - decl, _ := p.parseGenDecl(token.IMPORT, parseImportSpec, true); // consume optional semicolon - list.Push(decl); + decl, _ := p.parseGenDecl(token.IMPORT, parseImportSpec, true) // consume optional semicolon + list.Push(decl) } if p.mode&ImportsOnly == 0 { // rest of package body for p.tok != token.EOF { - decl, _ := p.parseDecl(true); // consume optional semicolon - list.Push(decl); + decl, _ := p.parseDecl(true) // consume optional semicolon + list.Push(decl) } } // convert declaration list - decls = make([]ast.Decl, list.Len()); + decls = make([]ast.Decl, list.Len()) for i := 0; i < list.Len(); i++ { decls[i] = list.At(i).(ast.Decl) } } - return &ast.File{doc, pos, ident, decls, p.comments}; + return &ast.File{doc, pos, ident, decls, p.comments} } diff --git a/src/pkg/exp/parser/parser_test.go b/src/pkg/exp/parser/parser_test.go index e01281815..2aefaa1cf 100644 --- a/src/pkg/exp/parser/parser_test.go +++ b/src/pkg/exp/parser/parser_test.go @@ -5,8 +5,8 @@ package oldParser import ( - "os"; - "testing"; + "os" + "testing" ) @@ -20,7 +20,7 @@ var illegalInputs = []interface{}{ func TestParseIllegalInputs(t *testing.T) { for _, src := range illegalInputs { - _, err := ParseFile("", src, 0); + _, err := ParseFile("", src, 0) if err == nil { t.Errorf("ParseFile(%v) should have failed", src) } @@ -37,7 +37,7 @@ var validPrograms = []interface{}{ func TestParseValidPrograms(t *testing.T) { for _, src := range validPrograms { - _, err := ParseFile("", src, 0); + _, err := ParseFile("", src, 0) if err != nil { t.Errorf("ParseFile(%q): %v", src, err) } @@ -52,8 +52,9 @@ var validFiles = []string{ func TestParse3(t *testing.T) { + return // disabled since the parser only accepts old syntax for _, filename := range validFiles { - _, err := ParseFile(filename, nil, 0); + _, err := ParseFile(filename, nil, 0) if err != nil { t.Errorf("ParseFile(%s): %v", filename, err) } @@ -69,16 +70,17 @@ func nameFilter(filename string) bool { default: return false } - return true; + return true } -func dirFilter(d *os.Dir) bool { return nameFilter(d.Name) } +func dirFilter(d *os.Dir) bool { return nameFilter(d.Name) } func TestParse4(t *testing.T) { - path := "."; - pkg, err := ParsePackage(path, dirFilter, 0); + return // disabled since the parser only accepts old syntax + path := "." + pkg, err := ParsePackage(path, dirFilter, 0) if err != nil { t.Fatalf("ParsePackage(%s): %v", path, err) } diff --git a/src/pkg/exp/spacewar/pdp1.go b/src/pkg/exp/spacewar/pdp1.go index d961030d9..e3abd6807 100644 --- a/src/pkg/exp/spacewar/pdp1.go +++ b/src/pkg/exp/spacewar/pdp1.go @@ -57,10 +57,10 @@ package pdp1 import ( - "bufio"; - "fmt"; - "os"; - "io"; + "bufio" + "fmt" + "os" + "io" ) type Word uint32 @@ -69,82 +69,82 @@ const mask = 0777777 const sign = 0400000 const ( - _ = iota; // 00 - opAND; - opIOR; - opXOR; - opXCT; - _; - _; - opCALJDA; + _ = iota // 00 + opAND + opIOR + opXOR + opXCT + _ + _ + opCALJDA - opLAC; // 10 - opLIO; - opDAC; - opDAP; - _; - opDIO; - opDZM; - _; + opLAC // 10 + opLIO + opDAC + opDAP + _ + opDIO + opDZM + _ - opADD; // 20 - opSUB; - opIDX; - opISP; - opSAD; - opSAS; - opMUS; - opDIS; + opADD // 20 + opSUB + opIDX + opISP + opSAD + opSAS + opMUS + opDIS - opJMP; // 30 - opJSP; - opSKP; - opSFT; - opLAW; - opIOT; - _; - opOPR; + opJMP // 30 + opJSP + opSKP + opSFT + opLAW + opIOT + _ + opOPR ) // A Trapper represents an object with a Trap method. // The machine calls the Trap method to implement the // PDP-1 IOT instruction. type Trapper interface { - Trap(y Word); + Trap(y Word) } // An M represents the machine state of a PDP-1. // Clients can set Display to install an output device. type M struct { - AC, IO, PC, OV Word; - Mem [010000]Word; - Flag [7]bool; - Sense [7]bool; - Halt bool; + AC, IO, PC, OV Word + Mem [010000]Word + Flag [7]bool + Sense [7]bool + Halt bool } // Step runs a single machine instruction. func (m *M) Step(t Trapper) os.Error { - inst := m.Mem[m.PC]; - m.PC++; - return m.run(inst, t); + inst := m.Mem[m.PC] + m.PC++ + return m.run(inst, t) } // Normalize actual 32-bit integer i to 18-bit ones-complement integer. // Interpret mod 0777777, because 0777777 == -0 == +0 == 0000000. func norm(i Word) Word { - i += i >> 18; - i &= mask; + i += i >> 18 + i &= mask if i == mask { i = 0 } - return i; + return i } type UnknownInstrError struct { - Inst Word; - PC Word; + Inst Word + PC Word } func (e UnknownInstrError) String() string { @@ -159,18 +159,18 @@ func (e HaltError) String() string { type LoopError Word -func (e LoopError) String() string { return fmt.Sprintf("indirect load looping at %06o", e) } +func (e LoopError) String() string { return fmt.Sprintf("indirect load looping at %06o", e) } func (m *M) run(inst Word, t Trapper) os.Error { - ib, y := (inst>>12)&1, inst&07777; - op := inst >> 13; + ib, y := (inst>>12)&1, inst&07777 + op := inst >> 13 if op < opSKP && op != opCALJDA { for n := 0; ib != 0; n++ { if n > 07777 { return LoopError(m.PC - 1) } - ib = (m.Mem[y] >> 12) & 1; - y = m.Mem[y] & 07777; + ib = (m.Mem[y] >> 12) & 1 + y = m.Mem[y] & 07777 } } @@ -184,13 +184,13 @@ func (m *M) run(inst Word, t Trapper) os.Error { case opXCT: m.run(m.Mem[y], t) case opCALJDA: - a := y; + a := y if ib == 0 { a = 64 } - m.Mem[a] = m.AC; - m.AC = (m.OV << 17) + m.PC; - m.PC = a + 1; + m.Mem[a] = m.AC + m.AC = (m.OV << 17) + m.PC + m.PC = a + 1 case opLAC: m.AC = m.Mem[y] case opLIO: @@ -204,22 +204,22 @@ func (m *M) run(inst Word, t Trapper) os.Error { case opDZM: m.Mem[y] = 0 case opADD: - m.AC += m.Mem[y]; - m.OV = m.AC >> 18; - m.AC = norm(m.AC); + m.AC += m.Mem[y] + m.OV = m.AC >> 18 + m.AC = norm(m.AC) case opSUB: - diffSigns := (m.AC^m.Mem[y])>>17 == 1; - m.AC += m.Mem[y] ^ mask; - m.AC = norm(m.AC); + diffSigns := (m.AC^m.Mem[y])>>17 == 1 + m.AC += m.Mem[y] ^ mask + m.AC = norm(m.AC) if diffSigns && m.Mem[y]>>17 == m.AC>>17 { m.OV = 1 } case opIDX: - m.AC = norm(m.Mem[y] + 1); - m.Mem[y] = m.AC; + m.AC = norm(m.Mem[y] + 1) + m.Mem[y] = m.AC case opISP: - m.AC = norm(m.Mem[y] + 1); - m.Mem[y] = m.AC; + m.AC = norm(m.Mem[y] + 1) + m.Mem[y] = m.AC if m.AC&sign == 0 { m.PC++ } @@ -233,25 +233,25 @@ func (m *M) run(inst Word, t Trapper) os.Error { } case opMUS: if m.IO&1 == 1 { - m.AC += m.Mem[y]; - m.AC = norm(m.AC); + m.AC += m.Mem[y] + m.AC = norm(m.AC) } - m.IO = (m.IO>>1 | m.AC<<17) & mask; - m.AC >>= 1; + m.IO = (m.IO>>1 | m.AC<<17) & mask + m.AC >>= 1 case opDIS: m.AC, m.IO = (m.AC<<1|m.IO>>17)&mask, - ((m.IO<<1|m.AC>>17)&mask)^1; + ((m.IO<<1|m.AC>>17)&mask)^1 if m.IO&1 == 1 { m.AC = m.AC + (m.Mem[y] ^ mask) } else { m.AC = m.AC + 1 + m.Mem[y] } - m.AC = norm(m.AC); + m.AC = norm(m.AC) case opJMP: m.PC = y case opJSP: - m.AC = (m.OV << 17) + m.PC; - m.PC = y; + m.AC = (m.OV << 17) + m.PC + m.PC = y case opSKP: cond := y&0100 == 0100 && m.AC == 0 || y&0200 == 0200 && m.AC>>17 == 0 || @@ -260,7 +260,7 @@ func (m *M) run(inst Word, t Trapper) os.Error { y&02000 == 02000 && m.IO>>17 == 0 || y&7 != 0 && !m.Flag[y&7] || y&070 != 0 && !m.Sense[(y&070)>>3] || - y&070 == 010; + y&070 == 010 if (ib == 0) == cond { m.PC++ } @@ -273,42 +273,42 @@ func (m *M) run(inst Word, t Trapper) os.Error { continue } switch (inst >> 9) & 017 { - case 001: // rotate AC left + case 001: // rotate AC left m.AC = (m.AC<<1 | m.AC>>17) & mask - case 002: // rotate IO left + case 002: // rotate IO left m.IO = (m.IO<<1 | m.IO>>17) & mask - case 003: // rotate AC and IO left. - w := uint64(m.AC)<<18 | uint64(m.IO); - w = w<<1 | w>>35; - m.AC = Word(w>>18) & mask; - m.IO = Word(w) & mask; - case 005: // shift AC left (excluding sign bit) + case 003: // rotate AC and IO left. + w := uint64(m.AC)<<18 | uint64(m.IO) + w = w<<1 | w>>35 + m.AC = Word(w>>18) & mask + m.IO = Word(w) & mask + case 005: // shift AC left (excluding sign bit) m.AC = (m.AC<<1|m.AC>>17)&mask&^sign | m.AC&sign - case 006: // shift IO left (excluding sign bit) + case 006: // shift IO left (excluding sign bit) m.IO = (m.IO<<1|m.IO>>17)&mask&^sign | m.IO&sign - case 007: // shift AC and IO left (excluding AC's sign bit) - w := uint64(m.AC)<<18 | uint64(m.IO); - w = w<<1 | w>>35; - m.AC = Word(w>>18)&mask&^sign | m.AC&sign; - m.IO = Word(w)&mask&^sign | m.AC&sign; - case 011: // rotate AC right + case 007: // shift AC and IO left (excluding AC's sign bit) + w := uint64(m.AC)<<18 | uint64(m.IO) + w = w<<1 | w>>35 + m.AC = Word(w>>18)&mask&^sign | m.AC&sign + m.IO = Word(w)&mask&^sign | m.AC&sign + case 011: // rotate AC right m.AC = (m.AC>>1 | m.AC<<17) & mask - case 012: // rotate IO right + case 012: // rotate IO right m.IO = (m.IO>>1 | m.IO<<17) & mask - case 013: // rotate AC and IO right - w := uint64(m.AC)<<18 | uint64(m.IO); - w = w>>1 | w<<35; - m.AC = Word(w>>18) & mask; - m.IO = Word(w) & mask; - case 015: // shift AC right (excluding sign bit) + case 013: // rotate AC and IO right + w := uint64(m.AC)<<18 | uint64(m.IO) + w = w>>1 | w<<35 + m.AC = Word(w>>18) & mask + m.IO = Word(w) & mask + case 015: // shift AC right (excluding sign bit) m.AC = m.AC>>1 | m.AC&sign - case 016: // shift IO right (excluding sign bit) + case 016: // shift IO right (excluding sign bit) m.IO = m.IO>>1 | m.IO&sign - case 017: // shift AC and IO right (excluding AC's sign bit) - w := uint64(m.AC)<<18 | uint64(m.IO); - w = w >> 1; - m.AC = Word(w>>18) | m.AC&sign; - m.IO = Word(w) & mask; + case 017: // shift AC and IO right (excluding AC's sign bit) + w := uint64(m.AC)<<18 | uint64(m.IO) + w = w >> 1 + m.AC = Word(w>>18) | m.AC&sign + m.IO = Word(w) & mask default: goto Unknown } @@ -332,8 +332,8 @@ func (m *M) run(inst Word, t Trapper) os.Error { m.AC ^= mask } if y&0400 == 0400 { - m.PC--; - return HaltError(m.PC); + m.PC-- + return HaltError(m.PC) } switch i, f := y&7, y&010 == 010; { case i == 7: @@ -347,43 +347,43 @@ func (m *M) run(inst Word, t Trapper) os.Error { Unknown: return UnknownInstrError{inst, m.PC - 1} } - return nil; + return nil } // Load loads the machine's memory from a text input file // listing octal address-value pairs, one per line, matching the // regular expression ^[ +]([0-7]+)\t([0-7]+). func (m *M) Load(r io.Reader) os.Error { - b := bufio.NewReader(r); + b := bufio.NewReader(r) for { - line, err := b.ReadString('\n'); + line, err := b.ReadString('\n') if err != nil { if err != os.EOF { return err } - break; + break } // look for ^[ +]([0-9]+)\t([0-9]+) if line[0] != ' ' && line[0] != '+' { continue } - i := 1; - a := Word(0); + i := 1 + a := Word(0) for ; i < len(line) && '0' <= line[i] && line[i] <= '7'; i++ { a = a*8 + Word(line[i]-'0') } if i >= len(line) || line[i] != '\t' || i == 1 { continue } - v := Word(0); - j := i; + v := Word(0) + j := i for i++; i < len(line) && '0' <= line[i] && line[i] <= '7'; i++ { v = v*8 + Word(line[i]-'0') } if i == j { continue } - m.Mem[a] = v; + m.Mem[a] = v } - return nil; + return nil } diff --git a/src/pkg/exp/spacewar/spacewar.go b/src/pkg/exp/spacewar/spacewar.go index 40976a420..a86aa7f24 100644 --- a/src/pkg/exp/spacewar/spacewar.go +++ b/src/pkg/exp/spacewar/spacewar.go @@ -24,36 +24,36 @@ package main import ( - "bytes"; - "exp/draw"; - "exp/nacl/av"; - "exp/nacl/srpc"; - "image"; - "log"; - "os"; - "runtime"; - "strings"; - "time"; - "./pdp1"; + "bytes" + "exp/draw" + "exp/nacl/av" + "exp/nacl/srpc" + "image" + "log" + "os" + "runtime" + "strings" + "time" + "./pdp1" ) func main() { - runtime.LockOSThread(); + runtime.LockOSThread() if srpc.Enabled() { go srpc.ServeRuntime() } - w, err := av.Init(av.SubsystemVideo, 512, 512); + w, err := av.Init(av.SubsystemVideo, 512, 512) if err != nil { log.Exitf("av.Init: %s", err) } - go quitter(w.QuitChan()); + go quitter(w.QuitChan()) - var m SpacewarPDP1; - m.Init(w); - m.PC = 4; - f := bytes.NewBuffer(strings.Bytes(spacewarCode)); + var m SpacewarPDP1 + m.Init(w) + m.PC = 4 + f := bytes.NewBuffer(strings.Bytes(spacewarCode)) if err = m.Load(f); err != nil { log.Exitf("loading %s: %s", "spacewar.lst", err) } @@ -63,12 +63,12 @@ func main() { // m.Mem[m.PC], m.AC, m.IO, m.OV); err = m.Step() } - log.Exitf("step: %s", err); + log.Exitf("step: %s", err) } func quitter(c <-chan bool) { - <-c; - os.Exit(0); + <-c + os.Exit(0) } // A SpacewarPDP1 is a PDP-1 machine configured to run Spacewar! @@ -76,49 +76,49 @@ func quitter(c <-chan bool) { // display and pauses every second time the program counter reaches // instruction 02051. type SpacewarPDP1 struct { - pdp1.M; - nframe int; - frameTime int64; - ctxt draw.Context; - dx, dy int; - screen draw.Image; - ctl pdp1.Word; - kc <-chan int; - colorModel image.ColorModel; - cmap []image.Color; - pix [][]uint8; + pdp1.M + nframe int + frameTime int64 + ctxt draw.Context + dx, dy int + screen draw.Image + ctl pdp1.Word + kc <-chan int + colorModel image.ColorModel + cmap []image.Color + pix [][]uint8 } func min(a, b int) int { if a < b { return a } - return b; + return b } func (m *SpacewarPDP1) Init(ctxt draw.Context) { - m.ctxt = ctxt; - m.kc = ctxt.KeyboardChan(); - m.screen = ctxt.Screen(); - m.dx = m.screen.Width(); - m.dy = m.screen.Height(); - m.colorModel = m.screen.ColorModel(); - m.pix = make([][]uint8, m.dy); + m.ctxt = ctxt + m.kc = ctxt.KeyboardChan() + m.screen = ctxt.Screen() + m.dx = m.screen.Width() + m.dy = m.screen.Height() + m.colorModel = m.screen.ColorModel() + m.pix = make([][]uint8, m.dy) for i := range m.pix { m.pix[i] = make([]uint8, m.dx) } - m.cmap = make([]image.Color, 256); + m.cmap = make([]image.Color, 256) for i := range m.cmap { - var r, g, b uint8; - r = uint8(min(0, 255)); - g = uint8(min(i*2, 255)); - b = uint8(min(0, 255)); - m.cmap[i] = m.colorModel.Convert(image.RGBAColor{r, g, b, 0xff}); + var r, g, b uint8 + r = uint8(min(0, 255)) + g = uint8(min(i*2, 255)) + b = uint8(min(0, 255)) + m.cmap[i] = m.colorModel.Convert(image.RGBAColor{r, g, b, 0xff}) } } const ( - frameDelay = 56 * 1e6; // 56 ms + frameDelay = 56 * 1e6 // 56 ms ) var ctlBits = [...]pdp1.Word{ @@ -134,35 +134,35 @@ var ctlBits = [...]pdp1.Word{ func (m *SpacewarPDP1) Step() os.Error { if m.PC == 02051 { - m.pollInput(); - m.nframe++; + m.pollInput() + m.nframe++ if m.nframe&1 == 0 { - m.flush(); - t := time.Nanoseconds(); + m.flush() + t := time.Nanoseconds() if t >= m.frameTime+3*frameDelay { m.frameTime = t } else { - m.frameTime += frameDelay; + m.frameTime += frameDelay for t < m.frameTime { - time.Sleep(m.frameTime - t); - t = time.Nanoseconds(); + time.Sleep(m.frameTime - t) + t = time.Nanoseconds() } } } } - return m.M.Step(m); + return m.M.Step(m) } func (m *SpacewarPDP1) Trap(y pdp1.Word) { switch y & 077 { case 7: - x := int(m.AC+0400000) & 0777777; - y := int(m.IO+0400000) & 0777777; - x = x * m.dx / 0777777; - y = y * m.dy / 0777777; + x := int(m.AC+0400000) & 0777777 + y := int(m.IO+0400000) & 0777777 + x = x * m.dx / 0777777 + y = y * m.dy / 0777777 if 0 <= x && x < m.dx && 0 <= y && y < m.dy { - n := uint8(min(int(m.pix[y][x])+128, 255)); - m.pix[y][x] = n; + n := uint8(min(int(m.pix[y][x])+128, 255)) + m.pix[y][x] = n } case 011: m.IO = m.ctl @@ -173,11 +173,11 @@ func (m *SpacewarPDP1) flush() { // Update screen image; simulate phosphor decay. for y := 0; y < m.dy; y++ { for x := 0; x < m.dx; x++ { - m.screen.Set(x, y, m.cmap[m.pix[y][x]]); - m.pix[y][x] >>= 1; + m.screen.Set(x, y, m.cmap[m.pix[y][x]]) + m.pix[y][x] >>= 1 } } - m.ctxt.FlushImage(); + m.ctxt.FlushImage() } func (m *SpacewarPDP1) pollInput() { diff --git a/src/pkg/expvar/expvar.go b/src/pkg/expvar/expvar.go index 3a2e74b26..b8f9bae5d 100644 --- a/src/pkg/expvar/expvar.go +++ b/src/pkg/expvar/expvar.go @@ -8,89 +8,89 @@ package expvar import ( - "bytes"; - "fmt"; - "http"; - "log"; - "strconv"; - "sync"; + "bytes" + "fmt" + "http" + "log" + "strconv" + "sync" ) // Var is an abstract type for all exported variables. type Var interface { - String() string; + String() string } // Int is a 64-bit integer variable, and satisfies the Var interface. type Int struct { - i int64; - mu sync.Mutex; + i int64 + mu sync.Mutex } -func (v *Int) String() string { return strconv.Itoa64(v.i) } +func (v *Int) String() string { return strconv.Itoa64(v.i) } func (v *Int) Add(delta int64) { - v.mu.Lock(); - defer v.mu.Unlock(); - v.i += delta; + v.mu.Lock() + defer v.mu.Unlock() + v.i += delta } // Map is a string-to-Var map variable, and satisfies the Var interface. type Map struct { - m map[string]Var; - mu sync.Mutex; + m map[string]Var + mu sync.Mutex } // KeyValue represents a single entry in a Map. type KeyValue struct { - Key string; - Value Var; + Key string + Value Var } func (v *Map) String() string { - v.mu.Lock(); - defer v.mu.Unlock(); - b := new(bytes.Buffer); - fmt.Fprintf(b, "{"); - first := true; + v.mu.Lock() + defer v.mu.Unlock() + b := new(bytes.Buffer) + fmt.Fprintf(b, "{") + first := true for key, val := range v.m { if !first { fmt.Fprintf(b, ", ") } - fmt.Fprintf(b, "\"%s\": %v", key, val.String()); - first = false; + fmt.Fprintf(b, "\"%s\": %v", key, val.String()) + first = false } - fmt.Fprintf(b, "}"); - return b.String(); + fmt.Fprintf(b, "}") + return b.String() } func (v *Map) Init() *Map { - v.m = make(map[string]Var); - return v; + v.m = make(map[string]Var) + return v } func (v *Map) Get(key string) Var { - v.mu.Lock(); - defer v.mu.Unlock(); + v.mu.Lock() + defer v.mu.Unlock() if av, ok := v.m[key]; ok { return av } - return nil; + return nil } func (v *Map) Set(key string, av Var) { - v.mu.Lock(); - defer v.mu.Unlock(); - v.m[key] = av; + v.mu.Lock() + defer v.mu.Unlock() + v.m[key] = av } func (v *Map) Add(key string, delta int64) { - v.mu.Lock(); - defer v.mu.Unlock(); - av, ok := v.m[key]; + v.mu.Lock() + defer v.mu.Unlock() + av, ok := v.m[key] if !ok { - av = new(Int); - v.m[key] = av; + av = new(Int) + v.m[key] = av } // Add to Int; ignore otherwise. @@ -104,29 +104,29 @@ func (v *Map) iterate(c chan<- KeyValue) { for k, v := range v.m { c <- KeyValue{k, v} } - close(c); + close(c) } func (v *Map) Iter() <-chan KeyValue { - c := make(chan KeyValue); - go v.iterate(c); - return c; + c := make(chan KeyValue) + go v.iterate(c) + return c } // String is a string variable, and satisfies the Var interface. type String struct { - s string; + s string } -func (v *String) String() string { return strconv.Quote(v.s) } +func (v *String) String() string { return strconv.Quote(v.s) } -func (v *String) Set(value string) { v.s = value } +func (v *String) Set(value string) { v.s = value } // IntFunc wraps a func() int64 to create a value that satisfies the Var interface. // The function will be called each time the Var is evaluated. type IntFunc func() int64 -func (v IntFunc) String() string { return strconv.Itoa64(v()) } +func (v IntFunc) String() string { return strconv.Itoa64(v()) } // All published variables. @@ -137,12 +137,12 @@ var mutex sync.Mutex // package's init function when it creates its Vars. If the name is already // registered then this will log.Crash. func Publish(name string, v Var) { - mutex.Lock(); - defer mutex.Unlock(); + mutex.Lock() + defer mutex.Unlock() if _, existing := vars[name]; existing { log.Crash("Reuse of exported var name:", name) } - vars[name] = v; + vars[name] = v } // Get retrieves a named exported variable. @@ -150,35 +150,35 @@ func Get(name string) Var { if v, ok := vars[name]; ok { return v } - return nil; + return nil } // RemoveAll removes all exported variables. // This is for tests; don't call this on a real server. func RemoveAll() { - mutex.Lock(); - defer mutex.Unlock(); - vars = make(map[string]Var); + mutex.Lock() + defer mutex.Unlock() + vars = make(map[string]Var) } // Convenience functions for creating new exported variables. func NewInt(name string) *Int { - v := new(Int); - Publish(name, v); - return v; + v := new(Int) + Publish(name, v) + return v } func NewMap(name string) *Map { - v := new(Map).Init(); - Publish(name, v); - return v; + v := new(Map).Init() + Publish(name, v) + return v } func NewString(name string) *String { - v := new(String); - Publish(name, v); - return v; + v := new(String) + Publish(name, v) + return v } // TODO(rsc): Make sure map access in separate thread is safe. @@ -186,27 +186,27 @@ func iterate(c chan<- KeyValue) { for k, v := range vars { c <- KeyValue{k, v} } - close(c); + close(c) } func Iter() <-chan KeyValue { - c := make(chan KeyValue); - go iterate(c); - return c; + c := make(chan KeyValue) + go iterate(c) + return c } func expvarHandler(c *http.Conn, req *http.Request) { - c.SetHeader("content-type", "application/json; charset=utf-8"); - fmt.Fprintf(c, "{\n"); - first := true; + c.SetHeader("content-type", "application/json; charset=utf-8") + fmt.Fprintf(c, "{\n") + first := true for name, value := range vars { if !first { fmt.Fprintf(c, ",\n") } - first = false; - fmt.Fprintf(c, " %q: %s", name, value); + first = false + fmt.Fprintf(c, " %q: %s", name, value) } - fmt.Fprintf(c, "\n}\n"); + fmt.Fprintf(c, "\n}\n") } -func init() { http.Handle("/debug/vars", http.HandlerFunc(expvarHandler)) } +func init() { http.Handle("/debug/vars", http.HandlerFunc(expvarHandler)) } diff --git a/src/pkg/expvar/expvar_test.go b/src/pkg/expvar/expvar_test.go index e64bdc2cc..51930eb1d 100644 --- a/src/pkg/expvar/expvar_test.go +++ b/src/pkg/expvar/expvar_test.go @@ -5,12 +5,12 @@ package expvar import ( - "json"; - "testing"; + "json" + "testing" ) func TestInt(t *testing.T) { - reqs := NewInt("requests"); + reqs := NewInt("requests") if reqs.i != 0 { t.Errorf("reqs.i = %v, want 4", reqs.i) } @@ -18,8 +18,8 @@ func TestInt(t *testing.T) { t.Errorf("Get() failed.") } - reqs.Add(1); - reqs.Add(3); + reqs.Add(1) + reqs.Add(3) if reqs.i != 4 { t.Errorf("reqs.i = %v, want 4", reqs.i) } @@ -30,12 +30,12 @@ func TestInt(t *testing.T) { } func TestString(t *testing.T) { - name := NewString("my-name"); + name := NewString("my-name") if name.s != "" { t.Errorf("name.s = %q, want \"\"", name.s) } - name.Set("Mike"); + name.Set("Mike") if name.s != "Mike" { t.Errorf("name.s = %q, want \"Mike\"", name.s) } @@ -46,11 +46,11 @@ func TestString(t *testing.T) { } func TestMapCounter(t *testing.T) { - colours := NewMap("bike-shed-colours"); + colours := NewMap("bike-shed-colours") - colours.Add("red", 1); - colours.Add("red", 2); - colours.Add("blue", 4); + colours.Add("red", 1) + colours.Add("red", 2) + colours.Add("blue", 4) if x := colours.m["red"].(*Int).i; x != 3 { t.Errorf("colours.m[\"red\"] = %v, want 3", x) } @@ -60,17 +60,17 @@ func TestMapCounter(t *testing.T) { // colours.String() should be '{"red":3, "blue":4}', // though the order of red and blue could vary. - s := colours.String(); - j, err := json.Decode(s); + s := colours.String() + j, err := json.Decode(s) if err != nil { t.Errorf("colours.String() isn't valid JSON: %v", err) } - m, ok := j.(map[string]interface{}); + m, ok := j.(map[string]interface{}) if !ok { t.Error("colours.String() didn't produce a map.") } - red := m["red"]; - x, ok := red.(float64); + red := m["red"] + x, ok := red.(float64) if !ok { t.Error("red.Kind() is not a number.") } @@ -80,13 +80,13 @@ func TestMapCounter(t *testing.T) { } func TestIntFunc(t *testing.T) { - x := int(4); - ix := IntFunc(func() int64 { return int64(x) }); + x := int(4) + ix := IntFunc(func() int64 { return int64(x) }) if s := ix.String(); s != "4" { t.Errorf("ix.String() = %v, want 4", s) } - x++; + x++ if s := ix.String(); s != "5" { t.Errorf("ix.String() = %v, want 5", s) } diff --git a/src/pkg/flag/flag.go b/src/pkg/flag/flag.go index 86a3b3dc1..d57a59c03 100644 --- a/src/pkg/flag/flag.go +++ b/src/pkg/flag/flag.go @@ -48,9 +48,9 @@ package flag import ( - "fmt"; - "os"; - "strconv"; + "fmt" + "os" + "strconv" ) // TODO(r): BUG: atob belongs elsewhere @@ -61,171 +61,171 @@ func atob(str string) (value bool, ok bool) { case "0", "f", "F", "false", "FALSE", "False": return false, true } - return false, false; + return false, false } // -- Bool Value type boolValue struct { - p *bool; + p *bool } func newBoolValue(val bool, p *bool) *boolValue { - *p = val; - return &boolValue{p}; + *p = val + return &boolValue{p} } func (b *boolValue) set(s string) bool { - v, ok := atob(s); - *b.p = v; - return ok; + v, ok := atob(s) + *b.p = v + return ok } -func (b *boolValue) String() string { return fmt.Sprintf("%v", *b.p) } +func (b *boolValue) String() string { return fmt.Sprintf("%v", *b.p) } // -- Int Value type intValue struct { - p *int; + p *int } func newIntValue(val int, p *int) *intValue { - *p = val; - return &intValue{p}; + *p = val + return &intValue{p} } func (i *intValue) set(s string) bool { - v, err := strconv.Atoi(s); - *i.p = int(v); - return err == nil; + v, err := strconv.Atoi(s) + *i.p = int(v) + return err == nil } -func (i *intValue) String() string { return fmt.Sprintf("%v", *i.p) } +func (i *intValue) String() string { return fmt.Sprintf("%v", *i.p) } // -- Int64 Value type int64Value struct { - p *int64; + p *int64 } func newInt64Value(val int64, p *int64) *int64Value { - *p = val; - return &int64Value{p}; + *p = val + return &int64Value{p} } func (i *int64Value) set(s string) bool { - v, err := strconv.Atoi64(s); - *i.p = v; - return err == nil; + v, err := strconv.Atoi64(s) + *i.p = v + return err == nil } -func (i *int64Value) String() string { return fmt.Sprintf("%v", *i.p) } +func (i *int64Value) String() string { return fmt.Sprintf("%v", *i.p) } // -- Uint Value type uintValue struct { - p *uint; + p *uint } func newUintValue(val uint, p *uint) *uintValue { - *p = val; - return &uintValue{p}; + *p = val + return &uintValue{p} } func (i *uintValue) set(s string) bool { - v, err := strconv.Atoui(s); - *i.p = uint(v); - return err == nil; + v, err := strconv.Atoui(s) + *i.p = uint(v) + return err == nil } -func (i *uintValue) String() string { return fmt.Sprintf("%v", *i.p) } +func (i *uintValue) String() string { return fmt.Sprintf("%v", *i.p) } // -- uint64 Value type uint64Value struct { - p *uint64; + p *uint64 } func newUint64Value(val uint64, p *uint64) *uint64Value { - *p = val; - return &uint64Value{p}; + *p = val + return &uint64Value{p} } func (i *uint64Value) set(s string) bool { - v, err := strconv.Atoui64(s); - *i.p = uint64(v); - return err == nil; + v, err := strconv.Atoui64(s) + *i.p = uint64(v) + return err == nil } -func (i *uint64Value) String() string { return fmt.Sprintf("%v", *i.p) } +func (i *uint64Value) String() string { return fmt.Sprintf("%v", *i.p) } // -- string Value type stringValue struct { - p *string; + p *string } func newStringValue(val string, p *string) *stringValue { - *p = val; - return &stringValue{p}; + *p = val + return &stringValue{p} } func (s *stringValue) set(val string) bool { - *s.p = val; - return true; + *s.p = val + return true } -func (s *stringValue) String() string { return fmt.Sprintf("%s", *s.p) } +func (s *stringValue) String() string { return fmt.Sprintf("%s", *s.p) } // -- Float Value type floatValue struct { - p *float; + p *float } func newFloatValue(val float, p *float) *floatValue { - *p = val; - return &floatValue{p}; + *p = val + return &floatValue{p} } func (f *floatValue) set(s string) bool { - v, err := strconv.Atof(s); - *f.p = v; - return err == nil; + v, err := strconv.Atof(s) + *f.p = v + return err == nil } -func (f *floatValue) String() string { return fmt.Sprintf("%v", *f.p) } +func (f *floatValue) String() string { return fmt.Sprintf("%v", *f.p) } // -- Float64 Value type float64Value struct { - p *float64; + p *float64 } func newFloat64Value(val float64, p *float64) *float64Value { - *p = val; - return &float64Value{p}; + *p = val + return &float64Value{p} } func (f *float64Value) set(s string) bool { - v, err := strconv.Atof64(s); - *f.p = v; - return err == nil; + v, err := strconv.Atof64(s) + *f.p = v + return err == nil } -func (f *float64Value) String() string { return fmt.Sprintf("%v", *f.p) } +func (f *float64Value) String() string { return fmt.Sprintf("%v", *f.p) } // FlagValue is the interface to the dynamic value stored in a flag. // (The default value is represented as a string.) type FlagValue interface { - String() string; - set(string) bool; + String() string + set(string) bool } // A Flag represents the state of a flag. type Flag struct { - Name string; // name as it appears on command line - Usage string; // help message - Value FlagValue; // value as set - DefValue string; // default value (as text); for usage message + Name string // name as it appears on command line + Usage string // help message + Value FlagValue // value as set + DefValue string // default value (as text); for usage message } type allFlags struct { - actual map[string]*Flag; - formal map[string]*Flag; - first_arg int; // 0 is the program name, 1 is first arg + actual map[string]*Flag + formal map[string]*Flag + first_arg int // 0 is the program name, 1 is first arg } var flags *allFlags = &allFlags{make(map[string]*Flag), make(map[string]*Flag), 1} @@ -246,74 +246,74 @@ func Visit(fn func(*Flag)) { // Lookup returns the Flag structure of the named flag, returning nil if none exists. func Lookup(name string) *Flag { - f, ok := flags.formal[name]; + f, ok := flags.formal[name] if !ok { return nil } - return f; + return f } // Set sets the value of the named flag. It returns true if the set succeeded; false if // there is no such flag defined. func Set(name, value string) bool { - f, ok := flags.formal[name]; + f, ok := flags.formal[name] if !ok { return false } - ok = f.Value.set(value); + ok = f.Value.set(value) if !ok { return false } - flags.actual[name] = f; - return true; + flags.actual[name] = f + return true } // PrintDefaults prints to standard error the default values of all defined flags. func PrintDefaults() { VisitAll(func(f *Flag) { - format := " -%s=%s: %s\n"; + format := " -%s=%s: %s\n" if _, ok := f.Value.(*stringValue); ok { // put quotes on the value format = " -%s=%q: %s\n" } - fmt.Fprintf(os.Stderr, format, f.Name, f.DefValue, f.Usage); + fmt.Fprintf(os.Stderr, format, f.Name, f.DefValue, f.Usage) }) } // Usage prints to standard error a default usage message documenting all defined flags. // The function is a variable that may be changed to point to a custom function. var Usage = func() { - fmt.Fprintf(os.Stderr, "Usage of %s:\n", os.Args[0]); - PrintDefaults(); + fmt.Fprintf(os.Stderr, "Usage of %s:\n", os.Args[0]) + PrintDefaults() } -func NFlag() int { return len(flags.actual) } +func NFlag() int { return len(flags.actual) } // Arg returns the i'th command-line argument. Arg(0) is the first remaining argument // after flags have been processed. func Arg(i int) string { - i += flags.first_arg; + i += flags.first_arg if i < 0 || i >= len(os.Args) { return "" } - return os.Args[i]; + return os.Args[i] } // NArg is the number of arguments remaining after flags have been processed. -func NArg() int { return len(os.Args) - flags.first_arg } +func NArg() int { return len(os.Args) - flags.first_arg } // Args returns the non-flag command-line arguments. -func Args() []string { return os.Args[flags.first_arg:] } +func Args() []string { return os.Args[flags.first_arg:] } func add(name string, value FlagValue, usage string) { // Remember the default value as a string; it won't change. - f := &Flag{name, usage, value, value.String()}; - _, alreadythere := flags.formal[name]; + f := &Flag{name, usage, value, value.String()} + _, alreadythere := flags.formal[name] if alreadythere { - fmt.Fprintln(os.Stderr, "flag redefined:", name); - panic("flag redefinition"); // Happens only if flags are declared with identical names + fmt.Fprintln(os.Stderr, "flag redefined:", name) + panic("flag redefinition") // Happens only if flags are declared with identical names } - flags.formal[name] = f; + flags.formal[name] = f } // BoolVar defines a bool flag with specified name, default value, and usage string. @@ -325,9 +325,9 @@ func BoolVar(p *bool, name string, value bool, usage string) { // Bool defines a bool flag with specified name, default value, and usage string. // The return value is the address of a bool variable that stores the value of the flag. func Bool(name string, value bool, usage string) *bool { - p := new(bool); - BoolVar(p, name, value, usage); - return p; + p := new(bool) + BoolVar(p, name, value, usage) + return p } // IntVar defines an int flag with specified name, default value, and usage string. @@ -339,9 +339,9 @@ func IntVar(p *int, name string, value int, usage string) { // Int defines an int flag with specified name, default value, and usage string. // The return value is the address of an int variable that stores the value of the flag. func Int(name string, value int, usage string) *int { - p := new(int); - IntVar(p, name, value, usage); - return p; + p := new(int) + IntVar(p, name, value, usage) + return p } // Int64Var defines an int64 flag with specified name, default value, and usage string. @@ -353,9 +353,9 @@ func Int64Var(p *int64, name string, value int64, usage string) { // Int64 defines an int64 flag with specified name, default value, and usage string. // The return value is the address of an int64 variable that stores the value of the flag. func Int64(name string, value int64, usage string) *int64 { - p := new(int64); - Int64Var(p, name, value, usage); - return p; + p := new(int64) + Int64Var(p, name, value, usage) + return p } // UintVar defines a uint flag with specified name, default value, and usage string. @@ -367,9 +367,9 @@ func UintVar(p *uint, name string, value uint, usage string) { // Uint defines a uint flag with specified name, default value, and usage string. // The return value is the address of a uint variable that stores the value of the flag. func Uint(name string, value uint, usage string) *uint { - p := new(uint); - UintVar(p, name, value, usage); - return p; + p := new(uint) + UintVar(p, name, value, usage) + return p } // Uint64Var defines a uint64 flag with specified name, default value, and usage string. @@ -381,9 +381,9 @@ func Uint64Var(p *uint64, name string, value uint64, usage string) { // Uint64 defines a uint64 flag with specified name, default value, and usage string. // The return value is the address of a uint64 variable that stores the value of the flag. func Uint64(name string, value uint64, usage string) *uint64 { - p := new(uint64); - Uint64Var(p, name, value, usage); - return p; + p := new(uint64) + Uint64Var(p, name, value, usage) + return p } // StringVar defines a string flag with specified name, default value, and usage string. @@ -395,9 +395,9 @@ func StringVar(p *string, name, value string, usage string) { // String defines a string flag with specified name, default value, and usage string. // The return value is the address of a string variable that stores the value of the flag. func String(name, value string, usage string) *string { - p := new(string); - StringVar(p, name, value, usage); - return p; + p := new(string) + StringVar(p, name, value, usage) + return p } // FloatVar defines a float flag with specified name, default value, and usage string. @@ -409,9 +409,9 @@ func FloatVar(p *float, name string, value float, usage string) { // Float defines a float flag with specified name, default value, and usage string. // The return value is the address of a float variable that stores the value of the flag. func Float(name string, value float, usage string) *float { - p := new(float); - FloatVar(p, name, value, usage); - return p; + p := new(float) + FloatVar(p, name, value, usage) + return p } // Float64Var defines a float64 flag with specified name, default value, and usage string. @@ -423,68 +423,68 @@ func Float64Var(p *float64, name string, value float64, usage string) { // Float64 defines a float64 flag with specified name, default value, and usage string. // The return value is the address of a float64 variable that stores the value of the flag. func Float64(name string, value float64, usage string) *float64 { - p := new(float64); - Float64Var(p, name, value, usage); - return p; + p := new(float64) + Float64Var(p, name, value, usage) + return p } func (f *allFlags) parseOne(index int) (ok bool, next int) { - s := os.Args[index]; - f.first_arg = index; // until proven otherwise + s := os.Args[index] + f.first_arg = index // until proven otherwise if len(s) == 0 { return false, -1 } if s[0] != '-' { return false, -1 } - num_minuses := 1; + num_minuses := 1 if len(s) == 1 { return false, index } if s[1] == '-' { - num_minuses++; - if len(s) == 2 { // "--" terminates the flags + num_minuses++ + if len(s) == 2 { // "--" terminates the flags return false, index + 1 } } - name := s[num_minuses:]; + name := s[num_minuses:] if len(name) == 0 || name[0] == '-' || name[0] == '=' { - fmt.Fprintln(os.Stderr, "bad flag syntax:", s); - Usage(); - os.Exit(2); + fmt.Fprintln(os.Stderr, "bad flag syntax:", s) + Usage() + os.Exit(2) } // it's a flag. does it have an argument? - has_value := false; - value := ""; - for i := 1; i < len(name); i++ { // equals cannot be first + has_value := false + value := "" + for i := 1; i < len(name); i++ { // equals cannot be first if name[i] == '=' { - value = name[i+1:]; - has_value = true; - name = name[0:i]; - break; + value = name[i+1:] + has_value = true + name = name[0:i] + break } } - flag, alreadythere := flags.actual[name]; + flag, alreadythere := flags.actual[name] if alreadythere { - fmt.Fprintf(os.Stderr, "flag specified twice: -%s\n", name); - Usage(); - os.Exit(2); + fmt.Fprintf(os.Stderr, "flag specified twice: -%s\n", name) + Usage() + os.Exit(2) } - m := flags.formal; - flag, alreadythere = m[name]; // BUG + m := flags.formal + flag, alreadythere = m[name] // BUG if !alreadythere { - fmt.Fprintf(os.Stderr, "flag provided but not defined: -%s\n", name); - Usage(); - os.Exit(2); + fmt.Fprintf(os.Stderr, "flag provided but not defined: -%s\n", name) + Usage() + os.Exit(2) } - if f, ok := flag.Value.(*boolValue); ok { // special case: doesn't need an arg + if f, ok := flag.Value.(*boolValue); ok { // special case: doesn't need an arg if has_value { if !f.set(value) { - fmt.Fprintf(os.Stderr, "invalid boolean value %t for flag: -%s\n", value, name); - Usage(); - os.Exit(2); + fmt.Fprintf(os.Stderr, "invalid boolean value %t for flag: -%s\n", value, name) + Usage() + os.Exit(2) } } else { f.set("true") @@ -493,34 +493,34 @@ func (f *allFlags) parseOne(index int) (ok bool, next int) { // It must have a value, which might be the next argument. if !has_value && index < len(os.Args)-1 { // value is the next arg - has_value = true; - index++; - value = os.Args[index]; + has_value = true + index++ + value = os.Args[index] } if !has_value { - fmt.Fprintf(os.Stderr, "flag needs an argument: -%s\n", name); - Usage(); - os.Exit(2); + fmt.Fprintf(os.Stderr, "flag needs an argument: -%s\n", name) + Usage() + os.Exit(2) } - ok = flag.Value.set(value); + ok = flag.Value.set(value) if !ok { - fmt.Fprintf(os.Stderr, "invalid value %s for flag: -%s\n", value, name); - Usage(); - os.Exit(2); + fmt.Fprintf(os.Stderr, "invalid value %s for flag: -%s\n", value, name) + Usage() + os.Exit(2) } } - flags.actual[name] = flag; - return true, index + 1; + flags.actual[name] = flag + return true, index + 1 } // Parse parses the command-line flags. Must be called after all flags are defined // and before any are accessed by the program. func Parse() { for i := 1; i < len(os.Args); { - ok, next := flags.parseOne(i); + ok, next := flags.parseOne(i) if next > 0 { - flags.first_arg = next; - i = next; + flags.first_arg = next + i = next } if !ok { break diff --git a/src/pkg/flag/flag_test.go b/src/pkg/flag/flag_test.go index 0acfc2f96..d6e642b2b 100644 --- a/src/pkg/flag/flag_test.go +++ b/src/pkg/flag/flag_test.go @@ -5,35 +5,35 @@ package flag_test import ( - . "flag"; - "testing"; + . "flag" + "testing" ) var ( - test_bool = Bool("test_bool", false, "bool value"); - test_int = Int("test_int", 0, "int value"); - test_int64 = Int64("test_int64", 0, "int64 value"); - test_uint = Uint("test_uint", 0, "uint value"); - test_uint64 = Uint64("test_uint64", 0, "uint64 value"); - test_string = String("test_string", "0", "string value"); - test_float = Float("test_float", 0, "float value"); - test_float64 = Float("test_float64", 0, "float64 value"); + test_bool = Bool("test_bool", false, "bool value") + test_int = Int("test_int", 0, "int value") + test_int64 = Int64("test_int64", 0, "int64 value") + test_uint = Uint("test_uint", 0, "uint value") + test_uint64 = Uint64("test_uint64", 0, "uint64 value") + test_string = String("test_string", "0", "string value") + test_float = Float("test_float", 0, "float value") + test_float64 = Float("test_float64", 0, "float64 value") ) func boolString(s string) string { if s == "0" { return "false" } - return "true"; + return "true" } func TestEverything(t *testing.T) { - m := make(map[string]*Flag); - desired := "0"; + m := make(map[string]*Flag) + desired := "0" visitor := func(f *Flag) { if len(f.Name) > 5 && f.Name[0:5] == "test_" { - m[f.Name] = f; - ok := false; + m[f.Name] = f + ok := false switch { case f.Value.String() == desired: ok = true @@ -44,35 +44,35 @@ func TestEverything(t *testing.T) { t.Error("Visit: bad value", f.Value.String(), "for", f.Name) } } - }; - VisitAll(visitor); + } + VisitAll(visitor) if len(m) != 8 { - t.Error("VisitAll misses some flags"); + t.Error("VisitAll misses some flags") for k, v := range m { t.Log(k, *v) } } - m = make(map[string]*Flag); - Visit(visitor); + m = make(map[string]*Flag) + Visit(visitor) if len(m) != 0 { - t.Errorf("Visit sees unset flags"); + t.Errorf("Visit sees unset flags") for k, v := range m { t.Log(k, *v) } } // Now set all flags - Set("test_bool", "true"); - Set("test_int", "1"); - Set("test_int64", "1"); - Set("test_uint", "1"); - Set("test_uint64", "1"); - Set("test_string", "1"); - Set("test_float", "1"); - Set("test_float64", "1"); - desired = "1"; - Visit(visitor); + Set("test_bool", "true") + Set("test_int", "1") + Set("test_int64", "1") + Set("test_uint", "1") + Set("test_uint64", "1") + Set("test_string", "1") + Set("test_float", "1") + Set("test_float64", "1") + desired = "1" + Visit(visitor) if len(m) != 8 { - t.Error("Visit fails after set"); + t.Error("Visit fails after set") for k, v := range m { t.Log(k, *v) } diff --git a/src/pkg/fmt/fmt_test.go b/src/pkg/fmt/fmt_test.go index 51a159ff1..78d4cf29a 100644 --- a/src/pkg/fmt/fmt_test.go +++ b/src/pkg/fmt/fmt_test.go @@ -5,27 +5,27 @@ package fmt_test import ( - . "fmt"; - "io"; - "malloc"; // for the malloc count test only - "math"; - "strings"; - "testing"; + . "fmt" + "io" + "malloc" // for the malloc count test only + "math" + "strings" + "testing" ) func TestFmtInterface(t *testing.T) { var i1 interface{} - i1 = "abc"; - s := Sprintf("%s", i1); + i1 = "abc" + s := Sprintf("%s", i1) if s != "abc" { t.Errorf(`Sprintf("%%s", empty("abc")) = %q want %q`, s, "abc") } } type fmtTest struct { - fmt string; - val interface{}; - out string; + fmt string + val interface{} + out string } const b32 uint32 = 1<<32 - 1 @@ -35,24 +35,24 @@ var array = []int{1, 2, 3, 4, 5} var iarray = []interface{}{1, "hello", 2.5, nil} type A struct { - i int; - j uint; - s string; - x []int; + i int + j uint + s string + x []int } type I int -func (i I) String() string { return Sprintf("<%d>", i) } +func (i I) String() string { return Sprintf("<%d>", i) } type B struct { - i I; - j int; + i I + j int } type C struct { - i int; - B; + i int + B } var b byte @@ -228,16 +228,16 @@ var fmttests = []fmtTest{ func TestSprintf(t *testing.T) { for _, tt := range fmttests { - s := Sprintf(tt.fmt, tt.val); + s := Sprintf(tt.fmt, tt.val) if i := strings.Index(s, "0x"); i >= 0 && strings.Index(tt.out, "PTR") >= 0 { - j := i + 2; + j := i + 2 for ; j < len(s); j++ { - c := s[j]; + c := s[j] if (c < '0' || c > '9') && (c < 'a' || c > 'f') { break } } - s = s[0:i] + "PTR" + s[j:]; + s = s[0:i] + "PTR" + s[j:] } if s != tt.out { if _, ok := tt.val.(string); ok { @@ -276,36 +276,36 @@ func BenchmarkSprintfIntInt(b *testing.B) { } func TestCountMallocs(t *testing.T) { - mallocs := 0 - malloc.GetStats().Mallocs; + mallocs := 0 - malloc.GetStats().Mallocs for i := 0; i < 100; i++ { Sprintf("") } - mallocs += malloc.GetStats().Mallocs; - Printf("mallocs per Sprintf(\"\"): %d\n", mallocs/100); - mallocs = 0 - malloc.GetStats().Mallocs; + mallocs += malloc.GetStats().Mallocs + Printf("mallocs per Sprintf(\"\"): %d\n", mallocs/100) + mallocs = 0 - malloc.GetStats().Mallocs for i := 0; i < 100; i++ { Sprintf("xxx") } - mallocs += malloc.GetStats().Mallocs; - Printf("mallocs per Sprintf(\"xxx\"): %d\n", mallocs/100); - mallocs = 0 - malloc.GetStats().Mallocs; + mallocs += malloc.GetStats().Mallocs + Printf("mallocs per Sprintf(\"xxx\"): %d\n", mallocs/100) + mallocs = 0 - malloc.GetStats().Mallocs for i := 0; i < 100; i++ { Sprintf("%x", i) } - mallocs += malloc.GetStats().Mallocs; - Printf("mallocs per Sprintf(\"%%x\"): %d\n", mallocs/100); - mallocs = 0 - malloc.GetStats().Mallocs; + mallocs += malloc.GetStats().Mallocs + Printf("mallocs per Sprintf(\"%%x\"): %d\n", mallocs/100) + mallocs = 0 - malloc.GetStats().Mallocs for i := 0; i < 100; i++ { Sprintf("%x %x", i, i) } - mallocs += malloc.GetStats().Mallocs; - Printf("mallocs per Sprintf(\"%%x %%x\"): %d\n", mallocs/100); + mallocs += malloc.GetStats().Mallocs + Printf("mallocs per Sprintf(\"%%x %%x\"): %d\n", mallocs/100) } type flagPrinter struct{} func (*flagPrinter) Format(f State, c int) { - s := "%"; + s := "%" for i := 0; i < 128; i++ { if f.Flag(i) { s += string(i) @@ -317,13 +317,13 @@ func (*flagPrinter) Format(f State, c int) { if p, ok := f.Precision(); ok { s += Sprintf(".%d", p) } - s += string(c); - io.WriteString(f, "["+s+"]"); + s += string(c) + io.WriteString(f, "["+s+"]") } type flagTest struct { - in string; - out string; + in string + out string } var flagtests = []flagTest{ @@ -342,9 +342,9 @@ var flagtests = []flagTest{ } func TestFlagParser(t *testing.T) { - var flagprinter flagPrinter; + var flagprinter flagPrinter for _, tt := range flagtests { - s := Sprintf(tt.in, &flagprinter); + s := Sprintf(tt.in, &flagprinter) if s != tt.out { t.Errorf("Sprintf(%q, &flagprinter) => %q, want %q", tt.in, s, tt.out) } @@ -353,23 +353,23 @@ func TestFlagParser(t *testing.T) { func TestStructPrinter(t *testing.T) { var s struct { - a string; - b string; - c int; + a string + b string + c int } - s.a = "abc"; - s.b = "def"; - s.c = 123; + s.a = "abc" + s.b = "def" + s.c = 123 type Test struct { - fmt string; - out string; + fmt string + out string } var tests = []Test{ Test{"%v", "{abc def 123}"}, Test{"%+v", "{a:abc b:def c:123}"}, - }; + } for _, tt := range tests { - out := Sprintf(tt.fmt, s); + out := Sprintf(tt.fmt, s) if out != tt.out { t.Errorf("Sprintf(%q, &s) = %q, want %q", tt.fmt, out, tt.out) } @@ -379,12 +379,12 @@ func TestStructPrinter(t *testing.T) { // Check map printing using substrings so we don't depend on the print order. func presentInMap(s string, a []string, t *testing.T) { for i := 0; i < len(a); i++ { - loc := strings.Index(s, a[i]); + loc := strings.Index(s, a[i]) if loc < 0 { t.Errorf("map print: expected to find %q in %q", a[i], s) } // make sure the match ends here - loc += len(a[i]); + loc += len(a[i]) if loc >= len(s) || (s[loc] != ' ' && s[loc] != ']') { t.Errorf("map print: %q not properly terminated in %q", a[i], s) } @@ -392,26 +392,26 @@ func presentInMap(s string, a []string, t *testing.T) { } func TestMapPrinter(t *testing.T) { - m0 := make(map[int]string); - s := Sprint(m0); + m0 := make(map[int]string) + s := Sprint(m0) if s != "map[]" { t.Errorf("empty map printed as %q not %q", s, "map[]") } - m1 := map[int]string{1: "one", 2: "two", 3: "three"}; - a := []string{"1:one", "2:two", "3:three"}; - presentInMap(Sprintf("%v", m1), a, t); - presentInMap(Sprint(m1), a, t); + m1 := map[int]string{1: "one", 2: "two", 3: "three"} + a := []string{"1:one", "2:two", "3:three"} + presentInMap(Sprintf("%v", m1), a, t) + presentInMap(Sprint(m1), a, t) } func TestEmptyMap(t *testing.T) { - const emptyMapStr = "map[]"; - var m map[string]int; - s := Sprint(m); + const emptyMapStr = "map[]" + var m map[string]int + s := Sprint(m) if s != emptyMapStr { t.Errorf("nil map printed as %q not %q", s, emptyMapStr) } - m = make(map[string]int); - s = Sprint(m); + m = make(map[string]int) + s = Sprint(m) if s != emptyMapStr { t.Errorf("empty map printed as %q not %q", s, emptyMapStr) } diff --git a/src/pkg/fmt/format.go b/src/pkg/fmt/format.go index b53bcc5a6..38b234414 100644 --- a/src/pkg/fmt/format.go +++ b/src/pkg/fmt/format.go @@ -5,20 +5,20 @@ package fmt import ( - "bytes"; - "strconv"; + "bytes" + "strconv" ) const ( - nByte = 64; + nByte = 64 - ldigits = "0123456789abcdef"; - udigits = "0123456789ABCDEF"; + ldigits = "0123456789abcdef" + udigits = "0123456789ABCDEF" ) const ( - signed = true; - unsigned = false; + signed = true + unsigned = false ) var padZeroBytes = make([]byte, nByte) @@ -28,55 +28,55 @@ var newline = []byte{'\n'} func init() { for i := 0; i < nByte; i++ { - padZeroBytes[i] = '0'; - padSpaceBytes[i] = ' '; + padZeroBytes[i] = '0' + padSpaceBytes[i] = ' ' } } // A fmt is the raw formatter used by Printf etc. // It prints into a bytes.Buffer that must be set up externally. type fmt struct { - intbuf [nByte]byte; - buf *bytes.Buffer; + intbuf [nByte]byte + buf *bytes.Buffer // width, precision - wid int; - prec int; + wid int + prec int // flags - widPresent bool; - precPresent bool; - minus bool; - plus bool; - sharp bool; - space bool; - zero bool; + widPresent bool + precPresent bool + minus bool + plus bool + sharp bool + space bool + zero bool } func (f *fmt) clearflags() { - f.wid = 0; - f.widPresent = false; - f.prec = 0; - f.precPresent = false; - f.minus = false; - f.plus = false; - f.sharp = false; - f.space = false; - f.zero = false; + f.wid = 0 + f.widPresent = false + f.prec = 0 + f.precPresent = false + f.minus = false + f.plus = false + f.sharp = false + f.space = false + f.zero = false } func (f *fmt) init(buf *bytes.Buffer) { - f.buf = buf; - f.clearflags(); + f.buf = buf + f.clearflags() } // Compute left and right padding widths (only one will be non-zero). func (f *fmt) computePadding(width int) (padding []byte, leftWidth, rightWidth int) { - left := !f.minus; - w := f.wid; + left := !f.minus + w := f.wid if w < 0 { - left = false; - w = -w; + left = false + w = -w } - w -= width; + w -= width if w > 0 { if left && f.zero { return padZeroBytes, w, 0 @@ -88,66 +88,66 @@ func (f *fmt) computePadding(width int) (padding []byte, leftWidth, rightWidth i return padSpaceBytes, 0, w } } - return; + return } // Generate n bytes of padding. func (f *fmt) writePadding(n int, padding []byte) { for n > 0 { - m := n; + m := n if m > nByte { m = nByte } - f.buf.Write(padding[0:m]); - n -= m; + f.buf.Write(padding[0:m]) + n -= m } } // Append b to f.buf, padded on left (w > 0) or right (w < 0 or f.minus) // clear flags aftewards. func (f *fmt) pad(b []byte) { - var padding []byte; - var left, right int; + var padding []byte + var left, right int if f.widPresent && f.wid != 0 { padding, left, right = f.computePadding(len(b)) } if left > 0 { f.writePadding(left, padding) } - f.buf.Write(b); + f.buf.Write(b) if right > 0 { f.writePadding(right, padding) } - f.clearflags(); + f.clearflags() } // append s to buf, padded on left (w > 0) or right (w < 0 or f.minus). // clear flags aftewards. func (f *fmt) padString(s string) { - var padding []byte; - var left, right int; + var padding []byte + var left, right int if f.widPresent && f.wid != 0 { padding, left, right = f.computePadding(len(s)) } if left > 0 { f.writePadding(left, padding) } - f.buf.WriteString(s); + f.buf.WriteString(s) if right > 0 { f.writePadding(right, padding) } - f.clearflags(); + f.clearflags() } func putint(buf []byte, base, val uint64, digits string) int { - i := len(buf) - 1; + i := len(buf) - 1 for val >= base { - buf[i] = digits[val%base]; - i--; - val /= base; + buf[i] = digits[val%base] + i-- + val /= base } - buf[i] = digits[val]; - return i - 1; + buf[i] = digits[val] + return i - 1 } // fmt_boolean formats a boolean. @@ -162,22 +162,22 @@ func (f *fmt) fmt_boolean(v bool) { // integer; interprets prec but not wid. Once formatted, result is sent to pad() // and then flags are cleared. func (f *fmt) integer(a int64, base uint64, signedness bool, digits string) { - var buf []byte = &f.intbuf; - negative := signedness == signed && a < 0; + var buf []byte = &f.intbuf + negative := signedness == signed && a < 0 if negative { a = -a } // two ways to ask for extra leading zero digits: %.3d or %03d. // apparently the first cancels the second. - prec := 0; + prec := 0 if f.precPresent { - prec = f.prec; - f.zero = false; + prec = f.prec + f.zero = false } else if f.zero && f.widPresent && !f.minus && f.wid > 0 { - prec = f.wid; + prec = f.wid if negative || f.plus || f.space { - prec-- // leave room for sign + prec-- // leave room for sign } } @@ -185,18 +185,18 @@ func (f *fmt) integer(a int64, base uint64, signedness bool, digits string) { // a is made into unsigned ua. we could make things // marginally faster by splitting the 32-bit case out into a separate // block but it's not worth the duplication, so ua has 64 bits. - i := len(f.intbuf); - ua := uint64(a); + i := len(f.intbuf) + ua := uint64(a) for ua >= base { - i--; - buf[i] = digits[ua%base]; - ua /= base; + i-- + buf[i] = digits[ua%base] + ua /= base } - i--; - buf[i] = digits[ua]; + i-- + buf[i] = digits[ua] for i > 0 && prec > nByte-i { - i--; - buf[i] = '0'; + i-- + buf[i] = '0' } // Various prefixes: 0x, -, etc. @@ -204,113 +204,113 @@ func (f *fmt) integer(a int64, base uint64, signedness bool, digits string) { switch base { case 8: if buf[i] != '0' { - i--; - buf[i] = '0'; + i-- + buf[i] = '0' } case 16: - i--; - buf[i] = 'x' + digits[10] - 'a'; - i--; - buf[i] = '0'; + i-- + buf[i] = 'x' + digits[10] - 'a' + i-- + buf[i] = '0' } } if negative { - i--; - buf[i] = '-'; + i-- + buf[i] = '-' } else if f.plus { - i--; - buf[i] = '+'; + i-- + buf[i] = '+' } else if f.space { - i--; - buf[i] = ' '; + i-- + buf[i] = ' ' } - f.pad(buf[i:]); + f.pad(buf[i:]) } // fmt_d64 formats an int64 in decimal. -func (f *fmt) fmt_d64(v int64) { f.integer(v, 10, signed, ldigits) } +func (f *fmt) fmt_d64(v int64) { f.integer(v, 10, signed, ldigits) } // fmt_d32 formats an int32 in decimal. -func (f *fmt) fmt_d32(v int32) { f.integer(int64(v), 10, signed, ldigits) } +func (f *fmt) fmt_d32(v int32) { f.integer(int64(v), 10, signed, ldigits) } // fmt_d formats an int in decimal. -func (f *fmt) fmt_d(v int) { f.integer(int64(v), 10, signed, ldigits) } +func (f *fmt) fmt_d(v int) { f.integer(int64(v), 10, signed, ldigits) } // fmt_ud64 formats a uint64 in decimal. -func (f *fmt) fmt_ud64(v uint64) { f.integer(int64(v), 10, unsigned, ldigits) } +func (f *fmt) fmt_ud64(v uint64) { f.integer(int64(v), 10, unsigned, ldigits) } // fmt_ud32 formats a uint32 in decimal. -func (f *fmt) fmt_ud32(v uint32) { f.integer(int64(v), 10, unsigned, ldigits) } +func (f *fmt) fmt_ud32(v uint32) { f.integer(int64(v), 10, unsigned, ldigits) } // fmt_ud formats a uint in decimal. -func (f *fmt) fmt_ud(v uint) { f.integer(int64(v), 10, unsigned, ldigits) } +func (f *fmt) fmt_ud(v uint) { f.integer(int64(v), 10, unsigned, ldigits) } // fmt_x64 formats an int64 in hexadecimal. -func (f *fmt) fmt_x64(v int64) { f.integer(v, 16, signed, ldigits) } +func (f *fmt) fmt_x64(v int64) { f.integer(v, 16, signed, ldigits) } // fmt_x32 formats an int32 in hexadecimal. -func (f *fmt) fmt_x32(v int32) { f.integer(int64(v), 16, signed, ldigits) } +func (f *fmt) fmt_x32(v int32) { f.integer(int64(v), 16, signed, ldigits) } // fmt_x formats an int in hexadecimal. -func (f *fmt) fmt_x(v int) { f.integer(int64(v), 16, signed, ldigits) } +func (f *fmt) fmt_x(v int) { f.integer(int64(v), 16, signed, ldigits) } // fmt_ux64 formats a uint64 in hexadecimal. -func (f *fmt) fmt_ux64(v uint64) { f.integer(int64(v), 16, unsigned, ldigits) } +func (f *fmt) fmt_ux64(v uint64) { f.integer(int64(v), 16, unsigned, ldigits) } // fmt_ux32 formats a uint32 in hexadecimal. -func (f *fmt) fmt_ux32(v uint32) { f.integer(int64(v), 16, unsigned, ldigits) } +func (f *fmt) fmt_ux32(v uint32) { f.integer(int64(v), 16, unsigned, ldigits) } // fmt_ux formats a uint in hexadecimal. -func (f *fmt) fmt_ux(v uint) { f.integer(int64(v), 16, unsigned, ldigits) } +func (f *fmt) fmt_ux(v uint) { f.integer(int64(v), 16, unsigned, ldigits) } // fmt_X64 formats an int64 in upper case hexadecimal. -func (f *fmt) fmt_X64(v int64) { f.integer(v, 16, signed, udigits) } +func (f *fmt) fmt_X64(v int64) { f.integer(v, 16, signed, udigits) } // fmt_X32 formats an int32 in upper case hexadecimal. -func (f *fmt) fmt_X32(v int32) { f.integer(int64(v), 16, signed, udigits) } +func (f *fmt) fmt_X32(v int32) { f.integer(int64(v), 16, signed, udigits) } // fmt_X formats an int in upper case hexadecimal. -func (f *fmt) fmt_X(v int) { f.integer(int64(v), 16, signed, udigits) } +func (f *fmt) fmt_X(v int) { f.integer(int64(v), 16, signed, udigits) } // fmt_uX64 formats a uint64 in upper case hexadecimal. -func (f *fmt) fmt_uX64(v uint64) { f.integer(int64(v), 16, unsigned, udigits) } +func (f *fmt) fmt_uX64(v uint64) { f.integer(int64(v), 16, unsigned, udigits) } // fmt_uX32 formats a uint32 in upper case hexadecimal. -func (f *fmt) fmt_uX32(v uint32) { f.integer(int64(v), 16, unsigned, udigits) } +func (f *fmt) fmt_uX32(v uint32) { f.integer(int64(v), 16, unsigned, udigits) } // fmt_uX formats a uint in upper case hexadecimal. -func (f *fmt) fmt_uX(v uint) { f.integer(int64(v), 16, unsigned, udigits) } +func (f *fmt) fmt_uX(v uint) { f.integer(int64(v), 16, unsigned, udigits) } // fmt_o64 formats an int64 in octal. -func (f *fmt) fmt_o64(v int64) { f.integer(v, 8, signed, ldigits) } +func (f *fmt) fmt_o64(v int64) { f.integer(v, 8, signed, ldigits) } // fmt_o32 formats an int32 in octal. -func (f *fmt) fmt_o32(v int32) { f.integer(int64(v), 8, signed, ldigits) } +func (f *fmt) fmt_o32(v int32) { f.integer(int64(v), 8, signed, ldigits) } // fmt_o formats an int in octal. -func (f *fmt) fmt_o(v int) { f.integer(int64(v), 8, signed, ldigits) } +func (f *fmt) fmt_o(v int) { f.integer(int64(v), 8, signed, ldigits) } // fmt_uo64 formats a uint64 in octal. -func (f *fmt) fmt_uo64(v uint64) { f.integer(int64(v), 8, unsigned, ldigits) } +func (f *fmt) fmt_uo64(v uint64) { f.integer(int64(v), 8, unsigned, ldigits) } // fmt_uo32 formats a uint32 in octal. -func (f *fmt) fmt_uo32(v uint32) { f.integer(int64(v), 8, unsigned, ldigits) } +func (f *fmt) fmt_uo32(v uint32) { f.integer(int64(v), 8, unsigned, ldigits) } // fmt_uo formats a uint in octal. -func (f *fmt) fmt_uo(v uint) { f.integer(int64(v), 8, unsigned, ldigits) } +func (f *fmt) fmt_uo(v uint) { f.integer(int64(v), 8, unsigned, ldigits) } // fmt_b64 formats a uint64 in binary. -func (f *fmt) fmt_b64(v uint64) { f.integer(int64(v), 2, unsigned, ldigits) } +func (f *fmt) fmt_b64(v uint64) { f.integer(int64(v), 2, unsigned, ldigits) } // fmt_b32 formats a uint32 in binary. -func (f *fmt) fmt_b32(v uint32) { f.integer(int64(v), 2, unsigned, ldigits) } +func (f *fmt) fmt_b32(v uint32) { f.integer(int64(v), 2, unsigned, ldigits) } // fmt_b formats a uint in binary. -func (f *fmt) fmt_b(v uint) { f.integer(int64(v), 2, unsigned, ldigits) } +func (f *fmt) fmt_b(v uint) { f.integer(int64(v), 2, unsigned, ldigits) } // fmt_c formats a Unicode character. -func (f *fmt) fmt_c(v int) { f.padString(string(v)) } +func (f *fmt) fmt_c(v int) { f.padString(string(v)) } // fmt_s formats a string. func (f *fmt) fmt_s(s string) { @@ -319,43 +319,43 @@ func (f *fmt) fmt_s(s string) { s = s[0:f.prec] } } - f.padString(s); + f.padString(s) } // fmt_sx formats a string as a hexadecimal encoding of its bytes. func (f *fmt) fmt_sx(s string) { - t := ""; + t := "" for i := 0; i < len(s); i++ { if i > 0 && f.space { t += " " } - v := s[i]; - t += string(ldigits[v>>4]); - t += string(ldigits[v&0xF]); + v := s[i] + t += string(ldigits[v>>4]) + t += string(ldigits[v&0xF]) } - f.padString(t); + f.padString(t) } // fmt_sX formats a string as an uppercase hexadecimal encoding of its bytes. func (f *fmt) fmt_sX(s string) { - t := ""; + t := "" for i := 0; i < len(s); i++ { - v := s[i]; - t += string(udigits[v>>4]); - t += string(udigits[v&0xF]); + v := s[i] + t += string(udigits[v>>4]) + t += string(udigits[v&0xF]) } - f.padString(t); + f.padString(t) } // fmt_q formats a string as a double-quoted, escaped Go string constant. func (f *fmt) fmt_q(s string) { - var quoted string; + var quoted string if f.sharp && strconv.CanBackquote(s) { quoted = "`" + s + "`" } else { quoted = strconv.Quote(s) } - f.padString(quoted); + f.padString(quoted) } // floating-point @@ -364,7 +364,7 @@ func doPrec(f *fmt, def int) int { if f.precPresent { return f.prec } - return def; + return def } // Add a plus sign or space to the floating-point string representation if missing and required. @@ -376,48 +376,48 @@ func (f *fmt) plusSpace(s string) { s = " " + s } } - f.padString(s); + f.padString(s) } // fmt_e64 formats a float64 in the form -1.23e+12. -func (f *fmt) fmt_e64(v float64) { f.plusSpace(strconv.Ftoa64(v, 'e', doPrec(f, 6))) } +func (f *fmt) fmt_e64(v float64) { f.plusSpace(strconv.Ftoa64(v, 'e', doPrec(f, 6))) } // fmt_E64 formats a float64 in the form -1.23E+12. -func (f *fmt) fmt_E64(v float64) { f.plusSpace(strconv.Ftoa64(v, 'E', doPrec(f, 6))) } +func (f *fmt) fmt_E64(v float64) { f.plusSpace(strconv.Ftoa64(v, 'E', doPrec(f, 6))) } // fmt_f64 formats a float64 in the form -1.23. -func (f *fmt) fmt_f64(v float64) { f.plusSpace(strconv.Ftoa64(v, 'f', doPrec(f, 6))) } +func (f *fmt) fmt_f64(v float64) { f.plusSpace(strconv.Ftoa64(v, 'f', doPrec(f, 6))) } // fmt_g64 formats a float64 in the 'f' or 'e' form according to size. -func (f *fmt) fmt_g64(v float64) { f.plusSpace(strconv.Ftoa64(v, 'g', doPrec(f, -1))) } +func (f *fmt) fmt_g64(v float64) { f.plusSpace(strconv.Ftoa64(v, 'g', doPrec(f, -1))) } // fmt_g64 formats a float64 in the 'f' or 'E' form according to size. -func (f *fmt) fmt_G64(v float64) { f.plusSpace(strconv.Ftoa64(v, 'G', doPrec(f, -1))) } +func (f *fmt) fmt_G64(v float64) { f.plusSpace(strconv.Ftoa64(v, 'G', doPrec(f, -1))) } // fmt_fb64 formats a float64 in the form -123p3 (exponent is power of 2). -func (f *fmt) fmt_fb64(v float64) { f.plusSpace(strconv.Ftoa64(v, 'b', 0)) } +func (f *fmt) fmt_fb64(v float64) { f.plusSpace(strconv.Ftoa64(v, 'b', 0)) } // float32 // cannot defer to float64 versions // because it will get rounding wrong in corner cases. // fmt_e32 formats a float32 in the form -1.23e+12. -func (f *fmt) fmt_e32(v float32) { f.plusSpace(strconv.Ftoa32(v, 'e', doPrec(f, 6))) } +func (f *fmt) fmt_e32(v float32) { f.plusSpace(strconv.Ftoa32(v, 'e', doPrec(f, 6))) } // fmt_E32 formats a float32 in the form -1.23E+12. -func (f *fmt) fmt_E32(v float32) { f.plusSpace(strconv.Ftoa32(v, 'E', doPrec(f, 6))) } +func (f *fmt) fmt_E32(v float32) { f.plusSpace(strconv.Ftoa32(v, 'E', doPrec(f, 6))) } // fmt_f32 formats a float32 in the form -1.23. -func (f *fmt) fmt_f32(v float32) { f.plusSpace(strconv.Ftoa32(v, 'f', doPrec(f, 6))) } +func (f *fmt) fmt_f32(v float32) { f.plusSpace(strconv.Ftoa32(v, 'f', doPrec(f, 6))) } // fmt_g32 formats a float32 in the 'f' or 'e' form according to size. -func (f *fmt) fmt_g32(v float32) { f.plusSpace(strconv.Ftoa32(v, 'g', doPrec(f, -1))) } +func (f *fmt) fmt_g32(v float32) { f.plusSpace(strconv.Ftoa32(v, 'g', doPrec(f, -1))) } // fmt_G32 formats a float32 in the 'f' or 'E' form according to size. -func (f *fmt) fmt_G32(v float32) { f.plusSpace(strconv.Ftoa32(v, 'G', doPrec(f, -1))) } +func (f *fmt) fmt_G32(v float32) { f.plusSpace(strconv.Ftoa32(v, 'G', doPrec(f, -1))) } // fmt_fb32 formats a float32 in the form -123p3 (exponent is power of 2). -func (f *fmt) fmt_fb32(v float32) { f.padString(strconv.Ftoa32(v, 'b', 0)) } +func (f *fmt) fmt_fb32(v float32) { f.padString(strconv.Ftoa32(v, 'b', 0)) } // float func (x *fmt) f(a float) { diff --git a/src/pkg/fmt/print.go b/src/pkg/fmt/print.go index 6fa747c29..d4ef3c62f 100644 --- a/src/pkg/fmt/print.go +++ b/src/pkg/fmt/print.go @@ -77,25 +77,25 @@ package fmt import ( - "bytes"; - "io"; - "os"; - "reflect"; - "utf8"; + "bytes" + "io" + "os" + "reflect" + "utf8" ) // Some constants in the form of bytes, to avoid string overhead. // Needlessly fastidious, I suppose. var ( - trueBytes = []byte{'t', 'r', 'u', 'e'}; - falseBytes = []byte{'f', 'a', 'l', 's', 'e'}; - commaSpaceBytes = []byte{',', ' '}; - nilAngleBytes = []byte{'<', 'n', 'i', 'l', '>'}; - nilParenBytes = []byte{'(', 'n', 'i', 'l', ')'}; - nilBytes = []byte{'n', 'i', 'l'}; - mapBytes = []byte{'m', 'a', 'p', '['}; - missingBytes = []byte{'m', 'i', 's', 's', 'i', 'n', 'g'}; - extraBytes = []byte{'?', '(', 'e', 'x', 't', 'r', 'a', ' '}; + trueBytes = []byte{'t', 'r', 'u', 'e'} + falseBytes = []byte{'f', 'a', 'l', 's', 'e'} + commaSpaceBytes = []byte{',', ' '} + nilAngleBytes = []byte{'<', 'n', 'i', 'l', '>'} + nilParenBytes = []byte{'(', 'n', 'i', 'l', ')'} + nilBytes = []byte{'n', 'i', 'l'} + mapBytes = []byte{'m', 'a', 'p', '['} + missingBytes = []byte{'m', 'i', 's', 's', 'i', 'n', 'g'} + extraBytes = []byte{'?', '(', 'e', 'x', 't', 'r', 'a', ' '} ) // State represents the printer state passed to custom formatters. @@ -103,21 +103,21 @@ var ( // the flags and options for the operand's format specifier. type State interface { // Write is the function to call to emit formatted output to be printed. - Write(b []byte) (ret int, err os.Error); + Write(b []byte) (ret int, err os.Error) // Width returns the value of the width option and whether it has been set. - Width() (wid int, ok bool); + Width() (wid int, ok bool) // Precision returns the value of the precision option and whether it has been set. - Precision() (prec int, ok bool); + Precision() (prec int, ok bool) // Flag returns whether the flag c, a character, has been set. - Flag(int) bool; + Flag(int) bool } // Formatter is the interface implemented by values with a custom formatter. // The implementation of Format may call Sprintf or Fprintf(f) etc. // to generate its output. type Formatter interface { - Format(f State, c int); + Format(f State, c int) } // Stringer is implemented by any value that has a String method(), @@ -125,7 +125,7 @@ type Formatter interface { // The String method is used to print values passed as an operand // to a %s or %v format or to an unformatted printer such as Print. type Stringer interface { - String() string; + String() string } // GoStringer is implemented by any value that has a GoString() method, @@ -133,16 +133,16 @@ type Stringer interface { // The GoString method is used to print values passed as an operand // to a %#v format. type GoStringer interface { - GoString() string; + GoString() string } const allocSize = 32 type pp struct { - n int; - buf bytes.Buffer; - runeBuf [utf8.UTFMax]byte; - fmt fmt; + n int + buf bytes.Buffer + runeBuf [utf8.UTFMax]byte + fmt fmt } // A leaky bucket of reusable pp structures. @@ -150,12 +150,12 @@ var ppFree = make(chan *pp, 100) // Allocate a new pp struct. Probably can grab the previous one from ppFree. func newPrinter() *pp { - p, ok := <-ppFree; + p, ok := <-ppFree if !ok { p = new(pp) } - p.fmt.init(&p.buf); - return p; + p.fmt.init(&p.buf) + return p } // Save used pp structs in ppFree; avoids an allocation per invocation. @@ -164,13 +164,13 @@ func (p *pp) free() { if cap(p.buf.Bytes()) > 1024 { return } - p.buf.Reset(); - _ = ppFree <- p; + p.buf.Reset() + _ = ppFree <- p } -func (p *pp) Width() (wid int, ok bool) { return p.fmt.wid, p.fmt.widPresent } +func (p *pp) Width() (wid int, ok bool) { return p.fmt.wid, p.fmt.widPresent } -func (p *pp) Precision() (prec int, ok bool) { return p.fmt.prec, p.fmt.precPresent } +func (p *pp) Precision() (prec int, ok bool) { return p.fmt.prec, p.fmt.precPresent } func (p *pp) Flag(b int) bool { switch b { @@ -185,15 +185,15 @@ func (p *pp) Flag(b int) bool { case '0': return p.fmt.zero } - return false; + return false } func (p *pp) add(c int) { if c < utf8.RuneSelf { p.buf.WriteByte(byte(c)) } else { - w := utf8.EncodeRune(c, &p.runeBuf); - p.buf.Write(p.runeBuf[0:w]); + w := utf8.EncodeRune(c, &p.runeBuf) + p.buf.Write(p.runeBuf[0:w]) } } @@ -207,28 +207,28 @@ func (p *pp) Write(b []byte) (ret int, err os.Error) { // Fprintf formats according to a format specifier and writes to w. func Fprintf(w io.Writer, format string, a ...) (n int, error os.Error) { - v := reflect.NewValue(a).(*reflect.StructValue); - p := newPrinter(); - p.doprintf(format, v); - n64, error := p.buf.WriteTo(w); - p.free(); - return int(n64), error; + v := reflect.NewValue(a).(*reflect.StructValue) + p := newPrinter() + p.doprintf(format, v) + n64, error := p.buf.WriteTo(w) + p.free() + return int(n64), error } // Printf formats according to a format specifier and writes to standard output. func Printf(format string, v ...) (n int, errno os.Error) { - n, errno = Fprintf(os.Stdout, format, v); - return n, errno; + n, errno = Fprintf(os.Stdout, format, v) + return n, errno } // Sprintf formats according to a format specifier and returns the resulting string. func Sprintf(format string, a ...) string { - v := reflect.NewValue(a).(*reflect.StructValue); - p := newPrinter(); - p.doprintf(format, v); - s := p.buf.String(); - p.free(); - return s; + v := reflect.NewValue(a).(*reflect.StructValue) + p := newPrinter() + p.doprintf(format, v) + s := p.buf.String() + p.free() + return s } // These routines do not take a format string @@ -236,30 +236,30 @@ func Sprintf(format string, a ...) string { // Fprint formats using the default formats for its operands and writes to w. // Spaces are added between operands when neither is a string. func Fprint(w io.Writer, a ...) (n int, error os.Error) { - v := reflect.NewValue(a).(*reflect.StructValue); - p := newPrinter(); - p.doprint(v, false, false); - n64, error := p.buf.WriteTo(w); - p.free(); - return int(n64), error; + v := reflect.NewValue(a).(*reflect.StructValue) + p := newPrinter() + p.doprint(v, false, false) + n64, error := p.buf.WriteTo(w) + p.free() + return int(n64), error } // Print formats using the default formats for its operands and writes to standard output. // Spaces are added between operands when neither is a string. func Print(v ...) (n int, errno os.Error) { - n, errno = Fprint(os.Stdout, v); - return n, errno; + n, errno = Fprint(os.Stdout, v) + return n, errno } // Sprint formats using the default formats for its operands and returns the resulting string. // Spaces are added between operands when neither is a string. func Sprint(a ...) string { - v := reflect.NewValue(a).(*reflect.StructValue); - p := newPrinter(); - p.doprint(v, false, false); - s := p.buf.String(); - p.free(); - return s; + v := reflect.NewValue(a).(*reflect.StructValue) + p := newPrinter() + p.doprint(v, false, false) + s := p.buf.String() + p.free() + return s } // These routines end in 'ln', do not take a format string, @@ -269,30 +269,30 @@ func Sprint(a ...) string { // Fprintln formats using the default formats for its operands and writes to w. // Spaces are always added between operands and a newline is appended. func Fprintln(w io.Writer, a ...) (n int, error os.Error) { - v := reflect.NewValue(a).(*reflect.StructValue); - p := newPrinter(); - p.doprint(v, true, true); - n64, error := p.buf.WriteTo(w); - p.free(); - return int(n64), error; + v := reflect.NewValue(a).(*reflect.StructValue) + p := newPrinter() + p.doprint(v, true, true) + n64, error := p.buf.WriteTo(w) + p.free() + return int(n64), error } // Println formats using the default formats for its operands and writes to standard output. // Spaces are always added between operands and a newline is appended. func Println(v ...) (n int, errno os.Error) { - n, errno = Fprintln(os.Stdout, v); - return n, errno; + n, errno = Fprintln(os.Stdout, v) + return n, errno } // Sprintln formats using the default formats for its operands and returns the resulting string. // Spaces are always added between operands and a newline is appended. func Sprintln(a ...) string { - v := reflect.NewValue(a).(*reflect.StructValue); - p := newPrinter(); - p.doprint(v, true, true); - s := p.buf.String(); - p.free(); - return s; + v := reflect.NewValue(a).(*reflect.StructValue) + p := newPrinter() + p.doprint(v, true, true) + s := p.buf.String() + p.free() + return s } @@ -300,13 +300,13 @@ func Sprintln(a ...) string { // If the arg itself is an interface, return a value for // the thing inside the interface, not the interface itself. func getField(v *reflect.StructValue, i int) reflect.Value { - val := v.Field(i); + val := v.Field(i) if i, ok := val.(*reflect.InterfaceValue); ok { if inter := i.Interface(); inter != nil { return reflect.NewValue(inter) } } - return val; + return val } // Getters for the fields of the argument structure. @@ -315,7 +315,7 @@ func getBool(v reflect.Value) (val bool, ok bool) { if b, ok := v.(*reflect.BoolValue); ok { return b.Get(), true } - return; + return } func getInt(v reflect.Value) (val int64, signed, ok bool) { @@ -343,7 +343,7 @@ func getInt(v reflect.Value) (val int64, signed, ok bool) { case *reflect.UintptrValue: return int64(v.Get()), false, true } - return; + return } func getString(v reflect.Value) (val string, ok bool) { @@ -353,7 +353,7 @@ func getString(v reflect.Value) (val string, ok bool) { if bytes, ok := v.Interface().([]byte); ok { return string(bytes), true } - return; + return } func getFloat32(v reflect.Value) (val float32, ok bool) { @@ -365,7 +365,7 @@ func getFloat32(v reflect.Value) (val float32, ok bool) { return float32(v.Get()), true } } - return; + return } func getFloat64(v reflect.Value) (val float64, ok bool) { @@ -377,7 +377,7 @@ func getFloat64(v reflect.Value) (val float64, ok bool) { case *reflect.Float64Value: return float64(v.Get()), true } - return; + return } func getPtr(v reflect.Value) (val uintptr, ok bool) { @@ -385,7 +385,7 @@ func getPtr(v reflect.Value) (val uintptr, ok bool) { case *reflect.PtrValue: return uintptr(v.Get()), true } - return; + return } // Convert ASCII to integer. n is 0 (and got is false) if no number present. @@ -394,33 +394,33 @@ func parsenum(s string, start, end int) (n int, got bool, newi int) { if start >= end { return 0, false, end } - isnum := false; - num := 0; + isnum := false + num := 0 for '0' <= s[start] && s[start] <= '9' { - num = num*10 + int(s[start]-'0'); - start++; - isnum = true; + num = num*10 + int(s[start]-'0') + start++ + isnum = true } - return num, isnum, start; + return num, isnum, start } type uintptrGetter interface { - Get() uintptr; + Get() uintptr } func (p *pp) printField(field reflect.Value, plus, sharp bool, depth int) (was_string bool) { - inter := field.Interface(); + inter := field.Interface() if inter != nil { switch { default: if stringer, ok := inter.(Stringer); ok { - p.buf.WriteString(stringer.String()); - return false; // this value is not a string + p.buf.WriteString(stringer.String()) + return false // this value is not a string } case sharp: if stringer, ok := inter.(GoStringer); ok { - p.buf.WriteString(stringer.GoString()); - return false; // this value is not a string + p.buf.WriteString(stringer.GoString()) + return false // this value is not a string } } } @@ -442,17 +442,17 @@ BigSwitch: if sharp { p.fmt.fmt_q(f.Get()) } else { - p.fmt.fmt_s(f.Get()); - was_string = true; + p.fmt.fmt_s(f.Get()) + was_string = true } case *reflect.MapValue: if sharp { - p.buf.WriteString(field.Type().String()); - p.buf.WriteByte('{'); + p.buf.WriteString(field.Type().String()) + p.buf.WriteByte('{') } else { p.buf.Write(mapBytes) } - keys := f.Keys(); + keys := f.Keys() for i, key := range keys { if i > 0 { if sharp { @@ -461,9 +461,9 @@ BigSwitch: p.buf.WriteByte(' ') } } - p.printField(key, plus, sharp, depth+1); - p.buf.WriteByte(':'); - p.printField(f.Elem(key), plus, sharp, depth+1); + p.printField(key, plus, sharp, depth+1) + p.buf.WriteByte(':') + p.printField(f.Elem(key), plus, sharp, depth+1) } if sharp { p.buf.WriteByte('}') @@ -474,10 +474,10 @@ BigSwitch: if sharp { p.buf.WriteString(field.Type().String()) } - p.add('{'); - v := f; - t := v.Type().(*reflect.StructType); - p.fmt.clearflags(); // clear flags for p.printField + p.add('{') + v := f + t := v.Type().(*reflect.StructType) + p.fmt.clearflags() // clear flags for p.printField for i := 0; i < v.NumField(); i++ { if i > 0 { if sharp { @@ -488,19 +488,19 @@ BigSwitch: } if plus || sharp { if f := t.Field(i); f.Name != "" { - p.buf.WriteString(f.Name); - p.buf.WriteByte(':'); + p.buf.WriteString(f.Name) + p.buf.WriteByte(':') } } - p.printField(getField(v, i), plus, sharp, depth+1); + p.printField(getField(v, i), plus, sharp, depth+1) } - p.buf.WriteByte('}'); + p.buf.WriteByte('}') case *reflect.InterfaceValue: - value := f.Elem(); + value := f.Elem() if value == nil { if sharp { - p.buf.WriteString(field.Type().String()); - p.buf.Write(nilParenBytes); + p.buf.WriteString(field.Type().String()) + p.buf.Write(nilParenBytes) } else { p.buf.Write(nilAngleBytes) } @@ -509,8 +509,8 @@ BigSwitch: } case reflect.ArrayOrSliceValue: if sharp { - p.buf.WriteString(field.Type().String()); - p.buf.WriteByte('{'); + p.buf.WriteString(field.Type().String()) + p.buf.WriteByte('{') } else { p.buf.WriteByte('[') } @@ -522,7 +522,7 @@ BigSwitch: p.buf.WriteByte(' ') } } - p.printField(f.Elem(i), plus, sharp, depth+1); + p.printField(f.Elem(i), plus, sharp, depth+1) } if sharp { p.buf.WriteByte('}') @@ -530,99 +530,99 @@ BigSwitch: p.buf.WriteByte(']') } case *reflect.PtrValue: - v := f.Get(); + v := f.Get() // pointer to array or slice or struct? ok at top level // but not embedded (avoid loops) if v != 0 && depth == 0 { switch a := f.Elem().(type) { case reflect.ArrayOrSliceValue: - p.buf.WriteByte('&'); - p.printField(a, plus, sharp, depth+1); - break BigSwitch; + p.buf.WriteByte('&') + p.printField(a, plus, sharp, depth+1) + break BigSwitch case *reflect.StructValue: - p.buf.WriteByte('&'); - p.printField(a, plus, sharp, depth+1); - break BigSwitch; + p.buf.WriteByte('&') + p.printField(a, plus, sharp, depth+1) + break BigSwitch } } if sharp { - p.buf.WriteByte('('); - p.buf.WriteString(field.Type().String()); - p.buf.WriteByte(')'); - p.buf.WriteByte('('); + p.buf.WriteByte('(') + p.buf.WriteString(field.Type().String()) + p.buf.WriteByte(')') + p.buf.WriteByte('(') if v == 0 { p.buf.Write(nilBytes) } else { - p.fmt.sharp = true; - p.fmt.fmt_ux64(uint64(v)); + p.fmt.sharp = true + p.fmt.fmt_ux64(uint64(v)) } - p.buf.WriteByte(')'); - break; + p.buf.WriteByte(')') + break } if v == 0 { - p.buf.Write(nilAngleBytes); - break; + p.buf.Write(nilAngleBytes) + break } - p.fmt.sharp = true; // turn 0x on - p.fmt.fmt_ux64(uint64(v)); + p.fmt.sharp = true // turn 0x on + p.fmt.fmt_ux64(uint64(v)) case uintptrGetter: - v := f.Get(); + v := f.Get() if sharp { - p.buf.WriteByte('('); - p.buf.WriteString(field.Type().String()); - p.buf.WriteByte(')'); - p.buf.WriteByte('('); + p.buf.WriteByte('(') + p.buf.WriteString(field.Type().String()) + p.buf.WriteByte(')') + p.buf.WriteByte('(') if v == 0 { p.buf.Write(nilBytes) } else { - p.fmt.sharp = true; - p.fmt.fmt_ux64(uint64(v)); + p.fmt.sharp = true + p.fmt.fmt_ux64(uint64(v)) } - p.buf.WriteByte(')'); + p.buf.WriteByte(')') } else { - p.fmt.sharp = true; // turn 0x on - p.fmt.fmt_ux64(uint64(f.Get())); + p.fmt.sharp = true // turn 0x on + p.fmt.fmt_ux64(uint64(f.Get())) } default: - v, signed, ok := getInt(field); + v, signed, ok := getInt(field) if ok { if signed { p.fmt.fmt_d64(v) } else { if sharp { - p.fmt.sharp = true; // turn on 0x - p.fmt.fmt_ux64(uint64(v)); + p.fmt.sharp = true // turn on 0x + p.fmt.fmt_ux64(uint64(v)) } else { p.fmt.fmt_ud64(uint64(v)) } } - break; + break } - p.buf.WriteByte('?'); - p.buf.WriteString(field.Type().String()); - p.buf.WriteByte('?'); + p.buf.WriteByte('?') + p.buf.WriteString(field.Type().String()) + p.buf.WriteByte('?') } - return was_string; + return was_string } func (p *pp) doprintf(format string, v *reflect.StructValue) { - end := len(format) - 1; - fieldnum := 0; // we process one field per non-trivial format + end := len(format) - 1 + fieldnum := 0 // we process one field per non-trivial format for i := 0; i <= end; { - c, w := utf8.DecodeRuneInString(format[i:]); + c, w := utf8.DecodeRuneInString(format[i:]) if c != '%' || i == end { if w == 1 { p.buf.WriteByte(byte(c)) } else { p.buf.WriteString(format[i : i+w]) } - i += w; - continue; + i += w + continue } - i++; + i++ // flags and widths - p.fmt.clearflags(); - F: for ; i < end; i++ { + p.fmt.clearflags() + F: for ; i < end; i++ { switch format[i] { case '#': p.fmt.sharp = true @@ -639,34 +639,34 @@ func (p *pp) doprintf(format string, v *reflect.StructValue) { } } // do we have 20 (width)? - p.fmt.wid, p.fmt.widPresent, i = parsenum(format, i, end); + p.fmt.wid, p.fmt.widPresent, i = parsenum(format, i, end) // do we have .20 (precision)? if i < end && format[i] == '.' { p.fmt.prec, p.fmt.precPresent, i = parsenum(format, i+1, end) } - c, w = utf8.DecodeRuneInString(format[i:]); - i += w; + c, w = utf8.DecodeRuneInString(format[i:]) + i += w // percent is special - absorbs no operand if c == '%' { - p.buf.WriteByte('%'); // TODO: should we bother with width & prec? - continue; + p.buf.WriteByte('%') // TODO: should we bother with width & prec? + continue } - if fieldnum >= v.NumField() { // out of operands - p.buf.WriteByte('%'); - p.add(c); - p.buf.Write(missingBytes); - continue; + if fieldnum >= v.NumField() { // out of operands + p.buf.WriteByte('%') + p.add(c) + p.buf.Write(missingBytes) + continue } - field := getField(v, fieldnum); - fieldnum++; + field := getField(v, fieldnum) + fieldnum++ // Try formatter except for %T, // which is special and handled internally. - inter := field.Interface(); + inter := field.Interface() if inter != nil && c != 'T' { if formatter, ok := inter.(Formatter); ok { - formatter.Format(p, c); - continue; + formatter.Format(p, c) + continue } } @@ -686,7 +686,7 @@ func (p *pp) doprintf(format string, v *reflect.StructValue) { // int case 'b': if v, _, ok := getInt(field); ok { - p.fmt.fmt_b64(uint64(v)) // always unsigned + p.fmt.fmt_b64(uint64(v)) // always unsigned } else if v, ok := getFloat32(field); ok { p.fmt.fmt_fb32(v) } else if v, ok := getFloat64(field); ok { @@ -792,8 +792,8 @@ func (p *pp) doprintf(format string, v *reflect.StructValue) { if inter != nil { // if object implements String, use the result. if stringer, ok := inter.(Stringer); ok { - p.fmt.fmt_s(stringer.String()); - break; + p.fmt.fmt_s(stringer.String()) + break } } if v, ok := getString(field); ok { @@ -814,8 +814,8 @@ func (p *pp) doprintf(format string, v *reflect.StructValue) { if v == 0 { p.buf.Write(nilAngleBytes) } else { - p.fmt.fmt_s("0x"); - p.fmt.fmt_uX64(uint64(v)); + p.fmt.fmt_s("0x") + p.fmt.fmt_uX64(uint64(v)) } } else { goto badtype @@ -823,10 +823,10 @@ func (p *pp) doprintf(format string, v *reflect.StructValue) { // arbitrary value; do your best case 'v': - plus, sharp := p.fmt.plus, p.fmt.sharp; - p.fmt.plus = false; - p.fmt.sharp = false; - p.printField(field, plus, sharp, 0); + plus, sharp := p.fmt.plus, p.fmt.sharp + p.fmt.plus = false + p.fmt.sharp = false + p.printField(field, plus, sharp, 0) // the value's type case 'T': @@ -834,42 +834,42 @@ func (p *pp) doprintf(format string, v *reflect.StructValue) { default: badtype: - p.buf.WriteByte('%'); - p.add(c); - p.buf.WriteByte('('); - p.buf.WriteString(field.Type().String()); - p.buf.WriteByte('='); - p.printField(field, false, false, 0); - p.buf.WriteByte(')'); + p.buf.WriteByte('%') + p.add(c) + p.buf.WriteByte('(') + p.buf.WriteString(field.Type().String()) + p.buf.WriteByte('=') + p.printField(field, false, false, 0) + p.buf.WriteByte(')') } } if fieldnum < v.NumField() { - p.buf.Write(extraBytes); + p.buf.Write(extraBytes) for ; fieldnum < v.NumField(); fieldnum++ { - field := getField(v, fieldnum); - p.buf.WriteString(field.Type().String()); - p.buf.WriteByte('='); - p.printField(field, false, false, 0); + field := getField(v, fieldnum) + p.buf.WriteString(field.Type().String()) + p.buf.WriteByte('=') + p.printField(field, false, false, 0) if fieldnum+1 < v.NumField() { p.buf.Write(commaSpaceBytes) } } - p.buf.WriteByte(')'); + p.buf.WriteByte(')') } } func (p *pp) doprint(v *reflect.StructValue, addspace, addnewline bool) { - prev_string := false; + prev_string := false for fieldnum := 0; fieldnum < v.NumField(); fieldnum++ { // always add spaces if we're doing println - field := getField(v, fieldnum); + field := getField(v, fieldnum) if fieldnum > 0 { - _, is_string := field.(*reflect.StringValue); + _, is_string := field.(*reflect.StringValue) if addspace || !is_string && !prev_string { p.buf.WriteByte(' ') } } - prev_string = p.printField(field, false, false, 0); + prev_string = p.printField(field, false, false, 0) } if addnewline { p.buf.WriteByte('\n') |