}
t = copyu(p, v2, A);
switch(t) {
- case 2: /* rar, cant split */
+ case 2: /* rar, can't split */
if(debug['P'])
print("; %Drar; return 0\n", v2);
return 0;
for(i=1; i<o; i++) {
if(oary[i] >= 0)
- fatal("cant happen");
+ fatal("can't happen");
gins(AMOVW, &n1, reg);
n1.xoffset = -(oary[i]+1);
}
}
t = copyu(p, v2, A);
switch(t) {
- case 2: /* rar, cant split */
+ case 2: /* rar, can't split */
if(debug['P'])
print("; %Drar; return 0\n", v2);
return 0;
switch(p->as) {
default:
- print("copyu: cant find %A\n", p->as);
+ print("copyu: can't find %A\n", p->as);
return 2;
case AMOVM:
return 1;
return 0;
}
- print("copyau1: cant tell %P\n", p);
+ print("copyau1: can't tell %P\n", p);
}
return 0;
}
a->type = D_CONST;
if(v->addr)
- fatal("addmove: shouldnt be doing this %A\n", a);
+ fatal("addmove: shouldn't be doing this %A\n", a);
switch(v->etype) {
default:
r = prg();
*r = *p;
if(!(r->mark&FOLL))
- print("cant happen 1\n");
+ print("can't happen 1\n");
r->mark |= FOLL;
if(p != q) {
p = p->link;
if(!(r->link->mark&FOLL))
xfol(r->link, last);
if(!(r->cond->mark&FOLL))
- print("cant happen 2\n");
+ print("can't happen 2\n");
return;
}
}
}
t = copyu(p, v2, A);
switch(t) {
- case 2: /* rar, cant split */
+ case 2: /* rar, can't split */
if(debug['P'])
print("; %D rar; return 0\n", v2);
return 0;
else if(n->left->op == OREGISTER)
idx.ptr = n->left->reg;
else if(n->left->op != OADDR) {
- reg[D_BP]++; // cant be used as a base
+ reg[D_BP]++; // can't be used as a base
regalloc(&nod1, &qregnode, Z);
cgen(n->left, &nod1);
idx.ptr = nod1.reg;
* Small structs or arrays with elements of basic type are
* also supported.
* nr is N when assigning a zero value.
- * return 1 if can do, 0 if cant.
+ * return 1 if can do, 0 if can't.
*/
int
componentgen(Node *nr, Node *nl)
break;
case 2: // offset output arg
-fatal("shouldnt be used");
+fatal("shouldn't be used");
n->op = OINDREG;
n->val.u.reg = D_SP;
n->xoffset += types[tptr]->width;
for(i=1; i<o; i++) {
if(oary[i] >= 0)
- fatal("cant happen");
+ fatal("can't happen");
gins(AMOVQ, &n1, reg);
n1.xoffset = -(oary[i]+1);
}
}
t = copyu(p, v2, A);
switch(t) {
- case 2: /* rar, cant split */
+ case 2: /* rar, can't split */
if(debug['P'])
print("; %D rar; return 0\n", v2);
return 0;
}
t = copyu(p, v2, A);
switch(t) {
- case 2: /* rar, cant split */
+ case 2: /* rar, can't split */
if(debug['P'])
print("; %D rar; return 0\n", v2);
return 0;
else if(n->left->op == OREGISTER)
idx.ptr = n->left->reg;
else if(n->left->op != OADDR) {
- reg[D_BP]++; // cant be used as a base
+ reg[D_BP]++; // can't be used as a base
regalloc(&nod1, ®node, Z);
cgen(n->left, &nod1);
idx.ptr = nod1.reg;
* copy a composite value by moving its individual components.
* Slices, strings and interfaces are supported.
* nr is N when assigning a zero value.
- * return 1 if can do, 0 if cant.
+ * return 1 if can do, 0 if can't.
*/
int
componentgen(Node *nr, Node *nl)
}
t = copyu(p, v2, A);
switch(t) {
- case 2: /* rar, cant split */
+ case 2: /* rar, can't split */
if(debug['P'])
print("; %D rar; return 0\n", v2);
return 0;
static void
fixtemp(Prog *firstp)
{
- static uint8 counts[1<<16]; // A hash table to count variable occurences.
+ static uint8 counts[1<<16]; // A hash table to count variable occurrences.
int i;
Prog *p, *p2;
uint32 h;
return 0;
bad:
- diag(n, "cant rewrite typestr for op %O\n", o);
+ diag(n, "can't rewrite typestr for op %O\n", o);
prtree(n, "isfunct");
n->type = T;
return 1;
return;
}
fr = frexp(native, &exp);
- f = 2097152L; /* shouldnt use fp constants here */
+ f = 2097152L; /* shouldn't use fp constants here */
fr = modf(fr*f, &ho);
ieee->h = ho;
ieee->h &= 0xfffffL;
*/
for(n1 = nn;; n1 = n1->left) {
if(n1 == Z) {
- diag(nn, "cant find function name");
+ diag(nn, "can't find function name");
return;
}
if(n1->op == ONAME)
return;
}
fr = frexp(native, &exp);
- f = 2097152L; /* shouldnt use fp constants here */
+ f = 2097152L; /* shouldn't use fp constants here */
fr = modf(fr*f, &ho);
ieee->h = ho;
ieee->h &= 0xfffffL;
return np >= ns && strcmp(p+np-ns, suffix) == 0;
}
-// hasprefix reports whether p begins wtih prefix.
+// hasprefix reports whether p begins with prefix.
bool
hasprefix(char *p, char *prefix)
{
return np >= ns && strcmp(p+np-ns, suffix) == 0;
}
-// hasprefix reports whether p begins wtih prefix.
+// hasprefix reports whether p begins with prefix.
bool
hasprefix(char *p, char *prefix)
{
return;
}
fr = frexp(native, &exp);
- f = 2097152L; /* shouldnt use fp constants here */
+ f = 2097152L; /* shouldn't use fp constants here */
fr = modf(fr*f, &ho);
h = ho;
h &= 0xfffffL;
}
stat = concat(stat, n->nbody);
- // botch - shouldnt fall thru declaration
+ // botch - shouldn't fall thru declaration
last = stat->end->n;
if(last->op == OXFALL) {
if(typeswvar) {
fi
rm -f test_std.list
-# issue 4096. Validate the output of unsucessful go install foo/quxx
+# issue 4096. Validate the output of unsuccessful go install foo/quxx
if [ $(./testgo install 'foo/quxx' 2>&1 | grep -c 'cannot find package "foo/quxx" in any of') -ne 1 ] ; then
echo 'go install foo/quxx expected error: .*cannot find package "foo/quxx" in any of'
ok=false
{
Sym *s;
- // -d supresses dynamic loader format, so we may as well not
+ // -d suppresses dynamic loader format, so we may as well not
// compute these sections or mark their symbols as reachable.
if(debug['d'] && HEADTYPE != Hwindows)
return;
/*
* Defining Abbrevs. This is hardcoded, and there will be
* only a handful of them. The DWARF spec places no restriction on
- * the ordering of atributes in the Abbrevs and DIEs, and we will
+ * the ordering of attributes in the Abbrevs and DIEs, and we will
* always write them out in the order of declaration in the abbrev.
* This implementation relies on tag, attr < 127, so they serialize as
* a char. Higher numbered user-defined tags or attributes can be used
}
/*
- * Generate short opcodes when possible, long ones when neccesary.
+ * Generate short opcodes when possible, long ones when necessary.
* See section 6.2.5
*/
{
CIERESERVE = 16,
DATAALIGNMENTFACTOR = -4, // TODO -PtrSize?
- FAKERETURNCOLUMN = 16 // TODO gdb6 doesnt like > 15?
+ FAKERETURNCOLUMN = 16 // TODO gdb6 doesn't like > 15?
};
static void
mh millihenry
mhz 1e+6/sec
mil 1e-3 in
-millenium 1000 year
+millennium 1000 year
minersinch 1.5 ft³/min
minim 1|60 fldr
mo month
{
uchar *s = (uchar*)t;
- return s[0] == (ANAME&0xff) /* aslo = ANAME */
+ return s[0] == (ANAME&0xff) /* also = ANAME */
&& s[1] == ((ANAME>>8)&0xff)
&& s[2] == D_FILE /* type */
&& s[3] == 1 /* sym */
{
uchar *s = (uchar*)t;
- return s[0] == (ANAME&0xff) /* aslo = ANAME */
+ return s[0] == (ANAME&0xff) /* also = ANAME */
&& s[1] == ((ANAME>>8)&0xff)
&& s[2] == D_FILE /* type */
&& s[3] == 1 /* sym */
}
// mux receives the values from sender and forwards them onto another channel.
-// It would be simplier to just have sender's four cases all be the same
+// It would be simpler to just have sender's four cases all be the same
// channel, but this doesn't actually trigger the bug.
func mux(out chan<- int, in <-chan int, done chan<- bool) {
for v := range in {