Pascal (programmeringsspråk)

Den aktuella versionen av sidan har ännu inte granskats av erfarna bidragsgivare och kan skilja sig väsentligt från versionen som granskades den 16 maj 2022; kontroller kräver 3 redigeringar .
Pascal
Språkklass imperativ , strukturerad
Utförandetyp sammanställt
Framträdde i 1970
Författare Niklaus Wirth
Filtillägg _ .pasför kodfiler, .incför rubrikfiler .
Släpp ISO/IEC 10206:1991 Steg: 90,93 ( 29 juli 2008 )
Typ system statisk , stark , säker [1]
Stora implementeringar CDC 6000 , ICT 1900 , Pascal-P , PDP-11 , PDP-10 , IBM System/370 , HP , Free Pascal , GNU , PascalABC.NET
Dialekter UCSD , Turbo , Delphi
Blivit påverkad ALGOL
påverkas Modula-2 , Oberon , Component Pascal , Ada , Object Pascal , Java [2] [3] [4] , Oxygene
Hemsida iso.org/standard/18237.h...
 Mediafiler på Wikimedia Commons

Pascal ärett av de mest kända programmeringsspråken [  5 ] , som används för att undervisa i programmering på gymnasiet och under de första åren på universitet, är grunden för ett antal andra språk.

Historik

Programmeringsspråket Pascal skapades 1970 baserat på språket Algol-60 [6] .

Pascal skapades av Niklaus Wirth 1968-1969 efter hans deltagande i arbetet i Algol-68 språkstandardutvecklingskommittén . Språket är uppkallat efter den franske matematikern, fysikern, författaren och filosofen Blaise Pascal , som skapade en av världens första mekaniska maskiner för att lägga till två siffror . Wirths första publikation om språk är daterad 1970; När han presenterade språket angav författaren som målet för dess skapande konstruktionen av ett litet och effektivt språk som främjar en bra programmeringsstil med hjälp av strukturerad programmering och strukturerad data.

Wirths efterföljande arbete var att skapa ett systemprogrammeringsspråk baserat på Pascal samtidigt som man bibehåller förmågan att genomföra en systematisk, holistisk kurs av professionell programmeringsutbildning på grundval av detta: “ Den vägledande idén var att konstruera en genuin efterföljare till Pascal som uppfyller kraven för systemteknik. , men också för att tillfredsställa min lärares önskan att presentera en systematisk, konsekvent, tilltalande och lärbar ram för professionell programmering. ". Resultatet av detta arbete blev Modula-2- språket , varefter Wirth började utveckla det objektorienterade programmeringsspråket Oberon baserat på alla tidigare utvecklingar [6] .

Niklaus Wirth ansåg att ett av målen med att skapa Pascal-språket för att lära eleverna strukturell programmering. Fram till nu anses Pascal välförtjänt vara ett av de bästa språken för inledande programmeringsinlärning. Dess moderna modifieringar, såsom Object Pascal, används ofta i industriell programmering (Delphi-miljö). Baserat på syntaxen för Pascal-språket skapades också programmeringsspråket Structured Text (ST) eller Structured Control Language (SCL) för programmerbara logiska styrenheter .

På 1990-talet hade Pascal blivit ett av världens mest använda algoritmiska programmeringsspråk. Ledande mjukvaruutvecklare släppte regelbundet nya versioner av sina kompilatorer för detta språk. Populära kompilatorer av tiden: Turbo Pascal (utvecklad av Borland ), Microsoft Pascal Compiler, Quick Pascal, Pascal-2, Professional Pascal, USCD Pascal [7] .

Implementationer och dialekter

Språket Pascal har många implementeringar [8] .

UCSD Pascal

1978 utvecklades UCSD p-System vid University of California i San Diego , som inkluderade en port av Wirth-kompilatorn från Pascal-språket till portabel p-kod , en källkodsredigerare, ett filsystem, etc. [9 ] , och implementerade även ett betydande antal språktillägg Pascal, såsom moduler, teckensträngar med variabel längd, översättningsdirektiv, I/O-felhantering, hänvisning till filer med namn och mer. Därefter baserades de huvudsakliga implementeringarna av Pascal-språket på denna dialekt.

ObjectPascal

1986 utvecklade Apple ett objekttillägg till Pascal-språket, vilket resulterade i Object Pascal . Den utvecklades av Larry Teslers grupp , som rådfrågade Niklaus Wirth .

Turbo Pascal och Object Pascal

1983 dök den första versionen av Borlands integrerade utvecklingsmiljö Turbo Pascal upp , baserad på Pascal-implementeringen med samma namn.

1989 lades ett objektspråktillägg till Turbo Pascal version 5.5.

Den senaste versionen (7.0) har bytt namn till Borland Pascal.

Objektfaciliteterna är lånade från Apples Object Pascal, och det finns väldigt få språkskillnader mellan Object Turbo Pascal 5.5 och Apples Object Pascal.

Nästan samtidigt med Borland släppte Microsoft sin version av det objektorienterade språket Pascal. [10] [11] Denna version av Pascal användes inte i stor utsträckning.

Ytterligare utveckling av Pascal-implementeringen från Borland gav upphov till Borlands Object Pascal -variant , senare, under utvecklingen av programmeringsmiljön Delphi , som fick samma namn .

Midlet Pascal

Moderna versioner av Object Pascal

Ett viktigt steg i utvecklingen av språket är uppkomsten av fria implementeringar av Pascal-språket Free Pascal och GNU Pascal , som inte bara absorberade funktionerna i många andra dialekter av språket, utan också säkerställde extremt bred portabilitet av program skrivna i det (till exempel stöder GNU Pascal mer än 20 olika plattformar, under över 10 olika operativsystem, Free Pascal tillhandahåller speciella kompatibilitetslägen med olika vanliga dialekter i språket, såsom Turbo Pascal (full kompatibilitet), Delphi och andra).

Sedan Delphi 2003 har en språkimplementering skapats för .Net- plattformen , även om utvecklare fortsätter att använda Delphi från tidigare versioner.

Lite är för närvarande känt om kommersiell utveckling i Free Pascal, GNU Pascal och TMT Pascal .

Dessutom har Southern Federal University utvecklat PascalABC.NET  , ett Pascal-programmeringsspråk som innehåller de flesta funktionerna i Delphi- språket , såväl som ett antal egna tillägg. Den är baserad på Microsoft.NET -plattformen och innehåller nästan alla moderna språkfunktioner: klasser , operatörsöverbelastning , gränssnitt , undantagshantering , generiska klasser och subrutiner , sophämtning , lambda-uttryck .

Funktioner i språket

Funktionerna i språket är strikt maskinskrivning och tillgången till strukturella (procedurmässiga) programmeringsverktyg . Pascal var ett av de första sådana språken. Enligt Wirth ska språket bidra till disciplinerad programmering, därför minimeras, tillsammans med stark typning, möjliga syntaktiska oklarheter i Pascal, och författaren försökte göra själva syntaxen intuitiv redan vid första bekantskapen med språket.

Men till en början hade språket ett antal begränsningar: omöjligheten att skicka arrayer av variabel längd till funktioner, avsaknaden av normala sätt att arbeta med dynamiskt minne , ett begränsat I/O-bibliotek , avsaknaden av medel för att koppla ihop funktioner skrivna i andra språk, avsaknaden av separata kompileringsverktyg etc. En detaljerad analys av bristerna i dåtidens Pascal-språk utfördes av Brian Kernighan i artikeln "Why Pascal is not my favorite programming language" [12] (denna artikel dök upp i början av 1980-talet, när Modula-2 , en ättling till Pascal, blev av med de flesta av dess laster, såväl som mer utvecklade dialekter av Pascal). Vissa brister hos Pascal korrigerades i 1982 års ISO-standard, särskilt öppna arrayer dök upp i språket, vilket gjorde det möjligt att använda samma procedurer för att bearbeta endimensionella arrayer av olika storlekar.

Många av språkets brister dyker dock inte upp eller blir ens fördelar när man lär sig programmera. Jämfört med det huvudsakliga programmeringsspråket i den akademiska miljön på 1970 -talet (som var Fortran , som hade mycket mer betydande nackdelar), representerade Pascal ett betydande steg framåt. På 1980-talet blev Pascal grunden för många utbildningsprogram, i vissa fall skapades specialiserade programmeringsspråk för undervisning, till exempel i början av 1980-talet i Sovjetunionen utvecklade Andrei Ershov ett Algol-Pascal-liknande språk att lära skolbarn grunderna i datavetenskap och datateknik. " lära algoritmiskt språk ".

Den mest kända implementeringen av Pascal, som säkerställde den breda spridningen och utvecklingen av språket, är Borlands Turbo Pascal , som sedan växte till objektet Pascal för DOS (från och med version 5.5) och Windows och vidare till Delphi, på vilket betydande språk förlängningar infördes.

Standarder

Efter att användningen av Pascal började 1970, och uppkomsten av implementeringar som skilde sig inte bara i tillägg, utan också i syntax, väcktes frågan om standardisering av språket. Språkstandarden utvecklades av Niklaus Wirth 1974 tillsammans med Kathleen Jensen. [13] Därefter antogs en internationell standard från ISO och en amerikansk standard från ANSI. För tillfället finns det tre fundamentalt olika standarder: Unextended Pascal (original), Extended Pascal (extended), Object-Oriented Extensions to Pascal (objektorienterad Pascal extension).

Pascal Language Standards: Source, International ISO och American ANSI
namn Alternativ Vem/var utvecklats Skapandets år
Pascal Standard första N. Wirth, Kathleen Jensen 1974
Pascal Standard första ISO 7185:1983
ANSI/ IEEE 770X3.97:1983		 1982
Oförlängd Pascal första ISO 7185:1990 1989
Förlängd Pascal förlängt ANSI/IEEE 770X3.160:1989 1989
ISO/ IEC 10206 1991
Objektorienterade
tillägg till Pascal [14] 		objektorienterad förlängning ANSI/X3-TR-13:1994 1993

En av de viktigaste ytterligare funktionerna i den objektorienterade Extended Pascal-förlängningen var modularitet och faciliteter som underlättar separat kompilering.

Standardiseringen av språket släpade efter det faktiska utseendet av vissa funktioner i språket. Kommersiella implementeringar har utökat standard Pascal; detta har gjorts i UCSD Pascal, Apples modifiering av Object Pascal , Borlands Turbo Pascal (en något modifierad version av Apple) och dess utlöpare. Ingen av de vanliga kommersiella implementeringarna av Pascal överensstämmer exakt med någon av de officiella språkstandarderna.

Syntax och språkkonstruktioner

Pascal, i sin ursprungliga form, är ett rent procedurspråk och innehåller många Algol-liknande strukturer och reserverade ordkonstruktioner som if, then, else, while, for, repeatetc. Pascal innehåller dock också ett stort antal möjligheter för att strukturera information och abstraktioner , som saknas från den ursprungliga Algol-60 , såsom typdefinitioner , poster , pekare , uppräkningar och uppsättningar . Dessa konstruktioner ärvdes delvis eller inspirerade från Simula -67 , Algol-68 skapad av Niklaus Wirth AlgolWoch föreslagen av Hoare .

På moderna dialekter (Delphi Pascal, Free Pascal) finns funktioner som operatörs- och funktionsöverbelastning tillgängliga.

Hej världen!

Pascal-program börjar med ett nyckelord Program följt av programnamnet följt av semikolon (valfritt i vissa dialekter), namnet kan följas inom parentes av en lista med externa fildeskriptorer ("miljö") som parametrar; den följs av programmets brödtext, bestående av sektioner som beskriver konstanter ( Const), typer ( Type), variabler ( Var), deklarationer av procedurer ( Procedure) och funktioner ( Function) och det block av satser som följer dem , som är ingångspunkten till program. I Pascal är blocket begränsat till nyckelorden beginoch end. Uttalandena separeras med semikolon , efter att kroppen har placerats en punkt , som fungerar som ett tecken på slutet av programmet.

Fallet med karaktärer i Pascal spelar ingen roll.

Således skulle det enklaste ("tomma") Pascal-programmet se ut så här:

program p ; börja slut .

Ovanstående program gör ingenting och innehåller ett tomt block med uttalanden.

Ett exempel på ett program som skriver ut strängen " Hej världen!" »:

program hej ; Börja writeln ( 'Hej världen!' ) ; // strängutgångsoperator slut .

Datatyper

Enkla typer

Det finns enkla typer i standard och utökad Pascal: flyttal ( real), heltal ( integer), tecken ( char), boolesk ( boolean) och uppräkningar (ny typkonstruktor introducerad i Pascal).

Turbo Pascal har lagt till varianter av dessa typer till språket: till exempel shortintblir det kortare integeroch longint längre.

Moderna dialekter av Pascal, såsom FPC eller Delphi , anser att integer - detta är det heltal som är mest lämpligt för en given maskin, som används till exempel för arrayindex , och shortint, longintoch andra - heltal av en viss längd; detta är praktiskt för plattformsoberoende programmering. Likaså med bråktal.

Typerna utökades igen när man bytte till x64  - "bara ett heltal" ( integer) förblev 32-bitars, men en speciell typ krävdes, som är lika longintmed x86 och int64x64.

Heltalstyper:

Sorts Räckvidd Formatera Storlek i byte Anteckningar
bytes 0..255 osignerad ett
ShortInt −128..127 ikonisk ett
SmallInt −32768..32767 ikonisk 2 Finns kanske inte; istället ett heltal med samma intervall
Ord 0..65535 osignerad 2
långt ord 0..4294967295 osignerad fyra
LongInt −2147483648..2147483647 ikonisk fyra
int64 −9223372036854775808..9223372036854775807 ikonisk åtta
QWord 0..18446744073709551615 osignerad åtta
Heltal -32768..32767. ikonisk 2 eller 4 Det snabbaste heltal; SmallInt eller LongInt
kardinal ? osignerad ? Det snabbaste heltal; vanligtvis LongWord
NativeInt ? ikonisk ? Matchar maskinregister; LongInt eller Int64
NativeUInt ? osignerad ? Matchar maskinregister; LongWord eller QWord

Flyttal:

Sorts Räckvidd Antal signifikanta siffror Storlek i byte Stöd
Verklig plattformsberoende ??? ??? Alla kompilatorer; på moderna är det vanligtvis likvärdigt med Double
Riktigt 48 2.9E−39..1.7E38 11-12 6 Borland; i Turbo Pascal hette det Real; använder inte en samprocessor och därför upprepas resultatet till biten
Enda 1.5E−45..3.4E38 7−8 fyra De flesta alternativen under IEEE 754 -kompatibla maskiner
Dubbel 5.0E-324..1.7E308 15−16 åtta De flesta alternativen under IEEE 754 -kompatibla maskiner
Förlängd 3.4E-4951..1.1E4932 19–20 tio De flesta alternativen för x86
Comp −9223372036854775808..9223372036854775807 åtta Borland; 8-byte heltal beräknat på samprocessorn; relevant för 16-bitars x86
Valuta −922337203685477.5808..922337203685477.5807 åtta Borland och andra kompilatorer för Windows; associerad med OLE ; fast punkt med enhet lika med 10000
var { variabeldeklarationsavsnitt } r : Real ; { variabel av reell typ } i : Heltal ; { variabel av heltalstyp } c : Char ; { teckenvariabel } b : Boolean ; { boolean } s : Sträng ; { strängvariabel } t : Text ; { variabel för att deklarera en textfil } e : ( äpple , päron , banan , apelsin , citron ) ; { enum-type variabel }

I Pascal är bitvisa operationer tillåtna på heltalstyper (byte, shortint, word, heltal, longint och deras intervall). Logiska operationer på bitar:

På bitarna av två heltalsoperander kan du utföra de tidigare övervägda logiska operationerna: not, och, eller, xor. Skillnaden mellan bitvisa och logiska operationer är att bitvisa (bitvisa) operationer utförs på enskilda bitar av operanderna, och inte på deras värde i decimal (vanligtvis) representation.

Begreppet ordningsdatatyper (ordningsföljd) är särskiljande, de inkluderar heltalstyper (förtecknade och osignerade), logiska ( boolean), tecken ( char), uppräknade typer och intervalltyper.

Ordinaltyper specificeras av ett heltal (kod), som kan erhållas med hjälp av ord-funktionen. Alla operationer som utförs på ordinaltyper utförs på deras koder.

Områden innehåller en delmängd av värden av andra ordinaltyper:

var x : 1 .. 10 ; y : 'a' .. 'z' ; z : päron..orange ; _ _

För ordningstyper definieras operationer inc, dec, succ, pred, ord, jämförelseoperationer ( = > < => <= <>), de kan användas i operatorer case, for(som en loopräknare), som arraygränser, för att specificera element i uppsättningar och intervalltyper.

I Pascal, till skillnad från C-liknande språk, definieras inte heltalsaritmetiska operationer med booleantyper char.

Set

Till skillnad från många vanliga språk stöder Pascal en speciell datatyp :

var set1 : set om 1 .. 10 ; set2 : uppsättning av 'a' .. 'z' ; set3 : set av päron ..orange ; _

En uppsättning är ett grundläggande begrepp i modern matematik som kan användas i många algoritmer.

I Pascal kan en mängdtyp endast innehålla element av samma typ av ordningstyp. Den här funktionen används ofta och är vanligtvis snabbare än motsvarande konstruktion i ett språk som inte stöder uppsättningar. Till exempel, för de flesta Pascal-kompilatorer:

om i i [ 5 .. 10 ] så { kontrollerar om elementet tillhör mängden } ...

bearbetas snabbare än

om ( i >= 5 ) och ( i <= 10 ) då { booleskt test } ...

För att ställa in värdet på uppsättningen används en lista med uppsättningselement, separerade med kommatecken och omgivna av hakparenteser (som redan visas ovan):

var { variabeldeklarationsavsnitt } d : uppsättning char ; börja {start av block} d := [ 'a' , 'b' ] ; ...

I Jensen och Wirths Pascal representerades strängar som packade uppsättningar av karaktärer; därför hade de en fast längd och var vanligtvis vadderade till den längden med mellanrum.

Sammansatta typer

Nya typer kan definieras från befintliga:

typ { typdeklarationssektion } x = Heltal ; y = x ; ...

Dessutom kan komposittyper konstrueras från primitiva typer:

typ { typdeklarationssektion } a = Array [ 1 .. 10 ] av heltal ; { array definition } b = post { post definition } x : heltal ; y : Char ; slut ; c = Fil av a ; { fildefinition }

Filtyper i Pascal är indelade i maskinskriven, text och filer utan typer.

Som visas i exemplet ovan är maskinskrivna filer i Pascal sekvenser av element av samma typ. För varje fil finns en buffertpekarvariabel, betecknad med f^. Procedurer get(för att läsa) och put(för att skriva) flyttar pekaren till nästa element. Läsning implementeras på ett sådant sätt att read(f, x)det är detsamma som get(f); x:=f^. Följaktligen implementeras posten på ett sådant sätt att write(f, x)den är densamma som f^ := x; put(f). Textfiler textdefinieras som en typtillägg file of charoch tillåter, förutom standardoperationer på maskinskrivna filer (läsa, skriva ett tecken), teckeninmatning/utmatning till en fil med alla typer av data, liknande konsolinmatning/utmatning.

Filer utan typer deklareras som variabler av typen file. Med dem kan du utföra byte-för-byte otypade I/O-operationer för flera block av byte av en specificerad längd genom en buffert, för detta används speciella procedurer blockreadoch blockwrite(UCSD-förlängning).

Strängar

Modern Pascal [15] använder den inbyggda typen string, som stöder sammanlänkning ( +) och jämförelse ( > < = <> >= <=), för att arbeta med strängar. Strängarna jämförs i lexikografisk ordning . Till exempel anses strängar vara lika om de har samma längd och koderna för alla tecken med samma index matchar.

Typen string [n]eller helt enkelt stringi dialekterna för språket på 1970-1990-talet definierades som en array av tecken array [0..n] of char(n tog som standard värdet 80 i UCSD Pascal och 255 i Turbo / Borland Pascal), nollelementet i arrayen i denna representation tjänar till att ställa in längden på strängen, respektive, strängen kan ha en maximal storlek på 255 tecken. Som standard, i Delphi och FreePascal, används AnsiString-typen som en String, vars minne är dynamiskt allokerat och frigjort av kompilatorn, och den maximala strängstorleken i nuvarande implementeringar är 2 gigabyte. Dessutom, i Delphi och Free Pascal , kan UnicodeString-typen användas som en typ, där en 16-bitars representation av tecken i UCS-2-string kodning används , medan det inte finns några sätt att konvertera från enbytesträngar till multibytesträngar och tillbaka i FPC-standardbiblioteket, men är tillgängliga i Delphi.

Delphi 2009 och högre har en konstruktion för att deklarera en AnsiString med en specifik teckentabell:

typ CyrillicString = AnsiString ( 1251 ) ; CP866String = AnsiString ( 20866 ) ; Pekare

Pascal stöder användningen av pekare (skrivna ^типoch oskrivna pointer):

skriv a = ^ b ; b = post x : Heltal ; y : Char ; z : a ; slut ; var pointer_to_b : a ;

Här är variabeln pointer_to_b en pekare till datatypen b, som är en post. En maskinskriven pekare kan definieras ( lookahead ) före deklarationen av den typ som den refererar till. Detta är ett av undantagen från regeln , som säger att alla element (konstant, typ, variabel, procedur, funktion) måste deklareras innan de används . Införandet av detta undantag låter dig organisera återkommande definitioner av datastrukturer, inklusive såsom linjära listor , stackar , köer , träd, inklusive en pekare till en post i beskrivningen av denna post (se även: nollpekare - nil).

För en maskinskriven pekare definieras en dereferenceoperation (dess syntax är: указатель^).

För att skapa en ny post och tilldela ett värde 10och en symbol till Afälten xoch yi den, krävs följande uttalanden:

ny ( pekare_till_b ) ; { minnesallokering till pekare } pekare_till_b ^. x := 10 ; {avreferensera pekaren och komma åt postfältet } pointer_to_b ^. y := 'A' ; pekare_till_b ^. z : = noll ... dispose ( pekare_till_b ) ; { frigör minne från under pekaren }

Du kan också använda operatorn för att referera till fält i poster och objekt with, som visas i exemplet:

ny ( pekare_till_b ) ; med pointer_to_b ^ börjar x : = 10 ; y := 'A' ; z := noll ände ; ... dispose ( pekare_till_b ) ; Procedurtyp

På originalspråket av Pascal Jensen och Wirth användes den procedurformella typen endast när man beskrev en formell parameter. Det fanns redan en fullständig procedurtyp i TP . Typdeklarationen innehåller rubriken för en procedur eller funktion (utan namn), som generellt beskriver subrutinens gränssnitt. Ett värde av denna typ innehåller en pekare till en subrutin med en titel som motsvarar den som deklareras i typdeklarationen. En variabelidentifierare kan användas för att anropa motsvarande procedur eller funktion.

Subrutinexempel för Pascal typ myfunc = funktion : sträng ; func1 : sträng ; _ start func1 := 'func #1' end ; func2 : sträng _ _ begin func2 := 'func #2' end ; var fun : min funk ; börja kul :=@ func1 ; writeln ( kul ) {func1-funktionen kallas} slut .

Kontrollsatser

Pascal är ett strukturerat programmeringsspråk , vilket innebär att ett program består av separata standardsatser som exekveras sekventiellt, helst utan att använda ett kommando GOTO.

Exempel för Pascal medan a <> b gör { loop med förutsättning } writeln ( 'Väntar' ) ; om a > b then { conditional statement } writeln ( 'Villkor uppfyllt' ) else { else-section - may utelates} writeln ( 'Villkor misslyckades' ) ; för i := 1 till 10 gör { iterationsslinga } writeln ( ' Iteration # ' , i : 1 ) ; för i i [ 1 .. 10 ] gör { iterera genom uppsättningen } writeln ( ' Iteration # ' , i : 1 ) ; { dök upp i version 2.4.0 } med ett gör {Operator With - a method to speed up access to record fields} begin l := 1 ; k := 2 ; p :=- 3 ; slut ; upprepa { postcondition loop } a := a + 1 tills a = 10 ; fall i av {villkorlig flervalsoperator } 0 : skriv ( 'noll' ) ; 1 : skriv ( 'en' ) ; 2 : skriv ( 'två' ) else skriv ( 'okänt nummer' ) { else-sektion - kan utelämnas} slut ;

I satser while, for, ifkan ett blockcase användas som en körbar sats . En sådan konstruktion, som är en vanlig sats eller block, kallas en komplex sats .

I Turbo Pascal, för att kontrollera kompileringsprocessen, finns det direktiv som läggs i kommentarer och låter dig byta kompilatorns driftlägen - till exempel aktivera och inaktivera kontroller för I/O-operationer, spill:

Exempel för Pascal tilldela ( inp , 'text.txt' ) ; {$I-} { inaktivera IO-kontrollläge - generering av programutgångskod vid I/O-fel } { (för fallet om filen inte hittas)} återställ ( inp ) ; {$I+} { aktivera IO-kontrollläge } om IOresult = 0 , börja då { kontrollera värdet på variabeln ioresult(<>0 vid ett I/O-fel) } ... close ( inp ) ; end else writeln ( 'filen hittades inte' )

Det finns direktiv som liknar C/C++-förprocessordirektiven ( $ifdef, $define, $include), de bearbetas av kompilatorn under kompileringen.

Procedurer och funktioner

I Pascal är subrutiner indelade i procedurer och funktioner. Samtidigt returnerar funktioner explicit ett värde (resultat) av en viss typ, och procedurer returnerar uttryckligen ingenting.

Syntaktiskt sett består beskrivningen av en procedur eller funktion av en rubrik som innehåller nyckelordet procedureeller functionnamnet, som kan följas av en beskrivning av de godkända (formella) parametrarna inom parentes. :För en funktion indikeras typen av returvärde genom kolonsymbolen . Titeln avslutas med semikolon ;. Rubriken följs av brödtexten , som (eventuellt) innehåller beskrivningssektioner av lokala konstanter, typer, variabler, procedurer, funktioner och (obligatoriskt) som innehåller ett block med satser, följt av ett semikolontecken ;.

Exempelprogram för Pascal programmera ( utgång ) ; _ var i : heltal ; procedure print ( var j : heltal ) ; funktion nästa ( k : heltal ) : heltal ; börja nästa := k + 1 slut ; börja skrivaln ( 'Totalt:' , j ) ; j := nästa ( j ) slut ; börja i := 1 ; medan i <= 10 skriver ut ( i ) slut .

En procedurs kropp kan, liksom ett program, i sin tur innehålla beskrivningar av procedurer och funktioner. Således kan procedurer och funktioner kapslas in i varandra så djupt som önskas, medan programmets kropp är den översta i kedjan.

Dessutom är innehållet i avsnitten av beskrivningen av variabler, typer, konstanter, extern kropp (procedurer, funktioner, program) som finns före beskrivningen av proceduren/funktionen tillgängligt i den. I de flesta dialekter kan du också komma åt parametrarna för en extern procedur från en procedur.

Efter rubriken av procedurer/funktioner, istället för body, kan nyckelordet placeras forward, detta görs om beskrivningen av proceduren/funktionen finns i programmet efter dess anrop, och är förknippad med möjligheten att sammanställa programmet i ett pass stöds i Pascal.

Pascals matematiska standardfunktioner och procedurer Matematiska funktioner
Funktionsnamn Typ av argument Värde typ Beräkningsresultat
Abs(x) hela verkliga hela verkliga Det absoluta värdet av "x"
sin(x) verklig verklig sinus "x" rad.
Cos(x) verklig verklig cosinus "x" rad.
Arctan(x) verklig verklig bågtans för "x" ( -Pi/2 <y< Pi/2 )
Sqrt(x) verklig verklig kvadratroten av "x"
Sqr(x) hela verkliga hela verkliga värdet på "x" i kvadrat ( x 2 )
effekt(a, x) verklig verklig värdet av "a" i potensen av "x" ( a x )
exp(x) verklig verklig värdet av "e" i potensen av "x" ( e x , där e= 2,718282... )
Ln(x) verklig verklig naturlig logaritm av "x" ( x > 0 )
frac(x) verklig verklig bråkdel "x"
Int(x) verklig verklig heltalsdel "x"
Slumpmässig - verklig slumptal ( 0 <=y< 1 )
Slumpmässig(x) Ord Ord slumptal ( 0 <=y< x )
Succ(c) ordinarie ordinarie tecken efter "s"
pred(c) ordinarie ordinarie föregående "med" tecken
Matematiska procedurer
Funktionsnamn Typ av argument Värde typ Beräkningsresultat
Inc(x) hela hela Ökar "x" med 1 ( x:=x+1; )
dec(x) hela hela Minskar "x" med 1 ( x:=x-1; )
Inc(x, n) hela hela "x" av n ( x:=x+n; )
Dec(x, n) hela hela "x" av n ( x:=xn; )
Procedurer för konvertering av variabeltyp
Funktionsnamn Typ av argument Värde typ Beräkningsresultat
Str(x, s) x-heltal eller verkligt s-sträng Sekvensen av tecken "s" från siffrorna i numret "x"
Val(s, v, cod) s-sträng v-heltal eller verkligt kod-heltal Binär form av sekvensnummer "s" cod=0 (felkod)
Funktioner för konvertering av variabeltyp
Funktionsnamn Typ av argument Värde typ Beräkningsresultat
Trunc(x) verklig LongInt heltalsdel "x"
Rund (x) verklig LongInt avrunda "x" till ett heltal
Udda(x) hela logisk returnerar True om "x" är ett udda tal
Chr(x) bytes Röding ASCII-kodtecken "x"
Ord(x) Röding bytes ASCII teckenkod "x"

Moduler

Före tillkomsten av anslutna moduler i sin moderna form, stödde vissa implementeringar av Pascal modularitet på grund av mekanismen för att inkludera rubrikfiler, liknande mekanismen #includei C-språket: med hjälp av ett speciellt direktiv formaterat som en pseudokommentar, till exempel, {$INCLUDE "файл"}, innehållet i den angivna filen inkluderades direkt i programmets källkod. , i textform. Således var det möjligt att dela upp programkoden i många fragment, för att underlätta redigeringen, men innan kompileringen kombinerades de automatiskt till en programfil, som så småningom bearbetades av kompilatorn. Denna implementering av modularitet är primitiv och har många uppenbara brister, så den byttes snabbt ut.

Moderna Pascal-implementationer (som börjar med UCSD Pascal) stödmoduler. Programmoduler kan vara av två typer: huvudprogrammodulen, som som vanligt börjar med nyckelordet program och vars kropp innehåller kod som körs efter att programmet har laddats in i minnet, och hjälpmoduler som innehåller typer, konstanter, variabler, procedurer och funktioner avsedda att användas i andra moduler, inklusive huvudmodulen.

Struktur

Den allmänna strukturen för ett plugin-program i Pascal är följande:

enhet Enhetsnamn1 ; gränssnitt ... implementering ... begin {kan utelämnas - används om initialiseringssatser behöver placeras} ... slut .

Ett annat alternativ är också möjligt:

enhet Enhetsnamn2 ; gränssnitt ... implementering ... initiering ... avslutning .... slut .

Till skillnad från huvudprogrammet börjar en modulfil med nyckelordet UNITföljt av modulnamnet och ett semikolon. Moderna implementeringar kräver vanligtvis att namnet på en modul är detsamma som namnet på källkodsfilen som innehåller modulen. En modul innehåller tre sektioner: en gränssnittssektion, en implementeringssektion och en modulkropp.

Gränssnittssektionen kommer först, börjar med ett nyckelord INTERFACEoch slutar vid den punkt i modulen där implementeringssektionen eller kroppen börjar. Gränssnittssektionen deklarerar de objekt (typer, konstanter, variabler, procedurer och funktioner - rubriker placeras för dem) som måste vara tillgängliga utanför modulen. I det här fallet är en partiell deklaration av typer tillåten: de kan deklareras utan att specificera en struktur, med endast ett namn. När du använder denna typ i ett externt program är det tillåtet att deklarera variabler och parametrar av denna typ, tilldela värden, men det är omöjligt att komma åt detaljerna om dess implementering. Procedurer och funktioner i gränssnittssektionen deklareras som forwards - rubriker med parametrar, men utan kropp. Sammansättningen av modulens gränssnittssektion är sådan att det räcker för att generera kod som använder denna modul. Variabler som deklareras i gränssnittssektionen är globala, det vill säga de finns i en enda instans och är tillgängliga i alla delar av programmet som använder denna modul.

Implementeringsavsnittet följer gränssnittsavsnittet och börjar med nyckelordet IMPLEMENTATION. Den innehåller beskrivningar av procedurer och funktioner som deklareras i gränssnittssektionen, samt beskrivningar av typer, konstanter, variabler, procedurer och funktioner som är nödvändiga för att implementera gränssnittsprocedurer och funktioner. Beskrivningen av en procedur eller funktion som deklareras i en gränssnittsdel måste ha exakt samma rubrik som i deklarationen. Organet kan använda andra procedurer och funktioner i denna modul, deklarerade både i gränssnittsdelen och i implementeringssektionen. Variabler som deklareras i implementeringssektionen är i själva verket globala (det vill säga det finns bara en instans av varje sådan variabel i hela programmet), men de är endast tillgängliga från procedurerna och funktionerna som beskrivs i implementeringssektionen av denna modul, såväl som från dess kropp. Om det finns förkortade typdeklarationer i gränssnittssektionen, måste dessa typer deklareras fullständigt i implementeringssektionen.

Brödtexten i en modul börjar med nyckelordet på den översta nivån av kapsling BEGIN. Brödtexten innehåller programkod som exekveras en gång när modulen laddas. Kroppen kan användas för initiering, tilldela initiala värden till modulvariabler, allokera resurser för dess drift och så vidare. Modulkroppen kan saknas. I ett antal Pascal-implementeringar, till exempel i Delphi, kan två sektioner (också valfria) användas istället för modulens body - INITIALIZATIONoch FINALIZATION. De placeras i slutet av modulen, efter motsvarande nyckelord. Den första, initialiseringssektionen, innehåller koden som måste exekveras när modulen laddas, den andra, finaliseringssektionen, innehåller koden som kommer att exekveras när modulen laddas ur. Avslutningssektionen kan utföra åtgärder, vända initialiseringar - ta bort objekt från minnet, stänga filer, släppa tilldelade resurser.

ENDModulen avslutas med ett punkt nyckelord .

Användning

För att använda en modul måste huvudprogrammet eller en annan modul importera modulen, det vill säga innehålla en deklaration om dess användning. Denna deklaration görs med en module include statement, vilket är nyckelordet USESföljt av ett kommaseparerat namn på modulerna som ska inkluderas. Anslutningsinstruktionen måste omedelbart följa programhuvudet, eller efter nyckelordet INTERFACEom anslutningen görs i en modul.

Moduler anslutna i gränssnittsdelen kan användas i hela modulen - både i implementeringsdelen och i kroppen. Men implementeringssektionen kan ha sin egen inkluderingsinstruktion (den följer nyckelordet IMPLEMENTATION) som innehåller namnen på plugin-program som inte finns i gränssnittssektionen men som behövs av implementeringssektionen. En anledning till att använda en separat anslutningslista för implementeringssektionen är när två eller flera moduler använder varandra. För att undvika cirkulärhänvisningar i deklarationerna om användningen av sådana moduler måste minst en av dem inkludera den andra i implementeringsavsnittet.

Alla objekt som deklareras i modulernas gränssnittssektioner kan användas i programmet där dessa moduler är anslutna. Namnen på objekt som importeras från plugin-program förblir desamma och kan användas direkt. Om två eller flera anslutna moduler har objekt som har samma namn, och kompilatorn inte kan skilja mellan dem, kommer ett kompileringsfel att genereras när man försöker använda ett sådant objekt - tvetydig namnspecifikation. I detta fall måste programmeraren tillämpa namnkvalificering - ange namnet i formatet "<modulnamn>.<objektnamn>".

Problem kan uppstå om det finns behov av att använda två olika moduler med samma namn i programmet. Om moduler endast är tillgängliga i kompilerad form (det vill säga det är omöjligt att ändra deras namn), är det omöjligt att importera dem samtidigt. Det finns ingen standardlösning för en sådan kollision på språknivå, men specifika kompilatorer kan erbjuda ett eller annat sätt att kringgå det, i synnerhet sättet att tilldela alias till importerade moduler och direkt specificera vilken modul som ska hämtas från vilken fil.

Kompilera och länka

Moduler är designade för att kompileras separat - kompilatorn behöver inte kompilera importerade moduler för att kompilera modulen som använder dem. Men för att kompilera en modul korrekt måste kompilatorn ha tillgång till gränssnittssektionen för alla moduler den använder. Det finns två olika, ibland kombinerade, sätt att organisera sådan åtkomst.

  • Moduler kompileras till binära filer av ett speciellt format (varje kompilator har sitt eget), som lagrar detaljerad information om objekten som deklareras i gränssnittssektionen, och kan även innehålla objektspråket som skapades under modulkompileringen, men den använder endast gränssnittssektionen av modulen. Om en biblioteksmodul tillhandahålls i en kompilerad form (utan fullständiga källtexter), så finns det tillsammans med den binära filen en trunkerad fil med modulens källkod, som endast innehåller gränssnittssektionen. Detta räcker för att kompilatorn ska kunna bearbeta anrop från de använda modulerna korrekt, och vid kompileringsstadiet inkluderar länkaren helt enkelt den binära filen i programmet.
Laddar och lossar moduler

För normal drift av modulen kan det vara nödvändigt att utföra några åtgärder innan du använder den: initiera variabler, öppna nödvändiga filer, allokera minne eller andra resurser. Allt detta kan göras i modulens kropp, eller i initialiseringssektionen. Det omvända till initiering görs i finaliseringssektionen.

Ordningen för initiering och slutförande av moduler bestäms indirekt av deklarationsordningen i användningssektionen, men för statiskt kompilerade program (där modulen antingen kompileras till en körbar fil med huvudprogrammet eller finns i ett separat dynamiskt bibliotek, men laddas vid det initiala laddningsstadiet), garanterar kompilatorn alltid att initiering kommer att göras före första användningen av modulen. Slutbehandling görs när programmet avslutas, efter att huvudmodulen avslutats, så att moduler som används slutförs senare än de som använder dem.

I fallet med dynamisk laddning av moduler som styrs av programmeraren själv, exekveras initialiserare vid laddning, det vill säga i det ögonblick då modulladdningskommandot returnerade kontrollen, har dess initialiserare redan exekveras. Finalizern exekveras efter urladdning, vanligtvis när modulens urladdningskommando exekveras. Om detta kommando inte anropas slutförs dynamiskt laddade moduler på samma sätt som alla andra moduler - när programmet avslutas.

Objektorienterad programmering

Objekt Pascal har förmågan att utveckla program med hjälp av det objektorienterade programmeringsparadigmet . Klasser definieras med en objectliknande typ record, som förutom datafält kan innehålla procedur- och metodrubriker . Namnen på de beskrivna metoderna följer klassnamnet separerade med en punkt.

Konstruktören och destruktorn anges som vanliga procedurer, men istället för en identifierareangesprocedurenyckelorden. Följaktligen, till skillnad från C++- liknande språk, har de ett namn som skiljer sig från klassnamnet, det kan finnas flera destruktörer och de kan ha parametrar (i praktiken används den här funktionen sällan, vanligtvis har en klass en enda förstöraresom åsidosätter den virtuella förstörare av föräldraklassen). constructordestructorDestroy

Enkelt arv, klasspolymorfism , virtuell metodmekanism (ord virtualefter klassmetodhuvud) stöds. Det finns också dynamiska metoder (i TP beskrivs de genom att lägga till ett heltal efter ordet virtualoch används främst för meddelandebehandling; i Delphi och FreePascal används ordet för dessa ändamål message, och ordet används för att skapa vanliga dynamiska metoder dynamic) , som kännetecknas av mindre minnesanvändning och en lägre anropshastighet för på grund av bristen på duplicering av dynamiska metoder för förfäder i barnets VMT (dock, FreePascal skiljer inte mellan virtuella och dynamiska metoder).

I Delphi implementerade FPC operatörsöverbelastning , abstrakta metoder, direktiv private, protected, public, published(klassmedlemmar är som standard public:

Exempelprogram för Pascal typ TbasicO = objektprocedur writeByte ( b : byte ) ; _ virtuell ; abstrakt ; slut ; TtextO = objekt ( TbasicO ) {ärver TbasicO, implementerar andra utdataoperationer baserade på writeByte} -proceduren writeS ( s : string ) ; {..} slut ; TfileO = objekt ( TbasicO ) {filutdataklass - implementerar utdataoperationen som att mata ut en byte till en fil} konstruktor init ( n : sträng ) ; procedure writeByte ( b : byte ) ; virtuell ; destructor closefile ; privat f : fil med byte ; slut ; basicO = ^ TbasicO ; textO = ^ TtextO ; fileO = ^ TfileO ; konstruktör TfileO . init ( n : sträng ) ; börja tilldela ( f , n ) ; skriva om ( f ) slut ; destructor TfileO . stäng fil ; börja nära ( f ) sluta ; procedur TfileO . writeByte ( b : byte ) ; börja skriva ( f , b ) sluta ; procedur TtextO . writeS ( s : sträng ) ; var i : heltal ; börja för i := 1 till längd ( s ) do writeByte ( ord ( s [ i ])) slut ; {..} var f : fileO ; börja ny ( f , init ( 'tstobj.txt' )) ; {allokerar minne för objektet och anropar konstruktorn} textO ( f ) ^. writeS ( 'textsträng' ) ; dispose ( f , closefile ) {anropar förstöraren och frigör objektets minne} end .

I Delphi-dialekten kan klasser också konstrueras med hjälp av ett ord class(detta är ömsesidigt arv med object-klasser inte tillåtet) och gränssnitt ( interface) introduceras - alla metoder är abstrakta och kan inte innehålla datafält.

Alla klasser (skapade med class) ärver TObjectfrån , alla gränssnitt härrör från IUnknown. Klasser skapade med classkan implementera flera gränssnitt.

Gränssnitt introducerades i Delphi för att stödja Microsofts COM -teknik.

Klasser ( Class) till skillnad från vanliga klasser ( Object) behöver inte explicit allokering/avallokering av minne, minne för dem allokeras dynamiskt av en konstruktor med namnet Create, anropad med klassnamnet, och släpps när destruktorn med namnet anropas Destroy(de kan ha andra namn). En variabel i en sådan klass, till skillnad från en klass, objectlagrar adressen till en instans av klassen i minnet, värdet nilanvänds för att indikera en tom referens, därför, för att släppa ett objekt, definieras TObjecten speciell metod freesom kontrollerar referensen till niloch anropar den virtuella förstöraren Destroy. Kod som använder sådana klasser skulle se ut så här:

Exempel för Pascal q1 := t1 . skapa ( 9 ) ; { construct object(t1 - class name) } writeln ( q1 . InstanceSize ) ; { visar storleken på en klassinstans } q1 . Gratis ; { objektförstöring } q1 := noll ; { så att förstöraren inte anropas igen när gratis anropas }

I modifieringen av ObjectPascal/Delphi/FreePascal visas egenskaper (egenskap) i beskrivningen av klasser, som kombinerar bekvämligheten med att arbeta med variabler (vars roll i OOP spelas av fält) och metodanrop som alltid meddelar objektet om en förändring i dess tillstånd:

Exempelprogram för Pascal typ TMyObj = klass ( TObject ) FProp : heltal ; procedur SetProp ( AValue : heltal ) ; egenskap MyProp : heltal läs FProp skriv SetProp ; slut ; procedur TMyObj . SetProp ( AValue : heltal ) ; börja FProp := AValue ; Writeln ( 'Någon har ändrat MyProp!' ) ; slut ; var MyObj : TMyObj ; börja MyObj := TMyObj . skapa ; MyObj . FProp := 5 ; MyObj . MyProp := MyObj . MyProp + 6 ; slut .

I det första fallet (med MyObj.FProp) har objektets fält ändrats direkt, som ett resultat kommer inte objektets metoder att misstänka att detta fält har ändrats tidigare; i ett mer komplext fall kan de förlita sig på att fältet är oförändrat, eller så kan fältet tilldelas ett värde som är ogiltigt för det givna objektet. I det andra fallet tilldelas värdet direkt till objektets egenskap, vilket hänvisar till ett metodanrop som korrekt hanterar ändring av det givna fältet.

Detta tillvägagångssätt är praktiskt om objektet är associerat med ett visuellt element: att direkt ändra fältet som är ansvarigt, till exempel för elementets bredd, kommer inte att påverka själva det visuella elementet, och objektet kommer att "felinformeras" om den faktiska storleken av elementet. Det korrekta tillvägagångssättet utan att använda egenskaper är att utveckla metoder för att få och ställa in valfritt fältvärde, men att arbeta med sådana metoder blir mindre bekvämt, till exempel, istället för den sista raden, skulle man behöva skriva

MyObj . SetProp ( MyObj . GetProp + 6 ) ;

Dessutom borde MyObj.GetProp-metoden ha skrivits för att förena åtkomst.

Av stort intresse är indexegenskaper, som beter sig på ungefär samma sätt som arrayer, och ersätter åtkomst till ett arrayelement med ett anrop till motsvarande metod.

Egenskaper är dock inte ett "universalmedel": när de kompileras översätts egenskapsanrop direkt till metodanrop eller direktarbete med fält, så egenskaper är inte verkliga variabler, i synnerhet kan de inte skickas som var-parametrar.

Anteckningar

  1. ↑ Kim B. Bruce. Grunderna för objektorienterade språk: typer och semantik . — MIT Press, 2002-01-01. - S. 9. - 416 sid. — ISBN 9780262025232 . Arkiverad 18 juni 2016 på Wayback Machine
  2. ↑ Vitbok. Om Microsofts "Delegater" Arkiverad 27 juni 2012 på Wayback Machine , java.sun.com
  3. ↑ History of Java, Java Application Servers Report Arkiverad 29 december 2010. TechMetrix Research, 1999
  4. ↑ En konversation med James Gosling . Hämtad 16 oktober 2009. Arkiverad från originalet 16 juli 2015.
  5. ↑ TIOBE Programming Language Popularity Index Arkiverad 25 december 2018 på Wayback Machine 
  6. ↑ 1 2 Wirth, N. Modula-2 och Oberon // HOPL III  : Proceedings of the third ACM SIGPLAN conference on History of programming languages: [ eng. ]  : [ arch. 22 december 2012 ]. - ACM, 2007. - Juni. — S. 3-1–3-10. - doi : 10.1145/1238844.1238847 .
  7. ↑ Borodich, Yu. S. Förord ​​// Pascal för persondatorer: Ref. ersättning / Yu. S. Borodich, A. N. Valvachev, A. I. Kuzmich. - Mn.  : Högre skola, 1991. - S. 3. - 365 sid. : sjuk. - BBK  32.973-01ya2 . - UDC  681.3.06 (035.5) . — ISBN 5-339-00662-X .
  8. ↑ Lista kompilator Pascal-Pascal kompilator lista . Hämtad 19 januari 2021. Arkiverad från originalet 11 april 2021.
  9. ↑ Wirth N. Minnen om utvecklingen av Pascal (HOPL II), 3.3 . Hämtad 16 april 2011. Arkiverad från originalet 22 december 2012.
  10. ↑ Jon Udell, Crash of the Object-Oriented Pascals, BYTE, juli 1989.
  11. ↑ MI Trofimov, The End of Pascal?, BYTE, mars 1990, sid. 36.
  12. ↑ Varför Pascal inte är mitt favoritprogrammeringsspråk . Tillträdesdatum: 27 augusti 2004. Arkiverad från originalet 28 april 2009.
  13. ↑ PASCAL: Användarmanual och rapport ISO Pascal Standard Kathleen Jensen och Niklaus Wirth, 4:e upplagan, Springer Verlag New York, Inc. 1974, 1985, 1991
  14. ↑ Objektorienterade tillägg till Pascal Arkiverade 5 juni 2021 på Wayback Machine , tekniska kommittén X3J9, programmeringsspråk Pascal
  15. ↑ ISO 7185 Pascal . Hämtad 12 april 2009. Arkiverad från originalet 25 november 2006.

Litteratur

  • Wirth N. Algoritmer + datastrukturer = program. — M .: Mir , 1985. — 406 sid.
  • Wirth N., Jensen C. Pascal. Användarmanual och språkbeskrivning. — M .: Finans och statistik , 1982. — 151 sid.
  • Grogono P. Programmering i Pascal. — M .: Mir , 1982. — 384 sid.
  • Kultin NB Delphi 6. Programmering i Object Pascal. - St Petersburg. : BHV-Petersburg , 2001. - 528 sid. — ISBN 5-94157-112-7 .
  • Morgun A. N. Programmering i Pascal. Grunderna för bearbetning av datastrukturer. - M . : Dialektik , 2005. - 576 sid. — ISBN 5-8459-0935-X .
  • Perminov O. N. Programmeringsspråk Pascal: A Handbook. - M .: Radio och kommunikation , 1989. - 128 sid. — ISBN 5-256-00311-9 .
  • Rubenking NJ Turbo Pascal för Windows: i 2 volymer. Per. från engelska. — M .: Mir, 1993.
  • Programmeringsspråk Ada, C, Pascal = Jämföra och bedöma programmeringsspråk Ada, C och Pascal / A. Feuer, N. Jehani. - M . : Radio och kommunikation, 1989. - 368 sid. — 50 000 exemplar.  — ISBN 5-256-00309-7 .
Standarder

Länkar

  Gå till Wikidata-objektet  Ordböcker och uppslagsverk
I bibliografiska kataloger
 Pascal
Dialekter
Kompilatorer
Kommersiell
Fri
Utan stöd
ID
Personer
 Programmeringsspråk