Teil 3: Lexik, Funktionen, Makefiles Gliederung

Transkript

1 Teil 3: Lexik, Funktionen, Makefiles Gliederung Lexik Zinsberechnung Eigene Funktionen Makefiles

2 Lexik 2

3 Bearbeitungsschritte des Compilers 1. Lexikalische Analyse 2. Syntaxanalyse 3. Semantische Analyse 4. Optimierungen 5. Codeerzeugung 3

4 1. Lexikalische Analyse Scanner Symbolentschlüsselung gültige Zeichen und Wörter der Sprache Lexikalische Einheiten: 1. Namen (Bezeichner) 2. reservierte Wörter 3. Literale Konstanten 4. Operatoren 5. Satzzeichen sind CASE sensitive Trenner: Leerzeichen, Zeilenumbruch 4

5 2. Syntaxanalyse Parser: Überführung der Symbolfolge in einen Ableitungsbaum korrekter Aufbau von Sätzen der Sprache Grammatik zulässige Folgen von Symbolen (Wörtern) Syntaxdiagramme (grafischen Darstellung kontextfreier Grammatiken) Knoten (Ellipse für Terminale, Rechtecke für Nichtterminale) Kanten (Pfeile, Eingangskante, Ausgangskante) Interpretation: Durchläuft man ein Syntaxdiagramm von der Eingangs- zur Ausgangskante entlang den Pfeilen, dann ist die Folge der Knoteninhalte, die dabei durchlaufen werden, aus dem Syntaxdiagramm ableitbar. 5

6 Syntax von Bezeichnern Variablen, Funktionen, Strukturen, Marken, Makros, Aufzählungskonstanten, Relevanz: mind. 31 Zeichen für interne (mind. 6 Zeichen für externe) Ein Name (identifier) besteht aus einer Zeichenfolge aus Buchstaben (nondigit) und Ziffern (digit), die mit einem Buchstaben beginnt. In C zählt auch der Unterstrich _ zu den Buchstaben. 6

7 Beispiele für Bezeichner Zulässig oder nicht? summe x_quadrat 1x x-quadrat ärger tmap Konventionen bzw. "Styleguides" alle Bezeichner klein laufvariable Symbolische Konstanten GROSS #define PI Ungarische Notation snachname dflaechequadrat 8

8 3. Semantische Analyse Bedeutung von Sätzen der Sprache Zwischencode Namen, Gültigkeitsbereiche Prüfung der Typverträglichkeiten (z.b. bei Addition zweier Werte unterschiedlicher Datentypen) 4. Optimierungen Speicherverbrauch und Rechenzeit Beispiele: nicht erreichbarer Code, wiederholtes Vorkommen des gleichen Ausdrucks 5. Codeerzeugung Synthese Umwandlung in Objektcode / Maschinensprache des Zielrechners Cross-Compiler 9

9 Zeichenvorrat in C Buchstaben A-Z, a-z, Unterstrich _ Ziffern 0-9 Leerzeichen Steuerzeichen (Zeilenende-Zeichen, Seitenvorschub, Tabulator) Semikolon zum Abschluss einer Anweisung ; Punkt. Sonderzeichen ( ) [ ] < > + - */ % ^~ & =!?, : Sonderzeichen für Strings ' " geschweifte Klammern (Block, Initialisierungslisten) Backslash für Ersatzdarstellung \ Nummernzeichen für Präprozessor # 10

10 Reservierte Wörter auto break case char const continue default do double else enum extern float for goto if int long register return short signed sizeof static struct switch typedef union unsigned void volatile while Literale Konstanten 3.1 Ganzzahlige Konstanten Gleitpunktkonstanten Zeichenkonstanten 'a' oder "abc 123" 3.4 Aufzählungskonstanten vgl. symbolische Konstanten: #define PI

11 Ganzzahlige Konstanten ganzzahlige Konstanten wie 123 haben den Typ int implizit: L L 123u 123UL X1234 0x0FFE 12

12 Fließkommakonstanten Fließkommakonstanten werden standardmäßig als double gespeichert vor dem E bzw. e: Mantisse dahinter: Exponent (Basis 10) e L 2.45E2F 1324.E F 13

13 Zeichenkonstanten Zeichenkonstanten werden als char gespeichert, z.b.: 'A', '1', '\n', '\x0d', '\015 Escape-Sequenzen 14

14 Zeichenkonstanten String-Konstanten (Zeichenketten) werden als char - Array gespeichert "Ich bin eine Zeichenkette" printf ("\ndiese Zeile ist soooooooooooooooooooooooo\ ooooooooooo lang!"); printf ("\ndiese Zeile ist soooooooooooooooooooooooo" "ooooooooooo lang!"); rechnerinterne Darstellung "Ritchie" 15

15 Aufzählungskonstanten ganzzahlige Konstanten, die einen Bezeichner als Alias für jeden Wert besitzen erster Bezeichner in der enum Liste per default 0 enum boolean no, yes; enum Monate Januar, Februar, Maerz; enum Monate Januar = 1, Februar, Maerz; enum Values alpha = 3, beta = 6, gamma = 7, delta = beta + alpha, epsi = gamma; 16

16 Aufzählungskonstanten ganzzahlige Konstanten, die einen Bezeichner als Alias für jeden Wert besitzen erster Bezeichner in der enum Liste per default enum boolean no, yes; enum Monate Januar, Februar, Maerz; enum Monate Januar = 1, Februar, Maerz; enum Values alpha = 3, beta = 6, gamma = 7, delta = beta + alpha, epsi = gamma;

17 Operatoren Anwendung auf einen oder mehrere Operanden Bildung von (Ergebnis-)Werten mögliche Nebeneffekte 19

18 Satzzeichen spezifizieren keine Operation können Operator oder Teil eines Operators sein 20

19 Lexik Zinsberechnung Eigene Funktionen Makefiles Zinsberechnung 21

20 Lexik Zinsberechnung Eigene Funktionen Makefiles Beispiel: Zinsberechnung Berechnung der jährlichen Entwicklung eines Grundkapitals über eine vorgegebene Laufzeit Zinsen werden mit dem Kapital wieder angelegt Erzeugung einer Tabelle mit folgenden Angaben: laufendes Jahr und angesammeltes Kapital (in EUR) Laufzeit: 10 Jahre Grundkapital: 1000 EUR Zins: 5% 22

21 Lexik Zinsberechnung Eigene Funktionen Makefiles /* Anwendung zur Zinsberechnung */ #include <stdio.h> #define LAUFZEIT 10 #define GRUNDKAPITAL int main() int jahr; double kapital = GRUNDKAPITAL; printf ("Zinstabelle fuer Grundkapital %7.2f EUR\n", ); printf ("Kapitalstand zum Jahresende:\n"); for (jahr = ; jahr <= ; jahr = ) printf ("\njahr: %2d\t", jahr); kapital = kapital * (1. + ZINS / ); printf ("Kapital: %7.2f EUR", ); printf ("\n\naus %7.2f EUR Grundkapital\n", ); printf ("wurden in %d Jahren %7.2f EUR\n",, ); return 0; 23

22 Lexik Zinsberechnung Eigene Funktionen Makefiles 25

23 Eigene Funktionen 26

24 Hauptprogramm - Unterprogramm Anwendung: mehrfach vorkommende Programmteile Teilaufgaben separieren Programm strukturieren (Module) Wiederverwendung Benutzung von Bibliotheken 27

25 int summe (int n) int zwsumme; zwsumme = n / 2 * (n + 1); return zwsumme; 28

26 Übergabeparameter und Rückgabewert Rückgabetyp Funktionsname(typ1 parameter1, typ2 parameter2,...) lokale Deklarationen; Anweisung1; Anweisung2;... return Ausdruck; Wertübergabe Hauptprogramm -> Unterprogramm - bei Funktionsaufruf - Funktionsparameter in beliebiger Anzahl Wertübergabe Unterprogramm -> Hauptprogramm - bei Beendigung des Unterprogramms - maximal 1 Wert 29

27 #include <stdio.h> int summe(int u, int o) int i; int zwsumme = 0; for (i = u; i <= o; i = i + 1) zwsumme = zwsumme + i; return zwsumme; int main() int eingabe; int resultat; printf("eingabe der unteren und oberen Grenze: "); scanf("%d %d", &untere, &obere); resultat = summe(untere, obere); printf("die Summe der Zahlen von %d bis %d ist %d\n", untere, obere, resultat); return 0; 30

28 Deklaration von Funktionen int main() int maximum, x = 2, y = 3; maximum = max(x, y); return 0; 34

29 Deklaration von Funktionen int main() int maximum, x = 2, y = 3; maximum = max(x, y); return 0; int max(int a, int b) 35

30 Deklaration von Funktionen int main() int maximum, x = 2, y = 3; maximum = max(x, y); return 0; int max(int a, int b) if (a > b) return a; else return b; 36

31 Deklaration von Funktionen int max(int, int); // Funktions-Prototyp int main() int maximum, x = 2, y = 3; maximum = max(x, y); return 0; int max(int a, int b) if (a > b) return a; else return b; 37

32 Deklaration von Funktionen int max(int a, int b); // Funktions-Prototyp, // Bezeichner sind optional int main() int maximum, x = 2, y = 3; maximum = max(x, y); return 0; int max(int a, int b) if (a > b) return a; else return b; 38

33 Deklaration vs. Definition Deklaration: Prototyp enthält den Funktionskopf. Rückgabetyp Funktionsname Parameter (inkl. Datentypen) Art der Parameterübergabe (call by value/reference) typ Funktionsname (typ1, typ2,...); typ Funktionsname (typ1 parameter1, typ2 parameter2,...); Definition: Implementierung enthält den Funktionsrumpf. typ Funktionsname (typ1 parameter1, typ2 parameter2,...)... return Ausdruck; 39

34 Beispiel: Programm aus mehreren Quelldateien modul1.c modul2.c modul3.c #include <stdio.h> int main() int u; i = 1; abc(); u = sum(17, 4); printf("%d", u); return 0; int i; int sum(int x, int y) return x + y; void abc() i = 10; 40

35 Beispiel: Programm aus mehreren Quelldateien modul1.c modul2.c modul3.c #include <stdio.h> extern int i; int main() int u; int i; int sum(int x, int y) return x + y; extern int i; void abc() i = 10; i = 1; abc(); u = sum(17, 4); printf("%d", u); return 0; 41

36 Beispiel: Programm aus mehreren Quelldateien modul1.c modul2.c modul3.c #include <stdio.h> int sum(int, int); void abc(); extern int i; int main() int u; int i; int sum(int x, int y) return x + y; extern int i; void abc() i = 10; i = 1; abc(); u = sum(17, 4); printf("%d", u); return 0; 42

37 Beispiel: Programm aus mehreren Quelldateien modul2.h modul3.h extern int i; int sum(int, int); void abc(); modul1.c modul2.c modul3.c #include <stdio.h> int main() int u; i = 1; abc(); u = sum(17, 4); printf("%d", u); return 0; int i; int sum(int x, int y) return x + y; void abc() i = 10; 43

38 Beispiel: Programm aus mehreren Quelldateien modul2.h modul3.h extern int i; int sum(int, int); void abc(); modul1.c modul2.c modul3.c #include <stdio.h> #include modul2.h #include modul3.h int main() int u; int i; int sum(int x, int y) return x + y; #include modul2.h void abc() i = 10; i = 1; abc(); u = sum(17, 4); printf("%d", u); return 0; 44

39 Beispiel: Programm aus mehreren Quelldateien modul2.h modul3.h extern int i; int sum(int, int); void abc(); modul1.c modul2.c modul3.c #include <stdio.h> #include modul2.h #include modul3.h int main() int u; i = 1; abc(); u = sum(17, 4); printf("%d", u); return 0; #include modul2.h int i; int sum(int x, int y) return x + y; #include modul2.h #include modul3.h void abc() i = 10; 45

40 Makefiles 46

41 Kompilieren, Binden, Laden 47

42 Aufbau eines Makefiles Definitionen von Variablen und Funktionen z.b. CC = gcc -Wall Kommentare z.b. # Dies ist ein Kommentar! Includes z.b. -include Makefile.local Regeln z.b. %.o: %.c; -CC $< Syntax für Regeln: Target [weitere Targets]:[:] [Vorbedingungen] [; Kommandos] [<Tab> Kommandos] [<Tab> Kommandos] 48

43 01 CC = gcc Wall 02 Objektdateien = main.o teil1.o teil2.o 03 Programm = beispiel.exe $(Programm): $(Objektdateien) 06 $(CC) -o $@ $^ # explizite Regel definiert das Kommando 09 $(Objektdateien): 10 $(CC) -c $< # implizite Regeln definieren die Abhängigkeiten 13 main.o: main.c sub1.h sub2.h 14 sub1.o: sub1.c 15 sub2.o: sub2.c all: clean $(Programm) run clean: 20 rm $(Objektdateien) $(Programm) -f run: 23./$(Programm) 49

44 hallo.o: hallo.c gcc -c hallo.c 50

45 hallo.o: hallo.c gcc -c hallo.c hallo.exe: hallo.o gcc -o hallo.exe hallo.o 51

46 hallo.exe: hallo.o gcc -o hallo.exe hallo.o hallo.o: hallo.c gcc -c hallo.c 52

47 CC = gcc -Wall -std=c99 hallo.exe: hallo.o $(CC) -o $@ $< hallo.o: hallo.c $(CC) -c $< Targetname: $@ erste Vorbedingung: $< 53

48 Kompilieren, Binden, Laden 54

49 01 CC = gcc Wall std=c beispiel.exe: main.o sub1.o sub2.o 04 $(CC) -o $@ $^ main.o: main.c sub1.h sub2.h 07 $(CC) -c $< sub1.o: sub1.c 10 $(CC) -c $< sub2.o: sub2.c 13 $(CC) -c $< Targetname: $@ erste Vorbedingung: $< alle Vorbedingungen: $^ 55

50 01 CC = gcc Wall std=c beispiel.exe: main.o sub1.o sub2.o 04 $(CC) -o $@ $^ main.o: main.c sub1.h sub2.h 07 $(CC) -c $< sub1.o: sub1.c 10 $(CC) -c $< sub2.o: sub2.c 13 $(CC) -c $< all: clean beispiel.exe run clean: 18 rm *.o beispiel.exe -f run: 21./beispiel.exe 56

51 01 CC = gcc Wall std=c beispiel.exe: main.o sub1.o sub2.o 04 $(CC) -o $@ $^ main.o: main.c sub1.h sub2.h 07 $(CC) -c $< sub1.o: sub1.c 10 $(CC) -c $< sub2.o: sub2.c 13 $(CC) -c $< all: clean beispiel.exe run clean: 18 rm *.o beispiel.exe -f run: 21./beispiel.exe 57

52 01 CC = gcc Wall std=c beispiel.exe: main.o sub1.o sub2.o 04 $(CC) -o $@ $^ # explizite Regel definiert das Kommando 07 main.o sub1.o sub2.o: 08 $(CC) -c $< # implizite Regeln definieren die Abhaengigkeiten 11 main.o: main.c sub1.h sub2.h 12 sub1.o: sub1.c 13 sub2.o: sub2.c all: clean beispiel.exe run clean: 18 rm *.o beispiel.exe -f run: 21./beispiel.exe 58

53 01 CC = gcc -Wall std=c beispiel.exe: main.o sub1.o sub2.o 04 $(CC) -o $@ $^ # explizite Regel definiert das Kommando 07 main.o sub1.o sub2.o: 08 $(CC) -c $< # implizite Regeln definieren die Abhaengigkeiten 11 main.o: main.c sub1.h sub2.h 12 sub1.o: sub1.c 13 sub2.o: sub2.c all: clean beispiel.exe run clean: 18 rm *.o beispiel.exe -f run: 21./beispiel.exe 59

54 01 CC = gcc Wall std=c99 02 Objektdateien = main.o sub1.o sub2.o 03 Programm = beispiel.exe $(Programm): $(Objektdateien) 06 $(CC) -o $@ $^ # explizite Regel definiert das Kommando 09 $(Objektdateien): 10 $(CC) -c $< # implizite Regeln definieren die Abhängigkeiten 13 main.o: main.c sub1.h sub2.h 14 sub1.o: sub1.c 15 sub2.o: sub2.c all: clean $(Programm) run clean: 20 rm $(Objektdateien) $(Programm) -f run: 23./$(Programm) 60

55 01 CC = gcc Wall std=c99 02 Objektdateien = main.o sub1.o sub2.o 03 Programm = beispiel.exe $(Programm): $(Objektdateien) 06 $(CC) -o $@ $^ # explizite Regel definiert das Kommando 09 $(Objektdateien): 10 $(CC) -c $< # implizite Regeln definieren die Abhängigkeiten 13 main.o: main.c sub1.h sub2.h 14 sub1.o: sub1.c 15 sub2.o: sub2.c all: clean $(Programm) run clean: 20 rm $(Objektdateien) $(Programm) -f run: 23./$(Programm) 61