1.1 Grundlagen: Reguläre Ausdrücke

(1)

1.1 Grundlagen: Reguläre Ausdrücke

• Programmtext benutzt ein endliches Alphabet Σ von Eingabe-Zeichen, z.B. ASCII :-)

• Die Menge der Textabschnitte einer Token-Klasse ist i.a. regulär.

• Reguläre Sprachen kann man mithilfe regulärer Ausdrückespezifizieren.

Die Menge EΣ der (nicht-leeren) regulären Ausdrücke ist die kleinste Menge E mit:

• ∈ E ₍ neues Symbol nicht aus Σ);

• a ∈ E _{für alle} _a ∈ ^Σ_;

• (e1 | _e₂),(e1 ·_e₂), e1∗ ∈ E _sofern _e₁_, _e₂ ∈ E_.

(2)

1.1 Grundlagen: Reguläre Ausdrücke

• Programmtext benutzt ein endliches Alphabet Σ von Eingabe-Zeichen, z.B. ASCII :-)

• Die Menge der Textabschnitte einer Token-Klasse ist i.a. regulär.

• Reguläre Sprachen kann man mithilfe regulärer Ausdrückespezifizieren.

Die Menge EΣ der (nicht-leeren) regulären Ausdrücke ist die kleinste Menge E mit:

• ∈ E ₍ neues Symbol nicht aus Σ);

• a ∈ E _{für alle} _a ∈ ^Σ_;

• (e1 | _e₂),(e1 ·_e₂), e1∗ ∈ E _sofern _e₁_, _e₂ ∈ E_.

(3)

Stephen Kleene, Madison Wisconsin, 1909-1994

(4)

Beispiele:

((a·b^∗)·a) (a | b)

((a·b)·(a·b))

Achtung:

• Wir unterscheiden zwischen Zeichen a, 0,|,... und Meta-Zeichen (,|, ),...

• Um (hässliche) Klammern zu sparen, benutzen wir Operator-Präzedenzen:

∗ > · >|

und lassen “·” weg :-)

• Reale Spezifikations-Sprachen bieten zusätzliche Konstrukte wie:

e? ≡ ( | e) e⁺ ≡ (e ·e^∗) und verzichten auf “_{” :-)}

(5)

Beispiele:

((a·b^∗)·a) (a | b)

((a·b)·(a·b))

Achtung:

• Wir unterscheiden zwischen Zeichen a, 0, |,... und Meta-Zeichen (,|,),...

∗ > · > |

e? ≡ ( | e) e⁺ ≡ (e ·e^∗) und verzichten auf “_{” :-)}

(6)

Beispiele:

((a·b^∗)·a) (a | b)

((a·b)·(a·b))

Achtung:

• Wir unterscheiden zwischen Zeichen a, 0, |,... und Meta-Zeichen (,|,),...

∗ > · > |

e? ≡ ( | e) e⁺ ≡ (e ·e^∗) und verzichten auf “_” _:-)

(7)

Spezifikationen benötigen eine Semantik :-) Im Beispiel:

Spezifikation Semantik ab^∗a {abⁿa | n ≥ 0} a | b {a,b}

abab {abab}

Für e ∈ E^Σ definieren wir die spezifizierte Sprache [[e]] ⊆ ^Σ^∗ _induktiv durch:

[[]] = {} [[a]] = {_a} [[e^∗]] = ([[e]])^∗

[[e1|_e₂]] = [[e1]]∪ [[e2]]

[[e₁·e₂]] = [[e₁]]· [[e₂]]

(8)

Beachte:

• Die Operatoren (_)^∗,∪_, · sind die entsprechenden Operationen auf Wort-Mengen:

(L)^∗ = {w1 . . .w_k | k ≥ 0, w_i ∈ L} L1 ·L2 = {w1w2 | w1 ∈ L1, w2 ∈ L2}

(9)

Beachte:

• Die Operatoren (_)^∗,∪_, · sind die entsprechenden Operationen auf Wort-Mengen:

(L)^∗ = {w1 . . .w_k | k ≥ 0, w_i ∈ L} L1 ·L2 = {w1w2 | w1 ∈ L1, w2 ∈ L2}

• Reguläre Ausdrücke stellen wir intern als markierte geordnete Bäume dar:

.

|

*

b

a (ab|)^∗

Innere Knoten: Operator-Anwendungen;

Blätter: einzelne Zeichen oder _.

(10)

Finger-Übung:

Zu jedem regulären Ausdruck e können wir einen Ausdruck e⁰ (evt. mit

“?”) konstruieren so dass:

• [[e]] = [[e⁰]];

• Falls [[e]] = {}, dann ist e⁰ ≡_;

• Falls [[e]] 6= {}, dann enthält e⁰ kein “_”.

Konstruktion:

Wir definieren eine Transformation T von regulären Ausdrücken durch:

(11)

Finger-Übung:

Zu jedem regulären Ausdruck e können wir einen Ausdruck e⁰ (evt. mit

“?”) konstruieren so dass:

• [[e]] = [[e⁰]];

• Falls [[e]] = {}, dann ist e⁰ ≡_;

• Falls [[e]] 6= {}, dann enthält e⁰ kein “_”.

Konstruktion:

Wir definieren eine Transformation T von regulären Ausdrücken durch:

(12)

T [] = T [a] = a

T [e1|e2] = ^case (T [e1], T [e2]) ^of (_,) :

| (e⁰₁,) : e⁰₁?

| (_, _e⁰

2) : e⁰₂?

| (e⁰₁,e⁰₂): (e⁰₁ | e⁰₂) T [e1·_e₂] = ^case (T [e1], T [e2]) ^of (_,) :

| (e⁰₁,) : e⁰₁

| (_, _e⁰

2) : e⁰₂

| (e⁰₁,e⁰₂): (e⁰₁ ·_e⁰₂) T [e^∗] = ^case T [e] ^of _:

| e1: e1∗

T [e?] = ^case T [e] ^of _:

| e1: e1?

(13)

Unsere Anwendung:

Identifier in Java:

le = [a-zA-Z_\$]

di = [0-9]

Id = {le} ({le} | {di})*

Bemerkungen:

• “le” und “di” sind Zeichenklassen.

• Definierte Namen werden in “{”, “}” eingeschlossen.

• Zeichen werden von Meta-Zeichen durch “\” unterschieden.

(14)

Unsere Anwendung:

Identifier in Java:

le = [a-zA-Z_\$]

di = [0-9]

Id = {le} ({le} | {di})*

Bemerkungen:

(15)

Unsere Anwendung:

Identifier in Java:

le = [a-zA-Z_\$]

di = [0-9]

Id = {le} ({le}|{di})*

Gleitkommazahlen:

Float = {di}* (\.{di}|{di}\.) {di}*((e|E)(\+|\-)?{di}+)?

Bemerkungen:

(16)

1.2 Grundlagen: Endliche Automaten Beispiel:

a b

Knoten: Zustände;

Kanten: Übergänge;

Beschriftungen: konsumierter Input :-)

(17)

1.2 Grundlagen: Endliche Automaten Beispiel:

a b

Knoten: Zustände;

Kanten: Übergänge;

Beschriftungen: konsumierter Input :-)

(18)

Michael O. Rabin, Stanford University

Dana S. Scott, Carnegy Mellon University, Pittsburgh

(19)

Formal ist ein nicht-deterministischer endlicher Automat mit-Übergängen (-NFA) ein Tupel A = (Q, Σ,δ_, _I_, _F) wobei:

Q eine endliche Menge von Zuständen;

Σ ein endliches Eingabe-Alphabet;

I ⊆ _Q die Menge der Anfangszustände;

F ⊆ Q die Menge der Endzustände und

δ die Menge der Übergänge (die Übergangs-Relation) ist.

(20)

Für_-NFAs _ist:

δ ⊆ Q × (^Σ∪ {})× Q

• Gibt es keine_-Übergänge (p,_,_q), ist A ein NFA.

• Ist δ _: _Q× ^Σ → Q eine Funktion und #I = 1, heißt A deterministisch (DFA).

(21)

Für_-NFAs _ist:

δ ⊆ Q × (^Σ∪ {})× Q

• Gibt es keine_-Übergänge (p,_, _q), ist A ein NFA.

• Ist δ _: _Q× ^Σ → Q eine Funktion und #I = 1, heißt A deterministisch(DFA).

(22)

Akzeptierung

• Berechnungen sind Pfade im Graphen.

• akzeptierende Berechnungen führen von I nach F .

• Ein akzeptiertes Wort ist die Beschriftung eines akzeptierenden Pfades ...

a b

(23)

Akzeptierung

• Berechnungen sind Pfade im Graphen.

• akzeptierende Berechnungen führen von I nach F .

• Ein akzeptiertes Wort ist die Beschriftung eines akzeptierenden Pfades ...

a b

(24)

• Dazu definieren wir den transitiven Abschluss δ^∗ _von δ als kleinste Menge δ⁰ _mit:

(p,_, _p) ∈ δ⁰ _und

(p,xw, q) ∈ δ⁰ _sofern (p, x, p1) ∈ δ _und (p1, w,q) ∈ δ⁰_.

δ^∗ beschreibt für je zwei Zustände, mit welchen Wörtern man vom einen zum andern kommt :-)

• Die Menge aller akzeptierten Worte, d.h. die von A akzeptierte Sprache können wir kurz beschreiben als:

L(_A) = {_w ∈ ^Σ^∗ | ∃ _i ∈ _I_, _f ∈ _F _: (i,w, f) ∈ δ^∗}

(25)

Satz:

Für jeden regulären Ausdruck e kann (in linearer Zeit :-) ein_-NFA konstruiert werden, der die Sprache [[e]] akzeptiert.

Idee:

Der Automat verfolgt (konzepionell mithilfe einer Marke “•”), wohin man in e mit der Eingabe w gelangen kann.

(26)

Beispiel:

*

.

|

b a

b a a

( _a | b )

^∗

_a ( _a | b )

(27)

Beispiel:

*

.

|

b a

b a a

w = _bbaa :

(28)

Beispiel:

*

.

|

b a

b a a

w = _bbaa :

(29)

Beispiel:

*

.

|

b a

b a a

w = _bbaa :

(30)

Beispiel:

*

.

|

b a

b a a

w = _bbaa :

(31)

Beispiel:

*

.

|

b a

b a a

w = _bbaa :

(32)

Beispiel:

*

.

|

b a

b a a

w = _bbaa :

(33)

Beispiel:

*

.

|

b a

b a a

w = _bbaa :

(34)

Beispiel:

*

.

|

b a

b a a

w = _bbaa :

(35)

Beispiel:

*

.

|

b a

b a a

w = _bbaa :

(36)

Beachte:

• Gelesen wird nur an den Blättern.

• Die Navigation im Baum erfolgt ohne Lesen, d.h. mit-Übergängen.

• Für eine formale Konstruktion müssen wir die Knoten im Baum bezeichnen.

• Dazu benutzen wir (hier) einfach den dargestellten Teilausdruck :-)

• Leider gibt es eventuell mehrere gleiche Teilausdrücke :-(

==⇒ Wir numerieren die Blätter durch ...

(37)

... im Beispiel:

*

.

|

b a

a

(38)

... im Beispiel:

*

.

|

0 1

2

3

b

4

a

b a

a

(39)

... im Beispiel:

*

.

|

0 1

2 3 4

a b a b

a

(40)

Die Konstruktion:

Zustände: •_r, _r• _r _{Knoten von} _e;

Anfangszustand: •e;

Endzustand: e•; Übergangsrelation:

Für Blätter r ≡ i x benötigen wir: (•r,x,r•). Die übrigen Übergänge sind:

(41)

r Übergänge r1 | r2 (•r,_,•r1)

(•_r,_,•_r₂) (r1•_,_, _r•) (r2•_,_, _r•) r1 ·_r₂ (•_r,_,•_r₁) (r1•,_, •_r₂) (r2•,_, _r•)

r Übergänge r^∗₁ (•r,_, _r•)

(•_r,_, •_r₁) (r1•_,_,•_r₁) (r1•_,_,_r•) r1? (•_r,_, _r•)

(•r,_, •_r₁) (r1•,_,_r•)

(42)

Diskussion:

• Die meisten Übergänge dienen dazu, im Ausdruck zu navigieren :-(

• Der Automat ist i.a. nichtdeterministisch :-(

==⇒

Strategie:

(1) Beseitigung der-Übergänge;

(2) Beseitigung des Nichtdeterminismus :-)

(43)

Diskussion:

• Die meisten Übergänge dienen dazu, im Ausdruck zu navigieren :-(

• Der Automat ist i.a. nichtdeterministisch :-(

==⇒

Strategie:

(1) Beseitigung der-Übergänge;

(2) Beseitigung des Nichtdeterminismus :-)

(44)

Beseitigung von -Übergängen:

Zwei einfache Ansätze:

p q

1

a q

2

q

Wir benutzen hier den zweiten Ansatz.

Zur Konstruktion von Parsern werden wir später den ersten benutzen :-)

(45)

Beseitigung von -Übergängen:

Zwei einfache Ansätze:

p q

1

a q

2

q

Wir benutzen hier den zweiten Ansatz.

Zur Konstruktion von Parsern werden wir später den ersten benutzen :-)

(46)

1. Schritt:

^empty^[^r^{] =} ^t ^gdw. ^∈ ^[[^r^]]

... im Beispiel:

*

.

|

0 1

2 3 4

a b a b

a

(47)

1. Schritt:

^empty^[^r^{] =} ^t ^gdw. ^∈ ^[[^r^]]

... im Beispiel:

*

.

|

f f

f

f f

0 1 3 4

2

a b a b

a

(48)

1. Schritt:

^empty^[^r^{] =} ^t ^gdw. ^∈ ^[[^r^]]

... im Beispiel:

*

.

|

f f

f

f f

0 1 3 4

2

a b a b

a

(49)

1. Schritt:

^empty^[^r^{] =} ^t ^gdw. ^∈ ^[[^r^]]

... im Beispiel:

.

* .

|

f f

f

f f

f t

0 1 3 4

2

a b a b

a

(50)

1. Schritt:

^empty^[^r^{] =} ^t ^gdw. ^∈ ^[[^r^]]

... im Beispiel:

.

* .

|

f f

f

f f

f t

f

0 1 3 4

2

a b a b

a

(51)

Implementierung: DFS post-order Traversierung

Für Blätter r ≡ i x ist empty[r] = (x ≡ ). Andernfalls:

empty[r1 | _r₂] = ^empty[r1]∨empty[r2] empty[r1 ·_r₂] = ^empty[r1]∧empty[r2] empty[r^∗₁] = t

empty[r₁?] = t

(52)

2. Schritt:

Die Menge erster Bätter: first[r] = {i in r | (•r,_, • i x ) ∈ δ^∗}

... im Beispiel:

.

* .

|

f f

f

f f

f t

f

0 1 3 4

2

a b a b

a

(53)

2. Schritt:

... im Beispiel:

.

* .

|

f f

f

f f

f t

f

0 0

1 2

3 4

1 3 4

2

a b a b

a

(54)

2. Schritt:

... im Beispiel:

.

* .

|

f f

f

f f

f t

f

0 0

1 2

3 4

1 3 4

0 1

3 4 2

a b a b

a

(55)

2. Schritt:

... im Beispiel:

.

* .

|

f f

f

f f

f t

f

0 0

1 2

3 4

1 3 4

0 1

3 4

0 1 2

2

a b a b

a

(56)

2. Schritt:

Die Menge erster Bätter: first[r] = {i in r | (•r,_, • i x ) ∈ δ^∗_,_x 6=}

... im Beispiel:

.

* .

|

f f

f

f f

f t

f

0 0

1 2

3 4

1 3 4

0 1

3 4

0 1 2

2 0 1 2

a b a b

a

(57)

Implementierung: DFS post-order Traversierung

Für Blätter r ≡ i x ist first[r] = {_i | _x 6≡}_. Andernfalls:

first[r1 | r2] = ^first[r1]∪^first[r2] first[r1 ·r2] =







first[r1]∪ first[r2] falls empty[r1] = t first[r1] falls empty[r1] = f first[r^∗₁] = ^first[r1]

1.1 Grundlagen: Reguläre Ausdrücke