Подтвердить что ты не робот

Ошибка # 1030: глубина стека несбалансирована

У меня есть эта странная проблема, когда этот код:

private function initLevel():void {
    var levelMap:Array = 
    [ 
           [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
           [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
    ];
    for (var y:* in levelMap) {
        for (var x:* in levelMap[y]) {
            trace(y, x);
            trace(levelMap[y, x]);
        }
    }
}

создает этот уродливый монстр в flashdevelop:

typecheck Level/initLevel()
  outer-scope = [global Object$ flash.events::EventDispatcher$ flash.display::DisplayObject$ flash.display::InteractiveObject$ flash.display::DisplayObjectContainer$ flash.display::Sprite$ flash.display::MovieClip$ Level$]
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {} ()
  0:debugfile "L:\svntest\flashgame\src;com\thom\TD;Level.as"
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {} ()
  2:debugline 66
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {} ()
  4:getlocal0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {} (Level[O])
  5:pushscope
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} ()
  6:pushundefined
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (void[A])
  7:coerce_a
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (*[A])
  8:setlocal2
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} ()
  9:pushundefined
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (void[A])
  10:coerce_a
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (*[A])
  11:setlocal3
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} ()
  12:debug
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} ()
  17:debug
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} ()
  22:debugline 69
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} ()
  24:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (int[I])
  26:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (int[I] int[I])
  28:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (int[I] int[I] int[I])
  30:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (int[I] int[I] int[I] int[I])
  32:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (int[I] int[I] int[I] int[I] int[I])
  34:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (int[I] int[I] int[I] int[I] int[I] int[I])
  36:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  38:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  40:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  42:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  44:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  46:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  48:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  50:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  52:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  54:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  56:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  58:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  60:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  62:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  64:newarray 20
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O])
  66:debugline 70
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O])
  68:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] int[I])
  70:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] int[I] int[I])
  72:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] int[I] int[I] int[I])
  74:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] int[I] int[I] int[I] int[I])
  76:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] int[I] int[I] int[I] int[I] int[I])
  78:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] int[I] int[I] int[I] int[I] int[I] int[I])
  80:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  82:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  84:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  86:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  88:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  90:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  92:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  94:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  96:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  98:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  100:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  102:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  104:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  106:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (...10: int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  108:newarray 20
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] Array[O])
  110:debugline 71
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] Array[O])
  112:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] Array[O] int[I])
  114:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] Array[O] int[I] int[I])
  116:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] Array[O] int[I] int[I] int[I])
  118:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] Array[O] int[I] int[I] int[I] int[I])
  120:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] Array[O] int[I] int[I] int[I] int[I] int[I])
  122:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] Array[O] int[I] int[I] int[I] int[I] int[I] int[I])
  124:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] Array[O] int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  126:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] Array[O] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  128:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] Array[O] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  130:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] Array[O] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  132:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] Array[O] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  134:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] Array[O] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  136:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] Array[O] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  138:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] Array[O] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  140:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] Array[O] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  142:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] Array[O] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  144:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] Array[O] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  146:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] Array[O] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  148:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (...10: Array[O] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  150:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (...11: int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  152:newarray 20
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] Array[O] Array[O])
  154:debugline 72
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] Array[O] Array[O])
  156:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] Array[O] Array[O] int[I])
  158:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] Array[O] Array[O] int[I] int[I])
  160:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] Array[O] Array[O] int[I] int[I] int[I])
  162:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] Array[O] Array[O] int[I] int[I] int[I] int[I])
  164:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] Array[O] Array[O] int[I] int[I] int[I] int[I] int[I])
  166:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] Array[O] Array[O] int[I] int[I] int[I] int[I] int[I] int[I])
  168:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] Array[O] Array[O] int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  170:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] Array[O] Array[O] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  172:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] Array[O] Array[O] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  174:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] Array[O] Array[O] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  176:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] Array[O] Array[O] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  178:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] Array[O] Array[O] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  180:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] Array[O] Array[O] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  182:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] Array[O] Array[O] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  184:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] Array[O] Array[O] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  186:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] Array[O] Array[O] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  188:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] Array[O] Array[O] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  190:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (...10: Array[O] Array[O] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  192:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (...11: Array[O] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  194:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (...12: int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  196:newarray 20
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] Array[O] Array[O] Array[O])
  198:debugline 73
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] Array[O] Array[O] Array[O])
  200:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] Array[O] Array[O] Array[O] int[I])
  202:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] Array[O] Array[O] Array[O] int[I] int[I])
  204:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] Array[O] Array[O] Array[O] int[I] int[I] int[I])
  206:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] Array[O] Array[O] Array[O] int[I] int[I] int[I] int[I])
  208:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] Array[O] Array[O] Array[O] int[I] int[I] int[I] int[I] int[I])
  210:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] Array[O] Array[O] Array[O] int[I] int[I] int[I] int[I] int[I] int[I])
  212:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] Array[O] Array[O] Array[O] int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  214:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] Array[O] Array[O] Array[O] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  216:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] Array[O] Array[O] Array[O] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  218:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] Array[O] Array[O] Array[O] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  220:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] Array[O] Array[O] Array[O] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  222:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] Array[O] Array[O] Array[O] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  224:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] Array[O] Array[O] Array[O] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  226:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] Array[O] Array[O] Array[O] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  228:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] Array[O] Array[O] Array[O] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  230:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (Array[O] Array[O] Array[O] Array[O] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I] int[I])
  232:pushbyte 0
                       [Level[O] *[A] *[A] *[A] *[A] *[A] *[A] *[A]] {Level[O]} (...10: Array[O] 
//SIXTY THOUSAND CHAR SNIP  
  804:callproperty trace 1
                       [Level[O] Array[O] *[A] *[A] int[I] *[A] int[I] *[A]] {Level[O]} (global[O] *[A])
  807:pop
                       [Level[O] Array[O] *[A] *[A] int[I] *[A] int[I] *[A]] {Level[O]} (global[O])
------------------------------------
MERGE CURRENT 808:     [Level[O] Array[O] *[A] *[A] int[I] *[A] int[I] *[A]] {Level[O]} (global[O])
MERGE TARGET B808:     [Level[O] Array[O] *[A] *[A] int[I] *[A] int[I] *[A]] {Level[O]} ()
[Fault] exception, information=VerifyError: Error #1030: Stack depth is unbalanced. 1 != 0.

Я думаю, что это имеет какое-то отношение к определению области или что-то в этом роде, но я в тупике.

Спасибо за любую помощь заранее

4b9b3361

ОТВЕТЫ

Ответ 1

A Я сказал в предыдущих комментариях, я думаю, что это ошибка компилятора, основанная на простом факте, что компилятор выпустил нелегальный байт-код, и игрок смог поймать этот неверный байт-код и выбрал VerifyError соответственно.

Однако, после некоторого исследования, я нашел пару интересных вещей.

Во-первых, результаты Джони поставили меня на правильный путь. По-видимому, как показывает его код, вы можете обмануть компилятор для перевода между квадратными скобками в качестве доступа к свойствам.

Итак, это:

foo[foo,'length']

эквивалентно:

foo["length"]

Здесь проблема, но я объясню это через секунду.

Вы также можете вызвать методы, например:

var foo:Array = [];
foo[foo,'push'](1);
trace(foo);

Это эффективно нажимает 1 на foo

С некоторыми дополнительными обманами вы можете связать все это, чтобы получить этого неприятного зверя:

var inner:Array     = [10];
var outter:Array    = [1,2,inner];
(inner[outter, 'pop']).call(null)[inner,'push'].call(null,20);

trace(inner);
trace(outter);

Это эквивалентно:

var inner:Array     = [10];
var outter:Array    = [1,2,inner];
outter.pop().push(20);

То есть, мы выталкиваем inner из outter, а затем нажимаем на него 20.

Я начал замечать, что здесь

inner[outter, 'pop']

inner не используется.

Фактически вы можете изменить его на:

null[outter,'pop']

или даже

(void)[outter,'pop']

И компилятор не будет жаловаться на это (и игрок не будет). Я сомневаюсь, что приведенное выше действие ActionScript sintactically (в этом случае компилятор должен отказаться от его компиляции), но я не уверен на 100%. Однако этот неиспользуемый объект является корнем проблемы. (Ниже приведено несколько базовых знаний о том, как работает флеш-сборка или любая другая сборка на основе стека, но я надеюсь, что смогу ее объяснить, поэтому ее можно понять, не допуская слишком многого.)

Я разобрал байт-код, сгенерированный этим кодом ActionScript:

var arr:Array = [10];
null[arr,'length'];

Демонтированный код:

function private::initLevel():void  /* disp_id 0*/
{
  // local_count=2 max_scope=1 max_stack=3 code_len=17
  0     getlocal0       
  1     pushscope       
  2     pushbyte        10
  4     newarray        [1]
  6     coerce          Array
  8     setlocal1       
  9     pushnull        
  10    getlocal1       
  11    pushstring      "length"
  13    getproperty     null
  15    pop             
  16    returnvoid      
}

Отпустите шаг за шагом. instr - смещение команды; stack_state показывает текущее состояние стека после выполнения команды; comments не требует пояснений;)

  instr stack_state             comments
  -------------------------------------------------------------------------------------------      
  0     this                    "this" is always passed in local register 0 to instance methods
  1                             "this" is added to the scope chain and popped
  2     10                      now, we have 10 on the stack    
  4     [10]                    an array is created and initialized taking 1 element from the stack
  6     [10]                    this is sort of like doing [10] as Array
  8                             the array is assigned to local variable 1
  9     null                    null is pushed. That is the null in this line:
                                null[arr,'length']
                                HERE BEGINS THE PROBLEM!
  10    null,local1             local 1 is pushed
  11    null,local1,"length"    the string constant "length" is pushed
  13    null,local1["length"]   getproperty null is used for dynamic lookup (object["prop"]). Both operands are popped from the stack
  15    null                    in the previous step, the result of local1["lengtht"] was pushed. But we dind't use it, so it discarded
  16    null                    here the method returns. The stack should be empty, but it not. 
                                The generated code should have popped the null pushed at #9, 
                                or it shouldn't have pushed it in the first place

Проблема заключается в том, что после выхода из метода все объекты, помещенные в стек методом, должны быть выведены. Это не так, поскольку константа null остается в стеке после возвращения метода. Другими словами, у нас есть несбалансированный стек. Теперь игрок явно не против или не проверяет. Я думаю, что он должен и не должен запускать этот код, поскольку это могло бы (по крайней мере потенциально) привести к переполнению стека, если это станет больше.

Теперь, если мы изменим раздел проблемного кода, который должен быть включен в блок перехода (например, блок, достигнутый после условного перехода, например, if), игрок отклоняет код с сообщением:

VerifyError: Error #1030: Stack depth is unbalanced. 1 != 0.

То же, что и OP. Таким образом, кажется, что наличие ветки вызывает какую-то проверку целостности стека в проигрывателе. На этом этапе следует отметить, что цикл ActionScript (любой тип цикла) реализуется на уровне байт-кода в виде условного перехода, как и ìf. Таким образом, даже если у нас нет цикла в следующем коде (if создает код, который короче и проще анализировать), поскольку он вызывает эту проверку в проигрывателе, для наших целей, это то же самое, что иметь как это сделал OP.

В коде AS:

var dummy:int = 1;
var arr:Array = [10];
if(dummy != 0) {
    null[arr,'length'];
}

Разобранный:

function private::initLevel():void  /* disp_id 0*/
{
  // local_count=3 max_scope=1 max_stack=3 code_len=27
  0     getlocal0       
  1     pushscope       
  2     pushbyte        1
  4     setlocal1       
  5     pushbyte        10
  7     newarray        [1]
  9     coerce          Array
  11    setlocal2       
  12    getlocal1       
  13    pushbyte        0
  15    ifeq            L1

  19    pushnull        
  20    getlocal2       
  21    pushstring      "length"
  23    getproperty     null
  25    pop             

  L1: 
  26    returnvoid      
}

Шаг за шагом:

  instr stack_state             comments
  -------------------------------------------------------------------------------------------      
  0     this                    "this" is always passed in local register 0 to instance methods    
  1                             "this" is added to the scope chain and popped
  2     1                       now, we have 1 on the stack    
  4                             1 is popped and assigned to the local variable 1 (the dummy var in the code)
  5     10                      10 is pushed
  7     [10]                    an array is created and initialized taking 1 element from the stack
  9     [10]                    this is sort of like doing [10] as Array
  11                            the array is assigned to local variable 2 (the arr var in the code)
  12    local1                  local1 (dummy) is pushed
  13    local1,0                0 is pushed
  15                            this instruction consumes (pops) both local1 and 0 to compare them
                                If this condition is satisfied, it jumps to the label L1
                                If it is not, it falls-through to the next instruction 
                                (the same as a case label in a switch statement that does not have a break, in Actionscript code)
  19    null                    null is pushed. That is the null in this line:
                                null[arr,'length']  
                                Again, HERE BEGINS THE PROBLEM!
  20    null,local2             local2 is pushed
  21    null,local2,"length"    the string constant "length" is pushed
  23    null,local2["length"]   getproperty null is used for dynamic lookup (object["prop"]). Both operands are popped from the stack
  25    null                    the value returned by local2["length"] is discarded

  26    null                    the method returns, but null is not properly popped from the stack!

Итак, снова, null все еще находится в стеке после возврата метода; стек неуравновешен. Но на этот раз игрок проверяет это, находит проблему, бросает VerifyError и прерывает код.

Во всяком случае, чтобы завершить его, мои выводы заключаются в следующем: компилятор генерирует незаконный байт-код в обоих случаях. Я думаю, что это ошибка. Игрок отклоняет этот код, если он способен его обнаружить. Но кажется, что он способен обнаружить это только в том случае, если проблемный код находится в блоке перехода (тоже выглядит как ошибка).

Добавление:

Джони упоминает в комментарии, что "Если вы вернетесь сразу перед прыжком, то нет ошибки". Что является правдой. Причина в том, что код внутри if, но после возврата является "мертвым кодом", поэтому компилятор удаляет его из байт-кода.

Итак, это не сам прыжок, что заставляет игрока проверять целостность стека. Я немного искал Google и нашел это на сайте haxe.

Это несбалансированная ошибка стека. Это означает, что две ветки Результат перехода в разные размеры стека когда они присоединяются назад. Все прыжки или код приводя к заданной позиции, следует приводит к тому же размеру стека.

Это делает все более понятным.

Во втором примере кода выше, это то, что на самом деле происходит.

Если код следует за прыжком в инструкции 15, он попадает непосредственно в последнюю команду (26), чтобы вернуться к вызывающему. null не был нажат, и в стек больше ничего нет, поэтому мы приходим к этой точке с размером стека 0.

Если код не перескакивает и не падает, null будет нажата (19) и не будет удалена. Таким образом, этот путь достигнет последней команды (26) с помощью null в стеке, что означает, что размер стека равен 1. Эта последняя команда - это точка, в которой обе ветки соединяются, но после одной ветки размер стека равен 0, а следуя за другим, это 1. И это то, что заставляет игрока жаловаться на несбалансированный стек.

Ответ 2

Doh, я решил это, заменив [y,x] на [y][x]

Не уверен, почему он не дал более четкого сообщения о том, что я делал неправильно.

Ответ 3

Это фанки, мне это нравится. Какая ошибка!

levelMap[y, x]

Где y - объект, а x - свойство y.

Быстрый тест:

var levelMap:Array = [[0, 100],
                      [20, 21]];
var something:* = levelMap[levelMap[0], 1]; // 100 - The second element of the first array!
trace(something);
something = levelMap[levelMap[0], 'length']; // 2
trace(something);

Некоторое интересное поведение. Кто-нибудь может объяснить?

UPDATE:

Я думаю, что мы просто используем его неправильно.

var a:Object = {num:0, fun:function(num:uint):void{this.num = num;}};
var b:Object = {num:0};
b[a, 'fun'](10);                                                                                                                                                                              
trace(a.num); // 
trace(b.num); // 10

Где b - область видимости, a - объект, "fun" - это свойство a, а (10) - аргумент. Это равно (но все же с дополнительным объектом в стеке):

a.fun.call(b, 10);

Причина b не вытекает из стека, потому что она дублируется, а дубликат используется для вызова функции.

90:getscopeobject 1
    stack: StackTest
    locals: StackTest StackTest * 
92:getslot 2
    stack: Object? (b)
    locals: StackTest StackTest * 
94:dup
    stack: Object? (b) Object? (Copy of b)
    locals: StackTest StackTest * 
95:setlocal2
    stack: Object? (b)
    locals: StackTest StackTest Object? (Copy of b) 
96:getscopeobject 1
    stack: Object? (b) StackTest
    locals: StackTest StackTest Object? (Copy of b)
98:getslot 1
    stack: Object? (b) Object? (a)
    locals: StackTest StackTest Object? (Copy of b)
100:pushstring "fun"
    stack: Object? (b) Object? (a) String ("fun")
    locals: StackTest StackTest Object? (Copy of b)
102:getproperty {StackTest...Object}::[]
    stack: Object? (b) * (a.fun)
    locals: StackTest StackTest Object? (Copy of b)
104:getlocal2
    stack: Object? (b) * (a.fun) Object? (Copy of b)
    locals: StackTest StackTest Object? (Copy of b)
105:pushbyte 10
    stack: Object? (b) * (a.fun) Object? (Copy of b) int (10)
    locals: StackTest StackTest Object? (Copy of b)
107:call 1 (Call a closure. 1 is the argument count. Stack: function (a.fun), receiver (Copy of b), arg (10).  The result (void) is pushed on the stack.)
    stack: Object? (b) * (void)
    locals: StackTest StackTest Object? (Copy of b)
109:pop
    stack: Object? (b)
    locals: StackTest StackTest Object? (Copy of b)
110:kill 2
    stack: Object? (b)
    locals: StackTest StackTest *

Кроме того, некоторые фанки поведения можно увидеть с помощью этого синтаксиса:

b[1, true, a, 'fun'](10);

Кажется, вы можете просто добавлять неиспользуемые объекты в стек и оценивать только последние 2.

Ответ 4

Для всех, кто сталкивается с подобными ошибками, я получил эту ошибку из необычной поздней ночи:

SomeClass.staticMethod[var1,var2]

вместо

SomeClass.staticMethod(var1,var2)

Ответ 5

omg вы, скорее всего, просто решили мистическую проблему, которая чуть не убила меня ^ _ ^ Я пытался воссоздать swf файл из дампа:

`[SWF]
  Header:
    Version: 10
    FileLength: 623
    FileLengthCompressed: 454
    FrameSize: (180,160)
    FrameRate: 8
    FrameCount: 10
  Tags:
    [69:FileAttributes] AS3: true, HasMetadata: false, UseDirectBlit: false, UseGPU: false, UseNetwork: false
    [09:SetBackgroundColor] Color: #666666
    [86:DefineSceneAndFrameLabelData]       Scenes:        [0] Frame: 0, Name: Scene 1
    [83:DefineShape4] ID: 1, ShapeBounds: (-100,1100,-100,1100), EdgeBounds: (0,1000,0,1000)
      FillStyles:
        [1] [SWFFillStyle] Type: 0 (solid), Color: FFFF0000
      LineStyles:`(and so on)

используя as3swf (библиотека, которая использует почти только байт-код внутри себя), но сегодня (со свежим загруженным flex sdk 4.1) все, что я получил, было странным следом (полученным много раз):

    [SWF]
    Version: 10
    FileLength: 21
    FileLengthCompressed: 21
    FrameSize: (14,14)
    FrameRate: 50
    FrameCount: 1
  Tags:

и самое странное для меня было то, что это был след глобальной переменной ByteArray хранилища, которая, скорее всего, была прочитана только во время выполнения, но информация, которую она хранила, отсутствовала только в некоторой части - почти каждое значение было изменено

так что спасибо за ваш ответ, он многое объяснил мне)

Ответ 6

Пропустил = на опечатке, что привело к этой сумасшедшей ошибке.

Нравится: array.var[x,y]; вместо array.var = [x,y];