assets/developer-notes/stephanie-gawroriski/2019/02/27.mkd

   1 # 2019/02/27
   2
   3 ## 06:42
   4
   5 For simplicity, Java instructions are going to map one to one to IL
   6 instructions since that is the easiest thing to pretty much do. Of
   7 course there will be some operations which do not need the specific
   8 type stuff since I want to remove that need. That is the type of
   9 a variable will be done in the copy and not encoded in the instruction.
  10
  11 ## 07:24
  12
  13 Okay, so I have an idea what to do for exceptions. For this I will have
  14 a separate pre-built code area which is for the exception handlers which
  15 will need to be processed. They will just be offset and be at the end of
  16 the code area. Throws will just be jumps to exception handlers, although
  17 I have not yet handled how propogating up the stack will be done but
  18 perhaps that is done with a special instruction. This means that for
  19 invokes or anything that could generate an instruction there will need to
  20 be an instructional jump target. So for Java instructions which throw an
  21 exception, I will need to pass a reference to a method which generates the
  22 exception and then also pass the exception handler address. For simplicity
  23 I want to completely decouple exception handling and just treat it as
  24 normal methods, code jumps, and compares. Also for `isinstance` I can just
  25 do a table of sorts in the loaded class object which contains class
  26 pointers to every instance that a class is. It works and is just a linear
  27 scan. This keeps things a bit simple. At least when classes load at the
  28 root they just need to copy all of the instance pointers as a set then
  29 just the current class has to be scanned. Well the current class is scanned
  30 and then for the extend and each interface all of those class pointers will
  31 be loaded to the table. It is only recursive at a single level so that is
  32 fine.