(function (factory) {
 if (typeof module === "object" && typeof module.exports === "object") {
 var v = factory(require, exports);
 if (v !== undefined) module.exports = v;
 }
 else if (typeof define === "function" && define.amd) {
 define(["require", "exports", "../SDT/LexicalScope", "../SDT/ILGen"], factory);
 }
})(function (require, exports) {
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const LexicalScope_1 = require("../SDT/LexicalScope");
 const ILGen_1 = require("../SDT/ILGen");
 //定义陈述语言抽象类
 class Stmt {
 //每个陈述语句都需要构建一次作用域
 buildLexicalScope(parent) {
 this.lexicalScope = parent;
 }
 }
 exports.Stmt = Stmt;
 //声明语句
 class DeclareStmt extends Stmt {
 constructor(left, right) {
 super();
 this.left = left;
 this.right = right;
 }
 buildLexicalScope(parent) {
 this.lexicalScope = parent;
 this.lexicalScope.bind(this.left.value, 'number');
 }
 print(level) {
 const pad = ''.padStart(level * 2);
 console.log(pad + '=');
 this.left.print(level + 1);
 this.right.print(level + 1);
 }
 gen(il) {
 let scope = this.lexicalScope;
 il.add(`declare ${scope.getLexemeName(this.left.lvalue())}`);
 if (this.right && this.right.gen) {
 this.right.gen(il, scope);
 }
 il.add(`${scope.getLexemeName(this.left.lvalue())}=${this.right.rvalue()}`);
 }
 }
 exports.DeclareStmt = DeclareStmt;
 class IfStmt extends Stmt {
 /**
 * @param {*} expr if 后面的表达式
 * @param {*} ifBlock if 后面的紧跟着的 Block
 * @param {*} elseIfStmt 如果有else if, 相当于else后面跟着的If语句
 * @param {*} elseBlock 如果没有else if 相当于else后面跟着的Block
 */
 constructor(expr, ifBlock, elseIfStmt, elseBlock) {
 super();
 this.expr = expr;
 this.ifBlock = ifBlock;
 this.elseIfStmt = elseIfStmt;
 this.elseBlock = elseBlock;
 }
 buildLexicalScope(parent) {
 super.buildLexicalScope(parent);
 this.expr.bindLexicalScope(this.lexicalScope);
 this.ifBlock.buildLexicalScope(this.lexicalScope);
 this.elseIfStmt && this.elseIfStmt.buildLexicalScope(this.lexicalScope);
 this.elseBlock && this.elseBlock.buildLexicalScope(this.lexicalScope);
 }
 print(level) {
 const pad = ''.padStart(level * 2);
 console.log(pad + 'if');
 this.expr.print(level + 1);
 this.ifBlock.print();
 }
 gen(il) {
 this.expr.gen(il, this.lexicalScope);
 const ifCodeLine = il.add('', true);
 let ifBlockNextLineNo = null;
 this.ifBlock.gen(il, this.lexicalScope);
 if (this.elseIfStmt) {
 if (!ifBlockNextLineNo) {
 ifBlockNextLineNo = il.current().lineno;
 }
 this.elseIfStmt.gen(il, this.lexicalScope);
 }
 else if (this.elseBlock) {
 if (!ifBlockNextLineNo) {
 ifBlockNextLineNo = il.current().lineno;
 }
 this.elseBlock.gen(il, this.lexicalScope);
 }
 // const nextLine = il.current().lines[ifCodeLine.lineno+1]
 const currentLine = il.currentLine();
 const l1 = il.genLabel();
 // il.bindLabel(nextLine.lineno, l1)
 il.bindLabel(currentLine.lineno + 1, l1);
 // currentLine.label = l2
 // nextLine.label = l1 
 ifCodeLine.code = `branch ${this.expr.rvalue()}${l1}`;
 }
 }
 exports.IfStmt = IfStmt;
 class ReturnStmt extends Stmt {
 constructor(expr) {
 super();
 this.expr = expr;
 this.expr = expr;
 }
 buildLexicalScope(parent) {
 super.buildLexicalScope(parent);
 this.expr.bindLexicalScope(this.lexicalScope);
 }
 print(level) {
 const pad = ''.padStart(level * 2);
 console.log(pad + 'return');
 this.expr.print(level + 1);
 }
 gen(il) {
 this.expr && this.expr.gen && this.expr.gen(il, this.lexicalScope);
 il.add(`return ${this.lexicalScope.getLexemeName(this.expr.rvalue())}`);
 }
 }
 exports.ReturnStmt = ReturnStmt;
 class Function extends Stmt {
 constructor(id, args, block) {
 super();
 this.id = id;
 this.args = args;
 this.block = block;
 }
 buildLexicalScope(parent) {
 this.lexicalScope = new LexicalScope_1.LexicalScope(parent, {
 type: 'function',
 argc: this.args.size()
 });
 parent.bind(this.id.value, 'function');
 this.args.bindLexicalScope(this.lexicalScope);
 this.block.buildLexicalScope(this.lexicalScope, false);
 }
 print(level) {
 const pad = ''.padStart(level * 2);
 console.log(pad + 'function:' + this.id);
 this.args.print(level + 1);
 // this.block.print(level + 1)
 this.block.print();
 }
 gen(il) {
 il.add(`declare function ${this.lexicalScope.getLexemeName(this.id.lvalue())}`);
 il.beginSection(this.id.value + '@' + this.lexicalScope.id);
 il.add(`set %TOP% %SP%`);
 this.args.gen(il, this.lexicalScope);
 this.block.gen(il, this.lexicalScope);
 il.endSection();
 }
 }
 exports.Function = Function;
 class Block {
 constructor(stmts) {
 this.stmts = stmts;
 }
 buildLexicalScope(parent, create = true) {
 if (create) {
 this.lexicalScope = new LexicalScope_1.LexicalScope(parent);
 }
 else {
 this.lexicalScope = parent;
 }
 this.stmts.forEach((stmt) => {
 if (stmt instanceof Stmt) {
 stmt.buildLexicalScope(this.lexicalScope);
 }
 else {
 stmt.bindLexicalScope(this.lexicalScope);
 }
 });
 }
 print() {
 for (let i = 0; i < this.stmts.length; i++) {
 this.stmts[i].print(0);
 }
 }
 gen(il, scope = this.lexicalScope) {
 for (let i = 0; i < this.stmts.length; i++) {
 this.stmts[i].gen(il, scope);
 }
 }
 }
 exports.Block = Block;
 class Program extends Block {
 constructor(stmts) {
 super(stmts);
 this.stmts = stmts;
 this.ilGen = new ILGen_1.ILGen();
 }
 registerGlobals(scope) {
 scope.bind('print', 'function');
 }
 buildLexicalScope() {
 this.lexicalScope = new LexicalScope_1.LexicalScope();
 this.registerGlobals(this.lexicalScope);
 this.stmts.forEach(stmt => {
 if (stmt instanceof Stmt) {
 stmt.buildLexicalScope(this.lexicalScope);
 }
 else {
 stmt.bindLexicalScope(this.lexicalScope);
 }
 });
 }
 gen() {
 this.ilGen.beginSection('main@1');
 this.ilGen.add('set %TOP% %SP%');
 for (let i = 0; i < this.stmts.length; i++) {
 this.stmts[i].gen(this.ilGen, this.lexicalScope);
 }
 this.ilGen.endSection();
 }
 }
 exports.Program = Program;
});
//# sourceMappingURL=statement.js.map