hxasm/Context.as

   1 package hxasm {
   2
   3         public class Context {
   4                 public function Context() : void {
   5                         this.lints = new Array();
   6                         this.lfloats = new Array();
   7                         this.lstrings = new Array();
   8                         this.lnamespaces = new Array();
   9                         this.lnssets = new Array();
  10                         this.lmtypes = new Array();
  11                         this.lnames = new Array();
  12                         this.lclasses = new Array();
  13                         this.lmethods = new Array();
  14                         this.hstrings = new Hash();
  15                         this.bytepos = 0;
  16                         this.emptyString = this.string("");
  17                         this.nsPublic = this.namespace(HNamespace.NPublic(this.emptyString));
  18                         this.arrayProp = this.name(Name.NMultiNameLate(this.nsset([this.nsPublic])));
  19                         this.beginFunction({ args : [], ret : null});
  20                         this.ops([OpCode.OThis,OpCode.OScope]);
  21                         this.init = this.curMethod;
  22                         this.init.maxStack = 2;
  23                         this.init.maxScope = 2;
  24                 }
  25                 protected var lints : Array;
  26                 protected var lfloats : Array;
  27                 protected var lstrings : Array;
  28                 protected var lnamespaces : Array;
  29                 protected var lnssets : Array;
  30                 protected var lnames : Array;
  31                 protected var hstrings : Hash;
  32                 protected var lclasses : Array;
  33                 protected var lmtypes : Array;
  34                 protected var lmethods : Array;
  35                 protected var curClass : *;
  36                 protected var curMethod : *;
  37                 protected var init : *;
  38                 protected var fieldSlot : int;
  39                 protected var bytepos : int;
  40                 protected var registers : Array;
  41                 public var emptyString : Index;
  42                 public var nsPublic : Index;
  43                 public var arrayProp : Index;
  44                 public function _int(i : int) : Index {
  45                         return this.lookup(this.lints,i);
  46                 }
  47                 public function float(f : Number) : Index {
  48                         return this.lookup(this.lfloats,f);
  49                 }
  50                 public function string(s : String) : Index {
  51                         var n : * = this.hstrings.get(s);
  52                         if(n == null) {
  53                                 this.lstrings.push(s);
  54                                 n = this.lstrings.length;
  55                                 this.hstrings.set(s,n);
  56                         }
  57                         return Index.Idx(n);
  58                 }
  59                 public function namespace(n : HNamespace) : Index {
  60                         return this.elookup(this.lnamespaces,n);
  61                 }
  62                 public function nsset(ns : Array) : Index {
  63                         {
  64                                 var _g1 : int = 0, _g : int = this.lnssets.length;
  65                                 while(_g1 < _g) {
  66                                         var i : int = _g1++;
  67                                         var s : Array = this.lnssets[i];
  68                                         if(s.length != ns.length) continue;
  69                                         var ok : Boolean = true;
  70                                         {
  71                                                 var _g3 : int = 0, _g2 : int = s.length;
  72                                                 while(_g3 < _g2) {
  73                                                         var j : int = _g3++;
  74                                                         if(!Type.enumEq(s[j],ns[j])) {
  75                                                                 ok = false;
  76                                                                 break;
  77                                                         }
  78                                                 }
  79                                         }
  80                                         if(ok) return Index.Idx(i + 1);
  81                                 }
  82                         }
  83                         this.lnssets.push(ns);
  84                         return Index.Idx(this.lnssets.length);
  85                 }
  86                 public function name(n : Name) : Index {
  87                         return this.elookup(this.lnames,n);
  88                 }
  89                 public function type(path : String) : Index {
  90                         if(path == "*") return null;
  91                         var path1 : Array = path.split(".");
  92                         var cname : String = path1.pop();
  93                         var pid : Index = this.string(path1.join("."));
  94                         var nameid : Index = this.string(cname);
  95                         var pid1 : Index = this.namespace(HNamespace.NPublic(pid));
  96                         var tid : Index = this.name(Name.NName(nameid,pid1));
  97                         return tid;
  98                 }
  99                 public function property(pname : String,ns : Index = null) : Index {
 100                         var pid : Index = this.string("");
 101                         var nameid : Index = this.string(pname);
 102                         var pid1 : Index = (ns == null?this.namespace(HNamespace.NPublic(pid)):ns);
 103                         var tid : Index = this.name(Name.NName(nameid,pid1));
 104                         return tid;
 105                 }
 106                 public function methodType(m : *) : Index {
 107                         this.lmtypes.push(m);
 108                         return Index.Idx(this.lmtypes.length - 1);
 109                 }
 110                 protected function lookup(arr : Array,n : *) : Index {
 111                         {
 112                                 var _g1 : int = 0, _g : int = arr.length;
 113                                 while(_g1 < _g) {
 114                                         var i : int = _g1++;
 115                                         if(arr[i] == n) return Index.Idx(i + 1);
 116                                 }
 117                         }
 118                         arr.push(n);
 119                         return Index.Idx(arr.length);
 120                 }
 121                 protected function elookup(arr : Array,n : *) : Index {
 122                         {
 123                                 var _g1 : int = 0, _g : int = arr.length;
 124                                 while(_g1 < _g) {
 125                                         var i : int = _g1++;
 126                                         if(Type.enumEq(arr[i],n)) return Index.Idx(i + 1);
 127                                 }
 128                         }
 129                         arr.push(n);
 130                         return Index.Idx(arr.length);
 131                 }
 132                 public function getDatas() : * {
 133                         return { ints : this.lints, floats : this.lfloats, strings : this.lstrings, namespaces : this.lnamespaces, nssets : this.lnssets, names : this.lnames, mtypes : this.lmtypes, classes : this.lclasses, methods : this.lmethods, init : Index.Idx(0)}
 134                 }
 135                 protected function beginFunction(mt : *) : Index {
 136                         this.curMethod = { type : this.methodType(mt), nRegs : mt.args.length + 1, maxScope : 0, maxStack : 0, opcodes : []}
 137                         this.lmethods.push(this.curMethod);
 138                         this.registers = new Array();
 139                         {
 140                                 var _g1 : int = 0, _g : int = this.curMethod.nRegs;
 141                                 while(_g1 < _g) {
 142                                         var x : int = _g1++;
 143                                         this.registers.push(true);
 144                                 }
 145                         }
 146                         return Index.Idx(this.lmethods.length - 1);
 147                 }
 148                 public function allocRegister() : int {
 149                         {
 150                                 var _g1 : int = 0, _g : int = this.registers.length;
 151                                 while(_g1 < _g) {
 152                                         var i : int = _g1++;
 153                                         if(!this.registers[i]) {
 154                                                 this.registers[i] = true;
 155                                                 return i;
 156                                         }
 157                                 }
 158                         }
 159                         this.registers.push(true);
 160                         this.curMethod.nRegs++;
 161                         return this.registers.length - 1;
 162                 }
 163                 public function freeRegister(i : int) : void {
 164                         this.registers[i] = false;
 165                 }
 166                 public function beginClass(path : String) : * {
 167                         this.endClass();
 168                         var index : Index = Index.Idx(this.lclasses.length);
 169                         var tpath : Index = this.type(path);
 170                         var st : Index = this.beginFunction({ args : [], ret : null});
 171                         this.op(OpCode.ORetVoid);
 172                         var m : Index = this.beginFunction({ args : [], ret : null});
 173                         this.op(OpCode.ORetVoid);
 174                         this.fieldSlot = 1;
 175                         this.curClass = { index : index, name : tpath, superclass : this.type("Object"), constructorType : this.curMethod.type, constructor : m, statics : st, fields : [], staticFields : []}
 176                         this.lclasses.push(this.curClass);
 177                         this.curMethod = null;
 178                         return this.curClass;
 179                 }
 180                 protected function endClass() : void {
 181                         if(this.curClass == null) return;
 182                         this.curMethod = this.init;
 183                         this.ops([OpCode.OGetGlobalScope,OpCode.OGetLex(this.type("Object")),OpCode.OScope,OpCode.OGetLex(this.curClass.superclass),OpCode.OClassDef(this.curClass.index),OpCode.OPopScope,OpCode.OInitProp(this.curClass.name)]);
 184                         this.curMethod = null;
 185                         this.curClass = null;
 186                 }
 187                 public function beginMethod(mname : String,targs : Array,tret : Index,isStatic : * = null,isOverride : * = null,isFinal : * = null) : * {
 188                         var m : Index = this.beginFunction({ args : targs, ret : tret});
 189                         var fl : Array = (isStatic?this.curClass.staticFields:this.curClass.fields);
 190                         fl.push({ name : this.property(mname), slot : 0, kind : FieldKind.FMethod(m,isFinal,isOverride)});
 191                         return this.curMethod;
 192                 }
 193                 public function defineField(fname : String,t : Index,isStatic : * = null) : int {
 194                         var fl : Array = (isStatic?this.curClass.staticFields:this.curClass.fields);
 195                         var slot : int = this.fieldSlot++;
 196                         fl.push({ name : this.property(fname), slot : slot, kind : FieldKind.FVar(t)});
 197                         return slot;
 198                 }
 199                 public function op(o : OpCode) : void {
 200                         this.curMethod.opcodes.push(o);
 201                         var w : OpWriter = new OpWriter();
 202                         w.write(o);
 203                         this.bytepos += w.getBytes().length;
 204                 }
 205                 public function ops(ops : Array) : void {
 206                         {
 207                                 var _g1 : int = 0, _g : int = ops.length;
 208                                 while(_g1 < _g) {
 209                                         var i : int = _g1++;
 210                                         this.op(ops[i]);
 211                                 }
 212                         }
 213                 }
 214                 public function backwardJump() : Function {
 215                         var start : int = this.bytepos;
 216                         var me : Context = this;
 217                         this.op(OpCode.OLabel);
 218                         return function(jcond : JumpStyle) : void {
 219                                 me.op(OpCode.OJump(jcond,start - me.bytepos - 4));
 220                         }
 221                 }
 222                 public function jump(jcond : JumpStyle) : Function {
 223                         var ops : Array = this.curMethod.opcodes;
 224                         var pos : int = ops.length;
 225                         this.op(OpCode.OJump(JumpStyle.JTrue,-1));
 226                         var start : int = this.bytepos;
 227                         var me : Context = this;
 228                         return function() : void {
 229                                 ops[pos] = OpCode.OJump(jcond,me.bytepos - start);
 230                         }
 231                 }
 232                 public function finalize() : void {
 233                         this.endClass();
 234                         this.curMethod = this.init;
 235                         this.op(OpCode.ORetVoid);
 236                         this.curMethod = null;
 237                         this.curClass = null;
 238                 }
 239         }
 240 }