}
if t.Width == -2 {
- lno := int(lineno)
- lineno = int32(t.Lineno)
if !t.Broke {
t.Broke = true
- Yyerror("invalid recursive type %v", t)
+ yyerrorl(int32(t.Lineno), "invalid recursive type %v", t)
}
t.Width = 0
- lineno = int32(lno)
return
}
// defer checkwidth calls until after we're done
defercalc++
- lno := int(lineno)
+ lno := lineno
lineno = int32(t.Lineno)
t.Width = -2
t.Align = 0
t.Align = uint8(w)
}
- lineno = int32(lno)
+ lineno = lno
if defercalc == 1 {
resumecheckwidth()
func capturevars(xfunc *Node) {
var outer *Node
- lno := int(lineno)
+ lno := lineno
lineno = xfunc.Lineno
func_ := xfunc.Func.Closure
func_.Func.Enter.Append(outer)
}
- lineno = int32(lno)
+ lineno = lno
}
// transformclosure is called in a separate phase after escape analysis.
// It transform closure bodies to properly reference captured variables.
func transformclosure(xfunc *Node) {
- lno := int(lineno)
+ lno := lineno
lineno = xfunc.Lineno
func_ := xfunc.Func.Closure
}
}
- lineno = int32(lno)
+ lineno = lno
}
func walkclosure(func_ *Node, init **NodeList) *Node {
nr := n.Right
var rv Val
- var lno int
+ var lno int32
var wr EType
var v Val
var norig *Node
n.SetVal(v)
// check range.
- lno = int(setlineno(n))
-
+ lno = setlineno(n)
overflow(v, n.Type)
- lineno = int32(lno)
+ lineno = lno
// truncate precision for non-ideal float.
if v.Ctype() == CTFLT && n.Type.Etype != TIDEAL {
*np = n
}
- lno := int(setlineno(n))
+ lno := setlineno(n)
ctype := idealkind(n)
var t1 *Type
switch ctype {
}
if n.Val().Ctype() == CTNIL {
- lineno = int32(lno)
+ lineno = lno
if n.Diag == 0 {
Yyerror("use of untyped nil")
n.Diag = 1
goto num
}
- lineno = int32(lno)
+ lineno = lno
return
num:
overflow(n.Val(), t1)
}
Convlit(np, t1)
- lineno = int32(lno)
+ lineno = lno
return
}
}
func structfield(n *Node) *Type {
- lno := int(lineno)
+ lno := lineno
lineno = n.Lineno
if n.Op != ODCLFIELD {
f.Sym = f.Nname.Sym
}
- lineno = int32(lno)
+ lineno = lno
return f
}
var uniqgen uint32
func checkdupfields(t *Type, what string) {
- lno := int(lineno)
+ lno := lineno
for ; t != nil; t = t.Down {
if t.Sym != nil && t.Nname != nil && !isblank(t.Nname) {
}
}
- lineno = int32(lno)
+ lineno = lno
}
// convert a parsed id/type list into
}
func interfacefield(n *Node) *Type {
- lno := int(lineno)
+ lno := lineno
lineno = n.Lineno
if n.Op != ODCLFIELD {
f.Broke = true
}
- lineno = int32(lno)
+ lineno = lno
return f
}
return
}
- lno := int(setlineno(n))
+ lno := setlineno(n)
// ninit logically runs at a different loopdepth than the rest of the for loop.
esclist(e, n.Ninit, n)
}
}
- lineno = int32(lno)
+ lineno = lno
}
// Assert that expr somehow gets assigned to dst, if non nil. for
dst = &e.theSink
}
- lno := int(setlineno(src))
+ lno := setlineno(src)
e.pdepth++
switch src.Op {
}
e.pdepth--
- lineno = int32(lno)
+ lineno = lno
}
// Common case for escapes is 16 bits 000000000xxxEEEE
fs = fs.Link
}
if fs != to.Sym {
- lno := int(lineno)
+ lno := lineno
setlineno(from)
// decide what to complain about.
} else {
Yyerror("goto %v jumps over declaration of %v at %v", from.Left.Sym, dcl, linestr(dcl.Lastlineno))
}
- lineno = int32(lno)
+ lineno = lno
}
}
return
}
- lno := int(setlineno(n))
+ lno := setlineno(n)
orderinit(n, order)
cleantemp(t, order)
}
- lineno = int32(lno)
+ lineno = lno
}
// Orderexprlist orders the expression list l into order.
return
}
- lno := int(setlineno(n))
+ lno := setlineno(n)
orderinit(n, order)
switch n.Op {
}
}
- lineno = int32(lno)
+ lineno = lno
*np = n
}
t := n.Type
a := n.Right
- lno := int(setlineno(a))
+ lno := setlineno(a)
n.Right = nil
var v1 *Node
case TARRAY:
if memclrrange(n, v1, v2, a) {
- lineno = int32(lno)
+ lineno = lno
return
}
n.Nbody.Set(append(body, n.Nbody.Slice()...))
walkstmt(&n)
- lineno = int32(lno)
+ lineno = lno
}
// Lower n into runtime·memclr if possible, for
var n *Node
var def *Node
- lno := int(setlineno(sel))
+ lno := setlineno(sel)
count := 0
typechecklist(sel.Ninit, Etop)
for l := sel.List; l != nil; l = l.Next {
}
sel.Xoffset = int64(count)
- lineno = int32(lno)
+ lineno = lno
}
func walkselect(sel *Node) {
Fatalf("double walkselect") // already rewrote
}
- lno := int(setlineno(sel))
+ lno := setlineno(sel)
i := count(sel.List)
// optimization: zero-case select
out:
sel.List = nil
walkstmtslice(sel.Nbody.Slice())
- lineno = int32(lno)
+ lineno = lno
}
// Keep in sync with src/runtime/runtime2.go and src/runtime/select.go.
func initfix(l *NodeList) []*Node {
var lout []*Node
initplans = make(map[*Node]*InitPlan)
- lno := int(lineno)
+ lno := lineno
initreorder(l, &lout)
- lineno = int32(lno)
+ lineno = lno
initplans = nil
return lout
}
// typecheckswitch typechecks a switch statement.
func typecheckswitch(n *Node) {
- lno := int(lineno)
+ lno := lineno
typechecklist(n.Ninit, Etop)
var nilonly string
typecheckslice(ncase.Nbody.Slice(), Etop)
}
- lineno = int32(lno)
+ lineno = lno
}
// walkswitch walks a switch statement.
var cas *NodeList
for _, c := range cc {
n := c.node
- lno := int(setlineno(n))
+ lno := setlineno(n)
a := Nod(OIF, nil, nil)
if (s.kind != switchKindTrue && s.kind != switchKindFalse) || assignop(n.Left.Type, s.exprname.Type, nil) == OCONVIFACE || assignop(s.exprname.Type, n.Left.Type, nil) == OCONVIFACE {
a.Nbody.Set([]*Node{n.Right}) // goto l
cas = list(cas, a)
- lineno = int32(lno)
+ lineno = lno
}
return liststmt(cas)
}
return nil
}
- lno := int(setlineno(n))
+ lno := setlineno(n)
// Skip over parens.
for n.Op == OPAREN {
break
default:
- lineno = int32(lno)
+ lineno = lno
return n
}
}
Yyerror("typechecking loop involving %v%s", n, fmt_)
}
- lineno = int32(lno)
+ lineno = lno
return n
}
typecheck_tcstack[last] = nil
typecheck_tcstack = typecheck_tcstack[:last]
- lineno = int32(lno)
+ lineno = lno
return n
}
var n1 int
var n2 int
- lno := int(lineno)
+ lno := lineno
if tstruct.Broke {
goto out
}
out:
- lineno = int32(lno)
+ lineno = lno
return
notenough:
}
// Double-check use of type as embedded type.
- lno := int(lineno)
+ lno := lineno
if embedlineno != 0 {
lineno = int32(embedlineno)
}
}
- lineno = int32(lno)
+ lineno = lno
// Queue check for map until all the types are done settling.
if maplineno != 0 {
func typecheckdeftype(n *Node) {
ntypecheckdeftype++
- lno := int(lineno)
+ lno := lineno
setlineno(n)
n.Type.Sym = n.Sym
n.Typecheck = 1
copytype(n, t)
ret:
- lineno = int32(lno)
+ lineno = lno
// if there are no type definitions going on, it's safe to
// try to resolve the method types for the interfaces
maptype(l.N.Type, Types[TBOOL])
}
- lineno = int32(lno)
+ lineno = lno
}
ntypecheckdeftype--
}
func typecheckdef(n *Node) *Node {
- lno := int(lineno)
+ lno := lineno
setlineno(n)
if n.Op == ONONAME {
typecheckdefstack[last] = nil
typecheckdefstack = typecheckdefstack[:last]
- lineno = int32(lno)
+ lineno = lno
n.Walkdef = 1
return n
}
dumpslice(s, Curfn.Nbody.Slice())
}
- lno := int(lineno)
+ lno := lineno
// Final typecheck for any unused variables.
// It's hard to be on the heap when not-used, but best to be consistent about &~PHEAP here and below.
}
}
- lineno = int32(lno)
+ lineno = lno
if nerrors != 0 {
return
}