RegExp-Kurs 02: Metazeichen & Escaping

[Meillo]

Code: Alles auswählen

RegEx eingeben: A,BCD,E,FG,,H
Esc-Char eing.: ,
Literal-Zeichen -> ACDG,H
   Meta-Zeichen ->BEF

Es waere cool wenn dein Programm die Reihenfolge insgesamt noch bewahren koennte, z.B. so:

Code: Alles auswählen

RegEx eingeben: A,BCD,E,FG,,H
Esc-Char eing.: ,
Literal-Zeichen -> A CD  G,H
   Meta-Zeichen ->  B  EF

[inne]

Das mit den Metazeichen und Escaping hat man bspw. auch bei strftime(3) usw., ist doch das selbe Prinzip?

[tegula]

Meillos schrieb ja in seiner Lektion:

Um das Escapezeichen literal zu erhalten muss es (mit sich selbst) escapet werden. (Zwei aufeinander folgende Escapezeichen stehen immer fuer ein literales Escapezeichen.)

Ich muss zugeben, dass ich ohne diesen Hinweis wohl nicht darauf gekommen wäre, das Escapezeichen selbst zu escapen.

Danke! Meine Lösung war also sogar in zweierlei Hinsicht falsch

Ich habe einerseits das Escapezeichen selbst nicht escapted und habe zusätzlich noch die literalen Zeichen escapted, obwohl in der Aufgabenstellung die literalen Zeichen als Standardzeichen definiert waren. Der erstgenannte Fehler bedeutet leider auch, dass meine Lösung zur Aufgabe 13 (zum Teil) falsch ist, da ich dort ebenfalls von der falschen Annahme ausgegangen bin, dass das Escapezeichen selbst nicht escapet werden muss. Gibt es eine "schönen" Weg, wie ich diesen Fehler beheben kann, ohne noch mehr Else-If-Verzweigungen zu nutzen (und das Script somit unübersichtlicher zu machen)?

[TuxPeter]

Meillo hat geschrieben:

Es waere cool wenn dein Programm die Reihenfolge insgesamt noch bewahren koennte, z.B. so:

Code: Alles auswählen

Esc-Char eingeben: ,
   RegEx eingeben: A,BCD,E,FG,,H
Literal-Zeichen -> A CD  G,H
   Meta-Zeichen ->  B  EF   

Kleinere Wünsche können sofort erfüllt werden. Einfach noch ein Blank in die jeweils nicht betroffene Zeichenklasse setzen. Außerdem das esc-Zeichen zuerst eingeben - ist schlüssiger. (lade ich aber jetzt nicht extra noch mal hoch, falls gewünscht, doch)
Der umgekehrte Fall (meta als Standard, literal escaped) müsste eigentlich auch mit dem Progrämmchen erschlagen sein - denkt euch einfach die Ausgabe vertauscht, dh. Literal-Zeichen heißt dann Meta-Zeichen und umgekehrt.

[TuxPeter]

Das mit den Metazeichen und Escaping hat man bspw. auch bei strftime(3) usw., ist doch das selbe Prinzip?

Haben wir das nicht in der bash andauernd, diese Unterscheidung, sogar in verschiedenen Meta-Ebenen, wenn man mal man date anschaut, dann gibt es sogar zwei Meta-Ebenen, nämlich 1. welches Datum behandelt werden soll und 2. wie es formatiert werden soll. Auch das hierarchische Quoting mit den verschiedenen Anführungszeichen (doppelte, einfache, backtikets) für die verschiedenen Verarbeitungsebenen.

[Meillo]

Meillo hat geschrieben:

Es waere cool wenn dein Programm die Reihenfolge insgesamt noch bewahren koennte, z.B. so:

Code: Alles auswählen

Esc-Char eingeben: ,
   RegEx eingeben: A,BCD,E,FG,,H
Literal-Zeichen -> A CD  G,H
   Meta-Zeichen ->  B  EF   

Kleinere Wünsche können sofort erfüllt werden. Einfach noch ein Blank in die jeweils nicht betroffene Zeichenklasse setzen.

Klasse!

Der umgekehrte Fall (meta als Standard, literal escaped) müsste eigentlich auch mit dem Progrämmchen erschlagen sein - denkt euch einfach die Ausgabe vertauscht, dh. Literal-Zeichen heißt dann Meta-Zeichen und umgekehrt.

Fast richtig. An welche Kleinigkeit hast du dabei nicht gedacht?

[Meillo]

@inne: Ja, genau.

@tegula: Weiter so! Auf diesem Wege lernt man am meisten dabei.


Ich find's klasse wie es gerade laeuft. Zumindest manche koennen diesen abstrakten Uebungen durchaus ein bisschen Spass abgewinnen.

Diejenigen, die noch mit dem Verstehen oder mit dem Spasshaben kaempfen duerfen auch gerne nochmal nachfragen und sich Dinge erklaeren lassen. Auch wenn ihr die Loesung von jemandem nicht verstanden habt, koennt ihr gerne nachfragen warum die so ist. (Vielleicht ist sie ja falsch und ihr habt es richtig verstanden. )

[inne]

@TuxPeter
Ich kam wegen dem hier drauf:

Obwohl es ja logisch sofort einsehbar ist, war mir nicht klar, dass man ENTWEDER die Metazeichen ODER die Literale escapen ... kann.

[Meillo]

Obwohl es ja logisch sofort einsehbar ist, war mir nicht klar, dass man ENTWEDER die Metazeichen ODER die Literale escapen ... kann.

Leider werden wir spaeter noch lernen muessen, dass es nicht immer so klar und einfach ist. Aber dazu dann spaeter mehr. Fuer den jetzigen Zeitpunkt ist deine Erkenntnis richtig und hilfreich.

[inne]

Von den Programmierlösungen hier bin ich schwer beeindruckt

Ich habe kein Informatik versucht zu studieren und werde es auch online nicht mehr anfangen.
Aber will mal noch was für mich fragen, ganz allgemein: Zeichenketten funktionieren auch nach diesem Prinzip oder?
Wobei hier idR. " das Metazeichen ist, und Literale (auch wieder) die Standardzeichen sind? Weil: "Mit \" beginnt und endet eine Zeichenkette".

PS: Ich hoffe ich bringe das nicht durcheinander. Aber hier passt doch noch am besten bevor es wirklich um REs geht. Ansonsten bitte abtrennen.

[TuxPeter]

Vermutlich kann man es so sagen: Eine Zeichenkette ist zunächst mal nichts weiter als das was das Wort sagt: Eine simple Aneinanderreihung von Zeichen. Wichtig ist noch, dass sie ein Anfang und ein Ende hat und damit eine bestimmte Reihenfolge hat, infolgedessen kann man die Zeichen auch abzählen und durchnummerieren und sonstwas mit ihnen anstellen. Was mit ihr passiert, bestimmt dann der Kontext - also innerhalb eines Programmes z.B. die Anführungszeichen. Die sagen dem Computer (bzw. Compiler oder Interpreter): Kümmere dich nicht um den Inhalt, reiche es einfach weiter. Aber ohne Gewähr, ich bin auch kein Informatiker - zu meiner Zeit sprach man eher von EDV als von Informatik.

[TuxPeter]

TuxPeter schrieb:

Der umgekehrte Fall (meta als Standard, literal escaped) müsste eigentlich auch mit dem Progrämmchen erschlagen sein - denkt euch einfach die Ausgabe vertauscht,
dh. Literal-Zeichen heißt dann Meta-Zeichen und umgekehrt.

Meillo schrieb:

Fast richtig. An welche Kleinigkeit hast du dabei nicht gedacht?

Also, schaun wir mal: Die Aufgaben 5 u. 6 und die Ausgaben meines Progrämmchens

5) Suche dir ein Escapezeichen aus. Literale Zeichen sind die Standardzeichen. Schreibe die Zeichenfolge: Literales `D', literales 'F', literales `D', literales 'E', Metazeichen `J', literales `R', literales `E', literales `s', literales `!', Metazeichen `J', Metazeichen `@'.

Code: Alles auswählen

Esc-Char eingeben: #   
   RegEx eingeben: DFDE#JREs!#J#@
Literal-Zeichen -> DFDE REs!  
   Meta-Zeichen ->     J    J@

6) Schreibe den gleichen Text aus (5) aber mit Metazeichen als Standard

Code: Alles auswählen

Esc-Char eingeben: #
   RegEx eingeben: #D#F#D#EJ#R#E#s#!J@
Literal-Zeichen ->     J    J@         // Lies: dies sind die Meta-Zeichen
   Meta-Zeichen -> DFDE REs!           // Lies: dies sind die Literal-Zeichen
                                       // also alles nur vertauscht    

Stimmt soweit.
Aber: Jetzt wollen wir mal ein literales # sehen und hängen das hinten an:

Code: Alles auswählen

Esc-Char eingeben: #
   RegEx eingeben: #D#F#D#EJ#R#E#s#!J@ ->##<-
Literal-Zeichen ->     J    J@ ->#<-   // Lies: dies sind die Meta-Zeichen
   Meta-Zeichen -> DFDE REs!           // Lies: dies sind die Literal-Zeichen

Und siehe da: Dieses landet prompt in der falschen Rubrik. Es muss also auch die
Behandlung des Esc.-Zeichens angepasst bzw. vertauscht werden, wenn der Standard nicht die literalen, sondern die Metazeichen sind. (hoffentlich liege ich damit richtig)

[Meillo]

@TuxPeter: Du bist schon auf dem richtigen Weg, bloss noch nicht ganz am Ende davon.

Es muss mit einem Ausdruck immer moeglich sein jedes beliebige Zeichen literal darzustellen.

Schreibe nun vier verschiedene Ausdruecke, jeweils mit # als Escapezeichen:

1) Literale sind Standardzeichen. Ein Ausdruck fuer den literalen String ``a''
2) Metazeichen sind Standardzeichen. Ein Ausdruck fuer den literalen String ``a''
3) Literale sind Standardzeichen. Ein Ausdruck fuer den literalen String ``#''
4) Metazeichen sind Standardzeichen. Ein Ausdruck fuer den literalen String ``#''

Was faellt dir auf?

[TuxPeter]

Hallo Meillo, danke für Deine Extra-Mühe - ich scheine im Punkt 4 echt Begriffsstutzig zu sein. Aber dann bleibt ja nur dies übrig:

Code: Alles auswählen

Schreibe nun vier verschiedene Ausdruecke, jeweils mit # als Escapezeichen:

1) Literale sind Standardzeichen. Ein Ausdruck fuer den literalen String ``a''
Lösung: a

2) Metazeichen sind Standardzeichen. Ein Ausdruck fuer den literalen String ``a''
Lösung: #a

3) Literale sind Standardzeichen. Ein Ausdruck fuer den literalen String ``#''
Lösung: ##

4) Metazeichen sind Standardzeichen. Ein Ausdruck fuer den literalen String ``#''
Lösung:  ### 

Punkt 4 mal versprachlicht:

a) Wir befinden uns auf der Meta-Ebene. Um auf die literale Ebene kommen, müssen wir escapen.
b) Dort angekommen, finden wir wieder ein Escape-Zeichen vor, das aber literal zu verstehen ist - und deshalb selber escaped werden muss.
Stimmt das so?

Ich fände es ja auch logisch, zu sagen:
a) wie oben
b) Dort angekommen, finden wir wieder ein Escape-Zeichen vor. Da wir gerade von der Meta-Ebene her kommen, kann das Escape-Zeichen hier nur literal gemeint sein. - scheint aber nicht so zu sein.

[Meillo]

Die ersten drei Varianten sind richtig.

4) Metazeichen sind Standardzeichen. Ein Ausdruck fuer den literalen String ``#''
Lösung: ### [/code]

Punkt 4 mal versprachlicht:

a) Wir befinden uns auf der Meta-Ebene. Um auf die literale Ebene kommen, müssen wir escapen.
b) Dort angekommen, finden wir wieder ein Escape-Zeichen vor, das aber literal zu verstehen ist - und deshalb selber escaped werden muss.
Stimmt das so?

Du denkst etwas zu kompliziert. Es gibt nur eine Ebene von Escaping.

Ich verweise nochmal auf das was ich anfangs gepostet habe:

Escapen funktioniert folgendermassen:

1) Wir waehlen ein Escapezeichen. (Man nimmt moeglichst ein Zeichen, das selten im Text vorkommt, aber prinzipiell ist jedes Zeichen moeglich.)

2) Entweder die Literale oder die Metazeichen sind die Standardzeichen. Die andere Zeichenart muss escapet werden. D.h. vor jedes Zeichen der anderen Zeichenart muss ein Escapezeichen kommen.

3) Um das Escapezeichen literal zu erhalten muss es (mit sich selbst) escapet werden. (Zwei aufeinander folgende Escapezeichen stehen immer fuer ein literales Escapezeichen.)

Das Wort ``immer'' im letzten Satz ist entscheidend. Ich haette dort noch einfuegen koennen: ``unabhaengig davon was die Standardzeichen sind''

[TuxPeter]

TuxPeter schrieb:

Der umgekehrte Fall (meta als Standard, literal escaped) müsste eigentlich auch mit dem Progrämmchen erschlagen sein [...] einfach die Ausgabe vertauscht, [...]

[...]
Meillo schrieb:

Fast richtig. An welche Kleinigkeit hast du dabei nicht gedacht?

[...]

Code: Alles auswählen

 [ ... ]
 Literal-Zeichen ->     J    J@ ->#<-   // Lies: dies sind die Meta-Zeichen
   Meta-Zeichen -> DFDE REs!           // Lies: dies sind die Literal-Zeichen

Und siehe da: Dieses landet prompt in der falschen Rubrik.

Heißt, es landet bei den Meta-Zeichen (die hier dummerweise Literale heißen), sollte aber bei den Literalen landen, die hier (noch) als "Meta" falsch deklariert sind, das hatte ich dann doch richtig kapiert, das Progr. hatte ich ja noch nicht geändert.

Die Lösung war aber so schön in meinem Kommentar, was das Progrämmchen an der Stelle falsch macht, versteckt - ein echtes Verwirrspiel, das ich zu verantworten habe - Egal, aber ich denke, ich hab's jetzt: Esc.-Zeichen doppelt -> IMMER literal.

[Huo]

Meine Lösungen der Aufgaben 13) und 14) in Python:

13) 41641
Anwendung auf Aufgabe 4):

Code: Alles auswählen

$ regex_2_13.py a l Haus
Haaus

14) 41642
Anwendung auf Aufgabe 9):

Code: Alles auswählen

$ regex_2_14.py "," m "hello, world"
meta "h", meta "e", meta "l", meta "l", meta "o", literales " ", meta "w", meta "o", meta "r", meta "l", meta "d"

[tegula]

@ Huo: Wow! Kurz und trotzdem super gut verständlich . Falls ich später noch eine Korrektur meiner (bisher teilweise inkorrekten) Lösung zu Aufgabe 13 schreiben sollte, werde ich mich an deiner Lösung orientieren.

[TuxPeter]

Na prima, da will ich doch meine neue Pascal-Version zum Zerpflücken einer RegEx-Eingabe in literale und nicht literale Zeichen auch noch mal vorzeigen. Sieht jetzt nicht mehr aus wie VHS-Pascal-Kurs Untertupfingen-Nord, die 3. Sitzung, sondern mindestens wie die 4. oder 6. Vor allem wird jetzt die Möglichkeit geboten, entweder den literalen Text oder den Meta-Text als nicht-escapten Standard zu interpretieren.
Damit alles hübsch untereinander steht, wird als Füllzeichen das einfache Anführungszeichen benutzt. (welches, nebenbei gesagt, im Pascal-Programm als literal escaped werden muss). Im RegEx kann man es trotzdem anwenden, aber in der Ausgabe nicht unterscheiden. Auf die Niederungen des UTF-Codes habe ich mich nicht eingelassen, d.h. mit deutschen Spezialitäten äöüß funktioniert es nicht korrekt, weil das 2-Byte-Codes sind. Ebenso habe auf die Meldung verzichtet, wie man das Programm beenden kann, wir sind ja hier unter uns.
Das Prog.:
41650
Beispiel:

Code: Alles auswählen

Escape-Char: # literal=Standard? (j/n): j
Literaler Text ist Standard
         RegEx: a#bcd##e##f und#j#e#t#z#t#?!
Literaler Text: a''cd'#e'#f und''''''''''''!
      MetaText: ''b'''''''''''''j'e't'z't'?'

Escape-Char: # literal=Standard? (j/n): n
Literaler Text ist escaped
         RegEx: a#bcd##e##f und#j#e#t#z#t#?!
Literaler Text: ''b'''#''#''''''j'e't'z't'?'
      MetaText: a''cd''e''f und''''''''''''!

[Meillo]

Den dritten Teil des Kurses werde ich dann wieder zum Wochenende veroeffentlichen (also nach einer Woche Osterpause).

Nun aber mal zu den Aufgaben und Loesungen vom zweiten Teil.

Bei den Aufgaben 1 bis 3 gab's keine Probleme. Die waren klar.

Bei Aufgabe 4 gab es unterschiedliche Antworten. Huo hatte dann die richtige: viewtopic.php?t=183974&start=15#p1299872
Korrekt ist: Haaus
Das erste `a' ist noetig damit das zweite `a' als literales Zeichen interpraetiert wird. (Merke: zwei Escapezeichen hintereinander stehen immer fuer das Escapezeichen literal.)

Bei Aufgabe 5 waren die abgegebenen Loesungen beide korrekt.

Bei Aufgabe 6 im Prinzip auch, aber tegula hat einen Backslash zu viel, was vermutlich ein Vertipper war. Die Loesung von buhtz ist korrekt.

Aufgabe 7 war vielleicht zu offen formuliert und insgesamt etwas nervig, weil die ganzen Klammern mit der Zeit den Augen weh tun Meine Musterloesung:

Literale Zeichen sind die Standardzeichen.

(())()(()((()

Literal (, Literal ), Literal ), Metazeichen ), Literal (, Literal ), Literal (, Metazeichen )

Bei Aufgabe 8 gab's wieder ein bisschen mehr Unterschiede, wobei diese mehr aus der ungenauen Aufgabenbeschreibung herruehren. Am meisten meinen Erwartungen entsprochen hat die Loesung von Huo: viewtopic.php?t=183974&start=15#p1299886

Bei Aufgabe 9 ist Huos Programmausgabe gut: viewtopic.php?t=183974&start=45#p1299979
Vermutlich war ich nicht deutlich genug was ich mit ``beschreibe den Ausdruck'' gemeint habe. Ich hatte an eine solche Auflistung gedacht, ob jedes Zeichen literal oder als Metazeichen interpraetiert wird. Verstanden haben es die anderen inhaltlich wohl auch, sie haben nur andere Formen der Antwort gewaehlt.

Bei Aufgabe 10 waren die Antworten korrekt.

Bei Aufgabe 11 an sich auch, abgesehen von der anfaenglichen Verwirrung mit dem mit sich selbst escapten Escapezeichen, das dann kein Metazeichen wird, sondern sich selbst literal darstellt.

Bei Aufgabe 12 passt die Loesung von tegula: viewtopic.php?t=183974&start=15#p1299866


Danke auch fuer eure aktiven Programmierereien bei den Aufgaben 13 und 14!

Ich denke, dass die hilfreich sind, um damit die eigenen Loesungen der anderen Aufgaben zu pruefen. Das gilt eigentlich allgemein: Wenn man fuer ein Thema eine eigene Programmumsetzung schreibt, dann ist das sowohl eine gute Methode, um das eigene Verstaendnis zu pruefen, und man erlangt damit einen Kontrollmechanismus und wie eine zweite Perspektive auf die Aufgaben. Hier war es ja mit wenig Code moeglich.

Naeher angeschaut habe ich mir eure Programme nicht. Das koennt ihr auch gegenseitig tun. Mir ist es nur recht, wenn nicht alles an mir haengt. Bei der Erarbeitung der Loesungen zu den anderen Aufgaben hat das ja toll funktioniert.

Ich poste meine Umsetzung in C gleich auch noch.


Gibt es nun noch offene Fragen zu dieser Einheit oder den Aufgaben?

[Meillo]

Nachdem der Pastebin keine Dateien *.c annehmen wollte, poste ich sie kurzerhand direkt hier:

Zu 13)

Code: Alles auswählen

#include <stdio.h>

int
main(int argc, char *argv[])
{
        char *esc;
        int litdefault;
        int escaped;
        int c;

        if (argc != 3) {
                fprintf(stderr, "Usage: %s ESCAPE {M|L}\n", argv[0]);
                return 1;
        }

        esc = argv[1];
        if (esc[1] != '\0') {
                fprintf(stderr, "Escape character must be a single character\n");
                return 2;
        }
        litdefault = *argv[2] == 'L';

        while ((c=getchar()) != EOF) {
                if (c == *esc) {
                        printf("%s%c", esc, c);
                } else {
                        printf("%s%c", (litdefault ? "" : esc), c);
                }
        }
        putchar('\n');
        return 0;
}

Zu 14)

Code: Alles auswählen

#include <stdio.h>

int
main(int argc, char *argv[])
{
        char esc;
        int litdefault;
        int escaped;
        int c;

        if (argc != 3) {
                fprintf(stderr, "Usage: %s ESCAPE {M|L}\n", argv[0]);
                return 1;
        }

        esc = *argv[1];
        litdefault = *argv[2] == 'L';

        while ((c=getchar()) != EOF) {
                if (escaped) {
                        if (c == esc) {
                                printf("Literal %c\n", c);
                                escaped = 0;
                        } else {
                                printf("%s %c\n", (litdefault ? "Meta" : "Literal"), c);
                                escaped = 0;
                        }
                } else {
                        if (c == esc) {
                                escaped = 1;
                        } else {
                                printf("%s %c\n", (litdefault ? "Literal" : "Meta"), c);
                        }
                }
        }
        return 0;
}

Aufrufbeispiele fuer die Aufgaben 4 und 8:

Code: Alles auswählen

:-/ printf %s Haus | ./02-13 a L
Haaus

:-/ printf %s A,BCD,E,FG,,H | ./02-14 , L
Literal A
Meta B
Literal C
Literal D
Meta E
Meta F
Literal G
Literal ,
Literal H

[heisenberg]

IdRegExpKurs2022