filepp - Online nel cloud

PROGRAMMA:

NOME

filepp - Un preprocessore di file generico

SINOSSI

filepp [Opzioni] nome/i file

DESCRIZIONE

filepp è un preprocessore di file generico progettato per consentire la funzionalità fornita dal
preprocessore C cpp(1) da utilizzare con qualsiasi tipo di file. filepp è progettato per essere facilmente
personalizzato ed esteso.

VERSIONI

filepp accetta le seguenti opzioni della riga di comando:

-b Elimina le righe vuote provenienti da file di inclusione (questo non ha effetto sulla parte superiore-
file di livello).

-c Leggi l'input da STDIN invece di un file. Nota: se entrambi -c e i file di input sono
specificato, entrambi vengono utilizzati come input nell'ordine indicato.

-Dmacro
Predefinire macro avere una definizione di `1'.

-Dmacro=def
Predefinire macro avere una definizione di def.

-d Informazioni di debug dell'output.

-DD Genera informazioni dettagliate sul debug. Questa opzione mostra tutto il normale debug
informazioni, oltre all'elenco completo delle macro definite ogni volta che l'elenco cambia.

Sig Informazioni di debug della luce di uscita. Questa opzione mostra il debug minimo
informazioni.

-dpreserbatoio
Prefissa tutte le informazioni di debug con serbatoio (può essere carattere o stringa), può essere
utilizzato per rendere il debug più facile da leggere.

-dpostserbatoio
Postfix tutte le informazioni di debug con serbatoio (può essere un carattere o una stringa), questo
l'impostazione predefinita è una nuova riga. Se serbatoio non contiene una nuova riga, quindi nessuna nuova riga sarà
stampato dopo il debug dei messaggi. (È possibile inserire nuove righe serbatoio usando il
__NEWLINE__ macro.)

-ds Stampa le informazioni di debug su stdout anziché su stderr.

-e Definisci tutte le variabili d'ambiente come macro con prefisso envchar.

-ec serbatoio
Impostato envchar (prefisso delle variabili d'ambiente definite come macro) a serbatoio, impostazioni predefinite
a $. (Nota: questa opzione ha effetto solo nel momento in cui le variabili d'ambiente
vengono convertiti in macro).

-ecn Impostato envchar (prefisso delle variabili d'ambiente definite come macro) a niente (no
prefisso).

-h Mostra il riepilogo delle opzioni.

-Idir Aggiungi directory dir all'elenco delle directory cercate per i file di inclusione.

-imacro filetto
Legge le macro da filetto, ma elimina tutto il resto nel file.

-k Disattiva l'analisi di tutte le parole chiave. Questo è utile se vuoi solo usare la macro
strutture di espansione di filepp. Con questa opzione tutte le parole chiave trovate saranno
ignorato, filepp sostituirà semplicemente qualsiasi macro specificata con il -Dmacro=def
opzione.

-kc serbatoio
Imposta il carattere del prefisso della parola chiave su serbatoio (può anche essere una stringa). Tutto filepp parole chiave
sono preceduti dal carattere # per impostazione predefinita. Questa opzione consente al prefisso di essere
cambiato in qualcos'altro.

-lc serbatoio
Imposta il carattere di continuazione della riga su serbatoio (può anche essere una stringa). Quando la linea
il carattere di continuazione si trova seguito da una nuova riga, esso e la nuova riga sono
sostituito dal carattere di sostituzione della continuazione di riga. L'impostazione predefinita è \ (cpp(1)
stile).

-lec serbatoio
Imposta il carattere di fine riga della parola chiave opzionale su serbatoio (può anche essere una stringa). Questo
consente di inserire caratteri aggiuntivi alla fine di una riga contenente una parola chiave.
I caratteri extra verranno ignorati. Questo è utile se le parole chiave devono essere
incorporato in commenti in stile HTML o C. Ad esempio, per incorporare parole chiave in un HTML
commentare il carattere del prefisso della parola chiave potrebbe essere impostato su <--!# e la parola chiave opzionale
carattere di fine riga impostato su ->. Una parola chiave di esempio sarebbe quindi:

<!--#include "intestazione.h" ->

Nel caso in cui i caratteri di fine riga della parola chiave facoltativi -> verrebbe ignorato.

-lr serbatoio
Imposta il carattere di sostituzione della continuazione di riga su serbatoio (può anche essere una stringa).
L'impostazione predefinita è una stringa nulla (cpp(1) stile).

-lrn Imposta il carattere di sostituzione della continuazione della riga come una nuova riga.

-m modulo.pm
Carica modulo modulo.pm. modulo.pm è un perl(1) modulo che può essere utilizzato per estendere
o modificare il comportamento di filepp. Vedi sezione FILEPP MODULI per i dettagli di
moduli inclusi con filepp e FILEPP MODULO API per i dettagli su come scrivere il tuo
propri moduli.

-Mdir Aggiungi directory dir all'elenco delle directory ricercate per i moduli filepp. Questo
list per impostazione predefinita è la directory in cui sono installati i moduli filepp (se presenti) più il
percorsi predefiniti del modulo Perl. (Nota: questo aggiunge la directory all'elenco Perl @INC.)

-mp serbatoio
Prefissa tutte le macro con serbatoio. Le macro sono definite nel modo normale, ma lo faranno solo
essere sostituito quando trovato preceduto da serbatoio. Ad esempio, le macro filepp si comporteranno
simile a Bourne shell (sh(1)) variabili se serbatoio è impostato su $.

-mpnk Disattiva i prefissi delle macro all'interno delle parole chiave. Quando si utilizza un carattere di prefisso macro questo
L'opzione consente di utilizzare le macro senza il prefisso nell'elaborazione delle parole chiave. Per
esempio, se il prefisso della macro è $ allora e #Se sarebbe scritto come:

#Se $MACRO == 1

Usando il mpnk opzione consente il #Se da scrivere come:

#Se MACRO == 1

-o Nome
Scrivi output su Nome invece di STDOUT. Se c'è solo un file di input e ha
lo stesso nome del file di output, verrà eseguito il backup del file di input originale come
nome~.

-Ov Modalità sovrascrittura, fa sì che il file di output sovrascriva il file di input. Utile quando
modificare un gran numero di file contemporaneamente, ad esempio:

filepp -ov -DQUESTO=QUELLO *

Verrà eseguito il backup dei file di input originali come nome~.

-ovc IN=OUT
Simile alla modalità di sovrascrittura, la differenza è che il nome del file di output è il nome del file di input
con IN parte convertita in OUT. Ad esempio, per elaborare un insieme di file che terminano tutti
con .in e fai in modo che i file di output finiscano tutti con .out:

filepp -ovc .in=.out *.in

In questo caso un file chiamato prova.in verrà elaborato e il file di output sarà
testare. Nota: se il file di input non contiene IN quindi il file di output lo farà
hanno lo stesso nome del file di input e verrà eseguito il backup dei file di input originali-
su come nome~!

-pb Conserva le righe vuote. L'utilizzo di questa opzione tenta di mantenere il maggior numero di righe nel
file di output come sono nel file di input, quindi tutte le righe vuote che normalmente non lo sarebbero
ottenere stampati vengono stampati. Utile quando si confronta il file di input con l'output.

-ri Tratta i caratteri delle parole chiave e dei prefissi delle macro e il carattere di continuazione della riga come Perl
espressioni regolari invece di normali stringhe.

-s Correre filepp in modalità provvisoria. Questo spegne il pragma parola chiave.

-Umacro
Indefinito precedentemente definito macro.

-u Annulla la definizione di tutte le macro attualmente definite, comprese quelle predefinite.

-v Mostra la versione del programma.

-w Attiva i limiti delle parole quando sostituisci le macro. Quando i confini delle parole sono attivi, le macro
verrà sostituito solo se la macro appare nel testo come una parola. Ad esempio, da
difetto macro sarebbe sostituito in entrambi i casi dal testo seguente:

macro as parola, macroNOTaparola

ma solo la prima occorrenza verrebbe sostituita con la -w opzione.

Con questa opzione abilitata filepp sostituirà solo le macro che contengono caratteri alfanumerici
caratteri. I set di caratteri internazionali (non ASCII) possono essere supportati utilizzando Perl's
gestione locale.

PAROLE CHIAVE

filepp supporta le seguenti parole chiave:

#includere <RISORSE>
Includere un file nel file in elaborazione. Questa variante è usata per "sistema"
includi file. Cerca un file chiamato RISORSE in un elenco di directory
da te specificato. Le directory sono specificate con l'opzione di comando `-I'. filepp
non predefinisce alcuna directory di sistema in cui cercare i file.

#includere "FILE"
Includere un file nel file in elaborazione. Questa variante viene utilizzata per i file di inclusione
del proprio progetto. Cerca un file chiamato RISORSE primo nella corrente
directory, quindi nell'elenco delle directory specificato con l'opzione di comando `-I'.
La directory corrente è la directory in cui si trova il file di input di base.

#define macro
Definisci la macro macro avere una definizione di "1". macro può quindi essere utilizzato con
le parole chiave #ifdef e #ifndef.

#define macro def
Definisci la macro macro avere il valore def. macro può quindi essere utilizzato con il
parole chiave #ifdef e #ifndef. Inoltre, tutte le istanze di macro seguendo la #define
l'istruzione verrà sostituita con la stringa def. La stringa def è considerato essere
tutti i caratteri nella riga seguente macro.

#define macro(arg1, argomento2, ...) def
Definisci la macro macro avere il valore def con argomenti (arg1, argomento2, ...).
macro può essere utilizzato come segue:

#define macro(pippo) defn con foo in

Ora, quando si verifica la sostituzione:

macro(barra)

diventerà:

defn con barra in

Le macro possono avere un numero qualsiasi di argomenti separati da virgole.

Le macro possono anche avere un numero variabile di argomenti se la macro finale termina in ...,
per esempio:

#define errore (stringa, argomenti...) fprintf(stderr, string, argomenti);

Qui il primo argomento dato diventa stringa e tutti gli altri argomenti diventeranno
args. Se chiamato come: errore("%d,%s", i, corda) darà

fprintf(stderr, "%d,%s", i, stringa);

Inoltre, se viene passata una macro con un numero variabile di argomenti, nessun argomento per il
argomento variabile, quindi le virgole possono essere facoltativamente rimosse dalla definizione da
precedendo la definizione con "##". Per esempio:

#define errore (stringa, argomenti...) fprintf(stderr, stringa, ##args);

Se questo è chiamato come: errore ("vuoto") allora il risultato sarà:

fprintf(stderr, "vuoto");

La virgola immediatamente prima ##argomenti è stato rimosso.

#Se espr
Una dichiarazione condizionale, espr verrà valutato come vero (1) o falso (0). Se espr
valuta true, il testo tra i #Se e il prossimo #else or #endif sarà
incluso. Se espr valuta false, il testo tra il #Se e il prossimo #else
or #endif verrà ignorato. espr può usare tutti i soliti confronti di stile cpp (==,
!=, <, >, ecc.). Confronti multipli possono essere combinati con e (&&) eo (||).
Il definito la parola chiave può essere utilizzata anche per verificare se le macro sono definite. Per esempio:

#Se definito macro && macro == def

Nota: filepp's #Se non funziona esattamente come cpp(1)'s #Se. cpp(1)'s
#Se esegue solo confronti di stile numerico. Filepp's #Se l'affermazione può anche confrontare
stringhe ed espressioni regolari usando perl(1) la gamma completa di comaprison
operazioni. Ad esempio, per verificare se due stringhe sono esattamente uguali usa:

#Se "MACRO" eq "corda"

Per verificare se le stringhe non sono uguali usa ne invece di eq. Le espressioni regolari possono
anche essere testato, ad esempio per verificare se una macro contiene spazi bianchi utilizzare:

#Se "MACRO" =~ /\S/

Per verificare se una macro non contiene spazi bianchi =~ può essere sostituito con !~.

Esperti di Perl: #Se funziona per primo parsing espr per l' definito parola chiave e controllo
se la macro a cui fa riferimento è definita, sostituendola con 1 se lo è e 0 se lo è
non lo è. Quindi controlla espr per eventuali altre macro e le sostituisce con le loro
definizione. Finalmente passa espr tramite Perl's eval funzione, che restituisce
vero o falso.

#elif espr
#elif sta per "altrimenti se". Piace #else, va nel mezzo di a
#Se[n][def]-#endif coppia e la suddivide; non richiede un abbinamento #endif of
propria. Piace #Se, l' #elif direttiva include un'espressione da testare.

#ifdef macro
Una dichiarazione condizionale, se macro è stato definito il testo tra il #ifdef e
la successiva #else or #endif sarà incluso. Se macro non è stato definito il testo
tra l' #ifdef e il prossimo #else or #endif verrà ignorato.

#ifndef macro
Il caso inverso di #ifdef condizionale.

#else Il #else direttiva può essere aggiunta a un condizionale per fornire un testo alternativo per essere
utilizzato se la condizione è falsa.

#endif Utilizzato per terminare un'istruzione condizionale. L'elaborazione normale riprende dopo il
#endif.

#indif macro
Annulla definizione di una macro definita in precedenza.

#errore Messaggio
Cause filepp per uscire con il messaggio di errore Messaggio.

#avvertimento Messaggio
Cause filepp per inviare il messaggio di avviso Messaggio.

#comment Messaggio
As filepp dovrebbe essere un preprocessore di file generico, non può supportarne nessuno
stili di commento conosciuti, quindi ne definisce uno proprio con questa parola chiave. Tutte le linee
Iniziare con #comment vengono trattati come commenti e rimossi da filepp.

#pragma filepp funzione argomento1, argomento2, ...
Il #pragma parola chiave immediatamente seguita dalla parola filepp consente all'utente di
eseguire una funzione Perl durante l'analisi. La parola immediatamente successiva filepp is
preso come il nome della funzione e il resto della riga è preso come a
elenco separato da virgole di argomenti per la funzione. uno qualsiasi dei filepp interno
funzioni (vedi sezione FILEPP MODULO API) può essere chiamato con il #pragma parola chiave.

Attenzione: Ci sono ovvi rischi per la sicurezza nel consentire l'esecuzione di funzioni arbitrarie
run, quindi è stata aggiunta l'opzione della riga di comando -s (modalità provvisoria) che trasforma il
#pragma parola chiave disattivata.

PREDEFINITO MACRO

filepp supporta una serie di macro predefinite. Tutte le macro predefinite sono della forma
__MACRO__, Dove MACRO è:

RISORSE Questa macro si espande al nome del file di input corrente.

LINE Questa macro si espande al numero di riga di input corrente.

DATA Questa macro si espande in una stringa che descrive la data in cui si trova il preprocessore
essere eseguito. La stringa contiene undici caratteri e assomiglia a "29 ottobre 2012".

DATA_ISO
Questa macro si espande in una stringa che descrive la data in cui si trova il preprocessore
essere eseguito. La stringa è nel formato specificato da ISO 8601 (AAAA-MM-GG) e
sembra "2012-10-29".

ORARIO Questa macro si espande in una stringa che descrive l'ora in cui il preprocessore è
essere eseguito. La stringa contiene otto caratteri e assomiglia a "02:35:47".

FILE_BASE
Questa macro si espande al nome del file di input principale.

INCLUDE_LIVELLO
Questa macro si espande in una costante intera decimale che rappresenta la profondità di
annidamento in file di inclusione. Il valore di questa macro viene incrementato ad ogni #includere
direttiva e decrementato ad ogni fine del file.

NUOVA LINEA
Questa macro si espande in una nuova riga.

TAB Questa macro si espande in una scheda.

NULL Questa macro si espande a nulla. È utile se vuoi definire qualcosa da essere
Niente.

VERSIONE
Questa macro si espande in una costante stringa che descrive il numero di versione di
filepp. La stringa è una sequenza di numeri decimali separati da punti e aspetto
come "1.8.0".

FILEPP_INPUT
Questa macro si espande in una costante di stringa che dice che il file è stato generato
automaticamente dalla corrente FILE_BASE e sembra "Generato automaticamente
da ./filepp.1.in di filepp".

FILEPP MODULI

I seguenti moduli sono inclusi con la distribuzione principale di filepp:

PER MODULO - per.pm

Il modulo for implementa un semplice ciclo for. Il suo nome file è per.pm.

Il ciclo for è simile nella funzionalità a quello di altri linguaggi di programmazione come
Perl o o C. Ha una singola variabile (una macro filepp) a cui è assegnato un valore numerico
valore. Questo valore numerico cambia di un incremento impostato su ogni iterazione attraverso il
ciclo continuo. Il ciclo termina quando il valore non supera più un test di confronto.

Il modulo for implementa le seguenti parole chiave:

#per macro inizia a confrontare fine incremento
Il #per parola chiave è funzionalmente equivalente al seguente ciclo di stile Perl o C:

per (macro=inizia a; macro confrontare fine; macro+=incremento)

Il #per parola chiave richiede i seguenti parametri separati da spazi:

macro : Il nome della macro a cui il ciclo for dovrebbe assegnare il suo numero
valore.

inizia a : Il valore macro deve essere assegnato all'inizio del ciclo. inizia a dovrebbero
essere un valore numerico.

confrontare : Il confronto da fare tra il valore attuale di macro e il valore
fine per determinare quando il ciclo deve terminare. Valori validi per confrontare sono <,
>, >=, <=.

fine : il ciclo for terminerà quando il test

macro confrontare fine

non riesce. fine dovrebbe essere un valore numerico.

incremento : Il valore da incrementare macro ad ogni iterazione del ciclo. Alla fine
di ogni iterazione il valore di incremento viene aggiunto al valore corrente di macro.
incremento dovrebbe essere un valore numerico.

#fineper
Il #fineper la parola chiave viene utilizzata per indicare la fine del ciclo. Tutto all'interno del
apertura #per e la chiusura #fineper verranno elaborati ad ogni iterazione del
ciclo continuo.

Utilizzo di esempio:

#per CONTATORE 10 > 1 -2.5

CONTATORE

#fineper

Nell'esempio sopra, COUNTER sarà definito con i valori 10, 7.5, 5 e 2.5 per ciascuno
iterazione successiva attraverso il ciclo.

Sono possibili anche cicli annidati, così come la modifica del valore della macro all'interno del ciclo.
inizia a, fine e incremento dovrebbero essere tutti valori numerici, tuttavia è possibile utilizzare
macro invece a condizione che le macro siano definite per avere valori numerici.

PER CIASCUNO MODULO - perogni.pm

Il modulo foreach implementa un semplice ciclo foreach. Il suo nome file è perogni.pm.

Il ciclo foreach è simile nella funzionalità a quello di altri linguaggi di programmazione come
come Perl. Prende un elenco di valori separati da un delimitatore definibile dall'utente (',' by
predefinito). Quindi scorre tutti i valori nell'elenco, definendo una macro come ciascuno
valore individuale per ogni iterazione del ciclo. Il ciclo termina quando tutti i valori hanno
stato usato.

Il modulo foreach implementa le seguenti parole chiave:

#per ciascuno macro stratagemma
Il #per ciascuno parola chiave è funzionalmente equivalente al seguente ciclo di stile Perl:

foreach macro (diviso(/delim/, stratagemma))

Il #per ciascuno parola chiave richiede i seguenti parametri separati da spazi:

macro : Il nome della macro a cui il ciclo foreach dovrebbe assegnare la corrente
valore di lista.

stratagemma : l'elenco dei valori, separati da delim (Vedi #foreachdelim parola chiave per come
set delim). stratagemma può anche essere una macro o contenere macro.

Il ciclo verrà eseguito da #per ciascuno parola chiave per il prossimo #finepercorso parola chiave.

#finepercorso
Il #finepercorso la parola chiave viene utilizzata per indicare la fine del ciclo. Tutto dentro
l'apertura #per ciascuno e la chiusura #finepercorso saranno elaborati su ciascuno
iterazione del ciclo.

Utilizzo di esempio:

#per ciascuno VALORE uno, due, tre, quattro

VALORE

#finepercorso

Nell'esempio sopra VALUE sarà definito per avere valori uno, due, tre e quattro per
ogni successiva iterazione del ciclo.

Sono possibili anche cicli nidificati.

#foreachdelim /delim/
Il #foreachdelim la parola chiave viene utilizzata per impostare il delimitatore utilizzato in ogni elenco. Il
delimitatore può essere qualsiasi carattere, stringa o espressione regolare. Il delimitatore dovrebbe
essere racchiuso tra barre, nello stesso stile delle espressioni regolari Perl.
Il valore predefinito per delim è ','. Per impostare il delimitatore in modo che sia un singolo spazio, procedi nel seguente modo:

#foreachdelim / /

Impostare delim per essere qualsiasi quantità di spazio bianco fai:

#foreachdelim /\s+/

Vedere la documentazione Perl sulle espressioni regolari per usi più avanzati.

LETTERALE MODULO - letterale.pm

Il modulo letterale impedisce la sostituzione delle macro che compaiono nelle stringhe letterali. UN
stringa letterale è definita come avente la forma:

"letterale stringa con macro in"

Nell'esempio sopra, macro non sarà sostituito.

Il comportamento del modulo letterale può essere invertito definendo la macro LETTERALE_REVERSE
prima di caricare il modulo, ad esempio:

filepp -DLETTERALE_REVERSE -m letterale.pm

Questo ha l'effetto di sostituire solo le macro che appaiono nelle stringhe.

TOPPER MODULO - topper.pm

Il modulo toupper converte tutte le lettere minuscole in maiuscole.

RIDURRE MODULO - tolower.pm

Il modulo inferiore converte tutte le lettere maiuscole in minuscole.

C / C ++ COMMENTO MODULO - c-commento.pm

Il modulo c-comment rimuove tutto lo stile C:

/* commento */

e stile C++:

// commento

commenti da un file. I commenti C e C++ vengono rimossi dopo l'elaborazione delle parole chiave.
Se desideri rimuovere i commenti C e C++ prima che le parole chiave vengano elaborate, definisci la macro
REMOVE_C_COMMENTS_PRIMO prima di caricare il modulo, ad esempio:

filepp -DREMOVE_C_COMMENTS_PRIMO -m c-commento.pm

HASH COMMENTO MODULO - hash-commento.pm

Il modulo hash-comment rimuove tutti i commenti dello stile:

# commento

da un file. Questo è lo stile di commento utilizzato da Perl, Bourne Shell, C Shell e molti altri
altri programmi e file di configurazione. I commenti hash vengono rimossi dopo che le parole chiave hanno
stato elaborato. Se desideri rimuovere i commenti hash prima che le parole chiave vengano elaborate, definisci
la macro REMOVE_HASH_COMMENT_FIRST prima di caricare il modulo (Nota: se lo fai e
usa anche # come carattere della parola chiave, quindi le parole chiave verranno rimosse PRIMA che lo siano
elaborato).

FUNZIONE MODULO - funzione.pm

Il modulo funzione consente all'utente di scrivere macro che chiamano funzioni Perl. Il suo nome file
is funzione.pm.

Il modulo funzionale consente macro della forma:

macro(arg1, argomento2, argomento3, ...)

da aggiungere a un file. Quando la macro viene trovata, eseguirà una funzione da un Perl
modulo, con argomenti arg1, arg2, arg3, ... passato alla funzione La funzione deve
restituire una stringa. La stringa restituita sostituirà la chiamata alla funzione nell'output.
La funzione può avere un numero qualsiasi di argomenti. Se la funzione non ha argomenti dovrebbe
essere chiamato con un elenco di argomenti vuoto:

macro()

Se la parola macro si trova nel file di input senza essere seguito da a ( lo sarà
ignorato.

Per utilizzare il modulo funzione, l'utente deve fornire una funzione Perl che facoltativamente richiede
in argomenti e restituisce una stringa. La funzione può essere una delle funzioni interne di filepp
funzioni o una di quelle fornite dall'utente in un modulo Perl. La funzione può essere aggiunta
in due modi. Il primo modo è attraverso il funzione parola chiave:

#funzione macro funzione
macro è il nome della macro che è usata per indicare una chiamata alla funzione in
il file di input e funzione è il nome della funzione da chiamare.

Il secondo metodo per aggiungere una funzione è chiamare la funzione Perl:

Funzione::AggiungiFunzione($macro,$funzione)
che ha gli stessi ingressi del funzione parola chiave.

Le funzioni possono essere rimosse tramite la parola chiave:

#funzione macro
o tramite la funzione Perl

Funzione::RimuoviFunzione($macro)

MATEMATICA MODULO - matematica.pm

Il modulo fornisce un insieme di macro che eseguono operazioni matematiche. Quando il
le macro vengono rilevate in un file di input, vengono valutate e il risultato viene restituito in
Il risultato.

Il modulo di matematica include le seguenti macro:

aggiungere un, b, c, ...)
Accetta un numero qualsiasi di argomenti e restituisce la loro somma: (a + b + c + ...)

sotto(a, b)
Restituisce a meno b: (a - b)

mul(a, b, c, ...)
Accetta un numero qualsiasi di argomenti e restituisce il loro prodotto: (a * b * c * ...)

diva, b)
Restituisce a su b: (a / b)

addominali(a) Restituisce il valore assoluto di a.

atan2(a, b)
Restituisce l'arcotangente di a/b nell'intervallo da -pi a pi.

cos(a) Restituisce il coseno di a in radianti.

esp(a) Restituisce la e alla potenza di a.

intero(a) Restituisce la parte intera di a.

registro(a) Restituisce il logaritmo naturale (base e) di a.

randa(a)
Restituisce un numero frazionario casuale compreso tra 0 e a. Se a viene omesso,
restituisce un valore compreso tra 0 e 1.

peccato(a) Restituisce il seno di a in radianti.

quadrato(a)
Restituisce la radice quadrata di a.

randa(a)
Imposta il seme del numero casuale per rand().

Il modulo di matematica definisce anche pi come M_PI come e come M_E.

Le macro matematiche sono implementate usando il funzione.pm modulo. Le macro nidificate sono consentite,
così come passare altre macro con definizioni numeriche come argomenti.

FORMATO MODULO - formato.pm

Questo modulo fornisce una serie di macro per la formattazione di stringhe e numeri.

Il modulo format fornisce le seguenti macro:

printf(formato, argomento1, argomento2, ...)
Il printf si comporta allo stesso modo della funzione Perl/C printf. Ci vuole
in una stringa di formato seguita da un elenco di argomenti da stampare. Vedi il printf(3) uomo
pagina o la documentazione Perl per tutti i dettagli del printf funzione.

toupper (stringa)
Converte la stringa di input in maiuscolo.

toupperfirst (stringa)
Converte il primo carattere della stringa di input in maiuscolo.

tolow (stringa)
Converte la stringa di input in minuscolo.

tolowerfirst (stringa)
Converte il primo carattere della stringa di input in minuscolo.

substr(stringa, compensare, lunghezza)
Estrae una sottostringa dall'input stringa. substr si comporta allo stesso modo del Perl
funzione substr. offset è usato per specificare il primo carattere della stringa a
output (negativo per offset dalla fine della stringa), lunghezza è la lunghezza della stringa
all'uscita. Se la lunghezza viene omessa, viene restituito tutto dall'offset. Per
ulteriori informazioni su substr vedere la documentazione Perl.

Le macro di formato sono implementate utilizzando il funzione.pm modulo.

GRANDEF MODULO - bigdef.pm

Il modulo bigdef consente una facile definizione di macro multilinea. Il suo nome file è bigdef.pm.

Una macro su più righe è una macro che ha una definizione che si estende su più di una riga. Il
il modo normale per definirli è posizionare un carattere di continuazione di riga alla fine di ciascuno
riga nella definizione. Tuttavia, questo può essere fastidioso e illeggibile per grandi linee multiple
macro. Il modulo bigdef cerca di migliorarlo fornendo due parole chiave:

#grandedef macro definizione...
Il #grandedef la parola chiave ha la stessa sintassi di #define, l'unica differenza è il
la definizione della macro è tutto ciò che segue il nome della macro, inclusi tutti i seguenti
in fila alla prossima #endbigdef parola chiave.

#endbigdef
Finisce un bigdef. Tutto tra questa parola chiave e l'ultima precedente #grandedef is
incluso nella macro.

Qualsiasi parola chiave trovata nella definizione verrà valutata come normale AL MOMENTO DELLA MACRO È
DEFINED e qualsiasi output da questi sarà incluso nella definizione.

Nota: la differenza tra bigfunc e bigdef è il tempo in cui le parole chiave nella definizione sono
valutato. Bigdef li valuta quando la macro è DEFINITA, bigfunc li valuta ogni volta che
la macro è SOSTITUITA.

BIGFUNC MODULO - bigfunc.pm

Il modulo bigfunc consente una facile definizione di macro multilinea. Il suo nome file è
bigfunc.pm.

Una macro su più righe è una macro che ha una definizione che si estende su più di una riga. Il
il modo normale per definirli è posizionare un carattere di continuazione di riga alla fine di ciascuno
riga nella definizione. Tuttavia, questo può essere fastidioso e illeggibile per grandi linee multiple
macro. Il modulo bigfunc cerca di migliorarlo fornendo due parole chiave:

#grandefunzione macro definizione...
Il #grandefunzione la parola chiave ha la stessa sintassi di #define, l'unica differenza è il
la definizione della macro è tutto ciò che segue il nome della macro, inclusi tutti i seguenti
in fila alla prossima #endbigfunc parola chiave.

#endbigfunc
Finisce un bigfunc. Tutto tra questa parola chiave e l'ultima precedente #grandefunzione is
incluso nella macro.

Qualsiasi parola chiave trovata nella definizione verrà valutata come normale AL MOMENTO DELLA MACRO È
SOSTITUITO e qualsiasi output da questi sarà incluso nella definizione.

Nota: la differenza tra bigfunc e bigdef è il tempo in cui le parole chiave nella definizione sono
valutato. Bigdef li valuta quando la macro è DEFINITA, bigfunc li valuta ogni volta che
la macro è SOSTITUITA.

DEFPLUS MODULO - defplus.pm

Il modulo defplus consente di aggiungere informazioni aggiuntive a una macro esistente. Il suo file
il nome è defplus.pm.

Il modulo defplus consente di aggiungere ulteriori elementi alle macro esistenti. Il modulo
implementa una parola chiave:

#defplus macro definizione...
Il #defplus la parola chiave ha la stessa sintassi di #define, l'unica differenza è se
la macro è già definita allora definizione è aggiunto alla definizione esistente
della macro. Se la macro non è definita allora #defplus si comporta esattamente allo stesso modo
modo come #define.

REGEXP MODULO - regexp.pm

Il modulo regexp consente di eseguire la sostituzione delle espressioni regolari Perl con filepp. Suo
il nome del file è regexp.pm.

La sostituzione delle espressioni regolari Perl consente di cercare un'espressione regolare e
sostituito con qualcos'altro. Le espressioni regolari sono definite come segue:

#esp.reg /regexp/sostituzione/
È molto simile alla sintassi Perl e verrà eseguito il seguente codice Perl
su ogni riga del file di input:

$ linea =~ s/regexp/sostituzione/g
Per gli utenti che non capiscono Perl, questo significa sostituire tutte le occorrenze di regexp
nella riga corrente con sostituzione.

Una descrizione completa delle espressioni regolari e delle possibili sostituzioni va oltre lo scopo di
questa pagina man. Maggiori informazioni possono essere trovate nella documentazione Perl usando il comando:

perldoc perla

È possibile definire un numero qualsiasi di espressioni regolari. Ogni espressione regolare viene valutata
una volta per ogni riga del file di input. Le espressioni regolari vengono valutate nell'ordine in cui
Sono definiti.

Le espressioni regolari possono essere indefinite nel modo seguente:

#rmregexp /regexp/sostituzione/
Questo rimuoverà l'espressione regolare specificata.

In modalità debug è possibile visualizzare l'elenco corrente di espressioni regolari utilizzando il pragma
parola chiave:

#pragma filepp Mostra Regexp
Quando non è in modalità di debug, non produrrà alcun output.

Una singola espressione regolare può essere definita anche sulla riga di comando usando il tasto REGEXP
macro, ad esempio:

filepp -DREGEXP=/regexp/sostituzione/ -m regexp.pm file di input

Notare la REGEXP la macro deve essere definita PRIMA che il modulo regexp venga caricato, mettendo
-DREGEXP... dopo -m regexp.pm non funzionerà. Quando si utilizza l'approccio della riga di comando, se
, il REGEXP la macro viene analizzata con successo come espressione regolare da cui non sarà definita
il normale elenco di macro filepp prima dell'inizio dell'elaborazione. Bisogna ovviamente fare attenzione
quando si esegue l'escape di caratteri speciali nella shell con espressioni regolari della riga di comando.

BLC MODULO - blc.pm

Il modulo Bracket Line Continuation fa sì che le linee continuino se hanno più aperture
parentesi: "(" rispetto alle parentesi chiuse: ")" su una riga. La linea sarà continuata fino a
si trova un numero uguale di parentesi aperte e chiuse.

È possibile impedire che le parentesi vengano conteggiate per la continuazione della linea facendole uscire con a
barra rovesciata: "\(" e "\)". Qualsiasi parentesi trovata con una barra rovesciata precedente verrà ignorata
quando si decide se è necessario eseguire la continuazione della riga e quindi rimuovere la barra rovesciata una volta
la linea completa è stata trovata.

C MACRO MODULO - cmcros.pm

Il modulo cmacros fa sì che venga citata la definizione delle seguenti macro predefinite:
DATA, TEMPO, VERSIONE, FILE_BASE, FILE, (nota: le macro predefinite sono scritte come __MACRO__).

Questo rende le macro più simili a "C", poiché anche il preprocessore C mette le virgolette intorno a queste
macro.

C MACRO MODULO - cpp.pm

Il cpp fa sì che filepp si comporti in modo simile a un preprocessore C cpp(1).

DISCLAIMER: filepp non è pensato per sostituire un preprocessore C anche con
questo modulo. Non consiglierei di usare filepp come preprocessore C a meno che tu non sia completamente
capire come differisce da un vero preprocessore C. L'output di filepp con il cpp
modulo non sarà lo stesso di un vero preprocessore C.

AFFERRARE MODULO - prendi.pm

Il modulo di acquisizione viene utilizzato per acquisire l'input prima dell'elaborazione. Il suo nome file è prendi.pm.

Il modulo grab è principalmente per l'uso in altri moduli, come for.pm e bigfunc.pm. Esso
acquisisce tutto l'input da un file prima che venga eseguita qualsiasi elaborazione su di esso. Questo permette ad altri
moduli per eseguire l'elaborazione sui dati di input originali prima che venga eseguita l'elaborazione principale.
Ad esempio, il modulo for memorizzerà l'input originale all'interno di un loop e lo riutilizzerà ciascuno
volta che il ciclo viene elaborato.

#preda macro definizione...
Il modulo grab inizierà ad acquisire tutti gli input dalla parola chiave grab, in poi.

#endgrab
Finisce una presa. Tutto tra questa parola chiave e l'ultima precedente #preda sarà
afferrato e archiviato per l'uso in altri moduli.

Le prese possono essere nidificate se necessario.

Quando si chiama grab da un altro modulo, utilizzare le seguenti funzioni:

Afferrare::StartGrab($inizioparola chiave,$ parola chiave finale)
$inizioparola chiave è la parola chiave da cui viene chiamato StartGrab. $ parola chiave finale Europe è
parola chiave a cui l'acquisizione dovrebbe fermarsi.

@Elenco=Prendi::GetInput()
Restituisce un elenco Perl contenente tutto l'input prelevato dall'ultima esecuzione di grab.

$ linea=Afferra::GetInputLine()
Restituisce il numero di riga del file di input in cui è iniziata l'ultima cattura.

FILEPP MODULO API

Il comportamento di filepp possono essere modificati o ampliati mediante l'utilizzo di moduli. filepp
i moduli sono infatti perl(1) moduli, e il resto di questa sezione presuppone che il lettore abbia un
conoscenza di Perl.

filepp i moduli sono perl(1) moduli che estendono o modificano fileppil comportamento di entrambi
chiamando o sostituendo filepple funzioni interne. filepp ha il nome del pacchetto Perl Filepp
quindi le sue funzioni interne possono essere chiamate all'interno dei moduli come Filepp::funzione() or
ad appena funzione(). Qualsiasi filepple funzioni interne di 's possono essere chiamate o sostituite dall'interno
a filepp modulo, quelli più utili sono:

Debug($stringa,numero di $)
Stampa $stringa come informazioni di debug se il debug è abilitato. numero di $ is
opzionale e può essere utilizzato per impostare il livello di debug al quale $stringa dovrebbe essere
stampato, i numeri più bassi hanno priorità più alta. Opzione della riga di comando d stampa tutto
informazioni di debug per 2 e inferiori, opzione dd stampa tutte le informazioni di debug per 3
e sotto e opzione dl stampa tutte le informazioni di debug per 1 e inferiori. Se
numero di $ non è fornito, il valore predefinito è 1.

Aggiungi Processore($funzione,$ pos,$ type)
Consente al modulo di aggiungere una funzione denominata $funzione a fileppla catena di lavorazione.
La catena di elaborazione è un insieme di funzioni che vengono eseguite su ogni riga di un file come
viene elaborato. Le funzioni predefinite nella catena di elaborazione sono Analizza parole chiave
che esegue l'analisi delle parole chiave e Sostituisci Definisci che esegue la sostituzione delle macro.
È possibile aggiungere ulteriori funzioni alla catena, con ciascuna funzione che prende una stringa
(la riga corrente) come input e restituisce la stringa elaborata come output.

Per impostazione predefinita, o se $ pos è impostato a 0, il processore viene aggiunto alla fine del
catena di lavorazione. Se $ pos è impostato a 1 il processore viene aggiunto all'inizio del
catena di lavorazione.

$ type controlla su cosa viene eseguito il processore. Ci sono tre opzioni per questo, 0
(default): il processore gira su tutto ciò che è passato alla catena di elaborazione; 1: il
il processore funziona solo su linee complete; 2: il processore funziona solo su linee parziali (una parte
line è il testo che segue una parola chiave come if che deve essere analizzato per
macro).

Entrambi $ pos e $ type sono parametri facoltativi.

AggiungiProcessoreDopo($funzione,$esistente,$ type)
Aggiunge funzione $funzione alla catena di trasformazione direttamente dopo il processore esistente
$esistente. Se $esistente non si trova allora $funzione viene aggiunto alla fine del
catena di lavorazione. La corrispondenza delle espressioni regolari viene utilizzata per confrontare $esistente con
i nomi delle funzioni nella catena di elaborazione.

$ type è facoltativo.

Aggiungi processore prima ($funzione,$esistente,$ type)
Aggiunge funzione $funzione alla catena di trasformazione direttamente prima del processore esistente
$esistente. Se $esistente non si trova allora $funzione viene aggiunto all'inizio del
catena di lavorazione. La corrispondenza delle espressioni regolari viene utilizzata per confrontare $esistente con
i nomi delle funzioni nella catena di elaborazione.

$ type è facoltativo.

Rimuovi Processore($funzione)
Rimuove la funzione del processore $funzione dalla catena di lavorazione.

$stringa=Sostituisci Definisce($stringa)
Sostituisce tutte le macro in $stringa con le loro definizioni e restituisce gli elaborati
stringa.

Aggiungiparola chiave($stringa,$funzione)
Aggiungi la parola chiave denominata $stringa. Quando la parola chiave viene trovata nell'elaborazione del testo,
funzione denominata $funzione verrà eseguito con tutto ciò che segue la parola chiave passata
come un unico argomento.

Rimuoviparola chiave($stringa)
Rimuove la parola chiave denominata $stringa.

RimuoviTutte le parole chiave()
Rimuove tutte le parole chiave attualmente definite per filepp (usato per la riga di comando -k
opzione).

AggiungiIfword($stringa)
Aggiunge la parola chiave denominata $stringa all'elenco Ifword. Un Ifword accetta la stringa seguente
la parola chiave e facoltativamente la analizza, restituendo 1 se la stringa viene analizzata su true
e 0 per falso. Gli Ifword predefiniti sono if, se def e ifndef.

RimuoviIfword($stringa)
Rimuove la parola chiave denominata $stringa dall'elenco Ifword (nota: questo NON rimuove il
parola chiave, uso Rimuovi parola chiave per quello).

AggiungiElseword($stringa)
Aggiunge la parola chiave denominata $stringa all'elenco Elseword. Un'Elseword prende la stringa
seguendo la parola chiave e facoltativamente la analizza, restituendo un 1 se la stringa analizza
a vero e 0 a falso. Le Elseword predefinite sono altro e Elif.

RimuoviElseword($stringa)
Rimuove la parola chiave denominata $stringa dall'elenco Elseword.

AggiungiEndifword($stringa)
Aggiunge la parola chiave denominata $stringa all'elenco Endifword. Un Endifword dovrebbe restituire un 1 a
indicare la conclusione positiva del blocco if. Se Endifword restituisce 0 il
Endifword viene ignorato e filepp assume il blocco corrente se continua dopo il
Endifword. L'Endifword predefinito è endif.

RimuoviEndifword($stringa)
Rimuove la parola chiave denominata $stringa dall'elenco Endifword.

AggiungiIncludePath($stringa)
Aggiunge il percorso di inclusione $stringa all'elenco delle directory da cercare include
file (usato per l'opzione della riga di comando -I).

AggiungiPercorsoModulo($stringa)
Aggiunge il percorso $stringa all'elenco delle directory in cui cercare i moduli filepp (usato
per l'opzione della riga di comando -M).

AggiungiFunzioneOpenInput($funzione)
Aggiunge un $funzione a un elenco di funzioni da eseguire ogni volta che un nuovo file di input di base
è aperto.

AggiungiChiudiInputFunc($funzione)
Aggiunge un $funzione a un elenco di funzioni da eseguire ogni volta che un nuovo file di input di base
è chiuso.

AggiungiFunzioneOpenOutput($funzione)
Aggiunge un $funzione a un elenco di funzioni da eseguire ogni volta che viene visualizzato un file di output
ha aperto.

AggiungiChiudiOutputFunc($funzione)
Aggiunge un $funzione a un elenco di funzioni da eseguire ogni volta che viene visualizzato un file di output
chiuso.

AggiungiFileInput($stringa)
Aggiunge un altro file di input all'elenco dei file da elaborare (usato per aggiungere input
file dalla riga di comando).

ModificaFileOutput($stringa)
Chiude il file di output corrente e tenta di aprirne uno nuovo denominato $stringa.

ImpostaKeywordchar($stringa)
Imposta il carattere della parola chiave iniziale su $stringa (usato per l'opzione della riga di comando -kc).

ImpostaContchar($stringa)
Imposta il carattere di continuazione della riga su $stringa (usato per l'opzione della riga di comando -lc).

SetContrepchar($stringa)
Imposta il carattere di sostituzione della continuazione della riga su $stringa (usato per il comando -lr
opzione linea).

SetOptLineEndchar($stringa)
Imposta il carattere di fine riga della parola chiave opzionale su $stringa (usato per il comando -lec
opzione linea).

ImpostaBlankSupp(1/0)
Attiva/disattiva la soppressione delle righe vuote (1 = sopprime, 0 = non sopprime). quando
la soppressione delle righe vuote è attiva, le righe vuote nei file di input non verranno copiate nel file
produzione. A differenza della corrispondente opzione della riga di comando (-b), questa funzione può anche
hanno effetto nel file di primo livello. Si applica l'impostazione della soppressione delle righe vuote
al file corrente in elaborazione e tutti i file inclusi nel file corrente.

ResetBlankSupp()
Reimposta la soppressione della riga vuota sul valore specificato dalla riga di comando. Solo questo
influisce sull'output delle righe vuote dal file attualmente in elaborazione e tutto il resto
file inclusi nel file corrente. Nel file di primo livello, questo diventa sempre
soppressione delle righe vuote disattivata.

SetMangiaTrail($stringa)
If $stringa è una macro, ogni volta che la macro viene sostituita tutto lo spazio vuoto tra i
la sostituzione della macro e il carattere successivo sulla riga verranno mangiati. Per esempio,
se macro foo è definito a bar e foo è stato impostato per avere il suo sentiero mangiato, il
seguenti:

mangia la mia scia

viene sostituito con

mangia il mio bartrail

CheckEatTrail($stringa)
Restituisce 1 se macro $stringa avrà la coda mangiata, 0 altrimenti.

SetEnvchar($stringa)
Imposta il prefisso delle variabili di ambiente convertite in macro (envchar) A $stringa
(usato per le opzioni della riga di comando -ec e -ecn).

DefinisciEnv()
Definisci tutte le variabili d'ambiente come macro con prefisso envchar (usato per il comando -e
opzione linea).

ImpostaUscita(1/0)
Attiva/disattiva la scrittura del file di input analizzato nel file di output. Questo richiede 1
(uscita attiva) o 0 (uscita disattivata) come ingresso. Quando l'uscita è disattivata, l'unico
output prodotto da filepp sarà quello generato dai moduli.

ImpostaConfiniParole(1/0)
Giri on(1) o MENO(0) controllo dei limiti delle parole durante la sostituzione delle macro (usato per -w
opzione della riga di comando).

ImpostaCarPerlre(1/0)
Giri on(1) o MENO(0) consentendo il prefisso della parola chiave char e il carattere di continuazione della riga a
essere espressioni regolari Perl (utilizzate per l'opzione della riga di comando -re).

UndefTutto()
Annulla tutte le macro attualmente definite, incluse quelle predefinite (usate per -u
opzione della riga di comando).

UsaModulo($stringa)
Carichi un perl(1) modulo denominato $stringa usando il comando Perl richiedere (usato per il
-m opzione della riga di comando).

ImpostaFineRigaParse($funzione)
Imposta la funzione per determinare se la continuazione della riga deve essere eseguita sulla riga corrente
a $funzione.

$stringa=OttieniLineaSuccessiva()
Restituisce la riga successiva (dopo che è stata trattata la continuazione della riga) dell'input
file attualmente in fase di elaborazione. Restituisce NULL per la fine del file.

Scrivi($stringa)
scrive $stringa al file di output corrente.

Produzione($stringa)
Scrive condizionalmente $stringa al file di output corrente. Se l'uscita è attivata
poi scrive $stringa. L'uscita viene attivata/disattivata utilizzando la funzione SetOutput.

In più tutto lo standard filepp le parole chiave hanno funzioni equivalenti che facoltativamente
prendi un solo argomento. Le funzioni hanno lo stesso nome della parola chiave, solo con a
prima lettera maiuscola (es: #define stringa chiama la funzione Definire(stringa)).

Una descrizione completa del Analizza funzione e tutto il resto filepp funzioni interne è
oltre lo scopo di questa pagina man. Il filepp lo script è ben commentato e, si spera
leggibile da un programmatore Perl, quindi usa il sorgente Luke!

Utilizzare filepp online utilizzando i servizi onworks.net