La sintassi del linguaggio di programmazione SPiM Appendice B

(1)

Appendice B

La sintassi del linguaggio di programmazione SPiM

Introduciamo la Sintassi dei Programmi : Program ::= { Directive₁ ,.., Directive_N } Declaration₁ .. Declaration_M

Directive ::= directive sample Float { Integer } | directive graph

| directive plot Point₁ .. Point_n

Point ::= !Channel {as String } | ? Channel {as String }

| Name ( Value₁ ,.., Value_n ) {as String }

I Programmi possono essere una o più Dichiarazioni precedute in modo opzionale da una o più Direttive.

Le direttive possono essere di tre tipi:

directive sample Float { Integer }

Specifica la durata massima di una simulazione data dal numero in virgola mobile Float e il numero massimo di punti da calcolare dato dal numero intero { Integer }.

L'unità di misura del tempo non è data esplicitamente, ma è determinata dal tasso delle reazioni del programma.

Per esempio se il tasso delle reazioni e dato in secondi−1 allora il tempo di simulazione va considerato in secondi.

Il massimo numero di punti da calcolare serve per dare un minimo intervallo di tempo tra un punto e l'altro, per esempio se il tempo di simulazione è 10.0 e il numero massimo di punti è 1000 allora ci sarà un minimo intervallo di tempo di 0.01 tra un punto e l'altro.

Omettendo Integer verranno usati tutti i punti calcolati.

Se non viene specificata nessuna direttiva sample allora la simulazione termina con la terminazione del programma.

(2)

directive graph

Indica in quale formato grafico presentare il programma ( tipicamente in .dot) e i risultati della simulazione (.ps o .png per i grafici, .csv per i tabulati), per poter essere esportati in altri ambienti di sviluppo.

directive plot Point₁ .. Point_n

Specifica uno o più Point che devono essere registrati per ogni passo. Se non vengono specificati nessun Point allora vengono registrati tutti i possibili dati che passano in tutti i canali di trasmissione e in tutti i canali di ricezione per ogni passo di tempo.

I Point possono essere

!Channel {as String }

per registrare il numero delle possibili trasmissioni che avvengono in un determinato canale Channel ad ogni passo di tempo, i dati vengono associati in una lista al nome dato dalla stringa, che può essere opzionale in questo caso viene usato per default il nome !Channel stesso.

? Channel {as String }

per registrare il numero delle possibili ricezioni che avvengono in un determinato canale Channel ad ogni passo di tempo, e li associa nella lista al nome dato dalla stringa, che può essere opzionale in questo caso viene usato come nome ? Channel stesso.

Name ( Value₁ ,.., Value_n ) {as String }

per registrare le variazioni del numero dei processi, identificati dal nome e dai rispettivi parametri, per ogni passo di tempo, e associa i risultati nella lista ai

rispettivi nome dati dalle stringhe associate, o se non presenti i risultati vengono registrati con i nomi stessi dei processi Name ( Value₁ ,.., Value_n ) .

Se non vengono specificati i parametri allora viene registrata la somma dei risultati dei processi che hanno lo stesso nome.

(3)

Declaration₁ .. Declaration_M

Specifica l'ordine dell'esecuzione della sequenza di Dichiarazioni (almeno una).

Sintassi delle dichiarazioni :

Declaration ::= new Name {@ Value }: Type | type Name = Type

| val Pattern = Value | run Process

| let Definition₁ and .. and Definition_n Definition ::= Name ( Pattern1 ,.., Patternn ) = Process

Dichiarazioni di canali :

new Name {@ Value }: Type

Crea un nuovo canale con rate dato da Value (opzionale ) e del tipo Type e lo associa al nome Name .

Il rate è un numero in virgola mobile, e rappresenta il tasso di interazione del canale, se non specificato si considera infinito.

Dichiarazione di tipi :

type Name = Type

Crea un nuovo tipo Type e lo associa al nome Name .

Se il nome Name compare in Type allora si ha un tipo ricorsivo.

Dichiarazione di valori :

val Pattern = Value

Assegna il valore Value al nome in Pattern , se Pattern è una tupla di nomi Pattern₁ ,.., Pattern_n allora vengono assegnati n valori.

Dichiarazione del esecuzione di processi :

|run Process esegue il processo Process .

(4)

Dichiarazione di definizione di processi:

let Definition₁ and .. and Definition_n dichiara uno o più processi mutualmente ricorsivi.

Definizioni di processi :

Name ( Pattern₁ ,.., Pattern_n ) = Process

Assegna un dato processo Process al nome Name parametrizzato da zero o più argomenti dati dai nomi in Pattern

Un istanza di un dato processo può essere eseguita invocando il nome e i rispettivi valori degli argomenti.

La sintassi dei Processi : Process ::= ( )

| ( Process₁ | . . | Process_n ) | Action {; Process }

| do Action₁ {; Process₁ } or . . or Action_n {; Process_n } | Name ( Value₁ ,.., Value_n ) {; Process }

| replicate Action {; Process }

| if Value then Process {else Process } | match Value case Case₁ . . case Case_n | Integer of Process

| ( Declaration₁ .. Declaration_M Process ) Case ::= Value → Process

Processo nullo :

( )

Terminazione dell'esecuzione di un processo.

Composizione parallela :

( Process₁ | . . | Process_n ) Esegue uno o più processi in parallelo.

(5)

Azione :

Action {; Process }

Tenta di eseguire l'azione Action e poi esegue il processo Process , se nessun processo viene specificato dopo l'azione allora termina l'esecuzione.

Scelta :

do Action₁ {; Process₁ } or . . or Action_n {; Process_n }

Tenta di eseguire una tra due o più azioni che sono in competizione tra loro contemporaneamente. Una volta scelta l'azione Action_i le altre vengono scartate ed eseguita l'azione viene eseguito i processo associato Processi .

Se nessun processo è associato all'azione scelta allora termina l'esecuzione.

Istanziazione :

Name ( Value1 ,.., Valuen ) {; Process }

Produce una copia del processo identificato dal nome Name e assegna i valori ai rispettivi argomenti e poi esegue il processo in parallelo al processo dato Process .

Se non viene specificato nessun processo da eseguire in parallelo dopo l'istanziazione, l'esecuzione termina al termine del processo istanziato.

Duplicazione :

replicate Action {; Process }

Tenta di eseguire l'azione Action seguita dal processo dato Process poi genera una coppia del processo Action {; Process } e ritenta l'esecuzione.

Se nessun processo viene specificato dopo l'azione allora vengono eseguite due Action e poi termina l'esecuzione.

Condizionale :

if Value then Process {else Process }

Valuta la guardia booleana Value e se questa vale True esegue il dato processo Process , se viene specificato anche il ramo opzionale “else” allora viene eseguito il secondo processo dato se la guardia vale False oppure termina l'esecuzione.

(6)

Corrispondenza :

match Value case Case₁ . . case Case_n

Controlla se esiste una corrispondenza del valore Value tra i valori di uno o più Case_i che hanno la forma Value_i → Process_i .

Il controllo viene eseguito in sequenza ordinata dal primo all'ultimo caso, e alla prima corrispondenza viene eseguito il processo associato.

Se nessun caso corrisponde allora non viene eseguito niente e termina l'esecuzione.

Ripetizione :

Integer of Process

Esegue zero o più coppie del dato processo Process contemporaneamente, specificato dal numero intero dato Integer .

Dichiarazioni annidate :

( Declaration1 .. DeclarationM Process )

Esegue zero o più dichiarazioni nidificate seguite dal processo dato Process . La sintassi è vincolata in modo che le dichiarazioni nidificate non possono contenere nuove definizioni di processi, cioè possono essere dichiarati solo nuovi tipi “type Name = Type “, nuovi valori “val Pattern = Value “ o nuovi canali di comunicazione “new Name {@ Value }: Type “ .

La sintassi delle Azioni :

Action ::= delay@ Value

| !Channel {( Value₁ ,.., Value_n )}{* Value } | ? Channel {( Pattern₁ ,.., Pattern_n )}{* Value }

Ritardo :

delay@ Value {; Process }

Aspetta un periodo di tempo calcolato in modo stocastico in relazione al valore dato Value , e dopo esegue l'eventuale prossimo processo.

(7)

Trasmissione :

!Channel {( Value₁ ,.., Value_n )}{* Value }{; Process } Tenta di spedire zero o più valori nel canale specificato Channel .

Se esistono uno o più processi in parallelo che sono in ascolto nello stesso canale Channel allora può avvenire la sincronizzazione e i valori vengono spediti, e dopo viene eseguito l'eventuale prossimo processo.

Il rate basico del canale può essere moltiplicato per un dato valore Value . In questo modo si può modificare localmente il tasso di interazione del canale durante la simulazione, per influenzare la scelta del processo con cui sincronizzarsi.

Ricezione :

? Channel {( Pattern1 ,.., Patternn )}{* Value }{; Process }

Tenta di ricevere zero o più valori nel canale specificato Channel .

Se esistono uno o più processi in parallelo che sono pronti a trasmettere nello stesso canale Channel allora può avvenire la sincronizzazione e i valori ricevuti vengono assegnati ai rispettivi Pattern , e dopo viene eseguito l'eventuale prossimo processo.

Il rate basico del canale può essere moltiplicato per un dato valore Value . La sintassi dei modelli :

Pattern ::= Name {: Type }

| ( Pattern₁ ,.., Pattern_n ) | _

I modelli o pattern sono identificati dal nome Name eventualmente seguito dal tipo Type del modello, possono essere raggruppati più modelli (anche di tipo diverso) racchiusi tra parentesi tonde.

Un modello può essere una Wildcard identificata dal carattere “ _” per specificare un qualsiasi tipo di modello.

All'interno di un processo ad un modello può essere associato un valore dello stesso tipo con l'assegnamento

(8)

La sintassi dei Valori :

Value ::= String per le stringhe di caratteri | Integer per i numeri interi

| Float per i numeri a virgola mobile | Character per i caratteri

| True per i valori booleani | False

| int_ of _ float per considerare un numero float come intero | float_ of_ int per considerare un numero intero come float | sqrt per la radice quadrata

| Name per le variabili

| show Value per mostrare il valore (in formato String)

| Value > Value per il maggiore

| Value <= Value per il minore o uguale | Value >= Value per il maggiore o uguale continuiamo la sintassi dei valori

Value ::= ..

| Name ( Value1 ,.., Valuen ) per il costruttore di valori (almeno uno)

| [ ] per la lista vuota

| Value :: Value per creare una lista concatenando un valore ad una lista

(9)

Tabella dei risultati di operazioni tra valori:

tipo + - * / - (prefisso) relazioni

stringhe concatena _ _ _ _ Ordinamento

lessicografico

interi somma sottrazione moltiplica dividi negazione Ordinamento interi

float somma sottrazione moltiplica dividi negazione Ordinamento float

booleani or _ and _ not Ordinamento

lessicografico

caratteri _ _ _ _ _ Ordinamento

codice ASCII

liste appendi _ _ _ _ Ordinamento

della lista

dati _ _ _ _ _ Ordinamento lessicografico

altro _ _ _ _ _ _

Tabella 1: risultato operazioni La sintassi dei Tipo :

Type ::= string

| int | float | char

| bool

| Name per le variabili di tipo

| ' Name per i tipi polimorfi | chan { ( Type₁ ,.., Type_n ) } per il tipo canale | proc ( Type1 ,.., Typen ) per il tipo processo

| Name ( Type₁ ,.., Type_n ) per il costruttore di tipi

| Type₁ | .. | Type_n per la scelta tra i tipi dato ( almeno due) | list( Type ) per la lista di tipi

| ( Type₁ ,.., Type_n ) per il raggruppamento di tipi

In un canale di tipo chan ( Type₁ ,.., Type_n ) possono transitare zero o più valori di determinati tipi contemporaneamente.

Un tipo espressione può essere un Name di un tipo costruito in precedenza con il costruttore Name ( Type₁ ,.., Type_n ) , o un tipo polimorfo ' Name che può variare ed essere istanziato con un tipo arbitrario a tempo di esecuzione.

(10)

programma.

La sintassi lessicale :

Regexp ::= c un carattere

| c . . . c un range di caratteri |¬c caratteri complementari

| Regexp Regexp concatenazione di espressioni regolari | Regexp | Regexp alternativa tra espressioni regolari | Regexp? espressioni opzionali

| Regexp* ripetizione di espressioni

| Regexp+ ripetizione stretta di espressioni (almeno una) | ( Regexp ) annidamento di espressioni

Le espressioni regolari servono per descrivere la sintassi delle costanti e delle variabili del Linguaggio SPiM.

La sintassi delle Costanti Integer ::= (-)?

(0. . .9)+

String ::= “(( ¬ ”)|( \ ”)*”

Float ::= Integer . (0 .. . 9)+ ((e|E) (+|-)(0 . ..9)+)?

Character ::='(¬ ')' carattere normale

|'\'' singola virgoletta |'\\'' backslach

| '\n' nuova linea

| '\r' ritorno carrello a capo | '\t' tabulazione orizzontale | '\b' backspace

|'\ (0 .. . 9) (0 .. . 9) (0 .. . 9) ' carattere in codice ASCII.

La sintassi delle variabili :

Name ::= ((A . .. Z | a . .. z)( A . .. Z |a .. . z | 0 .. . 9 | _ | '))* Channel ::= Name

(11)

Lista dei nomi di variabili riservate in SPiM :

and as bool chan char delay directive do else float float_ to_ int if in int

int_ to_ floar false let list new out or of plot proc replicate run sample show sqrt string then true type val

Per commentare una frase dentro un programma scritto i SPiM si usano i caratteri (* per iniziare la frase e *) per finirla.

I commenti possono essere annidati ma non possono contenere al proprio interno virgolette singole ' o doppie “ .