code review 4964046: src/cmd/gc/*: Adjustments for compilation using Plan 9 ...

src/cmd/gc/walk.c

 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 #include        <u.h>
 #include        <libc.h>
 #include        "go.h"
 
 static  Node*   walkprint(Node*, NodeList**, int);
 static  Node*   conv(Node*, Type*);
@@ skipping 362 matching lines @@
         lno = setlineno(n);
 
         if(debug['w'] > 1)
                 dump("walk-before", n);
 
         if(n->typecheck != 1) {
                 dump("missed typecheck", n);
                 fatal("missed typecheck");
         }
 
-        t = T;
-        et = Txxx;
-
         switch(n->op) {
         default:
                 dump("walk", n);
                 fatal("walkexpr: switch 1 unknown op %N", n);
-                goto ret;
+                break;
 
         case OTYPE:
         case ONONAME:
         case OINDREG:
         case OEMPTY:
                 goto ret;
 
         case ONOT:
         case OMINUS:
         case OPLUS:
@@ skipping 941 matching lines @@
 static char*
 dumptypes(Type **nl, char *what)
 {
         int first;
         Type *l;
         Iter savel;
         Fmt fmt;
 
         fmtstrinit(&fmt);
         fmtprint(&fmt, "\t");
-        l = structfirst(&savel, nl);
         first = 1;
         for(l = structfirst(&savel, nl); l != T; l = structnext(&savel)) {
                 if(first)
                         first = 0;
                 else
                         fmtprint(&fmt, ", ");
                 fmtprint(&fmt, "%T", l);
         }
         if(first)
                 fmtprint(&fmt, "[no arguments %s]", what);
@@ skipping 356 matching lines @@
 }
 
 /*
  * from ascompat[te]
  * evaluating actual function arguments.
  *      f(a,b)
  * if there is exactly one function expr,
  * then it is done first. otherwise must
  * make temp variables
  */
-NodeList*
+static NodeList*
 reorder1(NodeList *all)
 {
         Node *f, *a, *n;
         NodeList *l, *r, *g;
         int c, d, t;
 
         c = 0;  // function calls
         t = 0;  // total parameters
 
         for(l=all; l; l=l->next) {
@@ skipping 105 matching lines @@
         if(vmatch1(l->left, r))
                 return 1;
         if(vmatch1(l->right, r))
                 return 1;
         for(ll=l->list; ll; ll=ll->next)
                 if(vmatch1(ll->n, r))
                         return 1;
         return 0;
 }
 
-NodeList*
+static NodeList*
 reorder3(NodeList *all)
 {
         Node *n1, *n2, *q;
         int c1, c2;
         NodeList *l1, *l2, *r;
 
         r = nil;
         for(l1=all, c1=0; l1; l1=l1->next, c1++) {
                 n1 = l1->n;
                 for(l2=all, c2=0; l2; l2=l2->next, c2++) {
@@ skipping 297 matching lines @@
                 l = list(l, nod(OAS, nx, a->n));        // s[n] = arg
                 if (a->next != nil)
                         l = list(l, nod(OAS, nn, nod(OADD, nn, nodintconst(1))));  // n = n + 1
         }
 
         typechecklist(l, Etop);
         walkstmtlist(l);
         *init = concat(*init, l);
         return ns;
 }