escript - Online in de cloud

PROGRAMMA:

NAAM

escript - Ondersteuning voor Erlang-scripts

PRODUCTBESCHRIJVING

escript biedt ondersteuning voor het uitvoeren van korte Erlang-programma's zonder ze te hoeven compileren
eerste en een gemakkelijke manier om de opdrachtregelargumenten op te halen.

UITVOER

scriptnaam script-arg1 script-arg2...
escript escript-vlaggen scriptnaam script-arg1 script-arg2...

escript voert een script uit dat is geschreven in Erlang.

Hier volgt een voorbeeld.

$ chmod u+x faculteit
$ kat faculteit
#!/usr/bin/env escript
%% -*- lang -*-
%%! -smp inschakelen -sname faculteit -mnesia debug verbose
main([String]) ->
proberen
N = lijst_naar_geheel getal (tekenreeks),
F = fa(N),
io:format("faculteit ~w = ~w\n", [N,F])
vangst
_:_ ->
gebruik()
einde te maken;
hoofd(_) ->
gebruik().

gebruik() ->
io:format("gebruik: gehele faculteit\n"),
halte(1).

fac(0) -> 1;
fac(N) -> N * fac(N-1).
$ ./faculteit 5
faculteit 5 = 120
$ ./faculteit
gebruik: faculteit integer
$ ./faculteit vijf
gebruik: faculteit integer

De header van het Erlang-script in het voorbeeld wijkt af van een normale Erlang-module.
De eerste regel is bedoeld als de interpreterregel, die roept: escript.
Als u echter de escript als dit

$ escript faculteit 5

de inhoud van de eerste regel doet er niet toe, maar deze kan geen Erlang-code bevatten
aangezien het zal worden genegeerd.

De tweede regel in het voorbeeld bevat een optionele instructie voor de Emacs editor
waardoor het naar de hoofdmodus gaat voor het bewerken van Erlang-bronbestanden. Als de
richtlijn aanwezig is, moet deze zich op de tweede regel bevinden.

Als er een opmerking is, selecteert u de codering het kan op de tweede regel worden geplaatst.

Opmerking:
De codering gespecificeerd door de bovengenoemde opmerking is van toepassing op het script zelf.
De codering van de I/O-server moet echter expliciet als volgt worden ingesteld:

io:setopts([{codering, unicode}])

De standaard codering van de I/O-server voor: standaard_io is latin1 sinds het script
draait in een niet-interactieve terminal (zie gebruik Unicode in Erlang).

Op de derde lijn (of tweede lijn afhankelijk van de aanwezigheid van de Emacs
richtlijn), is het mogelijk om argumenten aan de emulator te geven, zoals:

%%! -smp inschakelen -sname faculteit -mnesia debug verbose

Zo'n argumentregel moet beginnen met %%! en de rest van de regel wordt geïnterpreteerd
als argumenten voor de emulator.

Als u de locatie van de escript uitvoerbaar, de eerste regel kan direct
geef het pad naar escript. Bijvoorbeeld:

#!/usr/local/bin/escript

Zoals elk ander soort script, zullen Erlang-scripts niet werken op Unix-platforms als de
uitvoeringsbit voor het scriptbestand is niet ingesteld. (Gebruik maken van chmod +x scriptnaam aanzetten
het uitvoeringsbit.)

De rest van het Erlang-scriptbestand kan ofwel Erlang . bevatten bron codeeen
inline straal filet of inline archief filet.

Een Erlang-scriptbestand moet altijd de functie bevatten hoofd/1. Wanneer het script is
voer de ... uit hoofd/1 functie wordt aangeroepen met een lijst met tekenreeksen die de . vertegenwoordigen
argumenten die aan het script worden gegeven (niet gewijzigd of op enigerlei wijze geïnterpreteerd).

Indien de hoofd/1 functie in het script succesvol terugkeert, de exit-status voor de
script is 0. Als er een uitzondering wordt gegenereerd tijdens de uitvoering, wordt een kort bericht
wordt afgedrukt en het script wordt beëindigd met afsluitstatus 127.

Bel . om uw eigen exit-code te retourneren die niet nul is stoppen(ExitCode); bijvoorbeeld:

halte(1).

Bel escript:scriptnaam() van uw naar script om de padnaam van de . op te halen
script (de padnaam is meestal, maar niet altijd, absoluut).

Als het bestand broncode bevat (zoals in het bovenstaande voorbeeld), wordt het verwerkt door:
de preprocessor ePP. Dit betekent dat u bijvoorbeeld voorgedefinieerde macro's mag gebruiken
(Zoals ?MODULE) evenals richtlijnen zoals de -include_lib Richtlijn.
Gebruik bijvoorbeeld

-include_lib("kernel/include/file.hrl").

om de recorddefinities op te nemen voor de records die worden gebruikt door de bestand:read_link_info/1
functie. U kunt codering ook selecteren door hier een coderingsopmerking op te nemen, maar als:
er is een geldige coderingsopmerking op de tweede regel die voorrang heeft.

Het script wordt gecontroleerd op syntactische en semantische correctheid voordat het wordt uitgevoerd.
Als er waarschuwingen zijn (zoals ongebruikte variabelen), worden deze afgedrukt en de
script wordt nog steeds uitgevoerd. Als er fouten zijn, worden deze afgedrukt en het script
wordt niet uitgevoerd en de afsluitstatus is 127.

Zowel de moduleaangifte als de uitvoeraangifte van de hoofd/1 functie zijn
optioneel.

Standaard wordt het script geïnterpreteerd. Je kunt het forceren om gecompileerd te worden door:
inclusief de volgende regel ergens in het scriptbestand:

-modus (compileren).

Uitvoering van geïnterpreteerde code is langzamer dan gecompileerde code. Als veel van de
uitvoering vindt plaats in geïnterpreteerde code, het kan de moeite waard zijn om het te compileren, zelfs
hoewel de compilatie zelf enige tijd in beslag zal nemen. Het is ook mogelijk om
leveren inheemse in plaats van compileren, dit zal het script compileren met behulp van de native
vlag, opnieuw afhankelijk van de kenmerken van het escript kan dit wel of niet
de moeite waard zijn.

Zoals eerder vermeld, is het mogelijk om een ​​script te hebben dat voorgecompileerde
straal code. In een voorgecompileerd script is de interpretatie van de scriptkop:
precies hetzelfde als in een script met broncode. Dat betekent dat je kunt
maak een straal bestand uitvoerbaar door het bestand vooraf te laten gaan met de regels die beginnen met #!
en %%! hierboven vermeld. In een voorgecompileerd script is de functie hoofd/1 moet
geëxporteerd.

Als nog een andere optie is het mogelijk om een ​​heel Erlang-archief in de
script. In een archiefscript is de interpretatie van de scriptkop precies de
hetzelfde als in een script dat de broncode bevat. Dat betekent dat je een archief kunt maken
bestand uitvoerbaar door het bestand vooraf te laten gaan met de regels die beginnen met #! en %%!
hierboven vermeld. In een archiefscript is de functie hoofd/1 moet worden geëxporteerd. Door
standaard de hoofd/1 functie in de module met dezelfde naam als de basisnaam van de
escript bestand wordt aangeroepen. Dit gedrag kan worden overschreven door de vlag in te stellen
-schrift hoofd- Module als een van de emulatorvlaggen. De Module moet de naam zijn van a
module met een geëxporteerd hoofd/1 functie. Zien code(3erl) voor meer informatie
over archieven en het laden van codes.

In veel gevallen is het erg handig om een ​​koptekst in het escript te hebben, vooral op
Unix-platforms. Maar de kop is in feite optioneel. Dit betekent dat je direct
kan een Erlang-module, beam-bestand of archiefbestand "uitvoeren" zonder een header toe te voegen
naar hen. Maar dan moet je het script als volgt aanroepen:

$ escript faculteit.erl 5
faculteit 5 = 120
$ escript faculteit.beam 5
faculteit 5 = 120
$ escript faculteit.zip 5
faculteit 5 = 120

escript:creëren(FileOrBin, secties) -> ok | {Oke, binair()} | {fout, termijn()}

types:

FileOrBin = bestandsnaam() | 'binair'
Secties = [Koptekst] Hoofdtekst | Lichaam
Header = kreng | {shebang, shebang} | commentaar | {commentaar, commentaar} |
{emu_args, EmuArgs}
Shebang = string() | 'standaard' | 'niet gedefinieerd'
Commentaar = string() | 'standaard' | 'niet gedefinieerd'
EmuArgs = string() | 'niet gedefinieerd'
Body = {bron, broncode} | {straal, BeamCode} | {archief, ZipArchive} |
{archief, ZipFiles, ZipOptions}
SourceCode = BeamCode = bestand:bestandsnaam() | binair()
ZipArchief = zip:bestandsnaam() | binair()
ZipFiles = [Zipbestand]
ZipFile = bestand:bestandsnaam() | {bestand:bestandsnaam(), binair()} | {bestand:bestandsnaam(),
binair(), bestand:bestandsinfo()}
ZipOpties = [zip:create_option()]

Ocuco's Medewerkers creëren/2 functie maakt een escript van een lijst met secties. De secties kunnen
in willekeurige volgorde worden gegeven. Een escript begint met een optional Voorvoegsel gevolgd door een
verplicht Lichaam. Als de header aanwezig is, begint deze altijd met a keet,
eventueel gevolgd door een commentaar en emu_args. De keet standaard "/usr/bin/env
escript". De opmerking is standaard "Deze is an - * - erlang - * - het dossier". de gecreëerde
escript kan als binair worden geretourneerd of naar een bestand worden geschreven.

Als voorbeeld van hoe de functie kan worden gebruikt, maken we een geïnterpreteerd escript
welke gebruikt emu_args om een ​​emulatorvlag in te stellen. In dit geval gebeurt het uitschakelen
de smp_support. We halen ook de verschillende secties uit de nieuw gemaakte
script:

> Source = "%% Demo\nmain(_Args) ->\n io:format(erlang:system_info(smp_support)).\n".
"%% Demo\nmain(_Args) ->\n io:format(erlang:system_info(smp_support)).\n"
> io:format("~s\n", [Bron]).
%% demo
main(_Args) ->
io:format(erlang:system_info(smp_support)).

ok
> {ok, Bin} = escript:create(binary, [shebang, comment, {emu_args, "-smp disable"}, {source, list_to_binary(Bron)}]).
{oke,<<"#!/usr/bin/env escript\n%% Dit is een -*- erlang -*- bestand\n%%!-smp disabl"...>>}
> bestand:write_file("demo.escript", Bin).
ok
> os:cmd("escript demo.escript").
"vals"
> escript:extract("demo.escript", []).
{ok,[{shebang,default}, {comment,default}, {emu_args,"-smp uitschakelen"},
{source,<<"%% Demo\nmain(_Args) ->\n io:format(erlang:system_info(smp_su"...>>}]}

Een escript zonder header kan als volgt worden gemaakt:

> file:write_file("demo.erl", ["%% demo.erl\n-module(demo).\n-export([main/1]).\n\n", Source]).
ok
> {ok, _, BeamCode} = compile:file("demo.erl", [binair, debug_info]).
{oké, demo,
<<70,79,82,49,0,0,2,208,66,69,65,77,65,116,111,109,0,0,0,
79,0,0,0,9,4,100,...>>}
> escript:create("demo.beam", [{beam, BeamCode}]).
ok
> escript:extract("demo.beam", []).
{ok,[{shebang,undefined}, {commentaar,undefined}, {emu_args,undefined},
{balk,<<70,79,82,49,0,0,3,68,66,69,65,77,65,116,
111,109,0,0,0,83,0,0,0,9,...>>}]}
> os:cmd("escript demo.beam").
"True"

Hier creëren we een archiefscript dat zowel Erlang-code als beam-code bevat.
Vervolgens herhalen we alle bestanden in het archief en verzamelen we hun inhoud en wat
informatie over hen.

> {ok, SourceCode} = file:read_file("demo.erl").
{ok,<<"%% demo.erl\n-module(demo).\n-export([main/1]).\n\n%% Demo\nmain(_Arg"...>>}
> escript:create("demo.escript", [shebang, {archive, [{"demo.erl", SourceCode}, {"demo.beam", BeamCode}], []}]).
ok
> {ok, [{shebang,default}, {comment,undefined}, {emu_args,undefined}, {archive, ArchiveBin}]} = escript:extract("demo.escript", []).
{ok,[{shebang,standaard}, {commentaar,undefined}, {emu_args,undefined},
{{archief,<<80,75,3,4,20,0,0,0,8,0,118,7,98,60,105,
152,61,93,107,0,0,0,118,0,...>>}]}
> bestand:write_file("demo.zip", ArchiveBin).
ok
> zip:foldl(fun(N, I, B, A) -> [{N, I(), B()} | A] end, [], "demo.zip").
{ok,[{"demo.beam",
{file_info,748,reguliere,read_write,
{{2010,3,2},{0,59,22}},
{{2010,3,2},{0,59,22}},
{{2010,3,2},{0,59,22}},
54,1,0,0,0,0,0},
<<70,79,82,49,0,0,2,228,66,69,65,77,65,116,111,109,0,0,0,
83,0,0,...>>},
{"demo.erl",
{file_info,118,reguliere,read_write,
{{2010,3,2},{0,59,22}},
{{2010,3,2},{0,59,22}},
{{2010,3,2},{0,59,22}},
54,1,0,0,0,0,0},
<<"%% demo.erl\n-module(demo).\n-export([main/1]).\n\n%% Demo\nmain(_Arg"...>>}]}

escript:extract(Bestand, opties) -> {Oke, secties} | {fout, termijn()}

types:

Bestand = bestandsnaam()
Opties = [] | [compileer_bron]
Secties = Headers Body
Headers = {shebang, Shebang} {commentaar, commentaar} {emu_args, EmuArgs}
Shebang = string() | 'standaard' | 'niet gedefinieerd'
Commentaar = string() | 'standaard' | 'niet gedefinieerd'
EmuArgs = string() | 'niet gedefinieerd'
Body = {bron, broncode} | {bron, BeamCode} | {straal, BeamCode} | {archief,
ZipArchief}
SourceCode = BeamCode = ZipArchive = binair()

Ocuco's Medewerkers uittreksel/2 functie ontleedt een escript en extraheert de secties. Dit is de
keerzijde van creëren/2.

Alle secties worden geretourneerd, zelfs als ze niet bestaan ​​in het escript. Als een bepaald
sectie heeft toevallig dezelfde waarde als de standaardwaarde, de geëxtraheerde waarde is
ingesteld op het atoom verzuim. Als een sectie ontbreekt, wordt de geëxtraheerde waarde ingesteld op de
atoom Gulf Driller VI.

Ocuco's Medewerkers compileer_bron optie heeft alleen invloed op het resultaat als het escript bevat bron
code. In dat geval wordt de Erlang-code automatisch gecompileerd en {bron, straalcode}
wordt geretourneerd in plaats van {bron, Broncode}.

> escript:create("demo.escript", [shebang, {archive, [{"demo.erl", SourceCode}, {"demo.beam", BeamCode}], []}]).
ok
> {ok, [{shebang,default}, {comment,undefined}, {emu_args,undefined}, {archive, ArchiveBin}]} = escript:extract("demo.escript", []).
{ok,[{{archief,<<80,75,3,4,20,0,0,0,8,0,118,7,98,60,105,
152,61,93,107,0,0,0,118,0,...>>}
{emu_args,ungedefinieerd}]}

escript:scriptnaam() -> Dien in

types:

Bestand = bestandsnaam()

Ocuco's Medewerkers scriptnaam/0 functie retourneert de naam van het escript dat wordt uitgevoerd. Als de
functie wordt aangeroepen buiten de context van een escript, is het gedrag niet gedefinieerd.

OPTIES AANVAARD BY BESCHRIJVING

-C:
Compileer het escript ongeacht de waarde van het mode-attribuut.

-d:
Debug het escript. Start de debugger, laadt de module met de hoofd/1
functie in de debugger, stelt een breekpunt in hoofd/1 en roept op hoofd/1. Indien de
module vooraf is gecompileerd, moet deze expliciet worden gecompileerd met de debug_info optie.

-ik:
Interpreteer het escript ongeacht de waarde van het mode-attribuut.

-S:
Voer alleen een syntactische en semantische controle van het scriptbestand uit. Waarschuwingen en fouten
(indien aanwezig) worden naar de standaarduitvoer geschreven, maar het script wordt niet uitgevoerd. De uitgang
status is 0 als er geen fouten zijn en anders 127.

-N:
Compileer het escript met de +native-vlag.

Gebruik escript online met onworks.net-services