[Hollywood] Introduzione + Help Library

[Allanon]

• 

Innanzi tutto una piccola introduzione:
Hollywood è un linguaggio multipiattaforma in grado di compilare per quasi tutto, da quest'ultima release il compilatore è in grado di produrre eseguibili anche per Linux perciò sono coperte tutte le principali piattaforme nonchè i nostri amati sistemi Amiga e Amiga-like, per chi vuole informazioni più dettagliate può visitare la pagina ufficiale di Hollywood:
http://www.airsoftsoftwair.com/

L'autore di questo ambiente di sviluppo (Andreas Falkenhahn) definisce la propria creatura come:

Hollywood is a multimedia-oriented programming language that can be used to create graphical applications very easily

Tuttavia io ritengo che Hollywood sia adatto a programmi di tutti i tipi, logicamente multimedia, general purpose, giochi, ecc... il core di Hollywood si basa su Lua, un linguaggio di scripting molto conosciuto ed estremamente flessibile e potente, disponibile per praticamente ogni sistema operativo.

Sviluppo regolarmente con Hollywood ormai da qualche anno, l'ho scoperto dopo aver provato a fare qualcosina con Lua, e l'ho trovato fenomenale.

Fenomenale per tre motivi principali:
1. Ha praticamente tutti i lati positivi di Lua
2. Supporta pienamente tutti i sistemi Amiga e Amiga-like
3. Crosscompila per moltissime piattaforme, e a meno che non vengano usate caratteristiche particolari di un sistema la ricompilazione non necessita di grosse modifiche del codice.

Questa tuttavia non vuole essere una recensione, ma vorrei proporre alcune librerie che ho scritto presentandole come tutorial per chi ha voglia di imparare questo linguaggio o semplicemente per chi già programma e vuole semplificarsi la vita con queste librerie.
Si presuppone una infarinatura di Basic generico

-----------------------------------------------------------------------------------------------------

Le librerie in Hollywood non sono altro che un insieme di definizioni e funzioni che possono essere utilizzate in qualsiasi progetto semplicemente "includendo" il codice della libreria nel proprio progetto.

In questo prima serie presento la più semplice delle mie librerie che ho chiamato Help Library, il nome del file in cui è definita si chiama Helpers.hws (.hws è l'estensione standard dei sorgenti di Hollywood che sta per Hollywood Script, ma è possibile chiamarli come si vuole in piena filosofia Amiga).

Per poter utilizzare queste librerie è necessario direal compilatore che deve includere questa libreria nel nostro progetto, per fare ciò dobbiamo utilizzare il comando @INCLUDE, nel nostro specifico caso, in testa al nostro sorgente dovremmo scrivere il seguente comando:

Codice: [Seleziona]

@INCLUDE "Helpers.hws"
In questo caso il compilatore cercherà la libreria nel cassetto corrente, è opportuno quindi fare attenzione al percorso dove la libreria sarà salvata.

Questa libreria contiene alcune utili funzioni di uso comune, che sono:

Codice: [Seleziona]

 • HL.IsNil()                                      Verifica se il valore passato è NIL
  • HL.ParseArgs()            Effettua il parsing degli argomenti della riga di comando
  • HL.SafeNil()             Resituisce la stringa "NIL" se il parametro passatto è NIL
  • HL.Swap()                                               Scambia fra loro due valori

Tutte le funzioni e le variabili utilizzate sono memorizzate nella tabella HL.


--------------------------------------------------------------------------
HL.IsNil(value)
--------------------------------------------------------------------------
Questa funzione verifica il parametro value e restituisce TRUE se è NIL, in caso contrario resituisce FALSE.
Ma cosa significa NIL?
NIL è un valore particolare assegnato alle variabili non inizializzate, può essere inteso anche come un non-valore, ossia come viariabili senza un valore.
Purtroppo in Hollywood non esiste un modo per verificare direttamente se una variabile è inizializzata o meno, perciò mi sono creato questa piccola funzione adatta allo scopo, ecco il codice:

Codice: [Seleziona]

Function HL.IsNil(value)
;———————————————————————————————————————————————————————————————————————————————
; Returns TRUE if <value> is NIL otherwise returns FALSE
;-------------------------------------------------------------------------------
; INPUT:
;  • value        value to check against NIL
;
; OUTPUT:
;  • result       TRUE if <value> is NIL, otherwise FALSE
;-------------------------------------------------------------------------------
   
   If GetType(value) = #NIL Then Return(True) Else Return(False)
   
EndFunction

Se si tolgono i commenti rimarrà una sola riga di codice:

Codice: [Seleziona]

  If GetType(value) = #NIL Then Return(True) Else Return(False)

Come si può intuire la chiave sta nel comando GetType() con il quale è possibile risalire al tipo di variabile che stiamo analizzando, per le variabili non inizializzate questo comando restituisce #NIL che è una costante particolare di Hollywood che ci da proprio l'indicazione che cerchiamo.

Gli altri tipi di variabile che GetType() può restituire sono:
#NUMBER per le variabili numeriche
#STRING per le variabili di testo
#TABLE per le tabelle
#FUNCTION per le funzioni
#NIL per le variabili non inizializzate
#USERDATA, #LIGHTUSERDATA e #THREAD in altri casi non ancora documentati nel manuale ufficiale

In attachment c'è la libreria completa, nei prossimi post spiegherò le altre funzioni. Se avete domande non fate i timidi  :greetings-cya:

[TheKaneB]

• 

grande! grazie per il tuo prezioso contributo!  :clap:

[Allanon]

• 

Dobbiamo diffondere il verbo  :lol:

[AmigaCori]

• 

Che bello!, grazie!!!  

Inizia ad avere una sua utilita' il sito

[rebraist]

• 

holliwood mi piace.
/me prende appunti.

[Allanon]

• 

Allora, eccomi qua per spiegare un'altra semplicissima funzione, ricordo che sto partendo proprio da cose estremamente semplici per permettere a tutti di capirle e prendere confidenza con questo linguaggio  

--------------------------------------------------------------------------
HL.SafeNil(value)
--------------------------------------------------------------------------
Diciamo che anche questa funzione è abbastanza banale ma mi resta molto comoda quando devo concatenare delle variabili stringa tra loro, tuttavia se una di queste stringhe è NIL Hollywood si inalbera e da errore  

Cosa sono le stringhe?
Le stringhe sono sequenze di caratteri alfanumerici, ad esempio 'pippo' è una stringa 'gianni ha 35 anni' è un'altra stringa e così via.
Una stringa vuota è semplicemente una sequenza di caratteri vuota, ossia senza caratteri. Per inizializzare una variabile stringa si può fare come segue:

Codice: [Seleziona]

Local stringa1 = "" ;     questa è una stringa vuota
Local stringa2 = "ciao!" ; questa è un'altra stringa

Concatenare le stringhe?  :?
Certo! Concatenare due o più stringhe significa semplicemente mettere in sequenza i vari caratteri delle stringhe da unire in una singola variabile, esempio:

Codice: [Seleziona]

Local risultato = "Il mio nome è " .. "Fabio"
Come si vede per unire due o più stringhe si usa l'operatore ..

Altro esempio:

Codice: [Seleziona]

DebugPrint("Il mio nome è " .. nome)
In questo caso la variabile nome non è stata inizializzata, pertanto vale NIL e Hollywood non gradisce concatenare stringhe con variabili non inizializzate: risultato il programma si interrompe ed esce inaspettatamente.

Prima regola del programmatore:
MAI, e dico MAI permettere al proprio programma di uscire in maniera inaspettata, e soprattutto incomprensibile per l'utente finale.

La funzione che ho fatto mi aiuta moltissimo proprio in questo ultimo caso, ossia quando devo concatenare delle stringhe per le quali non ho idea di cosa conterranno e devo fare in modo che se una di queste variabili sia a NIL il programma non si interrompa.

Ecco il codice semplicissimo di questa funzione:

Codice: [Seleziona]

Function HL.SafeNil(value)
;———————————————————————————————————————————————————————————————————————————————
; Returns the string 'NIL' if <value> is Nil, otherwise returns <value> without
; modifications.
;———————————————————————————————————————————————————————————————————————————————
; INPUT
;  • value        value to check against NIL
;———————————————————————————————————————————————————————————————————————————————
; OUTPUT
;  • Result       'NIL' if <value> is Nil, otherwise <value>
;———————————————————————————————————————————————————————————————————————————————
; NOTES
; This func is useful for string concatenations where there is a risk that
; the value to concatenate can be Nil, in this case the concatenation will raise
; an error breaking the code execution.
;
; Example:
;   DebugPrint("Hello " .. b)    ; In this case if <b> is Nil an error is raised
;   DebugPrint("Hello " .. HL.SafeNil(b)) ; No errors will be raised in case <b>
;                                         ; is Nil, at least you will get the
;                                         ; output:  Hello NIL
;-------------------------------------------------------------------------------

   If HL.IsNil(value)
      Return("NIL")
   Else
      Return(value)
   EndIf
   
EndFunction
Questa funzione fa una semplicissima cosa:
Se <value> è NIL restituisce una stringa contenente la parola "NIL" altrimenti restituisce <value> senza alcuna modifica.

Un'ora di spiegazione per questa cavolata di funzione? Che ci faccio adesso?
Esempio pratico
Ho una funzione che mi stampa sulla console dei messaggi per monitorare lo svolgimento del programma:

Codice: [Seleziona]

Function stampa_messaggio(messaggio)
   DebugPrint("Messaggio ricevuto:" .. messaggio)
EndFunction

Se <messaggio> è NIL il programma si interrompe con un errore, mentre se uso:

Codice: [Seleziona]

Function stampa_messaggio(messaggio)
   DebugPrint("Messaggio ricevuto:" .. HL.SafeNil(messaggio))
EndFunction
...tutto scorre come dovrebbe senza errori imprevisti  8-)

Per concludere una piccola nota sulla concatenazione: è possibile concatenare stringhe e numeri indistintamente, al momento della concatenazione Hollywood convertirà automaticamente i numeri in stringhe, provare per credere:

Codice: [Seleziona]

Local numero = 12
DebugPrint("Concatenare stringhe con numeri -->" .. numero)

La prossima volta facciamo qualcosina di leggermente più complesso  :obscene-smokingsombrero:
A presto  :whistle:

[rebraist]

• 

cool!!
NIL è l'equivalente di NULL del C.
Interessanti le GetType per la determinazione del tipo di dato, nonchè la Hl.SafeNil (un vero salvagente da quel che leggo) e la concatenazione di stringhe eseguite con la coppia di punti.
Aspetto la prossima lezione :clap:

[Allanon]

• 

Oggi vediamo un'altra funzione, un po' più complessa, della mia Help Library
--------------------------------------------------------------------------
HL.ParseArgs(CaseSensitive)
--------------------------------------------------------------------------
Premetto che esiste già una funzione di Hollywood che mette a disposizione in una tabella tutti gli argomenti passati nella riga di comando, tuttavia io sono un tipo pignolo, e come mi presenta i dati non mi soddisfa: per questo ho deciso di manipolare il risultato ottenuto per avere questi valori in una tabella molto più flessibile.

Procediamo con calma.

GetCommandLine() è il comando di Hollywood che restituisce, all'interno di una tabella, tutti i parametri specificati nella riga di comando. Supponiamo che il nostro programma si chiami "test", se io da shell digito:

Codice: [Seleziona]

>test -parametro1 ciao -parametro2 mondo
e che nello script vi sia un qualcosa di simile:

Codice: [Seleziona]

Local argomenti, conteggio = GetCommandLine()
Avrò come risultato la tabella <argomenti> così composta:
posizione 0 -> { arg = "-parametro1", param = "ciao" }
posizione 1 -> { arg = "-parametro2", param = "mondo" }
mentre <conteggio> riporterà il numero di parametri specificati, in questo caso 2

Esempio di come accedere a questi dati:

Codice: [Seleziona]

DebugPrint(argomenti[0].arg, argomenti[0].param)
DebugPrint(argomenti[1].arg, argomenti[1].param)


A questo punto io ho già un problema: se nel mio codice voglio sapere se l'utente ha specificato il -parametro2 come faccio?
Semplice, scorro la tabella con un ciclo For .. Next e se incontro ciò che cerco significa che l'utente l'ha specificato!
Si ok, ma se devo verificare tutti i parametri? E se il mio programma supporta tantissimi argomenti? Questa soluzione non è efficiente, non posso effettuare dei cicli For .. Next a raffica per ogni argomento da controllare!!

HL.ParseArgs() si occupa quindi di manipolare il risultato di GetCommandLine() e mi restituisce una tabella accessibile direttamente con il nome del parametro stesso.

Questo è possibile perchè in Hollywood (ed anche in LUA) è possibile indicizzare le tabelle con qualsiasi cosa, comprese le stringhe. Per chi è abituato al basic classico conoscerà sicuramente le tabelle, vettori o array come dir si voglia: le tabelle di Hollywood sono molto più dinamiche ma soprattutto possono contenere qualsiasi cosa ed essere indicizzate con qualsiasi cosa, nel caso specifico la tabella restituita da HL.ParseArgs() sarà indicizzata così:
posizione "parametro1" -> "ciao"
posizione "parametro2" -> "mondo"

Micro-Tour sulle tabelle:

Codice: [Seleziona]

; Tabella classica
Local classica1 = { "rosso", "verde", "giallo" }

; equivale a
Local classica2 = {}
classica2[0] = "rosso"
classica2[1] = "verde"
classica2[2] = "giallo"

; Tabella indicizzata con stringhe
Local computer1 = { cpu = "i5", clock = "2.26GHz", ram = "8Gb" }

; che equivale a scrivere
Local computer2 = {}
computer2["cpu"] = "i5"
computer2["clock"] = "2.26GHz"
computer2["ram"] = "8Gb"

; che, ancora, equivale a scrivere
computer3 = {}
computer3.cpu = "i5"
computer3.clock = "2.26GHz"
computer3.ram = "8Gb"

La potenza delle tabelle indicizzate con stringhe sta nel fatto che gli elementi possono essere recuperati direttamente, proprio come strutture dati, o record:

Codice: [Seleziona]

DebugPrint(computer1.cpu)
; Stamperà su console esattamente <i5>
E' chiaro che se avrò tutti gli argomenti in una tabella del genere non dovrò più effettuare i cicli For .. Next sprecando inutile tempo macchina, ma dovrò semplicemente tentare di accedere all'elemento che mi interessa, se questo esiste significa che l'utente lo ha specificato, altrimenti ciccia  

Per adesso mi fermo, consiglio a chi possiede Hollywood di dare un'occhiatella veloce alla sezione dove vengono spiegate le tabelle (sezione 5.3), sono fondamentali per utilizzare delle tecniche di programmazione decisamente carine e rapide.

La prossima volta spiego come ho implementato la funzione e le istruzioni coinvolte.
 :teasing-blah:

[divina]

• 

@Allanon

molto molto molto interessante grazie

[Allanon]

• 

prego!  

[Allanon]

• 

...dunque, dicevamo?  

Ecco il codice che ho utilizzato per la funzione HL.ParseArgs():

Codice: [Seleziona]

Function HL.ParseArgs(CaseSensitive)
;———————————————————————————————————————————————————————————————————————————————
; Parse command line arguments and return a table indexed by the argument and
; with the value equal to the parameter.
; Case sensitive is switched by default to TRUE, set to FALSE to parse arguments
; and parameters without case distinctions.
;———————————————————————————————————————————————————————————————————————————————
; INPUT
;  • CaseSensitive   Optional switch to activate (True) case sensitive argument
;                    recognition, defaults to True.
;———————————————————————————————————————————————————————————————————————————————
; OUTPUT
;  • Result          A table indexed with the argument and with the value equal
;                    to the argument value.
;———————————————————————————————————————————————————————————————————————————————
; NOTES
; Example:
;   shell>MyHWTest -test1 10 -test2 hello
;
;   HL.ParseArgs() will return the following table:
;   result = { test1 = '10',
;              test2 = 'hello' }
;-------------------------------------------------------------------------------

   If HL.IsNil(CaseSensitive) Then CaseSensitive = False
   
   Local Result = {}
   Local Args, ArgsCount = GetCommandLine()

   Local index, value = NextItem(Args)
   While GetType(index) <> #NIL
      If Not(CaseSensitive)
         Result[value.arg] = value.param
      Else
         Result[LowerStr(value.arg)] = LowerStr(value.param)
      EndIf
     
      index, value = NextItem(Args, index)
     
   Wend
   
   Return(Result)
EndFunction

Qua si comincia a vedere un po' di roba consistente  
Innanzitutto gestisco il valore di default del'argomento CaseSensitive questo perchè prevedo che questa funzione possa essere chiamata anche senza argomento e in questo caso CaseSensitive sarà assegnato a False come valore predefinito.

Codice: [Seleziona]

If HL.IsNil(CaseSensitive) Then CaseSensitive = FalseCome si vede utilizzo la funzione descritta qualche post indietro per verificare velocemente se CaseSensitive è stata specificata o meno.

Successivamente mi inizializzo una tabella che conterrà il risultato dell'elaborazione degli argomenti rilevati dalla riga di comando

Codice: [Seleziona]

Local Result = {}
E poi utilizzo il comando predefinito di Hollywood per leggere i parametri della riga di comando

Codice: [Seleziona]

Local Args, ArgsCount = GetCommandLine()
Adesso c'è il ciclo vero e proprio per convertire la tabella restituita da GetCommandLine() in una tabella indicizzata con il nome dell'argomento stesso.

Il ciclo di analisi viene eseguito con un loop particolare che utilizza il comando NextItem() per scorrere tutti gli elementi di una tabella, nel nostro caso la tabella restituita da GetCommandLine(): in pratica non è altro che un modo per scorrere una lista di elementi memorizzati in una tabella.

Vediamo pezzo per pezzo il codice:

Codice: [Seleziona]

  Local index, value = NextItem(Args)
   While GetType(index) <> #NILInizializzo <index> e <value> con il primo elemento e il primo valore della tabella <Args>
Dopodichè inizializzo un ciclo While ... Wend e come condizione pongo che <index> sia diverso da #NIL, questo perchè quando NextItem() raggiunge la fine della tabella restituisce NIL come indice, <value> invece prende il valore dell'elemento corrente su cui ci siamo posizionati con NextItem().
Quindi il ciclo prosegue fino a che non abbiamo raggiunto la fine della tabella.

Codice: [Seleziona]

     If Not(CaseSensitive)
         Result[value.arg] = value.param
      Else
         Result[LowerStr(value.arg)] = LowerStr(value.param)
      EndIf
Qua avviene la conversione, ossia memorizzo nella tabella <Result> alla posizione <value.arg> il valore <value.param>, ossia

Codice: [Seleziona]

Result[argomento_riga_di_comando] = valore_argomento_riga_di_comando
L' If ... Then ... EndIf serve solo a rendere tutto minuscolo (utilizzando LowerStr()) nel caso in cui si sia chiamata la funzione con CaseSensitive = False.

Per finire recupero il prossimo elemento della tabella da elaborare:

Codice: [Seleziona]

     index, value = NextItem(Args, index)
E chiudo il ciclo While

Codice: [Seleziona]

  Wend
Al termine dell'elaborazione restituisco la tabella dei risultati:

Codice: [Seleziona]

  Return(Result)

Esempio pratico dell'utilità di questa funzione
Voglio creare un visualizzatore di immagini da riga di comando che possa interpretare le seguenti coppie di argomenti:
-image <nome_file_da_aprire>
-fullscreen <0=off, 1=on>
-quitkey <tasto_da_premere_per_uscire>

Codice: [Seleziona]

...
Local arguments = HL.ParseArgs()
If GetType(RawGet(arguments, "image")) <> #NIL Then load_image
If GetType(RawGet(arguments, "fullscreen")) <> #NIL Then set_fullscreen
If GetType(RawGet(arguments, "quitkey")) <> #NIL Then set_quitkey

...
Function load_image()
   LoadBrush(1, arguments.image)
   ...
EndFunction

Vedete quanto è semplice testare se un argomento è stato passato o meno? Neppure un For ... Next per scorrere gli argomenti, il controllo è immediato e rapidissimo, inoltre è facile anche accedere ai valori abbinati agli argomenti come si vede nella funzione dell'esempio <load_image>: il valore del parametro viene letto come se fosse il membro di una struttura  8-)

Spero di non avervi confuso le idee e me ne resto qua in stand-by 2/3 giorni in attesa di domande, se ce ne saranno  :whistle:

[AmigaCori]

• 

Io leggo...passivamente ma leggo Non ho domande da farti perche' non sto programmando pero'...insomma...volevo dirti che la guida e' molto interessante e magari ci sono altri come me che sono "passivi" ma apprezzano, quindi grazie del tempo che dedichi alla guida per impararci qualcosa

[cdimauro]

• 

Anche se Lua non mi piace proprio (io sono un pythonista sfegato ), ci sono anch'io che leggo.

P.S. Sarebbe interessante aggiungere la syntax highlight al codice. Apro un thread nell'apposita sezione.

[Allanon]

• 

Ottimo!
Almeno sarò ancora più motivato a proseguire... grazie dell'interesse dimostrato  

@cdimauro
Devo essere sincero: non ho mai provato Python anche se so che si tratta di qualcosa di enormemente diffuso e con svariati moduli per praticamente ogni cosa, nel mio percorso di ricerca del linguaggio perfetto (che ancora non ho trovato ) ho incontrato LUA e mi sono subito innamorato del suo modo di gestire i dati, nonche' della semplicità di programmazione e della possibilità di creare codice dinamico con infinite possibilità per sviluppare anche le applicazioni più complesse... poi ho riscoperto Amiga nella sua incarnazione moderna, e successivamente Hollywood che nonostante allo stato attuale abbia molti difetti (come ad esempio la mancata accelerazione HW di tutte le chiamate grafiche) ha anche moltissimi pregi, primo fra tutti il crosscompiling per quasi tutte le piattaforme esistenti senza eccessivi sforzi da parte del programmatore  8-)

[cdimauro]

• 

E' un vero peccato che Hollywood abbia deciso di impiegare LUA e non Python. Dalla sua LUA ha una ENORME facilità di embedding, per cui da questo punto di vista è giustificato. E' anche un linguaggio molto semplice e dinamico, e per questo ha attecchito.

Per contro, Python ha una sintassi decisamente più semplice, ma anche... ben più ricca. Ti permette di esprimere molte cose con meno codice, e in maniera più elegante. Poi è dinamico fino all'osso, per cui cose "strane" ne puoi fare a bizzeffe ("monkey patching" e metaprogrammazione in generale).

Non ti nascondo che man mano che mostri il tuo codice e lo analizzo, penso subito "con Python farei così; questo verrebbe più semplice; non c'è da controllare ogni volta il Nil; ecc. ecc."

D'altra parte "se siamo nerd, ci sarà un perché..." :lol: