nichel - Online nel Cloud

PROGRAMMA:

NOME

nichel - un linguaggio per calcolatrici da tavolo

SINOSSI

nichel [--help|--usage] [-f file] [-l libreria] [-e espressione] [ script ] [--] [arg ...]

DESCRIZIONE

Nickle è un linguaggio per calcolatrici da tavolo con potenti capacità di programmazione e scripting.
Nickle supporta una varietà di tipi di dati, in particolare interi con precisione arbitraria,
razionali e reali imprecisi. Il linguaggio di input assomiglia vagamente al C. Alcune cose in C
che non si traducono facilmente sono diverse, sono state fatte alcune scelte di progettazione
in modo diverso e mancano semplicemente pochissime funzionalità.

USO

Un argomento non contrassegnato viene trattato come uno script Nickle e sostituisce l'input standard. Qualsiasi
gli argomenti rimanenti che seguono lo script vengono inseriti nell'array di stringhe Nickle argv per
ispezione programmatica. Quando richiamato senza un'espressione o un argomento di script, Nickle
legge dall'input standard e scrive sull'output standard.

Le opzioni sono le seguenti:

--aiuto,--uso
Stampa un messaggio di aiuto/utilizzo ed esci. Questa è una funzionalità integrata di Nickle
Modulo ParseArgs, e quindi sarà vero anche per gli script Nickle che lo utilizzano
biblioteca.

-f,--file filetto
Caricare filetto in Nickle prima di iniziare l'esecuzione.

-l,--libreria biblioteca
Caricare biblioteca in Nickle prima di iniziare l'esecuzione. Vedi sotto per una descrizione
della struttura della biblioteca.

-e,--espressione espr
Valutare espr prima di iniziare l'esecuzione.

-- Esci dall'analisi degli argomenti e passa il resto, non valutato, a arv.

SINTASSI

Per rendere la lingua di input più utile in un ambiente interattivo, nuova linea termina solo
dichiarazioni in momenti ``ragionevoli''. Nuova linea termina le espressioni o singole
istruzioni digitate dall'utente (ad eccezione di alcune istruzioni che richiedono
lookahead: in particolare if() e twixt(), che hanno una parte else facoltativa). All'interno del composto
dichiarazioni o definizioni di funzioni, solo un ; termina le istruzioni. Questo approccio è
comodo e non sembra causare problemi durante il normale utilizzo.

La sintassi dei programmi Nickle è la seguente. In questa descrizione, Nome denota qualsiasi
sequenza di lettere, cifre e caratteri _ che non iniziano con una cifra; E denota qualsiasi
espressione; S indica qualsiasi affermazione; e T denota qualsiasi tipo. La sintassi X,X,...,X denota
una o più X separate da virgole, salvo diversa indicazione.

Commenti:

I commenti in stile C sono racchiusi tra /* e */, mentre i commenti in stile shell sono indicati da un
# iniziale all'inizio di una riga.

Operandi:

numero reale
Può includere l'esponente, non è necessario includere il punto decimale o il segno. Verrà trattato come
razionali esatti. Se una parte decimale finale contiene una parentesi graffa di apertura, il
la parentesi graffa viene ignorata silenziosamente; se contiene una parte finale tra parentesi graffe, è
trattati come un decimale periodico. Le costanti ``a virgola mobile'' sono attualmente
rappresentati internamente come razionali: per costanti flottanti con una data precisione
(e un esponente di precisione infinita), utilizzare la funzione incorporata imprecise()
descritto di seguito.

numero ottale
Inizia con 0 (ad esempio, 014 equivale a 12).

numero esadecimale
Inizia con "0x" (ad esempio, 0x1a è uguale a 26).

stringa Come in C. Le costanti stringa sono racchiuse tra virgolette doppie. Caratteri con barra rovesciata
(incluse le virgolette doppie) hanno un significato proprio, eccetto "\n" che sta per nuova riga,
"\r" per ritorno a capo, "\b" per backspace, "\t" per tabulazione e "\f" per avanzamento pagina.

nome Un riferimento a una variabile.

nome() nome(E,E,...,E)
Una chiamata di funzione con zero o più argomenti. Le funzioni sono completamente chiamate per valore:
gli array e le strutture vengono copiati anziché essere referenziati come in C.

desc nome T nome = valore
Espressioni di definizione: viene reso disponibile un nuovo nome, con il valore di
definizione essendo il valore dell'inizializzatore nella seconda forma e non inizializzato
nella prima forma. Il descrittore desc non è facoltativo: consiste in qualsiasi
combinazione di visibilità, classe di archiviazione o tipo (in quest'ordine). Vedi QUALIFICATORI
immediatamente sotto per una descrizione di questi qualificatori. Un valore strutturato
è possibile anche l'espressione: vedere VALORI di seguito.

Oltre a poter inizializzare una definizione con un valore Nickle, lo stile C
Sono consentite anche le definizioni di array, struttura e unione: ad esempio,
i seguenti
int[*,*] nome = {{0,1},{2,3}}
int[2,2] nome = {{0...}...}
sono consentiti con la semantica ovvia. Questo è il contesto in cui il
le dimensioni in un tipo possono essere espressioni: vedere la discussione sui tipi di array sopra.
Vedere la discussione sui valori di array e struttura per array e struttura
sintassi dell'inizializzatore.

QUALIFICAZIONE

Una dichiarazione o definizione può essere qualificata, come in C, per indicare i dettagli della programmazione
comportamento. A differenza del C, questi qualificatori, sebbene facoltativi, devono apparire nell'ordine indicato.

Visibilità:

pubblico Qualsiasi espressione di definizione (definizione di funzione, definizione di variabile, tipo
definizione) può essere qualificato con pubblico per indicare che il nome viene definito
dovrebbe essere visibile al di fuori dello spazio dei nomi corrente e dovrebbe essere automaticamente
importato. Per ulteriori informazioni, vedere la sezione Spazi dei nomi qui sotto.

protetta
Qualsiasi espressione di definizione (definizione di funzione, definizione di variabile, tipo
definizione) può essere qualificato con protetto per indicare che il nome viene definito
dovrebbe essere visibile al di fuori dello spazio dei nomi corrente, ma non dovrebbe essere reso disponibile
tramite dichiarazioni di importazione. Per ulteriori informazioni, vedere la sezione "Spazi dei nomi" di seguito.

Tutta la vita:

auto Un oggetto auto è locale a un blocco particolare: la sua durata è almeno
durata di quel blocco. Un oggetto automatico con un inizializzatore verrà reinizializzato
ogni volta che viene valutato. Questa è la durata predefinita per gli oggetti locali.

statico Un oggetto statico è locale a una particolare definizione di funzione: la sua durata è
almeno la durata di quella definizione. Un nuovo oggetto statico verrà creato ogni
momento in cui viene valutata la definizione della funzione che la racchiude.

In Nickle, la parola chiave static ha a che fare solo con la durata (come l'uso di static
all'interno delle funzioni C), non con visibilità (che è gestita da qualificatori separati
come descritto sopra, non come l'uso di static nell'ambito globale in C).

globale Un oggetto globale è globale per l'intero programma: la sua durata è la durata di
il programma. Un oggetto globale verrà creato e inizializzato quando la sua definizione
viene visualizzato per la prima volta. Questa è la durata predefinita per gli oggetti globali.

La distinzione tra durata statica e globale in Nickle non è possibile in C,
perché le funzioni C non sono oggetti di prima classe con ambito annidato. Quando si decide
quale utilizzare in un programma Nickle, pensa a cosa dovrebbe accadere se una definizione è
rivalutato.

OPERATORI

Ecco gli operatori Nickle di base, raggruppati in ordine di precedenza decrescente:

A[E,E,...,E]
Si riferisce all'elemento E'th dell'espressione array A, o E1'th/E2'th/etc
elemento di un array multidimensionale. Entrambi gli array di array ala C e
sono possibili array multidimensionali come NAWK.

struct.tag
Dereferenziazione della struttura.

struct->tag
Dereferenziazione del puntatore di struttura ala C.

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

++ -- Incremento/decremento unario. Può essere sia postfisso che prefisso.

- Negazione unaria

! E Negazione logica.

E ! Fattoriale. Richiede un argomento intero non negativo.

* Dereferenziazione del puntatore E.

& E Costruzione di riferimento.

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

(U) E Costruisci un valore di tipo unione con tag U e valore E.

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

** Esponenziale. Entrambi gli operandi possono essere frazionari. L'operando di sinistra deve essere non-
negativo a meno che l'operando destro non sia intero. Il tipo di risultato è il tipo di
operando sinistro se l'operando destro è un numero intero, altrimenti è un numero reale.

Questa è l'unica caratteristica nota di Nickle che non è valida: un'espressione come 2 ** -3
sarà staticamente di tipo intero, ma dinamicamente genererà un razionale
risultato. Ciò potrebbe causare un errore di tipo runtime in seguito: considerare
intero x = 2 ** -3;

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

* / // %
Per, divisione, divisione intera e resto. L'operando destro degli ultimi tre
gli operatori devono essere diversi da zero. Il tipo di risultato dell'operatore di divisione sarà sempre
almeno razionale: il tipo di risultato dell'operatore di divisione intera sarà sempre
int. Questa è una notevole deviazione da C, dove la divisione intera è implicita da
operandi interi. La divisione intera è definita da
x // y == y > 0 ? piano (x / y) : soffitto (x / y)
Il resto è sempre non negativo ed è definito da: da
x % y = x - (x // y) * y

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

+ - Addizione e sottrazione.

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

<< >> Spostamento a sinistra e a destra bit a bit con operandi interi. Funzionano anche gli operandi a destra negativi
come previsto. Questi operatori sono definiti da
x << y = x * 2 ** y
x >> y = x // 2 ** y
Un altro modo di vedere questo è che gli operandi negativi a sinistra sono considerati in
una rappresentazione in complemento a due infinito (cioè, segno esteso all'infinito), con
segno di spostamento a destra: estende il suo operando sinistro.

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

<= >= < >
Operatori relazionali.

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

== != Operatori di uguaglianza.

=============
Infine, in ordine decrescente di precedenza:

& AND bit a bit. Gli operandi negativi sono considerati in un complemento a due infinito
rappresentazione (cioè, segno esteso all'infinito).

^ XOR bit a bit. Operandi negativi come in AND bit a bit.

| OR bit a bit. Operandi negativi come in AND bit a bit.

&& Cortocircuita l'AND logico.

|| OR logico di cortocircuito.

E ? E : E
Espressione condizionale: se la prima espressione è logicamente vera, il valore è il secondo
espressione, altrimenti terza.

fork E Crea (e restituisce) un thread. Vedi Thread qui sotto per i dettagli.

= += -= *= /= //= %= **= <<= >>= ^= &= |=
Operatori di assegnazione. Il lato sinistro deve essere assegnabile. x = y è equivalente
a x = x y

E , E Restituisce l'espressione di destra.

TIPI

La sintassi della dichiarazione di tipo di Nickle assomiglia maggiormente alla variante ``sinistra'' di
Sintassi Java rispetto a quella C. In sostanza, un tipo è costituito da:

poli intero razionale reale stringa continuazione vuoto
Un tipo base del linguaggio. Il tipo void è in realtà utilizzabile solo in alcuni
contesti, in particolare i ritorni di funzione. Attualmente è implementato come tipo ``unità''
ala ML, e quindi ha un comportamento leggermente diverso rispetto a C. Il tipo poly è il
supertipo di tutti gli altri tipi (vale a dire, può essere utilizzato per inibire il tipo statico
controllo), ed è il tipo predefinito nella maggior parte delle situazioni in cui non è necessario che un tipo appaia.

file semaforo thread
Anche tipi di base incorporati, ma integrati negli ADT File e Thread: vedere sotto.

altro Informazioni tipi:

Nickle supporta dati polimorfici: quando un'espressione viene valutata, viene scelto un tipo di dati per
adattare il risultato. Qualsiasi oggetto Nickle può essere tipizzato staticamente, nel qual caso i limiti
le violazioni saranno segnalate come errori in fase di compilazione. Variabili e funzioni polimorfiche
non porre restrizioni sul tipo di dati assegnato; questo è il tipo predefinito per tutti
oggetti.

poly Descrive l'unione di tutti i tipi di dati. Una variabile con questo tipo può contenere
qualsiasi valore di dati.

int Interi di precisione arbitraria.

razionale
Numeri razionali di precisione arbitraria.

Numeri in virgola mobile con precisione esponente arbitraria. Poiché molti calcoli non possono
essere eseguiti esattamente come numeri razionali, Nickle implementa non precisi
aritmetica utilizzando la propria rappresentazione indipendente dalla macchina per i numeri in virgola mobile
numeri. La funzione incorporata imprecise(n) genera un numero reale con 256 bit
di precisione dal numero n, mentre imprecise(n,p) genera un numero reale con p
pezzi di precisione.

T[] Un array di tipo T, di una o più dimensioni. Non ci sono array di dimensione zero
array in Nickle.

T[*] Un array unidimensionale di tipo T. A differenza di C, la dimensione di un array non è mai
parte del suo tipo in Nickle. Inoltre, array e puntatori sono tipi non correlati in
Nichel.

T[*,*,...,*]
Un array bidimensionale o più di tipo T. Gli asterischi ``*'' non sono facoltativi. Come
i paragrafi precedenti chiariscono che ``T[]'' non è un array a dimensione zero.

T[E,E,...,E]
Nei contesti di definizione, è possibile fornire valori interi per ciascuna dimensione di un array
contesto. Questi sono strettamente finalizzati alla creazione di valore e non fanno parte del
tipo. Un tipo di array è determinato solo dal tipo di base e dal numero di dimensioni
della matrice.

T0() T0(T,T,...,T)
Una funzione che restituisce il tipo T0. Una funzione accetta 0 o più argomenti.

T0() T0(T,T,...,T ...)
Una funzione che accetta zero o più argomenti obbligatori, più un numero arbitrario di
argomenti facoltativi. La seconda sequenza di tre punti (ellissi) è la sintassi, non
metasintassi: vedere la descrizione delle funzioni varargs per i dettagli.

*TA puntatore a una posizione di tipo T. L'aritmetica dei puntatori in Nickle opera solo su
puntatori ad array: il puntatore deve essere del tipo corretto e non può mai deviare
fuori dai limiti. Un puntatore può puntare a una posizione o essere nullo (0). Come in
C, la precedenza di ``*'' è inferiore alla precedenza di ``[]'' o ``()'': usa
parentesi secondo necessità.

struct {T nome; T nome; ...}
Una struttura con campi del nome e del tipo specificati. I tipi T sono opzionali: in
in loro assenza, il tipo del campo è poli.

unione {T nome; T nome; ...}
Un'``unione disgiunta'' dei tipi dati. È più simile al tipo di record variante
di Pascal o il tipo di dati di ML rispetto al tipo di unione C: i nomi sono tag del
tipo dato, di cui esattamente uno si applica a un dato valore in un dato momento.

(T) Parentesi per il raggruppamento.

Typedef:

Come in C, è possibile creare nuovi nomi di tipo con l'istruzione typedef. La sintassi è
typedef T nometipo;
dove T è un tipo Nickle. Il nome del tipo risultante può essere utilizzato ovunque sia previsto un tipo.

VALORI

I valori dei tipi base di Nickle sono quelli previsti. Vedere la sintassi per le costanti sopra.
I valori di tipo file, semaforo e continuazione possono attualmente essere creati solo tramite chiamate a
funzioni predefinite: non esistono costanti Nickle di questo tipo.

Come notato in TIPI sopra, Nickle ha diversi tipi di ``valore strutturato'': array,
funzioni, puntatori, strutture e unioni disgiunte. Tutti questi hanno qualcosa in comune
proprietà. Quando vengono creati, tutti i valori dei componenti non sono inizializzati (a meno che non sia diversamente specificato)
specificato). I tentativi di utilizzare un valore non inizializzato comporteranno un errore in fase di compilazione
errore o un'eccezione in fase di esecuzione.

Array:

[E] crea un array (a base zero) con E elementi. E deve essere non negativo.

[E]{V,V,...,V}
Crea un array con E elementi, inizializzati a V. Se ce ne sono troppo pochi
inizializzatori, gli elementi rimanenti rimarranno non inizializzati.

[E]{V,V,...,V...}
La seconda ellissi (tre punti) è sintassi, non metasintassi. Crea un array con E
elementi. I primi elementi nell'array verranno inizializzati in base a V,
con tutti gli elementi rimanenti che ricevono lo stesso valore dell'ultimo V. Questa sintassi
può essere utilizzato nel modo ovvio con uno qualsiasi degli inizializzatori di array indicati di seguito.

[*]{V,V,...,V}
Crea un array inizializzato con esattamente tanti elementi quanti sono gli inizializzatori.
deve esserci almeno un inizializzatore.

[E,E,...,E] [*,*,...,*]
Crea array multidimensionali. Le espressioni intere e "*" non possono essere combinate: un
le dimensioni dell'array sono interamente specificate o non specificate dalla definizione.
Questi array possono anche essere creati inizializzati: vedere il paragrafo successivo per l'inizializzatore
sintassi.

(T[E]) (T[E,E,...,E]) (T[E]){E,E,...,E}

(T[E,E,...,E]){{E,...},...,{E,...}}
Sintassi alternativa per la creazione di array di tipo T. Gli inizializzatori, tra parentesi graffe,
sono facoltativi. Il numero di inizializzatori deve essere minore o uguale al dato
numero di elementi in ogni dimensione. Per gli array multidimensionali, il numero extra di elementi
sono necessarie parentesi graffe per dimensione nell'inizializzatore; questo è diverso da C, dove sono
sono opzionali.

(T[*]){E,E,...,E} (T[*,*,...,*]){{E,...},...,{E,...}}
Crea array di tipo T, con la dimensione di ogni dimensione data dal numero massimo di
inizializzatori in qualsiasi sottoarray in quella dimensione.

Suggerimenti:

0 Il puntatore nullo, nei contesti in cui è richiesto un puntatore.

&V &A[E,E,...,E] &S.N
Crea un puntatore alla variabile, all'elemento dell'array o al membro della struttura specificati.
il tipo del puntatore sarà *T, dove T è il tipo dell'oggetto puntato.

*P Il valore a cui punta il puntatore P. Può essere visualizzato o modificato come in C.

Funzioni:

(T func(){S;S;...S;}) (T func(T nome,T nome,...T nome){S;S;...S;})
Espressione di funzione: denota una funzione di zero o più parametri formali con l'
tipi e nomi specificati, restituendo il tipo di risultato specificato. Il corpo della funzione è specificato
dall'elenco di istruzioni racchiuso tra parentesi graffe. Tutti i tipi sono facoltativi e per impostazione predefinita sono
poly. Come notato sopra, le funzioni sono rigorosamente chiamate per valore: in particolare, gli array
e le strutture vengono copiate anziché referenziate.

Nome funzione T(nome T,nome T,...,nome T){S;S;...S;}
Definisce una funzione di zero o più argomenti. Zucchero sintattico per
T(T,T,...T) nome = (T func(T nome,T nome,...T nome){S;S;...S;});

Nome funzione T (nome T, nome T ...)
L'ellissi qui è sintassi, non metasintassi: se l'ultimo argomento formale a un
la funzione è seguita da tre punti, la funzione può essere chiamata con più valori effettivi
rispetto ai formali. Tutti gli effettivi ``extra'' sono impacchettati nell'array formale del
nome dato e verificato rispetto al tipo facoltativo T dell'ultimo argomento
(poli predefinito).

strutture:

(struct { T nome; T nome; ...T nome; }){nome = E; nome = E; ...nome=E;}
Crea un valore di tipo strutturato. I campi denominati vengono inizializzati al valore specificato
valori, con il resto non inizializzato. Come indicato, l'inizializzazione avviene tramite etichetta
piuttosto che posizionale come in C.

sindacati:

(unione { T nome; T nome; ...T nome; }.nome) E
Crea un valore del tipo di unione specificato, la variante fornita da .name e il valore
dato da E. E deve essere compatibile con il tipo name.

DICHIARAZIONI

La sintassi dell'istruzione assomiglia molto a quella del C. È stata aggiunta una sintassi aggiuntiva
aggiunto per supportare le funzionalità aggiuntive di Nickle.

E; Valuta l'espressione.

{S ... S}
Esegue le istruzioni allegate in ordine.

se (E) S
Condizionale di base.

se (E) S
Esecuzione condizionale.

else S Else è consentito, con la consueta sintassi e semantica. In particolare, un else lega
al più recente if() o twixt() applicabile.

mentre (E) S
Ciclo while in stile C.

fai S mentre (E);
Ciclo do in stile C.

per (opt-E; opt-E; opt-E) S
Ciclo for in stile C.

switch (E) { caso E: S-list caso E: S-list ... default: S-list }
Istruzione case in stile C. Non è necessario che le espressioni case siano costanti
espressioni, ma può essere arbitrario. Il primo caso valuta lo switch
viene preso l'argomento, altrimenti viene utilizzato il valore predefinito se presente, altrimenti il ​​corpo dello switch viene saltato.

twixt(opt-E; opt-E) S

twixt(opt-E; opt-E) S altrimenti S
Se la prima espressione dell'argomento viene valutata come vera, il corpo del twixt() e quindi
verrà valutata la seconda espressione di argomento. Se la prima espressione di argomento
viene valutato come falso, l'istruzione else verrà eseguita se presente. In caso contrario, l'
l'intera istruzione twixt() verrà saltata.

L'istruzione twixt() garantisce che tutti questi eventi si verificheranno nel tempo specificato
ordine indipendentemente dal modo in cui il twixt() viene inserito (dall'esterno) o esce,
comprese eccezioni, continuazioni e break. (Confronta con la clausola ``finally'' di Java.)

prova S;

prova S cattura nome (T nome, ...) { S; ... };

prova S cattura nome (T nome, ...) { S; ... } ... ;
Eseguire la prima istruzione S. Se viene sollevata un'eccezione durante l'esecuzione e
il nome corrisponde al nome in un blocco catch, associa i parametri formali nel catch
bloccare i parametri effettivi dell'eccezione ed eseguire il corpo del catch
blocco. Potrebbero esserci più blocchi di cattura per tentativo. Zero catture, sebbene legali, sono
relativamente inutile. Dopo il completamento di un blocco catch, l'esecuzione continua dopo
la clausola try. Come con else, un catch si lega al try-applicabile più recente
blocco di cattura.

raise name(nome, nome, ..., nome)
Genera l'eccezione denominata con zero o più argomenti.

; L'affermazione nulla

break; Interrompe l'esecuzione dell'istruzione for/do/while/switch/twixt più vicina.
L'espressione leave verrà eseguita quando si esce dall'istruzione twixt.

continua;
Passa direttamente al test condizionale del for/do/while più vicino
.

restituisci E;
Restituisce il valore E dalla funzione racchiusa più vicina.

Namespace:

Come Java e C++ Nickle ha una nozione di namespace, una raccolta di nomi con parzialmente
visibilità limitata. In Nickle, gli spazi dei nomi vengono creati con namespace comando.

opt-P namespace N { S ... }
Inserisce tutti i nomi definiti nelle istruzioni S in uno spazio dei nomi denominato N.
il qualificatore facoltativo P può essere la parola chiave public, ma attenzione: questo indica semplicemente
che il nome N stesso è visibile altrove nell'ambito corrente e non ha nulla
riguarda la visibilità degli elementi all'interno dello spazio dei nomi.

estendi lo spazio dei nomi N { S ... }
Riaprire lo spazio dei nomi N specificato ed estenderlo con i nomi definiti come pubblici in
dichiarazioni fornite S.

I nomi definiti all'interno dello spazio dei nomi sono invisibili all'esterno dello spazio dei nomi a meno che non
sono qualificati con la parola chiave pubblico. I nomi pubblici possono essere indicati utilizzando un
notazione del percorso:
namespace::namespace::...:namespace::nome
si riferisce al nome dato come definito all'interno del set di namespace specificato. Il
La sintassi dei due punti è infelice, poiché il suo significato è leggermente diverso rispetto a
C++, ma tutti i simboli validi sono stati presi e si ritiene che sia una caratteristica che
il separatore dello spazio dei nomi è sintatticamente diverso dall'operatore di struttura. In
Java, ad esempio, la frase
nome.nome.nome
è sintatticamente ambiguo: il secondo nome può essere una struttura o un
spazio dei nomi.

importa N;
Il nome N deve fare riferimento a uno spazio dei nomi: tutti i nomi pubblici in questo spazio dei nomi sono
inserito nell'ambito corrente (escludendo i nomi in conflitto).

COSTRUITI

Nickle ha una raccolta di funzioni standard integrate. Alcune di queste sono scritte in C,
ma molti sono scritti in Nickel. Diverse raccolte di funzioni hanno funzioni incorporate associate
tipi di dati: i loro namespace, insieme ai loro tipi, dovrebbero essere considerati come ADT.

Primo livello Incorporati:

int printf(string fmt, poly args...)
Chiama File::fprintf(stdout, fmt, args ...) e restituisce il risultato.

la funzione stringa ottiene ()
Chiama File::fgets(stdin) e restituisce il risultato.

funzione stringa scanf (string fmt, *poly args...)
Chiama File::vfscanf(stdin, fmt, args) e restituisce il risultato.

funzione stringa vscanf (string fmt, (*poly)[*] args)
Chiama File::vfscanf(stdin, fmt, args) e restituisce il risultato.

reale impreciso (valore razionale)
Vedere la discussione sul tipo reale sopra.

reale impreciso(valore razionale, int prec)
Vedere la discussione sul tipo reale sopra.

int string_to_integer(string s)

int atoi(stringa s)
L'argomento s è una stringa di cifre con segno e il risultato è l'intero che
rappresenta. Se la stringa s è sintatticamente esadecimale, ottale, binaria o
costante esplicita in base 10, trattala come tale.

int string_to_integer(string s, int base)

int atoi(stringa s, int base)
Tratta s come una stringa di cifre nella base data. Una base di 0 si comporta come se non ci fosse alcuna base.
argomento. In caso contrario, la sintassi di specifica di base nella stringa viene ignorata.

int putchar(int c)
Posizionare il carattere specificato sull'output standard utilizzando File::putc(c, stdout) e
restituire il risultato.

int sleep(int msec)
Prova a sospendere il thread corrente per almeno msecs millisecondi. Restituisce 1 su
rientro anticipato, altrimenti 0.

int exit(int stato)
Esci da Nickle con il codice di stato indicato. Non restituire nulla.

int dim(poly[*] a)
Dato un array unidimensionale a, dim() restituisce il numero di elementi di a.

int[] dims(poly[] a)
Dato un array arbitrario a, dims() restituisce un array di interi che fornisce la dimensione di
ogni dimensione di a. Quindi, dim(dims(a)) è il numero di dimensioni di a.

*riferimento poly(poly v)
Dato un valore arbitrario v, ``inscatola'' quel valore nella memoria e restituisce un puntatore a
la scatola.

stringa razionale_in_reale(stringa s)

razionale atof(string s)
Converti la stringa costante reale s nel numero reale associato.

numero abs(reale v)
Restituisce il valore assoluto di v. Il tipo di risultato scelto corrisponderà al dato
socio-culturale.

int floor(reale v)
Restituisce il più grande intero minore o uguale a v. Questo fallirà se v è un numero reale
e la precisione è troppo bassa.

int ceil(reale v)
Restituisce il più piccolo intero maggiore o uguale a v. Questo fallirà se v è un
reale e la precisione è troppo bassa.

int esponente(reale v)
Restituisce l'esponente del reale impreciso v.

mantissa razionale (v reale)
Restituisce la mantissa del reale impreciso v, come un razionale m con 0 <= m <= 0.5 .

int numeratore(razionale v)
Restituisce il numeratore del numero razionale v: ovvero, se v = n/d in forma ridotta,
ritorno n.

int denominatore(razionale v)
Restituisce il denominatore del numero razionale v: ovvero, se v = n/d in forma ridotta,
ritorno d.

int precision(real v)
Restituisce il numero di bit di precisione della mantissa del numero reale impreciso
v.

int sign(reale v)
Restituisce -1 o 1 se v è negativo o non negativo.

int bit_width(int v)
Restituisce il numero di bit necessari per rappresentare internamente abs(v).

int is_int(poly v)
Predicato di tipo.

int is_rational(poly v)
I predicati di tipo numerico sono inclusivi: ad esempio, è_razionale(1) restituisce 1.

int is_number(poly v)
Predicato di tipo.

int is_string(poly v)
Predicato di tipo.

int is_file(poly v)
Predicato di tipo.

int is_thread(poly v)
Predicato di tipo.

int is_semaphore(poly v)
Predicato di tipo.

int is_continuation(poly v)
Predicato di tipo.

int is_array(poly v)
Predicato di tipo.

int is_ref(poly v)
Predicato di tipo: verifica il tipo del puntatore. Questa è probabilmente una funzionalità errata e potrebbe
cambiare.

int is_struct(poly v)
Predicato di tipo.

int is_func(poly v)
Predicato di tipo.

int is_void(poly v)
Predicato di tipo.

int mcd(int p, int q)
Restituisce il MCD di p e q. Il risultato è sempre positivo.

int xor(int a, int b)
Restituisce a ^ b . Si tratta in gran parte di un residuo di prima che Nickle avesse un operatore xor.

poly setjmp(continuazione *c, poly retval)
Le primitive setjmp() e longjmp() insieme al tipo di continuazione formano un
ADT utile per trasferimenti quasi arbitrari del flusso di controllo. Setjmp() e
I built-in longjmp() sono come quelli del C, tranne per la restrizione che longjmp()
salta sempre verso l'alto viene rimosso(!): una continuazione salvata tramite setjmp() non diventa mai
non valido durante il ciclo di vita del programma.

Il builtin setjmp() salva la posizione corrente e il contesto nella sua continuazione
argomento puntatore e quindi restituisce il suo secondo argomento.

void longjmp(continuazione c, poly retval)
Il builtin longjmp() non ritorna mai al sito di chiamata, ma invece ritorna dal
setjmp() che ha creato la continuazione, con valore di ritorno uguale al secondo
argomento di longjmp().

prompt di stringa
Il prompt visualizzato durante l'uso interattivo quando ci si trova al livello superiore. Predefinito "> ". quando
in attesa del resto di un'istruzione o espressione e durante il debug,
rispettivamente. I valori predefiniti sono "> ", "+ " e "- ".

stringa prompt2
Il prompt stampato durante l'uso interattivo in attesa del resto di un'istruzione
o espressione. Predefinito "+ ".

stringa prompt3
Prompt visualizzato durante l'uso interattivo durante il debug. Valore predefinito "-".

formato stringa
Formato printf() per stampare i valori di primo livello. Il valore predefinito è "%g".

versione stringa
Numero di versione dell'implementazione Nickle attualmente in esecuzione.

costruzione di stringhe
La data di compilazione dell'implementazione Nickle attualmente in esecuzione, nel formato
"aaaa/mm/gg" oppure "?" se per qualche motivo la data di compilazione è sconosciuta.

file stdin
Collegato al flusso di input standard.

file stdout
Collegato al flusso di output standard.

file stderr
Collegato al flusso di errore standard.

eccezioni:

Alcune eccezioni standard sono predichiarate e utilizzate internamente da Nickle.

eccezione uninitialized_value(string msg)
Tentativo di utilizzare un valore non inizializzato.

eccezione invalid_argument(string msg, int arg, poly val)
L'argomento arg-esimo di una funzione incorporata aveva un valore non valido val.

eccezione readonly_box(string msg, poly val)
Tentativo di modificare il valore di una quantità di sola lettura in val.

eccezione invalid_array_bounds(string msg, poly a, poly i)
Il tentativo di accedere all'array a all'indice i è fuori dai limiti.

eccezione divide_by_zero(string msg, numero reale, numero reale)
Prova a dividere num per den con den == 0.

eccezione invalid_struct_member(string msg, poly struct, string name)
Tentativo di fare riferimento al nome del membro della struttura dell'oggetto, che non esiste.

eccezione invalid_binop_values(string msg, poly arg1, poly arg2)
Tentativo di valutare un operatore binario con argomenti arg1 e arg2, dove almeno uno
di questi valori non è valido.

eccezione invalid_unop_values(string msg, poly arg)
Tentativo di valutare un operatore unario con argomento non valido arg.

incorporato Namespace:

Matematica Le funzioni matematiche disponibili nello spazio dei nomi Math sono implementate in un modo
destinato ad essere compatibile con la libreria C. Si prega di consultare l'appropriato
manuali per ulteriori dettagli.

pi greco reale
Costante imprecisa che fornisce il valore del rapporto circonferenza/diametro dell'
cerchio alla precisione predefinita di 256 bit.

beni immobili protetti
Costante imprecisa che fornisce il valore della base dei logaritmi naturali per
precisione predefinita di 256 bit. Poiché e è protetto, deve essere referenziato tramite
Math::e, per evitare problemi con l'utilizzo della quinta lettera dell'alfabeto a
livello superiore.

funzione reale sqrt(v reale)
Restituisce la radice quadrata di v.

funzione reale cbrt(reale v)
Restituisce la radice cubica di v.

funzione reale exp(v reale)
Restituisce e**v.

funzione reale log(a reale)
Restituisce v in modo che e**v == a. Genera un'eccezione invalid_argument se a non è
positiva.

funzione reale log10(a reale)
Restituisce v in modo che 10**v == a. Genera un'eccezione invalid_argument se a non è-
positiva.

funzione reale log2(a reale)
Restituisce v in modo che 2**v == a. Genera un'eccezione invalid_argument se a non è-
positiva.

funzione reale pi_value(int prec)
Restituisce il rapporto tra la circonferenza di un cerchio e il diametro, con bit prec
di precisione.

funzione reale sin(a reale)
Restituisce il rapporto tra il lato opposto e l'ipotenusa dell'angolo a di un retto
triangolo, espresso in radianti.

funzione reale cos(a reale)
Restituisce il rapporto tra il lato adiacente e l'ipotenusa dell'angolo a di un retto
triangolo, espresso in radianti.

funzione void sin_cos(real a, *real sinp, *real cosp)
Restituisce con sin(a) e cos(a) memorizzati nelle posizioni indicate da sinp e cosp
rispettivamente. Se uno dei puntatori è 0, non memorizzare in quella posizione. Potrebbe essere
leggermente più veloce rispetto alla chiamata indipendente di entrambe le funzioni trigonometriche.

funzione reale tan(a reale)
Restituisce il rapporto tra il lato opposto e il lato adiacente dell'angolo a di un retto
triangolo, espresso in radianti. Si noti che tan(pi/2) non è attualmente un errore: lo sarà
restituire un numero molto grande a seconda della precisione del suo input.

funzione reale asin(reale v)
Restituisce a tale che sin(a) == v.

funzione reale acos(reale v)
Restituisce a tale che cos(a) == v.

funzione reale atan(reale v)
Restituisce a tale che tan(a) == v.

funzione reale atan2(reale x, y)
Restituisce a tale che tan(a) == x / y. Gestisce correttamente y == 0.

funzione reale pow(a reale, b reale)
L'implementazione dell'operatore **.

File Lo spazio dei nomi File fornisce operazioni sui valori dei file.

funzione int fprintf(file f, stringa s, ....)
Stampa i valori formattati in un file, come con la libreria stdio UNIX fprintf(). fprintf()
e printf() accetta un sottoinsieme ragionevole della versione della libreria stdio: %c, %d, %e,
%x, %o, %f, %s, %g funzionano come previsto, così come %v per stampare in modo intelligente un valore. Formato
i modificatori possono essere posizionati tra il segno di percentuale e la lettera del formato da modificare
formattazione. Sono noti molti bug nella formattazione di input e output.

Formato Lettere:

%c Richiede un argomento intero piccolo (0..255) e formatta come ASCII
carattere.

%d Richiede un argomento intero e viene formattato come intero.

%x Richiede un argomento intero e il formato è in base 16 (esadecimale)
numero intero.

%o Richiede un argomento intero e il formato è un intero in base 8 (ottale).

%e Richiede un argomento numerico e il formato è in notazione scientifica.

%f Richiede un argomento numerico e il formato è in notazione a virgola fissa.

%s Richiede un argomento stringa ed emette la stringa letteralmente.

%g Richiede un numero e tenta di scegliere una rappresentazione precisa e leggibile
per formattarlo.

Formato modificatori:

cifre Tutti i caratteri di formato accetteranno un modificatore di formato intero che indica il
numero di spazi vuoti nel campo formato per i dati da formattare. Il
il valore verrà stampato giustificato a destra in questo spazio.

cifre.cifre
I formati reali accetteranno una coppia di modificatori di formato intero che indicano il
larghezza del campo e precisione (numero di caratteri dopo la virgola decimale) del
valore formattato. Entrambi i numeri interi possono essere omessi.

- Un valore di precisione che indica una precisione infinita.

* Il prossimo argomento di fprintf() è un intero che indica la larghezza del campo o
precisione del valore formattato.

funzione file string_write()
Restituisce un file che raccoglie i valori scritti in una stringa.

funzione int close(file f)
Chiude il file f e restituisce un'indicazione di successo.

funzione int flush(file f)
Svuota i buffer del file f e restituisce un'indicazione di successo.

funzione int getc(file f)
Ottiene il carattere successivo dal file f e lo restituisce.

funzione int end(file f)
Restituisce true se il file f è alla fine del file, altrimenti false.

errore funzione int (file f)
Restituisce true se è presente un errore nel file f, altrimenti false.

funzione int clear_error(file f)
Cancella gli errori in sospeso sul file f e restituisce un'indicazione di successo.

funzione file string_read(string s)
Restituisce un file virtuale il cui contenuto è la stringa s.

funzione stringa string_string(file f)
Restituisce la stringa precedentemente scritta nel file f, che avrebbe dovuto essere
creato da string_read() o string_write(). Il comportamento su altri file è attualmente
non definito.

funzione file open(percorso stringa, modalità stringa)
Aprire il file nel percorso specificato con la stringa di modalità specificata, come UNIX stdio fopen().
Le modalità consentite sono quelle in stdio: "r", "w", "x", "r+", "w+" e "x+".

funzione intera fputc(intero c, file f)
Invia il carattere c al file di output f e restituisce un'indicazione di successo.

funzione intera ungetc(intero c, file f)
Riporta il carattere c nel file di input f e restituisce un'indicazione di
successo.

funzione intera setbuf(file f, intero n)
Imposta la dimensione del buffer associato al file f su n e restituisce n.

funzione stringa fgets (file f)
Ottiene una riga di input dal file f e restituisce la stringa risultante.

funzione file pipe(stringa percorso, stringa[*] argv, stringa modalità)
Avvia il programma nel percorso specificato, restituendo un file che è un'estremità di un
"pipe" al processo specificato. L'argomento mode può essere "r" per leggere dalla pipe o
"w" per scrivere nella pipe. L'argomento argv è un array di stringhe che fornisce
argomenti da passare al programma, con argv[0] che è convenzionalmente il
nome del programma.

funzione int stampa (file f, poly v, stringa fmt, int base, int larghezza, int prec, stringa
riempire)
Stampa il valore v nel file f nel formato fmt con la base, la larghezza, la precisione e il riempimento specificati.
Utilizzato internamente da File::fprintf();

funzione int fscanf(file f, stringa fmt, *poly argomenti...)
Riempi le posizioni indicate dall'array args con i valori presi dal file f
in base alla stringa fmt. Gli specificatori di formato sono molto simili a quelli di UNIX stdio scanf():
gli specificatori "%d", "%e", "%f", "%c" e "%s" sono supportati con il previsto
modificatori.

funzione int vfscanf (file f, stringa fmt, (*poly)[*] argomenti)
Dato il file f, il formato fmt e l'array di argomenti args, fscanf()
appropriatamente.

Thread Lo spazio dei nomi Thread supporta varie operazioni utili per la programmazione con
fili, che forniscono un flusso di controllo simultaneo nello spazio di indirizzamento condiviso.
Esiste una parte di sintassi speciale associata ai thread.

forchetta(E)
Accetta un'espressione arbitraria e la valuta in un nuovo thread figlio.
Il thread padre riceve il thread come valore dell'espressione fork.

Le restanti funzioni di Thread sono piuttosto standard.

int function kill(lista thread...)
Uccide ogni thread in esecuzione nell'elenco array. Senza argomenti, uccide il
thread attualmente in esecuzione. Restituisce il numero di thread terminati.

int funzione trace(poly lista...)
Mostra lo stato di ogni thread in esecuzione nell'elenco array. Senza argomenti,
traccia la continuazione predefinita. Restituisce il numero di thread tracciati.

funzione int cont()
Continua l'esecuzione di tutti i thread interrotti e restituisce il numero di thread continuati
thread.

funzione thread current()
Restituisce il thread corrente.

funzione int list()
Segnala il thread attualmente in esecuzione su stdout.

funzione int get_priority(thread t)
Segnala la priorità del thread specificato.

funzione thread id_to_thread(int id)
Restituisce il thread con l'ID specificato, se trovato, altrimenti 0.

funzione poli join(thread t)
Attende che il thread t termini e restituisce ciò che restituisce.

funzione int set_priority(thread t, int i)
Tenta di impostare la priorità del thread t al livello i e restituisce la nuova priorità.
Priorità più elevate significano più tempo di esecuzione: un'attività con priorità più alta verrà sempre eseguita
invece di un'attività con priorità inferiore. I thread con priorità più alta uguale saranno pre-
multitasking in modo voluttuoso.

Semaforo
Lo spazio dei nomi Semaphore incapsula le operazioni sull'ADT incorporato nel semaforo. A
Il semaforo viene utilizzato per la sincronizzazione dei thread. Ogni operazione signal() sul
semaforo risveglia il thread meno recente per wait() su quel semaforo. Il
Il ``conteggio'' dei processi in attesa può essere impostato al momento della creazione del semaforo.

funzione semaforo new(int c)
Crea un nuovo semaforo con un conteggio iniziale c di processi in attesa. Se c è
positivo, significa che c thread possono attendere sul semaforo prima che uno blocchi. Se
c è negativo, imposta un conteggio dei thread che devono essere in attesa sul semaforo
prima che ulteriori attese non si blocchino.

funzione semaforo new()
Call semaforo(0) e restituire il risultato.

int segnale(semaforo s)
Incrementa il semaforo s. Se s non è positivo e qualche thread è bloccato su s,
rilascia il thread bloccato meno di recente. Restituisce 1 in caso di successo.

int wait(semaforo s)
Decrementa il semaforo s. Se s è negativo, blocca fino al rilascio. Restituisce 1 su
successo.

int test(semaforo s)
Verificare se wait() sui semafori causerebbe il blocco del thread corrente. In tal caso,
restituisce 0. Altrimenti, tenta di decrementare s e restituisce 1 in caso di successo.

Stringa Lo spazio dei nomi String contiene alcune operazioni di base sull'ADT stringa.

funzione int lunghezza(stringa s)
Restituisce il numero di caratteri in s.

funzione stringa new(int c)
Restituisce come stringa il singolo carattere c.

funzione stringa new(int cv[*])
Restituisce una stringa composta dai caratteri di cv.

funzione int indice(stringa t, stringa p)
Restituisce l'indice intero della stringa di pattern p nella stringa di destinazione t, oppure -1 se
p non è una sottostringa di t.

funzione stringa substr(stringa s, int i, int l)
Restituisce la sottostringa della stringa s che inizia con il carattere all'offset i (zero-
basato) e continuando per un totale di l caratteri. Se l è negativo, la sottostringa
sarà costituito da caratteri che precedono anziché seguire i.

PRNG Lo spazio dei nomi PRNG fornisce la generazione e la manipolazione di numeri pseudo-casuali.
Il generatore di core è il generatore di cifratura a flusso RC4, opportunamente avviato. Questo
fornire un flusso di bit pseudo-casuali crittograficamente sicuri a prezzi ragionevoli
costo ammortizzato. (Ma attenzione, l'inizializzazione è piuttosto costosa.)

funzione vuota srandom(int s)
Inizializza il generatore, utilizzando l'intero (arbitrariamente grande) come seme.

funzione vuota dev_srandom(int nbit)
Inizializza il generatore, utilizzando nbits bit di entropia ottenuti da alcuni dati ragionevoli
Sorgente di entropia. Sui sistemi UNIX, questa sorgente è /dev/urandom. Chiedo maggiori informazioni.
l'entropia iniziale di quella del sistema può portare al bootstrapping (come su UNIX)
o per appenderlo, quindi usare con cautela.

funzione int randbits(int n)
Restituisce un n-bit numero pseudo-casuale, nell'intervallo 0..(2**n)-1Utile per le cose
come RSA.

funzione int randint(int n)
Restituisce un numero pseudo-casuale nell'intervallo 0..n-1.

funzione vuota shuffle(*(poly[*]) a)
Esegue un efficiente shuffle reale sul posto (cfr. Knuth) dell'array a.

Comando
Lo spazio dei nomi Command viene utilizzato dai comandi di primo livello come descritto di seguito. È
occasionalmente utile anche di per sé.

stringa library_path
Contiene il percorso di ricerca della libreria corrente, un elenco di directory separate da due punti da
essere ricercati i file della libreria.

int funzione undefine(stringa nome)
Implementa il comando undefine di primo livello. Rimuove il nome indicato dalla stringa name
dallo spazio dei nomi. Questo rimuove tutte le definizioni visibili del nome.

funzione int undefine(string[*] nomi)
Rimuovi ciascuno dei nomi nell'array names dallo spazio dei nomi. Questo rimuove tutti
definizioni visibili di ciascun nome.

funzione int delete(string name)
Tenta di rimuovere il comando con il nome stringa specificato dal comando di livello superiore
elenco e restituisce 1 in caso di successo.

funzione int lex_file(stringa percorso)
Tenta di rendere il file nel percorso specificato la sorgente corrente del codice Nickle e
restituisce 1 in caso di successo. Nota che questo di fatto ``include'' il file
inserendolo in una pila di file da elaborare.

funzione int lex_library(stringa nome file)
Come lex_file(), ma cerca le directory fornite da percorso_biblioteca variabile
per il primo file con il nome file specificato.

funzione int lex_string(codice stringa)
Tenta di far sì che il codice Nickle contenuto nel codice stringa sia l'input successivo.

funzione int edit(string[*] nomi)
Implementa il comando di modifica di primo livello. I nomi nell'array sono un percorso di
nomi degli spazi dei nomi che portano al nome del simbolo, che è l'ultimo.

int function new(string name, poly func)
Associa la funzione func alla stringa di comando di livello superiore name: ovvero, la rende parte di
il vocabolario dei comandi di livello superiore.

funzione int new_names(stringa nome, poli funzione)
Associa la funzione func alla stringa di comando di livello superiore name: ovvero, la rende parte di
il vocabolario dei comandi di primo livello. A differenza di new(), i nomi delle stringhe assegnati a func at
il livello superiore viene passato non valutato come un array di nomi di stringhe o come un singolo
nome della stringa.

funzione int pretty_print(file f, string[*] nomi)
Implementa il comando di stampa di primo livello. Ciascuna delle stringhe di nome passate viene esaminata
e il codice corrispondente viene stampato nel file f.

funzione int display(string fmt, poly val)
Utilizza printf() per visualizzare il valore val nel formato fmt.

Storia
Nickle mantiene una cronologia dei valori di primo livello, utile come complemento alla riga di comando
modifica durante il calcolo. Lo spazio dei nomi History contiene funzioni per accedere a questo
storia.

funzione int show(string fmt)
Implementa il comando di primo livello history senza argomenti. Mostra i più recenti
valori cronologici con formato fmt.

funzione int show(string fmt, int count)
Implementa il comando di primo livello history con un argomento. Mostra l'ultimo conteggio
valori cronologici con formato fmt.

funzione int show(string fmt, int primo, int ultimo)
Implementa il comando di primo livello history con due argomenti.

funzione poli insert(poly val)
Inserisce val nell'elenco cronologico e lo restituisce.

environ
Molti sistemi operativi hanno una qualche nozione di ``variabili d'ambiente''. L'ambiente
namespace contiene funzioni per manipolarli.

funzione int check(stringa nome)
Restituisce 1 se la variabile con il nome specificato è nell'ambiente e 0
altrimenti.

funzione stringa get(nome stringa)
Tenta di recuperare e restituire il valore della variabile di ambiente con
nome specificato. Genera un'eccezione invalid_argument se la variabile non è disponibile.

funzione int unset(stringa nome)
Tenta di annullare l'impostazione della variabile di ambiente con il nome specificato e restituisce un
indicazione di successo.

funzione stringa set(nome stringa, valore stringa)
Tenta di impostare la variabile di ambiente con il nome specificato sul valore specificato,
e restituisce un'indicazione di successo.

COMANDI

Nickle ha una serie di comandi che possono essere impartiti al livello più alto.

esci Exit Nickle.

quit E Esci da Nickle con codice di stato intero E.

non definire NOME {,NOME}
Rimuovere questi nomi dal sistema.

carica E Carica un file indicato dalla stringa nome E.

biblioteca E
Carica una libreria indicata dalla stringa E. Vedi la discussione su NICKLEPATH
variabile d'ambiente in AMBIENTE di seguito, e la discussione di
Command::library_path sopra.

E # E Stampa expr1 nella base expr2 .

stampa NOME
Visualizza una versione formattata dell'oggetto indicato da NOME. Commenti e originale
la formattazione viene persa. Se NAME è una variabile, stampa sia il tipo che il valore.

modifica NOME
Richiama $EDITOR sull'oggetto denominato e reincorpora i risultati della modifica.
Questa funzione è particolarmente utile con le funzioni.

storia
Visualizza i 10 valori stampati più di recente. È possibile accedervi con $n where n
è il numero visualizzato a destra del valore in questo elenco.

storia E
Visualizza i valori cronologici più recenti.

storia E,E
Visualizza i valori cronologici dal primo intero E al secondo.

DEBUGGER

Quando un'eccezione non gestita raggiunge il livello superiore durante l'esecuzione, l'utente riceve un trattino
prompt, che indica che la modalità debug è attiva. In questa modalità, l'ambiente della riga di comando
è quello in cui è stata sollevata l'eccezione non gestita. Inoltre, una serie di debug
i comandi sono a disposizione dell'utente:

traccia Ottieni un backtrace dello stack che mostra lo stato corrente, come con il comando GDB where.

su Spostarsi verso l'alto nello stack (ovvero, verso l'espressione di livello superiore) come GDB.

down Spostarsi verso il basso nello stack (ovvero, verso il contesto corrente) come in GDB.

done Esce dalla modalità debug, abbandonando l'esecuzione.

Inoltre, lo spazio dei nomi Debug è limitato alla modalità di debug. Questo è principalmente
utile per il debug di Nickle stesso.

raccogliere()
Esegui il garbage collector.

dump(funzione)
Stampa il bytecode compilato per la funzione.

AMBIENTE

EDITOR L'editor utilizzato dal comando di modifica, descritto in COMANDI sopra.

NICKLERC
La posizione del file .nicklerc dell'utente, che verrà caricato all'inizio di
esecuzione in nichel se possibile.

HOME Utilizzato per trovare il file .nicklerc dell'utente se NICKLERC non è impostato.

NICKLEPATH
Un percorso separato da due punti i cui elementi sono directory contenenti codice Nickle.
comando library e il flag -l, descritto sopra, cercano in questo percorso un nome file
corrispondente al file specificato. Il percorso predefinito della libreria in assenza di questa variabile
è /usr/share/nickle.

NICKLESTART
Nome del file che dovrebbe essere caricato come bootstrap all'avvio di Nickle.
L'impostazione predefinita in assenza di questa variabile è caricare
/usr/share/nickle/builtin.5c.

ESEMPI

Un esempio (tratto dal bc Manuale:

funzione reale esponente(x reale) {
reale a = 1;
intero b = 1;
reale s = 1;
int i = 1;
mentre (1) {
a = a * x;
b = b * i;
reale c = a / b;
se (abs(c) < 1e-6)
restituisci s;
s = s + c;
i + +;
}
}

definisce una funzione per calcolare un valore approssimativo della funzione esponenziale e ** x e

per (i = 1; i < 10; i++)
printf ("%g\n", esponente (i));

stampa i valori approssimativi della funzione esponenziale dei primi dieci numeri interi.

VERSIONE

Questo documento descrive la versione 1.99.2 di Nickle, così come alcune nuove funzionalità. È stato
distribuito con la versione 2.77 di nickel.

Utilizzare il nichel online utilizzando i servizi onworks.net