statement.ts

import { Identifier, Terminal } from './terminal'
import { Expr, AssignExpr, FunctionCallExpr, Args } from './expression'
import { LexicalScope } from '../SDT/LexicalScope'
import { ILGen } from '../SDT/ILGen'


//定义陈述语言抽象类
export abstract class Stmt {
  protected lexicalScope: LexicalScope
  //每个陈述语句都需要构建一次作用域
  buildLexicalScope(parent: LexicalScope): void {
    this.lexicalScope = parent
  }
  abstract print(level: number): void;
  abstract gen(il: ILGen, scopte: LexicalScope): void;
}

//声明语句
export class DeclareStmt extends Stmt {
  constructor(private left: Identifier, private right: Expr | Terminal) {
    super()
  }

  buildLexicalScope(parent: LexicalScope): void {
    this.lexicalScope = parent
    this.lexicalScope.bind(this.left.value, 'number')
  }


  print(level: number): void {
    const pad = ''.padStart(level * 2)
    console.log(pad + '=')
    this.left.print(level + 1)
    this.right.print(level + 1)
  }

  gen(il: ILGen): void {
    let scope: LexicalScope = this.lexicalScope
    il.add(`declare ${scope.getLexemeName(this.left.lvalue())}`);
    if (this.right && (<Expr>this.right).gen) {
      (<Expr>this.right).gen(il, scope)
    }
    il.add(`${scope.getLexemeName(this.left.lvalue())}=${this.right.rvalue()}`)
  }
}

export class IfStmt extends Stmt {
  /**
   * @param {*} expr if 后面的表达式
   * @param {*} ifBlock  if 后面的紧跟着的 Block
   * @param {*} elseIfStmt 如果有else if， 相当于else后面跟着的If语句
   * @param {*} elseBlock 如果没有else if 相当于else后面跟着的Block
   */
  constructor(private expr: Expr | Terminal, private ifBlock: Block, private elseIfStmt?: Stmt, private elseBlock?: Block) {
    super()
  }

  buildLexicalScope(parent: LexicalScope): void {
    super.buildLexicalScope(parent);
    (<Expr | Identifier>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: number): void {
    const pad = ''.padStart(level * 2)
    console.log(pad + 'if')
    this.expr.print(level + 1)
    this.ifBlock.print()
  }

  gen(il): void {
    (<Expr>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}`
  }
}

export class ReturnStmt extends Stmt {
  constructor(private expr) {
    super()
    this.expr = expr
  }

  buildLexicalScope(parent): void {
    super.buildLexicalScope(parent)
    this.expr.bindLexicalScope(this.lexicalScope)
  }

  print(level): void {
    const pad = ''.padStart(level * 2)
    console.log(pad + 'return')
    this.expr.print(level + 1)
  }

  gen(il): void {
    this.expr && this.expr.gen && this.expr.gen(il, this.lexicalScope)
    il.add(`return ${this.lexicalScope.getLexemeName(this.expr.rvalue())}`)
  }
}

export class Function extends Stmt {
  constructor(private id: Identifier, private args: Args, private block: Block) {
    super()
  }

  buildLexicalScope(parent): void {
    this.lexicalScope = new 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): void {
    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): void {
    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()
  }
}


export class Block {
  protected lexicalScope: LexicalScope
  constructor(public stmts: Array<Stmt | Expr | Terminal>) { }

  buildLexicalScope(parent: LexicalScope, create = true): void {
    if (create) {
      this.lexicalScope = new LexicalScope(parent)
    } else {
      this.lexicalScope = parent
    }

    this.stmts.forEach((stmt: (Stmt | Expr | Terminal)) => {
      if (stmt instanceof Stmt) {
        stmt.buildLexicalScope(this.lexicalScope)
      } else {
        (<Expr | Identifier>stmt).bindLexicalScope(this.lexicalScope)
      }
    })
  }

  print(): void {
    for (let i = 0; i < this.stmts.length; i++) {
      this.stmts[i].print(0)
    }
  }
  gen(il: ILGen, scope: LexicalScope = this.lexicalScope): void {
    for (let i = 0; i < this.stmts.length; i++) {
      (<Stmt | Expr>this.stmts[i]).gen(il, scope)
    }
  }
}

export class Program extends Block {
  public ilGen: ILGen
  public lexicalScope: LexicalScope
  constructor(public stmts: Array<Stmt | Expr | Terminal>) {
    super(stmts)
    this.ilGen = new ILGen()
  }

  registerGlobals(scope): void {
    scope.bind('print', 'function')
  }

  buildLexicalScope(): void {
    this.lexicalScope = new LexicalScope()
    this.registerGlobals(this.lexicalScope)
    this.stmts.forEach(stmt => {
      if (stmt instanceof Stmt) {
        stmt.buildLexicalScope(this.lexicalScope)
      } else {
        (<Expr | Identifier>stmt).bindLexicalScope(this.lexicalScope)
      }
    })
  }

  gen(): void {
    this.ilGen.beginSection('main@1')
    this.ilGen.add('set %TOP% %SP%')
    for (let i = 0; i < this.stmts.length; i++) {
      (<Stmt | Expr>this.stmts[i]).gen(this.ilGen, this.lexicalScope)
    }
    this.ilGen.endSection()
  }
}