

====================================================================================================================
__GENERAL__
====================================================================================================================

[-01] fileXML not found or you havent permisson

      Se il file non esiste o non si hanno i permessi per leggerlo.

      Esempio 1. Il file XML non esiste!

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/noexist.xml
      Error -1: fileXML not found or you havent permisson


      Esempio 2. Nessun permesso di accesso al file XML

      jack0e@jack0e-laptop:~/spiderxml/src$ touch ../samples/nopermission.xml
      jack0e@jack0e-laptop:~/spiderxml/src$ chmod 000 ../samples/nopermission.xml
      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/nopermission.xml 
      Error -1: fileXML not found or you havent permisson


[BUG]

      Casistica: File XML vuoto. (dovrebbe dare un errore/warning ed invece dice che non ha i permessi...)

      jack0e@jack0e-laptop:~/spiderxml/src$ rm ../samples/empty.xml 
      jack0e@jack0e-laptop:~/spiderxml/src$ touch ../samples/empty.xml 
      jack0e@jack0e-laptop:~/spiderxml/src$ ls -la ../samples/empty.xml 
      -rw-r--r-- 1 jack0e jack0e 0 2008-08-28 16:41 ../samples/empty.xml
      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/empty.xml 
      Error -1: fileXML not found or you havent permission



====================================================================================================================
__TAG_INI_REMARK__   <!--
====================================================================================================================

[-24] i not fount tag XML first row but remark

      Il commento non può precedere l'intestazione XML. Nel caso specifico lo stack XML è VUOTO quindi il commento
      la precede o manca un'instazione. 

      Esempio 1.
      
         .-------------------------o Posizione Parsen 
         |
         V
      <!-- TEST Return Code 24: Remark after head XML -->
      <?xml version = "1.0" ?>
      <tag>100</tag>

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test24.xml   
      Error -24: [../samples/test24.xml:1] I not found tag XML dirst row but remark [<!--]

====================================================================================================================

[-25] found a remark into delimiter tag XML

      Il commento non può iniziare all'interno di un tag XML (di intestazione o di coda) ancora aperto.
      Questo lo si verifica andando a verificare lo stato dell'ultimo TAG registrato nello stack XML
      che se è aperto è valorizzato a 0 per l'intestazione aperta ed a 2 per la coda aperta. Nel caso
      di TAG XML non è prevista l'utilizzo di tag di cosa, quindi lo stato può trovarsi solamente a 0.

      Esempio 1. 

              .--------------------o Posizione Parsen 
             /
            /
      <?xml/
      <!-- TEST Return Code 24: Remark after head XML -->
            version = "1.0" ?>
      <tag>100</tag>

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test25.xml 
      Error -25: [../samples/test25.xml:2] found a remark into delimiter tag XML [xml]


====================================================================================================================

[-03] found a remark into delimiter tag

      Il commento non può iniziare all'interno di un tag (di intestazione o di coda) ancora aperto.
      Questo lo si verifica andando a verificare lo stato dell'ultimo TAG registrato nello stack
      che se è aperto è valorizzato a 0 per l'intestazione aperta ed a 2 per la coda aperta. 

      >> Esempio 1. Remark all'interno di TAG di TESTA 

      <?xml version = "1.0" ?>
      <tag <!-- Commento dentro TAG --> >100</tag> 
              ^     
              |
              '--------o Posizione Parsen

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test03A.xml 
      Error -3: [../samples/test03A.xml:2] found a remark into delimiter tag


      >> Esempio 2. Remark all'interno di TAG di CODA  

      <?xml version = "1.0" ?> 
      <tag len = "100" ></tag <!-- Commento dentro TAG --> >
                                 ^     
                                 |
                                 '--------o Posizione Parsen
 
      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test03B.xml 
      Error -3: [../samples/test03B.xml:2] found a remark into delimiter tag

====================================================================================================================

[-04] unknown token on left the remark

      Alla sinistra di un commento non ci dovrebbe essere nulla che non sia stato precedentemente già analizzato.
      Il commento non può stare all'interno di un TAG ne di TESTA ne di CODA e quindi può trovarsi solamente prima 
      della definizione di un nodo figlio o fratello del precedente.

      <?xml version = "1.0" ?>
      <!-- remark --> 
      <tag_padre>
             <!-- remark --> 
             <tag_figlio_1 \>
             <!-- remark --> 
             <tag_figlio_2 \>
      </tag_padre>

      Come è possibile verificare prima di un remark c'è sempre un token di chiusura TAG: "?>", ">", "\>". Spazi, tabulazioni
      ed LF non vengono considerate.

      In realtà esiste la possibilità in XML di inserire un attributo tra TAG di TESTA e TAG di CODA... 
      ma per questa versione il parsen non supporta questa ancora questa possibilità. 
      Quindi (ahimè) file XML fatti così non verrebbero considerati validi nel caso migliore... 

      <?xml version = "1.0" ?> 
      <tag>
            100
      </tag>

      quindi questa casistica dovrebbe dare errore -04 

      <?xml version = "1.0" ?> 
      <tag>
            100<!-- Remark -->
      </tag>

      Alcuni esempi testati :



[BUG - NOT SUPPORTED]

      >>> esempio 1: senza blank dopo il token 100

      <?xml version = "1.0" ?> 
      <tag>
            100
      </tag>

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test04A.xml 
      Error -18: [../samples/test04A.xml:4] Unknown token [100]



[BUG - NOT SUPPORTED]

      >>> esempio 2: con un commento dopo il token 100

      <?xml version="1.0"?>
      <tag >
             100<!-- Remark -->
      </tag>

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test04B.xml 
      Error -4: [../samples/test04B.xml:3] unknown token [100] on left the remark



[BUG - da ricercare nella sezione TOKEN __SEPARATORE__ ]

      >>> esempio 3: con spazio tra token 100 e commento

      jack0e@jack0e-laptop:~/spiderxml/src$ cat ../samples/test04C.xml 
      <?xml version="1.0"?> 
      <tag >
             <!-- Remark -->100 <!-- Remark -->
      </tag> 

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test04C.xml 

      ================================ ============ ============ ============
                                                                       Numero
                                   Tag        Level        Stato    Variabili
      -------------------------------- ------------ ------------ ------------
      [                           xml] [         0] [         3] [         1]


      ================================ ============ ============ ============
                                                                       Numero
                                   Tag        Level        Stato    Variabili
      -------------------------------- ------------ ------------ ------------
      [                           tag] [         0] [         3] [         0]





====================================================================================================================
__TAG_END_REMARK__
====================================================================================================================

[-23] not found open delimiter remark

      il commento è delimitato tai token <!-- in apertura e --> in chiusura. E' un errore se si trova un token
      di chiusura commento e non risulta nessuna apertura.


      >>> Esempio 1.

      <?xml version="1.0" ?>

      -->
      <tag len="100" \>

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test23A.xml 
      Error -23: [../samples/test23A.xml:3] Not found open delimiter remark [-->]

      E' ovvio che un errore così può capitare se uno si sbaglia a scrivere il token di apertura del commento  
      magari mettendo anzichè "<!--" il token "<--" (senza l'escamativo... ma che succede in questo caso? vediamo...


      >>> Esempio 2.

      <?xml version="1.0" ?>

      <-- Questo il commento errato -->
      <tag len="100" \>

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test23B.xml 
      Error -37: [../samples/test23B.xml:3] not found ASSIGN but unknown token [il].

      In questo caso l'errore viene rilevato prima di arrivare al token di chiusura commento, perchè
      il token "<" viene considerato come delimitatore di apertura di un tag di testa, il toke "--" viene 
      considerato come nome tag (non è ancora implementato la verifica del nome altrimenti si sarebbe fermato qua)
      la parola Questo come variabile ed a questo punto il parsen si aspetta un ASSIGN (=) ed invece trova "il".





====================================================================================================================
__TAG_INI_XML__
====================================================================================================================

[-05] unknown token on left the XML delimiter

      Alla sinistra di un delimitatore di apertura di un TAG-XML non ci può essere nulla di classificato
      gia in precedenza. Di fatto ci può essere solo un delimitatore di chiusura di un TAG-XML precedente
      che è un token gestito.
      
      <?xml version="100" ?>

      CAMILLO<?xmlAltro parametro="AAA" ?>
              ^     
              |
              '--------o Posizione Parsen


      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test05A.xml 
      Error -5: [../samples/test05A.xml:4] unknown token [CAMILLO] on left the XML delimiter

====================================================================================================================

[-15] a previous definition tag xml is open

      Se un TAG XML è aperto non se ne può aprire all'interno di esso un altro
      
      <?xml version="100" 

             <?xmlAltro parametro="AAA" ?>
              ^     
      ?>      |
              '--------o Posizione Parsen

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test15A.xml 
      Error -15: [../samples/test15A.xml:3] a previous definition tag xml is open [xml]

====================================================================================================================

[-16] found XML TAG after DATE TAG

      i tag XML devono trovarsi in TESTA, cioè prima dei TAG DATI.
      Nel caso non sia così il parse si ferma.

      >>> esempio 1.

      <?xml version="100" ?> 
      <?xmlAltro parametro="AAA" ?>
      <tag />

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test16A.xml 

      ================================ ============ ============ ============
                                                                       Numero
                                   Tag        Level        Stato    Variabili
      -------------------------------- ------------ ------------ ------------
      [                           xml] [         0] [         3] [         1] [version]   = ["100"]
      [                      xmlAltro] [         0] [         3] [         1] [parametro] = ["AAA"]

      ================================ ============ ============ ============
                                                                       Numero
                                   Tag        Level        Stato    Variabili
      -------------------------------- ------------ ------------ ------------
      [                           tag] [         0] [         3] [         0]



      >>> esempio 2.

      <?xml version="100" ?> 
      <tag />
      <?xmlAltro parametro="AAA" ?>

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test16B.xml 
      Error -16: [../samples/test16B.xml:3] found XML TAG after DATE TAG [tag]


      
      >>> esempio 3.

      <tag />
      <?xml version="100" ?> 
      <?xmlAltro parametro="AAA" ?>

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test16C.xml 
      Error -40: [../samples/test16C.xml:1] not found XML head



====================================================================================================================
__TAG_END_XML__
====================================================================================================================

[-06] initial delimiter xml not found

      Una chiusura di un TAG-XML deve sempre essere preceduta da un'apertura.


      >>> esempio 1. 

      <?xml version="100" ?> ?>

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test06A.xml 
      Error -6: [../samples/test06A.xml:1] initial delimiter xml not found


      >>> esempio 2. 

      <?xml version="100" ?>
      <xmlAltro parametro="AAA" ?>
      <tag />

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test06B.xml 
      Error -6: [../samples/test06B.xml:2] initial delimiter xml not found

====================================================================================================================

[-41] unknown token

      la chiusura di un TAG XML si aspetta di trovare tutto in ordine :

      a) nome TAG assegnato per evitare <? ?> 
      b) variabile definita per evitare :
         b.1) <?xml var?>               (state_var = 0) <=================== CASISTICA ANALIZZATA
         b.2) <?xml var token_unknown?> (state_var = 1)
         b.2) <?xml var =?>             (state_var = 2) 


      esempio: non corretto

      <?xml var?>

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test41D.xml   
      Error -41: [../samples/test41D.xml:1] Unknown token [var].


====================================================================================================================

[-42] not found ASSIGN but unknown token

      la chiusura di un TAG XML si aspetta di trovare tutto in ordine :

      a) nome TAG assegnato per evitare <? ?>
      b) variabile definita per evitare :
         b.1) <?xml var?>               (state_var = 0)
         b.2) <?xml var token_unknown?> (state_var = 1) <=== CASISTICA ANALIZZATA
         b.2) <?xml var =?>             (state_var = 2) 


      esempio: non corretto

      <?xml var word?>

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test42A.xml 
      Error -42: [../samples/test42A.xml:1] not found ASSIGN but unknown token [word].

====================================================================================================================

[-43] unknown token

      la chiusura di un TAG XML si aspetta di trovare tutto in ordine :

      a) nome TAG assegnato per evitare <? ?> <=== CASISTICA ANALIZZATA
      b) variabile definita per evitare :
         b.1) <?xml var?>               (state_var = 0)
         b.2) <?xml var token_unknown?> (state_var = 1) 
         b.2) <?xml var =?>             (state_var = 2) 


      >>>> esempio 1: scorretto (caso a)

      <? ?>

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test43A.xml 
      Error -43: [../samples/test43A.xml:1] the TAG close have not a name.



      >>>> esempio 2: scorretto (caso a - altro ramo perchè stavolta è senza spazio)

      <??>

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test43B.xml 
      Error -43: [../samples/test43B.xml:1] the TAG close have not a name.

====================================================================================================================

[-44] the TAG close have variable not definition.

      la chiusura di un TAG XML si aspetta di trovare tutto in ordine :

      a) nome TAG assegnato per evitare <? ?> 
      b) variabile definita per evitare :
         b.1) <?xml var?>               (state_var = 0)
         b.2) <?xml var token_unknown?> (state_var = 1) 
         b.2) <?xml var =?>             (state_var = 2) <=== CASISTICA ANALIZZATA 

      >>> esempio 1.

      <?xml var =?>

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test44A.xml 
      Error -44: [../samples/test44A.xml:1] the TAG close have variable not definition. [var]


      >>> esempio 2.

      <?xml var=?>

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test44B.xml 
      Error -44: [../samples/test44B.xml:1] the TAG close have variable not definition. [var]


[BUG]

      esempio: scorretto

      <???>

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test41C.xml 

      ================================ ============ ============ ============
                                                                       Numero
                                   Tag        Level        Stato    Variabili
      -------------------------------- ------------ ------------ ------------
      [                             ?] [         0] [         3] [         0]
 

      ================================ ============ ============ ============
                                                                       Numero
                                   Tag        Level        Stato    Variabili
      -------------------------------- ------------ ------------ ------------

      Da implementare solo il controllo nome perchè questo non sarebbe valido.



      >>> esempio 3.

      <?xml var = "100"?>

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test41H.xml 

      ================================ ============ ============ ============
                                                                       Numero
                                   Tag        Level        Stato    Variabili
      -------------------------------- ------------ ------------ ------------
      [                           xml] [         0] [         3] [         1]
      [var] = ["100"]


      ================================ ============ ============ ============
                                                                       Numero
                                   Tag        Level        Stato    Variabili
      -------------------------------- ------------ ------------ ------------



====================================================================================================================
__TAG_END_OPEN__
====================================================================================================================

[-18] Unknown token

      Prima del delimitatire di apertura di un TAG di CODA non ci può essere nulla di non analizzato gia in precedenza.
      Infatti questa versione al momento si aspetta prima un delimitatore di chiusura o di un nodo figlio
      oppure del TAG di TESTA, quindi token quali >, />

      <tag>
      </tag>

      <tag>
          <tag-figlio>
               ...
          </tag-figlio>
      </tag>

      <tag>
          <tag-figlio />
      </tag>


      >>> esempio 1: 

      <?xml version = "1.0" ?>
      <tag >
      token_unknown</tag>

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test18A.xml 
      test18A.xml:3] Unknown token [token_unknown]


[BUG] 

      >>> esempio 2: 

      <?xml version = "1.0" ?>
      <tag>
      token_unknown</tag>

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test18B.xml 
      Error -18: [../samples/test18B.xml:3] Unknown token [token_unknown]


      >>> esempio 3: 

      <?xml version = "1.0" ?>  <---- senza spazio
      <</>

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test18C.xml 
      Error -18: [../samples/test18C.xml:2] Unknown token [<]


      >>> esempio 4: 

      <?xml version = "1.0" ?>  <---- con spazio 
            <</>

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test18D.xml 
      Error -18: [../samples/test18D.xml:2] Unknown token [<]



====================================================================================================================

[-19] found tail tag but there arent head

      Il delimitatore di chiusura presuppone la definizione di un TAG di CODA. E quindi per un TAG di CODA ci deve essere
      sempre un corrispondente TAG di TESTA. Non c'e' il corrispondente TAG di TESTA sicuramente se son vere una 
      di queste condizioni :

      1) STACK Empty  <======== caso trattato

      >>> esempio 1: 

      <?xml version = "1.0" ?>
      </tag-1>

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test19A.xml 
      Error -19: [../samples/test19A.xml:2] found tail tag but there arent heads.


      >>> esempio 2:

      <?xml version = "1.0"?>
      </>

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test19B.xml 
      Error -19: [../samples/test19B.xml:2] found tail tag but there arent heads.

      Ok perchè considera lo slash legato al primo delimitatore. Quindi considera </ come delimitatore iniziale del TAG
      di CODA (TAIL).


====================================================================================================================

[-20] a previous head tag [%s] is not close

      Il delimitatore di chiusura presuppone la definizione di un TAG di CODA. E quindi per un TAG di CODA ci deve essere
      sempre un corrispondente TAG di TESTA. Per cercare il padre si legge a ritroso l'elenco dei TAG già processati
      alla ricerca di uno con stato 1 (conclusa TESTA). I TAG a 3 se li aspetta d trovare lungo il traggitto perchè
      rappresentano i figli chiusi

      <tag-1>
         <tag-figlio>
         </tag-figlio>
      </tag-1>
      o
      |
      '----------------------- parser      

      ma non si aspetta di trovare lungo il tragitto :

      1) TAG in stato 0 (TAG di TESTA non concluso)  <============ caso trattato
      2) TAG in stato 2 (TAG di CODA non concluso)
      3) Tutti i NODI completamente definito (tutti a stato 3 fono alla radice)

[BUG] 

      esempio: 

      <?xml version = "1.0" ?>
      <tag-1
      </tag-1>

      jack0e@jack0e-laptop:~/spiderxml/src$ cat ../samples/test20A.xml; ../bin/parseXML ../samples/test20A.xml 
      <?xml version = "1.0" ?>
      <tag-1
      </tag-1>

      [DEBUG] [         XMLIni] | [                                                                              <?]
      [DEBUG] [            XML] | [                                                                             xml]
      [DEBUG] [       Separate] | [                                                                                ]
      [DEBUG] [       Variable] | [                                                                         version]
      [DEBUG] [       Separate] | [                                                                                ]
      [DEBUG] [         Assign] | [                                                                               =]
      [DEBUG] [          Value] | [                                                                           "1.0"]
      [DEBUG] [       Separate] | [                                                                                ]
      [DEBUG] [         XMLEnd] | [                                                                              ?>]
      Error -18: [..samples/test20A.xml:3] Unknown token [<tag-1]

      Non essendoci lo spazio di separazione tra "<tag-1" e "<\" riempie il buffer con "<tag-1<\" e non aspettandosi
      nulla alla sinistra del delimitatore analizzato come detto al codice -18 ricade in quella casistica.
      Questo non è proprio un BUG perchè l'errore comunque lo rileva solo che il messaggio non proprio corretto
      e comunque la gestione del delimitatore "<" è un pò sporca che rende alla lunga il codice meno leggibile....
      Da persare all'intercettazione immediata di ">"...


      esempio: 

      <?xml version = "1.0" ?>
      <tag-1   <---------------------- questa volta con spazio di separazione.
      </tag-1>

      jack0e@jack0e-laptop:~/spiderxml/src$ cat ../samples/test20B.xml; ../bin/parseXML ../samples/test20B.xml 
      Error -20: [../samples/test20B.xml:3] a previous head tag [tag-1] is not close.

[BUG]

      esempio: 

      <?xml version = "1.0" ?>
      < 
      </tag-1>


      jack0e@jack0e-laptop:~/spiderxml/src$ cat ../samples/test20C.xml; ../bin/parseXML ../samples/test20C.xml 
      Error -20: [../samples/test20C.xml:3] a previous head tag [] is not close.

      forse come messaggio è meglio questo ma avrebbe dovuto riportare tra le parendesi il TAG aperto...
      il parser mette *Unknown* se ancora non lo conosce. Mi viene da pensare che nel ramo che intraprende 
      nel processare il token "<" dopo sibito dopo il separatore non valorizza il nome del tag.



====================================================================================================================

[-21] a previous tail tag [%s] is not close

      Il delimitatore di chiusura presuppone la definizione di un TAG di CODA. E quindi per un TAG di CODA ci deve essere
      sempre un corrispondente TAG di TESTA. Per cercare il padre si legge a ritroso l'elenco dei TAG già processati
      alla ricerca di uno con stato 1 (conclusa TESTA). I TAG a 3 se li aspetta d trovare lungo il traggitto perchè
      rappresentano i figli chiusi

      <tag-1>
         <tag-figlio>
         </tag-figlio>
      </tag-1>
      o
      |
      '----------------------- parser      

      ma non si aspetta di trovare lungo il tragitto :

      1) TAG in stato 0 (TAG di TESTA non concluso)  
      2) TAG in stato 2 (TAG di CODA non concluso)    <============ caso trattato
      3) Tutti i NODI completamente definito (tutti a stato 3 fono alla radice)

      esempio: 

      <?xml version = "1.0" ?>
      <tag-1> <---------------------- questa volta con spazio di separazione.
           <tag-figlio> <---------------------- questa volta con spazio di separazione. 
           </tag-figlio <---------------------- questa volta con spazio di separazione.
      </tag-1>

      jack0e@jack0e-laptop:~/spiderxml/src$ cat ../samples/test21A.xml; ../bin/parseXML ../samples/test21A.xml 
      Error -21: [../samples/test21A.xml:4] a previous tail tag [tag-figlio] is not close.

====================================================================================================================

[-22]  delimiter tail tag but missing father

      Il delimitatore di chiusura presuppone la definizione di un TAG di CODA. E quindi per un TAG di CODA ci deve essere
      sempre un corrispondente TAG di TESTA. Per cercare il padre si legge a ritroso l'elenco dei TAG già processati
      alla ricerca di uno con stato 1 (conclusa TESTA). I TAG a 3 se li aspetta d trovare lungo il traggitto perchè
      rappresentano i figli chiusi

      <tag-1>
         <tag-figlio>
         </tag-figlio>
      </tag-1>
      o
      |
      '----------------------- parser      

      ma non si aspetta di trovare lungo il tragitto :

      1) TAG in stato 0 (TAG di TESTA non concluso)  
      2) TAG in stato 2 (TAG di CODA non concluso)
      3) Tutti i NODI completamente definito (tutti a stato 3 fono alla radice)     <============ caso trattato

      esempio: 

      <?xml version = "1.0" ?>
      <tag-1> <---------------------- questa volta con spazio di separazione.
           <tag-figlio> <---------------------- questa volta con spazio di separazione. 
           </tag-figlio> <---------------------- questa volta con spazio di separazione.
      </tag-1> <---------------------- questa volta con spazio di separazione.
      </tag-1>
      o
      |
      '------------ parser


      jack0e@jack0e-laptop:~/spiderxml/src$ cat ../samples/test22A.xml; ../bin/parseXML ../samples/test22A.xml 
      Error -22: [../samples/test22A.xml:5] delimiter tail tag but missing father



====================================================================================================================
__TAG_INI_END__
====================================================================================================================

[-45] missing intestation XML

      Un delimitatore di chiusura di un tag senza contenuti (/>) presuppone prima di tutto
      che ci sia :

      * l'intestazione XML nel documento                <========== caso analizzato
      * l'ultimo TAG XML sia chiuso. (stato = 3)

      Un delimitatore di chiusura di un tag senza contenuti (/>) presuppone che ci sia un tag aperto.
      Questo non è sicuramente vero se risultano vere le seguenti condizioni :
 
      * stack tag vuoto   
      * se l'ultimo TAG inserito nello stack non risulta di TESTA e aperto (stato 0)

      esempio 1.

      />

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test45A.xml 
      Error -45: [../samples/test45A.xml:1] missing intestation XML.


      esempio 2.

      unknown_token/>

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test45B.xml 
      Error -45: [../samples/test45B.xml:1] missing intestation XML.


      esempio 3.

      <unknown_token/>

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test45C.xml 
      Error -45: [../samples/test45C.xml:1] missing intestation XML.

====================================================================================================================

[-46] Last TAG XML isnt close

      Un delimitatore di chiusura di un tag senza contenuti (/>) presuppone prima di tutto
      che ci sia :

      * l'intestazione XML nel documento                
      * l'ultimo TAG XML sia chiuso. (stato = 3)   <========== caso analizzato

      Un delimitatore di chiusura di un tag senza contenuti (/>) presuppone che ci sia un tag aperto.
      Questo non è sicuramente vero se risultano vere le seguenti condizioni :
 
      * stack tag vuoto   
      * se l'ultimo TAG inserito nello stack non risulta di TESTA e aperto (stato 0)

      esempio 1.

      <? />

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test46A.xml 
      Error -46: [../samples/test46A.xml:1] Last TAG XML [*Unknown*] isnt close.

      
      esempio 2.

      <?/>

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test46B.xml 
      Error -46: [../samples/test46B.xml:1] Last TAG XML [*Unknown*] isnt close.

      
      esempio 3.

      <?xml />

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test46C.xml 
      Error -46: [../samples/test46C.xml:1] Last TAG XML [xml] isnt close.


      esempio 4.

      <?xml versione = "1.0"/>

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test46D.xml 
      Error -46: [../samples/test46D.xml:1] Last TAG XML [xml] isnt close.


      esempio 5.

      <?xml versione = "1.0"?>
      <?xml-other />

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test46E.xml 
      Error -46: [../samples/test46E.xml:2] Last TAG XML [xml-other] isnt close.


      Esempio 6.

      <?xml version = "1.0"   <--- uno spazio
      />

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test46F.xml 
      Error -46: [../samples/test46F.xml:2] Last TAG XML [xml] isnt close.

      Ok giusto.


      Esempio 7.

      <?xml version = "1.0"   <--- senza spazio
      />

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test46G.xml 
      Error -46: [../samples/test46G.xml:2] Last TAG XML [xml] isnt close.

      Ok giusto.


====================================================================================================================

[-47] delimiter close tag but there isnt tag

      Un delimitatore di chiusura di un tag senza contenuti (/>) presuppone prima di tutto
      che ci sia :

      * l'intestazione XML nel documento             
      * l'ultimo TAG XML sia chiuso. (stato = 3)

      Un delimitatore di chiusura di un tag senza contenuti (/>) presuppone che ci sia un tag aperto.
      Quetso non è sicuramente vero se risultano vere le seguenti condizioni :
 
      * stack tag vuoto   <========== caso analizzato
      * se l'ultimo TAG inserito nello stack non risulta di TESTA e aperto (stato 0)

      Esempio 1.

      <?xml version = "1.0" ?>
      />

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test47A.xml 
      Error -47: [../samples/test47A.xml:2] delimiter close tag but there isnt tag

====================================================================================================================

[-17] Unknown token

      per il delimitatore di chiusura di un tag senza contenuti (/>) è stato trovato il corrispondente
      tag di testa aperto. Se alla sinistra del token analizzato il parser trova qualcosa può considerarlo 
      [a] come nome del tag (nel caso in cui non presenta variabili) ed il nome del tag non è assegnato (*Unknown*)
      esempio < *tag*/> [b] come valore se il nome del tag è assegnato ed l'ultima variabile definita sia in attesa 
      di valore (stato_last_variabile == 2) esempio <tag var = *value*/>. Se il nome del tag è assegnato (tag <> *Unknown*) 
      ma non ci sono variabili definite (dimTabVar == 0 && stato_last_variabile == 0) il parsen non lo può considerare 
      ne nometag e ne value quindi il parse esce per errore perchè non sa come catalogare il token
      esempio <tag *Unknown*/>

      Esempio 1.

      <?xml version = "1.0" ?>
      <tag pippo/>

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test17A.xml 
      Error -17: [../samples/test17A.xml:2] Unknown token [pippo]

      Ok.

====================================================================================================================

[-26] Unknown token

      per il delimitatore di chiusura di un tag senza contenuti (/>) è stato trovato il corrispondente
      tag di testa aperto. Se alla sinistra del token analizzato il parser trova qualcosa può considerarlo 
      [a] come nome del tag (nel caso in cui non presenta variabili) ed il nome del tag non è assegnato (*Unknown*)
      esempio < *tag*/> [b] come valore se il nome del tag è assegnato ed l'ultima variabile definita sia in attesa 
      di valore (stato_last_variabile == 2) esempio <tag var = *value*/>. Se il nome del tag è assegnato (tag <> *Unknown*) 
      ma e nello stak ci sono variabili definite ma l'ultima variabile acquisita però non è attesa di un valore anzi 
      è completamente definita (stato_last_variabile == 0) il parsen non lo può considerare il token ne nometag e ne value... 
      e quindi il parse lo considera token unknown (sconosciuto/noncatalogabile). Esempio <tag var = "1" var2 = "1" *Unknown*/>. 

      Esempio 1.

      <?xml version = "1.0" ?>
      <tag var = "10" pippo/>

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test26A.xml 
      Error -26: [../samples/test26A.xml:2] Unknown token [pippo]


====================================================================================================================

[-39] not found ASSIGN but unknown token

      per il delimitatore di chiusura di un tag senza contenuti (/>) è stato trovato il corrispondente
      tag di testa aperto. Se alla sinistra del token analizzato il parser trova qualcosa può considerarlo 
      [a] come nome del tag (nel caso in cui non presenta variabili) ed il nome del tag non è assegnato (*Unknown*)
      esempio < *tag*/> [b] come valore se il nome del tag è assegnato ed l'ultima variabile definita sia in attesa 
      di valore (stato_last_variabile == 2) esempio <tag var = *value*/>. Se il nome del tag è assegnato (tag <> *Unknown*) 
      ma e l'ultima variabile definita però non è attesa di un valore ma dell'ASSIGN (stato_last_variabile == 1) il parsen 
      non lo può considerare il token ne nometag e ne value... non è sicuramente un ASSIGN perchè sarebe stato processato prima
      spostando lo stato_last_variabile ad 1... e quindi il parse lo considera token unknown (sconosciuto/noncatalogabile)
      esempio <tag var *Unknown*/>. 

      Esempio 1.

      <?xml version = "1.0" ?>
      <tag var pippo/>

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test39A.xml 
      Error -39: [../samples/test39A.xml:2] not found ASSIGN but unknown token [pippo].



====================================================================================================================
[-53] unknown token [%s] on left the XML delimiter

      per il delimitatore di chiusura di tag senza contenuti (/>) l'ultimo TAG aquisito non è aperto (stato 0)
      ma in stato 1|3 vale a dire che il parse ha trovato una situazione del genere :
      ultimo tag in stato 1: <tag> .../>
      ultimo tag in stato 3: <tag></tag> .../>
      Quindi il parsen guarda alla sua sinistra per verificare se trova attaccato qualcosa nel tentativo di 
      trovare la parte che manca: delimitatore di sinistra a nome tag. Quindi verifica innanzitutto che ci sia qualcosa
      alla sua sinistra. Se esiste qualcosa si aspetta di trovare il delimitatore. Lo trova ma non i prima posizione...
      e quindi da errore perchè solo in prima posizione può trovarsi...
      Quindi ricapitolando si aspetta di trovare in prima posizione il delimitatore di apertura del TAG relativo 

      [<]tag/>

      invece lo trova il delimitatore di apertura... ma non in prima posizione. In poche parole trova qualcosa alla sinistra
      del delimitatore di sinistra di non catalogabile

  
      >> esempio 1: E' il primo TAG

      <?xml version = "1.0" ?>    <---- senza spazio
      pippo<tag/>

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test53A.xml 
      Error -53: [../samples/test53A.xml:2] unknown token [pippo] on left the XML delimiter


      >> esempio 2: E' il primo TAG

      <?xml version = "1.0" ?>    <----- con spazio
      pippo<tag var pippo/>

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test53B.xml 
      Error -53: [../samples/test53B.xml:2] unknown token [pippo] on left the XML delimiter


      >> esempio 3: Non è il primo TAG (TAG precedente in stato 1 padre)

      <?xml version = "1.0" ?>    
      <tagpadre >       <---- senza spazio
      pippo<tag/>
      </tagpadre>

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test53C.xml 
      Error -53: [../samples/test53C.xml:3] unknown token [pippo] on left the XML delimiter


      >> esempio 4: Non è il primo TAG (TAG precedente in stato 1 padre)

      <?xml version = "1.0" ?>   
      <tagpadre >       <---- con spazio
           pippo<tag/>
      </tagpadre>

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test53D.xml 
      Error -53: [../samples/test53D.xml:3] unknown token [pippo] on left the XML delimiter


      >> esempio 5: Non è il primo TAG (TAG precedente in stato 3 fratello)

      <?xml version = "1.0" ?>    
      <tagpadre > 
           <tagfratello var = "10" />pippo<tag/>
      </tagpadre>

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test53E.xml 
      Error -53: [../samples/test53E.xml:3] unknown token [pippo] on left the XML delimiter


      >> esempio 6: Non è il primo TAG (TAG precedente in stato 3 fratello)

      <?xml version = "1.0" ?>    
      <tagpadre > 
           <tagfratello var = "10" />   <---- con spazio
           pippo<tag/>
      </tagpadre>

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test53F.xml 
      Error -53: [../samples/test53F.xml:4] unknown token [pippo] on left the XML delimiter


      >> esempio 7: 

      <?xml version = "1.0" ?>    <---- senza spazio
      pippo<<tag/>

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test53G.xml 
      Error -53: [../samples/test53G.xml:2] unknown token [pippo] on left the XML delimiter


      >> esempio 8: 

      <?xml version = "1.0" ?>    <---- con spazio
      pippo<<tag/>

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test53H.xml 
      Error -53: [../samples/test53H.xml:2] unknown token [pippo] on left the XML delimiter



====================================================================================================================
[-54] found more tag delimiter [%s]

      per il delimitatore di chiusura di tag senza contenuti (/>) non esistono TAG precedenti (primo TAG) oppure 
      l'ultimo TAG aquisito non è aperto (stato 0) ma in stato 1|3 vale a dire che il parse ha trovato una situazione consolidata :
      * ultimo tag in stato 1: <tag> .../>
      * ultimo tag in stato 3: <tag></tag> .../>
      * primo tag: .../>
      Quindi trova una situazione consolidata a livello di stack (di quando è stato già processato e registrato)
      Quindi il parsen guarda alla sua sinistra per verificare se trova attaccato qualcosa nel tentativo di 
      trovare la parte che manca: delimitatore di sinistra e nome nome tag. Quindi verifica innanzitutto che ci sia qualcosa
      alla sua sinistra. Se esiste qualcosa si aspetta di trovare il delimitatore: uno solo e nella prima posizione.
      Se il delimitatore lo trova in prima posizione ma subito dopo (in seconda posizione) ne trova un altro da questo errore perchè 
      come scritto se ne aspetta uno ed in prima posizione.
      Quindi ricapitolando si aspetta di trovare in prima posizione l'unico delimitatore di apertura del TAG relativo 

      [<]tag/>

      invece ne trova più di uno, dalla prima posizione in poi...


      >> esempio 1: 

      <?xml version = "1.0" ?>    <---- senza spazio
      <<tag/>

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test54A.xml 
      Error -54: [../samples/test54A.xml:2] found more tag delimiter [<<]


      >> esempio 2: 

      <?xml version = "1.0" ?>    <---- con spazio
      <<tag/>

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test54B.xml 
      Error -54: [../samples/test54B.xml:2] found more tag delimiter [<<]




====================================================================================================================
[-55] not found close delimiter for tag [%s]

      per il delimitatore di chiusura di tag senza contenuti (/>) non esistono TAG precedenti (primo TAG) oppure 
      l'ultimo TAG aquisito non è aperto (stato 0) ma in stato 1|3 vale a dire che il parse ha trovato una situazione consolidata :
      * ultimo tag in stato 1: <tag> .../>
      * ultimo tag in stato 3: <tag></tag> .../>
      * primo tag: .../>
      Quindi trova una situazione consolidata a livello di stack (di quando è stato già processato e registrato)
      Quindi il parsen guarda alla sua sinistra per verificare se trova attaccato qualcosa nel tentativo di 
      trovare la parte che manca: delimitatore di sinistra e nome nome tag. Quindi verifica innanzitutto che ci sia qualcosa
      alla sua sinistra. Se esiste qualcosa si aspetta di trovare il delimitatore: uno solo e nella prima posizione.
      Se il delimitatore lo trova in prima posizione ma successivamente (non in maniera consecutiva) ne trova altri 
      da questo errore perchè come scritto se ne aspetta uno ed in prima posizione.
      Quindi ricapitolando si aspetta di trovare in prima posizione l'unico delimitatore di apertura del TAG relativo
      ma in quello che considera nometag ne trova altri di delimitatori. 

      >> esempio 1: 

      <?xml version = "1.0" ?>    <---- senza spazio
      <pippo<tag/>

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test55A.xml 
      Error -55: [../samples/test55A.xml:0] not found close delimiter for tag [pippo]


      >> esempio 2: 

      <?xml version = "1.0" ?>    <---- con spazio
      <pippo<tag/>

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test55B.xml 
      Error -55: [../samples/test55B.xml:0] not found close delimiter for tag [pippo]


      >> esempio 3: 

      <?xml version = "1.0" ?>    <---- senza spazio
      <pippo<pippo<tag/>

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test55C.xml 
      Error -55: [../samples/test55C.xml:0] not found close delimiter for tag [pippo]


      >> esempio 4: 

      <?xml version = "1.0" ?>    <---- con spazio
      <pippo<pippo<tag/>

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test55D.xml 
      Error -55: [../samples/test55D.xml:0] not found close delimiter for tag [pippo]


      >> esempio 5: 

      <?xml version = "1.0" ?>    <---- senza spazio
      <pippo<pippo<<pippo<pippo<pippo<<<<<<tag/>

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test55E.xml 
      Error -55: [../samples/test55E.xml:0] not found close delimiter for tag [pippo]


      >> esempio 6: 

      <?xml version = "1.0" ?>    <---- con spazio
      <pippo<pippo<pippo<pippo<<pippo<<<<<<tag/>

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test55F.xml 
      Error -55: [../samples/test55F.xml:0] not found close delimiter for tag [pippo]


====================================================================================================================

[-49] missing delimiter close for tag %s

      il delimitatore di chiusura (/>) di un tag senza contenuti presuppone che ci sia un TAG aperto in uno stato 
      consistenza che aspetta di essere chiuso. Il tag aperto lo si può trovare nello stack (quindi già)
      processato o nel buffer (da processare ancora, quindi alla sinistra di tale token)
      ma in ogni caso la situazione nel token rientrare in una delle seguenti casistiche :
      * nessun TAG nel buffer (vuoto) - si spera che il TAG da chiudere sia definito nel buffer (non ancora processato)
      * TAG precedente in stato 1. La situazione standard (TAG aperto che aspetta di essere chiuso)
      * TAG precedente in stato 3. Si spera che il TAG da chiudere sia definito nel buffer (non ancora processato)
      
      Nel caso in cui il TAG precedente è in stato 2 invece, quindi a questo manca il delimitatore di destra della CODA
      es. <tag> ... </tag .../>  il parse si ferma perchè sa che nel buffer non potrebbe mai trovare il delimitatore di
      chiusura dell'ultimo TAG presente... perchè se ci fosse stato sarebbe stato processato precedentemente...
      perchè tale carattere interrompe la bufferizazione...


      >> esempio 1.

      <?xml version = "1.0" ?>    <---- senza spazio
      <pippo ></pippo <tag/>

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test49A.xml
      Error -49: [../samples/test49A.xml:2] missing delimiter close for tag [pippo]



      >> esempio 2.

      <?xml version = "1.0" ?>    <---- senza spazio
      <pippo ></pippo <tag/>

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test49B.xml
      Error -49: [../samples/test49B.xml:2] missing delimiter close for tag [pippo]





====================================================================================================================

[-48] delimiter close tag but there isnt tag open

      il delimitatore di chiusura (/>) di un tag senza contenuti presuppone che ci sia un TAG aperto in uno stato 
      consistenza che aspetta di essere chiuso. Come detto in precedenza il parse deve tener conto (per avere la 
      situazione corretta) sia lo stack dei TAG acquisiti sia il BUFFER non ancora processato.
      Dopo aver processato il buffer lo stack a questo punto rispecchia la situazione aggiornata.
      Se una delle seguenti condizioni non è vera il parse si ferma con un errore :
      [condizione 1] Ultimo TAG presente nello stack non è in stato 0
      [condizione 2] Nome tag non assegnato 
      [condizione 3] Situazione variabili non consistente 

      Se alla sinistra del token il parser trova qualcosa, in quel caso nell'analizzare il buffer intercetta anche le casistiche 
      sopra elencate, quindi il parse si ferma prima. Dovrebbe incappare in questi errori solamente se non c'è stato
      nessun buffer da processare, cioè nel caso in cui alla sinistra del token c'è un separatore.

      L'errore in questione esce fuori quando il TAG precedente non è in stato ZERO, non è quindi il TAG che aspetta 
      di essere chiuso.



      ---------------------------------------------
      >>> esempio 1. Ok. Tutto Unico. Unico TAG.
      ---------------------------------------------

      <?xml version = "1.0"?>
      <tag-1/>

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test48A.xml 

      [DEBUG] [         XMLIni] | [                                                                              <?]
      [DEBUG] [            XML] | [                                                                             xml]
      [DEBUG] [       Separate] | [                                                                                ]
      [DEBUG] [       Variable] | [                                                                         version]
      [DEBUG] [       Separate] | [                                                                                ]
      [DEBUG] [         Assign] | [                                                                               =]
      [DEBUG] [          Value] | [                                                                           "1.0"]
      [DEBUG] [         XMLEnd] | [                                                                              ?>]
      [DEBUG] [     TagIniOpen] | [                                                                               <]
      [DEBUG] [         TagIni] | [                                                                              ?>]
      [DEBUG] [      TagIniEnd] | [                                                                              />]

      ================================ ============ ============ ============
                                                                       Numero
                                   Tag        Level        Stato    Variabili
      -------------------------------- ------------ ------------ ------------
      [                           xml] [         0] [         3] [         1]


      ================================ ============ ============ ============
                                                                       Numero
                                   Tag        Level        Stato    Variabili
      -------------------------------- ------------ ------------ ------------
      [                         tag-1] [         0] [         3] [         0]

      Ok.



      ---------------------------------------------
      >>> esempio 2. Ok. Token separato. Unico TAG
      ---------------------------------------------

      <?xml version = "1.0"?>
      <tag-1 />

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test48B.xml

      [DEBUG] [         XMLIni] | [                                                                              <?]
      [DEBUG] [            XML] | [                                                                             xml]
      [DEBUG] [       Separate] | [                                                                                ]
      [DEBUG] [       Variable] | [                                                                         version]
      [DEBUG] [       Separate] | [                                                                                ]
      [DEBUG] [         Assign] | [                                                                               =]
      [DEBUG] [          Value] | [                                                                           "1.0"]
      [DEBUG] [         XMLEnd] | [                                                                              ?>]
      [DEBUG] [     TagIniOpen] | [                                                                               <]
      [DEBUG] [         TagIni] | [                                                                           tag-1]
      [DEBUG] [       Separate] | [                                                                                ]
      [DEBUG] [      TagIniEnd] | [                                                                              />]

      ================================ ============ ============ ============
                                                                       Numero
                                   Tag        Level        Stato    Variabili
      -------------------------------- ------------ ------------ ------------
      [                           xml] [         0] [         3] [         1]


      ================================ ============ ============ ============
                                                                       Numero
                                   Tag        Level        Stato    Variabili
      -------------------------------- ------------ ------------ ------------
      [                         tag-1] [         0] [         3] [         0]

      


      ---------------------------------------------
      >>>> esempio 3. Ok, Tutto unito. 1 Variabile. Unico TAG.
      ---------------------------------------------

      <?xml version = "1.0"?>
      <tag-1 var="10"/>

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test48C.xml 

      [DEBUG] [         XMLIni] | [                                                                              <?]
      [DEBUG] [            XML] | [                                                                             xml]
      [DEBUG] [       Separate] | [                                                                                ]
      [DEBUG] [       Variable] | [                                                                         version]
      [DEBUG] [       Separate] | [                                                                                ]
      [DEBUG] [         Assign] | [                                                                               =]
      [DEBUG] [          Value] | [                                                                           "1.0"]
      [DEBUG] [         XMLEnd] | [                                                                              ?>]
      [DEBUG] [     TagIniOpen] | [                                                                               <]
      [DEBUG] [         TagIni] | [                                                                           tag-1]
      [DEBUG] [       Separate] | [                                                                                ]
      [DEBUG] [       Variable] | [                                                                             var]
      [DEBUG] [         Assign] | [                                                                               =]
      [DEBUG] [          Value] | [                                                                            "10"]
      [DEBUG] [      TagIniEnd] | [                                                                              />]

      ================================ ============ ============ ============
                                                                       Numero
                                   Tag        Level        Stato    Variabili
      -------------------------------- ------------ ------------ ------------
      [                           xml] [         0] [         3] [         1]
      [version] = ["1.0"]


      ================================ ============ ============ ============
                                                                       Numero
                                   Tag        Level        Stato    Variabili
      -------------------------------- ------------ ------------ ------------
      [                         tag-1] [         0] [         3] [         1]
      [var] = ["10"]




      ---------------------------------------------
      >>>>>> esempio 4. Ok. Token separato. 1 variabile. Unico TAG
      ---------------------------------------------

      <?xml version = "1.0"?>
      <tag-1 var="10" />

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test48D.xml 

      [DEBUG] [         XMLIni] | [                                                                              <?]
      [DEBUG] [            XML] | [                                                                             xml]
      [DEBUG] [       Separate] | [                                                                                ]
      [DEBUG] [       Variable] | [                                                                         version]
      [DEBUG] [       Separate] | [                                                                                ]
      [DEBUG] [         Assign] | [                                                                               =]
      [DEBUG] [          Value] | [                                                                           "1.0"]
      [DEBUG] [         XMLEnd] | [                                                                              ?>]
      [DEBUG] [     TagIniOpen] | [                                                                               <]
      [DEBUG] [         TagIni] | [                                                                           tag-1]
      [DEBUG] [       Separate] | [                                                                                ]
      [DEBUG] [       Variable] | [                                                                             var]
      [DEBUG] [         Assign] | [                                                                               =]
      [DEBUG] [          Value] | [                                                                            "10"]
      [DEBUG] [      TagIniEnd] | [                                                                              />]

      ================================ ============ ============ ============
                                                                       Numero
                                   Tag        Level        Stato    Variabili
      -------------------------------- ------------ ------------ ------------
      [                           xml] [         0] [         3] [         1]
      [version] = ["1.0"]


      ================================ ============ ============ ============
                                                                       Numero
                                   Tag        Level        Stato    Variabili
      -------------------------------- ------------ ------------ ------------
      [                         tag-1] [         0] [         3] [         1]
      [var] = ["10"]

      Ok.

      


      ---------------------------------------------
      >>>> esempio 5. Ok. 1 Variabile. Unito Token con value. Unico TAG.
      ---------------------------------------------

      <?xml version = "1.0"?>
      <tag-1 var= "10"/>

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test48E.xml 

      [DEBUG] [         XMLIni] | [                                                                              <?]
      [DEBUG] [            XML] | [                                                                             xml]
      [DEBUG] [       Separate] | [                                                                                ]
      [DEBUG] [       Variable] | [                                                                         version]
      [DEBUG] [       Separate] | [                                                                                ]
      [DEBUG] [         Assign] | [                                                                               =]
      [DEBUG] [          Value] | [                                                                           "1.0"]
      [DEBUG] [         XMLEnd] | [                                                                              ?>]
      [DEBUG] [     TagIniOpen] | [                                                                               <]
      [DEBUG] [         TagIni] | [                                                                           tag-1]
      [DEBUG] [       Separate] | [                                                                                ]
      [DEBUG] [       Variable] | [                                                                             var]
      [DEBUG] [         Assign] | [                                                                               =]
      [DEBUG] [          Value] | [                                                                            "10"]
      [DEBUG] [      TagIniEnd] | [                                                                              />]

      ================================ ============ ============ ============
                                                                       Numero
                                   Tag        Level        Stato    Variabili
      -------------------------------- ------------ ------------ ------------
      [                           xml] [         0] [         3] [         1]
      [version] = ["1.0"]


      ================================ ============ ============ ============
                                                                       Numero
                                   Tag        Level        Stato    Variabili
      -------------------------------- ------------ ------------ ------------
      [                         tag-1] [         0] [         3] [         1]
      [var] = ["10"]
     
      ok.




      ---------------------------------------------
      >>>> esempio 6. Ok. Token unito a Assign+Value. 1 Variabile. Unico TAG.
      ---------------------------------------------

      <?xml version = "1.0"?>
      <tag-1 var ="10"/>

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test48F.xml 

      [DEBUG] [         XMLIni] | [                                                                              <?]
      [DEBUG] [            XML] | [                                                                             xml]
      [DEBUG] [       Separate] | [                                                                                ]
      [DEBUG] [       Variable] | [                                                                         version]
      [DEBUG] [       Separate] | [                                                                                ]
      [DEBUG] [         Assign] | [                                                                               =]
      [DEBUG] [          Value] | [                                                                           "1.0"]
      [DEBUG] [         XMLEnd] | [                                                                              ?>]
      [DEBUG] [     TagIniOpen] | [                                                                               <]
      [DEBUG] [         TagIni] | [                                                                           tag-1]
      [DEBUG] [       Separate] | [                                                                                ]
      [DEBUG] [       Variable] | [                                                                             var]
      [DEBUG] [         Assign] | [                                                                               =]
      [DEBUG] [          Value] | [                                                                            "10"]
      [DEBUG] [      TagIniEnd] | [                                                                              />]

      ================================ ============ ============ ============
                                                                       Numero
                                   Tag        Level        Stato    Variabili
      -------------------------------- ------------ ------------ ------------
      [                           xml] [         0] [         3] [         1]
      [version] = ["1.0"]


      ================================ ============ ============ ============
                                                                       Numero
                                   Tag        Level        Stato    Variabili
      -------------------------------- ------------ ------------ ------------
      [                         tag-1] [         0] [         3] [         1]
      [var] = ["10"]

      Ok.

      


      ---------------------------------------------
      >>>> esempio 7. Ok. 1 Variabile. Token separato. Unico TAG.
      ---------------------------------------------

      <?xml version = "1.0"?>
      <tag-1 var ="10" />
      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test48G.xml

      [DEBUG] [         XMLIni] | [                                                                              <?]
      [DEBUG] [            XML] | [                                                                             xml]
      [DEBUG] [       Separate] | [                                                                                ]
      [DEBUG] [       Variable] | [                                                                         version]
      [DEBUG] [       Separate] | [                                                                                ]
      [DEBUG] [         Assign] | [                                                                               =]
      [DEBUG] [          Value] | [                                                                           "1.0"]
      [DEBUG] [         XMLEnd] | [                                                                              ?>]
      [DEBUG] [     TagIniOpen] | [                                                                               <]
      [DEBUG] [         TagIni] | [                                                                           tag-1]
      [DEBUG] [       Separate] | [                                                                                ]
      [DEBUG] [       Variable] | [                                                                             var]
      [DEBUG] [         Assign] | [                                                                               =]
      [DEBUG] [          Value] | [                                                                            "10"]
      [DEBUG] [      TagIniEnd] | [                                                                              />]

      ================================ ============ ============ ============
                                                                       Numero
                                   Tag        Level        Stato    Variabili
      -------------------------------- ------------ ------------ ------------
      [                           xml] [         0] [         3] [         1]
      [version] = ["1.0"]


      ================================ ============ ============ ============
                                                                       Numero
                                   Tag        Level        Stato    Variabili
      -------------------------------- ------------ ------------ ------------
      [                         tag-1] [         0] [         3] [         1]
      [var] = ["10"]

      Ok. 




      ---------------------------------------------
      >>>>> esempio 8. Ok. Token unito a Value. Unico TAG. 1 variabile.
      ---------------------------------------------

      <?xml version = "1.0"?>
      <tag-1 var = "10"/>

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test48H.xml 

      [DEBUG] [         XMLIni] | [                                                                              <?]
      [DEBUG] [            XML] | [                                                                             xml]
      [DEBUG] [       Separate] | [                                                                                ]
      [DEBUG] [       Variable] | [                                                                         version]
      [DEBUG] [       Separate] | [                                                                                ]
      [DEBUG] [         Assign] | [                                                                               =]
      [DEBUG] [          Value] | [                                                                           "1.0"]
      [DEBUG] [         XMLEnd] | [                                                                              ?>]
      [DEBUG] [     TagIniOpen] | [                                                                               <]
      [DEBUG] [         TagIni] | [                                                                           tag-1]
      [DEBUG] [       Separate] | [                                                                                ]
      [DEBUG] [       Variable] | [                                                                             var]
      [DEBUG] [         Assign] | [                                                                               =]
      [DEBUG] [          Value] | [                                                                            "10"]
      [DEBUG] [      TagIniEnd] | [                                                                              />]

      ================================ ============ ============ ============
                                                                       Numero
                                   Tag        Level        Stato    Variabili
      -------------------------------- ------------ ------------ ------------
      [                           xml] [         0] [         3] [         1]
      [version] = ["1.0"]


      ================================ ============ ============ ============
                                                                       Numero
                                   Tag        Level        Stato    Variabili
      -------------------------------- ------------ ------------ ------------
      [                         tag-1] [         0] [         3] [         1]
      [var] = ["10"]

      Ok.





      ---------------------------------------------
      >>>> esempio 9. Ok. 1 Variabile. Token separato. 1 Tag.
      ---------------------------------------------

      <?xml version = "1.0"?>
      <tag-1 var = "10" />

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test48I.xml 

      [DEBUG] [         XMLIni] | [                                                                              <?]
      [DEBUG] [            XML] | [                                                                             xml]
      [DEBUG] [       Separate] | [                                                                                ]
      [DEBUG] [       Variable] | [                                                                         version]
      [DEBUG] [       Separate] | [                                                                                ]
      [DEBUG] [         Assign] | [                                                                               =]
      [DEBUG] [          Value] | [                                                                           "1.0"]
      [DEBUG] [         XMLEnd] | [                                                                              ?>]
      [DEBUG] [     TagIniOpen] | [                                                                               <]
      [DEBUG] [         TagIni] | [                                                                           tag-1]
      [DEBUG] [       Separate] | [                                                                                ]
      [DEBUG] [       Variable] | [                                                                             var]
      [DEBUG] [         Assign] | [                                                                               =]
      [DEBUG] [          Value] | [                                                                            "10"]
      [DEBUG] [      TagIniEnd] | [                                                                              />]

      ================================ ============ ============ ============
                                                                       Numero
                                   Tag        Level        Stato    Variabili
      -------------------------------- ------------ ------------ ------------
      [                           xml] [         0] [         3] [         1]
      [version] = ["1.0"]


      ================================ ============ ============ ============
                                                                       Numero
                                   Tag        Level        Stato    Variabili
      -------------------------------- ------------ ------------ ------------
      [                         tag-1] [         0] [         3] [         1]
      [var] = ["10"]

      Ok.




      ---------------------------------------------
      >>>>> esempio 10. KO. Token con TAG ultimo <> 0.
      ---------------------------------------------

      <?xml version = "1.0"?>
      <tag-1 >
            <tag-2 >
            </tag-2>
      </tag-1>
      />

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test48L.xml 
      Error -48: [../samples/test48L.xml:6] delimiter close tag but there isnt tag open


====================================================================================================================

[-50] il delimitatore di chiusura (/>) di un tag senza contenuti presuppone che ci sia un TAG aperto in uno stato 
      consistenza che aspetta di essere chiuso. Come detto in precedenza il parse deve tener conto (per avere la 
      situazione corretta) sia lo stack dei TAG acquisiti sia il BUFFER non ancora processato.
      Dopo aver processato il buffer lo stack a questo punto rispecchia la situazione aggiornata.
      Se una delle seguenti condizioni non è vera il parse si ferma con un errore :
      [condizione 1] Ultimo TAG presente nello stack non è in stato 0
      [condizione 2] Nome tag non assegnato 
      [condizione 3] Situazione variabili non consistente 

      Se alla sinistra del token il parser trova qualcosa, in quel caso nell'analizzare il buffer intercetta anche le casistiche 
      sopra elencate, quindi il parse si ferma prima. Dovrebbe incappare in questi errori solamente se non c'è stato
      nessun buffer da processare, cioè nel caso in cui alla sinistra del token c'è un separatore.

      L'errore in questione esce fuori quando il TAG precedente è in stato ZERO, ma il nome TAG non 
      è ancora assegnato. [condizione 2] 


      esempio 1.

      <?xml version = "1.0"?>
      < />

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test50A.xml 

      [DEBUG] [         XMLIni] | [                                                                              <?]
      [DEBUG] [            XML] | [                                                                             xml]
      [DEBUG] [       Separate] | [                                                                                ]
      [DEBUG] [       Variable] | [                                                                         version]
      [DEBUG] [       Separate] | [                                                                                ]
      [DEBUG] [         Assign] | [                                                                               =]
      [DEBUG] [          Value] | [                                                                           "1.0"]
      [DEBUG] [         XMLEnd] | [                                                                              ?>]
      [DEBUG] [     TagIniOpen] | [                                                                               <]
      [DEBUG] [       Separate] | [                                                                                ]

      Error -50: [../samples/test50A.xml:2] missing tag name


====================================================================================================================

[-51] il delimitatore di chiusura (/>) di un tag senza contenuti presuppone che ci sia un TAG aperto in uno stato 
      consistenza che aspetta di essere chiuso. Come detto in precedenza il parse deve tener conto (per avere la 
      situazione corretta) sia lo stack dei TAG acquisiti sia il BUFFER non ancora processato.
      Dopo aver processato il buffer lo stack a questo punto rispecchia la situazione aggiornata.
      Se una delle seguenti condizioni non è vera il parse si ferma con un errore :
      [condizione 1] Ultimo TAG presente nello stack non è in stato 0
      [condizione 2] Nome tag non assegnato 
      [condizione 3] Situazione variabili non consistente 

      Se alla sinistra del token il parser trova qualcosa, in quel caso nell'analizzare il buffer intercetta anche le casistiche 
      sopra elencate, quindi il parse si ferma prima. Dovrebbe incappare in questi errori solamente se non c'è stato
      nessun buffer da processare, cioè nel caso in cui alla sinistra del token c'è un separatore.

      L'errore in questione esce fuori quando il TAG precedente è in stato ZERO, il nome del TAG è assegnato. 
      La situazione variabili è inconsistente, in particolare è definita una variabile ma è senza ASSIGN
      ne tantomeno valorizzata [condizione 3]

      esempio 1.

      <?xml version = "1.0"?>
      <tag-1 var />

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test51A.xml
      Error -51: [../samples/test51A.xml:2] missing assign and value for var [var]


====================================================================================================================

[-52] il delimitatore di chiusura (/>) di un tag senza contenuti presuppone che ci sia un TAG aperto in uno stato 
      consistenza che aspetta di essere chiuso. Come detto in precedenza il parse deve tener conto (per avere la 
      situazione corretta) sia lo stack dei TAG acquisiti sia il BUFFER non ancora processato.
      Dopo aver processato il buffer lo stack a questo punto rispecchia la situazione aggiornata.
      Se una delle seguenti condizioni non è vera il parse si ferma con un errore :
      [condizione 1] Ultimo TAG presente nello stack non è in stato 0
      [condizione 2] Nome tag non assegnato 
      [condizione 3] Situazione variabili non consistente 

      Se alla sinistra del token il parser trova qualcosa, in quel caso nell'analizzare il buffer intercetta anche le casistiche 
      sopra elencate, quindi il parse si ferma prima. Dovrebbe incappare in questi errori solamente se non c'è stato
      nessun buffer da processare, cioè nel caso in cui alla sinistra del token c'è un separatore.

      L'errore in questione esce fuori quando il TAG precedente è in stato ZERO, il nome del TAG è assegnato. 
      La situazione variabili è inconsistente, in particolare è definita una variabile, è presente l'ASSIGN
      manca però il "value" [condizione 3]


      esempio 1.

      <?xml version = "1.0"?>
      <tag-1 var= />

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test52A.xml
      Error -52: [../samples/test52A.xml:2] missing assign for var [var]


      esempio 2.

      <?xml version = "1.0"?>
      <tag-1 var=/>

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test52B.xml
      Error -52: [../samples/test52B.xml:2] missing assign for var [var]


      esempio 3.

      <?xml version = "1.0"?>
      <tag-1 var = />

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test52C.xml
      Error -52: [../samples/test52C.xml:2] missing assign for var [var]





====================================================================================================================
__TAG_END__
====================================================================================================================

Il token __TAG_END__ chiude un TAG di TEST o un TAG di CODA solamente per i TAG Utente. (quindi non TAG di 
Intestazione XML che vengono chiusi con "?>"). Questo vuol dire che tale TAG si aspetta di trovare consolidata 
la parte di intestazione ed un TAG testa|coda aperto. (es. <tag|<tag></tag). Quindi ricapitolando :

1. controllo intestazione consolidata.
2. presenza di almeno un TAG stack dati (dopo aver svuotato il buffer)
3. che l'albero dati non sia chiuso.
4. quindi posizionamento sul primo TAG in stato 0|2 (aperta TESTA|aperta CODA)
5. verifica dell'assegnazione del nome
6. verifica assenza variabili o stato consolidato in caso di stato 0
7. registrazione token.

****************************************************
*** Esiste un problemaccio con il TAG di CODA    ***
*** Ad oggi non viene memorizzato nulla che      ***
*** faccia capire se il token è stato acquisito  ***
*** o meno. Lo si può trovare dopo un token di   ***
*** SEPARAZIONE (non ancora analizzato) o dopo   ***
*** un token TAG_END appunto. Sarebbe necessario ***
*** aggiungere un ulteriore STATO tra gli        ***
*** attuali stati 2 e 3 ma quetso poi sarebbe    ***
*** poco fluido perchè tra gli attuali 1 e 2 non ***
*** esiste (il test è su *Unknown*) e quindi     ***
*** bisognerebbe aggiungerlo anche lì            ***
*** stravolgendo completamente la numerazione    ***
***                                              ***
*** 0  =  0                                      ***
*** 0  =  1                                      ***
*** 1  =  2                                      ***
*** 2  =  3                                      ***
*** 2  =  4                                      ***
*** 3  =  5                                      ***
***                                              ***
*** e quindi il test per verificare se il nome è ***
*** assegnato o meno lo si potrebbe fare non più ***
*** sul nome tag fittizio *Unknown* ma sul stato ***
*** uguale a 1 (*unknown*) o maggiore di 1.      ***
****************************************************


====================================================================================================================
[69] not found XML head.

     Un token di chiusura di un TAG DATI di TESTA|CODA vice nell'albero dati e non nelle intestazioni XML del documento.
     Le intestazioni XML devo stare in TESTA al documento quindi prima dell'albero DATI. Questo significa che 
     prima di tutto il parse deve verificare che l'area intestazione prima di tutto non sia vuota che vuol dire che ci 
     deve essere almeno un TAG nello stack XML :

     >>> esempio 1. 

     <tag><\tag>

     jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test69A.xml 
     Error -69: [../samples/test69A.xml:1] not found XML head.


====================================================================================================================
[70] Last TAG XML isnt close [%s]

     Un token di chiusura di un TAG DATI di TESTA|CODA vice nell'albero dati e non nelle intestazioni XML del documento.
     Le intestazioni XML devo stare in TESTA al documento quindi prima dell'albero DATI. Questo significa che 
     prima di tutto il parse deve verificare che l'area intestazione sia chiusa che vuol dire che ci deve essere almeno 
     un TAG nello stack XML e che l'ultimo TAG sia consolidato|chiuso.

     >>> esempio 1. 

     <?
     <tag><\tag>

     jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test70A.xml 
     Error -70: [../samples/test70A.xml:2] Last TAG XML isnt close [*Unknown*]


     >>> esempio 2. 

     <?xml
     <tag><\tag>

     jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test70B.xml 
     Error -70: [../samples/test70B.xml:2] Last TAG XML isnt close [*Unknown*]


     >>> esempio 3. 

     <? xml
     <tag><\tag>

     jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test70C.xml 
     Error -70: [../samples/test70C.xml:2] Last TAG XML isnt close [*Unknown*]

     (*) interessante notare che il parse non da un'informazione precisissima. Infatti non riesce ad analizzare
         e catogare il token "xml" perchè questo è unito al tag dati e quindi finisce ne buffer col token di 
         chiusura "xml<tag>". Se riuscisse a passare il controllo e quelli successivi rischierebbe per divenire 
         un Unknown token... 
 

     >>> esempio 4. 

     <?xml version
     <tag><\tag>

     jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test70D.xml 
     Error -70: [../samples/test70D.xml:2] Last TAG XML isnt close [xml]

     (*) interessante notare che il parse non da un'informazione precisissima. Infatti non riesce ad analizzare
         e catogare il token "xml" perchè questo è unito al tag dati e quindi finisce ne buffer col token di 
         chiusura "xml<tag>". Se riuscisse a passare il controllo e quelli successivi rischierebbe per divenire 
         un Unknown token... 


     >>> esempio 5. 

     <? xml version
     <tag><\tag>

     jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test70E.xml 
     Error -70: [../samples/test70E.xml:2] Last TAG XML isnt close [xml]


     >>> esempio 6. 

     <?xml version=
     <tag><\tag>

     jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test70F.xml 
     Error -70: [../samples/test70F.xml:2] Last TAG XML isnt close [xml]


     >>> esempio 7. 

     <? xml version=
     <tag><\tag>

     jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test70G.xml 
     Error -70: [../samples/test70G.xml:2] Last TAG XML isnt close [xml]


     >>> esempio 8. 

     <?xml version =
     <tag><\tag>

     jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test70H.xml 
     Error -70: [../samples/test70H.xml:2] Last TAG XML isnt close [xml]


     >>> esempio 9. 

     <? xml version =
     <tag><\tag>

     jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test70I.xml 
     Error -70: [../samples/test70I.xml:2] Last TAG XML isnt close [xml]


     >>> esempio 10. 

     <?xml version="1.0"
     <tag><\tag>

     jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test70L.xml 
     Error -70: [../samples/test70L.xml:2] Last TAG XML isnt close [xml]


     >>> esempio 11. 

     <? xml version="1.0"
     <tag><\tag>

     jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test70M.xml 
     Error -70: [../samples/test70M.xml:2] Last TAG XML isnt close [xml]


     >>> esempio 12. 

     <?xml version ="1.0"
     <tag><\tag>

     jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test70N.xml 
     Error -70: [../samples/test70N.xml:2] Last TAG XML isnt close [xml]


     >>> esempio 13. 

     <? xml version ="1.0"
     <tag><\tag>

     jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test70O.xml 
     Error -70: [../samples/test70O.xml:2] Last TAG XML isnt close [xml]


     >>> esempio 14. 

     <?xml version = "1.0"
     <tag><\tag>

     jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test70P.xml 
     Error -70: [../samples/test70P.xml:2] Last TAG XML isnt close [xml]


     >>> esempio 15. 

     <? xml version = "1.0"
     <tag><\tag>

     jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test70Q.xml 
     Error -70: [../samples/test70Q.xml:2] Last TAG XML isnt close [xml]


     >>> esempio 16. 

     <?xml version = "1.0"?>
     <?
     <tag><\tag>

     jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test70R.xml 
     Error -70: [../samples/test70R.xml:3] Last TAG XML isnt close [xml]




====================================================================================================================
[35] found tag delimiter close but no tag

     Un token di chiusura di un TAG DATI di TESTA|CODA vice nell'albero dati e non nelle intestazioni XML del documento.
     Le intestazioni XML devo stare in TESTA al documento quindi prima dell'albero DATI. Questo significa che 
     prima di tutto il parse deve verificare che l'area intestazione sia chiusa che vuol dire che ci deve essere almeno 
     un TAG nello stack XML e che l'ultimo TAG sia consolidato|chiuso. Se questa prima verifica è superata allora il
     parse verifica se ci si trovi nell'albero, quindi se questo è aperto, se c'è quindi almeno un TAG registrato nello
     stack che definisce l'albero DATI. Se l'albero è vuoto e la situazione è aggiornata (buffer vuoto) il parse esce
     perchè se lo stack è vuoto significa che non c'è sicuramente nessun TAG aperto.

     >>> esempio 1.

     <?xml version = "1.0" ?>
     >

     jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test35A.xml
     Error -35: [../samples/test35A.xml:2] found tag delimiter close but no tag


     >>> esempio 2.

     <?xml version = "1.0" ?>    <---- con spazio
     >

     jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test35B.xml
     Error -35: [../samples/test35B.xml:2] found tag delimiter close but no tag


====================================================================================================================
[36] the three is complete.

     Un token di chiusura di un TAG DATI di TESTA|CODA vive nell'albero dati e non nelle intestazioni XML del documento.
     Le intestazioni XML devo stare in TESTA al documento quindi prima dell'albero DATI. Questo significa che 
     prima di tutto il parse deve verificare che l'area intestazione sia chiusa che vuol dire che ci deve essere almeno 
     un TAG nello stack XML e che l'ultimo TAG sia consolidato|chiuso. Se questa prima verifica è superata allora il
     parse verifica se ci si trovi nell'albero, quindi se questo è aperto, se c'è quindi almeno un TAG registrato nello
     stack che definisce l'albero DATI. Se l'albero risulta definito (quindi se esiste almeno un TAG nel corrispondente
     stack) il parse verifica che l'albero non sia completamente definito. Questo verifica la fa controllando che lo stato
     del TAG radice non stia a "3", chiuso. Se la radice è chiusa l'albero è completamente definito e quindi non
     c'è porto per nullaltro. In XML si può definire al massimo un unico albero dati.

     >>>> esempio 1. Nell'esempio tag-1 è la radice dell'albero.

     <?xml version = "1.0" ?>
     <tag-1>
          <tag-2 var = "100"/>
     </tag-1>
     ></tag-3>
     o
     |
     '------- il parse è quà

     jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test36A.xml
     Error -36: [../samples/test36A.xml:5] found tag delimiter close but no tag open



     >>>> esempio 2. Nell'esempio tag-1 è la radice dell'albero.

     <?xml version = "1.0" ?>
     <tag-1>
          <tag-2 var = "100"/>
     </tag-1>
     tag-3></tag-3>
          o
          |
          '------- il parse è quà

     jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test36B.xml
     Error -36: [../samples/test36B.xml:5] found tag delimiter close but no tag open



     >>>> esempio 3. Nell'esempio tag-1 è la radice dell'albero.

     <?xml version = "1.0" ?>
     <tag-1>
          <tag-2 var = "100"/>
     </tag-1>
     <tag-3></tag-3>
           o
           |
           '------- il parse è quà

     jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test36C.xml
     Error -36: [../samples/test36C.xml:5] found tag delimiter close but no tag open

            

====================================================================================================================
[71] Found delimiter close but no TAG open.

     Un token di chiusura di un TAG DATI di TESTA|CODA vive nell'albero dati e non nelle intestazioni XML del documento.
     Le intestazioni XML devo stare in TESTA al documento quindi prima dell'albero DATI. Questo significa che 
     prima di tutto il parse deve verificare che l'area intestazione sia chiusa che vuol dire che ci deve essere almeno 
     un TAG nello stack XML e che l'ultimo TAG sia consolidato|chiuso. Se questa prima verifica è superata allora il
     parse verifica se ci si trovi nell'albero, quindi se questo è aperto, se c'è quindi almeno un TAG registrato nello
     stack che definisce l'albero DATI. Se l'albero risulta definito (quindi se esiste almeno un TAG nel corrispondente
     stack) il parse verifica che l'albero non sia completamente definito. Questo verifica la fa controllando che lo stato
     del TAG radice non stia a "3", chiuso. Se la radice è chiusa l'albero è completamente definito e quindi non
     c'è porto per nullaltro. In XML si può definire al massimo un unico albero dati. Nel costro caso l'albero 
     non è completamente chiuso, quindi aperto, il token è posizionato al suo interno. Il parse a questo punto deve cercare
     il TAG aperto a cui associare il token di chiusura trovato. Legge allora a ritroso lo stack (dall'inserimento più
     recente a quello meno recente) sicuro di trovarne uno ancora aperto (perchè lo stack non risulta chiuso).
     Il token di chiusura è il medesimo sia per TAG di TESTA sia per TAG di coda è quindi si ferma al primo TAG 
     che trova in uno di questi dei stati (stato 0|2).

     o CASISTICA 1. TAG TESTA Aperto (stato 0)

     <tag-1>
          <tag-2>
               <tag-3>
     ...             o
                     |
                     '------- il parsen è quà.

     Il TAG di TESTA Aperto lo può trovare solamente come ultimo TAG inserito, perchè un TAG in tale stato non può
     trovarsi al centro non essendo ancora consolidato.


     o CASISTICA 2. TAG TESTA Aperto (stato 2)

     <tag-1>
          <tag-2>
               <tag-3></tag-3>
          </tag-2>
     ...         o
                 |
                 '------- il parsen è quà.

     Il TAG di CODA aperto il parse se lo aspetta in qualsiasi posizione dello stack. Tra il TAG di CODA e quello 
     precedentemente inserito di TESTA ci potrebbero essere dei figli (come nel'esempio precedente - tag-3 è figlio
     di tag-2). Nel caso non abbia figli il TAG di TESTA corrispondente lo trova in ultima posizione (ultimo inserito).
     

     Il parse si ferma anche se trova una TAG di TESTA chiuso (stato 1) perchè potrebbe anche essere che l'albero non sia 
     ancora aggiornatissimo per via del buffer da processare. 

     <tag-1>
          <tag-2>
               <tag-3></tag3>
          </tag-2>   o
     ...             |
                     |
                     '------- il parsen è quà.

     Nell'esempio precedete ad esempio, nel momento il cui il parse incontra il token di chiusura di tag-3 TESTA
     si ritrova la seguente situazione nello stack e nel buffer :

     stack 

     \                 /
   1 | tag-1 [stato 1] |
   2 | tag-2 [stato 1] |
     /                 \

     buffer: <tag-3
     token : >

     - - - - - 

     Se lo stack fosse aggiornato si troverebbe il TAG 3 in stato 0 (aperto). Quindi non conoscendo ancora il contenuto del buffer 
     e quindi la situazione aggiornata dello stack, per il momento sceglie di non scartare l'ipotesi che nel buffer ci possa
     essere la definizione di un intero TAG di TESTA figlio del TAG trovato in stato 1 (tag-2). Se il buffer è vuoto 
     però si ferma per errore perchè ha di fronte una situazione con nulla da aggiornare.


     >>>> esempio 1. 

     <?xml version = "1.0" ?>
     <tag-1>
          <tag-2>>
     </tag-1>    o
                 |
                 |
                 '------- il parse è quà

     jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test71A.xml
     Error -71: [../samples/test71A.xml:3] Found delimiter close but no TAG open.


     >>>> esempio 2. 

     <?xml version = "1.0" ?>
     <tag-1>
          <tag-2>
               <tag-3/>
               <tag-4/>
               <tag-5/>
          > o----.  
     </tag-1>    |
                 |
                 '------- il parse è quà


     jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test71B.xml
     Error -71: [../samples/test71B.xml:7] Found delimiter close but no TAG open.



====================================================================================================================
[72] delimiter close but TAG havent name.

     Un token di chiusura di un TAG DATI di TESTA|CODA vive nell'albero dati e non nelle intestazioni XML del documento.
     Le intestazioni XML devo stare in TESTA al documento quindi prima dell'albero DATI. Questo significa che 
     prima di tutto il parse deve verificare che l'area intestazione sia chiusa che vuol dire che ci deve essere almeno 
     un TAG nello stack XML e che l'ultimo TAG sia consolidato|chiuso. Se questa prima verifica è superata allora il
     parse verifica se ci si trovi nell'albero, quindi se questo è aperto, se c'è quindi almeno un TAG registrato nello
     stack che definisce l'albero DATI. Se l'albero risulta definito (quindi se esiste almeno un TAG nel corrispondente
     stack) il parse verifica che l'albero non sia completamente definito. Questo verifica la fa controllando che lo stato
     del TAG radice non stia a "3", chiuso. Se la radice è chiusa l'albero è completamente definito e quindi non
     c'è porto per nullaltro. In XML si può definire al massimo un unico albero dati. Nel costro caso l'albero 
     non è completamente chiuso, quindi aperto, il token è posizionato al suo interno. Il parse a questo punto deve cercare
     il TAG aperto a cui associare il token di chiusura trovato. Legge allora a ritroso lo stack (dall'inserimento più
     recente a quello meno recente) sicuro di trovarne uno ancora aperto (perchè lo stack non risulta chiuso).
     Il token di chiusura è il medesimo sia per TAG di TESTA sia per TAG di coda è quindi si ferma al primo TAG 
     che trova in uno di questi dei stati (stato 0|2). Inoltre si ferma anche se trova un TAG in stato 1 se il buffer 
     non è ancora vuoto, come detto in precedenza (perchè la situazione aggiornata potrebbe rilevare un nuovo TAG
     nel buffer in stato 0. Se il buffer è vuoto i TAG validi rimandono quelli negli stati 0|1. Se lo scenario è
     questo il TAG in stato 0|1 (e col buffer vuoto) deve avere una situazione consolidata :
     * deve avere un nome assegnato il TAG nella TESTA (nome <> *Unknown*)
     * deve avere un nome assegnato il TAG nella CODA ( NON IMPLEMENTABILE AL MOMENTO ) 
     * deve avere una situazione consolidata per le variabili (stato_last_variable = 0)
     Se la prma condizione non è vera il parse esce con l'errore che si sta documentando. 

     Di esempi se ne può fare uno credo...

     >>>> esempio 1.

     <?xml version = "1.0" ?>
     < >

     jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test72A.xml
     Error -72: [../samples/test72A.xml:2] delimiter close but TAG havent name.



====================================================================================================================
[73] delimiter close but missing assign var [%s]

     Un token di chiusura di un TAG DATI di TESTA|CODA vive nell'albero dati e non nelle intestazioni XML del documento.
     Le intestazioni XML devo stare in TESTA al documento quindi prima dell'albero DATI. Questo significa che 
     prima di tutto il parse deve verificare che l'area intestazione sia chiusa che vuol dire che ci deve essere almeno 
     un TAG nello stack XML e che l'ultimo TAG sia consolidato|chiuso. Se questa prima verifica è superata allora il
     parse verifica se ci si trovi nell'albero, quindi se questo è aperto, se c'è quindi almeno un TAG registrato nello
     stack che definisce l'albero DATI. Se l'albero risulta definito (quindi se esiste almeno un TAG nel corrispondente
     stack) il parse verifica che l'albero non sia completamente definito. Questo verifica la fa controllando che lo stato
     del TAG radice non stia a "3", chiuso. Se la radice è chiusa l'albero è completamente definito e quindi non
     c'è porto per nullaltro. In XML si può definire al massimo un unico albero dati. Nel costro caso l'albero 
     non è completamente chiuso, quindi aperto, il token è posizionato al suo interno. Il parse a questo punto deve cercare
     il TAG aperto a cui associare il token di chiusura trovato. Legge allora a ritroso lo stack (dall'inserimento più
     recente a quello meno recente) sicuro di trovarne uno ancora aperto (perchè lo stack non risulta chiuso).
     Il token di chiusura è il medesimo sia per TAG di TESTA sia per TAG di coda è quindi si ferma al primo TAG 
     che trova in uno di questi dei stati (stato 0|2). Inoltre si ferma anche se trova un TAG in stato 1 se il buffer 
     non è ancora vuoto, come detto in precedenza (perchè la situazione aggiornata potrebbe rilevare un nuovo TAG
     nel buffer in stato 0. Se il buffer è vuoto i TAG validi rimandono quelli negli stati 0|1. Se lo scenario è
     questo il TAG in stato 0|1 (e col buffer vuoto) deve avere una situazione consolidata :
     * deve avere un nome assegnato il TAG nella TESTA (nome <> *Unknown*)
     * deve avere un nome assegnato il TAG nella CODA ( NON IMPLEMENTABILE AL MOMENTO ) 
     * deve avere una situazione consolidata per le variabili (stato_last_variable = 0)
     Se la prima condizione è vera, il parse verifica che la situazione variabile per il TAG sia consolidata. Nel 
     dettaglio se vengono definite variabili, l'ultima deve essere completamente definita ( var + assign + value ), 
     nel caso in cui l'ultima variabile è in attesa di assign (es. "<tag var >", "<tag var = '1' var-2 >") il 
     parse esce con questo errore.   

     >>>> esempio 1.

     <?xml version = "1.0" ?>
     <tag var1 >

     jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML test73A.xml   
     Error -73: [test73A.xml:2] delimiter close but missing assign var [tag]


     >>>> esempio 2.

     <?xml version = "1.0" ?>
     <tag var1 = "1" var2 >

     jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML test73B.xml 
     Error -73: [test73B.xml:2] delimiter close but missing assign var [tag]


====================================================================================================================
[74] delimiter close but missing value var [%s]

     Un token di chiusura di un TAG DATI di TESTA|CODA vive nell'albero dati e non nelle intestazioni XML del documento.
     Le intestazioni XML devo stare in TESTA al documento quindi prima dell'albero DATI. Questo significa che 
     prima di tutto il parse deve verificare che l'area intestazione sia chiusa che vuol dire che ci deve essere almeno 
     un TAG nello stack XML e che l'ultimo TAG sia consolidato|chiuso. Se questa prima verifica è superata allora il
     parse verifica se ci si trovi nell'albero, quindi se questo è aperto, se c'è quindi almeno un TAG registrato nello
     stack che definisce l'albero DATI. Se l'albero risulta definito (quindi se esiste almeno un TAG nel corrispondente
     stack) il parse verifica che l'albero non sia completamente definito. Questo verifica la fa controllando che lo stato
     del TAG radice non stia a "3", chiuso. Se la radice è chiusa l'albero è completamente definito e quindi non
     c'è porto per nullaltro. In XML si può definire al massimo un unico albero dati. Nel costro caso l'albero 
     non è completamente chiuso, quindi aperto, il token è posizionato al suo interno. Il parse a questo punto deve cercare
     il TAG aperto a cui associare il token di chiusura trovato. Legge allora a ritroso lo stack (dall'inserimento più
     recente a quello meno recente) sicuro di trovarne uno ancora aperto (perchè lo stack non risulta chiuso).
     Il token di chiusura è il medesimo sia per TAG di TESTA sia per TAG di coda è quindi si ferma al primo TAG 
     che trova in uno di questi dei stati (stato 0|2). Inoltre si ferma anche se trova un TAG in stato 1 se il buffer 
     non è ancora vuoto, come detto in precedenza (perchè la situazione aggiornata potrebbe rilevare un nuovo TAG
     nel buffer in stato 0. Se il buffer è vuoto i TAG validi rimandono quelli negli stati 0|1. Se lo scenario è
     questo il TAG in stato 0|1 (e col buffer vuoto) deve avere una situazione consolidata :
     * deve avere un nome assegnato il TAG nella TESTA (nome <> *Unknown*)
     * deve avere un nome assegnato il TAG nella CODA ( NON IMPLEMENTABILE AL MOMENTO ) 
     * deve avere una situazione consolidata per le variabili (stato_last_variable = 0)
     Se la prima condizione è vera, il parse verifica che la situazione variabile per il TAG sia consolidata. Nel 
     dettaglio se vengono definite variabili, l'ultima deve essere completamente definita ( var + assign + value ), 
     nel caso in cui l'ultima variabile è in attesa di value (es. "<tag var = >", "<tag var = '1' var-2 = >") il 
     parse esce con questo errore.   

     >>>> esempio 1.

     <?xml version = "1.0" ?>
     <tag var1 = >

     jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML test74A.xml 
     Error -74: [test74A.xml:2] delimiter close but missing value var [tag]


     >>>> esempio 2.

     <?xml version = "1.0" ?>
     <tag var1= >

     jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML test74B.xml 
     Error -74: [test74B.xml:2] delimiter close but missing value var [tag]


     >>>> esempio 3.

     <?xml version = "1.0" ?>
     <tag var1 = "1" var2 = >

     jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML test74C.xml 
     Error -74: [test74C.xml:2] delimiter close but missing value var [tag]


     >>>> esempio 4.

     <?xml version = "1.0" ?>
     <tag var1 = "1" var2= >

     jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML test74D.xml 
     Error -74: [test74D.xml:2] delimiter close but missing value var [tag]



====================================================================================================================
[75] delimiter close but missing assign var [%s]

     Un token di chiusura di un TAG DATI di TESTA|CODA vive nell'albero dati e non nelle intestazioni XML del documento.
     Le intestazioni XML devo stare in TESTA al documento quindi prima dell'albero DATI. Questo significa che 
     prima di tutto il parse deve verificare che l'area intestazione sia chiusa che vuol dire che ci deve essere almeno 
     un TAG nello stack XML e che l'ultimo TAG sia consolidato|chiuso. Se questa prima verifica è superata allora il
     parse verifica se ci si trovi nell'albero, quindi se questo è aperto, se c'è quindi almeno un TAG registrato nello
     stack che definisce l'albero DATI. Se l'albero risulta definito (quindi se esiste almeno un TAG nel corrispondente
     stack) il parse verifica che l'albero non sia completamente definito. Questo verifica la fa controllando che lo stato
     del TAG radice non stia a "3", chiuso. Se la radice è chiusa l'albero è completamente definito e quindi non
     c'è porto per nullaltro. In XML si può definire al massimo un unico albero dati. Nel nostro caso l'albero 
     non è completamente chiuso, quindi aperto, il token è posizionato al suo interno. Il parse a questo punto deve cercare
     il TAG aperto a cui associare il token di chiusura trovato. Legge allora a ritroso lo stack (dall'inserimento più
     recente a quello meno recente) sicuro di trovarne uno ancora aperto (perchè lo stack non risulta chiuso).
     Il token di chiusura è il medesimo sia per TAG di TESTA sia per TAG di coda è quindi si ferma al primo TAG 
     che trova in uno di questi dei stati (stato 0|2). Inoltre si ferma anche se trova un TAG in stato 1 se il buffer 
     non è ancora vuoto, come detto in precedenza (perchè la situazione aggiornata potrebbe rilevare un nuovo TAG
     nel buffer in stato 0. Se il buffer è vuoto i TAG validi rimandono quelli negli stati 0|1. 

     Se lo scenario è questo :

     * stack dati non vuoto 
     * primo TAG buono in stato 0
     * buffer non vuoto

     il parse verifica se al TAG è assegnato un nome, se non è assegnato la parte di buffer viene considerata 
     come nome del TAG, ed il parse si avvia a chiudere positivamente attaccando al tag il token di chiusura.
     
     <*Unknown* tag> ==> < tag>

     Nessun analisi al momento viene fatta sul contenuto di tale buffer, quindi casi di nomi non validi
     non vengono presi in considerazione al momento.

     INVECE, se il TAG ha già un nome il parse deve verificare cos'è quel token e quindi va ad analizzare la situazione 
     variabili nella speranza di trovare una variabile (l'ultima inserita) in attesa del value, altre
     scenari son considerati errori. I scenari possibili per il parse son questi :

     *1* <<<ERRORE-1>>> mancanza di variabili o ultima variabile completamente definita (stato_last_variabile = 0)
     *2* <<<ERRORE-2>>> ultima variabile in attesa di assign (stato_last_variabile = 1)
     *3* <<<OK>>> ultima variabile in attesa di value (stato_last_variabile = 2)

     Nel primo caso il parse segnata il problema con il codice di errore che stiamo analizzando. Seguono esempi :


     >>>> esempio 1. Ok.

     <?xml version = "1.0" ?>
     < tag> </tag>
     
     jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML test75A.xml 

     [DEBUG] [         XMLIni] | [                                                                              <?]
     [DEBUG] [            XML] | [                                                                             xml]
     [DEBUG] [       Separate] | [                                                                                ]
     [DEBUG] [       Variable] | [                                                                         version]
     [DEBUG] [       Separate] | [                                                                                ]
     [DEBUG] [         Assign] | [                                                                               =]
     [DEBUG] [          Value] | [                                                                           "1.0"]
     [DEBUG] [       Separate] | [                                                                                ]
     [DEBUG] [         XMLEnd] | [                                                                              ?>]
     [DEBUG] [     TagIniOpen] | [                                                                               <]
     [DEBUG] [       Separate] | [                                                                                ]
     [DEBUG] [         TagIni] | [                                                                             tag]
     [DEBUG] [    TagIniClose] | [                                                                               >]
     [DEBUG] [    TagIniClose] | [                                                                               >]
     [DEBUG] [     TagEndOpen] | [                                                                              </]
     [DEBUG] [         TagEnd] | [                                                                             tag]
     [DEBUG] [    TagEndClose] | [                                                                               >]

     ================================ ============ ============ ============
                                                                      Numero
                                  Tag        Level        Stato    Variabili
     -------------------------------- ------------ ------------ ------------
     [                           xml] [         0] [         3] [         1]
     [version] = ["1.0"]


     ================================ ============ ============ ============
                                                                      Numero
                                  Tag        Level        Stato    Variabili
     -------------------------------- ------------ ------------ ------------
     [                           tag] [         0] [         3] [         0]

     
     >>>> esempio 2. 

     <?xml version = "1.0" ?>
     <tag *Unknown*>

     jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML test75B.xml 
     Error -75: [test75B.xml:2] delimiter close but missing assign var [tag]


     >>>> esempio 3. 

     <?xml version = "1.0" ?>
     <tag var = 0 *Unknown*>

     jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML test75C.xml 
     Error -75: [test75C.xml:2] delimiter close but missing assign var [tag]



====================================================================================================================
[76] delimiter close but missing value var [%s]

     Un token di chiusura di un TAG DATI di TESTA|CODA vive nell'albero dati e non nelle intestazioni XML del documento.
     Le intestazioni XML devo stare in TESTA al documento quindi prima dell'albero DATI. Questo significa che 
     prima di tutto il parse deve verificare che l'area intestazione sia chiusa che vuol dire che ci deve essere almeno 
     un TAG nello stack XML e che l'ultimo TAG sia consolidato|chiuso. Se questa prima verifica è superata allora il
     parse verifica se ci si trovi nell'albero, quindi se questo è aperto, se c'è quindi almeno un TAG registrato nello
     stack che definisce l'albero DATI. Se l'albero risulta definito (quindi se esiste almeno un TAG nel corrispondente
     stack) il parse verifica che l'albero non sia completamente definito. Questo verifica la fa controllando che lo stato
     del TAG radice non stia a "3", chiuso. Se la radice è chiusa l'albero è completamente definito e quindi non
     c'è porto per nullaltro. In XML si può definire al massimo un unico albero dati. Nel nostro caso l'albero 
     non è completamente chiuso, quindi aperto, il token è posizionato al suo interno. Il parse a questo punto deve cercare
     il TAG aperto a cui associare il token di chiusura trovato. Legge allora a ritroso lo stack (dall'inserimento più
     recente a quello meno recente) sicuro di trovarne uno ancora aperto (perchè lo stack non risulta chiuso).
     Il token di chiusura è il medesimo sia per TAG di TESTA sia per TAG di coda è quindi si ferma al primo TAG 
     che trova in uno di questi dei stati (stato 0|2). Inoltre si ferma anche se trova un TAG in stato 1 se il buffer 
     non è ancora vuoto, come detto in precedenza (perchè la situazione aggiornata potrebbe rilevare un nuovo TAG
     nel buffer in stato 0. Se il buffer è vuoto i TAG validi rimandono quelli negli stati 0|1. 

     Se lo scenario è questo :

     * stack dati non vuoto 
     * primo TAG buono in stato 0
     * buffer non vuoto

     il parse verifica se al TAG è assegnato un nome, se non è assegnato la parte di buffer viene considerata 
     come nome del TAG, ed il parse si avvia a chiudere positivamente attaccando al tag il token di chiusura.
     
     <*Unknown* tag> ==> < tag>

     Nessun analisi al momento viene fatta sul contenuto di tale buffer, quindi casi di nomi non validi
     non vengono presi in considerazione al momento.

     INVECE, se il TAG ha già un nome il parse deve verificare cos'è quel token e quindi va ad analizzare la situazione 
     variabili nella speranza di trovare una variabile (l'ultima inserita) in attesa del value, altre
     scenari son considerati errori. I scenari possibili per il parse son questi :

     *1* <<<ERRORE-1>>> mancanza di variabili o ultima variabile completamente definita (stato_last_variabile = 0)
     *2* <<<ERRORE-2>>> ultima variabile in attesa di assign (stato_last_variabile = 1)
     *3* <<<OK>>> ultima variabile in attesa di value (stato_last_variabile = 2)

     Nel secondo caso il parse segnata il problema con il codice di errore che stiamo analizzando. Seguono esempi :


     >>>> esempio 1. 

     <?xml version = "1.0" ?>
     <tag var *Unknown*>

     jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML test76A.xml 
     Error -76: [test76A.xml:2] delimiter close but missing value var [tag]


     >>>> esempio 2. 

     <?xml version = "1.0" ?>
     <tag var = 0 var2 *Unknown*>

     jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML test76B.xml 
     Error -76: [test76B.xml:2] delimiter close but missing value var [tag]



====================================================================================================================
[77] Found delimiter close but no TAG open.

     Un token di chiusura di un TAG DATI di TESTA|CODA vive nell'albero dati e non nelle intestazioni XML del documento.
     Le intestazioni XML devo stare in TESTA al documento quindi prima dell'albero DATI. Questo significa che 
     prima di tutto il parse deve verificare che l'area intestazione sia chiusa che vuol dire che ci deve essere almeno 
     un TAG nello stack XML e che l'ultimo TAG sia consolidato|chiuso. Se questa prima verifica è superata allora il
     parse verifica se ci si trovi nell'albero, quindi se questo è aperto, se c'è quindi almeno un TAG registrato nello
     stack che definisce l'albero DATI. Se l'albero risulta definito (quindi se esiste almeno un TAG nel corrispondente
     stack) il parse verifica che l'albero non sia completamente definito. Questo verifica la fa controllando che lo stato
     del TAG radice non stia a "3", chiuso. Se la radice è chiusa l'albero è completamente definito e quindi non
     c'è porto per nullaltro. In XML si può definire al massimo un unico albero dati. Nel nostro caso l'albero 
     non è completamente chiuso, quindi aperto, il token è posizionato al suo interno. Il parse a questo punto deve cercare
     il TAG aperto a cui associare il token di chiusura trovato. Legge allora a ritroso lo stack (dall'inserimento più
     recente a quello meno recente) sicuro di trovarne uno ancora aperto (perchè lo stack non risulta chiuso).
     Il token di chiusura è il medesimo sia per TAG di TESTA sia per TAG di coda è quindi si ferma al primo TAG 
     che trova in uno di questi dei stati (stato 0|2). Inoltre si ferma anche se trova un TAG in stato 1 se il buffer 
     non è ancora vuoto, come detto in precedenza (perchè la situazione aggiornata potrebbe rilevare un nuovo TAG
     nel buffer in stato 0. Se il buffer è vuoto i TAG validi rimandono quelli negli stati 0|1. 

     Se lo scenario è questo :

     * stack dati vuoto | primo TAG buono in stato 1
     * buffer non vuoto

     es. 

     [1] <?xml version = "1.0" ?>  // stack utente empty.
     [2] <?xml version = "1.0" ?>  // trovato tag con stato 1
         <tag> ...

     il parse si aspetta di trovare a questo punto un'intero TAG di TESTA nel buffer per poter continuare a considerare
     valido il file XML analizzato.

     es. 

     [1] <?xml version = "1.0" ?>  buffer = <tag>
     [2] <?xml version = "1.0" ?>  buffer = <tag-figlio>
         <tag> ...
     
     viene quindi analizzato il buffer alla ricesca di :

     * "<" un delimitatore in testa
     * "nometag" successivo al delimitatore
     * ">" un delimitatore in coda chiaramente che già c'è essendo questo il token che ha terminato la bufferizzazione...

     i test effettuati dal parsen per verificare sono i seguenti :

     [TEST1] che ci sia almeno un delimitatore di apertura (<) - count(*) > 0
     

     Nel caso in cui vada male TEST1, cioè che non ci sia nessun delimitatore di apertura il parse si ferma 
     restituendo questo codice di errore.







====================================================================================================================
[78] unknown token on left the XML delimiter


====================================================================================================================
[79] found more tag delimiter


====================================================================================================================
[80] not found close delimiter for tag






***********************************************************
BUG PRECEDENTI LEGATI AL TOKEN ANALIZZATO
***********************************************************


**********************************************************************
CODICEEEEEEEEEEEEEE
**********************************************************************

              /*
              .-------------------------------------------------------------------------------------.
              |                                                                                     |
              |                                                                                     |
              |                                                                                     |
              |                                     __TAG_END__                                     |
              |                                                                                     |
              |                                                                                     |
              |                                                                                     |
              |                                                                                     |
              '-------------------------------------------------------------------------------------' */
              if ( search(buffer,__TAG_END__) == __TRUE__ && remark == __OFF__ && foundToken == __FALSE__ ) 
              {

                   /*
                   .-----------------------------------------------------------------------------------.
                   | Err 1. Area INTESTAZIONI XML non presente - Stack XML vuoto.                      |
                   .-----------------------------------------------------------------------------------.
                   | Un token di CHIUSURA presuppone che [1] ci sia un TAG aperto [2] che il nometag   |
                   | sia assegnato e [3] che ci sia nello stack una situazione consolidata per le      |
                   | variabili... (nessuna o completamente definite - stato 2). Fatta questa premessa  |
                   | Il primo TEST da implementare è sulla presenta del TAG di TESTA aperto.           |
                   | Prima di questo è necessario verificare che lo stack XML sia consolidato cioè se  |
                   | ci troviamo nell'area dati dell'XML. Se lo stack XML è assente o non ancora       |
                   | concluso è un errore perchè il token analizzato come detto chiude i TAG dati.     |
                   | Quello successivo è il TEST per verificare che nello stack XML ci sia qualcosa.   |
                   | E' inutile prima processare un'eventuale buffer pieno perchè anche se fosse       |
                   | sicuramente non riuscirebbe da solo a sanare un'eventuale mancanza riscontrata    |
                   | nell'attuale stack.                                                               |
                   '-----------------------------------------------------------------------------------' */
                   if (rPharse.iTabTagXML == 0) {  
                       rPharse.row_error = countRowXMLFile + 1;
                       rPharse.token_unknown = malloc(strlen("\0")); 
                       strcpy(rPharse.token_unknown,"\0");
                       rPharse.return_code = -69;
                       return rPharse; 
                   }

                   /*
                   .----------------------------------------------------------------------------.
                   | Err 2. Area INTESTAZIONI XML non conclusa                                  |
                   .----------------------------------------------------------------------------.
                   | Se lo stack XML non è vuoto è necessario (per continuare) che l'ultimo TAG |
                   | inserito sia CHIUSO che quindi la sezione intestazione sia consolidata.    |
                   | Come detto in precedenza il token analizzato può trovarsi solo nella       |
                   | sezione dati. Il buffer non viene verificato se è pieno o meno, perchè     |
                   | anche se fosse pieno di qualcosa non riuscirebbe a sanare completamente    |
                   | un'eventuale mancanza riscontrata.                                         |
                   '----------------------------------------------------------------------------' */
                   if (rPharse.rTabTagXML[rPharse.iTabTagXML-1].stato != 3)
                   {
                       rPharse.row_error = countRowXMLFile + 1;
                       rPharse.token_unknown = malloc(strlen("\0")); 
                       strcpy(rPharse.token_unknown,"\0");
                       rPharse.return_code = -70;
                       return rPharse;
                   };

                   /*
                   .-----------------------------------------------------------.
                   | Isolamento della stringa alla sinistra del __TAG_END__    |
                   '-----------------------------------------------------------' */
                   i = i - strlen(__TAG_END__);
                   buffer[i] = __NULL__;

                   /*
                   .----------------------------------------------------------------------------.
                   | Err 3. Missing Area DATI                                                   |
                   .----------------------------------------------------------------------------.
                   | Un delimitatore di chiusura presuppone un TAG aperto. Se lo stack è vuoto  |
                   | quindi se non ci sono TAG precedentemente analizzati ed il buffer da       |
                   | analizzare è vuoto (quindi si tratta di una situazione aggiornata)         |
                   | manca un tag aperto pronto a ricevere la chiusura e pertanto il parsen     |
                   | si ferma con questo errore.                                                |
                   '----------------------------------------------------------------------------' */
                   if (rPharse.iTabTag == 0 && i == 0) {
                       rPharse.row_error = countRowXMLFile + 1;
                       rPharse.token_unknown = malloc(strlen("\0")); 
                       strcpy(rPharse.token_unknown,"\0");
                       rPharse.return_code = -35;
                       return rPharse; };

                   /*
                   .---------------------------------------------------------------------.
                   | Se L'albero TAG dati è pieno e aperto i successivi due blocchi di   |
                   | codici verificano che [1] l'albero non sia chiuso, cioè che il      |
                   | primo TAG (radice) non sia in stato 3 (completamente definito) e    |
                   | [2] verificato che sia aperto l'albero il parse si posiziona sul    |
                   | primo TAG (leggendo a ritroso in stato 0, 1 o 2. Questo per poter   |
                   | identificare quale TAG il parse si aspetta.                         |
                   '---------------------------------------------------------------------' */ 
                   if ( rPharse.iTabTag > 0 ) 
                   {

                        /*
                        .----------------------------------------------------------------------------.
                        | Err 4. Close Area DATI                                                     |
                        .----------------------------------------------------------------------------.
                        | Medesimo discorso fatto in precedenza. Se lo stack è pieno ma il nodo      |
                        | radice è consolidato (chiuso, stato a 3) significa che nessun stack        |
                        | risulta aperto (stato 0, stato 2), anzi per dirla ancora meglio che        |
                        | l'intero albero|documento è consolidato e non c'è spazio per nulla altro   |
                        | Il parse quindi si ferma con un errore.                                    |
                        |                                                                            |
                        | ### forse questo TEST bisognerebbe inserirlo in tutte le sezioni come      |
                        | primo dopo le verifiche del caso sullo STACK XML ######################### |
                        '----------------------------------------------------------------------------' */
                        if ( rPharse.rTabTag[0].stato == 3 ) {
                             rPharse.row_error = countRowXMLFile + 1;
                             rPharse.token_unknown = malloc(strlen("\0"));
                             strcpy(rPharse.token_unknown,"\0");
                             rPharse.return_code = -36;
                             return rPharse; };
                   };

                   /*
                   .----------------------------------------------------------------------------.
                   |                                                                            |
                   | Ok se siamo arrivati a questo punto significa che :                        |
                   |                                                                            |
                   | [a] le intestazioni XML son tutte chiuse.                                  |
                   |                                                                            |
                   | [b] E' vera una delle due condizioni :                                     |
                   |                                                                            |
                   |     [b.1] l'albero dati è completamente vuoto ma il buffer è pieno quindi  |
                   |           potrebbe essere che nel buffer è contenuto l'intero TAG di TESTA |
                   |                                                                            |
                   |     [b.2] l'albero dati è pieno e non chiuso.                              |
                   |           Il parse si appresta ad entrarci dentro... uhaaa uhaaa           |
                   |                                                                            |
                   |  A questo punto il parsen legge a ritroso lo stack alla ricerca del primo  |
                   |  TAG in attesa di un delimitatore di chiusura, quindi in stato 0 o stato 2 |
                   |  Se lungo il traggitto incontra un TAG con stato a 1 (testa completa)      |
                   |  termina comunque la ricerca perchè anche questo per il momento è          |
                   |  compatibile (il buffer potrebbe contenere ciò che manca per ottenere un   |
                   |  nuovo tag successivo in STATO 0). Nel caso di albero assente l'indice j   |
                   |  (posizione dell'elemento nello stack) rimane a 0.                         |
                   |                                                                            |
                   '----------------------------------------------------------------------------' */
                   j = rPharse.iTabTag;

                   while ( j > 0 && rPharse.rTabTag[j-1].stato != 0 
                                 && rPharse.rTabTag[j-1].stato != 1 
                                 && rPharse.rTabTag[j-1].stato != 2 )
                                 j--;

                   /*
                   .---------------------------------------------------------------------------.
                   | Individuato il primo TAG (leggendo l'albero a ritroso come si è detto) in |
                   | STATO 0|1|2 vengono effettuati su di esso dei controlli per verificare    |
                   | nel dettaglio la compatibilità con il token di chiusura TAG TESTA|CODA    |
                   | trovato e di cui si sta verificando la correttezza. In particolare si     |
                   | verifica di tale TAG trovato nel caso in cui il buffer è vuoto (quindi    |
                   | nel caso in cui la situazione è aggiornata) la consistenza, cioè se il    |
                   | è in attesa, può ricevere il delimitatore di chiusura. Chiaramente i TEST |
                   | sono possibili solemente se è stato trovato un TAG, quindi se lo stack è  |
                   | pieno altrimenti il blocco di TEST viene saltato. In ogni caso se non     |
                   | esiste buffer da processare lo stack è sempre pieno altrimenti il parse   |
                   | sarebbe uscito ad uno dei test fatti in precedenza.                       |
                   '---------------------------------------------------------------------------' */ 
                   if ( rPharse.iTabTag > 0 ) 
                   {
                        if ( i == 0 ) 
                        {
                             /*
                             .----------------------------------------------------------------------------.
                             | Err 5. Found delimiter close but there isnt a TAG open.                    |
                             .----------------------------------------------------------------------------.
                             | Se il primo TAG trovato è in STATO 1 quindi TESTA CHIUSO (es. <tag>) è     |
                             | necessario che il buffer sia pieno per poter ancora sperare che il tutto   |
                             | sia corretto perchè nel buffer potrebbe esserci un intero TAG figlio       |
                             | ancora non processato che validerebbe il token trovato (>) che il token    |
                             | sta in questo momento analizzando.(es. token:<tagpadre> buffer:<tagfiglio>)|
                             | Se però è stato trovato un TAG in STATO 1 ed il BUFFER è vuoto questo è    |
                             | prova certa che esiste un errore del tipo: chiusura di TAG inesistente,    |
                             | cioè mai aperto. (es. <tag> >, <tagpadre><tagfiglio/>>)                    |
                             '----------------------------------------------------------------------------' */
                             if ( rPharse.rTabTag[j-1].stato == 1 ) { 
                                  rPharse.row_error = countRowXMLFile + 1;
                                  rPharse.token_unknown = malloc(strlen("\0"));
                                  strcpy(rPharse.token_unknown,"\0");
                                  rPharse.return_code = -71;
                                  return rPharse; };

                             /*
                             .----------------------------------------------------------------------------.
                             | Err 6. The TAG havent name (es. <*Unknown* >)                              |
                             .----------------------------------------------------------------------------.
                             | Il TAG trovato non ha un nome quindi non può essere chiuso. Come detto non | 
                             | c'è nulla nel buffer quindi la situazione è aggiornata con un delimitatore |
                             | di chiusura trovato da validare e da registrare. Chiaramente se è così lo  |
                             | stato del TAG è ZERO condizione omessa perchè ovvia.                       | 
                             '----------------------------------------------------------------------------' */
                             if ( strcmp(rPharse.rTabTag[j-1].tag,"*Unknown*") == 0 ) {
                                  rPharse.row_error = countRowXMLFile + 1;
                                  rPharse.token_unknown = malloc(strlen("\0"));
                                  strcpy(rPharse.token_unknown,"\0");
                                  rPharse.return_code = -72;
                                  return rPharse; };

                             /*
                             .----------------------------------------------------------------------------.
                             | Err 7. the last variable missing token assign (es. <tag var >)             |
                             .----------------------------------------------------------------------------.
                             | Il TAG trovato non ha una situazione variabili consolidata. Come detto non |
                             | c'è nulla nel buffer quindi la situazione è aggiornata con u delimitatore  |
                             | di chiusura trovato da validare e da registrare. In particolare l'ultima   |
                             | variabile trovata nello stack è attesa di assign e value.                  |
                             '----------------------------------------------------------------------------' */
                             if ( rPharse.rTabTag[j-1].stato_last_variable == 1 ) { 
                                  rPharse.row_error = countRowXMLFile + 1;
                                  rPharse.token_unknown = malloc(strlen(rPharse.rTabTag[j-1].tag));
                                  strcpy(rPharse.token_unknown,rPharse.rTabTag[j-1].tag);
                                  rPharse.return_code = -73;
                                  return rPharse; };

                             /*
                             .----------------------------------------------------------------------------.
                             | Err 8. the last variable missing token assign (es. <tag var >)             |
                             .----------------------------------------------------------------------------.
                             | Il TAG trovato non ha una situazione variabili consolidata. Come detto non |
                             | c'è nulla nel buffer quindi la situazione è aggiornata con u delimitatore  |
                             | di chiusura trovato da validare e da registrare. In particolare l'ultima   |
                             | variabile trovata nello stack è attesa di assign e value.                  |
                             '----------------------------------------------------------------------------' */
                             if ( rPharse.rTabTag[j-1].stato_last_variable == 2 ) { 
                                  rPharse.row_error = countRowXMLFile + 1;
                                  rPharse.token_unknown = malloc(strlen(rPharse.rTabTag[j-1].tag));
                                  strcpy(rPharse.token_unknown,rPharse.rTabTag[j-1].tag);
                                  rPharse.return_code = -74;
                                  return rPharse; };
                        };
                   };

                   /*
                   .---------------------------------------------------------------------------.
                   | E' necessario a questo punto aggiornare lo stack dati XML e per farlo     |
                   | bisogna analizzare il buffer, se questo risulta pieno. E' pieno se alla   |
                   | sinistra del token che stiamo in questo momento analizzando.              |
                   | Il test successivo serve appunto a capire se esiste qualcosa nel buffer.  |
                   | La variabile "i" contiene la lunghezza della stringa alla sinistra del    |
                   | di tale token, quindi del buffer stesso.                                  |
                   '---------------------------------------------------------------------------' */
                   if ( i > 0 )
                   {

                        /*
                        .------------------------------------------------------------------------------.
                        | Il buffer è pieno perchè la sia lunghezza è maggiore di ZERO. Il parse       |
                        | il TAG su cui si è fermato in precedenza per capire se nel buffer è presente |
                        | realmente la parte mancante che ancora serve prima di poter registrare il    |
                        | token di chiusura. Il parsen considera tutte le casistiche in cui il TAG     |
                        | potrebbe trovarsi, partendo dal suo stato che come detto a questo punto      |
                        | dell'analisi potrebbe trovarsi in stato 0,1 e 2 (aperto tag di testa, chiuso |
                        | tag di testa, aperto tag di coda).                                           |
                        '------------------------------------------------------------------------------' */

                        /*
                        .------------------------------------------------------------------------------.
                        |                                 TAG TESTA APERTO                             |
                        .------------------------------------------------------------------------------.
                        | Si sta considerando solamente la casistica in cui l'albero XML dati risulta  |
                        | pieno di almeno un TAG altrimenti il successivo blocco non è applicabile.    |
                        | Il TAG su cui il parse si è fermato è un TAG di TESTA aperto. Il parsen      |
                        | verifica il suo stato di consolidamente seguendo la sintassi prevista:       |
                        | [1] assegnazione del nome [2] stato variabili. Il parse si aspetta di        |
                        | trovare un TAG senza nome perchè in quel caso il contenuto del buffer viene  |
                        | considerato tale, oppure che ci siano variabili nello stack per quel tag e   |
                        | che l'ultimo sia in attesa di valore perchè in quel caso viene considerato   |
                        | tale il contenuto del buffer. In tutti gli altri casi il parse come si vedrà |
                        | li considererà errori perchè queste sono gli unici due scenari in cui manca  |
                        | per raggiungere la consistena un'unico token.                                |
                        '------------------------------------------------------------------------------' */
                        if ( rPharse.iTabTag > 0 ) {
                        if ( rPharse.rTabTag[j-1].stato == 0 )
                        {
                             /* 
                             .---------------------------------------------------------------------------.
                             | Se il TAG trovato è in STATO 0 quindi di TESTA e APERTO il parse verifica |
                             | che il nome sia stato assegnato. Se non risulta assegnato il parse        |
                             | deduce che nel buffer ci sia proprio il nome del TAG e quindi lo assegna. |
                             | E' stata raggiunta la consistena tale per poterlo chiudere.               |
                             '---------------------------------------------------------------------------' */
                             if ( strcmp(rPharse.rTabTag[j-1].tag,"*Unknown*") != 0 ) 
                             { 
                                  /*
                                  .----------------------------------------------.
                                  |  Classificazione e valorizzazione del Token  |
                                  '----------------------------------------------' */
                                  token[foundToken].type = malloc(strlen("TagIni\0"));
                                  strcpy(token[foundToken].type, "TagIni\0");
                                  token[foundToken].value = malloc(strlen(buffer));
                                  strcpy(token[foundToken].value , buffer);
                                  foundToken++;

                                  /*
                                  .----------------------------------------------.
                                  |           Aggiornamento nome TAG             |
                                  '----------------------------------------------' */
                                  rPharse.rTabTag[j-1].tag = malloc(strlen(buffer));
                                  strcpy(rPharse.rTabTag[j-1].tag, buffer);
                             }
                             else
                             {   
                                  /*
                                  .---------------------------------------------------------------------------.
                                  | Se il TAG trovato è in STATO 0 quindi di TESTA e APERTO. Il nome come     |
                                  | visto è stato assegnato. Il parse passa a verificare come detto in        |
                                  | lo stato delle variabili nella speranza di trovarne almeno una e che      |
                                  | l'ultima sia attesa di un valore. Il parse considera il contenuto del     |
                                  | buffer come valore. Anche in questo caso si raggiunge così per il tag     |
                                  | un punto di consistenza necessario per poterlo chiudere. In tutti gli     |
                                  | casi (nessuna variabile, ultima variabile in attesa di assign) è un       |
                                  | errore perchè in questi casi il contenuto del buffer in nessun caso       |
                                  | riuscirebbe a sanare le mancanze riscontrate.                             |
                                  '---------------------------------------------------------------------------' */
                                  switch ( rPharse.rTabTag[j-1].stato_last_variable )
                                  {                                 

                                           case 0: 

                                                   /*
                                                   .--------------------------------------------------------------.
                                                   | Err 9. CASO 1: Value (es. <tag UnknownToken>                 |
                                                   .--------------------------------------------------------------.
                                                   | Il parse si aspettava la value per l'ultima variabile        |
                                                   | presente nello stack, però questa non ha bisogno del valore  |
                                                   | perchè risulta già completa (var=value) e quindi il parse si |
                                                   | ferma e segnala l'errore. Oppure non sono presenti variabili |
                                                   |                                                              |
                                                   '--------------------------------------------------------------' */
                                                   rPharse.row_error = countRowXMLFile + 1;
                                                   rPharse.token_unknown = malloc(strlen(rPharse.rTabTag[j-1].tag));
                                                   strcpy(rPharse.token_unknown,rPharse.rTabTag[j-1].tag);
                                                   rPharse.return_code = -75;
                                                   return rPharse;
                                                   break;

                                           case 1:
 
                                                   /*
                                                   .--------------------------------------------------------------.
                                                   | Err 10. CASO 2: Value (es. <tag var UnknownToken/>)          |
                                                   .--------------------------------------------------------------.
                                                   | Il parse si aspettava la value per l'ultima variabile        |
                                                   | presente nello stack, però questa non ha bisogno del valore  |
                                                   | ma dell'assign (var) e quindi il parse si ferma e segnala    |
                                                   | l'errore.                                                    |
                                                   |                                                              |
                                                   '--------------------------------------------------------------' */
                                                   rPharse.row_error = countRowXMLFile + 1;
                                                   rPharse.token_unknown = malloc(strlen(rPharse.rTabTag[j-1].tag));
                                                   strcpy(rPharse.token_unknown,rPharse.rTabTag[j-1].tag);
                                                   rPharse.return_code = -76;
                                                   return rPharse;
                                                   break;

                                           case 2:
 
                                                   /*
                                                   .--------------------------------------------------------------.
                                                   | CASO 3: Value (es. <tag var = [value]>)                      |
                                                   .--------------------------------------------------------------.
                                                   | Il parse si aspetta la value per l'ultima variabile          |
                                                   | presente nello stack e realmente trova un ultima variabile   |
                                                   | in attesa di esso. Quindi assegna il value e cambia lo stato |
                                                   | della variabile nuovamente a zero.                           |
                                                   |                                                              |
                                                   '--------------------------------------------------------------' */

                                                   /*
                                                   .--------------------------------------------------------.
                                                   | Identificato e classificato la tipologia del token     |
                                                   '--------------------------------------------------------' */
                                                   token[foundToken].type  = malloc(strlen("Value\0"));
                                                   strcpy(token[foundToken].type  , "Value\0");
                                                   token[foundToken].value = malloc(strlen(buffer));
                                                   strcpy(token[foundToken].value , buffer);
                                                   foundToken++;

                                                   /*
                                                   .-------------------------------------------------------.
                                                   | Imposta il valore relativo alla variabile nello stack |
                                                   '-------------------------------------------------------' */
                                                   int istack = j-1 ;
                                                   int istackVar = rPharse.rTabTag[istack].dimTabVar ;
                                                   rPharse.rTabTag[istack].rTabVar[istackVar].value = malloc(strlen(buffer));
                                                   strcpy(rPharse.rTabTag[istack].rTabVar[istackVar].value,buffer);
                                                   rPharse.rTabTag[istack].dimTabVar++;

                                                   /*
                                                   .-------------------------------------------------------.
                                                   | Imposta l'ultimo stato variabili a zero (consolidato) |
                                                   '-------------------------------------------------------' */
                                                   rPharse.rTabTag[istack].stato_last_variable = 0 ;
                                                   break;
                                  };
                             };

                        }};


                        /*
                        .------------------------------------------------------------------------------.
                        |                                TAG TESTA CHIUSO                              |
                        .------------------------------------------------------------------------------.
                        |                                                                              |
                        |  Se il primo TAG valido ha stato ad 1 (TAG di TESTA chiuso) oppure l'albero  |
                        |  nello STACK è completamente assente. Il entrambi i casi il parse come       |
                        |  tentativo per considerare valido l'XML verifica il contenuto del BUFFER     |
                        |  nel tentativo di trovare non ancora processato un intero TAG di TESTA.      |
                        |  (es. <tag-1><tag-2> con <tag-2> ancora nel buffer. oppure <tag-1> con       |
                        |  <tag-1> ancora nel buffer). Uso un flag (?) son costretto ad usarlo perchè  | 
                        |  test del tipo "rPharse.rTabTag[j-1].stato == 1 || rPharse.iTabTag == 0 mi   |
                        |  potrebbero creare problemi nel caso in cui lo stack è vuoto, in quel caso j |
                        |  vale 0 e quindi j-1 equivale a dire -1.                                     |
                        '------------------------------------------------------------------------------' */
                        int fHeadClose = 0;
                        if ( rPharse.iTabTag > 0 )    
                             if ( rPharse.rTabTag[j-1].stato == 1 )
                                  fHeadClose = 1 ;

                        if ( rPharse.iTabTag == 0 )    
                             fHeadClose = 1 ;

                        if ( fHeadClose == 1 )
                        {
                             /*
                             .--------------------------------------------------------------.
                             | Alla sinistra del token >  ci  può essere un delimitatore    |
                             | iniziale di TAG con il nome del TAG  stesso  (es. "<tag". In |
                             | questo  caso  per  riconoscerlo   è  necessario  cercare  il |
                             | __TAG_INI_OPEN__ (<) nella stringa. Viene ricercato in tutta |
                             | la sottostringa senza considerare  una  specifica  posizione |
                             | questo perchè alla sinistra  del  delimitatore  ci  potrebbe |
                             | essere qualcos'altro (es. "unknown<tag". Se questo avviene è |
                             | un errore ed il parse si ferma  perchè  alla  sinistra  di   |
                             | tale delimitatore (<) non ci può essere nulla  che  non  sia |
                             | stato classificato in precedenza come token.   Nel  caso  di |      
                             | eccezione: "<<tag" sarebbe un errore  andare  avanti  quindi |
                             | bisogna accertarsi che di delimitatori non ce ne sia piu' di |
                             | uno. Nel caso in cui invece mancasse il delimitatore di      |
                             | apertura del tag è un errore perchè in questo caso il parse  |
                             | necessita di trovare nel buffer un TAG di TESTA completo.    |
                             '--------------------------------------------------------------' */

                             /*
                             .--------------------------------------------------------------.
                             | Err 11. Not found TAG left delimiter                         |
                             .--------------------------------------------------------------.
                             | Non è stato trovato nessun delimitatore  di apertura del TAG |
                             | quindi nel buffer non può essere contenuto nessun TAG di     |
                             | TESTA completo e quindi il parse si ferma perchè cercava     |
                             | proprio questo.                                              |
                             '--------------------------------------------------------------' */
		             if ( search(buffer,__TAG_INI_OPEN__) == __ZERO__ ) 
                             {
                                  rPharse.row_error = countRowXMLFile + 1;
                                  rPharse.token_unknown = malloc(strlen(buffer));
                                  strcpy(rPharse.token_unknown,buffer);
                                  rPharse.token_unknown[i] = __NULL__ ;
                                  rPharse.return_code = -77;
                                  return rPharse;    
                             }
                             else
                             {
                                  /*
                                  .---------------------------------------------------------.
                                  | Err 12. *UnknownToken* found left TAG                   |
                                  .---------------------------------------------------------.
                                  | Il delimitatore di apertura tag (<) è stato trovato si, |
                                  | ma non in prima posizione (es. "unknown<tag ") quindi   |
                                  | il parsen esce con un errore perchè alla sinistra del   |
                                  | delimitatore non è previsto nulla. Qualunque            |
                                  | delimitatore di chiusura precedente sarebbe stato       |
                                  | individuato precedentemente.                            |
                                  '---------------------------------------------------------' */ 
                                  i = 0;
                                  while ( i < strlen(buffer) && buffer[i] != __TAG_INI_OPEN2__ ) i++;
                                  if ( i > 0 ) {
                                       rPharse.row_error = countRowXMLFile + 1;
                                       rPharse.token_unknown = malloc(strlen(buffer));
                                       strcpy(rPharse.token_unknown,buffer);
                                       rPharse.token_unknown[i] = __NULL__ ;
                                       rPharse.return_code = -78;
                                       return rPharse; };   

                                  /*
                                  .-------------------------------------------------------------.
                                  | trovato il delimitatore di apertura tag in prima posizione  |
                                  | ma trovato anche almeno un'altro medesimo delimitatore      |
                                  | (es. "<tag<tag ") Questo significa per il parsen che il     |
                                  | tag precedente (lo considera un tag il token tra i due      |
                                  | delimitatori di apertura) non è stato chiuso e quindi esce  |
                                  | per errore.                                                 |
                                  '-------------------------------------------------------------' */
                                  if ( search(buffer,__TAG_INI_OPEN__) > __ONE__ ) 
                                  {
                                       /*
                                       .-----------------------------------------------------------------.
                                       | Questo TEST serve solo per differenziare il messaggio di errore |
                                       | per una maggiore comprensione: se nelle prime due posizioni     |
                                       | trova il delimitatore "es. <<tag" non si può parlare di         |
                                       | delimitatore di chiusura del tag non trovato bensi di un        |
                                       | delimitatore inserito più di una volta ad esempio per una       |
                                       | distrazione. Mentre nel caso in cui tra i due delimitatori ci   |
                                       | sia qualcosa di diverso "<tag<" in questo caso l'errore         |
                                       | potrebbe essere interpretato come di un delimitatore di         |
                                       | chiusura non trovato.                                           |
                                       '-----------------------------------------------------------------' */
                                       if (buffer[0]==__TAG_INI_OPEN2__ && buffer[1]==__TAG_INI_OPEN2__) 
                                       { 
                                           /*
                                           .---------------------------------------.
                                           | Err 13. duplicate delimiter left TAG  |
                                           '---------------------------------------' */
                                           rPharse.row_error = countRowXMLFile + 1;
                                           rPharse.token_unknown = malloc(3);
                                           rPharse.token_unknown[0]=buffer[0];
                                           rPharse.token_unknown[1]=buffer[1];
                                           rPharse.token_unknown[2]=__NULL__;
                                           rPharse.return_code = -79;
                                           return rPharse; 
                                       }
                                       else
                                       {
                                           /*
                                           .-----------------------------------------------.
                                           | Err 14. found two or more delimiter left TAG  |
                                           '-----------------------------------------------' */
                                           rPharse.token_unknown = malloc(strlen(buffer));
                                           i=1; 
                                           while (i<strlen(buffer) && buffer[i]!=__TAG_INI_OPEN2__) {
                                                  rPharse.token_unknown[i-1] = buffer[i];
                                                  i++; };
                                           rPharse.token_unknown[i-1]=__NULL__; 
                                           rPharse.return_code = -80;
                                           return rPharse;                                      
                                       }; 
                                  };

                                  /*
                                  .-----------------------------------------------------------------.
                                  |                                                                 |
                                  |                                                                 |
                                  |                   Inserimento di un nuovo TAG                   |
                                  |                                                                 |
                                  |                                                                 | 
                                  '-----------------------------------------------------------------' */
                                  rPharse.rTabTag[rPharse.iTabTag].tag = malloc(strlen("*Unknown*"));
                                  strcpy(rPharse.rTabTag[rPharse.iTabTag].tag, "*Unknown*");
                                  rPharse.rTabTag[rPharse.iTabTag].stato = 0;

                                  /*
                                  .-----------------------------------------------------------------.
                                  | Ricava il livello : [1] se lo stack è vuoto si tratta di primo  |
                                  | tag quindi il livello è 0 perchè si è in presenza della radice  |
                                  | [2] se lo stack non è vuoto si incrementa di 1 il livello del   |
                                  | tag trovato in stato 1 che è considerato suo padre.             |
                                  '-----------------------------------------------------------------' */
                                  if (rPharse.iTabTag == 0) 
                                  {
                                      rPharse.rTabTag[rPharse.iTabTag].level = 0;
                                  }
                                  else 
                                  {
                                      rPharse.rTabTag[rPharse.iTabTag].level = rPharse.rTabTag[j-1].level+1;
                                  }

                                  rPharse.rTabTag[rPharse.iTabTag].dimTabVar = 0;
                                  rPharse.iTabTag++;

                                  /*
                                  .--------------------------------------------------------.
                                  | identificato il token delimitatore iniziale del tag    |
                                  '--------------------------------------------------------' */       
                                  token[foundToken].type  = malloc(strlen("TagIniOpen\0"));
                                  strcpy(token[foundToken].type  , "TagIniOpen\0");
                                  token[foundToken].value = malloc(strlen(__TAG_INI_OPEN__));
                                  strcpy(token[foundToken].value , __TAG_INI_OPEN__);
                                  foundToken++; 

                                  /* 
                                  .--------------------------------------------------------.
                                  | elimina dal buffer il delimitatore lasciando solo      |
                                  | il nome tag "<tag\0" ==> "tag\0".                      |
                                  | Successivamente verrà catalogato il tag.               |
                                  | Tale codice non è riportato in questo blocco perchè    |
                                  | potrebbe accadere anche che tra delimitatore e tag ci  |
                                  | sia uno spazio di mezzo "< tag". In questo caso i due  |
                                  | token verrebbero letti in due bufferizzazioni          |
                                  | differenti anche se consecutive.                       |
                                  '--------------------------------------------------------' */ 
                                  int j2 = 1;
                                  while (buffer[j2]!=__ZERO__) { 
                                         buffer[j2-1] = buffer[j2];
                                         j2++;
                                  };
                                  buffer[j2-1] = __ZERO__;

                             };

                             /*
                             .----------------------------------------------.
                             |  Classificazione e valorizzazione del Token  |
                             '----------------------------------------------' */
                             token[foundToken].type = malloc(strlen("TagIni\0"));
                             strcpy(token[foundToken].type, "TagIni\0");
                             foundToken++;

                             /*
                             .----------------------------------------------.
                             |           Aggiornamento nome TAG             |
                             '----------------------------------------------' */
                             rPharse.rTabTag[rPharse.iTabTag-1].tag = malloc(strlen(buffer));
                             strcpy(rPharse.rTabTag[rPharse.iTabTag-1].tag, buffer);
                             
                        }; 

                     

                        /*
                        .------------------------------------------------------------------------------.
                        |                                TAG CODA APERTO                               |
                        .------------------------------------------------------------------------------.
                        |                                                                              |
                        |                                                                              |
                        |                                                                              |
                        |                                                                              |
                        |                                                                              |
                        |                                                                              |
                        |                                                                              |
                        |                                                                              |
                        '------------------------------------------------------------------------------' */
                        if ( rPharse.iTabTag > 0 ) {
                        if ( rPharse.rTabTag[j-1].stato == 2 )
                        {
                             // .---------------------------------------------------.      
                             // *****************************************************     
                             // ****** PROBLEMA IL TAG DI CHIUSURA COME SI FA *******     
                             // ****** A CAPIRE SE GIA' E' ASSEGNATO ???????? *******     
                             // *****************************************************      
                             // '---------------------------------------------------'     

                             /*
                             .--------------------------------------------------------.
                             | Identificato e classificato la tipologia del token     |
                             '--------------------------------------------------------' */
                             token[foundToken].type  = malloc(strlen("TagEnd\0"));
                             strcpy(token[foundToken].type  , "TagEnd\0");

                             /*
                             .---------------------------------------------------------.
                             | Registra Token trovato alla sinistra                    |
                             '---------------------------------------------------------' */
                             token[foundToken].value = malloc(strlen(buffer));
                             strcpy(token[foundToken].value  , buffer);
                             foundToken++;
                        };};

                   };

                   /*
                   .----------------------------------------------------------------------------.
                   | In questo punto si ricongiungono i due rami: buffer vuoto, buffer pieno.   |
                   | Quindi da questo punto in poi lo stack dei TAG è aggiornato. In presenza   |
                   | di errori il parse li ha già rilevati ed è uscito. Quindi a questo punto   |
                   | Tutto è OK e si appresta a registrare il Token di chiusura trovato. E' a   |
                   | questo punto che il parse ha necessità di capire se il tiken di chiusura è |
                   | legato ad un TAG di TESTA oppure ad un TAG di CODA.                        |
                   '----------------------------------------------------------------------------' */


                   /*
                   .----------------------------------------------------------------------------.
                   |                                                                            | 
                   |  Chiude il TAG di TESTA                                                    | 
                   |                                                                            | 
                   '----------------------------------------------------------------------------' */
                   if ( rPharse.rTabTag[j-1].stato == 0 ) { 

                        /*
                        .--------------------------------------------------------.
                        | identificato il token delimitatore iniziale del tag    |
                        '--------------------------------------------------------' */       
                        token[foundToken].type  = malloc(strlen("TagIniClose\0"));
                        strcpy(token[foundToken].type  , "TagIniClose\0");
                        token[foundToken].value = malloc(strlen(__TAG_END__));
                        strcpy(token[foundToken].value , __TAG_END__);
                        foundToken++; 

                        /*
                        .-------------------------------------------------------------.
                        | passa lo stato del TAG da 0 (TESTA OPEN) a 1 (TESTA CLOSE). |
                        '-------------------------------------------------------------' */       
                        rPharse.rTabTag[j-1].stato = 1;
                   };

                   /*
                   .----------------------------------------------------------------------------.
                   |                                                                            | 
                   |  Chiude il TAG di TESTA figlio del TAG in STATO 1 trovato (padre)          | 
                   |                                                                            | 
                   '----------------------------------------------------------------------------' */
                   if ( rPharse.rTabTag[j-1].stato == 1 ) {                         

                        /*
                        .--------------------------------------------------------.
                        | identificato il token delimitatore iniziale del tag    |
                        '--------------------------------------------------------' */       
                        token[foundToken].type  = malloc(strlen("TagIniClose\0"));
                        strcpy(token[foundToken].type  , "TagIniClose\0");
                        token[foundToken].value = malloc(strlen(__TAG_END__));
                        strcpy(token[foundToken].value , __TAG_END__);
                        foundToken++; 

                        /*
                        .-------------------------------------------------------------.
                        | passa lo stato del TAG da 0 (TESTA OPEN) a 1 (TESTA CLOSE). |
                        '-------------------------------------------------------------' */       
                        rPharse.rTabTag[rPharse.iTabTag-1].stato = 1;
                   };

                   /*
                   .----------------------------------------------------------------------------.
                   |                                                                            | 
                   |  Chiude il TAG di CODA                                                     | 
                   |                                                                            | 
                   '----------------------------------------------------------------------------' */
                   if ( rPharse.rTabTag[j-1].stato == 2 ) { 

                        /*
                        .--------------------------------------------------------.
                        | identificato il token delimitatore iniziale del tag    |
                        '--------------------------------------------------------' */       
                        token[foundToken].type  = malloc(strlen("TagEndClose\0"));
                        strcpy(token[foundToken].type  , "TagEndClose\0");
                        token[foundToken].value = malloc(strlen(__TAG_END__));
                        strcpy(token[foundToken].value , __TAG_END__);
                        foundToken++; 

                        /*
                        .-----------------------------------------------------------.
                        | passa lo stato del TAG da 2 (CODA OPEN) a 3 (CODA CLOSE). |
                        '-----------------------------------------------------------' */       
                        rPharse.rTabTag[j-1].stato = 3;
                   };


              };




====================================================================================================================
__SEPARATORE__
====================================================================================================================

_____DA_COMPILARE_____




====================================================================================================================
__ASSIGN__
====================================================================================================================

Quando il parse trova un ASSIGN (=) si aspetta di trovare le seguenti condizioni :

L'assign è identico sia per i TAG XML sia per i TAG Dati. E' necessario quindi capire di che ASSIGN si tratta
per effettuare i TEST e le assegnazioni sullo stack corrispondente. Alla sinistra l'unica cosa che si aspetta 
di trovare è una variabile.

*1* Che sia definita e consolidata l'intestazione XML (solamente per Stack Dati)

*2* Presente almeno un TAG
*3* Che L'ultimo TAG caricato sia in Aperto ed in STATO 1
*4* Che sia stato assegnato un NOME
*5* Che ci sia almeno una variabile definita
*6* Che l'ultima variabile definita sia in stato 0 (in attesa di Assign)

Lo stack deve essere considato prima di effettuare le verifiche, quindi va processato tutto quello che è alla sinistra 
del token ASSIGN prima di tutto.


====================================================================================================================

[-56] It isnt XML file. Not found TAG

      L'assign (=) viene utilizzato per separare variabile da valore all'interno del TAG di TESTA. La definizione
      delle variabili è successivo alla definizione del TAG. Sia nei TAG di intestazione XML sia nei tag utente
      è possibile definire variabili. Il primo test effettuato trovato un token di assign è il controllo di esistenza 
      di almeno un TAG nello stack delle intestazioni, perchè l'intestazione è la parte obbligatoria di un file 
      XML. Tale controllo evita casistiche di questo tipo :
      
      >> esempio 1.

      =

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test56A.xml 
      Error -56: [../samples/test56A.xml:1] It isnt XML file. Not found TAG.


      >> esempio 2.

      unknown=

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test56B.xml 
      Error -56: [../samples/test56B.xml:1] It isnt XML file. Not found TAG.


      >> esempio 3.

      <unknown=

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test56C.xml 
      Error -56: [../samples/test56C.xml:1] It isnt XML file. Not found TAG.


      >> esempio 4.

      <=

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test56D.xml 
      Error -56: [../samples/test56D.xml:1] It isnt XML file. Not found TAG.



====================================================================================================================

[-57] found token assign. Last TAG is TAIL close

      L'assign (=) viene utilizzato per separare variabile da valore all'interno del TAG di TESTA. La definizione
      delle variabili è successivo alla definizione del TAG. Sia nei TAG di intestazione XML sia nei tag utente
      è possibile definire variabili. Il primo test effettuato trovato un token di assign è il controllo di esistenza 
      di almeno un TAG nello stack delle intestazioni. Dopodichè il parse verifica che l'ultimo TAG di intestazione
      sia aperto, se non lo è si ferma e da questo errore.

      >> esempio 1.

      <?xml version = "1.0" ?>
      =

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test57A.xml 
      Error -57: [../samples/test57A.xml:2] found token assign. Last TAG is TAIL close.


      >> esempio 2.

      <?xml version = "1.0" ?>
      unknown=

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test57B.xml 
      Error -57: [../samples/test57B.xml:2] found token assign. Last TAG is TAIL close.


      >> esempio 3.

      <?xml version = "1.0" ?>
      <unknown=

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test57C.xml 
      Error -57: [../samples/test57C.xml:2] found token assign. Last TAG is TAIL close.


====================================================================================================================

[-58] last tag found have not a name

      L'assign (=) viene utilizzato per separare variabile da valore all'interno del TAG di TESTA. La definizione
      delle variabili è successivo alla definizione del TAG. Sia nei TAG di intestazione XML sia nei tag utente
      è possibile definire variabili. Il primo test effettuato trovato un token di assign è il controllo di esistenza 
      di almeno un TAG nello stack delle intestazioni. Dopodichè il parse verifica che l'ultimo TAG di intestazione
      sia aperto, se questo risulta aperto verifica che il nome del tag sia assegnato, se non lo è si ferma e 
      da questo errore.

      >>> esempio 1:

      <? = "1.0" ?>

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test58A.xml 
      [DEBUG] [         XMLIni] | [                                                                              <?]
      Error -58: [../samples/test58A.xml:1] last tag found have not a name.


      >>> esempio 2:

      <?= "1.0" ?>

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test58B.xml 
      [DEBUG] [         XMLIni] | [                                                                              <?]
      Error -58: [../samples/test58B.xml:1] last tag found have not a name.


      >>> esempio 3:

      <?xml= "1.0" ?>

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test58C.xml 
      [DEBUG] [         XMLIni] | [                                                                              <?]
      Error -58: [../samples/test58C.xml:1] last tag found have not a name.


      >>> esempio 4:

      <?version= "1.0" ?>

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test58D.xml 
      [DEBUG] [         XMLIni] | [                                                                              <?]
      Error -58: [../samples/test58D.xml:1] last tag found have not a name.


      >>> esempio 5:

      <?xmlversion= "1.0" ?>
      XX
       |X---------X
       |     |
       |     '---------------o da processare (buffer)
       '---------------------o processato (memorizzato nello stack


      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test58E.xml 
      [DEBUG] [         XMLIni] | [                                                                              <?]
      Error -58: [../samples/test58E.xml:1] last tag found have not a name.





====================================================================================================================

[-59] not found var for token assign.

      L'assign (=) viene utilizzato per separare variabile da valore all'interno del TAG di TESTA. La definizione
      delle variabili è successivo alla definizione del TAG. Sia nei TAG di intestazione XML sia nei tag utente
      è possibile definire variabili. Il primo test effettuato trovato un token di assign è il controllo di esistenza 
      di almeno un TAG nello stack delle intestazioni. Dopodichè il parse verifica che l'ultimo TAG di intestazione
      sia aperto, se questo risulta aperto verifica che il nome del tag sia assegnato, superato quest'ultimo controllo
      il parse verifica lo stato delle variabili. Se lo stack è vuoto o l'ultima inserita è in stato consolidato
      significa che non è presente una variabile in attesa di assign ed allora verifica nel buffer (la parte
      alla sinistra dell'assign non ancora processato) nel tentativo di trovarla lì. Se il buffer però è vuoto
      si arrende. Manca la variabile relativa all'assign trovato.

      esempio 1.

      <?xml = "100" ?>

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test59A.xml 
      Error -59: [../samples/test59A.xml:1] not found var for token assign.


====================================================================================================================

[-60] *Unknown Token* [%s] left token assign.

      L'assign (=) viene utilizzato per separare variabile da valore all'interno del TAG di TESTA. La definizione
      delle variabili è successivo alla definizione del TAG. Sia nei TAG di intestazione XML sia nei tag utente
      è possibile definire variabili. Il primo test effettuato trovato un token di assign è il controllo di esistenza 
      di almeno un TAG nello stack delle intestazioni. Dopodichè il parse verifica che l'ultimo TAG di intestazione
      sia aperto, se questo risulta aperto verifica che il nome del tag sia assegnato, superato quest'ultimo controllo
      il parse verifica lo stato delle variabili. Se lo stack non è vuoto e l'ultima variabile inserita in stato 1
      quindi attesa di assign il parse verifica che nel buffer (la parte
      alla sinistra dell'assign non ancora processato) non ci sia nulla da processare, cioè 
      che quanto trovato sia la situazione aggiornata. Se il buffer però è presente qualcosa allora il parse si
      interrompe perchè non è in grado di catalogare il token alla sinistra dell'assign (nel buffer appunto)
      in uno scenario che precedentemente all'ultimo controllo sembrava corretto. 
 
      esempio 1.

      <?xml version unknown= "1.0" ?>
                           o
                           |
                           '------- il parse è quì (contenuto buffer: "unknown=")

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test60A.xml 
      Error -60: [../samples/test60A.xml:1] *Unknown Token* [unknown] left token assign.


====================================================================================================================

[-61] replicate token assign for var [%s].

      L'assign (=) viene utilizzato per separare variabile da valore all'interno del TAG di TESTA. La definizione
      delle variabili è successivo alla definizione del TAG. Sia nei TAG di intestazione XML sia nei tag utente
      è possibile definire variabili. Il primo test effettuato trovato un token di assign è il controllo di esistenza 
      di almeno un TAG nello stack delle intestazioni. Dopodichè il parse verifica che l'ultimo TAG di intestazione
      sia aperto, se questo risulta aperto verifica che il nome del tag sia assegnato, superato quest'ultimo controllo
      il parse verifica lo stato delle variabili. Se lo stack non è vuoto e l'ultima variabile inserita in stato 2
      quindi attesa di un valore il parse si ferma per token di assign duplicato

      esempio 1.

      <?xml version == "1.0" ?>

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test61A.xml   
      Error -61: [../samples/test61A.xml:1] replicate token assign for var [version].


====================================================================================================================

[-62] last tag found have not a name.

      L'assign (=) viene utilizzato per separare variabile da valore all'interno del TAG di TESTA. La definizione
      delle variabili è successivo alla definizione del TAG. Sia nei TAG di intestazione XML sia nei tag utente
      è possibile definire variabili. Il parse considera che l'assign si trovi nel contesto dei TAG utente
      se le intestazioni son chiuse ed è presente almeno un tag utente nello stack. Dopodichè il parse verifica che 
      l'ultimo TAG utente sia aperto, se questo risulta aperto verifica che il nome del tag sia assegnato, 
      e se non lo è si ferma e da questo errore. Questo è come l'errore [58] ma in un contesto di TAG utente.

      >>> esempio 1:

      <?xml version = "1.0" ?>
      < = "password" ?>
 
      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test62A.xml 
      Error -62: [../samples/test62A.xml:2] last tag found have not a name.

====================================================================================================================

[-63] not found var for token assign.

      L'assign (=) viene utilizzato per separare variabile da valore all'interno del TAG di TESTA. La definizione
      delle variabili è successivo alla definizione del TAG. Sia nei TAG di intestazione XML sia nei tag utente
      è possibile definire variabili. Il parse considera che l'assign si trovi nel contesto dei TAG utente
      se le intestazioni son chiuse ed è presente almeno un tag utente nello stack. Dopodichè il parse verifica che 
      l'ultimo TAG utente sia aperto, se questo risulta aperto verifica che il nome del tag sia assegnato, cioè abbia un nome.
      Infine verifica lo stato delle variabili. Se lo stack variabili è vuoto o consolidato (def. ultima variabile conclusa)
      come estremo tentativo la cerca nel buffer (contenuto precedente all'assign) ma non ancora processato)
      Se questo è vuoto il parse si arrende, esce e segnala che non esiste la variabile per il relativo assign trovato.

      >>>> esempio 1.

      <?xml version = "100" ?>
      <credenziali user = "user" = "password" />

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test63A.xml 
      Error -63: [../samples/test63A.xml:2] not found var for token assign.


      >>>> esempio 2.

      <?xml version = "100" ?>
      <credenziali user = "user"password = "password" />

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test63B.xml 

      [DEBUG] [         XMLIni] | [                                                                              <?]
      [DEBUG] [            XML] | [                                                                             xml]
      [DEBUG] [       Separate] | [                                                                                ]
      [DEBUG] [       Variable] | [                                                                         version]
      [DEBUG] [       Separate] | [                                                                                ]
      [DEBUG] [         Assign] | [                                                                               =]
      [DEBUG] [          Value] | [                                                                           "100"]
      [DEBUG] [       Separate] | [                                                                                ]
      [DEBUG] [         XMLEnd] | [                                                                              ?>]
      [DEBUG] [     TagIniOpen] | [                                                                               <]
      [DEBUG] [         TagIni] | [                                                                     credenziali]
      [DEBUG] [       Separate] | [                                                                                ]
      [DEBUG] [       Variable] | [                                                                            user]
      [DEBUG] [       Separate] | [                                                                                ]
      [DEBUG] [         Assign] | [                                                                               =]
      [DEBUG] [          Value] | [                                                                  "user"password]
      [DEBUG] [       Separate] | [                                                                                ]
      Error -63: [../samples/test63B.xml:2] not found var for token assign.

      (*) Questo caso è interessante... perchè la variabile c'è solo che è unica alla value precedente...
      e quindi il parse la considera value. In un parse che implementa le specifiche completamente di xml
      il parsen sarebbe uscito comunque ma prima perchè la value deve essere contenuta all'interno di doppi-apici
      o apici singoli. Quindi avrebbe considerato l'errore u token prima. Un parse intelligente oltre le specifiche
      sarebbe in grado di capire che l'utente si è dimenticato di inserire uno spazio tra prec value e next var.


====================================================================================================================

[-64] *Unknown Token* [%s] left token assign.

      L'assign (=) viene utilizzato per separare variabile da valore all'interno del TAG di TESTA. La definizione
      delle variabili è successivo alla definizione del TAG. Sia nei TAG di intestazione XML sia nei tag utente
      è possibile definire variabili. Il parse considera che l'assign analizzato si trovi nel contesto dei TAG utente
      se le intestazioni son chiuse ed è presente almeno un tag utente nello stack. Dopodichè il parse verifica che 
      l'ultimo TAG utente sia aperto, se questo risulta aperto verifica che il nome del tag sia assegnato, cioè abbia un nome.
      Infine verifica lo stato delle variabili. Se lo stack variabili non è vuoto e l'ultima variabile è in stato
      1 significa che è stata definita ed è in attesa dell'assign, quindi all'apparenza tutto regolare. Il parse
      verifica che il buffer sia vuoto che quindi non ci sia nulla tra l'assign e la variabile. Se il buffer
      non è vuoto significa che c'è qualcosa che il parse non sa catalogare e quindi esce con questo errore. 

      >>> esempio 1.

      <?xml version = "1.0" ?>
      <creden ziali user="user" password="password" /> 

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test64A.xml 

      [DEBUG] [         XMLIni] | [                                                                              <?]
      [DEBUG] [            XML] | [                                                                             xml]
      [DEBUG] [       Separate] | [                                                                                ]
      [DEBUG] [       Variable] | [                                                                         version]
      [DEBUG] [       Separate] | [                                                                                ]
      [DEBUG] [         Assign] | [                                                                               =]
      [DEBUG] [          Value] | [                                                                           "1.0"]
      [DEBUG] [       Separate] | [                                                                                ]
      [DEBUG] [         XMLEnd] | [                                                                              ?>]
      [DEBUG] [     TagIniOpen] | [                                                                               <]
      [DEBUG] [         TagIni] | [                                                                          creden]
      [DEBUG] [       Separate] | [                                                                                ]
      [DEBUG] [       Variable] | [                                                                           ziali]
      [DEBUG] [       Separate] | [                                                                                ]
      Error -64: [../samples/test64A.xml:2] *Unknown Token* [user] left token assign.


      >>> esempio 2.

      <?xml version = "1.0" ?>
      <credenziali use r="user" password="password /> 

      [DEBUG] [         XMLIni] | [                                                                              <?]
      [DEBUG] [            XML] | [                                                                             xml]
      [DEBUG] [       Separate] | [                                                                                ]
      [DEBUG] [       Variable] | [                                                                         version]
      [DEBUG] [       Separate] | [                                                                                ]
      [DEBUG] [         Assign] | [                                                                               =]
      [DEBUG] [          Value] | [                                                                           "1.0"]
      [DEBUG] [       Separate] | [                                                                                ]
      [DEBUG] [         XMLEnd] | [                                                                              ?>]
      [DEBUG] [     TagIniOpen] | [                                                                               <]
      [DEBUG] [         TagIni] | [                                                                     credenziali]
      [DEBUG] [       Separate] | [                                                                                ]
      [DEBUG] [       Variable] | [                                                                             use]
      [DEBUG] [       Separate] | [                                                                                ]
      Error -64: [../samples/test64B.xml:2] *Unknown Token* [r] left token assign.


      (*) questo errore potrebbe capitare per errore se ad esempio di inserisce uno spazio non voluto nel nome tag...
          oppure nel nome variabile

====================================================================================================================

[-65] duplicate token assign for var [%s].

      L'assign (=) viene utilizzato per separare variabile da valore all'interno del TAG di TESTA. La definizione
      delle variabili è successivo alla definizione del TAG. Sia nei TAG di intestazione XML sia nei tag utente
      è possibile definire variabili. Il parse considera che l'assign analizzato si trovi nel contesto dei TAG utente
      se le intestazioni son chiuse ed è presente almeno un tag utente nello stack. Dopodichè il parse verifica che 
      l'ultimo TAG utente sia aperto, se questo risulta aperto verifica che il nome del tag sia assegnato, cioè abbia un nome.
      Infine verifica lo stato delle variabili. Se lo stack variabili non è vuoto e l'ultima variabile è in stato
      2 significa che è in attesa di un valore (già è stato acquisito l'assign). Quindi il parse esce per assign duplicato
      anche se nel buffer ci potrebbe essere ancora qualcosa da processare che in tutti i casi non risolverebbe 
      il problema

      >>>>> esempio 1.

      <?xml version = "1.0" ?>
      <credenziali user=="user" password="password" />


      >>>>> esempio 2.

      <?xml version = "1.0" ?>
      <credenziali user= password="password" />

      (*) quets'ultimo caso è interessante perchè il messaggio per questo è un pò impreciso non scendendo nel dettaglio
          non processando quindi il contenuto del buffer. Quì ad esempio manca la value per la variabile user
          non avendo il token del buffer agli estremi apici o doppi apici... 

====================================================================================================================

[-66] found token assign. Last TAG is HEAD close.

      L'assign (=) viene utilizzato per separare variabile da valore all'interno del TAG di TESTA. La definizione
      delle variabili è successivo alla definizione del TAG. Sia nei TAG di intestazione XML sia nei tag utente
      è possibile definire variabili. Il parse considera che l'assign analizzato si trovi nel contesto dei TAG utente
      se le intestazioni son chiuse ed è presente almeno un tag utente nello stack. Dopodichè il parse verifica che 
      l'ultimo TAG utente sia aperto (stato 0). Se invece lo trova in stato 1 (TAG TESTA chiuso es "<tag></tag>=")
      esce con questo errore.

      >>>>> esempio 1.

      <?xml version = "1.0" ?>
      <credenziali user="user">=

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test66A.xml 
      Error -66: [../samples/test66A.xml:2] found token assign. Last TAG is HEAD close.


      >>>>> esempio 2.

      <?xml version = "1.0" ?>
      <credenziali user="user"> =

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test66B.xml 
      Error -66: [../samples/test66B.xml:2] found token assign. Last TAG is HEAD close.


      >>>>> esempio 3.

      <?xml version = "1.0" ?>
      <credenziali user="user"><=

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test66C.xml 
      Error -66: [../samples/test66C.xml:2] found token assign. Last TAG is HEAD close.

[BUG]

      >>>>> esempio 4.

      <?xml version = "1.0" ?>
      <credenziali>
            <user="xxx"/>
      </credenziali>

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test66D.xml 

      [DEBUG] [         XMLIni] | [                                                                              <?]
      [DEBUG] [            XML] | [                                                                             xml]
      [DEBUG] [       Separate] | [                                                                                ]
      [DEBUG] [       Variable] | [                                                                         version]
      [DEBUG] [       Separate] | [                                                                                ]
      [DEBUG] [         Assign] | [                                                                               =]
      [DEBUG] [          Value] | [                                                                           "1.0"]
      [DEBUG] [       Separate] | [                                                                                ]
      [DEBUG] [         XMLEnd] | [                                                                              ?>]

      Error -35: [../samples/test66D.xml:2] found tag delimiter close but no tag

      il problema è il token di chiusura... (>) il parsen non riesce a spezzare <+credenziali+>


      >>>>>> esempio 5.

      <?xml version = "1.0" ?>
      <credenziali >
            <user="xxx"/>
      </credenziali >

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test66E.xml 
      Error -66: [../samples/test66E.xml:3] found token assign. Last TAG is HEAD close.



====================================================================================================================

[-67] found token assign. Last TAG is TAIL open.

      L'assign (=) viene utilizzato per separare variabile da valore all'interno del TAG di TESTA. La definizione
      delle variabili è successivo alla definizione del TAG. Sia nei TAG di intestazione XML sia nei tag utente
      è possibile definire variabili. Il parse considera che l'assign analizzato si trovi nel contesto dei TAG utente
      se le intestazioni son chiuse ed è presente almeno un tag utente nello stack. Dopodichè il parse verifica che 
      l'ultimo TAG utente sia aperto (stato 0). Se invece lo trova in stato 2 (TAG CODA aperto es "<tag></tag =...")
      esce con questo errore.

      >>>> esempio 1

      <?xml version = "1.0" ?>
      <credenziali>
      </credenziali =>
                    o
                    |
                    '------ il parse si ferma qui
             
      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test67A.xml 
      Error -67: [../samples/test67A.xml:3] found token assign. Last TAG is TAIL open.

      >>>> esempio 2

      <?xml version = "1.0" ?>
      <credenziali>
      </credenziali user="user" password="password">
                        o
                        |
                        '------ il parse si ferma qui
             
      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test67B.xml   
      Error -67: [../samples/test67B.xml:3] found token assign. Last TAG is TAIL open.

====================================================================================================================

[-68] found token assign. Last TAG is TAIL close.

      L'assign (=) viene utilizzato per separare variabile da valore all'interno del TAG di TESTA. La definizione
      delle variabili è successivo alla definizione del TAG. Sia nei TAG di intestazione XML sia nei tag utente
      è possibile definire variabili. Il parse considera che l'assign analizzato si trovi nel contesto dei TAG utente
      se le intestazioni son chiuse ed è presente almeno un tag utente nello stack. Dopodichè il parse verifica che 
      l'ultimo TAG utente sia aperto (stato 0). Se invece lo trova in stato 3 (TAG CODA aperto es "<tag></tag>=")
      esce con questo errore.

      >>>> esempio 1

      <?xml version = "1.0" ?>
      <credenziali >
      </credenziali>="user" password="password"
                    o
                    |
                    '------ il parse si ferma qui

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test68A.xml 
      Error -68: [../samples/test68A.xml:3] found token assign. Last TAG is TAIL close.


      >>>> esempio 2

      <?xml version = "1.0" ?>
      <credenziali user="user1" password="password1"></credenziali>
      <credenzialiuser="user2" password="password2"></credenziali>
                      o
                      |
                      '------ il parse si ferma qui

      jack0e@jack0e-laptop:~/spiderxml/src$ ../bin/parseXML ../samples/test68B.xml
      Error -68: [../samples/test68B.xml:3] found token assign. Last TAG is TAIL close.

      (*) interessante notare (nel secondo esempio) che in certe situazioni anche il dimenticarsi di uno spazio
          di separazione tra nometag e nomevariabile "credenzialiuser" può generare questo errore perchè
          nel caso specifico al momento del rilevamente del token di assign questa è la stringa al momento bufferizzata
          "<credenzialiuser=". Il parse trova l'ultimo tag a stato 3 (precedente tag "credenziali"). Questo sicuramente
          è un errore perchè nel buffer non ci può essere definizione nuovo tag + variabile e quindi il parse interrompe
          senza scendere troppo nel dettaglio di specificare l'errore più consono. Il tal caso avrebbe dovuto
          analizzare il buffer e concludere che manca la definizione della variabile relativa all'assign trovato.

====================================================================================================================
====================================================================================================================
====================================================================================================================



~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*

MANCA :

* verifica value tra "" o ''
* verifica che nome nel tag di TESTA e tag di CODA corrispondente sia uguali.
* verifica del nome TAG (controllo sintattico) ... e che non contengano la parola xml|XML|etc...
* verifica che i tag di intestazione inizino per xml|XML|etc.
* verifica che il primo tag di instestazione deve essere "xml" (es. <?xml...) 
* Anomalia: ad oggi gli spazi doppi vengono eliminati anche dai value... questo è un errore
* Anomalia: ad oggi i valori tra TAG OPEN e TAG CLOSE non sono supportati <tag>Qesta è una bella Poesia</tag>

~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*








