Optimizer

Compiling
  DEBUG MODE
      Set the preprocessor constant OPTIMIZER_DEBUG_COMPILE to 1 to turn debug 
    code on in the optimizer. This is mainly used for devlopment.
    
  STASTICS MODE
      Set the preprocessor constant OPTIMIZER_STATS_COMPILE to 1 to turn on 
    statistics gathering in the optimizer. This will gather information on the 
    op-array before and after the optimizer in order to gague effectivness of 
    the optimizer. In addition it will keep track of the number of optimizations
    that occure. 
    
    NOTE: if both OPTIMIZER_DEBUG_COMPILE and OPTIMIZER_STATS_COMPILE are set to
      1 then the optimizer will build a list of optimizations that occured on a 
      given op-array and bump that. This is a great tool to see what is actually 
      going on inside the optimizer.
    
  STANDARD
      Standard compiling doesnt make use of any preprocessor constants and 
    should provide for a transparent running of the optimizer that does not 
    print out any data. BOTH DEBUG MODE and STAISTICS MODE will print extra 
    information out to stdout or stderr. 
    
    
    
INI values
  optimizer.enabled: Turns the optimizer on or off. When enabled=0 the optimizer 
      will NOT register hooks with APC.
      
  optimizer.verbose_debug: Allows for the printing of debug information (This 
      will probably be removed... but its handy to specify on the command line 
      while developing)
      
  optimizer.detect_static_function_calls: Used for building the optimizer (and 
      maybe an analyzer), this will output a line to indicate that a function 
      call with all static params was NOT optimized out.
      
  optimizer.report_constants:
  
  optimizer.report_only_native_func:
  
  optimizer.optimize_define: If set to 1 define() statements will be optimized 
      (this is a little bit buggy right now...)
  
  optimizer.optimize_assert: If set to 1 assert() statements will be removed.
  
  optimizer.inline_server: _SERVER variables that are safe to fold into static 
      literal values.
      
  optimizer.optimize_file_ops: If set to 1 some file oppeerations will be 
      performed at compile time as opposed to execution time. These 
      optimizations will ONLY occure when a all static parameters are being 
      passed to one of the file functions (for example... a string literal for a
      file name/path). Constant folding and DFA might effect this and therfore, 
      these optimizations may occure on more then just for functions with all 
      static parameters in source. It is important that this is ONLY done in 
      cases that you know the state of certain files will NOT change on the 
      server after compilation time and during the life cycle of the cached 
      op-code. 
      
      The optimizable file functions are as follows:
        file_exists()
        is_link()
        is_dir()
        is_file()
        is_executable()
        is_readable()
        is_writeable()
        fileatime()
        filectime()
        filegroup()
        fileinode()
        filemtime()
        fileowner()
        fileperms()
        filesize()
        filetype()
  
  
  
Testing
    At the moment all test cases are created as plain php files. The intent is 
    to eventually turn these into phpt test cases. At the moment, a VLD dump is 
    being used to manually verify that the expected optimization(s) occured.
