The new comparison rule was added to the spec by
changeset: 5605:33abb649cb63
user: Robert Griesemer <gri@golang.org>
date: Thu Jun 03 16:55:50 2010 -0700
files: doc/go_spec.html
description:
go spec: Base comparison compatibility on assignment compatibility.
Specifically:
- Simplified definition of comparison compatibility and folded into
section on comparison operators since it's only used there.
This is a small language change/cleanup. As a consequence:
- An interface value may now be compared against a non-interface value.
- Channels with opposite directions cannot be compared directly anymore
(per discussion with rsc).
R=rsc, r, iant, ken2
CC=golang-dev
https://golang.org/cl/1462041
but never implemented.
Fixes#1070.
R=ken2
CC=golang-dev
https://golang.org/cl/2116047
This test is supposed to test runtime behaviour. However,
gccgo is smart enough to see that the variables are local to
the package and that they never change. Add a function so
that gccgo thinks that the variables can in fact vary, so that
the test works at runtime as expected.
R=rsc
CC=golang-dev
https://golang.org/cl/2178041
The gccgo compiler does not always generate a "cannot use"
error message. It only does so for named types. Maybe that
should change, but in any case it is irrelevant for this test.
assign1.go:105:4: error: incompatible types in assignment (cannot use type A1 as type A)
assign1.go:107:5: error: incompatible types in assignment (cannot use type A as type A1)
assign1.go:112:4: error: incompatible types in assignment (cannot use type B1 as type B)
assign1.go:114:5: error: incompatible types in assignment (cannot use type B as type B1)
assign1.go:119:4: error: incompatible types in assignment (cannot use type C1 as type C)
assign1.go:121:5: error: incompatible types in assignment (cannot use type C as type C1)
assign1.go:126:4: error: incompatible types in assignment (cannot use type F1 as type F)
assign1.go:128:5: error: incompatible types in assignment (cannot use type F as type F1)
assign1.go:140:4: error: incompatible types in assignment (cannot use type M1 as type M)
assign1.go:142:5: error: incompatible types in assignment (cannot use type M as type M1)
assign1.go:147:4: error: incompatible types in assignment (cannot use type P1 as type P)
assign1.go:149:5: error: incompatible types in assignment (cannot use type P as type P1)
assign1.go:154:4: error: incompatible types in assignment (cannot use type S1 as type S)
assign1.go:156:5: error: incompatible types in assignment (cannot use type S as type S1)
assign1.go:158:6: error: incompatible types in assignment
assign1.go:159:6: error: incompatible types in assignment
assign1.go:160:5: error: incompatible types in assignment
assign1.go:161:5: error: incompatible types in assignment
assign1.go:162:6: error: incompatible types in assignment
assign1.go:163:6: error: incompatible types in assignment
assign1.go:165:6: error: incompatible types in assignment
assign1.go:166:6: error: incompatible types in assignment
assign1.go:167:5: error: incompatible types in assignment
assign1.go:168:5: error: incompatible types in assignment
assign1.go:169:6: error: incompatible types in assignment
assign1.go:170:6: error: incompatible types in assignment
assign1.go:172:6: error: incompatible types in assignment
assign1.go:173:6: error: incompatible types in assignment
assign1.go:174:5: error: incompatible types in assignment
assign1.go:175:5: error: incompatible types in assignment
assign1.go:176:6: error: incompatible types in assignment
assign1.go:177:6: error: incompatible types in assignment
assign1.go:179:6: error: incompatible types in assignment
assign1.go:180:6: error: incompatible types in assignment
assign1.go:181:5: error: incompatible types in assignment
assign1.go:182:5: error: incompatible types in assignment
assign1.go:183:6: error: incompatible types in assignment
assign1.go:184:6: error: incompatible types in assignment
assign1.go:186:6: error: incompatible types in assignment
assign1.go:187:6: error: incompatible types in assignment
assign1.go:188:5: error: incompatible types in assignment
assign1.go:189:5: error: incompatible types in assignment
assign1.go:190:6: error: incompatible types in assignment
assign1.go:191:6: error: incompatible types in assignment
assign1.go:193:6: error: incompatible types in assignment
assign1.go:194:6: error: incompatible types in assignment
assign1.go:195:5: error: incompatible types in assignment
assign1.go:196:5: error: incompatible types in assignment
assign1.go:197:6: error: incompatible types in assignment
assign1.go:198:6: error: incompatible types in assignment
assign1.go:200:6: error: incompatible types in assignment
assign1.go:201:6: error: incompatible types in assignment
assign1.go:202:5: error: incompatible types in assignment
assign1.go:203:5: error: incompatible types in assignment
assign1.go:204:6: error: incompatible types in assignment
assign1.go:205:6: error: incompatible types in assignment
assign1.go:207:6: error: incompatible types in assignment
assign1.go:208:6: error: incompatible types in assignment
assign1.go:209:5: error: incompatible types in assignment
assign1.go:210:5: error: incompatible types in assignment
assign1.go:211:6: error: incompatible types in assignment
assign1.go:212:6: error: incompatible types in assignment
R=rsc
CC=golang-dev
https://golang.org/cl/2163044
The gccgo library generates some garbage in the init routines
because it handles interfaces slightly differently. Since the
test sets MemStats.Alloc to 0, the first time the garbage
collector runs it goes negative and the test fails.
R=rsc, r2
CC=golang-dev
https://golang.org/cl/2110044
nonblock.go wants to test nonblocking operations on
synchronous channels, so it is inherently racy. This
introduces loops to make the race conditions much more likely
to succeed when using gccgo.
R=r
CC=golang-dev
https://golang.org/cl/2161043
gccgo does not handle 'new' specially here.
varerr.go:10:6: error: reference to undefined name ‘asdf’
varerr.go:12:6: error: invalid left hand side of assignment
R=rsc
CC=golang-dev
https://golang.org/cl/2139045
undef.go:12:6: error: reference to undefined name ‘x’
undef.go:13:6: error: reference to undefined name ‘x’
undef.go:14:6: error: reference to undefined name ‘x’
undef.go:22:25: error: reference to undefined name ‘y’
undef.go:42:11: error: reference to undefined name ‘v’
R=rsc
CC=golang-dev
https://golang.org/cl/2152045
vareq.go:10:25: error: expected ';' or '}' or newline
vareq1.go:9:24: error: expected ';' or newline after top level declaration
R=rsc
CC=golang-dev
https://golang.org/cl/2132045
With the recursive descent parser that gccgo uses, I think
that it doesn't make sense to try to match a statement where a
statement is not expected. If the construct is not a
statement, you will just get bizarre error messages.
topexpr.go:9:1: error: expected declaration
topexpr.go:14:1: error: expected declaration
topexpr.go:19:1: error: expected declaration
R=rsc, r2
CC=golang-dev
https://golang.org/cl/2175041
named1.go:40:11: error: argument 1 has incompatible type (cannot use type bool as type Bool)
named1.go:41:11: error: argument 1 has incompatible type (cannot use type bool as type Bool)
named1.go:43:7: error: incompatible types in assignment (cannot use type bool as type Bool)
named1.go:44:12: error: argument 4 has incompatible type (cannot use type Bool as type bool)
named1.go:46:4: error: incompatible types in assignment (cannot use type bool as type Bool)
named1.go:48:11: error: argument 1 has incompatible type (cannot use type bool as type Bool)
named1.go:50:7: error: incompatible types in assignment (cannot use type bool as type Bool)
named1.go:54:7: error: incompatible types in assignment (cannot use type bool as type Bool)
named1.go:60:7: error: incompatible types in assignment (cannot use type bool as type Bool)
named1.go:63:9: error: argument 1 has incompatible type (cannot use type bool as type Bool)
named1.go:64:4: error: incompatible types in assignment (cannot use type bool as type Bool)
named1.go:67:17: error: invalid type conversion (cannot use type Slice as type String)
R=rsc
CC=golang-dev
https://golang.org/cl/2146044
explicit.go:36:4: error: incompatible types in assignment (need explicit conversion)
explicit.go:41:4: error: incompatible types in assignment (type has no methods)
explicit.go:42:4: error: incompatible types in assignment (need explicit conversion)
explicit.go:45:5: error: incompatible types in assignment (need explicit conversion; missing method ‘N’)
explicit.go:48:9: error: invalid type conversion (need explicit conversion; missing method ‘N’)
explicit.go:51:4: error: incompatible types in assignment
explicit.go:51:7: error: invalid type conversion (need explicit conversion)
explicit.go:57:10: error: impossible type assertion: type does not implement interface (type has no methods)
explicit.go:62:10: error: impossible type assertion: type does not implement interface (incompatible type for method ‘M’ (different number of parameters))
explicit.go:67:5: error: incompatible type in initialization (type has no methods)
explicit.go:68:5: error: incompatible type in initialization (incompatible type for method ‘M’ (different number of parameters))
explicit.go:70:11: error: invalid type conversion (type has no methods)
explicit.go:71:11: error: invalid type conversion (incompatible type for method ‘M’ (different number of parameters))
R=rsc
CC=golang-dev
https://golang.org/cl/2139044
bug299.go:16:2: error: expected field name
bug299.go:17:2: error: expected field name
bug299.go:18:3: error: expected field name
bug299.go:25:9: error: expected receiver name or type
bug299.go:26:10: error: expected receiver name or type
bug299.go:27:9: error: expected receiver name or type
R=rsc
CC=golang-dev
https://golang.org/cl/2150044
Solves the (English) peg solitaire game. The board is represented
by a 1-dimensional array for easy representation of directions
with a single integer. The board's contents are chosen such that
it can be printed with a direct string() conversion.
R=r
CC=adg, golang-dev
https://golang.org/cl/2066042
bug284.go:33: error: invalid type conversion
bug284.go:36: error: invalid type conversion (cannot use type A2 as type A1)
bug284.go:37: error: invalid type conversion
bug284.go:38: error: invalid type conversion (cannot use type A1 as type A2)
bug284.go:56: error: invalid type conversion
bug284.go:59: error: invalid type conversion (cannot use type S2 as type S1)
bug284.go:60: error: invalid type conversion
bug284.go:61: error: invalid type conversion (cannot use type S1 as type S2)
bug284.go:71: error: invalid type conversion
bug284.go:74: error: invalid type conversion (cannot use type P2 as type P1)
bug284.go:75: error: invalid type conversion
bug284.go:76: error: invalid type conversion (cannot use type P1 as type P2)
bug284.go:96: error: invalid type conversion
bug284.go:99: error: invalid type conversion (cannot use type Q2 as type Q1)
bug284.go:101: error: invalid type conversion (cannot use type Q1 as type Q2)
bug284.go:111: error: invalid type conversion (different parameter types)
bug284.go:114: error: invalid type conversion (different parameter types)
bug284.go:115: error: invalid type conversion (different parameter types)
bug284.go:116: error: invalid type conversion (different parameter types)
bug284.go:134: error: invalid type conversion (incompatible type for method 'f' (different result types))
bug284.go:137: error: invalid type conversion (incompatible type for method 'f' (different result types))
bug284.go:138: error: invalid type conversion (incompatible type for method 'f' (different result types))
bug284.go:139: error: invalid type conversion (incompatible type for method 'f' (different result types))
bug284.go:149: error: invalid type conversion
bug284.go:152: error: invalid type conversion (cannot use type L2 as type L1)
bug284.go:153: error: invalid type conversion
bug284.go:154: error: invalid type conversion (cannot use type L1 as type L2)
bug284.go:164: error: invalid type conversion
bug284.go:167: error: invalid type conversion (cannot use type L2 as type L1)
bug284.go:168: error: invalid type conversion
bug284.go:169: error: invalid type conversion (cannot use type L1 as type L2)
bug284.go:179: error: invalid type conversion
bug284.go:182: error: invalid type conversion (cannot use type C2 as type C1)
bug284.go:183: error: invalid type conversion
bug284.go:184: error: invalid type conversion (cannot use type C1 as type C2)
R=rsc
CC=golang-dev
https://golang.org/cl/2136041
bug278.go:18: error: invalid left hand side of assignment
bug278.go:19: error: array is not addressable
bug278.go:21: error: invalid left hand side of assignment
bug278.go:22: error: invalid left hand side of assignment
R=rsc
CC=golang-dev
https://golang.org/cl/2122042
The gccgo compiler is smart enough to not make something which
is not used. Use global variables to defeat this
optimization.
R=rsc
CC=golang-dev
https://golang.org/cl/2129041
Another case where gccgo and gc report similar but not
identical errors for a recursive interface.
bug251.go:11: error: invalid recursive interface
R=rsc
CC=golang-dev
https://golang.org/cl/2094041
This introduces GC_ERROR to mark an error only issued by the
gc compiler. GCCGO_ERROR already exists to mark errors only
issued by the gccgo compiler. Obviously these should be used
sparingly.
bug195.go:9: error: interface contains embedded non-interface
bug195.go:12: error: interface contains embedded non-interface
bug195.go:15: error: interface contains embedded non-interface
bug195.go:18: error: invalid recursive interface
bug195.go:22: error: invalid recursive interface
R=rsc
CC=golang-dev
https://golang.org/cl/2040043
Also, if the header is bad, exit with a non-zero status.
Other calls to Brdline in the tree, by category:
Reading symbol name from object file:
./cmd/5l/obj.c:486: name = Brdline(f, '\0');
./cmd/6l/obj.c:535: name = Brdline(f, '\0');
./cmd/8l/obj.c:564: name = Brdline(f, '\0');
./libmach/sym.c:292: cp = Brdline(bp, '\0');
Reading archive header line (fixed, short):
./cmd/gc/lex.c:287: if((a = Brdline(b, '\n')) == nil)
./cmd/gc/lex.c:303: if((p = Brdline(b, '\n')) == nil)
Reading object file header line (fixed, short):
./cmd/ld/lib.c:421: line = Brdline(f, '\n');
Reading undefined symbol list (unused code):
./cmd/ld/lib.c:773: while((l = Brdline(b, '\n')) != nil){
Implementing Brdstr:
./libbio/brdstr.c:36: p = Brdline(bp, delim);
The symbol names ones will cause a problem loudly if they
fail: they'll error out with symbol name too long. This means
that you can't define an enormous struct without giving the
type a name and then stick it in an interface, because the
type's symbol name will be too long for the object file.
Since this will be a loud failure instead of a silent one,
I'm willing to wait until it comes up in practice.
R=r
CC=golang-dev
https://golang.org/cl/1982041
these tests work fine on n1 and gumstix. it's unclear
why they keep failing on the godashboard build.
R=rsc
CC=golang-dev
https://golang.org/cl/1664056
Background: The current spec is imprecise with respect to the parsing ambiguity
for composite literals: It says that the ambiguity arises when the TypeName form
of the LiteralType is used. The following code:
if (B) {} ...
is not using the TypeName form (but the parenthesized TypeName form) and thus
could be interpreted as:
if ((B){}) ...
instead of
if B {} ...
Both compilers and gofmt choose the latter interpretation. One could fix the
spec by making the clause regarding the parsing ambiguity more precise ("...using
the _possibly parenthesized_ TypeName form of the LiteralType..."). The alternative
(chosen here) is to simply disallow parenthesized literal types. Except for a single
test case (test/parentype.go) there appears to be no Go code under $GOROOT containing
parenthesized literal types. Furthermore, parentheses are never needed around a
literal type for correct parsing.
R=golang-dev
CC=golang-dev
https://golang.org/cl/1913041
of syscall.Syscall and syscall.SYS_KILL.
In RTEMS, there is no syscall.Syscall support, but it does
support POSIX signals. So, if this testcase is changed to use
syscall.Kill, then it would run fine on RTEMS, when using gccgo.
R=rsc, iant
CC=golang-dev
https://golang.org/cl/1863046
but with less precision than hardware counterparts.
fixed a number of tests to output BUG when they failed.
changed the runner to distinghuish between output
and output containing ^BUG
R=rsc
CC=dho, golang-dev
https://golang.org/cl/1778041
remove the print statements.
This change is because of the port of gccgo to RTEMS.
These tests use the GCC DejaGNU framework. In some cases,
the tests need to be run on qemu where the status code
cannot be sent back to DejaGNU, so it prints the exit status
by putting a wrapper around the exit and abort calls.
This testcase closes the stdout, and hence prohibits DejaGNU
from knowing the status in such cases, and causes this test
to be wrongly declared as a failure.
R=rsc, iant
CC=golang-dev
https://golang.org/cl/1792042
x.go:13: cannot use t (type T) as type Reader in assignment:
T does not implement Reader (Read method requires pointer receiver)
x.go:19: cannot use q (type Q) as type Reader in assignment:
Q does not implement Reader (missing Read method)
have read()
want Read()
x.go:22: cannot use z (type int) as type Reader in assignment:
int does not implement Reader (missing Read method)
x.go:24: too many arguments to conversion to complex: complex(1, 3)
R=ken2
CC=golang-dev
https://golang.org/cl/1736041
This shortens, simplifies and regularizes the code significantly.
(Improvements to reflect could make another step.)
Passes all.bash.
One semantic change occurs: The String() method changes
behavior. It used to run only for string formats such as %s and %q.
Instead, it now runs whenever the item has the method and the
result is then processed by the format as a string. Besides the
regularization, this has three effects:
1) width is honored for String() items
2) %x works for String() items
3) implementations of String that merely recur will recur forever
Regarding point 3, example from the updated documentation:
type X int
func (x X) String() string { return Sprintf("%d", x) }
should cast the value before recurring:
func (x X) String() string { return Sprintf("%d", int(x)) }
R=rsc
CC=golang-dev
https://golang.org/cl/1613045
* Code for assignment, conversions now mirrors spec.
* Changed some snprint -> smprint.
* Renamed runtime functions to separate
interface conversions from type assertions:
convT2I, assertI2T, etc.
* Correct checking of \U sequences.
Fixes#840.
Fixes#830.
Fixes#778.
R=ken2
CC=golang-dev
https://golang.org/cl/1303042
- renamed Len -> BitLen, simplified implementation
- renamed old Div, Mod, DivMod -> Que, Rem, QuoRem
- implemented Div, Mod, DivMod (Euclidian definition, more
useful in a mathematical context)
- fixed a bug in Exp (-0 was possible)
- added extra tests to check normalized results everywhere
- uniformly set Int.neg flag at the end of computations
- minor cosmetic cleanups
- ran all tests
R=rsc
CC=golang-dev
https://golang.org/cl/1091041
- fixed a couple of bugs in the process
(shift right was incorrect for negative numbers)
- added more tests and made some tests more robust
- changed pidigits back to using shifts to multiply
by 2 instead of add
This improves pidigit -s -n 10000 by approx. 5%:
user 0m6.496s (old)
user 0m6.156s (new)
R=rsc
CC=golang-dev
https://golang.org/cl/963044
this is a version synthesized from rsc's, dean's and my
versions. changes and updates:
- embeds the retval script and pushes a new version to the
device if needed
- passes arguments correctly to the program on the device
- export GOARCH, GOTRACEBACK and GOGC from the local
environment to the device.
- added times.out support to run-arm
enabled a few tests that are now passing and moved the
GOGC=off workaround to run-arm.
R=dpx
CC=golang-dev, rsc
https://golang.org/cl/880046
tested on linux/amd64, linux/386, linux/arm, darwin/amd64, darwin/386.
freebsd untested; will finish in a separate CL.
for now all the panics are errorStrings.
richer structures can be added as necessary
once the mechanism is shaked out.
R=r
CC=golang-dev
https://golang.org/cl/906041
1. Fix bug in GOMAXPROCS when trying to cut number of procs
Race could happen on any system but was
manifesting only on Xen hosted Linux.
2. Fix recover on ARM, where FP != caller SP.
R=r
CC=golang-dev
https://golang.org/cl/880043
* correct symbol table size
* do not reorder functions in output
* traceback
* signal handling
* use same code for go + defer
* handle leaf functions in symbol table
R=kaib, dpx
CC=golang-dev
https://golang.org/cl/884041
* adds pass 3 to dequeue from channels eagerly
various other cleanup/churn:
* use switch on cas->send in each pass to
factor out common code.
* longer goto labels, commented at target
* be more agressive about can't happen:
throw instead of print + cope.
* use "select" instead of "selectgo" in errors
* use printf for debug prints when possible
R=ken2, ken3
CC=golang-dev, r
https://golang.org/cl/875041
note that sortmain.go has been run through hg gofmt;
only the formatting of the day initializers changed.
i'm happy to revert that formatting if you'd prefer.
stop on error in doc/progs/run
R=r
CC=golang-dev
https://golang.org/cl/850041
test/64bit.go: segfaults on sheevaplug(armv5)
The following have long runtimes when GC is on.
Sample run time in seconds for android emulator
and sheevaplug
test/stack.go: 4934s 1780s
test/ken/chan.go: 860s 296s
test/gc1.go: 218s 69s
R=rsc, kaib
CC=golang-dev
https://golang.org/cl/749041
