<?
/**
 * @author Gianluca GIMIGLIANO
 * @package myAutoloaders
 */

/**
 * Effettua un'indicizzazione delle classi e le include in modo trasparente ogni
 * volta che serve, e se vogliamo un myOffice ed un mySelect senza includere nulla.
 *
 * <code>
 * myAutoloader('../caches')->get_Istanza('../myForms');
 * new mySelect('');
 * new myOffice();
 * </code>
 * @see myAutoloaders
 */
class myAutoloader{
 protected static /** @ignore */	$percorsi_aggiunti,$istanza=null,$registrata,$individua_classi='/(?:\babstract\s+class|\bfinal\s*class|\bclass|\binterface)\s+([\w°§]+\b)(?:[a-z0-9_ \n\r\t\,]*\{)/isS';
 protected 		  /** @ignore */	$dirSaves,$percorsi_esclusi,$indici,$reloaded;
 protected static /** @ignore */	$debug,$tentativi_ricerca,$RamCache=null;

/** @ignore */
 protected  function __construct($dirSaves){
      $this->set_dir($dirSaves);
      self::$registrata=get_class($this).'::Loader';
      self::$tentativi_ricerca=1;
      $this->start();

  }

  /**
   * Imposta la directory, in cui andranno salvati i file temporanei
   * @access  public
   * @param string $dirSaves
   */
   public  function get_dir($dirSaves){
     return  $this->dirSaves;
  }

  /**
   * Imposta la directory, in cui andranno salvati i file temporanei
   * @access  public
   * @param string $dirSaves
   */
   public  function set_dir($dirSaves){
      $dirSaves=realpath($dirSaves);
      if (!is_dir($dirSaves)) throw new Exception("$dirSaves non è un directory valida");
      $this->dirSaves=$dirSaves;
  }

/**
 * Attiva autoloading
 */
  public function start(){
  	spl_autoload_unregister('__autoload');
  	spl_autoload_register(self::$registrata);
  	if (is_callable('__autoload')) spl_autoload_register('__autoload');
  }

 /**
   * Blocca autoloading
   */
  public function stop() {
  	spl_autoload_unregister('__autoload');
  	spl_autoload_unregister(self::$registrata);
  	if (is_callable('__autoload')) spl_autoload_register('__autoload');
   }


  public function set_debug($debug) {
    self::$debug=$debug;
   }

  /**
   * Abilita/disabilita, l'autorefresh della cache (sconsigliato disabilitarla)
   *
   * @param boolean $abilitato
   */
  public function auto_refresh($abilitato) {
    if ($abilitato) self::$tentativi_ricerca=0;
    		  else  self::$tentativi_ricerca=1;
   }




	/*** @ignore **/
  protected static function file_write($nome,$content,$append=false) {
     if($append) $content.=@file_get_contents($nome);
     $md5=md5($content);
     $n=0;
	 do{$esito=(strlen($content)==file_put_contents($nome,$content,LOCK_NB|LOCK_EX));
        if ($esito && $md5==@md5_file($nome)) return true;
        usleep($wt=mt_rand(100,90000));
        $n+=$wt;
      } while ($n<1000000);//attesa max 1 secondo poi getta la spugna
      return false;
  }




  /** @ignore */
 static function &leggi_file($file) {
 	  @include_once($file);
 	  $f=get_called_class().'_'.md5($file);
 	  if(class_exists($f,false)) return $f::get_paths();
  }


  /** @ignore */
  static function scrivi_file($file,$info) {
  	  $f=get_called_class().'_'.md5($file);
  	  $testo='<'."? abstract class $f{static function get_paths(){return ".var_export($info,1)."; }}?".'>';
  	  if(!self::file_write($file,$testo)) return;
  }



  /** Restituisce l'istanza della classe, essendo un singleton l'stanza è sempre la stessa
  *
  * @param string $dirSaves percorso in cui salvare i file di indicizzazione
  */

  static function get_Istanza($dirSaves) {
  	  if (self::$istanza!==null) {if (is_dir($dirSaves)) self::$istanza->set_dir($dirSaves);
  	  							  return self::$istanza;
  	  							  }
                          else   return self::$istanza=new myAutoloader($dirSaves);
  }


  /**
   * Indicizza le classi presenti in un percorso, può essere dir o file
   *
   * @param string $percorso          percorso in cui cercare script da indicizzare
   * @param array $percorsi_esclusi   array si percorsi da non indicizzare, se omesso non si esclude niente
   * @param int $profonditaMax        numero max di sottocartelle in cui cercare, se omesso tutte
   * @param boolean $forzaReload      se true tutti gli script vengono rianalizzati
   * @return boolean/istanza          se percorso errato restituisca falso altrimente il puntatore all'istanza
   */
  function &add_percorso($percorso,$percorsi_esclusi=array(),$profonditaMax=0,$forzaReload=false) {
   //  if (!is_dir($percorso) && !is_file($percorso)) return false;
                             	   {
                             	   self::$percorsi_aggiunti[$percorso]=func_get_args();
                             	   $percorso=realpath($percorso);
                             	   if(!$percorso) return false;
                             	   if (stripos($percorso,$this->dirSaves)===0) return $this;
                             	   $nome_file=$this->dirSaves.DIRECTORY_SEPARATOR.str_replace(array(':',DIRECTORY_SEPARATOR),array('^','^'),$percorso).'.php';
                                   if (!isset($this->indici[$percorso]) || !is_array($this->indici[$percorso])) $this->indici[$percorso]=self::leggi_file($nome_file);
                                   if (!isset($this->indici[$percorso]) || !is_array($this->indici[$percorso]) || $forzaReload)
                                                             {if (is_array($percorsi_esclusi)) foreach ($percorsi_esclusi as $i=>&$dirfile) if ($dirfile=realpath($dirfile)) $this->indici[$percorso]['esclusi'][$dirfile]=true;
                                                              $this->indici[$percorso]['profondita']=$profonditaMax;
                                                              $this->scanClass($percorso,$this->indici[$percorso]['esclusi'],$this->indici[$percorso]['classi'],$this->indici[$percorso]['profondita']);
                                                              $this->reloaded[$percorso]=true;
                                                             }
                                     return $this;
                                   }

   }

   /**
    * metodo statico invocato ad ogni new di classi non definite
    * @ignore
    * @param string $classe
    */
   static function Loader($classe){
   //echo "$classe<br>";
   		if (is_callable('__autoload')) {@__autoload($classe);
   										if (class_exists($classe,0) || interface_exists($classe,0)) return;
   										}

   		if (is_callable($classe) || class_exists($classe,0) || interface_exists($classe,0)) return;

   		static $unloaded;
   		$classe=trim(strtolower($classe));
   		if (isset($unloaded[$classe])) return false;
   		//echo "$classe?<br>";
   	    try {  self::$istanza->esegui_classe($classe,self::$tentativi_ricerca);
   	    	   unset($unloaded[$classe]);

   	   		 } catch (Exception $e)
   	   		 {$unloaded[$classe]=true;
			  if(self::$debug)  @file_put_contents(dirname(__FILE__).'/notAutoloaded.log',date("d/m/Y H:i:s")."\t$classe\t$_SERVER[REQUEST_URI]\t{$e->getMessage()} riga {$e->getLine()} script {$e->getFile()}\n", FILE_APPEND);
   	   		 }
   }


   /**
    * Esecuzione effettiva della classe
    *
    * @param string $classe
    * @ignore
    */
   protected function esegui_classe($classe,$tentativi=0) {
  	   $info_classe=&$this->cerca_classe($classe,$tentativi);
	   include_once($info_classe['file']);
       $variabili_definite=get_defined_vars(); //se per caso c'è un main eventuali variabili definite vengono "globalizzate" non è il massimo,
                                              //ma il main non ci dovrebbe essere
       if ($variabili_definite) foreach ($variabili_definite as $v=>&$val)
       					if ($v!='info_classe'){ global $$v;
       											 $$v=$val;
       											}
  }

  /**
   * Cerca la classe negli indici
   *
   * @param string $nome_classe
   * @ignore
   * @return string nome del file in cui è definita
   */
  protected function cerca_classe($nome_classe,$tentativo=0){
      $gia_inclusi=get_included_files();
      $out=array();
      if ($this->indici)
        foreach ($this->indici as $percorso=>&$percorsi) {
          if(isset($percorsi['classi'][$nome_classe]))
            {
             foreach ($percorsi['classi'][$nome_classe] as $percorsoFile=>&$chk)
               {//se il chk è stato annullato o il file non c'è più elimina questa classe dell'indice... le altre verranno eliminate gradualmente
                if (!$chk || !is_file($percorsoFile))
                	{unset($percorsi['classi'][$nome_classe][$percorsoFile]);
                	 $this->reloaded[$percorso]=true; //se il file non esiste più lo toglie dall'array e ne segna il salvataggio
                	}
                  else
                  	{$chk_attuale=self::calcola_chk($percorsoFile); //calcola il chk del file corrente
                     if ($chk!=$chk_attuale){
                     	                      $chk=null; //setto preventivamente check di questa classe a null
                     	                      $classi_estratte=&$this->estrai_classi($percorsoFile,$chk_attuale);
                     						  foreach ($classi_estratte as $classe_estratta=>&$chk_estratto) $percorsi['classi'][$classe_estratta][$percorsoFile]=$chk_estratto;
                     						  $this->reloaded[$percorso]=true; // segna il salvataggio
                     						  //dopo refresh delle classi di questo file chk potrebbe ancora essere null,
                     						  //perchè	la classe è stata eliminata dal file, alla prox chiamata verrà definitivamente tolta dall'indicizzazione
                     						}
                     if ($chk) $out[$chk]=array('file'=>$percorsoFile,'chk'=>$chk);
                    }
               }
          }
     }
    if (count($out)) ksort($out);
    	elseif ($tentativo==1) throw new Exception("Classe $nome_classe non trovata");
    		else { //se non trova la classe rianalizza tutti i percorsi forzando il reloading e riesegue questo metodo un'ultima volta
    			;
    			   foreach (self::$percorsi_aggiunti as $parametri) $this->add_percorso($parametri[0],$parametri[1],$parametri[2],true);
         		   return $this->cerca_classe($nome_classe,1);
         		 }

    return array_pop($out);
  }

  /**
   * Calcola un check per la verifica della versione del file
   *
   * @param string $file
   * @ignore
   * @return string
   */
  protected static function calcola_chk($file) {
  	   static $calcolati; //cache interna dei chk calcolati
  	   if (!isset($calcolati[$file])) $calcolati[$file]=filemtime($file);//.'|'.filesize($file);
  	   return $calcolati[$file];
  }

    /** @ignore */
  static function &minimizza_codice($src) {
  	static $prec;
  	if (isset($prec[$src]) && $prec[$src]) return $prec[$src];
    //if ($codicePHP=@php_strip_whitespace($src)) return $codicePHP;
    $codicePHP=@file_get_contents($src);
   	$codicePHP=@preg_replace('#([^/]{1})/\*.+\*/#sUS','\1',$codicePHP);
   	@file_put_contents(dirname(__FILE__).'/minimizzaAutoloaded.log',date("d/m/Y H:i:s")."\t$src\r\n", FILE_APPEND);

   	if (!$codicePHP) return '';
	$i=0;
 	do {
	$posApice=$i;
	//$Z=substr($codicePHP,$i);
	$primoApice=false;
	while (($primoApice=strpos($codicePHP,"'",$posApice))!==false) {
		             $retroverifica=$primoApice-1;
		             $nslash=0;
					 while ($codicePHP{$retroverifica--}=='\\') $nslash++;
					 if ($nslash%2)  $posApice=$primoApice+1;
					  	     else    break;
					}


	$posVirgolette=$i;
	$primoVirgolette=false;
	while (($primoVirgolette=strpos($codicePHP,'"',$posVirgolette))!==false) {
					 $retroverifica=$primoVirgolette-1;
		             $nslash=0;
					 while ($codicePHP{$retroverifica--}=='\\') $nslash++;
					 if ($nslash%2) $posVirgolette=$primoVirgolette+1;
					 		  else    break;
					}

	$inizioStringaSbagliata=false;
	$inizioStringa=false;
	$fineStringa=false;
	if ($primoVirgolette===false && $primoApice===false) $inizioStringa=strlen($codicePHP);
				else {
					  if ($primoVirgolette===false || ($primoApice!==false && $primoApice<$primoVirgolette))
									 {
									  $inizioStringa=$primoApice;
									  while (($primoApice=strpos($codicePHP,"'",$primoApice+1))!==false)
					 						{
					 						 $retroverifica=$primoApice-1;
		             						 $nslash=0;
					 						 while ($codicePHP{$retroverifica--}=='\\') $nslash++;
					 						 if ($nslash%2==0) break;
									    	}
					 				  if ($primoApice!==false) $fineStringa=$primoApice+1;
									  }
								else {
									  $inizioStringa=$primoVirgolette;
									    while (($primoVirgolette=strpos($codicePHP,'"',$primoVirgolette+1))!==false)
									    	{
					 						 $retroverifica=$primoVirgolette-1;
		             						 $nslash=0;
					 						 while ($codicePHP{$retroverifica--}=='\\') $nslash++;
					 						 if ($nslash%2==0) break;
									    	}
					 				  if ($primoVirgolette!==false) $fineStringa=$primoVirgolette+1;
									 }
					  }


	$posCommentoLinea=$i;
	//echo "\nAnalisi commenti di: ".substr($codicePHP,$posCommentoLinea,$inizioStringa-$posCommentoLinea+1);
	do {if (($c1=strpos($codicePHP,'//',$posCommentoLinea))===false) $c1=$inizioStringa+1;
	 	if (($c2=strpos($codicePHP,'#', $posCommentoLinea))===false) $c2=$inizioStringa+1;
		$primoCommentoLinea=min($c1,$c2);
		if ($primoCommentoLinea>=$inizioStringa) break;
					else{
						if (($primoNL=strpos($codicePHP,"\n",$primoCommentoLinea+1))===false)
									  $primoNL=strlen($codicePHP);
				   			   elseif($primoNL>$inizioStringa)  $inizioStringaSbagliata=true;

						if (($primoCR=strpos($codicePHP,"\r",$primoCommentoLinea+1))===false)
									  $primoCR=strlen($codicePHP);
							   elseif($primoCR>$inizioStringa) $inizioStringaSbagliata=true;


						$da_togliere=min($primoCR,$primoNL)-$primoCommentoLinea+1;
						//echo "\nELIMINATO:" .substr($codicePHP,$primoCommentoLinea,$da_togliere);

						$codicePHP=substr_replace($codicePHP,'',$primoCommentoLinea,$da_togliere);
						$inizioStringa-=$da_togliere;
						$fineStringa-=$da_togliere;
						$posCommentoLinea=$primoCommentoLinea;
						}
	   } while (true);

	  if (!$inizioStringaSbagliata)
	  	{
	  	$porzione= substr($codicePHP,$i,$inizioStringa-$i);
	    do{
	 		 $porzione=str_replace(array('  ',"\t","\r","\n"),array(' ',' ',' ',' '),$porzione,$tolti);
	    	} while ($tolti);
	 	$codicePHP=substr_replace($codicePHP,$porzione,$i,$inizioStringa-$i);
	 	if ($fineStringa===false) break;
	 	$i=$fineStringa-($inizioStringa-$i-strlen($porzione));
	  	}

	  if ($i===false) break;
	} while ($i<strlen($codicePHP) && $inizioStringa<strlen($codicePHP));

	$prec=array($src=>trim($codicePHP));
	return $prec[$src];
 }




  /**
   * Estrae un array con le classi individuate nel file e relativo chk
   *
   * @param string $file
   * @param string $chk se valorizzato non viene calcolato ma si prende per buono
   * @ignore
   * @return array
   */
  protected function &estrai_classi($file,$chk=null) {
  	  $classi=array();
  	  if ($chk===null) $chk=self::calcola_chk($file);
  	  $sorgenteScript= &self::minimizza_codice($file);
  	  if (preg_match_all(self::$individua_classi,$sorgenteScript,$matches))
			foreach ($matches[1] as &$classe) $classi[strtolower($classe)]=$chk;
	  //echo '<Pre>';	echo "$file\n";	print_r($matches);
      return $classi;
  }


  /**
   * Cerca classi nei vari file
   * @ignore
   * @param string $percorso   		 percorso base in cui si ricerca
   * @param array  $percorsi_esclusi array con i percorsi da non indicizzare
   * @param array  $classi     		 array in cui vengono inserite le classi trovate man mano
   * @param int $profonditamax       max profondità nella ricerca delle sottodirectory
   */
  protected function scanClass($percorso,&$percorsi_esclusi,&$classi,&$profonditamax,$profondita=1) {
  	 	  if (is_dir($percorso)) $files=@scandir($percorso);
  	  				   else {$files=array(basename($percorso));
  	  						 $percorso=dirname($percorso);
  	  						 $profonditamax=1;
  	  						 }
      foreach ($files as &$file)
         {$percorsoCorrente=$percorso.DIRECTORY_SEPARATOR.$file;
          if($file!='.' && $file!='..' && !isset($percorsi_esclusi[$percorsoCorrente]))
             {
                if (stripos($percorsoCorrente,'.php',strlen($percorsoCorrente)-4)!==false ||
		          stripos($percorsoCorrente,'.inc',strlen($percorsoCorrente)-4)!==false)
		       	   {
                  	$classi_estratte=&$this->estrai_classi($percorsoCorrente);
                  	foreach ($classi_estratte as $classe=>&$info) $classi[$classe][$percorsoCorrente]=&$info;
                   }
               elseif (($profonditamax==0 || $profondita<$profonditamax) &&  is_dir($percorsoCorrente) )
               				 $this->scanClass($percorsoCorrente,$percorsi_esclusi,$classi,$profonditamax,$profondita+1);
             }
         }
  }

    /** @ignore */
  function __destruct() {
  	  if (is_array(@ob_get_status()))  ob_end_flush();//invocato sempre alla fine dell script quindi prima di salvare pulisce eventuali buffer
  	  if ($this->reloaded) {
  			foreach ($this->reloaded as $percorso=>$null)
  				  	  self::scrivi_file($this->dirSaves.DIRECTORY_SEPARATOR.str_replace(array(':',DIRECTORY_SEPARATOR),array('^','^'),$percorso).'.php',$this->indici[$percorso]);
  			if(function_exists('apc_clear_cache')) apc_clear_cache();
  			if(function_exists('accelerator_reset')) accelerator_reset();
  		    }
  }

  function &get_indici($percorso=''){
  	    if ($percorso) return $this->indici[$percorso];
  				 else return $this->indici;
  }
}




/**
 * Ottimizzazione della myAutoloader
 * @see myAutoloaders
 *
 */
class myCachedAutoloader extends myAutoloader {
protected /** @ignore */	$da_salvare=array(),$noautoload_cache_exists=true,$usa_cache_classi=true,$classi_pronte=array(),$noInclude=false;
protected /** @ignore */    static $da_eseguire;


  /** Restituisce l'istanza della classe, essendo un singleton l'sianza è sempre la stessa
  *
  * @access  public
  * @param string $dirSaves percorso in cui salvare i file di indicizzazione
  */

  static function get_Istanza($dirSaves) {
  	  if (self::$istanza!==null) {if (is_dir($dirSaves)) self::$istanza->set_dir($dirSaves);
  	  							  return self::$istanza;
  	  							  }
                          else   return self::$istanza=new myCachedAutoloader($dirSaves);
  }



   /**
    * disabilita include, require nel main degli script inclusi
    *
    * @param boolean/array $modo se false disabilià l'opzione se omesso o true si applica a tutti
    * 							 se è un array indica a quali script non applicare
    * @return istanza corente
    */
   function set_noInclude($modo=true) {
   	if (is_bool($modo)) $this->noInclude=$modo;
   					else foreach ($modo as $path) if (is_file($path)) $this->noInclude[realpath($path)]=true;
   	return  $this;
   }


   /**
    * disabilita autoload nella funzione case_exists,
    * degli script inclusi
    *
    * @param boolean/array $modo se false disabilià l'opzione se omesso o true si applica a tutti
    * 							 se è un array indica a quali script non applicare
    * @return istanza corente
    */
   function set_noautoload_cache_exists($modo=true) {
   	if (is_bool($modo)) $this->noautoload_cache_exists=$modo;
   					else foreach ($modo as $path) if (is_file($path)) $this->noautoload_cache_exists[realpath($path)]=true;
   	return $this;
   }


   /**
    * se true il contenuto dei file indicizzati, viene man mano
    * memorizzato su disco
    *
    * @param boolean $usa_cache_classi
    * @return istanza corente
    */
   function usa_cache_classi($usa_cache_classi){
   	$this->usa_cache_classi=$usa_cache_classi;
   	return $this;
   }

  /** @ignore */
   static function class_exists($classe) {
   	    return class_exists($classe,false);
   }


  /** @ignore */
  public static function error_handler($errno ,  $errstr ){
  	   switch ($errno) {
        case E_NOTICE:
        case E_STRICT:
        case E_USER_NOTICE:
            return false;
            break;
        case E_WARNING:
        case E_USER_WARNING:
            $errors = "Warning";
            break;
        case E_ERROR:
        case E_USER_ERROR:
            $errors = "Fatal Error";
            break;
        default:
            $errors = "Ignoto";
            break;
        }


    if (ini_get("display_errors"))
        print("<br />\n<b>$errors</b>: $errstr <br><pre>".(self::$da_eseguire)."</pre><hr />\n\n\n\n");
    if (ini_get('log_errors'))
        error_log("PHP $errors:  $errstr\n".self::$da_eseguire );
   return true;

  }


   /**
    * Effettua evalutazione del codice passato,
    * se per caso c'è un main eventuali variabili definite vengono "globalizzate"
    *
    * @param string $____phpCode
    * @ignore
    */
   protected static function myEval ($____phpCode) {//echo '<pre>',$____phpCode,'</pre>';
     if (!trim($____phpCode) || $____phpCode==';') return;
   	 if(!self::$debug) eval($____phpCode);
   	 			 else {
   	 			 	  set_error_handler('myCachedAutoloader::error_handler');
   	 			 	     self::$da_eseguire=&$____phpCode;
   	 			 	     if (@eval("$____phpCode ; return true;")!==true) trigger_error('Errore');
   	 				  restore_error_handler();
   	 			 	}
     foreach (get_defined_vars() as $____k=>$____v)
       				if ($____k!='____phpCode')
       				    		{ global $$____k;
       							  $$____k=&$____v;
       							}
   }


   /** @ignore */
   function esegui_classe($classe,$tentativi=0) {
     if (!isset($this->classi_pronte[$classe]))
        {
 		 $infoclasse=&$this->cerca_classe($classe,$tentativi);

	     $md5fileClasse=md5($infoclasse['file']);
		 $define="define('__FILE__{$md5fileClasse}__','".addslashes($infoclasse['file'])."');define('__DIR__{$md5fileClasse}__','".addslashes(dirname($infoclasse['file']))."');";

	     $percorsoCache=$this->dirSaves.DIRECTORY_SEPARATOR.$md5fileClasse.'.class.php';
		 if ($this->usa_cache_classi)
			       {
					$classeCache=self::leggi_file($percorsoCache);
					if ($classeCache['chk']==$infoclasse['chk']  &&
				        count($classeCache['classi'])) {self::myEval($classeCache['Main']);
				        								$this->classi_pronte+=$classeCache['classi'];
													   }
											  	  else unset($classeCache);
		 	  	   }

	   	  if (!isset($classeCache))
	   	      {
	   		  $sorgenteScript=&self::minimizza_codice($infoclasse['file']);
	   		  //$sorgenteScript=preg_replace(self::$elimina_commenti_lunghi,'',$sorgenteScript);
	   		  $sorgenteScript=preg_replace('/(?<![a-z0-9\_\>\:]{1})__FILE__(?![a-z0-9\_\>\:]{1})/Ss',"__FILE__{$md5fileClasse}__",$sorgenteScript);
	   		  $sorgenteScript=preg_replace('/(?<![a-z0-9\_\>\:]{1})__DIR__(?![a-z0-9\_\>\:]{1})/Ss',"__DIR__{$md5fileClasse}__",$sorgenteScript);


	   		  if ($this->noautoload_cache_exists===true || !isset($this->noautoload_cache_exists[$infoclasse['file']]))
	   		  				 {
	   		  				 $sorgenteScript=preg_replace('/(?<![a-z0-9\_\>\:]{1})class_exists\s*\(/iSs',' myCachedAutoloader::class_exists(',$sorgenteScript);
 			  				 }
 	   		  preg_match_all(self::$individua_classi,$sorgenteScript,$matches);
	   		  $n=count($matches[0]);


	   		  $startPos=strpos($sorgenteScript,$matches[0][0]);
	   		  $sorgenteTemp=$sorgenteScript;
	   		  for ($i=0;$i<$n;++$i) {
	   		  	    $class_name=trim(strtolower($matches[1][$i]));
	  		 		if ($i+1>=$n)  $classi[$class_name]=$bodyClass=trim(substr($sorgenteScript,$startPos));
	  		 				  else {$endPos=strpos($sorgenteScript,$matches[0][$i+1],$startPos+strlen($class_name)+1);
	  								$classi[$class_name]=preg_replace(array('~^<?[ph]{,3}\s~isS',
	  	   																				   '~\s\\?>~isS'
	  	   																					),
	  	   																				array('',''),
	  	   																$bodyClass=trim(substr($sorgenteScript,$startPos,$endPos-$startPos)));
	  								$startPos=$endPos;
	  	    				  		}
	  	    		$this->classi_pronte[$class_name]=&$classi[$class_name];
	  	    		$sorgenteTemp=str_replace($bodyClass, '', $sorgenteTemp);
	  	      		}


	  	     if ($classi) $Main=$define.str_ireplace(array('<?php','<?','?>'),'',trim($sorgenteTemp));
	    			 else $Main=$define;
	    	 if ($this->noInclude===true || !isset($this->noInclude[$infoclasse['file']])) $Main=trim(str_ireplace(array('include_once(','require_once(','include(','require('),'(',$Main));
	  		  if ($this->usa_cache_classi) $this->da_salvare[$percorsoCache]=array('Main'=>$Main,
	  		  											     					   'classi'=>$classi,
	  		  											      					   'chk'=>$infoclasse['chk']);

	  		  self::myEval($Main);
	  		  unset($Main);
	   		  }
	  	}

	   self::myEval($this->classi_pronte[$classe]); unset($this->classi_pronte[$classe]);//ormai non serve più
    }

     /** @ignore */
    function __destruct() {
    	parent::__destruct();
    	foreach ($this->da_salvare as $percorsoCache=>&$array) self::scrivi_file($percorsoCache,$array);
    }
}



/**
 * Prevede la scomposizione dei file con le classi in tanti file singoli
 * @see myAutoloaders
 *
 */
class myFastCachedAutoloader extends myCachedAutoloader {
static /** @ignore */	$MainUsati=array();



  /** Restituisce l'istanza della classe, essendo un singleton l'sianza è sempre la stessa
  * @access public
  * @param string $dirSaves percorso in cui salvare i file di indicizzazione
  */
  static function get_Istanza($dirSaves) {
  	  if (self::$istanza!==null) {if (is_dir($dirSaves)) self::$istanza->set_dir($dirSaves);
  	  							  return self::$istanza;
  	  							  }
                          else   return self::$istanza=new myFastCachedAutoloader($dirSaves);
  }


  /**
   * Effettua inclusione dello script passato
   * se per caso c'è un main con eventuali variabili definite vengono "globalizzate"
   * @param string $____file
   * @ignore
   */
  /*protected static function myInclude($____file) {
  	@include($____file);
    //foreach (get_defined_vars() as $____k=>$____v)
    //   				if ($____k!='____file' )
    //   				    		{ global $$____k;
    //   							  $$____k=$____v;
     //  							}

   }*/


  /** @ignore */
  function esegui_classe($classe,$tentativi=0) {
  	     static $classeCache;
  		 if (!$this->usa_cache_classi) return parent::esegui_classe($classe,$tentativi);

         $infoclasse=$this->cerca_classe($classe,$tentativi);
	     $md5fileClasse=md5($infoclasse['file']);

	   	 //define("__FILE__{$md5fileClasse}__",$infoclasse['file']);
	   	 $define="define('__FILE__{$md5fileClasse}__','".addslashes($infoclasse['file'])."');define('__DIR__{$md5fileClasse}__','".addslashes(dirname($infoclasse['file']))."');";

	   	 $percorsoCache=$this->dirSaves.DIRECTORY_SEPARATOR.$md5fileClasse;
	     if ($classeCache[$percorsoCache] || is_file("$percorsoCache.php"))
			       {
			        if (!($classeCache[$percorsoCache]['chk']=self::$MainUsati[$md5fileClasse]))
			        										    {$classeCache[$percorsoCache]=self::leggi_file("$percorsoCache.php");
			        										     self::myEval($classeCache[$percorsoCache]['Main']);
			        											 self::$MainUsati[$md5fileClasse]=$classeCache[$percorsoCache]['chk'];
			        											}

			     	if ($classeCache[$percorsoCache]['chk']==$infoclasse['chk'])
			     					{
			     						return Include("$percorsoCache.$classe.php");
			     					}
		 	  	   }



	  	 $sorgenteScript= &self::minimizza_codice($infoclasse['file']);
	     // $sorgenteScript=preg_replace(self::$elimina_commenti_lunghi,'',$sorgenteScript);
      	 $sorgenteScript=preg_replace('/(?<![a-z0-9\_\>\:]{1})__FILE__(?![a-z0-9\_\>\:]{1})/Ss',"__FILE__{$md5fileClasse}__",$sorgenteScript);
      	 $sorgenteScript=preg_replace('/(?<![a-z0-9\_\>\:]{1})__DIR__(?![a-z0-9\_\>\:]{1})/Ss',"__DIR__{$md5fileClasse}__",$sorgenteScript);

	   	 if ($this->noautoload_cache_exists===true || !isset($this->noautoload_cache_exists[$infoclasse['file']]))
	   	 																			$sorgenteScript=preg_replace('/(?<![a-z0-9\_\>\:]{1})class_exists\s*\(/iSs',' myCachedAutoloader::class_exists(',$sorgenteScript);
 			  																		//$sorgenteScript=preg_replace('/\b(class_exists)\s*\(/iSs','myCachedAutoloader::class_exists(',$sorgenteScript);

 	   	 preg_match_all(self::$individua_classi,$sorgenteScript,$matches);
	   	 $n=count($matches[0]);
	   	 $startPos=strpos($sorgenteScript,$matches[0][0]);
	   	 for ($i=0;$i<$n;++$i) {
	   	  	    $class_name=trim(strtolower($matches[1][$i]));
	  	 		if ($i+1>=$n)   $phpclasse=trim(substr($sorgenteScript,$startPos));
	  	 				  else {$endPos=strpos($sorgenteScript,$matches[0][$i+1],$startPos+strlen($class_name)+1);
	  							$phpclasse=trim(substr($sorgenteScript,$startPos,$endPos-$startPos));
	  							$startPos=$endPos;
	  	   				  		}
	  	   		$classi[]=$phpclasse;
	  	   		if ($class_name==$classe)  $da_eseguire=$phpclasse;

	  	   		self::file_write("$percorsoCache.$class_name.php",'<? '.preg_replace(array('~^<?[ph]{,3}\s~isS',
	  	   																				   '~\s\\?>~isS'
	  	   																					),
	  	   																				array('',''),
	  	   																					trim($phpclasse)).' ?>');
	   		  }

	    if ($classi) $Main=$define.trim(str_ireplace(array('<?php','<?','?>'),'',str_replace($classi,'',$sorgenteScript)));
	    		else $Main=$define;

	    if ($this->noInclude===true || !isset($this->noInclude[$infoclasse['file']])) $Main=trim(str_ireplace(array('include_once(','require_once(','include(','require('),'(',$Main));

	    self::$MainUsati[$md5fileClasse]=$classeCache[$percorsoCache]['chk'];
        self::scrivi_file("$percorsoCache.php",
        				  array('chk'=>$infoclasse['chk'],'Main'=>$Main)
        				  );
     	self::myEval($Main); unset($Main);
     	self::myEval($da_eseguire);
    }

}



class mystupidautoloader extends myAutoloader{


/** @ignore */
 protected  function __construct(){
  }


  function add_percorso($percorso,$null,$profondita=0,$livello=0) {
     if ($livello>$profondita) return $this;
     if (is_file($percorso)) include_once($percorso);

     if (is_dir($percorso))
     		foreach (GLOb("$percorso/*.php") as $dir)
     		       $this->add_percorso($dir,$null,$profondita,$livello+1);
     return $this;
  }

  function __descruct(){
  }
 }





/**
 * E' una classe di utilità che sceglie il tipo di autoloader migliore a seconda della configurazione del server
 * In automatico include le myForms
 * <code>
 * myAutoloaders::get_Istanza() //solo questo carica l'indicizzazione delle myForms nella modalità migliore
 *					->add_percorso('./include',2) //include tutte le classi sotto include limitandosi a 2 sottodirectori
 *					->add_percorso('./include/classi.php'); //include le classi in classi.php
 *
 * </code>
 */
abstract class myAutoloaders{
protected static /** @ignore */$modalita,$istanza;

	/**
	 * Forza l'uso della myAutoloader che prevede inclusione secca dei file
	 * per farne meglio il debug
	 *
     * @access  public
	 * @param 1|2 $modalita se 1 si usa un myAutoloader semplice (in pratica si sfrutta solo l'indicizzazione delle classi)
	 * 						   2 si usa la l'Autoloader scelto ma in modalità di debug
	 */
	public static function set_debugging($modalita=1) {
		self::$modalita=$modalita;
	}


	/**
	 * Restituisce l'istanza tra myAutoloader,myCachedAutoloader e myFastCachedAutoloader più adatto.
	 * Tutt le myForms sono automaticamente comprese.
	 *
	 * @param  string $percorso
	 * @return myAutoloader|myCachedAutoloader|myFastCachedAutoloader
	 */
	public static function  get_Istanza($percorso='',$forzaClasse=''){
		static $percorso_prec;
	    if (!$percorso) $percorso=$percorso_prec;
	    if (!$percorso) $percorso="$_SERVER[DOCUMENT_ROOT]/myAutoloader";
		if (!is_dir($percorso)) @mkdir($percorso,0777,true);
		$percorso_prec=$percorso;
		if ($forzaClasse)
			switch (strtolower($forzaClasse))
								  { case 'mystupidautoloader': $istanza=myStupidAutoloader::get_Istanza($percorso);
														 break;
									case 'myfastcachedautoloader': $istanza=myFastCachedAutoloader::get_Istanza($percorso);
														 break;
									case 'mycachedautoloader': $istanza=myCachedAutoloader::get_Istanza($percorso);
														 break;
									case 'myautoloader': $istanza=myAutoloader::get_Istanza($percorso);
														 break;
								 }
		 elseif (self::$modalita==1) $istanza=myAutoloader::get_Istanza($percorso);
			else {
				  if (array_intersect(array('zend platform','eaccelerator','zend optimizer+','apc','xcache'),
									  array_keys(array_change_key_case((array_flip(get_loaded_extensions())))))!=null)
										  $istanza= myFastCachedAutoloader::get_Istanza($percorso);
							 	   else   $istanza= myCachedAutoloader::get_Istanza($percorso);
				  $istanza->set_debug(self::$modalita);
				  $istanza->auto_refresh((self::$modalita?0:1));
				 }
		$istanza->add_percorso(dirname(__FILE__),array(),2,0);
		return $istanza;
	}
}
?>