`` `
2. Syntaxanalys (parsing):
* Syfte: Kontroller om tokens sekvens överensstämmer med de grammatiska reglerna (syntaxen) för programmeringsspråket.
* Åtgärder:
* Använder tokens för att bygga ett abstrakt syntaxträd (AST). AST representerar programmets hierarkiska struktur, som visar hur tokens är relaterade.
* Identifierar syntaxfel (t.ex. saknade semikoloner, felaktiga parenteser).
* Utgång: Ett abstrakt syntaxträd (AST).
Exempel (fortsätter uppifrån):
Parseren skulle bygga ett AST som representerar uttalandet `int x =10 + y;` AST skulle visa att `x` förklaras som ett heltal och initialiseras med resultatet av uttrycket` 10 + y '.
3. Semantisk analys:
* Syfte: Kontrollerar koden (semantik) och säkerställer att programmet är logiskt konsekvent.
* Åtgärder:
* Typkontroll:Verifierar att operationer utförs på kompatibla datatyper (t.ex. att lägga till ett heltal till en sträng skulle vara ett fel).
* Räckningsupplösning:Bestämmer betydelsen av identifierare baserat på deras sammanhang (t.ex. vilken variabel "X" hänvisas till).
* Feldetektering:Identifierar semantiska fel (t.ex. med hjälp av en odeklarerad variabel och kallar en funktion med fel antal argument).
* Symboltabellhantering:Symboltabellen lagrar information om identifierare (variabler, funktioner etc.) som används i programmet.
* Utgång: En kommenterad AST (AST med ytterligare semantisk information) och symboltabellen.
4. Mellankodgenerering:
* Syfte: Översätter den kommenterade AST till en mellanliggande representation (IR).
* Åtgärder:
* IR är en maskinoberoende representation av programmet, utformat för att enkelt optimeras och översättas till målkod. Vanliga IR:er inkluderar kod för tre-adresser och stackmaskin.
* Förenklar koden och gör det enklare att utföra optimeringar.
* Utgång: Mellankod (IR).
Exempel (enkel kod med tre adresser):
Uttrycket `10 + y` kan översättas till:
`` `
t1 =10 + y // t1 är en tillfällig variabel
x =T1
`` `
5. Kodoptimering:
* Syfte: Förbättrar effektiviteten i mellankoden.
* Åtgärder:
* Olika optimeringstekniker tillämpas för att minska kodstorlek, exekveringstid eller båda.
* Vanliga optimeringar inkluderar:
* Konstant vikning (utvärdering av konstant uttryck vid sammanställningstid).
* Eliminering av död kod (ta bort kod som aldrig körs).
* Loop rullning (expanderande slingor för att minska omkostnaden).
* Gemensamt eliminering av subuttryck (undvika redundanta beräkningar).
* Utgång: Optimerad mellankod.
6. Kodgenerering:
* Syfte: Översätter den optimerade mellanliggande koden till målmaskyden (eller monteringsspråk).
* Åtgärder:
* Väljer lämpliga maskininstruktioner för varje IR -uttalande.
* Tilldelar register för att lagra variabler och mellanvärden.
* Hanterar minnesallokering.
* Utgång: Maskinkod eller monteringsspråk.
7. Montering (valfritt):
* Om kodgeneratorn matar ut monteringsspråket används ett monterande program för att konvertera monteringskoden till maskinkod.
8. Länkning (valfritt):
* Kombinerar flera objektfiler (sammanställd kod från olika källfiler) och bibliotek till en enda körbar fil.
* Löser externa referenser (referenser till funktioner eller variabler definierade i andra filer).
Exempel Sammanfattning:
Låt oss säga att du har ett enkelt C ++ -program:
`` `C ++
int main () {
int a =5;
int b =10;
int sum =a + b;
return 0;
}
`` `
Kompilatorn skulle gå igenom följande (förenklade) process:
1. lexikal analys: Identifierar tokens som `int`,` main`, `=`, `5`,`+`, etc.
2. Syntaxanalys: Skapar en AST som representerar strukturen i koden (t.ex. "huvud" -funktion innehåller deklarationer och en tilläggsoperation).
3. Semantisk analys: Kontroller om variabler deklareras före användning, att `+` är giltig för heltal etc.
4. Mellankodgenerering: Skapar en mellanliggande representation, kanske något som:
`` `
a =5
b =10
summa =a + b
return 0
`` `
5. Kodoptimering: Kan utföra mindre optimeringar (inte mycket optimering möjlig i detta triviala fall).
6. Kodgenerering: Översätter IR till maskinkodinstruktioner som är specifika för målprocessorn (t.ex. x86 monteringsinstruktioner).
Nyckelfördelar med sammanställning:
* hastighet: Sammanställd kod körs i allmänhet snabbare än tolkad kod eftersom översättningen görs endast en gång, under sammanställning, snarare än varje gång programmet körs.
* feldetektering: Kompilatorer kan upptäcka många fel under sammanställningen, innan programmet någonsin körs, vilket hjälper till att förbättra kodens tillförlitlighet.
* Säkerhet: Genom att upptäcka fel vid sammanställningstid kan kompilatorer hjälpa till att förhindra vissa säkerhetssårbarheter.
Nyckel nackdelar med sammanställning:
* Plattformberoende: Kompilerad kod är ofta plattformsspecifik, vilket innebär att den bara kan köras på operativsystemet och processorarkitekturen för vilken den sammanställdes för.
* kompileringstid: Kompilationsprocessen kan ta en betydande tid, särskilt för stora program.
* felsökningskomplexitet: Felsökning av sammanställd kod kan ibland vara mer utmanande än felsökningstolkad kod eftersom du arbetar med maskinkod snarare än den ursprungliga källkoden.
Sammanfattningsvis är kompilatorn en avgörande del av mjukvaruutvecklingen, ansvarig för att omvandla kod på hög nivå till en form som en dator kan utföra. Den utför flera komplexa steg för att analysera, optimera och generera maskinkod, vilket i slutändan gör det möjligt för oss att köra programmen vi skriver.
