Articoli

Creare un parser con Parse::RecDescent

bronto — 2010-09-06T16:08:02+02:00

Grazie a Dio, i file di configurazione sono dappertutto, e non è più necessario inserire configurazioni direttamente nel codice. E se per caso continui a farlo... beh, almeno sai che non è una buona prassi, no? In ogni caso, i file di configurazione devono essere interpretati per estrarre le informazioni che contengono. Se il formato del file è uno di quelli ben noti, troverai sicuramente una libreria già pronta. Se il formato non è poi così conosciuto, ma è orientato alla linea (cioè: ogni direttiva di configurazione si trova su una singola riga di testo) e semplice, allora scrivere un parser sarà facile. Se è un file XML, le cose si complicano un po' ma decodificare il file è sempre fattibile: basta usare una delle tante librerie per il parsing di XML, ispezionare gli elementi che ci interessano, e il gioco è fatto. Se poi siamo noi a dover scegliere il formato del file, possiamo usarne uno che sia fatto apposta per la nostra libreria preferita --nel mio caso il modulo AppConfig. Ma... cosa fare nel caso in cui ci si trovi in un caso diverso? Io, per esempio, dovevo decodificare le informazioni di un file pseudo-INI di 350 chilobyte. Con "pseudo-ini" intendo che ha dei costrutti tipici dei file INI, come le dichiarazioni di sezione:

[nome_sezione]

e associazioni chiave valore, come:

    parametro=valore
    valori="possonno essere anche fra doppi apici"

linee di commento:

    ; come questa

e sono permesse linee vuote. Una differenza è che sono permesse assegnazioni multiple allo stesso parametro, che risultano nell'assegnazione di un array di valori al parametro stesso:

    parametro=valore1
    parametro=valore2
    parametro=valore3
    ; il valore del parametro è (valore1, valore2, valore3)

E non è finita! La parte più difficile era che ad un parametro era possibile assegnare una struttura multivalore del linguaggio Pike, cioè un array:

    parametro=({ valore1, valore2, valore3 })

o un mapping (associazioni chiave/valore):

    parametro=([ "key1" : "value1", "key2" : "value2" ])

C'è di più: le strutture Pike possono essere multilinea e annidate! Ad esempio:

	parameter=({
	            ([
	                "key1" : "value1",
	                "key2" : ([ "array", "value" ]),
	            ]),
	            "second element of this array",
	            ({
	                "and here is another array",
	                ({
	                    "with another one nested",
	                }),
	                ([
	                    "that" : "contains",
	                    "one"  : "more",
	                    "hash" : "value",
	                ]),
	            }),
	            "Hooray!",
	          })

Un incubo, vero? Dovevo interpretare questo file. Il formato del file può essere descritto (è quello che ho appena fatto, giusto?), quindi ciò che mi serviva era una descrizione formale (ossia: una grammatica) da dare in pasto ad un generatore di parser. Mi sono ricordato di quel corso sul modulo Parse::RecDescent che seguii nel lontano 1999 alla Open Source Software Convention di Monterey, USA... bei ricordi!!! Dopo 11 anni, era finalmente arrivato il momento di applicare ciò che avevo imparato durante il corso. Ma, come ho poi scoperto, Parse::RecDescent è un modulo molto potente, e usarlo correttamente può diventare altrettanto complicato. Ecco perché ho deciso di scrivere questo articolo come una guida passo-passo. Naturalmente è richiesta la conoscenza di Perl, dato che parlerò diffusamente di strutture dati in Perl, reference ed altri costrutti senza spiegarli. La prima parte è scrivere la grammatica. Il nostro file conterrà zero o più linee, fino alla fine del file. Possiamo esprimerlo in questo modo:

AsIni: Line(s?) /\Z/

che significa che AsIni è composto da zero o più "Line", fino alla fine del file. So che il nome AsIni fa ridere in Italiano, ma il file si chiama proprio as.ini, quindi non avevo molta scelta... Come è fatta una "Line"? Può essere un commento, una linea vuota, una dichiarazione di sezione, o una assegnazione a un parametro; nessun altro tipo di linea è consentito. Lo esprimeremo così:

Line:   CommentLine
                | BlankLine
                | SectionDeclaration
                | AssignmentLine
                | <error>

Abbiamo fatto un passo avanti, proseguiamo: com'è fatta una linea di commento? Abbiamo detto che inizia con un ";", eventualmente preceduto da spazi, e il commento è tutto il testo che segue quel carattere, fino alla fine della linea. Lo possiamo esprimere in questo modo:

CommentLine:    <skip: q{}> /^\s*/m ';' /.*$/m

Cosa significa il costrutto "skip"? Normalmente, Parse::RecDescent isola i "token" che compongono il file, scartando gli spazi eccedenti. Se vogliamo esprimere che la linea può avere spazi in testa, dobbiamo cambiare questo comportamento quando cerchiamo questo tipo di linea: è ciò che il costrutto skip fa. Per maggiori informazioni vi rimando alla documentazione del modulo. Possiamo usare lo stesso trucco per esprimere BlankLine:

BlankLine:      <skip: q{}> /^\s+$/m

Cosa ci fa il modificatore "m" alla fine del pattern matching? È necessario usarlo perché il testo da elaborare viene passato al parser come un'unica stringa, che quindi conterrà anche le sequenze di ritorno a capo. La "m" è un modificatore che, in un certo senso, indica a Perl di match-are l'inizio e la fine della linea all'interno della stringa. Continuando ad esaminare le possibili linee, arriviamo alla dichiarazione di sezione:

SectionDeclaration:     '[' /[^\]]+/ ']'

Che significa: una "[", una stringa non nulla che non contiene "]", e infine il carattaere "]. Era facile. Siamo arrivati al dunque: le assegnazioni ai parametri. Com'è fatta una linea di assegnazione?

AssignmentLine: Parameter '=' Value(?)

Questo significa: il nome del parametro, un segno di "=", ed un valore, o nessun valore (il che significa che il parametro è undef). "(?)" è una "repetition", che significa "0 o 1 ricorrenze di questo elemento". Abbiamo espresso la AssignmentLine, ma com'è fatto un parametro?

Parameter:      /\w[\w\s-]*/

Questo significa: un "word character" (potete pensarlo come un carattere alfanumerico, più il "_"), che può essere seguito da una seuqenza di altri word character, o "spazi" (cioè lo spazio vero e proprio, la tabulazione...), o "-". Il valore, come detto, può essere una struttura Pike o una stringa:

Value:          PikeStructure   | ValueString

Esaminiamo prima le stringhe, che sono più semplici. Abbiamo detto che possono essere stringhe normali o racchiuse fra doppi apici; questo concetto può essere espresso in questo modo:

ValueString:    QuotedString    | UnquotedString

QuotedString:   '"' /[^"]+/ '"'

UnquotedString: /.+/

Ciò significa: una QuotedString è una stringa che inizia e finisce con i doppi apici, e contiene caratteri diversi dai doppi apici. Una UnquotedString è una stringa qualsiasi. Si noti che verifichiamo prima se si tratti di una QuotedString, e poi una UnquotedString, altrmenti la UnquotedString sarebbe verificata anche quando non vorremmo che lo fosse (gli apici verrebbero "catturati" come facenti parte della stringa). Questo mi dà anche l'opportunità di far notare che i parser generati da Parse::RecDescent sono di tipo "first match": fra tutte quelle possibili, viene utilizzata la prima regola che viene verificata. Quindi, è importante che le regole più specifiche vengano verificate per prime. E siamo arrivati alla PikeStructure. Se non lo avete già fatto da poco, procuratevi un caffè perché questa spiegazione sarà lunga e, a tratti, anche complessa. Andate a prenderlo, io vi aspetto qui. Preso il caffè? Bene. Il primo livello di definizione della PikeStructure è abbastanza semplice, così come il secondo:

PikeStructure:  PikeArray | PikeMapping

PikeArray:      '({' PikeArrayContent '})'

PikeMapping:    '([' PikeMappingContent '])'

Cominciamo a lavorare sugli array. Il contenuto di un array può essere:

nessun contenuto (un array vuoto)
un elemento
due o più elementi, separati da virgole

Inoltre, è ammissibile che ci sia una virgola in coda all'ultimo valore. Chiameremo la virgola "PikeStructureSeparator", e la sequenza di valori contenuta nell'array la chiameremo "PikeArraySequence". Scriviamo le definizioni:

PikeStructureSeparator: ','

PikeArrayContent:       PikeArraySequence(?) PikeStructureSeparator(?)

Quindi possiamo avere zero o una PikeArraySequence (perché zero o una??? Continua a leggere!!!), e zero o uno PikeStructureSeparator in coda. Incidentalmente, questo permette anche di avere una dichiarazione di array vuoto che contiene solo una virgola, ma faremo finta che va bene anche questo. Ora, definiamo formalmente la sequenza a partire dalla definizione che ne abbiamo dato a parole poche righe più su:

PikeArraySequence:      PikeValue PikeArrayFurtherValue(s?)

Questo significa: almeno un PikeValue, pià zero o uno ulteriori valori. Probabilmente cominci a vedere qual'era la strategia: la ripetizione zero/uno "PikeArraySequence(?)" si occupa del caso in cui l'array è vuoto, il singolo PikeValue tiene conto del caso in cui ci sia un singolo valore, e "PikeArrayFurtherValue(s?)" tiene conto del resto. Ma non abbiamo ancora finito. Che cos'è un PikeValue?

PikeValue:              PikeStructure | QuotedString | Number

Un PikeValue può essere: un'altra PikeStructure (che tiene conto del caso in cui vi siano più strutture annidate), o una QuotedString, o un numero... Number non lo avevamo ancora visto! Cos'è un numero?

Number: /[+-]?\d*(\.\d+)?/ <reject: $item[1] eq ''>

Questo significa che possiamo avere un segno, quindi potrebbero esserci cifre, dopo le quali potrebbero esserci anche un punto e ulteriori cifre. Putroppo però questo pattern è verificato anche dalla stringa nulla, che non vogliamo che sia verificata perché... non è un numero! Esprimiamo questa condizione con la direttiva reject, che significa: se la stringa che verifica il pattern è la stinga nulla, allora la regola non è verificata. Questo completa la discussione sul PikeValue, ci manca PikeArrayFurtherValue. Che cos'è? Se ci pensi un attimo, si tratta di prevedere ulteriori valori dopo il primo, quindi:

PikeArrayFurtherValue:  PikeStructureSeparator PikeValue

Abbiamo finito: se torni indietro alla PikeArraySequence vedrete che è un PikeValue seguito da zero o più ", PikeValue"! Questo conclude la discussione sui PikeArray, e possiamo dedicarci ai mapping. Abbiamo già imparato parecchio dalla discussione precedente, quindi per PikeMapping avremo meno bisogno di spiegare:

PikeMappingContent:     PikeMappingSequence(?) PikeStructureSeparator(?)

PikeMappingSequence:    PikeMappingPair PikeMappingFurtherPair(s?)

PikeMappingPair:        QuotedString ':' PikeValue

PikeMappingFurtherPair: PikeStructureSeparator PikeMappingPair

Essenzialmente, un PikeMapping è una sequenza di zero o più "QuotedString : PikeValue", che può avere una virgola in coda. Montando tutti i pezzi assieme otteniamo la nostra grammatica:

AsIni: Line(s?) /\Z/

Line:   CommentLine
                | BlankLine
                | SectionDeclaration
                | AssignmentLine
                | 
                
CommentLine:    <skip: q{}> /^\s*/m ';' /.*$/m

BlankLine:      <skip: q{}> /^\s+$/m

SectionDeclaration:     '[' /[^\]]+/ ']'

AssignmentLine: Parameter '=' Value(?)

Parameter:      /\w[\w\s-]*/

Value:          PikeStructure   | ValueString

ValueString:    QuotedString    | UnquotedString

QuotedString:   '"' /[^"]+/ '"'

UnquotedString: /.+/

PikeStructure:  PikeArray | PikeMapping

PikeArray:      '({' PikeArrayContent '})'

PikeMapping:    '([' PikeMappingContent '])'

PikeStructureSeparator: ','

PikeArrayContent:       PikeArraySequence(?) PikeStructureSeparator(?)

PikeArraySequence:      PikeValue PikeArrayFurtherValue(s?)

PikeValue:              PikeStructure | QuotedString | Number

Number: /[+-]?\d*(\.\d+)?/ <reject: $item[1] eq ''>

PikeArrayFurtherValue:  PikeStructureSeparator PikeValue

PikeMappingContent:     PikeMappingSequence(?) PikeStructureSeparator(?)

PikeMappingSequence:    PikeMappingPair PikeMappingFurtherPair(s?)

PikeMappingPair:        QuotedString ':' PikeValue

PikeMappingFurtherPair: PikeStructureSeparator PikeMappingPair

I più attenti potrebbero aver intuito una struttura ad albero o un grafo sotto questa grammatica, ed è proprio così che Parse::RecDescent lavora: parte da una radice (nel nostro caso AsIni) e va sempre più in fondo nella struttura delle regole che compongono la grammatica, cercando di verificare ogni regola con le sue sottoregole, andando sempre più in profondità. Se un ramo non viene verificato, il parser torna alla biforcazione precedente e tenta di percorrerla verificando le sue regole, e così via. Abbiamo quindi una grammatica, che se data in pasto a Parse::RecDescent produce un parser che elaborerà correttamente il nostro file pseudo-ini. Il problema è che non farà niente a parte questo. Perché? Dovreste sapere che i computer sono macchine stupide, e se non gli chiedete di fare qualcosa, loro non fanno assolutamente niente! Dobbiamo istruire esplicitamente Parse::RecDescent su cosa fare quando una regola viene verificata, allegando delle azioni alle regole della nostra grammatica: le azioni sono pezzi di codice Perl. Per quanto nelle azioni si possa fare qualunque cosa, ho scoperto che nel mio caso specifico la cosa migliore era lasciare che le sezioni di testo "match-ate" dalle regole della grammatica salissero su per l'albero come delle bolle, fino ad arrivare alla regola AssignmentLine. Arrivate lì, le informazioni verranno disposte in un hash annidato, con i nomi delle sezioni al primo livello, i parametri al secondo, e associati a questa coppia avremo un array di valori per quel parametro in quella sezione. Per indirizzare un certo valore useremo quindi un'espressione del tipo:

  $AsIni::node{$section_name}{$parameter_name}[$value_index]

Per poterlo fare, è necessario conoscere alcune altre cose. La prima: gli elementi che verificano una regola vengono disposti su un array che si chiama @item, e su un hash che si chiama %item. Per ciò che riguarda questo articolo, faremo riferimento solo ad @item, rimandando alla documentazione per la descrizione del hash. Accade quindi che se la stringa

"ParseMe"

verifica la regola

QuotedString:   '"' /[^"]+/ '"'

allora:

$item[0] conterrà il nome della regola, cioè: QuotedString
$item[1] conterrà il valore della stringa '"', cioè... "
$item[2] conterrà la stringa che verifica il pattern, cioè: ParseMe
$item[3] conterrà ancora il valore della stringa '"'

Se invece la regola contiene anche ripetizioni --cioè le stringhe "(?)", "(s?)"... che seguono una sottoregola--, il funzionamento è leggermente diverso. In questo caso, gli elementi di @item conterranno una reference all'array dei valori che la sottoregola ha verificato. Cioè, quando la linea:

	cheese=pecorino

verifica AssignmentLine, allora:

$item[0] conterrà il nome della regola, cioè: 'AssignmentLine'
$item[1] conterrà il valore di Parameter, cioè: "cheese"
$item[2] conterrà il valore di '=', cioè... =
$item[3] conterrà una reference ad array dei Value che sono stati verificati. In questo caso potremmo esprimere Value con l'espressione Perl [ "pecorino" ]

Infine, $return è una variabile speciale che contiene il valore che l'azione deve restuire se l'intera regola è verificata. Se una sottoregola viene verificata, ma l'intera regola non lo è, il valore di $return viene scartato. È un comportamento decisamente conveniente, perché se invece conservassimo i risultati man mano che vengono verificati dalle sottoregole, ma la regola successivamente fallisse, dovremmo anche occuparci di eliminare i valori precedentemente salvati. E potrebbe non essere semplice! Ora sappiamo abbastanza per poter far "salire" i valori, partendo dalle foglie dell'albero (cioè QuotedString, UnquotedString e Number) fino alla cima. È molto semplice:

QuotedString:   '"' /[^"]+/ '"'
  {
    $return = $item[2] ;
  }

UnquotedString: /.+/
  {
    $return = $item[1] ;
  }

# This rule matches a number, but rejects null-length results
Number: /[+-]?\d*(\.\d+)?/ <reject: $item[1] eq ''>
  {
    $return = $item[1] ;
  }

Nelle regole per la ripetizione "(?)", bisogna ricordarsi di "spacchettare" il valore contenuto nella reference:

PikeMappingContent:     PikeMappingSequence(?) PikeStructureSeparator(?)
  {
    # Since we have a repetition here, $item[1] is a reference to an
    # array which may contain 0 or 1 PikeMappingSequence's.
    # In turn, PikeMappingSequence returns an hash reference.
    # So, if we want the hash reference to bubble up, we have to
    # unwrap it and return it as is.

    ( $return ) = @{ $item[1] } ;
  }

...e così via per gli altri casi simili. Quando incontriamo una sezione, dobbiamo conservarne il nome in una package variable per poterlo usare successivamente:

SectionDeclaration:     '[' /[^\]]+/ ']'
  {
    print STDERR qq{In section "$item[2]"\n} ;

    my $sectionname = $item[2] ;

    $AsIni::section = $sectionname ;
  }

E infine, quando arriviamo a verificare una AssignmentLine, dobbiamo salvare i valori ottenuti nel hash %AsIni::node:

AssignmentLine: Parameter '=' Value(?)
  {
    my $distvalue = $item[3] ;
    my $parmname  = $item[1] ;
    my $paramvalue ;

    ( $paramvalue ) = @$distvalue ;

    if ( not exists $AsIni::node{$AsIni::section}{$parmname} ) {
      $AsIni::node{$AsIni::section}{$parmname} = [] ;
    }

    # Get a reference to the current array of values for this parameter
    # in $current
    my $current = $AsIni::node{$AsIni::section}{$parmname} ;

    # We can update this safely, since we are using the reference
    push @$current,$paramvalue ;

  }

La versione finale della grammatica è la seguente:

# $Id: g3.txt,v 1.14 2010/07/23 12:41:24 bronto Exp bronto $

AsIni: Line(s?) /\Z/

Line:	CommentLine
		| BlankLine
		| SectionDeclaration
		| AssignmentLine
		| 


CommentLine:	<skip: q{}> /^\s*/m ';' /.*$/m
  {
    print STDERR qq{\tSkipping comment: $item[4]\n} ;
  }

BlankLine:	<skip: q{}> /^\s+$/m
  {
    print STDERR qq{\tSkipping blank line\n}
  }

SectionDeclaration:	'[' /[^\]]+/ ']'
  {
    print STDERR qq{In section "$item[2]"\n} ;

    my $sectionname = $item[2] ;

    $AsIni::section = $sectionname ;
  }

AssignmentLine:	Parameter '=' Value(?)
  {
    my $distvalue = $item[3] ;
    my $parmname  = $item[1] ;
    my $paramvalue ;

    ( $paramvalue ) = @$distvalue ;

    if ( not exists $AsIni::node{$AsIni::section}{$parmname} ) {
      $AsIni::node{$AsIni::section}{$parmname} = [] ;
    }

    # Get a reference to the current array of values for this parameter
    # in $current
    my $current = $AsIni::node{$AsIni::section}{$parmname} ;

    # We can update this safely, since we are using the reference
    push @$current,$paramvalue ;

  }

Parameter:	/\w[\w\s-]*/
  {
    $return = $item[1] ;
  }

Value:		PikeStructure	| ValueString
  {
    $return = $item[1] ;
  }

ValueString:	QuotedString	| UnquotedString
  {
    $return = $item[1] ;
  }

QuotedString:	'"' /[^"]+/ '"'
  {
    $return = $item[2] ;
  }

UnquotedString:	/.+/
  {
    $return = $item[1] ;
  }

# This rule matches a number, but rejects null-length results
Number:	/[+-]?\d*(\.\d+)?/ <reject: $item[1] eq ''>
  {
    $return = $item[1] ;
  }

PikeStructure:	PikeArray	| PikeMapping
  {
    # $item[1] is a reference to an array (PikeArray) or hash
    # (PikeMapping). We bubble it up as is
    $return = $item[1] ;
  }

PikeArray:	'({' PikeArrayContent '})'
  {
    # $item[2] is a PikeArrayContent, and since PikeArrayContent
    # bubbles up a reference to an array of PikeValues, this should be
    # an array reference that we can safely bubble up as is.
    $return = $item[2] ;
  }

PikeMapping:	'([' PikeMappingContent '])'
  {
    # $item[2] is a PikeMappingContent, and since PikeMappingContent
    # bubbles up an hash reference, this should be an hash reference that we
    # can safely bubble up as is.
    $return = $item[2] ;
  }

PikeStructureSeparator:	','

PikeArrayContent:	PikeArraySequence(?) PikeStructureSeparator(?)
  {
    # $item[1] comes from a repetition of PikeArraySequence,
    # so it is a reference to an array of 0 or 1 PikeArraySequence.
    # In turn, PikeArraySequence is a reference to an array of
    # PikeValue's. We don't want to change the PikeValue's but we need
    # to unroll $item[1] before bubbling it up.
    ( $return ) = @{ $item[1] } ;
  }

PikeArraySequence:	PikeValue PikeArrayFurtherValue(s?)
  {
    # $item[1] is a PikeValue, hence:
    # - a reference to an array or hash (if PikeStructure)
    # - a scalar (if QuotedString or Number)
    #
    # $item[2] comes from a repetition of PikeArrayFurtherValue,
    # so it is a reference to an array of 0 or 1 PikeArrayFurtherValue.
    # In turn, PikeArrayFurtherValue just returns a PikeValue. So,
    # we actually don't want to change $item[1], but we need to
    # unroll $item[2] before returning it. Actually, we return an
    # array reference with the whole thing.
    $return = [ $item[1], @{ $item[2] } ] ;
  }

PikeArrayFurtherValue:	PikeStructureSeparator PikeValue
  {
    # $item[2] is a PikeValue, hence:
    # - a reference to an array or hash (if PikeStructure)
    # - a scalar (if QuotedString or Number)
    # We bubble it up as is.
    $return = $item[2] ;
  }

PikeMappingContent:	PikeMappingSequence(?) PikeStructureSeparator(?)
  {
    # Since we have a repetition here, $item[1] is a reference to an
    # array which may contain 0 or 1 PikeMappingSequence's.
    # In turn, PikeMappingSequence returns an hash reference.
    # So, if we want the hash reference to bubble up, we have to
    # unwrap it and return it as is.
    
    ( $return ) = @{ $item[1] } ;
  }

PikeMappingSequence:	PikeMappingPair PikeMappingFurtherPair(s?)
  {
    # $item[1] is a PikeMappingPair, hence a reference to an array
    # of two elements: a string and a PikeValue, that is:
    # - a reference to an array or hash (if Pikevalue ~ PikeStructure)
    # - a scalar (if PikeValue ~ QuotedString or Number)
    #
    # $item[2] has a repetition, so it is a reference to an array of
    # PikeMappingFurtherPair's. Since PikeMappingFurtherPair just
    # returns a PikeMappingPair (see $item[1]), then $item[2] is
    # a reference to an array where each element is, in turn, a
    # reference to an array of two elements.
    #
    # Since we are going to return an hash here, we create a reference
    # to an hash; to correctly unroll the values of $item[1] and
    # $item[2] we:
    # - simply dereference $item[1], hence unrolling the only hash
    #   pair the array contained
    # - we dereference $item[2], getting an array of arrays, and
    #   then we use map to further unroll the key/value pairs
    #
    # We then bubble up the outcome
    $return = { @{ $item[1] } , map( @$_ , @{ $item[2] } ) } ;
  }

PikeMappingPair:	QuotedString ':' PikeValue
  {
    # $item[1] is a scalar (QuotedString)
    # $item[3] is a PikeValue, hence:
    # - a reference to an array or hash (if Pikevalue ~ PikeStructure)
    # - a scalar (if PikeValue ~ QuotedString or Number)
    # We throw them up together as a single entity: a reference to an array
    $return = [ $item[1], $item[3] ] ;
  }

PikeMappingFurtherPair:	PikeStructureSeparator PikeMappingPair
  {
    # $item[2] is a PikeMappingPair, hence a reference to an array
    # containing a QuotedString (the first) and a PikeValue, hence:
    # - a reference to an array or hash (if Pikevalue ~ PikeStructure)
    # - a scalar (if PikeValue ~ QuotedString or Number)
    $return = $item[2] ;
  }

PikeValue:		PikeStructure | QuotedString | Number
  {
    # $item[1] is:
    # - a reference to an array or hash (if PikeStructure)
    # - a scalar (if QuotedString or Number)
    $return = $item[1] ;
  }

Potete provarla su uno dei vostri file, magari uno di grosse dimensioni... ma se non ne avete uno a portata di mano potete anche accontentarvi di questo piccolo esempio:

[section1]
  onehash=([ "onekey" : "onevalue" ])
  hashtest=([ "key1" : "val1", "key2" : "val2" ])
  aohtest=({
    ([ "hash1key1": "hash1val1" ]),
    ([
      "hash2key1": "hash2val1",
      "hash2key2": "hash2val2",
    ]),
    })
  string=sample string
  onearray=({ "onevalue" })

E per testarlo avrete bisogno di uno script di test, giusto? Ve ne lascio uno molto sbrigativo, che legge la grammatica da un file che si chiama g3.txt e un file INI da mockup.ini, entrambi nella directory corrente --scrivere qualcosa di più serio è lasciato al lettore per esercizio.

#!/usr/bin/perl

# $Id: test.pl,v 1.8 2010/07/23 13:00:09 bronto Exp bronto $

use strict ;
use warnings ;

use Parse::RecDescent ;
use Data::Dumper ;

########################################################################
package AsIni ;

our %node ;
our $section ;
our $parmname ;
our $content ;

########################################################################
package AsIni::Parser ;

push @ARGV,0 unless @ARGV > 0 ;

eval { use constant DEBUG => $ARGV[0] } ;
die $@ if $@ ;

if (DEBUG >= 1) {
  $::RD_HINT  = 'true' ;
  $::RD_WARN  = 'true' ;

  $Data::Dumper::Indent = 1 ;

  if (DEBUG >= 2) {
    $::RD_TRACE  = 'true' ;
    $::RD_ERRORS = 'true' ;
  }
}

my $grammar = q{} ;
my $asini   = q{} ;
{
  local $/ ;
  undef $/ ;

  open my $grammarfh, '<', 'g3.txt' or die ;
  $grammar = <$grammarfh> ;


  open my $asinifh, '<', 'mockup.ini' or die ;
  $asini   = <$asinifh> ;
}

my $parser = Parse::RecDescent->new($grammar) ;
die if not defined $parser ;

my $parser_outcome = $parser->AsIni($asini) ;

print Dumper ( $parser_outcome ) if DEBUG >= 3 ;

print Dumper ( \%AsIni::node  )  if DEBUG >= 0 ;

Potete passare allo script un parametro, il debug level, da zero a tre per fargli emettere delle informazioni di debug sia dallo script stesso, sia da Parse::RecDescent. Il significato delle variabili RD_* è spiegato nel manuale.
Buon divertimento!!!

Bibliografia:

Crypt::FNA

dakkar — 2010-04-07T23:35:30+02:00

Anak's Fractal Numerical Algorithm for a new cryptography technology

a. Una nuova crittografia frattale

"Le nuvole non sono sfere, le montagne non sono coni, le costiere non sono cerchi e la corteccia non è liscia, né la luce viaggia su una linea retta"

così Benoit Mandelbrot ne "Il Mondo dei frattali"

Non potevo iniziare questo articolo senza citare l'incipit del bellissimo libro di Mandelbrot: in realtà i frattali che incontreremo nascono ben prima degli anni '70 del XX secolo ma procediamo per gradi... Chiariamo immediatamente che cosa è FNA:

Crypt::FNA è l'implementazione, in linguaggio Perl, di due distinti algoritmi che ho elaborato:

per la costruzione dell'insieme di una famiglia di curve frattali
per una crittografia basata su queste curve

b. Definizione dell'insieme di curve frattali {F}

"Il caso favorisce solo la mente preparata"

Louis Pasteur

Immaginate la complessità, a livello computazionale, di un algoritmo per la costruzione della curva di Koch che segua l'idea del suo creatore e cioè:

prendi un segmento... e fin qui
dividilo in tre... e fin qui
elimina il segmento mediano... mmmh...
congiungi i due punti mediani con un altro in modo da avere un triangolo equilatero... mmmmhh
itera il procedimento su ogni segmento.... Mumble... complesso, considerato poi che per ogni segmento occorre, dopo il disegno, rimuovere una parte, calcolare le coordinate dell'altro vertice e così via...

Se avessi implementato questo algoritmo per la costruzione della curva di ordine n, avrei dovuto, necessariamente, calcolare tutte le curve da 1 a n-1. Dovevo semplificare...

La proprietà fondamentale di questa curva, come pure di tante altre curve frattali, è l'autosimilitudine.

Ragioniamo inizialmente sulla curva di Koch per poi estendere i risultati.

Indicando quindi con:

Ro:	il numero di parametri della base (4 nel caso della curva di Koch)
r:	l'ordine della curva
an_n:	numero angoli della curva di ordine n

Possiamo stabilire che il numero di angoli (an) della curva di ordine n è:

an_n=Ro^r

Riportiamo ora gli angoli dei vari ordini in una costruzione a triangolo:

                                     0
                               0, 60, -60, 0
       0, 60, -60, 0, 60, 120, 0, 60, -60, 0, -120, -60, 0, 60, -60, 0

Vi ricorda qualcosa? Notiamo la somiglianza con la costruzione del Triangolo di Tartaglia:

                                     1
                                  1     1
                               1     2     1
                            1     3     3     1
                         1     4     6     4     1

Questo triangolo riporta la disposizione triangolare dei coefficienti binomiali, ossia dei coefficienti dello sviluppo del binomio (a+b) elevato ad una qualsiasi potenza n.

La cosa che a noi interessa è che ogni numero del triangolo è ottenuto come somma delle due corrispondenti al rigo superiore: osserviamo che possiamo esprimere la proprietà di auto-similitudine della curva di Koch grazie ad una costruzione simile, combinando tra loro i valori della base e poi con quelli derivati dalla combinazione e così via iterando il procedimento.

In questo caso, per Ro=4, abbiamo questa situazione:

riga per r=0 -> 0 + 0 = 0

riga per r=1 -> 0 + 0 = 0; 0 + 60 = 60; 0 - 60 = -60; 0 + 0 = 0

riga per r=2 ->
a. 0 + 0 = 0; 0 + 60 = 60; 0 - 60 = -60; 0 + 0 = 0
b. 60 + 0 = 60; 60 + 60 = 120; 60 - 60 = 0; 60 + 0 = 60
c. -60 + 0 = -60; -60 + 60 = 0; -60 - 60 = -120; -60 + 0 = -60
d. 0 + 0 = 0; 0 + 60 = 60; 0 - 60 = -60; 0 + 0 = 0

Iterando il procedimento, otteniamo proprio gli angoli della curva di ordine n.

Sembra però che per identificare gli angoli della curva di ordine n sia ancora necessario procedere all'identificazione degli angoli di tutte quelle con ordine <n.

Continuiamo ad osservare, scrivendo la successione degli angoli come gli elementi di un vettore:

             a(0)  =  a(0) + a(0)
             a(1)  =  a(0) + a(1)                I   GRUPPO
             a(2)  =  a(0) + a(2)
             a(3)  =  a(0) + a(3)
             ----------------------------------------------
             a(4)  =  a(1) + a(0)
             a(5)  =  a(1) + a(1)                II  GRUPPO
             a(6)  =  a(1) + a(2)
             a(7)  =  a(1) + a(3)
             ----------------------------------------------
             a(8)  =  a(2) + a(0)
             a(9)  =  a(2) + a(1)                III GRUPPO
             a(10) =  a(2) + a(2)
             a(11) =  a(2) + a(3)
             ----------------------------------------------
             a(12) =  a(3) + a(0)
             a(13) =  a(3) + a(1)                IV  GRUPPO
             a(14) =  a(3) + a(2)
             a(15) =  a(3) + a(3)

Abbiamo così le somme per identificare i vari angoli di inclinazione dei segmenti approssimanti la curva...
Scritte le relazioni in questo modo, possiamo osservare chiaramente la proprietà dei due addendi che forniscono l'angolo n-esimo:

il primo addendo è il gruppo o ramo su cui si itera il procedimento di costruzione.

Il secondo addendo è la posizione dell'angolo che stiamo calcolando nell'ambito di quel ramo.

Il gruppo cui appartiene l'angolo k-esimo possiamo indicarlo così nel formalismo del Perl:

G(k) = int(k/Ro)

La posizione dell'angolo k-esimo nel gruppo è invece:

P(k) = k-int(k/Ro) = k-G(k)

In definitiva, il valore della direzione k-esima sarà:

a(k)=a(G(k)) + a(P(k)) ⁽¹⁾

Notiamo che questa relazione è generale, indipendente dal numero di parametri base della curva. In quella di Koch abbiamo una base di cardinalità pari a 4 ma non è necessariamente così.

Con questa relazione diventa semplice ricavare il grafico della curva, potendone calcolare le direzioni dei segmenti approssimanti ad un certo ordine ed implementando poi un sistema di turtle graphics per il tracciamento:

            while ($k<$Ro**$r) {
                 $a[$k]=$a[int($k/$Ro)]+$a[$k-int($k/$Ro)];
                 $k++
            }

Indichiamo quindi con {F} l'insieme delle curve le cui direzioni dei segmenti approssimanti sono ottenute mediante la relazione (1). {F} ha una dimensione di Hausdorff compresa tra 1 e 2 (con piccole varianti possono calcolarsi anche quelle con dimensione minore di 1, come la polvere di Cantor) e cardinalità infinita, come facilmente rilevabile osservando il numero di parametri genitore possibili.

c. Grafico di alcune curve di {F}

Di seguito alcuni grafici realizzati tramite il metodo make_fract di Crypt::FNA che implementa l'algoritmo appena descritto.

(56,-187, 215, 64)

(0,90,-60,-90,60)

(56,-77,215,-64,60)

(56,-177,225,-164)

d. Algoritmo di crittografia basato su una curva dell'insieme {F}

"Il più nobile dei piaceri è la gioia di capire"

Leonardo da Vinci

Abbiamo quindi incontrato, spero piacevolmente, questi strani enti autosimili ma il mio desiderio è di applicarli, creando nel contempo, tecnologia.

Anni addietro mi sono interessato di crittografia, sviluppando un sistema adatto a cifrare stringhe ASCII. Adesso volevo usare le curve {F} in modo da criptare i files più disparati.

Il ragionamento seguito per giungere a questo scopo è il seguente.

I dati sono memorizzati in byte: qualunque tipo di file vada ad aprire, il suo contenuto è certamente una sequenza ben precisa di byte. Un byte è costituito da 8 bit, per cui il suo valore deve appartenere all'insieme degli interi compresi tra 0 e 255 (256 elementi complessivamente). Seguo quindi la curva frattale scelta, dell'insieme {F}, per un numero di vertici uguale a quella del valore del byte da criptare. Le coordinate cartesiane di quel vertice rappresentano il crittogramma di quel ben preciso byte.

Qualcuno potrebbe domandarsi perché non una funzione y=f(x) qualsiasi? La risposta è che i grafici delle funzioni y=f(x) non hanno un andamento notevolmente irregolare come nel caso dei frattali ed è proprio questa irregolarità a rendere maggiormente complessa la crittoanalisi. In altre parole, i frattali appartenenti ad {F} non essendo frutto di una funzione matematica, bensì di un algoritmo, non sono dotati di UNA relazione "singola" che permetta di calcolarne le coordinate di ogni punto. Ho calcolato che la "visibilità diretta", dati k angoli e base di cardinalità ro è: ro^2+(k-int(k/ro)).

Le curve {F} hanno quindi un andamento che, in generale, si conosce solo calcolandolo ma lo si può calcolare solo se sono noti i parametri Ro genitori che sono parti fondamentali della chiave: è proprio in questo il cuore del sistema crittografico. Come altri sistemi di cifratura simmetrici, ad esempio il DES ed AES, FNA ha chiave segreta ma a differenza dei predetti Data Encryption Standard (che ha una chiave di 56 bit) ed Advanced Encryption Standard (che ha una chiave compresa tra i 128 ed i 256 bit), Fractal Numerical Algorithm ha una chiave in bit lunga quanto si vuole: non ci sono restrizioni sul numero e valore delle direzioni della base Ro.

L'attento lettore avrà forse notato che il byte "0" produce, nel crittogramma, ripetizione nei valori (avanzando di 0 vertici sulla curva): alla crittoanalisi, ove ci fossero coppie di coordinate uguali e consecutive, identificherei tutti i bytes di valore "0". Ho evitato questo comportamento, procedendo sempre e comunque in avanti sulla curva: crittografato il valore di un byte nelle cartesiane del vertice k-esimo, si riparte dal successivo k+1-esimo. Ho poi ulteriormente modificato l'algoritmo, introducendo il cosiddetto "magic number", un altro parametro, segreto, che istruisce il sistema a saltare un certo numero di vertici della curva frattale, in modo da far perdere le tracce del percorso seguito...

In definitiva:

criptare

Ogni byte viene crittografato mediante le coordinate del vertice della curva frattale, ottenuto partendo dal successivo a quello precedentemente valutato, saltando di un numero ulteriore di vertici uguale al magic number più il valore del byte da crittografare.

decriptare

Si segue la curva frattale verificando, di vertice in vertice, che le coordinate corrispondano a quelle del crittogramma. Il valore del byte originale viene ricostruito avendo contato quanti vertici si sono succeduti per arrivare all'uguaglianza dei due valori, dall'ultima uguaglianza incontrata. Il numero di vertici, ridotto del magic number sommato all'unità, rappresenta il valore del byte n-esimo.

e. Crypt::FNA i metodi della classe

La libreria Crypt::FNA è costituita da una classe principale ed una accessoria per la validazione dell'istanza. La classe principale, in Anakrypt/FNA.pm, contiene il codice per l'istanziazione dell'oggetto frattale oltre i metodi per la crittografia ed il disegno della particolare approssimazione alla curva dell'insieme {F}. L'altra classe, in Anakrypt/FNA/Validation.pm, riporta: i valori di default per una istanziazione veloce dell'oggetto; i controlli di coerenza sui valori degli attributi in fase di istanziazione; la cattura degli errori in scrittura e lettura sui files di lavoro coinvolti.

Crypt::FNA comprende quattro metodi:

new
- per l'istanziazione di un nuovo oggetto FNA
make_fract
- per il disegno della curva frattale utilizzata da FNA
encrypt_file
- per calcolare il crittogramma, secondo la curva scelta, di un file
decrypt_file
- per ricostruire il file partendo dal crittogramma
encrypt_scalar
- per calcolare il crittogramma di un testo

Vediamo ora nel dettaglio i metodi e relativa sintassi

e.1 Il metodo "new"

Questo metodo ha due diverse modalità per l'istanziazione dell'oggetto:

            1.	my $krypto=FNA->new();
            2.	my $krypto=FNA->new(
                     {
                           r=> 7,
                           angle =>  [56,-187, 215,-64],
                           square => 4096,
                           background => [255,255,255],
                           foreground => [0,0,0],
                           magic => 3
                     }
                );

Con la prima modalità, l'oggetto viene creato con i valori standard, fissati nella classe "Crypt::FNA::Validation". Nella seconda modalità, si specificano tutti o parte dei parametri dell'oggetto che ora vedremo in dettaglio.

e.1.1 Il parametro "r": ordine della curva di {F}

Indica il livello di approfondimento nel calcolo della curva. E' un numero maggiore di zero, non necessariamente intero. Indicato con Ro il numero di angoli base della struttura autosimile, il numero di segmenti costituenti la curva è dato da Ro**r.

Valore di default: 7

e.1.2 I parametri "angle": direzioni dei segmenti base della curva di {F}

Sono gli angoli cui si applica l'algoritmo di ricorsione: su questi angoli si determina la struttura base autosimile della curva di {F}. Gli angoli sono espressi nel sistema sessadecimale, con valori compresi tra -360 e 360 (ovvero da 0 a 360).

Valore di default: (56,-187, 215,-64)

e.1.3 Il parametro "square": lato del quadrato dove verrà disegnata/calcolata la curva di {F}

E' la lunghezza del lato del quadrato contenitore della curva. Square non solo ha importanza per la (eventuale) rappresentazione grafica, ma anche per la crittografia, poiché viene utilizzato per calcolare la lunghezza del lato di della curva (di è proporzionale a square/Ro**r)

Valore di default: 4096

e.1.4 Il parametro "background": colore di fondo per il disegno della curva di {F}

E' il colore RGB di fondo del file PNG contenente il disegno della curva. La notazione è decimale, quindi con valori che vanno da 0 a 255.

Valore di default: (255,255,255)

e.1.5 Il parametro "foreground": colore di primo piano per il disegno della curva di {F}

E' il colore RGB del tratto nel file PNG contenente il disegno della curva. La notazione è decimale, quindi con valori che vanno da 0 a 255.

Valore di default: (0,0,0)

e.1.6 Il parametro "magic number": per la crittografia discreta

Indica il numero di vertici della curva da saltare in fase di cifratura e decifratura: essendo l'algoritmo, una funzione continua sui vertici, saltandone alcuni questa resta continua su punti isolati dell'insieme dei vertici (da cui "discreta").

Valore di default: 3

e.2 Il metodo "encrypt_file"

I metodi encrypt_file e decrypt_file, sono la summa: rendono utile mediante applicazione, la matematica delle curve di {F}. Questo metodo realizza un'operazione ben precisa: cripta il file di input in quello di output.

La sintassi è:

        $krypto->encrypt_file($name_plain_file,$name_encrypted_file)

Il file di input di qualsivoglia formato sarà letto e cifrato, tramite la curva {F}.

e.3 Il metodo "decrypt_file" I metodi decrypt_file ed encrypt_file, sono la summa: rendono utile mediante applicazione, la matematica delle curve di {F}. Questo metodo realizza un'operazione ben precisa: decripta il file di input (che è quello di output del metodo encrypt_file) in quello di output (che è quello di input del metodo encrypt_file).

La sintassi è:

       $krypto->decrypt_file($name_encrypted_file,$name_decrypted_file)

Il file di input sarà letto e decodificato, tramite la curva {F}, nel file di output.

e.4 Il metodo "encrypt_scalar"

Il metodo encrypt_scalar cifra stringhe: il risultato dell'operazione di cifratura è un vettore contenente il crittogramma.

La sintassi è:

           @encrypted_scalar=$krypto->encrypt_scalar($this_string)

Questo metodo è particolarmente utile per il salvataggio delle password in un'applicazione. Come metodologia operativa, supponiamo di avere un database utenti di un'applicazione web. Salvando nel database le password criptate, l'eventuale violazione della tabella non porterà alla violazione delle password. Il sistema, in fase di login utente, prenderà la password digitata e la cripterà, mediante il metodo encrypt_scalar, verificando la corrispondenza con il valore criptato e non con quello in chiaro (che non sarà stato salvato).

Il programmatore che implementi un salvataggio password farà bene a implementare quello che viene definito "salt", ovvero un "sale" per la password. Ricordo brevemente che il "salt" è una stringa random che viene aggiunta al dato da criptare, in modo che un brute force a dizionario non produca risultati.

Crypt::FNA non implementa, allo stato attuale, un metodo per decifrare gli scalari criptati poiché ho ritenuto che la sola cifratura, per usi mirati al salvataggio password, fosse sufficiente. In ogni caso, con un piccolo artificio, è possibile decifrare anche gli scalari utilizzando il metodo decrypt_file e scrivendo lo scalare in un file in memoria volatile (possiamo evitare di sollecitare il file system per questa operazione :)).

Di sequito il codice (inserito nel file di test della lib):

# hack ricostruzione stringa
     my $stringa_in_chiaro='questa è una prova';
     my @encrypted_scalar=$krypto->encrypt_scalar($stringa_in_chiaro);
     for(@encrypted_scalar) {print $_."\n"}
     # ricostruzione stringa
          my ($fh_testo_criptato,$file_criptato);
          open $fh_testo_criptato, '>',\$file_criptato or die "err. scrittura file in memoria\n";
               for (@encrypted_scalar) {print $fh_testo_criptato $_."\n"}
          close $fh_testo_criptato;
          my ($fh_testo_decriptato,$stringa_decriptata);
          $krypto->decrypt_file(\$file_criptato,\$stringa_decriptata);
     # end ricostruzione stringa
# end hack

$stringa_decriptata contiene il valore della stringa in chiaro.

e.5 Il metodo "make_fract"

Questo metodo è senz'altro il più suggestivo e permette di "toccare" le curve che verranno poi applicate negli algoritmi crittografici. Per il programmatore può essere utile, nella propria applicazione, mostrare la curva, ad esempio in un ipotetico pannello di controllo per la gestione delle password o file criptati in attachment a moduli inviati per posta elettronica e salvati sul server.

Il file grafico di output è in formato PNG (Portable Network Graphic), fruibile da un qualunque browser come dai più diversi software di grafica.

La sintassi è:

			$krypto->make_fract($pngfile,$zoom)

$pngfile è il nome del file png - senza estensione "png" che viene inserita automaticamente
$zoom è la scala del disegno - maggiore di zero. Valore di default: 1
L'immagine prodotta è contenuta nel quadrato di lato square

f. Il codice di esempio: fnatest.pl

(Per motivi di spazio ho rimosso l'hack per la ricostruzione stringa, già illustrato nel par. e.4)

# package: Anak Cryptography with Fractal Numeric Algorithm
# autore: Mario Rossano aka Anak
# www.netlogicalab.com, www.netlogica.it
# software@netlogicalab.com; software@netlogica.it
# FILE DI ESEMPIO

# caricamento moduli moduli
    use strict;
    use warnings;
    use Crypt::FNA;
# fine caricamento moduli

    # fractals examples
        #angle => [0,90,-60,-90,60]    # chiave
        #angle => [0,90,60,-90,120]    # scorpione
        #angle => [0,60,-60,0]         # von Koch
        #angle => [56,-187,215,64]     # nebulosa gassosa
        #angle => [66,-177,205,64]     # ramo sulla spiaggia
        #angle => [0,80,60,-90,120]    # maschera
   # end fractals examples

   # METODI

        # ISTANZA DI UN OGGETTO FNA
             my $krypto=FNA->new(
                  {
                       r=> "6a",
                       angle =>  [0,90,-60,-90,60],
                       square => 4096,
                       background => ["b",0,0],
                       foreground => ["a255",255,255],
                       magic => 2
                  }
             );
             my $krypto2=FNA->new();

        # GRAFICO DI UN FRATTALE
             $krypto->make_fract("fractal1","1a"); # nome file png e zoom
             $krypto2->make_fract("fractal2",1);   # nome file png e zoom

        # CIFRATURA DI FILE
             $krypto->encrypt_file("test.txt","test.fna");

        # DECIFRATURA DI FILE
             $krypto->decrypt_file("test.fna","test_rebuild.txt");

        # UNIONE DEI METODI (IPERCRITTOGRAFIA)
             $krypto->encrypt_file("test.txt","test2.fna");
                  $krypto2->encrypt_file("test2.fna","test3.fna");
                  $krypto2->decrypt_file("test3.fna","test2_rebuild.fna");
             $krypto->decrypt_file("test2_rebuild.fna","test3_rebuild.txt");

        # CIFRATURA DI STRINGHE
             my @encrypted_scalar=$krypto->encrypt_scalar("questa è una prova");
             foreach my $encrypted_scalar(@encrypted_scalar) {
                  print $encrypted_scalar."\n"
             }

        # INTERCETTAZIONE ERRORI (SALVATI NEL VETTORE  $krypto->message)
             $krypto->make_fract("fractal1","3a"); # nome file png e zoom
             my @errors=@{$krypto->message};
                  foreach my $errors(@errors) {
                       print "> 1-".$errors."\n"
             }
             @errors=@{$krypto2->message};
                  foreach my $errors(@errors) {
                       print "> 2-".$errors."\n"
             }
exit

Sono volutamente riportati errori di inizializzazione nel file di test, per popolare il vettore @errors.

g. Il codice del package FNA.pm

"La filosofia è scritta in questo grandissimo libro che continuamente ci sta aperto innanzi agli occhi, ma non si può intendere se prima non s'impara a intender la lingua, e conoscere i caratteri, ne' quali è scritto. Egli è scritto in lingua matematica, e i caratteri son triangoli, cerchi, ed altre figure geometriche, senza i quali mezi è impossibile a intenderne umanamente parola; senza questi è un aggirarsi vanamente per un oscuro laberinto"

così Galileo Galilei nel "Saggiatore"

Il package nelle prime righe riporta le indicazioni di rito, con l'indicazione del titolo, autore e numero di versione.

# package: Anak Cryptography with Fractal Numeric Algorithm
# author: Mario Rossano aka Anak
# www.netlogicalab.com, www.netlogica.it
# software@netlogicalab.com, software@netlogica.it
# LIBRERIA

package FNA;

# caricamento lib
    use strict;
    use warnings;
    use Crypt::FNA::Validation;
# fine caricamento lib

our $VERSION = '0.01';
use constant pi => 3.141592;

Una piccola nota: il valore di pi greco è stato impostato come valore costante, approssimato indipendentemente dalla piattaforma utilizzata, poiché viene utilizzato per il calcolo della curva su cui poggia il processo crittografico. E' necessario che il numero, fino all'ultimo decimale che si è scelto di utilizzare, sia quindi sempre lo stesso, pena l'impossibilità di reversibilità dell'operazione crittografica.

Di seguito il codice che implementa i metodi disponibili nella classe. Il primo è "new", che serve a creare l'oggetto con cui si andrà ad operare. Vediamo che, dopo le chiamate per l'impostazione degli attributi così come da script parent (r, angle, square, background, foreground, magic), viene creato l'oggetto "$validate" come istanza di Crypt::FNA::Validation. Su $validate viene applicato il metodo "control_new_fna" (cui si passa l'oggetto $self, ovvero l'istanza di Crypt::FNA creata nel parent), in modo da verificare la coerenza di tutti i valori di inizializzazione. Vedremo in seguito qualche dettaglio su FNA::Validation. "control_new_fna" effettua la verifica dei valori, mediante regular expression come argomento di istruzioni condizionali e, in caso di assegnazione non coerente, come ad esempio potrebbe essere assegnare "-34" o "pippo" all'ordine della curva "r" (che invece è un numero positivo), carica, se possibile, il valore di default del parametro, procedendo comunque con l'elaborazione.

Vediamo che in caso di errore, dallo script parent è accessibile il valore dell'attributo "message", un array contenente i codici restituiti da Crypt::FNA::Validation, ad uso del programmatore per una eventuale gestione.

# metodi ed attributi

sub new {
	my $class = shift;
	my $init  = shift;
	my $self={};

	bless $self,$class;

	$self->r($init->{r});
	$self->angle($init->{angle});
	$self->square($init->{square});
	$self->binary_mode($init->{binary_mode});
	$self->background($init->{background});
	$self->foreground($init->{foreground});
	$self->magic($init->{magic});
	$self->message($init->{message});

	my $validate=Crypt::FNA::Validation->new({intercept => $self});
	$validate->method_new_fna($self);

	return $self
}

Tralascio qui il codice degli accessor in modo da riservare maggiore spazio ai metodi.

La subroutine per la cifratura di un file è quella riportata di seguito. Qui trovano compimento gli algoritmi descritti di calcolo della curva frattale unitamente a quello di crittografia.

Oltre all'oggetto, sono passati al metodo il nome del file da criptare: $name_plain_file ed il nome del file dove sarà stampato il crittogramma: $name_encrypted_file.

La chiamata al metodo init_geometry effettua le operazioni di calcolo delle coordinate di partenza per il tracciamento della curva e della lunghezza del segmento in relazione al quadrato contenitore. Questo dato è importante ai fini del processo di crittografia poiché, come sopra riportato, verte sulla trasformazione del byte nel numero complesso delle coordinate del vertice n-esimo.

Al metodo init_geometry viene passato, oltre l'oggetto, il parametro $ro che, come sappiamo, è la lunghezza del segmento di curva.

$ro viene assegnato mediante calcolo effettuato tramite applicazione del metodo set_starting_angle. set_starting_angle restituisce, oltre che $ro, anche @initial_angle contenente gli angoli di inizializzazione convertiti in radianti (necessari come argomento alle funzioni seno e coseno).

Si invoca il metodo set_starting_angle, assegnando $ro e @initial_angle per poi passare ad init_geometry.

Per rendere maggiormente complessa la crittoanalisi, di, calcolato sulla base dell'attributo square , viene incrementato del magic_number. Per analogo motivo, le coordinate iniziali per il tracciamento e calcolo sono rapportate al magic_number che fa parte della chiave a pieno titolo, unitamente alla base Ro.

Sono poi inizializzate tre variabili locali: $this_byte, $byte_dec e $byte_pos:

$this_byte è utilizzato nel ciclo di lettura del file da cifrare
$byte_dec è il valore decimale di $this_byte
$byte_pos è la posizione di $this_byte nel file da criptare

sub encrypt_file {
    my $self=shift;
    my $name_plain_file=shift;
    my $name_encrypted_file=shift;

    (my $ro,my @initial_angle)=$self->set_starting_angle();
    (my $nx,my $ny,my $di)=$self->init_geometry($ro);

    $di+=$self->magic;
    $nx=$nx/$self->magic; # ascissa iniziale
    $ny=$ny/$self->magic; # ordinata iniziale;

    my ($this_byte,$byte_dec);
    my $byte_pos=0;

    my ($fh_plain,$fh_encrypted);
    open $fh_plain,'<',$name_plain_file or do {
        push(@{$self->{message}},7);
        return
    };
        binmode $fh_plain;
        open $fh_encrypted,'>',$name_encrypted_file or do {
            push(@{$self->{message}},8);
            return
        };

Qualora l'apertura del file di input e/o output non abbia successo, viene eseguito il codice alternativo (or do) per cui il contenitore dei codici di errore, il valore dell'attributo message, viene aggiornato e l'elaborazione attinente l'apertura non viene eseguita.

Definiti quindi gli attori della sub, inizia l'iterazione, mediante ciclo while dal primo byte all'ultimo, byte a byte.

Dopo aver letto (read) il byte corrente ed assegnatone il valore decimale alla variabile $byte_dec, si aggiunge a questo il valore definito dal magic_number per un motivo che sarà chiaro tra poco...

Con la chiamata alla funzione successiva, crypt_fract, non facciamo altro che seguire la curva frattale, partendo dal vertice successivo all'ultimo processato e saltando un numero di vertici pari al valore del byte aumentato del magic number. Le coordinate di questo vertice sono il crittogramma di quel ben preciso byte.

I crittogrammi sono riportati, man mano che vengono assegnati, nel file $fh_encrypted: una riga per ogni singola coordinata in modo da avere, alla fine del processo, una sequenza di numeri incolonnati.

        while (!eof($fh_plain)) {
            read($fh_plain,$this_byte,1);

            $byte_dec=unpack('C',$this_byte);
            $byte_dec+=$self->magic+1;

            ($nx,$ny,$byte_pos)=$self->crypt_fract($ro,1,$di,$nx,$ny,$byte_dec,$byte_pos);
            print $fh_encrypted $nx."\n".$ny."\n"
        }
        close ($fh_encrypted);
    close ($fh_plain);
    @{$self->angle}=@initial_angle
}

L'ultima operazione è la riassegnazione all'oggetto degli angoli di inizializzazione nel sistema sessadecimale. Questo è necessario poiché il vettore, durante l'applicazione del metodo, è stato popolato con gli angoli di inclinazione per il tracciamento, tutti espressi in radianti e la mancata riassegnazione produrrebbe un comportamento anomalo da parte degli altri metodi, eventualmente invocati da parte dello script parent.

La subroutine successiva, encrypt_scalar, effettua la stessa operazione della subroutine encrypt_file, restituendo in uscita un array (e non un file) che è il crittogramma del testo. Abbiamo quindi:

in luogo del READ, un SUBSTRing per la lettura del singolo carattere
un ciclo sulla lunghezza della stringa, anziché sulla fine del file
un push nell'array @encrypted contenente le coordinate del vertice calcolato (restituito allo script parent a fine ciclo insieme a tutti gli altri) in luogo del print nel file criptato

Le chiamate alla init_geometry e set_starting_angle effettuano, chiaramente, le identiche operazioni di calcolo in modo da avere le coordinate iniziali per il calcolo/tracciamento e la lunghezza del segmento di curva.

Come nel caso della subroutine encrypt_file, un'ulteriore complicazione per i crittoanalisti eventualmente impegnati a decrittare le informazioni, è che la lunghezza del segmento di viene incrementata del valore del magic number. Inoltre le coordinate iniziali per il tracciamento della curva vengono anch'esse legate al magic number.

sub encrypt_scalar {
    my $self=shift;
    my $string=shift;

    (my $ro,my @initial_angle)=$self->set_starting_angle();
    (my $nx,my $ny,my $di)=$self->init_geometry($ro);

    # incremento del magic_number in modo da rendere maggiormente complessa
    # l'individuazione della parte di chiave "di" alla crittoanalisi
    $di+=$self->magic;
    $nx=$nx/$self->magic; # ascissa iniziale
    $ny=$ny/$self->magic; # ordinata iniziale;

    my $char_code;
    my $char_pos=0;
    my @encrypted;

    for (split(//,$string)) {
        $char_code=unpack('C',$_);
        $char_code+=$self->magic+1; # maschero il codice carattere

        # chiamata ricorsiva
        ($nx,$ny,$char_pos)=$self->crypt_fract($ro,1,$di,$nx,$ny,$char_code,$char_pos);
        push(@encrypted,($nx,$ny))
    }
    @{$self->angle}=@initial_angle;
    return (@encrypted)
}

La subroutine decrypt_file fa esattamente cosa ci si aspetta: ricostruisce il file originale del crittogramma.

Vediamo quali variabili sono coinvolte nel processo:

il primo parametro è, come sempre, l'oggetto cui afferisce la particolare istanza nello script parent
il successivo è il nome del file criptato: $name_encrypted_file
infine vi è l'impostazione del filename che conterrà la ricostruzione del file originale: $name_decrypted_file

Effettuate le chiamate alle ormai note subroutines init_geometry e set_starting_angle, vengono inizializzate le altre variabili locali che corrispondono alle omonime delle subroutines encrypt_file ed encrypt_scalar, utilizzate nel processo di percorso sulla curva e calcolo delle coordinate dei vertici successivi.

Come nelle subroutine encrypt_file ed encrypt_scalar, per ovvi motivi di reversibilità, la lunghezza del segmento di viene incrementata del valore del magic number. Inoltre le coordinate iniziali per il tracciamento della curva vengono anch'esse legate al magic number.

Per ricostruire il file originale, si scandisce il file criptato, leggendo le coordinate lì salvate, quindi si segue la curva {F} calcolando le coordinate cartesiane dei vertici, verificando, nel contempo, l'uguaglianza con le coordinate lette dal crittogramma. Abbiamo quindi due cicli annidati: uno esterno sul crittogramma ed uno interno sulla curva. Nel ciclo esterno leggiamo due righe alla volta poiché nel file criptato le coordinate dei vertici occupano ognuna una riga (quindi leggiamo ascissa ed ordinata). Nel ciclo interno, una volta verificata l'uguaglianza delle coordinate del vertice processato con quelle del crittogramma, il valore del byte corrisponderà al numero di vertici processati, rispetto all'ultima uguaglianza, diminuito del magic number ($self->magic) e diminuito dell'unità (poiché quando si cripta, si riparte sempre dal vertice successivo): $this_byte_dec=$this_vertex-$from_vertex-1-$self->magic. Come si evince, $from_vertex è il vertice corrispondente alle ultime coordinate trovate.

Tanto premesso, le variabili (locali) coinvolte sono:

$from_vertex contiene il valore del posizionale dell'ultimo vertice processato per il quale si è verificata un'uguaglianza
$vertex è il contatore del ciclo interno, punto di partenza per il calcolo delle coordinate dei vertici di rispetto all'ultima uguaglianza trovata {F}
$this_vertex è il posizionale del vertice di {F} di cui si sono calcolate le coordinate da verificare per l'uguaglianza
$this_byte_dec il valore del byte nel sistema decimale, calcolato come differenza del posizionale del vertice di {F} valutato attualmente, rispetto all'ultimo posizionale per cui ci sia stata uguaglianza di coordinate tra crittogramma e coordinate del vertice della curva
$this_byte è il valore del byte da scrivere nel file originale
$x_coord è l'ascissa del vertice della curva {F}
$y_coord è l'ordinata del vertice della curva {F}

Una volta verificata l'uguaglianza e calcolato il valore del byte, lo si scrive nel file di output $fh_decrypted dopo aver salvato in $from_vertex il valore di $this_vertex, come sopra indicato.

In caso di errore in apertura dei files coinvolti, come nel caso del metodo encrypt_file, verrà inserito in coda all'array $self->message il codice di errore riscontrato.

sub decrypt_file {
    my $self=shift;
    my $encrypted_filename=shift;
    my $decrypted_filename=shift;

    (my $ro,my @initial_angle)=$self->set_starting_angle();
    (my $nx,my $ny,my $di)=$self->init_geometry($ro);

    # incremento del magic_number in modo da rendere complessa la crittoanalisi
    # basandosi sulla lunghezza di
    $di+=$self->magic;
    $nx=$nx/$self->magic; # ascissa iniziale
    $ny=$ny/$self->magic; # ordinata iniziale;

    my $from_vertex=0;
    my ($this_byte,$this_byte_dec,$this_vertex,$x_coord,$y_coord);

    my ($fh_encrypted,$fh_decrypted);
    open $fh_encrypted,'<',$encrypted_filename or do {
        push(@{$self->{message}},9);
        return
    };
        open $fh_decrypted,'>',$decrypted_filename or do {
            push(@{$self->{message}},10);
            return
        };
            binmode $fh_decrypted;

             while (!eof($fh_encrypted)) {
                $x_coord=<$fh_encrypted>;$y_coord=<$fh_encrypted>;
                chop($x_coord,$y_coord);
                # ho usato chop perchè l'ultimo carattere è certamente \n e chop è più veloce di chomp

                for (my $vertex=$from_vertex;$vertex<256+$from_vertex+$self->magic+1;$vertex++){
                    ($nx,$ny,$this_vertex)=$self->crypt_fract($ro,1,$di,$nx,$ny,1,$vertex);
                    if ($nx eq $x_coord && $ny eq $y_coord) {
                        # qui ricavo il byte come posizione rispetto
                        # alla posizione trovata precedentemente
                        $this_byte_dec =$this_vertex-$from_vertex-$self->magic-1;

                        $this_byte=pack('C',$this_byte_dec);
                        print $fh_decrypted $this_byte;

                        #imposto il from per ripartire il ciclo for dal punto giusto alla
                        # prossima iterazione del while, quando ripartirà il for

                        $from_vertex=$this_vertex;
                        last
                    }
                } # fine for
            } # fine ciclo while
        close $fh_decrypted;
    close $fh_encrypted;
    @{$self->angle}=@initial_angle
}

Il metodo seguente, make_fract, non è strutturale alle funzionalità crittografiche ma non potevo esimermi dal realizzarlo, poiché è dal desiderio di ottenere il grafico di queste bellissime curve che è nata la sfida e l'algoritmo. Tramite make_fract si stampa il grafico di {F} in un file PNG (Portable Network Graphics), formato fruibile da tutti i browser (non testuali) e dai più disparati software di grafica nei diversi sistemi operativi.

Qualora dallo script parent non venga invocato questo metodo, non sarà necessario caricare GD::Simple (ed implicitamente GD), quindi, per fruire delle funzionalità crittografiche, Crypt::FNA non ha dipendenze: è eseguibile anche su macchine dotate del solo interprete/compilatore Perl.

Le prime operazioni effettuate sono, come sempre, la lettura dei parametri, nella fattispecie: l'oggetto ($self), il nome del file di output ($png_filename nome del PNG destinatario del grafico di {F} di ordine n) ed infine il fattore di zoom della curva.

Una volta completata la prima serie di istruzioni, viene impostato l'oggetto e la geometria iniziale di disegno (init_geometry e set_starting_angle ormai ben noti).

Si controlla quindi la presenza della libreria GD::Simple nel calcolatore in uso, mediante eval che viene poi verificata tramite l'istruzione condizionale if che, in caso di errore di caricamento, provvede a inserire in $self->message il codice di errore e a tornare allo script parent, consentendo il prosieguo dell'elaborazione residua.

Un'ulteriore verifica è quella sul fattore di zoom: nel caso in cui il valore sia non congruo (diverso da un numero positivo), viene assegnato il valore di default dalla classe Crypt::FNA::Validation. Per fare questo si istanzia $validate come oggetto Crypt::FNA::Validation e impostando, tramite il suo metodo new, nell'attributo intercept, il fattore di zoom passato dallo script parent. Una descrizione della classe Crypt::FNA::Validation esula dai limiti imposti all'articolo ma nulla vieta al lettore di aprire il source code :)

sub make_fract {
    my $self=shift;
    my $png_filename=shift;
    my $zoom=shift;

    # assegno coordinate iniziali del calcolo.
    # init_geometry usa set_starting_angle perchè "ro" e "angle"
    # iniziali vengono fuori da lì
    # posso quindi passarli direttamente, risparmiando un passaggio

    (my $ro,my @initial_angle)=$self->set_starting_angle();
    (my $nx,my $ny,my $di)=$self->init_geometry($ro);

    my $load_this_package=eval("require GD::Simple;");
    $load_this_package.='';
    if ($load_this_package eq '') {
        push(@{$self->{message}},16);
        return
    }

    #controllo zoom, solo valori numerici e > 0
      my $validate=Crypt::FNA::Validation->new({intercept => [$zoom,$self]});
      ($zoom,@{$self->message})=$validate->param_zoom_fna($self);
    #fine controllo zoom

Tramite il metodo new di GD::Simple, viene creata l'istanza $img.
L'immagine, contenuta in un quadrato di lato $self->square, è il nostro foglio da disegno.
Vengono inoltre impostati i colori di background e foreground, così come stabilito nell'istanza dell'oggetto Crypt::FNA nello script parent.

In un ciclo for sul numero degli angoli, vengono quindi calcolate le coordinate di ogni singolo vertice della curva, in modo tale che, tramite il metodo lineTo di GD::Simple, sarà possibile tracciarla.

Gli angoli sono in numero uguale al numero dei parametri genitore della curva, elevato all'ordine desiderato: maggiore è l'ordine, maggiore sarà l'accuratezza del grafico del frattale.

Questi sono calcolati mediante la function evaluate_this_angle, popolando man mano il vettore $self->angle e poi utilizzati per il disegno calcolando, in cascata, le coordinate dei vertici successivi. A questo metodo vengono passati l'indice $k corrispondente all'indice del vettore $self->angle da popolare in quel ciclo ed il numero di angoli base del frattale, $ro. Il metodo restituisce il valore dell'angolo k-esimo che va a popolare l'elemento di eguale indice del vettore $self->angle.
Inserito il valore dell'angolo nel vettore, viene passato l'indice $k al metodo evaluate_this_coords che restituisce le coordinate del prossimo punto della curva, unitamente al fattore di zoom ($zoom), alle coordinate dell'ultimo vertice processato ($nx,$ny) e alla lunghezza del segmento di curva ($di).
Calcolate le coordinate, queste vengono passate al metodo lineTo di GD::Simple per il tracciamento.

Le successive istruzioni, si occupano di tracciare il disegno di {F} nel file PNG. Tra i parametri passati ci sono infatti il nomefile: $png_filename (l'estensione ".png" è automaticamente inserita in fase di salvataggio) ed il fattore di zoom: $zoom già verificato.

Una volta completato il ciclo, si salva l'elaborazione nel file grafico.
Come in altre occasioni, qualora non sia possibile aprire il file in scrittura, viene aggiornato il contenuto di $self->message. In caso affermativo viene salvato il file png per gli usi previsti dallo script parent.

    my $img = GD::Simple->new($self->square,$self->square);
        $img->fgcolor(@{$self->background});              # foreground
        $img->bgcolor(@{$self->background});              # background
        $img->rectangle(0,0,$self->square,$self->square); # campisce il quadrato
        $img->fgcolor(@{$self->foreground});              # foreground

    $img->move($nx,$ny);

    for (my $k=0;$k<$ro**($self->r);$k++) {
        ${$self->angle}[$k]=$self->evaluate_this_angle($k,$ro) if $k>=$ro;
        ($nx,$ny)=$self->evaluate_this_coords($k,$zoom,$nx,$ny,$di);
        $img->lineTo($nx,$ny)
    }

    my $fh_pngfile;
    open $fh_pngfile,'>',$png_filename.'.png' or do {
        push(@{$self->{message}},11);
        return
    };
        binmode $fh_pngfile;
        print $fh_pngfile $img->png;
    close $fh_pngfile;
    @{$self->angle}=@initial_angle
}

Abbiamo fin qui esaminato i metodi principali della classe Crypt::FNA, vediamo ora quelli di "di servizio".

Il primo che incontriamo è set_starting_angle che, come già brevemente indicato, converte nel sistema radiante gli angoli passati dallo script parent, in fase di inizializzazione dell'oggetto (metodo new). Oltre a questo il metodo restituisce il numero di angoli base della curva {F}, $ro, dato necessario al calcolo che diversamente si perderebbe durante la popolazione di $self->angle oltre al vettore @initial_angle che re-inizializza $self->angle a fine elaborazione.

sub set_starting_angle {
    my $self=shift;
    my $ro=scalar(@{$self->angle});

    my @initial_angle;

    #conversione in radianti
    for (my $k=0;$k<$ro;$k++) {
        push(@initial_angle,${$self->angle}[$k]);
        ${$self->angle}[$k]=${$self->angle}[$k]*pi/180
    }
    return ($ro,@initial_angle)
}

Incontriamo poi il metodo init_geometry che calcola la lunghezza del lato di della curva {F}. Questa distanza è utilizzata sia nei processi di crittografia (encrypt_file ed encrypt_scalar) che di ricostruzione del dato (decrypt_file), come pure dal metodo di disegno (make_fract). Il lato della curva, inteso anche come distanza percorsa dalla tartaruga in fase di disegno (il turtle graphics), è un dato fondamentale e strutturale, poiché influenza direttamente le coordinate dei vertici utilizzate dai vari metodi della classe FNA.
Osserviamo come il valore di sia funzione dell'ampiezza del quadrato contenitore (di lato $self->square), del numero di parametri (angoli) genitori della curva ($ro) e dell'ordine (profondità di calcolo) della stessa ($self->r). Dopo il calcolo di di ($di) viene effettuata una verifica, implementata mediante ciclo while: se di risulta essere inferiore all'intero "5", di viene incrementato moltiplicandolo per sé stesso aumentato dell'unità. Si aggiunge 1 prima del prodotto (che diversamente consisterebbe in un'elevazione al quadrato di di) poiché se di fosse inferiore od uguale ad 1, lo script entrerebbe in un loop infinito. Una volta impostato il valore di, vengono fissate le coordinate di partenza per il disegno/calcolo della curva, ponendo l'origine al centro del quadrato contenitore. Questi valori vengono restituiti al metodo invocante.

sub init_geometry {
    my $self=shift;
    my $ro=shift;

    my $di=int(($self->square/$ro**$self->r)*10000)/5000;
    while ($di<5) {
        $di=$di*(1+$di)
    }
    my $nx=$self->square/2; # ascissa iniziale
    my $ny=$self->square/2; # ordinata iniziale
    return ($nx,$ny,$di)
}

Arriviamo quindi ad uno dei metodi di servizio più importanti del package: crypt_fract che viene invocato da tutti i metodi (escluso new) e chiama il fondamentale evaluate_this_angle come pure evaluate_this_coords, per il calcolo degli angoli della curva e coordinate dei relativi vertici. E' un vero e proprio anello di giunzione nel processo ricorsivo.

Tra i parametri passati al metodo (oltre allo "starting" - ro, zoom, di, nx, ny con i significati ormai noti) ci sono $value_dec e $pos: questi sono il valore decimale del byte (o l'ordinale del carattere) da crittografare e il vertice della curva da cui partire per il calcolo. Vengono restituiti al metodo invocante:

le coordinate del vertice corrispondente al byte o carattere (come già indicato, vengono "saltati" un numero di vertici pari al valore del byte o all'ordinale del carattere oltre ad un altro vertice più un numero di ulteriori vertici pari al magic number)
il vertice da cui ripartire per la successiva operazione di cifratura o decifratura, pari chiaramente al valore del $pos di ingresso e del "salto" effettuato lungo la curva {F}

Vedremo subito dopo la descrizione puntuale di evaluate_this_angle ed evaluate_this_coords.

sub crypt_fract {
    my $self=shift;
    my $ro=shift;
    my $zoom=shift;
    my $di=shift;
    my $nx=shift;
    my $ny=shift;
    my $value_dec=shift;
    my $pos=shift;

    for (my $k=$ pos;$k<($pos+$value_dec);$k++) {
        ${$self->angle}[$k]=$self->evaluate_this_angle($k,$ro) if $k>=$ro;
        ($nx,$ny)=$self->evaluate_this_coords($k,$zoom,$nx,$ny,$di)
    }
    return($nx,$ny,$pos+$value_dec)
}

Giungiamo infine al fondamentale metodo evaluate_this_angle, il cui cuore, la relazione:

$angle[$k]=$angle[int($k/$ro)]+$angle[$k-$ro*int($k/$ro)]

è ben descritta nel paragrafo b.

Il parametro fondamentale passato al metodo è l'indice $k, riferito al vettore $self->angle, in cui verrà inserito il valore dell'angolo k-esimo. Il calcolo è basato inizialmente sui parametri genitore (gli angle impostati nel metodo new) e l'indice della curva (r impostato nello stesso metodo new) su cui poi si va ad iterare.
g ed p sono le funzioni G(k) e P(k) pure descritte al paragrafo b.

# calcolo direzione segmento e coordinate del vertice finale corrispondente

    sub evaluate_this_angle {
        my $self=shift;
        my $k=shift;
        my $ro=shift;

        return ${$self->angle}[g($k,$ro)]+${$self->angle}[p($k,$ro)]
    }

    sub g {
        my $k=shift;
        my $ro=shift;

        my $n=int($k/$ro);
        return $n
    }

    sub p {
        my $k=shift;
        my $ro=shift;

        my $n=$k-$ro*g($k,$ro);
        return $n
    }

evaluate_this_coords calcola le coordinate del vertice k-esimo della curva e le restituisce al metodo chiamante. Le coordinate sono utilizzate per il disegno (metodo make_fract) oppure per le funzionalità crittografiche (metodi encrypt_file, decrypt_file, encrypt_scalar).
I parametri passati alla function sono l'indice dell'angolo nel vettore $self->angle($k) ed il fattore di zoom.
Il calcolo delle coordinate viene effettuato tramite le precedenti e spostandosi sul successivo vertice, considerando il lato della curva come l'ipotenusa del triangolo rettangolo che ha come estremi i due vertici della curva. Applicando le note proprietà di seno e coseno, siamo in grado di calcolare facilmente le nuove coordinate.
Per rendere cross-platform il software e rendere agevoli le operazioni di crittografia, si è scelto di approssimare per difetto ad 8 decimali il calcolo delle coordinate.

sub evaluate_this_coords {
    my $self=shift;
    my $k=shift;
    my $zoom=shift;
    my $nx=shift;
    my $ny=shift;
    my $di=shift;

    if (!$zoom) {$zoom=1};
    $nx=int(10**8*($nx-$di*$zoom*cos(${$self->angle}[$k])))/10**8;
    $ny=int(10**8*($ny-$di*$zoom*sin(${$self->angle}[$k])))/10**8;

    return ($nx,$ny)
}

Completa Crypt::FNA la classe Crypt::FNA::Validation, i cui metodi implementano i controlli di coerenza nei dati di inizializzazione e del fattore di zoom oltre all'aggiornamento del contenitore dei codici di errore restituiti nell'array $self->message.

Async Howto

larsen — 2010-03-20T16:30:10+02:00

Prefazione

Immaginiamo di avere una lista molto lunga di oggetti da elaborare: questa lista omogena richiede per ogni elemento una serie di operazioni su sistemi esterni, che pero' impiegano un po di tempo a rispondere.

Sebbene questo problema sembri altamente scalabile, nella pratica potrebbe risultare difficile da parallelizzare per via di limiti ambientali, tipo un limite sulle risorse usabili; se per esempio dovessimo fare una serie di chiamate http e registrarne gli esiti su un db, allora potremmo aprire anche molte connessioni http ma poche sul db o addirittura solo 1.

In questi casi puo' venir comodo un pool per le risorse limitate dove ogni singolo thread puo' ottenere temporaneamente un handler e permettere cosi' di avere tanti processi che condividono poche risorse. (Nell'esempio sopra avremmo tanti thread quante connessioni vogliamo aprire, che a termine dell'operazione chiedono in prestito una connessione a db per registrarne l'esito, quindi restituirla)

Sfortunatamente questo e' possibile solo usando appunto i threads; in multi-tasking > non e' possibile condividere le risorse visto che i task sono isolati fra loro.

E' possibile usare un'altro approccio, su un unico task posso operare su piu' connessioni in maniera asincrona...

Sincrono vs asincrono

Sincrono

Per prima cosa, vediamo cosa significano questi due termini, il modo migliore e' con un esempio.


        sub sync {
          my ($request) = @_;

          my $conn = openConn();
          $conn->send($request);

          my $response = $conn->recv();
          $conn->close();
          return $response;
        }

In questo esempio si apre una connessione e si inviano dati, quindi si aspetta di ricevere una risposta. E' possibile (in certi casi) migliorare le prestazioni aprendo una connessione una volta sola e usandola piu' volte:

        sub sync {
          my ($request, $conn) = @_;

          $conn->send($request);
          my $response = $conn->recv();
          return $response;
        }

Ci possiamo anche aspettare un meccanismo piu' complicato, dove le operazioni sono piu' d'una:

        sub sync {
          my ($request, $conn) = @_;

          $conn->send($request->head);
          my $ack = $conn->recv();
          $ack->is_ok or die;

          $conn->send($request->body);
          my $response = $conn->recv();
          return $response;
        }

A questo punto scriviamo il corpo del programma:

        my @list = fetchList();
        my $conn = openConn();
        my $db = openDB();

        foreach my @item (@list) {
          my $response = sync($item, $conn);
          $db->storeResult($item, $response);
        }

Se volessimo parallelizzare usando piu' task

        my $NTASK = 4;
        my @list = fetchList();

        # prepariamo delle partizioni in round-robin, una per ogni figlio
        my @partitions = map { []; } (1..$NTASK);
        for(my $i=0; $i < scalar @list; $i++) {
                my $tid = $i % $NTASK;
                push @{$partitions[$tid]}, $list[$i];
        }

        # fork di ogni child
        my @childs;
        foreach my $tid (1..$NTASK) {
                my $pid = fork();
                defined $pid or die;
                if($pid) {
                        # sono il padre, mi registro il pid
                        push @childs, $pid;
                } else {
                        # sono il figlio, iniziamo a lavorare
                        work($partitions[$tid]);
                        exit;
                }
        }
        # e aspettiamo che finiscano
        map { waitpid($_); } @childs;
        
        # ogni figlio lavorera' sulla sua partizione di dati
        sub work
        {
                my ($list) = @_;
                my $conn = openConn();
                my $db = openDB();
                foreach my $item ( @$list ) {
                        my $response = sync($item);
                        $db->storeResult($item, $response);
                }
        }

E' evidente che cosi' per ogni child dovro' fare una chiamata a openConn() e una a openDB(). E' gia' un bel passo avanti certo, ma il numero di child non puo' esser elevato perche' il numero di openDB non puo' esserlo.

Asincrono

Se il tempo che impiega il metodo sync() e' molto elevato, finiremmo con avere un pugno di task che aspettano una risposta nel 99% del tempo e non possiamo aumentare il numero di child perche' -- come abbiamo detto -- sul db non possiamo fare molte connessioni.

In questo caso possiamo rompere il metodo sync in due parti, una prima che invia i dati e una seconda che li elabora. Il nostro programma quindi iniviera' i dati a tante connessioni senza bloccarsi aspettando una risposta, per poi raccogliere le risposte in seguito.

Wrapper della connessione

Creiamo quindi un oggetto di connessione nostro che useremo come involucro attorno alla connessione vera. Iniziamo immaginando un caso semplice, dove si fa solo una richiesta e si ottiene solo una risposta:

        package Conn;
        
        sub new
        {
                my ($class, $conn)
                bless [
                        $conn,  # la connessione
                        undef,  # spazio per la closure INTERNA di lettura
                ], $class;
        }

        sub async
        {
                my ($self, $request, $on_success) = @_;
                die "already in use" if $self->[1]; # morte agli stacanovisti

                $self->[0]->send($request); # invio i dati

                $self->[1] = sub { # registro la closure INTERNA di lettura
                        my $response = $self->[0]->recv();
                        $on_success->($response);
                        return undef;
                };
        }

        sub dispose
        {
                my ($self) = @_;
                return unless $self->[1]; # se non c'e' nulla da fare...
                $self->[1] = $self->[1]->();
        }

        sub is_working
        {
                my ($self) = @_;
                return defined $self->[1];
        }

Il wrapper sopra puo' esser costruito partendo da una connessione, e espone 2 metodi: async e dispose.

Il suo uso e' piuttosto semplice:

        my $conn = Conn->new(openConn());
        my $db = openDB();
        # ...
        $conn->async(
                $request, # la richiesta
                sub {     # la callback
                    my $result = @_;
                    $db->storeResult($request, $result);
                }
        );
        # ...
        $conn->dispose();

Vediamo meglio cosa succede in questo disegno dove il tempo scorre verso il basso:

Note: ---> chiama o ritorna ...> definisce

1 - Alla chiamata async() si passa la $request e una closure in grado di registrare sul db il risultato, che chiameremo callback.

2 - async() invia la richiesta e registra la closure INTERNAL nel wrapper, che chiude la callback al suo interno.

a questo punto, il codice puo' fare altro...

3 - dopo un po di tempo, si chiama il metodo dispose()

4 - dispose() invoca la closure registrata nel wrapper: INTERNAL

5 - INTERNAL blocca finche' non arriva la risposta.

6 - la closure callback viene quindi invocata e registrera' l'esito sul DB.

7 - dispose() imposta come closure interna il valore da lei stessa ritornato, cioe' undef

Tanti Wrapper per 1 solo task

Dobbiamo pero' riempire i #... del codice sopra, e' cioe' vedere come far funzionare tutto questo:

        # apro NTASK connessioni ma solo 1 a db
        my @conns = map { Conn->new(openConn()); } (1..$NTASK);
        my $db = openDB();

        # ottengo tutti i dati
        my @list = fetchList();
        my $cid = 0;

        foreach my $item (@list)
        {
                # prendo una connessione in round-robin
                my $conn = $conns[$cid++ % $NTASK];

                # chiamo dispose cosi' da sbrigare il lavoro arretrato
                $conn->dispose;

                $conn->async($request, sub { # callback
                        my $result = @_;
                        $db->storeResult($request, $result);
                });
        }

        # finiamo le cose ancora in sospeso
        map { $_->dispose(); } grep { $_->[1] } @conns;

Ecco che gia' si vede un netto miglioramento: si puo' assegnare a $NTASK un numero anche molto grande, visto che cmq useremo solo una connessione a db! E non solo, non abbiamo piu' tanti task e una fork da gestire, ma tutto in un unico processo, ancora meglio!

Inoltre si vede che per ogni elemento della lista ci si sposta di 1 nella lista di connessioni, quindi si chiamera' dispose() sullo stesso wrapper solo dopo che verra' fatto un giro completo.

Se per esempio ogni risposta richiedesse 10 secondi e usassimo 100 connessioni allora le prime 100 richieste verranno inviate quasi istantaneamente. Alla 101-esima la dispose blocchera' per 10 secondi, per poi registrare la prima risposta sul db. Alla 102-esima la dispose non blocchera', visto che sono gia' passati 10 secondi!

Idealmente se le risposte richiedessero esattamente 10 secondi l'una avremmo un atteggiamento a ondate dove partono 100 richieste e poi si blocca, poi altre 100 e poi di nuovo si blocca.

Richieste a piu' fasi

Prima abbiamo immaginato una richiesta a due fasi, dove in pratica si deve prima inviare una richiesta e dopo una seconda... ma come farlo usando il wrapper?

In realta' abbiamo gia' quasi tutto pronto, basta che la prima closure INTERNAL anziche' ritornare undef ritorni la seconda fase:

        sub async
        {
                my ($self, $request, $on_success, $on_error) = @_;
                die "already in use" if $self->[1]; # morte agli stacanovisti

                $self->[2] = $on_error;
                $self->[0]->send($request->head);

                $self->[1] = sub { # <-------------------------- INTERNAL prima fase
                        my $ack = $self->[0]->recv();

                        # se NAK, cancelliamo l'operazione
                        unless($ac->is_ok()) {
                                $ack->is_ok() or $on_error("NAK", $request, $ack);
                                return undef;
                        }

                        $self->[0]->send($request->body);
                        return sub { # <------------------------ INTERNAL seconda fase
                                my response = $self->[0]->recv();

                                if($response->is_ok()) { $on_success->($response); }
                                else { $on_error->("RESPONSE KO", $request, $response);

                                return undef;
                        };
                }
        }

Vediamo meglio cosa abbiamo aggiunto:

La close INTERNAL, come gia' detto, ora ritorna una seconda closure. In questo modo la prima chiamata a dispose non finira' il lavoro subito ma registrera' una seconda fase.

Abbiamo aggiunto anche una seconda callback on_error che verra' chiamata se qualcosa va storto sia nella prima fase che nella seconda.

Dobbiamo inoltre modificare l'uso, visto che una dispose potrebbe non esser abbastanza:

        my @conns = map { Conn->new(openConn()); } (1..$NTASK);
        my $db = openDB();
        my @list = fetchList();
        my $cid = 0;
        foreach my $item (@list)
        {
                my $conn;
                while(1) {
                        # prendo una connessione in round-robin
                        $conn = $conns[$cid++ % $NTASK];
        
                        # chiamo dispose cosi' da sbrigare il lavoro arretrato
                        $conn->dispose;

                        # se ha finito... altrimenti avanti il prossimo
                        last unless $conn->is_working;
                }

                $conn->async($request, sub { # callback
                        my $result = @_;
                        $db->storeResult($request, $result);
                });
        }

        # finiamo le cose ancora in sospeso
        map { $_->dispose() while $_->is_working(); } @conns;

Qui le cose si complicano un pochino, ma ormai avete raggiunto la meta' di questo articolo, tanto vale finire no?

Immaginiamo sempre il nostro caso teorico dove ogni richiesta richiede 10 secondi e abbiamo 100 connessioni. Per le prima 100 richieste, come gia' succedeva', invieremo la prima parte della richiesta quasi istantaneamente.

Arrivati alla 101-esima richiesta, pero', le cose cambiano: Infatti si chiamera' la dispose sulla prima connessione che blocchera' fino ad ottenere la risposta della prima fase, e inviera' la richiesta per la seconda fase.

Purtroppo pero' la connessione NON e' ancora disponibile, si dovra' dunque iterare nel ciclo e tentare con la seconda, che non blocchera' piu' per 10 secondi ma si spostera' anch'essa alla seconda fase e via dicendo, fino a tornare alla prima.

La prima nuovamente blocchera' per 10 secondi, terminera' dunque il lavoro e ritornera' disponibile all'uso, procendendo dunque all'effettivo invio della 101-esima richiesta, 20 secondi dopo.

Le successive richieste non blocceranno (come per la 101-esima): esattamente come volevamo.

IO::Select

Il sistema sopra funziona egregiamente quando i tempi di risposta sono abbastanza costanti, ma quando alcune risposte impiegano molto piu' di altre allora possono sorgere problemi di efficienza.

Immaginiamo di avere solo 2 istanze di wrapper, al primo e' stata fatta una richiesta che richiedera' 10 secondi mentre al secondo una richiesta che richiedera' 1 secondo.

Quando arrivera' la terza richiesta, questa blocchera' per 10 secondi sul primo slot anche se avrebbe potuto aspettare solo 1 secondo se avesse usato il secondo.

Se il nostro wrapper usa direttamente degli handler per comunicare, e' possibile usare la syscall select per sapere, data una lista di handlers, quale di questi handlers ha dati disponibili per la lettura.

Per semplificare la gestione useremo il modulo the IO::Select manpage, ecco un esempio:

        use IO::Select;

        my $sel = IO::Select->new();
        map { $sel->add($_); } @handlers;
        # ....
        my @ready = $sel->can_read($timeout);

Nell'array @ready otteniamo alcuni degli handlers aggiungi a $sel, vale a dire quelli che hanno dati disponibili per la lettura.

Il parametro $timeout indica quanto tempo aspettare per avere almeno 1 filehandle. Cio' significa che se uno o piu' handler e' gia' pronto ritornera' subito, oppure aspettera fino ad un massimo di $timeout secondi prima di arrendersi e tornare una lista vuota.

Modifichiamo quindi radicalmente il nostro wrapper e rendiamolo un vero pool di connessioni wrapped:

        package Pool;
        use IO::Select;
        use IO::Socket;

        sub new {
                my ($class, %args) = @_;
                bless { 
                        %args,
                        _slots = {},
                        _sel = IO::Select->new();
                }, $class;
        }

        sub _create {
                my ($self) = @_;
                my $slot = [
                        IO::Socket::INET->new($self->{host}),
                        undef, # INTERNAL
                        undef, # ON_ERROR
                ];
                my $fd = $slot->[0]->fileno or die;
                $slot->[0]->autoflush(1);
                $self->{_slots}->{$fd} = $slot;
                $self->{_sel}->add($slot->[0]);
                return $slot;
        }

        sub _find {
                my ($self) = @_;
                $self->dispose(0);
                while(1) {
                        my $ct = 0;
                        foreach my $slot (values %{$self->{_slots}})
                        {
                                $ct++;
                                return $slot unless $slot->is_working();
                        }
                        return $self->_create() if $ct < $self->{size};
                        $self->dispose(0.5);
                }
        }

        sub close {
                my ($self) = @_;

                OUTER: while(1) {
                        foreach my $slot (values %{$self->{_slots}})
                        {
                                if($slot->[1]) {
                                        $self->dispose(0.5);
                                        continue OUTER;
                                }
                        }
                        break;
                }
        }

        sub dispose {
                my ($self, $timeout) = @_;

                # get what is ready for data
                my @ready = $self->{_sel}->can_read($timeout);

                foreach my $fh (@ready) {
                        # get the slot
                        my $fd = $fh->fileno;
                        my $slot = $self->{_slot}->{$fd};

                        # invoke che INTERNAL
                        eval { $slot->[1] = $slot->[1]->(); };
                        next unless $@;
                        my $err = $@;

                        # remove the slot
                        delete $self->{_slot}->{$fd};
                        $self->{_sel}->remove($slot->[0]);

                        # call the on_error
                        eval { $slot->[2]->($err); };
                }
        }

        sub async {
                my ($self, $req, $on_success, $on_error) = @_;

                # find a slot
                my $slot = $self->_find();
                my $fh = $slot->[0];

                # register the on_error
                $slot->[2] = $on_error;

                # send first part of request
                $fh->print($req->head);

                # register the response handler 
                $slot->[1] = sub {
                        my $ack = <$fh>;

                        # die, the dispose() will fire the on_error
                        die "NAK" unless $ack =~ /^OK/;

                        # send the second part of the request
                        $fh->print($req->body);

                        # register the new handler
                        return sub {
                                my $res = <$fh>;
                                die "KO" unless $res =~ /^200/;

                                # all went fine, call on_success
                                $on_success->($res);

                                # free the slot
                                return undef;
                        };
                };
        }

Molte cose nuove, per prima cosa abbiamo un oggetto unico che conterra' tutte le connessioni aperte, definito con un massimo di connessioni disponibili.

Il metodo dispose() deve ora gestire il gruppo intero di connessioni, usando il selettore IO::Select creato nel costruttore.

Accetta anche un parametro di $timeout che indica quanto tempo aspettare al massimo.

Il metodo async() e' simile al precedente, ma chiamera' il metodo interno _find() per scoprire quale slot usare invece di fare round-robin.

Il vantaggio, oltre che l'efficienza, e' una piu' semplice usabilita' all'esterno:

        my $pool = Pool->new(
                host => '1.2.3.4:1234',
                size => 100,
        );
        my $db = openDB();

        foreach my $req (@list) 
        {
                $pool->async( $req, 
                  sub {
                      my ($result) = @_;
                      $db->storeResult($req, $result);
                  }, 
                  sub {
                      warn "error while $req:  @_";
                });
        }
        $pool->close();

Il metodo _find() per prima cosa vede di chiamare la dispose(), quindi se non trova slot liberi verifica quanti sono aperti, se sono meno del limite crea una nuova connessione, altrimenti richiama la dispose() passando un timeout e aspetta che qualcuno si liberi.

Visto che _find() viene chiamato ad ogni chiamata a async() possiamo evitare di chiamare il metodo dispose() direttamente, a meno che non serva controllare la coda senza aggiunger nulla.

Usando the IO::Select manpage abbiamo inoltre risolto il problema delle richieste a tempo non costante: se avessimo come prima massimo 2 connessioni impegnate dove la prima rispondera' fra 10 secondi e la seconda solo dopo 1 secondo, la chiamata a async() iniziera' a chiamare _find() che non potendo creare una connessione nuova chiamera' la dispose() anche piu' volte, dopo qualche tentativo finalmente otterremo la risposta sul secondo slot rendendolo disponibile e _find() ritornera' questo slot permettendo cosi' l'invio del terzo messaggio dopo 1 secondo.

Cosa aggiungere ora?

Il sistema usato sopra non fa piu' round-robin ma gestisce le connessioni in ordine sparso.

E' possibile quindi aggiungere altri parametri allo slot, come un timeout per la lettura e un idle_time oltre il quale chiudere la connessione.

In questo modo le connessioni oltre ad aprirsi quando richiesto possono anche chiudersi dopo un tempo di idle.

E' possibile inoltre distruggere le connessioni dopo qualche migliaio di usi, cosi' da liberare eventuali risorse allocate lato server.

Per fare questo aggiungiamo a $self->{_next_expire_check} e aggiungiamo allo slot un quarto parametro last_use:

        sub dispose {
                my ($self, $timeout) = @_;

                # get what is ready for data
                my @ready = $self->{_sel}->can_read($timeout);
                my %closing;

                foreach my $fh (@ready) {
                        # get the slot
                        my $fd = $fh->fileno;
                        my $slot = $self->{_slot}->{$fd};

                        # invoke che INTERNAL
                        eval { 
                                $slot->[1] = $slot->[1]->(); 
                                $slot->[3] = time(); # aggiorno last_use
                        };
                        next unless $@;

                        # mark for closing
                        $closing{$fd} = $@;
                }

                next unless time() > $self->{_next_expire_check};
                $self->{_next_expire_check} = time();
                
                foreach my $slot ( values %{ $self->{_slots} } )
                {
                        my $timeout = $slot->[1]   # e' in uso?
                                ? $self->{read_timeout} 
                                : $self->{idle_timeout};

                        # confronto il last_use
                        next unless $slot->[3]+$timeout < time();

                        # se e' passato troppo tempo
                        $closing{$slot->[0]->fileno} ||= "TIMEOUT";
                }
                
                # per tutte quelle in closing...
                while( my($fd, $err) = each %closing )
                {
                        my $slot = $self->{_slots}->{$fd};

                        # remove the slot
                        delete $self->{_slots}->{$fd};
                        $self->{_sel}->remove($slot->[0]);

                        # call the ERROR callback if still in 
                        eval { $slot->[2]->($err); } if $slot->[1];
                }
        }

e aggiungiamo alla sub async un reset del last_use alla fine prima di uscire:

        $slot->[3] = time();

ora non serve altro che impostare questi valori durante la costruzione:

        my $pool = Pool->new(
                host => '1.2.3.4:1234',
                size => 100,
                read_timeout => 30, 
                idle_timeout => 120,
        );

E il resto rimane uguale, ora le connessioni che non rispondono in 30 secondi chiameranno la callback di errore con TIMEOUT mentre quelle non usate per 120 secondi verranno chiuse silenziosamente.

Conclusioni

Certo si e' dovuto scrivere un mucchio di codice, e la gestione degli errori e' complessa, ma i vantaggi sono evidenti: Un solo task gestisce piu' connessioni, una sorta di reattore.

E' necessario pero' tener presente che la gestione degli errori puo' esser complessa!

Autobox: un po' di futuro, adesso

dada — 2009-07-25T15:27:28+02:00

Parlare del futuro, per noi perlisti, è divenuta purtroppo una faccenda imbarazzante. Da talmente tanti anni ormai siamo convinti, o cercano di convincerci, che prima o poi il Perl6 arriverà, che abbiamo ineluttabilmente accettato il fatto che sarà il linguaggio di programmazione utilizzato dai nostri nipotini.

Ma oggi non sono qui per affliggervi, tutt'altro! Esiste già, se non altro, un effetto collaterale del Perl6. Ed è quello di aver spinto un sostanzioso numero di brillanti sviluppatori a spremersi le meningi per realizzare, in certa misura, una "compatibilità con le versioni successive" del linguaggo. In altre parole, aggiungere nuove e sempre più sorprendenti funzionalità al Perl5 attuale, in buona parte mutuate o ispirate da quello che sarà il Perl6.

I primi sforzi hanno portato al fiorire, su CPAN, di vari moduli nel namespace Perl6 (Perl6::Variables, Perl6::Rules, Perl6::Junction tanto per citarne alcuni). Utili a livello di prototipo per la progettazione del nuovo linguaggio, decisamente meno nell'uso quotidiano. Col passare del tempo, però, e con il consolidamento delle specifiche del Perl6, alcune nozioni - soprattutto per quanto riguarda la programmazione object oriented - sono "trapelate" in strumenti tutt'altro che puramente teorici. Mi riferisco principalmente a Moose, del quale potete leggere altrove su questo sito.

Questo dimostra sostanzialmente due cose: primo, che il processo di "invenzione" del Perl6 non è campato in aria, che le idee ci sono, sono buone e vale la pena di implementarle. Secondo, che il Perl5, nonostante gli anni, non ha ancora finito di stupirci per potenza, flessibilità e capacità di rinnovarsi.

L'oggetto del mio articolo è un modulo (due, in realtà) dall'apparenza innocua, che trovate su CPAN. Ai lettori più smaliziati non sfuggiranno i riferimenti al Perl6 impliciti nel modulo. Si chiama semplicemente autobox. Non ha un nome altisonante, non è composto da migliaia di righe di codice, eppure può davvero rivoluzionare il modo in cui scrivete codice Perl. Oggi.

"hello autobox"

La finalità del modulo autobox è enunciata quasi laconicamente nella sua documentazione: invocare metodi su tipi nativi.

In altre parole, tramutare qualunque termine di un programma in un oggetto. O meglio, visto che non si tratta di un vero e proprio tramutare, estendere la sintassi object oriented facendo sì che anche semplici valori, non solo ciò che esplicitamente instanziamo tramite un costruttore, diventino oggetto d'invocazione di un metodo.

Ma forse era più chiara la spiegazione laconica. Lasciamo da parte la teoria e vediamo un attimo come questa si traduce in pratica. Il modulo permette cose come questa:

    use autobox;
    my $greeting = "hello autobox"->upper();

Sorprendente, no? "hello autobox" è una stringa, eppure la riga sopra funziona (in realtà, no. Funzionerebbe se avessimo definito un metodo upper che converte una stringa in maiuscolo; ma ci arriviamo). In sostanza, il codice equivale ad aver scritto una cosa del genere:

    use String;
    my $string = String->new("hello autobox");
    my $greeting = $string->upper();

Supponendo l'esistenza di una classe String, dall'implementazione piuttosto ovvia. Eppure "hello autobox" non è un oggetto, non ci assomiglia neanche lontanamente. È una stringa!

Da un altro punto di vista, però, esso è anche uno scalare, ossia qualcosa che rappresenta un valore. Così come $foo (una variabile) o 2+2 (un'espressione). E autobox non fa altro che definire "classi virtuali", per così dire, delle quali implicitamente tutto può essere istanza. Nella fattispecie, la classe per la nostra stringa è SCALAR.

Dovremmo avere tutti gli elementi, a questo punto, per far effettivamente funzionare il nostro primo esempio:

    use autobox;
    sub SCALAR::upper { return uc(@_); }
    
    my $greeting = "hello autobox"->upper();
    # $greeting ora contiene "HELLO AUTOBOX"!

In pratica, basta definire metodi appartenenti alla "classe virtuale" e la loro invocazione avviene come se il termine fosse un'istanza di quella classe. Focalizzate i primi due esempi, quello che usa autobox e quello che usa l'ipotetica classe String. Questo è, in sostanza, quello che succede:

    "hello autobox"->upper()  corrisponde a: SCALAR::upper("hello autobox")
    $string->upper()          corrisponde a: String::upper($string)

La dicitura "tipi nativi", inoltre, non ci limita solo alle stringhe. Anche array e hash godono delle stesse prerogative. Un esempio:

    use autobox;

    sub ARRAY::sum {
        my $array = shift;
        my $sum = 0; 
        $sum += $_ foreach(@$array); 
        return $sum; 
    }

    my @numeri = (1..10);
    print @numeri->sum(); # stampa 55

Chiaro come il sole, no? Ok, lo so cosa state pensando. Sicuramente un trucchetto interessante, meritevole di un'alzata di sopracciglia. Ma andiamo, a chi potrebbe venire in mente di usare seriamente una sintassi del genere? Sono pienamente d'accordo con voi. Ma aspettate, il bello deve ancora venire...

Facciamo 31

Di per sé, come abbiamo visto, autobox non fornisce nulla se non la possibilità di utilizzare sintassi object oriented su non-oggetti. Per convertire una stringa in maiuscolo ho dovuto scrivere una funzione (metodo) che utilizzasse la parola chiave uc. Bell'affare.

Esiste però un altro modulo su CPAN, chiamato autobox::Core, il quale applica le potenzialità di autobox nientepopodimeno che al core del Perl, ossia tutte (o quasi) le sue parole chiave.

Basta usare il modulo, e la magia si compie sotto i nostri occhi increduli:

    use autobox::Core;
    
    "hello autobox"->uc()->print(); # stampa HELLO AUTOBOX
    
    my @numeri = (1..10);
    @numeri->join(",")->print(); # stampa 1,2,3,4,5,6,7,8,9,10

Ora sì che la cosa si fa davvero interessante! Questi esempi funzionano, usando una sintassi che non sembra solo il capriccio di un abile programmatore con troppo tempo libero. Una sintassi appetibile, elegante, certo spiazzante per il perlista di lunga data, ma sensata. Dannatamente sensata. Una sintassi, per dirla con un acronimo prettamente informatico, deliziosamente DWIM (Do What I Mean).

Andiamo sul concreto

Non pretendo di illustrarvi le conseguenze ultime dell'utilizzo di autobox. Del resto, io stesso non ho ancora veramente "rivoluzionato" il modo in cui scrivo Perl.

Voglio darvi però qualche assaggio, codice alla mano, partendo da un caso concreto. Dove a mio avviso autobox brilla davvero, e allevia alcune "brutture" congenite alla sintassi Perl, è nella gestione di strutture dati complesse.

Avevo come compito quello di realizzare una sorta di procedura di backup, in pratica serializzare su file alcuni dati contenuti in un database. I dettagli della procedura, comunque, sono poco importanti.

Comincio il mio lavoro definendo una struttura nella quale andare a memorizzare tutto quello che mi serve:

    my $data = {
        objects => [],
        languages => [],
        # ...
    };

Fin qui niente di speciale. Ora devo popolare la struttura con i dati provenienti da una query:

    foreach my $object ( do_query() ) {
    	push(@{ $data->{objects} }, $object);
    }

Quant'è brutto quel push, eh? Eppure inevitabile. Almeno finché non c'era autobox::Core:

    use autobox::Core;
    foreach my $object ( do_query() ) {
        $data->{objects}->push( $object );
    }

Non so voi, ma a me così piace molto di più! Ora diciamo che in un punto successivo del mio codice devo nuovamente scorrere la lista degli oggetti recuperati per qualche motivo:

    ## prima
    foreach my $object (@{ $data->{objects} }) {
        do_stuff($object);
    }
    
    ## dopo
    foreach my $object ($data->{objects}->flatten) {
        do_stuff($object);
    }

Ok, c'è un flatten che forse non ci aspettavamo: $data->{objects} contiene un riferimento ad array, e dunque dobbiamo in ogni caso dereferenziarlo per ottenere la lista vera e propria. Meglio flatten, comunque, che un più criptico @{ ... }. Scagli la prima pietra chi non ha mai dimenticato una parentesi graffa con la sintassi di "prima"!

Ma non solo. Se Perl è il linguaggio del "c'è più di un modo per farlo", autobox non è da meno. Anche queste forme sono possibili (per quanto personalmente preferisca il caro, vecchio foreach):

    $data->{objects}->foreach(sub {
        do_stuff($_[0]);
    });

    ## ma anche...
    $data->{objects}->map(sub {
        do_stuff($_);
    });

E ora supponiamo di avere una struttura dati che contiene un elenco (strutturato a sua volta) di file per ogni linguaggio, una cosa del genere:

    my %files = (
        en => {
            templates => 'po/templates_en.po',
            forms => 'po/forms_en.po',
        },
        it => {
            templates => 'po/templates_it.po',
            forms => 'po/forms_it.po',
            cities => 'po/cities_it.po',
        },
        # etc. etc.
    );

Devo andare a memorizzare in $data->{languages} l'elenco dei file che mi servono, ossia quelli dei linguaggi utilizzati negli oggetti che ho recuperato.

    ## prima
    my %language_seen;
    foreach my $object (@{ $data->{objects} }) {
        $language_seen{ $object->language_id } = 1;
    }
    foreach my $language (keys %language_seen) {
        push(@{ $data->{languages} }, values %{ $files{$language} });
    }

La probabilità di scordarsi qualche parentesi cresce esponenzialmente... e ora vediamo cosa succede con autobox. Ma se dobbiamo farlo, facciamolo bene! Abbiamo già visto come sia facile definire metodi che vadano ad agire sui "tipi nativi", quindi chiamiamo in causa List::MoreUtils:

    ## dopo
    use autobox;
    use autobox::Core;
    use List::MoreUtils;
    sub ARRAY::uniq { return List::MoreUtils::uniq(@_) }

    foreach my $language ($data->{objects}->map( sub { $_->language_id } )->uniq->flatten) {
        $data->{languages}->push( $files{$language}->values->flatten );
    }

D'accordo, questo comincia a sembrare più un esercizio di stile che del serio e onesto codice. Del resto autobox è uno strumento, e in quanto tale soggetto ad essere abusato. Quello che ancora disturba un po', a mio avviso, è la necessità di introdurre con sub l'argomento del metodo map. Ma nessuno è perfetto :-).

Concludo con un esempio "da manuale". Tutti sappiamo cos'è la trasformata di Schwartz, ovviamente (altrimenti, date una ripassata). Questo codice, liberamente tratto dalla documentazione Perl, ordina un array secondo il primo numero presente nella stringa. Per capirci:

    my @data = ( 
        "Biancaneve e i 7 nani",
        "Ali baba e i 40 ladroni", 
        "I 3 Porcellini",
    );

    my @sorted = map  { $_->[0] }
                 sort { $a->[1] <=> $b->[1] }
                 map  { [ $_, (/(\d+)/)[0] ] } @data;

    # @sorted:
    # I 3 Porcellini
    # Biancaneve e i 7 nani
    # Ali baba e i 40 ladroni

    # (ossia 3, 7, 40)

Vediamo che faccia ha la nostra trasformata usando autobox:

    my @sorted = @data
        ->map ( sub { [ $_, (/(\d+)/)[0] ] } )
        ->sort( sub { my($a, $b) = @_; $a->[1] <=> $b->[1] } )
        ->map ( sub { $_->[0] } )
        ->flatten;

Più comprensibile? Meno comprensibile? Lascio a voi decidere. Sintassi a parte, la differenza sta nella sequenza delle istruzioni, che con autobox seguono il "flusso" naturale dei dati. La normale trasformata di Schwartz al contrario si legge, per così dire, da destra a sinistra:

    normale: map <- sort <- map <- array
    autobox: array -> map -> sort -> map

Nella documentazione di autobox::Core trovate alcune interessanti osservazioni sul perchè questa differenza è cosa buona e giusta, oltre naturalmente a vari altri illuminanti esempi d'utilizzo.

Conclusioni

Questo è un articolo breve (un pregio, direte voi): ho probabilmente tralasciato molti aspetti di autobox che meriterebbero di essere approfonditi.

Un avvertimento però è doveroso: l'utilizzo di autobox influisce sulle prestazioni! Non ho fatto personalmente benchmark, ma sicuramente le chiamate a metodi sono costose. Soprattutto se applicate a strutture dati molto corpose (ad esempio, array con svariate decine di migliaia di elementi).

Quello che apprezzo di più di autobox è la discrezione. Quel che aggiunge al linguaggio non è poca cosa: sarà simulazione quanto volete, ma di fatto il modulo regala al Perl ciò di cui moltri altri linguaggi - dinamici e non - si vantano: everything is an object.

E nonostante questo, non siete assolutamente forzati a utilizzare le parole chiave del Perl come fossero metodi. Anzi, potete scegliere caso per caso: nello stesso programma possono convivere pacificamente costrutti tradizionali e spericolati viaggi ai confini della sintassi. autobox non pesta i piedi a nessuno, e lo amo per questo.

Non so dire se autobox sia un gran passo avanti per l'umanità o un piccolo passo per il Perl (che lo avvicina - idealmente - al Perl6). Come ho già accennato, non l'ho utilizzato in maniera estensiva, ma quel poco che ho visto mi ha divertito molto e volevo condividerlo. Spero lo troviate divertente anche voi :-)

Mettiamoli a confronto

guest — 2008-11-06T11:07:58+02:00

Perl offre un supporto alla manipolazione degli array molto comodo: possiamo allungarli ed accorciarli a nostro piacimento a run-time senza preoccuparci di troppe cose, crearli in svariate maniere, ciclarci sopra in modi diversi... Ma avete mai provato a confrontare una coppia di array?

In questo articolo cercheremo di approfondire alcune nostre conoscenze sulle operazioni possibili su una coppia di array, infatti in taluni casi può esser molto utile confrontare due collezioni di dati per vedere dove e in cosa differiscono. Ci viene in aiuto per questi compiti il comodissimo Array::Compare.

Facciamo subito un piccolo esempio: creiamo due array che contengono i numeri da 0 a 10

my @arr1 = 0 .. 10;
my @arr2 = 0 .. 10;

istanziamo un oggetto della classe Array::Compare tramite il costruttore new

my $comp = Array::Compare->new;

su questo oggetto andiamo a chiamare il metodo 'compare', che accetta due riferimenti ad array e restituisce - ci credereste - vero o falso a seconda dell'esito del confronto:

if ($comp->compare(\@arr1, \@arr2)) {
  print "Array identici\n";
} else {
  print "Array differenti\n";
}

Ma come fa il nostro modulo a far tutto ciò? Internamente quello che viene fatto per confrontare i due array non è nient'altro che un join tra tutti gli elementi di ciascun array: questo "trasforma" i due array in altrettante stringhe che poi vengono confrontate con 'eq'. Il separatore interposto tra ciascun elemento dell'array dalla funzione join sono i caratteri "^G" che potrebbero portare a dei problemi se fossero presenti tra gli elementi dei vostri array. Diamo un'occhiata a questi due array:

my @array1 = ('ciao^G', 'ola', 'hello', 'bueno');
my @array2 = ('ciao', '^Gola', 'hello', 'bueno');

all'apparenza sembrerebbero diversi, ma per il motivo detto sopra il nostro comparatore cade nel tranello e crea due stringhe così:

$stringa1 = 'ciao^G^Gola^Ghello^Gbueno';
$stringa2 = 'ciao^G^Gola^Ghello^Gbueno';

per cui quando va a confrontarle, per lui sono uguali e ci dice che gli array hanno gli stessi elementi! Per aggirare questo problema è possibile ridefinire il separatore andando a passare al costruttore dell'oggetto (quindi mentre si sta instanziando l'oggetto stesso) il parametro 'Sep':

my $comp = Array::Compare->new(Sep => '|');

oppure possiamo anche cambiare il separatore su un oggetto che abbiamo precedentemente creato:

$comp->Sep('|');

È ovvio che conviene scegliere un separatore che non compare nei nostri dati; se non si è certi se si ha o meno quel separatore nell'array si potrebbe pensare di utilizzare la funzione any contenuta nel package List::Moreutils in questo modo:

print "cambia separatore!" if any { m/mioseparatore/ } @arr1;

in maniera tale da fare un controllo al volo ed esser certi di non cadere in tranelli subdoli.

Possiamo anche controllare se gli spazi devono esser significativi per il nostro confronto, ricorrendo al metodo WhiteSpace(). Di default tutti gli spazi sono significativi, in alternativa si può far in modo che più spazi consecutivi vengano convertiti in un solo spazio passando al costruttore il seguente parametro:

my $comp = Array::Compare->new(WhiteSpace => 0);

oppure come al solito:

$comp->WhiteSpace(0);

La stessa identica cosa può esser fatta per rendere il confronto case sensitive o meno passando al costruttore l'opzione "Case":

my $comp = Array::Compare->new(Case => 0);

l'altro modo non ve lo scrivo tanto l'avete già capito... Fino a qui è un modulino carino che fa qualche cosina che alla fin fine ci saremmo potuti scrivere in qualche riga anche noi, vero? Questo modulo però ci permette di fare qualcosa di più potente con poco sforzo, tipo confrontare due array ed avere una lista degli indici che differiscono. Questo tipo di confronto è detto "confronto completo" ed in contesto scalare restituisce la lunghezza della lista di elementi che differiscono. Vediamo un piccolo esempio:

  
my @verdura_da_comprare = qw( zucchine pomodori asparagi insalata );
my @verdura_comprata = qw( zucchine melanzane peperoni insalata );

my $comp = Array::Compare->new(DefFull => 1);

my @lista_sbadato = $comp->compare(\@verdura_da_comprare, \@verdura_comprata);

print "Ho comprato $verdura_comprata[$_] anziche' $verdura_da_comprare[$_]\n" for (@lista_sbadato);

In questo frammento di codice andiamo a confrontare due array che contengono ciò che volevamo comprare al banco di frutta e verdura e ciò che invece abbiamo poi comprato perché ci siamo dimenticati la lista della spesa a casa. In @lista_sbadato abbiamo la lista degli indici i cui relativi elementi differiscono nel confronto e la utilizziamo comodamente per stampare gli elementi incriminati dei due array.

Dato che il modulo rispetta a pieno la filosofia Perl, c'è anche un altro modo per fare questa cosa, chiamando direttamente la funzione "full_compare":

$comp->full_compare(\@arr1, \@arr2);

per simmetria si può invocare anche il confronto semplice in questo modo:

$comp->simple_compare(\@arr1, \@arr2);

Abbiamo un po' di verdura in pentola, siamo partiti dal semplice confronto e ora abbiamo già un bel po' di opzioni per poter estrarre al volo molte informazioni sui nostri array. Andiamo avanti! Avete mai pensato di confrontare il podio delle gare di motociclismo? Quello della seconda fila si sta facendo una risata perché dice: "Cosa ti vuoi confrontare... vince sempre Valentino!". Beh, l'obiezione è buona ma noi partendo dal presupposto che nelle due gare in esame abbia vinto sempre Valentino, vogliamo confrontare i secondi e terzi posti. Possiamo indicare al nostro modulo di fregarsene del contenuto del primo elemento di ciascun array e andare a vedere se gli altri due sono uguali:

my %skip = (1 => 1); #il primo è sempre lo stesso

my @mugello = ('valentino','max','loris');

my @brno = ('valentino','loris','max');

Ora confrontiamo questi due podi del motomondiale:

my $podio = Array::Compare->new(Skip => \%skip);
$podio->compare(\@mugello, \@brno);

Ovviamente ci restituirà falso (in contesto booleano) perché si vede subito che non sono uguali ma possiamo notare che i piloti che stanno sul podio sono stati gli stessi!! Non vi stuzzica neanche un po' questa cosa? Beh lo sviluppatore del modulo c'aveva pensato: possiamo facilmente controllare se un array è la permutazione di un altro, cioè contiene gli stessi elementi ma in ordine diverso:

if ($podio->perm(\@mugello, \@brno) {
  print "Stesse persone sul podio\n";
} else {
  print "No. Sul podio ci sono andate persone diverse\n";
}

Per resettare il comparatore in maniera tale da non far saltare alcun elemento nell'array possiamo usare:

$podio->Skip({});

A dire il vero il discorso su quali elementi saltare nel confronto di due array può anche esser ribaltato vedendolo così: dico al comparatore di ignorare degli elementi che sicuramente so esser diversi, ed andare così a controllare se gli altri differiscono.

Cala il sipario siori e siore ma io ho ancora qualcosa da suggerirvi e cioè qualche modulo che potete andare a sbirciare e che può tornarvi utile quando avete a che fare con array e liste:

* List::Util <-- una selezione di utility per liste e array.

* List::Moreutils <-- tutto ciò che volevate in List::Util ma che il suo autore si è "ostinatamente" rifiutato di includere :D

* Tie::File <-- associa le linee di un file con gli elementi di un array, è un modulo comodissimo, un'occhiata è obbligatoria.

Pecche :-(

Se alla fine di questo articolo vi state domandando se sia possibile confrontare array multilivello, siete molto arguti ed avete scovato la falla di questo modulo. Purtroppo il confronto di strutture più complicate di un array non è effettuabile tramite questo modulo, vi segnalo qualcosa che potrà esservi utile per assolvere questo compito:

* Data::Compare - compara strutture dati Perl

Questo modulo non vi permette però tutte le opzioni con le quali potevate controllare il confronto su due array come con Array::Compare.

La guida di brian

dree — 2008-07-25T17:41:05+02:00

NOME
RIASSUNTO
DESCRIZIONE

La mia filosofia di debugging
Il mio metodo

AUTORE
TRADUZIONE
COPYRIGHT

NOME

La guida di brian per la risoluzione di qualsiasi problema sul Perl

RIASSUNTO

Seguite questa guida e evitate di impazzire

DESCRIZIONE

La mia filosofia di debugging

Io credo in tre cose:

Non è una cosa personale

Dimenticati la proprietà del codice. Puoi pensare a te stesso come ad un artista, ma anche i grandi Maestri hanno prodotto un sacco di schifezze. Il codice di chiunque è una schifezza, il che significa che il mio codice è una schifezza e il tuo codice è una schifezza. Impara ad apprezzare questo fatto. Quando hai un problema, il tuo primo pensiero dovrebbe essere "C'è qualcosa che non va nel mio schifoso codice". Questo significa che non devi prendertela con perl. Non è una cosa personale.
Scordati di come tu fai le cose. Se il tuo modo di fare le cose funzionasse, non staresti qui a leggere. Non è neppure una brutta cosa: è semplicemente tempo di progredire. Ci siamo passati tutti.

Responsabilità personale

Se hai un problema con il tuo script, è proprio questo: un tuo problema. Dovresti fare tutto il possibile per risolverlo da solo. Ricorda, ognuno ha i propri script, il che significa che ognuno ha i propri problemi. Svolgi i tuoi compiti per casa e fai del tuo meglio prima di dare fastidio a qualcun altro con i tuoi problemi. Se hai davvero provato tutto quello che è scritto in questa guida e non riesci ancora a risolvere il problema, hai fatto del tuo meglio ed è ora di dare fastidio a qualcun altro.

Cambia il modo in cui fai le cose

Risolvi le cose in modo da non avere di nuovo lo stesso problema. Il problema sta probabilmente in come scrivi il codice, non in cosa scrivi. Cambia il modo in cui fai le cose, in modo da semplificati la vita. Non forzare Perl ad adattarsi a te stesso, perché non si adatterà. Adattati tu a Perl. È solo un linguaggio, non uno stile di vita.

Il mio metodo

Il tuo script compila usando i controlli sintattici?

Se non stai ancora usando i controlli sintattici, attivali. I guru del Perl sono tali perché usano strict, che lascia loro molto più tempo per risolvere altri problemi, imparare cose nuove e inserire moduli funzionanti in CPAN.
Puoi attivare i controlli sintattici all'interno del codice con la direttiva strict.

        use strict;

Da linea di comando, puoi attivare i controlli sintattici con il parametro -M a perl.

        perl -Mstrict script.pl

Potresti essere infastidito dai controlli sintattici, ma dopo un paio di settimane di programmazione con i controlli attivi, scriverai del codice migliore, perderai meno tempo a rincorrere dei semplici errori, e probabilmente non avrai bisogno di questa guida.

Cosa sono gli avvertimenti?

Perl può darti un sacco di avvertimenti sui costrutti discutibili. Attiva gli avvertimenti e lascia che Perl ti aiuti.
Puoi usare il parametro -w nella shebang.

        #!/usr/bin/perl -w

Puoi attivare gli avvertimenti dalla linea di comando.

        perl -w script.pl

Puoi usare gli avvertimenti lessicali con tutta una serie di caratteristiche interessanti. Dai un'occhiata a warnings per i dettagli.

        use warnings;

Se non capisci un avvertimento, puoi cercarne una versione esplicativa in perldiag, oppure puoi usare la direttiva diagnostics nel codice.

        use diagnostics;

Risolvi il primo problema per primo!

Dopo aver ottenuto da perl un errore o un messaggio di avvertimento, risolvi il primo messaggio e poi vedi se perl continua a lamentarsi. Gli ulteriori messaggi potrebbero essere stati conseguenze del primo problema.

Guarda il codice prima del numero di linea nel messaggio d'errore!

perl ti fornisce dei messaggi d'avvertimento nel momento in cui inizia a preoccuparsi, non prima. Al momento in cui perl è preoccupato, il problema è già capitato e il numero di linea di cui perl si sta occupando sta in realtà dopo il problema. Dai un'occhiata un paio di espressioni prima del numero di linea dell'avvertimento.

Il valore è quello che tu pensi che sia?

Non tirare ad indovinare! Esamina davvero il valore, subito prima di usarlo in una espressione. Il migliore debugger dell'universo è print.

        print STDERR "Il valore e` [$valore]\n";

Ho racchiuso $valore tra parentesi in maniera da poter vedere eventuali spazi o a capo all'inizio o alla fine del valore.
Se ho a che fare con qualcosa di diverso da uno scalare, uso Data::Dumper per stampare le strutture dati.

        require Data::Dumper;

        print STDERR "L'hash e` ", Data::Dumper::Dumper( %hash ), "\n";

Se il valore non è quello che pensi sia, torna indietro di qualche passo e prova di nuovo! Fai così fino a che non trovi il punto nel quale il valore smette di essere quello che pensi dovrebbe essere!
Puoi anche usare il debugger integrato in perl, tramite il parametro -d. Studia perldebug per i dettagli.

        perl -d script.pl

Puoi anche utilizzare altri debugger o ambienti di sviluppo, come ptkdb (un debugger grafico basato su Tk) oppure Komodo (l'IDE Perl di Activestate basato su Mozilla).

Stai usando la funzione in maniera corretta?

Programmo in Perl da un sacco di tempo e consulto ancora perlfunc quasi tutti i giorni. Alcune cose non riesco proprio a memorizzarle, e qualche volta ho così tanto sonno arretrato che il cervello se ne va in vacanza, e mi domando come mai sprintf() non stampi a schermo.
Puoi cercare una particolare funzione con il comando perldoc e il suo parametro -f.

        perldoc -f nome_funzione

Se stai usando un modulo, controlla la documentazione per assicurarti di usarlo nel modo giusto. Puoi controllare la documentazione del modulo usando perldoc.

        perldoc Nome::Modulo

Stai usando la variabile speciale giusta?

Di nuovo, io faccio continuamente riferimento a perlvar. Beh, non proprio, visto che trovo The Perl Pocket Reference molto più facile da usare.

Hai la versione giusta del modulo?

Alcuni moduli cambiano il loro comportamento da una versione all'altra. Hai la versione del modulo che pensi di avere? Puoi controllare la versione della maggior parte dei moduli con una semplice riga di perl.

        perl -MNome::Modulo -le 'print Nome::Modulo->VERSION';

Se consulti la maggior parte della tua documentazione sul web, ad esempio su http://www.perldoc.com oppure http://search.cpan.org, invece che leggere quella che hai sulla tua macchina, è più facile che tu finisca per leggere la documentazione di una versione diversa da quella che hai.

Hai scritto dei piccoli test?

Se stai sperimentando qualcosa di nuovo, o se pensi che una particolare porzione di codice si stia comportando in maniera bizzarra, scrivi il programma più breve possibile che implementi quella porzione e nient'altro. Questo toglie di mezzo la maggior parte dei fattori irrilevanti. Se questo breve programma di test fa quello che pensi debba fare, probabilmente il problema non sta in quel codice. Se il programma non fa quello che pensi debba fare, forse hai trovato il problema.

Hai controllato l'ambiente?

Alcune cose dipendono dalle variabili d'ambiente. Sei sicuro che siano impostate con i valori giusti? Il tuo ambiente è lo stesso che il programma vede quando è in esecuzione? Ricordati che i programmi eseguiti via CGI o cron, possono vedere ambienti differenti rispetto a quelli eseguiti nella tua shell, specialmente su altre macchine.
Perl mette a disposizione l'ambiente tramite %ENV. Se hai bisogno di una di queste variabili, fornisci un valore di default per quando non esiste, anche solo a scopo di test.
Se hai ancora qualche problema, esamina l'ambiente.

        require Data::Dumper;
        print STDERR Data::Dumper::Dumper( \%ENV );

Hai controllato Google?

Se hai un problema, probabilmente qualcun altro l'ha già avuto. Controlla se qualcuno ha già pubblicato qualcosa su usenet nel gruppo comp.lang.perl.misc, tramite la ricerca con Google Groups (http://groups.google.com/). La differenza tra le persone che fanno domande su usenet e quelle che rispondono, sta nell'abilità di usare Google Groups.

Hai misurato le prestazioni della tua applicazione?

Se vuoi scovare le parti lente del programma, ne hai misurato le prestazioni? Fai fare il lavoro pesante a Devel::SmallProf. Devel::SmallProf conta le volte che perl esegue ciascuna linea di codice e quanto impiega ad eseguirla, e stampa un bel resoconto.

Quale test fallisce?

Se hai una suite di test, qual'è il test che fallisce? Dovresti essere in grado di scovare l'errore molto velocemente, visto che ogni test dovrebbe esercitare solo una piccola porzione di codice.
Se non hai una suite di test, perché non farne una? Se hai uno script davvero breve o si tratta di un uno script usa e getta, non ti obbligo certo a scrivere un paio di test. In tutti gli altri casi, un po' di script di test portano molti vantaggi. Test::Harness rende l'esecuzione dei test talmente semplice, che non hai proprio alcuna scusa per non scriverli. Se non ne hai il tempo, forse stai sprecando troppo tempo nel fare il debug degli script senza i test. MakeMaker e simili non sono solo per i moduli, si possono usare anche per gli script.

Hai parlato con l'orsacchiotto?

Spiega il tuo problema ad alta voce. Pronuncia davvero le parole.
Per un paio d'anni ho avuto il piacere di lavorare con un programmatore davvero bravo che riusciva a risolvere praticamente qualsiasi cosa. Quando ero proprio bloccato, andavo alla sua scrivania e iniziavo a spiegare il problema. Di solito non arrivavo alla terza frase senza dire "Lascia perdere, ho capito". Non si sbagliava quasi mai.
Visto che ti capiterà piuttosto spesso, ti consiglio di procurarti un qualche peluche che ti faccia da "psicanalista" Perl, in modo da non disturbare i tuoi colleghi. Io ho un orsetto seduto sulla mia scrivania, al quale spiego i miei problemi. La mia ragazza non fa neppure più caso a quando parlo da solo.

Il problema sembra differente sulla carta?

Stai guardando fisso il monitor del computer; magari un supporto differente ti farà vedere le cose in un una maniera diversa. Prova a dare un'occhiata ad una stampa del tuo programma.

Hai guardato il quiz quotidiano con Gerri Scotti?

Davvero. Se non vi piace Gerri Scotti, sceglietevi qualcos'altro. Fate una pausa. Smettete di pensare al problema per un po' e lasciate che la vostra mente si rilassi. Torna al problema più tardi, e la sua risoluzione potrebbe essere immediatamente ovvia.

Hai cestinato il tuo ego?

Se, arrivati a questo punto, non hai ancora risolto, il problema potrebbe essere psicologico. Potresti essere emotivamente legato ad una certa parte del codice, per cui non vuoi cambiarlo. Potresti anche pensare che tutti abbiano torto tranne te. Ogni volta che pensi qualcosa del genere, non stai prendendo seriamente in considerazione la più probabile fonte di bug -- tu stesso. Non ignorare nulla. Verifica tutto.

AUTORE

brian d foy, <bdfoy@cpan.org>

TRADUZIONE

Traduzione a cura del gruppo di www.perl.it Originale disponibile presso http://www.pair.com/~comdog/brian's_guide.pod

COPYRIGHT

Redirezione

polettix — 2008-06-21T20:57:12+02:00

Capita a volte di voler redirigere l'output di un programma su un file, o da qualche altra parte. Altre volte, invece, vorremmo che gli input arrivassero da dove diciamo noi, invece che da dove il programma pensa che stiano arrivando. A volte, infine, abbiamo bisogno che queste redirezioni siano temporanee, e dopo un po' vogliamo ``tornare indietro''. Vediamo un po' come fare.

Dare una riordinata in Perl

guest — 2008-06-05T12:25:36+02:00

Dati di classe in Perl

guest — 2008-02-07T14:25:04+02:00

Probabilmente, una delle cose più sorprendenti per chi proviene da altri linguaggi è la incredibile varietà di approcci all'object orientation che offre il Perl.
Come se non bastassero la libertà e flessibilità offerte dal linguaggio nel 'fai da te', esistono le soluzioni preconfezionate su CPAN, dalle più leggere e semplici a quelle più estese e complesse, dai metamodelli e class class generators (MOP, Moose) all'implementazione del Design By Contract (Class::Contract).
Anche per un perlista esperto, il numero di moduli dedicati all'OO su CPAN è qualcosa che lascia disorientati.

In questo articolo voglio parlare di un aspetto dell'OO che in Perl è relativamente trascurato, o quantomeno che non ha trovato per me le soluzioni che avrei voluto. Si tratta dei dati di classe, detti anche dati statici. Persino in Programming Perl Third Edition § 12.8 si può leggere, "No matter how you roll it, package-relative class data is always a bit awkward.".
Come noto, questi dati sono condivisi da tutti gli oggetti della classe e servono tipicamente a mantenere uno stato globale, informazioni comuni, o tenere traccia di quello che la classe sta facendo.

Contextual::Return - una recensione

larsen — 2008-01-25T11:30:00+02:00

Per chi non lo conoscesse, Damian Conway è uno dei punti di riferimento nella comunità Perl: moduli, libri, conferenze... Una delle sue ultime fatiche, Perl Best Practices, riporta una serie di 256 raccomandazioni per migliorare il proprio modo di produrre codice.

Una cosa che ho trovato interessante nel libro è stata il fatto che, in moltissime occasioni, sembra una promozione dei propri moduli pubblicati su CPAN. Non so, m'è sembrato un po' autocelebrativo, ma se non si autocelebra Conway parlando di Perl... chi può farlo?

In una raccomandazione, in particolare, suggerisce di utilizzare il modulo Contextual::Return, che permette di restituire, in uscita da una funzione, valori differenti a seconda del contesto in cui la funzione viene chiamata.

Graylister - proviamo a fermare lo "SPAM"

dakkar — 2008-01-14T16:40:54+02:00

Un po' di storia

Non provo neppure a spiegare cosa si intende con "spam" parlando di posta elettronica. Se non lo sapete, vuol dire che non avete usato la posta elettronica negli ultimi <troppi> anni, per cui questo articolo non vi interessa :-).

Matrici in Perl

jontk — 2007-11-05T10:42:13+02:00

Se uno dà un'occhiata rapida al manuale (in particolare perlvar), scopre un'interessante verità circa i principali tipi di variabili in Perl:

scalari: possono contenere un valore singolo, di varia natura (come un numero, o una stringa);
array: sono delle collezioni ordinate di elementi - elementi scalari;
hash: sono delle associazioni fra stringhe (dette chiavi) e valori, i quali sono, nuovamente, degli scalari.

Così, di primo acchito, verrebbe da dire che non ci sia molto per sbizzarrirsi. O valori singoli, oppure insiemi che contengono valori singoli. Ma allora una matrice come la rappresentiamo?!? Come facciamo ad aggiungere dimensioni ad un semplice array?

Gtk2, Perl e Drag&Drop

dakkar — 2007-09-06T09:01:27+02:00

Avevo bisogno di un modo semplice per tenere una coda di "cose da leggere". Mi capita spesso di trovare in rete dei riferimenti interessanti, ma di non avere tempo / modo di leggerli sul momento. Certo, ci sono i "bookmark", ma li sento un po' troppo permanenti (sì, uso un'applicazione web per gestirmi i bookmark in modo centralizzato, ma quello è materiale per un altro articolo). Per cui ho pensato di avere un piccolo "riquadro" su cui trascinare delle URL, e ritrovarmele in una cartella del mio account di posta, da cui posso riprenderle con comodo, e cancellare dopo lette.

Perl Template Toolkit

larsen — 2007-02-03T12:44:59+02:00

Tra gli sviluppatori Perl circola una battuta scherzosa secondo la quale una delle tappe fisse dello studio del linguaggio è la realizzazione di un sistema di templating fatto in casa. Sono certo che si tratta di una battuta diffusa anche presso altri gruppi di programmatori, per lo meno tra coloro che usano linguaggi adatti allo sviluppo di applicazioni web.

Introspezione!

dada — 2007-01-08T19:16:16+02:00

Capita ogni tanto che, sul canale IRC #perl.it, qualcuno o qualcosa venga ad accendere una scintilla d'interesse in una altrimenti grigia e noiosa giornata lavorativa. Cos'è un canale IRC, chiedete? Quello che comunemente passa sotto il nome di chat, e nella fattispecie la chat sulla quale si possono trovare molti degli autori di Perl.it (praticamente tutti). Se qualcuno di voi sta pensando che la chat sia una cosa da scellerati perdigiorno o adolescentelli brufolosi che non hanno una vera vita, si dovrà ora ricredere. Perlomeno per quanto riguarda i brufoli, che personalmente avevo una quindicina d'anni fa :-)