assets/developer-notes/stephanie-gawroriski/2016/03/08.mkd

   1 # 2016/03/08
   2
   3 ## 00:14
   4
   5 Perhaps later today I can figure out ZIP files. I suppose the next thing I will
   6 do is just do a massive dump of the central directory tables to attempt to see
   7 if there is any sane way to determine how large a local file is along with its
   8 header.
   9
  10 ## 11:09
  11
  12 Perhaps what I can do to limit the massive number of constants that I have in
  13 the ZIP code for all of the offsets, I can do a typesafe kind of enumeration
  14 structure reference based on an input pointer. Doing it this way I can then
  15 have all the fields defined in an enumeration which can handle the type. Then
  16 I could perform a read on those fields and use long/int/short/byte as required.
  17 That would be easier to debug because I could just read and print them without
  18 giant print statements with constants. It would also probably be less prone to
  19 bugs because then the field being requested would be known.
  20
  21 ## 11:20
  22
  23 Actually realization, I suppose a stressful day yesterday was messing with my
  24 thinking. Anyway, I can determine the size of the zip by using the local file
  25 offsets. Note that these can appear in any order, so I get them all first and
  26 have it so I know which values belong to what. I then sort all of them to
  27 determine their logical placement in the file. Then using that I can determine
  28 how large the actual ZIP is. One thing I would have to handle though is
  29 polyglots and situations where local file indexes are in the contents of
  30 stored entries. So also with this I am going to go into the structured enum
  31 form so I do not have to rely on adding with constants. Then I am going to fix
  32 my code around that, then perform the required calculation to determine the
  33 actual ZIP size. The good thing with the ZIP format is that there is the offset
  34 to the start of the central directory start which will be useful. Also
  35 currently I use the central directory size to determine where it starts from
  36 the end. So doing both of these will end up with clean code and should result
  37 in working ZIP code. I have been working on this ZIP code for 6 days, and
  38 hopefully after this I just need to get the decompression algorithms
  39 implemented and then I can continue with loading classes.
  40
  41 ## 19:17
  42
  43 Was a busy outside real life day today. However I do know what I want to do.
  44 First I will write the structure code so I can have a safer way to access the
  45 raw ZIP data without potentially falling into bugs and such.
  46
  47 ## 19:35
  48
  49 I can also throw the magic number information in the structure data also. I
  50 suppose due to the way it works, using an enumeration would be a bit silly so
  51 I really could just use a base class to do these things.
  52
  53 ## 20:44
  54
  55 Structured reading will be a bit slower, however it will be more safer and
  56 such. Plus, it may be possible for it to be optimized later on when things are
  57 finished.
  58
  59 ## 20:49
  60
  61 I can also have bounds checking on the read also to make sure things are
  62 working properly also.
  63
  64 ## 20:52
  65
  66 Well moving part of my code to the structured system was quite easy and was no
  67 trouble at all. If in the future I may need it again I could always put it in
  68 its own package and use it as such.
  69
  70 ## 22:30
  71
  72 All of these structure stuff can use up a bunch of memory, however I will
  73 likely have an aggressive garbage collector which can collect entire classes
  74 if they all objects are not externally references. So even if a public static
  75 final of an object of a class exists, if nothing points to any instance of the
  76 given object for a class and say the objects all reference themselves. Then
  77 that means the class and all of its finals can be removed. So say there is not
  78 much memory and a ZIP file is being read. Say for example the system runs out
  79 of memory reading the central directory. If say for example the end directory
  80 structure class is no longer referenced except by itself, then it can be
  81 collected and the static finals collected. Then if the ZIP loading code hits
  82 the class again, it will load it again. Although this would reduce speed,
  83 memory is very important. However if a class is statically compiled into the
  84 ROM then it may be possible for ROM based instances to exist. For example if
  85 all code paths for a static final are well known, then the object would always
  86 exist and be within the ROM data. I can do this and get away with it because
  87 there is no reflection and no way to access fields using reflection. So if and
  88 when Java ME adds reflection, that will be the day it will no longer have the
  89 potential for optimization on size and memory.
  90
  91 ## 22:39
  92
  93 So this means that my static compiler and the class compiler can use the
  94 interpreter and such to determine if a prebuilt static final is constant
  95 viable. Of course I would need to remove this optimization in the run-time
  96 system when loading JARs because otherwise I would need to keep the JAR and
  97 byte code around. Writing a disassembler to evaluate would be a large mess.
  98 However, I could still include it potentially if desired. Everything would be
  99 ahead of time and cached before being used. So for example if I were to target
 100 the Nintendo 64 with a flash cart, I could keep the byte code in the ROM to
 101 allow for static optimization.
 102
 103 ## 22:43
 104
 105 The only problem with this is that it would violate how Java would see things
 106 so I would need to have a defer for it to work properly. Normally, when
 107 initializing a static final, all other fields following it will not be
 108 initialized at all. So when the fields are being initialized I will have to
 109 have a pointer of sorts. Essentially, the constructor will just set the pointer
 110 of the field to the precomposed object that already exists.
 111
 112 ## 23:10
 113
 114 Actually, determining the size of the ZIP is quite simple. All I need to do is
 115 determine the size of the end central directory, use the provided offset to the
 116 start of the central directory and its size. Then that is the size of the ZIP.
 117
 118 ## 23:19
 119
 120 And that was simple, I just need to make sure it works with a bunch of
 121 arbitrary data placed before the ZIP. It says it starts at 2097152 and I did
 122 `dd if=/dev/urandom bs=1048576 count=2`. So yes that works.
 123
 124 ## 23:56
 125
 126 Ok so the next thing to do tomorrow when I awaken is to start reading actual
 127 entries and implementing inflation and the CRC32 calculator to determine if
 128 data is valid or not.
 129