go2json.js

var go2json = new function(){let that = this;
  const SIGIL = [
    /*TRIPLE*/ "<<=",">>=",
    /*DOUBLE*/ "+=","-=","*=","/=","%=","++","--",":=","==","&&","||",">=","<=","<<",">>","&=","^=","|=","!=","<-",
    /*SINGLE*/ "=","+","-","*","/","%","{","}","[","]","(",")",",","&","|","!","<",">","^",";",":"
  ];
  const OPERATOR = SIGIL.filter(x=>!["{","}","[","]",";",":=","="].includes(x));
  const DOT = ".";
  const WHITESPACE = " \t";
  const NEWLINE = "\n\r";
  const NUMBER = "01234567890";
  const QUOTE = "\"'`";
  const PRIMTYPES = ["int","byte","bool","float32","float64","int8","int32","int16","int64","uint8","uint32","uint16","uint64","rune","string"];

  function go2tokens(src){
    let ident = "";
    let isNum = false;
    let tokens = [];
    let i = 0;
    let sigilset = Array.from(new Set(SIGIL.join("")));

    function newlineMaybe(){
      if (tokens.length && tokens[tokens.length-1].tag != "newline"){
        tokens.push({tag:"newline",value:"\n"});
      }
    }
    function pushIdent(){
      if (ident.length){
        tokens.push({tag:isNum?"number":"ident",value:ident});
        ident="";
        isNum = false;
      }
    }
    while (i < src.length){
      // console.log(i,src[i])
      if (WHITESPACE.includes(src[i])){
        pushIdent();
        i++;
      }else if (NEWLINE.includes(src[i])){
        pushIdent();
        newlineMaybe();
        i++;
      }else if (src[i]=="/" && src[i+1]=="/"){
        var cmt = "";
        while (src[i] != "\n" && i < src.length){
          cmt += src[i];
          i++;
        }
        // tokens.push({tag:"comment",value:cmt});
        newlineMaybe();
        i++;
      }else if (src[i] == "/" && src[i+1] == "*"){
        i+=3;
        let lvl = 0;
        while (true){
          if (i > src.length*2){
            throw "Unexpected EOF"
          }
          if (src[i-1]=="/" && src[i] == "*"){
            lvl ++;
          }
          if (src[i-1] == "*" && src[i] == "/"){
            if (!lvl){
              i++;
              break;
            }
            lvl --;
          }
          i++;
        }
      }else if (QUOTE.includes(src[i])){
        let j = i+1;
        while (true){
          if (src[j] == "\\"){
            j++;
          }else if (src[j] == src[i]){
            break;
          }
          j++;
        }
        j++;
        tokens.push({tag:src[i]=="'"?"char":"string",value:src.slice(i,j)});
        i=j;
      }else if (src[i] == "." && src[i+1] == "." && src[i+2] == "."){
        pushIdent();
        tokens.push({tag:"sigil",value:"..."});
        i+=3;
      }else if (sigilset.includes(src[i])){
        if (src[i] == "-" || src[i] == "+"){ // e.g. 1e+8 1E-9
          if (isNum && ident[ident.length-1]=="e"||ident[ident.length-1]=="E"){
            ident += src[i];
            i++;
            continue;
          }
        }
        pushIdent();
        let done = false;
        for (var j = 0; j < SIGIL.length; j++){
          let l = SIGIL[j].length;
          let ok = true;
          for (var k = 0; k < l; k++){
            if (src[i+k] != SIGIL[j][k]){
              ok = false;
              break;
            }
          }
          if (ok){
            tokens.push({tag:"sigil",value:SIGIL[j]});
            i += l;
            done = true;
            break;
          }
        }
      }else if (DOT.includes(src[i])){
        if (isNum){
          ident += src[i];
          i++;
        }else{
          pushIdent();
          tokens.push({tag:"sigil",value:DOT});
          i++;
        }
      }else if (NUMBER.includes(src[i])){
        if (ident.length == 0){
          isNum = true;

        }
        ident += src[i];
        i++;
      }else{
        ident += src[i];
        i++;
      }
    }
    pushIdent();
    newlineMaybe();
    return tokens;
  }


  function tokens2ast(tokens){
    function gtok(i){
      return tokens[i]||{};
    }


    function toksHasVal(toks,val){
      for (var i = 0; i < toks.length; i++){
        if (toks[i].value == val){
          return true;
        }
      }
      return false;
    }

    function tillNestEndImpl(toks,i,l,r){
      let tk = [];
      let lvl = 0;

      while (true){
        if (i >= toks.length){
          return [i,tk]
        }
        if (toks[i].value == l){
          lvl ++;
        }else if (toks[i].value == r){
          if (lvl == 0){
            return [i,tk];
          }
          lvl --;
        }
        tk.push(toks[i]);
        i++;
      }
      return [i,tk];
    }


    function parseExpr(toks){
      

      let i;
      let lvl = 0;
      for (i = 0; i < toks.length; i++){
        if ("{[(".includes(toks[i].value)){
          lvl ++;
        }
        if (")]}".includes(toks[i].value)){
          lvl --;
        }
        if (toks[i].value == ":="){
          if (lvl != 0){
            continue;
          }
          return {
            tag:"declare",
            names:splitToksBy(toks.slice(0,i),",").map(x=>x[0].value),
            value:parseExpr(toks.slice(i+1)),
            type:{tag:"auto"},
            isconst:false,
          }
        }
      }
      lvl = 0;

      for (i = 0; i < toks.length; i++){
        if ("{[(".includes(toks[i].value)){
          lvl ++;
        }
        if (")]}".includes(toks[i].value)){
          lvl --;
        }
        if (toks[i].value == "="){
          if (lvl != 0){
            continue;
          }
          return {
            tag:"assign",
            lhs:parseExpr(toks.slice(0,i)),
            rhs:parseExpr(toks.slice(i+1)),
          }
        }
      }

      // console.log(splitToksBy(toks,","))
      let groups = splitToksBy(toks,",");
      if (groups.length > 1){
        return {
          tag:"tuple",
          items:groups.map(parseExpr),
        }
      }

      let body = [];
      
      i = 0;
      while (i < toks.length){
        function tillNestEnd(l,r){
          let [j,tk] = tillNestEndImpl(toks,i,l,r);
          i = j;
          return tk;
        }

        if (toks[i].value== "("){

          if (i > 0 && (toks[i-1].tag == "ident") && (toks[i-1].value == "make") && (body.length<2 || body[body.length-2].tag != "access") ){

            i++;
            body.pop();
            let args = splitToksBy(tillNestEnd("(",")"),",");

            body.push({
              tag:"alloc",
              type:parseType(args[0]),
              size:args[1]?parseExpr(args[1]):null,
            });
            i++;
          }else if (i > 0 && (toks[i-1].tag == "ident" || toks[i-1].value == "]" || toks[i-1].value == "}" || toks[i-1].value == ")")){
            let fun = body.pop();
            if (fun.tag == "ident" && PRIMTYPES.includes(fun.value)){
              i++;
              body.push({
                tag:"cast",
                type:{tag:fun.value},
                value:parseExpr(tillNestEnd("(",")"))
              })
              i++;
            }else{
              i++;
              body.push({
                tag:"call",
                func:fun,
                args:splitToksBy(tillNestEnd("(",")"),",").map(parseExpr)
              });
              i++;

            }
          }else{
            i++;
            body.push(parseExpr(tillNestEnd("(",")")));
            i++;
          }
        }else if (toks[i].value == "."){
          i++;
          // console.log(toks[i])
          body.push({
            tag:"access",
            struct:body.pop(),
            member:toks[i].value,
          })
          i++;
        }else if (toks[i].value == "["){
          if (i > 0 && (toks[i-1].tag == "ident" || toks[i-1].value == "]")){
            i++;
            let idx = tillNestEnd("[","]");
            let idc = splitToksBy(idx,":");
            // console.log(idc);
            if (idc.length == 1){
              body.push({
                tag:"index",
                container:body.pop(),
                index:parseExpr(idx),
              });
            }else{
              body.push({
                tag:"slice",
                container:body.pop(),
                lo:parseExpr(idc[0]),
                hi:parseExpr(idc[1]),
              });
            }
            i++;
          }else{
            i++;
            let size = tillNestEnd("[","]");
            let mode = 0;
            for (var j = 0; j < toks.length; j++){
              if (toks[j].value == "{"){
                mode = 0;
                break;
              }else if (toks[j].value == "("){
                mode = 1;
                break;
              }
            }
            if (mode==0){
              let lit = {
                tag:"arraylit",
                size:parseExpr(size),
              }
              i++;
              lit.type = parseType(tillNestEnd("}","{"));
              i++;
              lit.items = splitToksBy(tillNestEnd("{","}"),",");
              body.push(lit);
              i++;
            }else{
              i++;
              let type = tillNestEnd(")","(");
              type = parseType(type);
              i++;
              let val =parseExpr(tillNestEnd("(",")"));
              body.push({
                tag:"cast",
                type:{tag:"array",size:parseExpr(size),item:type},
                value:val
              })
              i++;

            }
          }
        
        }else if (toks[i].value == "{"){
          // console.log(toks,i)
          i++;
          let cont = tillNestEnd("{","}");
          cont = splitToksBy(cont,",")
          let fields = [];
          for (let j= 0; j < cont.length; j++){
            let pair = splitToksBy(cont[j],",");
            let lhs = pair[0];
            let rhs = pair[1];
            if (!rhs){
              fields.push({name:null,value:parseExpr(lhs)});
            }else{
              fields.push({name:lhs[0].value,value:parseExpr(rhs)});
            }
          }

          body.push({
            tag:"structlit",
            struct:body.pop(),
            fields,
          });
          i++;

        }else if (toks[i].tag == "sigil" && OPERATOR.includes(toks[i].value)){
          body.push({tag:"op",value:toks[i].value});
          i++;
        }else if (toks[i].tag == "newline"){
          i++;
        }else if (toks[i].value == "func"){
          let stmt = {tag:"lambda"};
          i++;
          i++;
          let args = tillNestEnd("(",")");

          args = parseArgs(args);

          stmt.args = args;
          
          i++;
          stmt.returns = [];
          if (toks[i].value != "{"){
            if (toks[i].value != "("){
              stmt.returns.push({name:null,type:parseType(tillNestEnd("}","{"))});
            }else{
              i++;
              stmt.returns = parseRetTypes(tillNestEnd("(",")"));
              i++;
            }
          }
          i++;
          stmt.body = tokens2ast(tillNestEnd("{","}"));
          body.push(stmt);
          i++;
        }else{
          body.push(toks[i]);
          i++;
        }
      }
      return {tag:"expr",body};
    }
    function parseArgs(toks){

      let args = [];

      let i = 0;

      let lvl = 0;
      while (i < toks.length){
        

        let arg = {};
        arg.name = toks[i].value;
        i++;
        let typ = []
        let lvl = 0;
        while (i < toks.length){
          if (toks[i].value == "("){
            lvl ++;
          }else if (toks[i].value == ")"){
            lvl --;
          }else if (toks[i].value == ","){
            if (lvl == 0){
              break;
            }
          }
          typ.push(toks[i]);
          i++;
        }
        // console.log(typ);
        arg.type = parseType(typ);
        i++;
        args.push(arg);
      
        

      }
      // console.log(args);

      for (i = args.length-1; i >= 0; i--){
        if (args[i].type == undefined){
          args[i].type = args[i+1].type;
        }

      }
      return args;
    }

    function splitToksBy(toks,delim,delim2){
      let groups = [];
      let gp = [];
      let lvl = 0;
      for (let i = 0; i < toks.length; i++){
        if (toks[i].value == "{" || toks[i].value == "(" || toks[i].value == "["){
          lvl ++;
          gp.push(toks[i])
        }else if (toks[i].value == "}" || toks[i].value == ")" || toks[i].value == "]"){
          lvl --;
          gp.push(toks[i])
        }else if (toks[i].value == delim && lvl == 0){
          groups.push(gp);
          gp = [];
        }else if (delim2 != undefined && toks[i].value == delim2 && lvl == 0){
          groups.push(gp);
          gp = [];
        }else{
          gp.push(toks[i])
        }
      }
      if (groups.length || gp.length){
        groups.push(gp);
      }
      return groups;
    }

    function parseRetTypes(toks){
      let items = splitToksBy(toks,",");
      let simple = true;
      for (let j = 0; j < items.length; j++){
        if (items[j].length != 1){
          if (items[j][0].value != "map" && items[j][0].value != "[" && items[j][0].value != "*"){
            simple = false;
          }
          break;
        }
      }
      if (simple){
        return items.map(x=>({name:null,type:parseType(x)}));
      }
      let ret = items.map(x=>({}));

      for (let j = items.length-1; j >= 0 ; j--){
        let name = items[j][0].value;
        let type = items[j].slice(1);
        if (!type.length){
          type = ret[j+1].type;
        }else{
          type = parseType(type);
        }
        ret[j].name = name;
        ret[j].type = type;
      }
      return ret;
    }


    function parseType(toks){

      // return toks.map(x=>x.value).join("");
      if (toks.length == 1){
        return {tag:toks[0].value};
      }
      let i = 0;
      while (i < toks.length){

        function tillNestEnd(l,r){
          let [j,tk] = tillNestEndImpl(toks,i,l,r);
          i = j;
          return tk;
        }

        if (toks[i].value == "["){

          let typ = {tag:"array",size:null,item:null};
          i++;
          typ.size = parseExpr(tillNestEnd("[","]"));
          i++;
          typ.item = parseType(toks.slice(i));
          return typ;

        }else if (toks[i].value == "..."){

          let typ = {tag:"rest",item:null};
          i++;
          typ.item = parseType(toks.slice(i));
          return typ;

        }else if (toks[i].value == "*"){
          return {tag:"ptr",item:parseType(toks.slice(i+1))};

        }else if (toks[i].value == "map"){

          let typ = {tag:"map",key:null,value:null};
          i+=2;

          let te = tillNestEnd("[","]");

          typ.key = parseType(te);

          i++;
          typ.value = parseType(toks.slice(i));

          return typ;
        }else if (toks[i].value == "func"){
          return {tag:"lambda",...parseFuncSig(toks.slice(i+1))};
        }else if (toks[i].value == "interface"){
          return {tag:"interface"};
        }else if (toks[i].value == "<-" && toks[i+1].value == "chan"){
          return {tag:"chan", item:parseType(toks.slice(i+2)), mode:'i'}
        }else if (toks[i].value == "chan" && toks[i+1].value == "<-"){
          return {tag:"chan", item:parseType(toks.slice(i+2)), mode:'o'}
        }else if (toks[i].value == "chan"){
          return {tag:"chan", item:parseType(toks.slice(i+1)), mode:'io'}

        }else if (toks[i+1] && toks[i+1].value == "."){
          
          return {tag:"namespaced",namespace:toks[i].value,item:parseType(toks.slice(i+2))}
        }
      }
    }

    function parseFuncSig(toks){
      let lvl = 0;
      let k;
      for (k = 1; k < toks.length; k++){

        if (toks[k].value == "("){
          lvl ++;
        }else if (toks[k].value == ")"){
          if (lvl == 0){
            break;
          }
          lvl --;
        }

      }

      let args = toks.slice(1,k);

      args = parseRetTypes(args);
      let rets = toks.slice(k+1);
      if (rets.length){
        while(rets[0].value == "("){
          rets = rets.slice(1,-1);
        }
        rets = parseRetTypes(rets);
      }else{
        rets = [];
      }
      return {args:args,returns:rets}
    }


    let tree = [];
    let i = 0;
    while (i < tokens.length){
      // console.log(i,tokens[i])
      function tillStmtEnd(){
        let toks = [];
        let lvl = 0;
        while (true){

          if (i >= tokens.length){
            return toks;
          }
          // if (gtok(i).tag == undefined){
          //   // process.exit();
          // }
          if (gtok(i).tag == "sigil" && gtok(i).value == ";"){
            break;
          }
          if ("[{(".includes(gtok(i).value)){
            lvl++;
          }else if (")}]".includes(gtok(i).value)){
            lvl--;
          }else if (gtok(i).tag == "newline"){
            if (lvl == 0){
              if (gtok(i-1).tag != "sigil" || 
                gtok(i-1).value == ";" || 
                gtok(i-1).value == "++" || 
                gtok(i-1).value == "--" ||
                "}])".includes(gtok(i-1).value)){
                break;
              }
            }
          }
          toks.push(tokens[i]);
          i++;
        }
        return toks;
      }

      function tillNestEnd(l,r){
        let [j,tk] = tillNestEndImpl(tokens,i,l,r);
        i = j;
        return tk;
      }

      if (gtok(i).tag == "ident" && gtok(i).value == "package"){
        tree.push({tag:"package",name:gtok(i+1).value});
        i+=2;
      }else if (gtok(i).tag == "ident" && gtok(i).value == "type"){
        if (gtok(i+2).value == "struct"){
          let stmt = {tag:"typedef",name:gtok(i+1).value,fields:[],embeds:[]};
          i += 4;

          let lns = splitToksBy(tillNestEnd("{","}"),"\n",";");
          for (let j = 0; j < lns.length; j++){
            let names = splitToksBy(lns[j],",");
            if (!names.length){
              continue;
            }
            if (names.length == 1 && names[0].length == 1){
              stmt.embeds.push(names[0][0].value);

            }else{
              let type = names[names.length-1].slice(1);

              type = parseType(type);
              
              for (let k = 0; k < names.length; k++){
                stmt.fields.push({name:names[k][0].value,type});
              }
            }
            
          }
          i++;

          tree.push(stmt);
        }else if (gtok(i+2).value == "interface"){
          let stmt = {tag:"interface",name:gtok(i+1).value,methods:[]};
          i += 4;

          let lns = splitToksBy(tillNestEnd("{","}"),"\n",";");

          for (let j = 0; j < lns.length; j++){

            let name = lns[j][0];
            if (!name){
              continue;
            }
            name = name.value;
            let sig = Object.assign({name},parseFuncSig(lns[j].slice(1)));
            
            stmt.methods.push(sig)
            
          }
          tree.push(stmt);

          i++;
        }else{
          let stmt = {tag:"typealias",name:gtok(i+1).value};
          i += 2;
          let typ = tillStmtEnd();
          stmt.value = parseType(typ);
          tree.push(stmt);
        }
      }else if (gtok(i).tag == "ident" && gtok(i).value == "func"){
        let stmt = {tag:"func",receiver:null};
        if (gtok(i+1).value == "("){
          stmt.receiver = {name:gtok(i+2).value};
          i += 3;
          stmt.receiver.type=parseType(tillNestEnd("(",")"));
        }

        i++;
        stmt.name = gtok(i).value;
        i+=2;
        let args = tillNestEnd("(",")");

        args = parseArgs(args);

        stmt.args = args;
        
        i++;
        stmt.returns = [];
        if (gtok(i).value != "{"){
          if (gtok(i).value != "("){
            stmt.returns.push({name:null,type:parseType(tillNestEnd("}","{"))});
          }else{
            i++;
            stmt.returns = parseRetTypes(tillNestEnd("(",")"));
            i++;
          }
        }
        i++;
        stmt.body = tokens2ast(tillNestEnd("{","}"));
        tree.push(stmt);
        i++;
      }else if (gtok(i).tag == "ident" && gtok(i).value == "if"){
        let stmt = {tag:"if"}
        i+=1;
        let cond = tillNestEnd("}","{");
        let conds = splitToksBy(cond,";");
        stmt.prepare = conds.slice(0,-1).map(parseExpr);
        stmt.condition = parseExpr(conds[conds.length-1]);
        i++;
        stmt.body = tokens2ast(tillNestEnd("{","}")); 
        tree.push(stmt);
        i++;

      }else if (gtok(i).tag == "ident" && gtok(i).value == "else"){
        if (gtok(i+1).tag == "ident" && gtok(i+1).value == "if"){
          let stmt = {tag:"elseif"};
          i += 2;
          let cond = tillNestEnd("}","{");
          stmt.condition = parseExpr(cond);
          i++;
          stmt.body = tokens2ast(tillNestEnd("{","}")); 
          tree.push(stmt);
          i++;
        }else{
          let stmt = {tag:"else"};
          i ++;
          i++;
          stmt.body = tokens2ast(tillNestEnd("{","}")); 
          tree.push(stmt);
          i++;
        }

      }else if (gtok(i).tag == "ident" && gtok(i).value == "for"){
        let stmt = {tag:"for"}
        i+=1;
        let head = tillNestEnd("}","{");

        if (toksHasVal(head,"range")){
          stmt.tag = "foreach";
          let [lhs,rhs] = splitToksBy(head,":=");

          stmt.names = splitToksBy(lhs,",").map(x=>x[0].value);
          stmt.container = parseExpr(rhs.slice(1));
          i++;
        }else{
          stmt.headers = splitToksBy(head,";").map(parseExpr);
          i++;
        }
        stmt.body = tokens2ast(tillNestEnd("{","}")); 
        tree.push(stmt);
        i++;

      }else if (gtok(i).tag == "ident" && (gtok(i).value == "var" || gtok(i).value == "const")){
        let isconst = (gtok(i).value == "const");

        if (gtok(i+1).value == "("){
          i++;
          let toks = tillStmtEnd().slice(1,-1);
          let lns = splitToksBy(toks,"\n",";").filter(x=>x.length);

          let lastval = null;
          let iota = 0;
          function inferval(rhs){
            if (rhs == null){
              if (lastval){
                rhs = lastval.slice();
              }else{
                return null; //probably invalid go, but whatever
              }
            }
            lastval = rhs.slice();
            let diduseiota = false;
            for (let j = 0; j < rhs.length; j++){
              if (rhs[j].value == "iota"){
                rhs[j] = {tag:"number",value:`${iota}`};
                diduseiota = true;
              }
            }
            if (diduseiota){
              iota ++;
            }
            return parseExpr(rhs);
          }
          for (let j = 0; j < lns.length; j++){
            let sides = splitToksBy(lns[j],"=");

            let lhs = sides[0];
            let type = lhs.slice(1);

            if (type.length){
              type = parseType(type);
            }else{
              type = null;
            }
            let rhs = sides[1];
            let stmt = {
              tag:"declare",
              names:[lhs[0].value],
              value:inferval(rhs),
              type:type||{tag:"auto"},
              isconst,
            };
            tree.push(stmt);
          }
          i++;

        }else{

          i++;
          let toks = tillStmtEnd();
          let sides = splitToksBy(toks,"=");
          let lhs = sides[0];
          let rhs = sides[1];

          let names = splitToksBy(lhs,",");


          let type = names[names.length-1].slice(1);

          if (type){
            type = parseType(type);
          }

          names = names.map(x=>x[0].value);
          let stmt = {
            tag:"declare",
            names,
            value:(!rhs)?null:parseExpr(rhs),
            type:type||{tag:"auto"},
            isconst,
          };

          tree.push(stmt);
          i++;
        }
      }else if (gtok(i).tag == "ident" && (gtok(i).value == "switch")){
        let stmt = {tag:"switch"}
        i+=1;
        let cond = tillNestEnd("}","{");
        stmt.condition = parseExpr(cond);
        i++;
        let body = tillNestEnd("{","}"); 

        stmt.cases = [];
        let j = 0;
        let s0=null;
        let s1=null;
        while (j < body.length){
          if (body[j].value=="case" || body[j].value == "default"){
            if (s0 == null){
              s1 = null;
              s0 = [];
            }else{
              if (s0.length){
                stmt.cases.push({
                  tag:"case",
                  condition:parseExpr(s0),
                  body:tokens2ast(s1),
                })
              }else{
                stmt.cases.push({
                  tag:"default",
                  body:tokens2ast(s1),
                })
              }
              s0 = [];
              s1 = null;
            }
          }else if (body[j].value==":"){
            s1 = [];
          }else{
            if (s1 != null){
              s1.push(body[j]);
            }else if (s0 != null){
              s0.push(body[j]);
            }
          }
          j++;
        }
        if (s0 != null){
          if (s0.length){
            stmt.cases.push({
              tag:"case",
              condition:parseExpr(s0),
              body:tokens2ast(s1),
            })
          }else{
            stmt.cases.push({
              tag:"default",
              body:tokens2ast(s1),
            })
          }
        }
        
        tree.push(stmt);
        i++;

      }else if (gtok(i).tag == "newline"){
        i++;
      }else if (gtok(i).tag == "comment"){
        tree.push({tag:"comment",text:gtok(i).value});
        i++;
      }else if (gtok(i).value == "return"){
        i++;
        tree.push({tag:"return",value:parseExpr(tillStmtEnd())})
        i++;
      }else if (gtok(i).value == "import"){
        i++;
        let imps = tillStmtEnd();
        // imps = imps.filter(x=>x.tag!="newline");

        for (let j = 0; j < imps.length-1; j++){
          if (imps[j].tag == "string"){
            tree.push({tag:"import",value:imps[j].value})
          }
        }
        i++;

      }else if (gtok(i).value == "go"){
        i++;
        let e = tillStmtEnd();
        tree.push({tag:"invoke",func:parseExpr(e)})
        i++;
      }else if (gtok(i).value == "defer"){
        i++;
        let e = tillStmtEnd();
        tree.push({tag:"defer",expr:parseExpr(e)})
        i++;
      }else{
        let toks = tillStmtEnd();
        // console.log(toks);
        let stmt = parseExpr(toks);
        if (stmt.tag == "expr"){
          stmt = {
            tag:"exec",
            expr:stmt,
          };
        }
        tree.push(stmt);
        i++;
      }
    }
    return tree;
  }

  function go2ast(src){
    var tokens = go2tokens(src);
    // tokens.map(x=>console.log(x));
    var tree = tokens2ast(tokens);
    return tree;
  }

  this.go2ast = go2ast;
  this.go2tokens = go2tokens;
  this.tokens2ast = tokens2ast;
}

var IS_NODE = typeof module !== 'undefined';
var IS_MAIN = (IS_NODE && !module.parent);

if (IS_NODE){
  module.exports = go2json;
}

if (IS_MAIN){
  const fs = require("fs");
  var src = fs.readFileSync(process.argv[2]).toString();
  var tokens = go2json.go2tokens(src);
  // tokens.map(x=>console.log(x));
  var tree = go2json.tokens2ast(tokens);
  fs.writeFileSync(process.argv[3],JSON.stringify(tree,null,2))
}