assets/developer-notes/stephanie-gawroriski/2016/04/07.mkd

   1 # 2016/04/07
   2
   3 ## 09:47
   4
   5 Going to need some kind of operational logic that a program uses so that things
   6 are done for example. The interpreter and compiler could use those logical
   7 bits to perform actual actions and such.
   8
   9 ## 10:15
  10
  11 Can do better with variable storage.
  12
  13 ## 13:00
  14
  15 Actually when it comes to the interpreter, I will need the method code to
  16 actually perform the execution. I have to do this because for example during
  17 class initialization I will have to jump into the guest virtual machine to
  18 initialize objects as they appear in the guest. My current thread based stuff
  19 sort of works, but no quite as much. So basically what I have in the thread
  20 stuff now will be changed over. When a guest method goes to invoke another
  21 guest method it will just perform the same logic and such on the destination
  22 method.
  23
  24 ## 15:21
  25
  26 A work around is needed for `Class`. I will need to note this in the future
  27 when native code is generated. Since every object references a class for the
  28 `getClass()` method, on initialization the `Class` object's initialized
  29 object would not exist at all. Thus a minor work around is needed so that it
  30 exists and can be used for example.
  31
  32 ## 15:23
  33
  34 What I need now is to interpret the class constructor, which would be very
  35 important.
  36
  37 ## 17:32
  38
  39 Going to need classes for the primitive types.
  40
  41 ## 20:20
  42
  43 I suppose I can do the same thing as I did before, by using an interface and
  44 implementations of that so that logicals may be created and returned based on
  45 the instruction used. However, there are going to be logicals for instructions
  46 which are exactly the same. Right now, my logicals are planned to be sub-things
  47 based on the byte code. However that might not actually be needed at all. Well
  48 really my plan for logicals was for it to be stuff such as add, subtract, and
  49 other things with variables. What is really just needed is an abstract class
  50 of sorts which wraps operation handlers for input and output. I could also
  51 possibly have a kind of abstract computation machine so that when operations
  52 are called, the actual codes can be generated and such. So basically remove
  53 logicals and just have operation handlers that I had similarly before. However
  54 instead of a list of operations to perform, there is instead a logical machine
  55 of sorts which operates on something. I would need to pass an argument back
  56 and forth so that way I do not have to create a few thousand objects for each
  57 instruction to be executed. So basically it would look like this:
  58
  59         public interface CPComputeMachine<P>
  60         {
  61                 public abstract void add(P __pass, ? __dest, ? __a, ? __b);
  62         }
  63
  64         CPOp.<P>compute(CPComputeMachine<P> __p, P __pass);
  65
  66 This compute machine would be able to be used by later operations to set the
  67 variable states without performing an actual work. The method I listed above
  68 would essentially just perform the actual operation work and handle calling
  69 into the compute machine with the given object. Then I just need one compute
  70 machine implemented for the inetrpreter. The compiler would also use the
  71 compute machine to perform any intermediary work between operations. I would
  72 support currently my compute machine would not be as optimizing (just not
  73 performing wasteful stack moving operations) as I intend it to be in the future
  74 currently. However, if the backend calling into the compute machine becomes
  75 optimized (such as compacting adds and removing useless operations) then the
  76 interpreter and compiler should remain untouched for the most part.
  77
  78 ## 20:32
  79
  80 What I need however is a class which acts as an ideal type of variable
  81 reference. I suppose just integer variable references could do. At least to the
  82 interpreter it will have the feeling of being given the local variable IDs to
  83 do stuff on, while for the compiler this would be virtual registers. So yes,
  84 the integer would just be the register for the most part. It would not be
  85 precisely SSA at least as seen by the interpreter and compiler though. However,
  86 any optimizations would be done by the program layout itself which may use SSA
  87 or not. The only thing that is really needed is that the execution layer is
  88 called with the right logical code.
  89
  90 ## 20:47
  91
  92 Accidently lost some of my notes. However they were just a few sentences on
  93 the my idea and a creation of an index for the blog. Actually the only thing
  94 I really lost was my idea of having an `index.mkd` for the blogs so they can be
  95 indexed and I can have that info there. Luckily though my paragraph before this
  96 I had an open web browser seeing what I wrote which is nice.
  97
  98 ## 21:15
  99
 100 I can also setup a manual too which contains the needed operations and such
 101 for how to build and run the stuff.
 102