10390.txt 0000644 0000764 0000144 00000000677 10167776200 013000 0 ustar markus users 0000000 0000000 Korrektheit: 10
Verwendbarkeit: 0
Programmierstil:4
Dokumentation:
Leider nicht objektorientiert. Ansonsten sehr gut
gelöst. Lobenswert ist die Exception EOF die sehr
passend ist.
Das Programm ist leider nicht in irgendeiner
Form wiederverwendbar. Vielleicht solltest du
einige Funktionen auslagern.
Der Programmierstil ist auch nicht gerade, was man sich
von einem so kurzen Programm erwarten kann. Kommentare
sind aber genug und passend.
10823.txt 0000644 0000764 0000144 00000000723 10167776635 013005 0 ustar markus users 0000000 0000000 Korrektheit: 10
Verwendbarkeit: 8
Programmierstil:4
Dokumentation:
Die Dokumentation ist sehr gut, aber auch kurz.
Leider nicht objektorientiert. Ansonsten sehr gut
gelöst. Lobenswert ist die Verwendung von vielen
Funktionen.
Einige Funktionen sind möglicherweise
wiederverwendbar. Trotzdem ist das Hauptprogramm
noch recht lang.
Der Programmierstil ist ok. Kommentare
sind aber genug und passend. Sehr gut ist, dass
die einzelne Funktionen kommentiert sind!
html/Parser.java 0000644 0000764 0000144 00000012064 10170005066 014604 0 ustar markus users 0000000 0000000 package html;
import eprog.*;
/**Htmlparser.
* Dieser Parser kann einen Teil von Html
* richtig erkennen. Die Formatierung wird
* einfach in einem String geschrieben.*/
public class Parser
{
// Private Variablen
private String formatstring;
private int state;
private int prevstate;
private int tablebegin;
private int spalten;
private int zeilen;
// state kann folgende Zustände annehmen
private final int NONE = 0;
private final int HTML = 1;
private final int H2 = 2;
private final int H3 = 3;
private final int H4 = 4;
private final int H5 = 5;
private final int HEAD = 10;
private final int TITLE = 11;
private final int BODY = 20;
private final int TABLE = 100;
private final int TBODY = 101;
private final int TR = 110;
private final int TD = 120;
private final int ATEND = 100000;
// Der Konstruktor
public Parser ()
{
state = NONE;
formatstring = "";
}
/* end gibt zurück, ob der Parser
* den Endtoken gefunden hat.*/
public boolean end ()
{
return state == ATEND;
}
/* Diese Funktion wird bei Token verwendet
* die öffnend sind.
* z.b.
* sate wird neu gesetzt und der Formatstring
* wird erweitert*/
public void begintoken (String Token) throws Exception
{
prevstate = state;
if (state == NONE && Token.equals("HTML"))
state = HTML;
else if (state == HTML && Token.equals ("HEAD"))
state = HEAD;
else if (state == HTML && Token.equals ("BODY"))
state = BODY;
else if ((state == BODY || state == TD) &&
Token.length()==2 && Token.charAt(0)=='h')
{
if (Token.charAt(1) == '2')
{
formatstring += "Text_sehr_gross";
state = H2;
}
else if (Token.charAt(1) == '3')
{
formatstring += "Text_gross";
state = H3;
}
else if (Token.charAt(1) == '4')
{
formatstring += "Text_mittel";
state = H4;
}
else if (Token.charAt(1) == '5')
{
formatstring += "Text_normal";
state = H5;
}
else throw new Exception ("Nicht definierte Überschrift!");
}
else if (state == BODY && Token.equals ("BR"))
formatstring += "\n";
else if (state == HEAD && Token.equals ("TITLE"))
{
formatstring += "Titel";
state = TITLE;
}
else if (state == BODY && Token.equals("TABLE"))
{
if (formatstring.length()>0 &&
! formatstring.endsWith("\n"))
formatstring += " ";
formatstring += "Tabelle ";
tablebegin = formatstring.length();
spalten = 0;
zeilen = 0;
state = TABLE;
}
else if(state == TABLE && Token.equals("TBODY"))
state = TBODY;
else if(state == TBODY && Token.equals("TR"))
{
spalten++;
state = TR;
} else if(state == TR && Token.equals("TD"))
{
zeilen++;
state = TD;
}
else throw new Exception ("Kann hier nicht aufgemacht werden: "
+ Token);
}
/* Hier wird bestimmt, was mit den Endtoken
* passieren soll. State wird wieder zurück
* gesetzt und der Formatstring wird angepasst*/
private void endtoken(String Token) throws Exception
{
if (state == HTML && Token.equals("HTML"))
{
if (formatstring.length()>0 &&
! formatstring.endsWith("\n"))
formatstring += " ";
formatstring += "Ende";
state = ATEND;
}
else if (state == HEAD && Token.equals("HEAD"))
state = HTML;
else if (state == BODY && Token.equals("BODY"))
state = HTML;
else if (Token.length() == 2 && Token.charAt(0) == 'h')
{
formatstring += ";";
if ( state == H2 && Token.charAt(1) == '2' ||
state == H3 && Token.charAt(1) == '3' ||
state == H4 && Token.charAt(1) == '4' ||
state == H5 && Token.charAt(1) == '5')
state = prevstate;
else throw new Exception ("Falsche Überschrift " +
"geschlossen h" + Token.charAt(1));
}
else if (state == TITLE && Token.equals ("TITLE"))
{
formatstring += ";";
state = HEAD;
}
else if (state == TD && Token.equals("TD"))
state = TR;
else if (state == TR && Token.equals("TR"))
state = TBODY;
else if (state == TBODY && Token.equals("TBODY"))
state = TABLE;
else if(state == TABLE && Token.equals("TABLE"))
{
String s1 = formatstring.substring(0, tablebegin);
s1+=spalten; s1+=" ";
s1+=zeilen; s1+=" ";
s1+=formatstring.substring(tablebegin);
;
formatstring = s1;
state = BODY;
} else throw new Exception ("Falsch zugemacht!");
}
/* Diese Funktion parst die Token aus dem String
* heraus. Da der String nur ein Token oder
* ein Wort beinhaltet ist die Funktion trivial.*/
public void parse (String str) throws Exception
{
if (str.charAt(0) == '<') // Token found!
{
String Token; // stores the Token
if (str.charAt(str.length()-1) != '>') // invalid Token
throw new Exception ("> nicht gefunden!");
if (str.charAt(1) == '/')
endtoken(str.substring(2,str.length()-1));
else
begintoken(str.substring(1,str.length()-1));
} else {
if ( state == TITLE ||
state >= H2 && state <= H5)
formatstring += " " + str;
}
}
/* Gibt den formatierten String zurück. Der Inhalt ist nur
* korrekt, wenn weder eine Exception geworfen wurde und
* end() true zurückgibt.*/
public String formated ()
{
return formatstring;
}
}
Main.java 0000644 0000764 0000144 00000001112 10170010500 013245 0 ustar markus users 0000000 0000000 import html.*;
import eprog.*;
class Main
{
public static void main (String [] argv)
{
Parser p = new Parser();
int laenge = 0;
String gelesen;
boolean fehler = false;
try
{
while (! p.end())
{
gelesen = EprogIO.readWord();
laenge += gelesen.length();
if (laenge > 300) // throw new Exception ("String zu lang");
fehler = true;
p.parse (gelesen);
}
} catch (Exception e)
{
fehler = true;
// EprogIO.println (e.toString());
}
if (fehler)
EprogIO.println ("FALSCHE EINGABE");
else
EprogIO.println (p.formated());
}
}
html.txt 0000644 0000764 0000144 00000001113 10170003612 013232 0 ustar markus users 0000000 0000000 html Parser
Author: Markus Raab
Dieser Parser ist eine straight-forward Implementierung
für HTML. Erweiterungen für weitere HTML Tags können
sehr leicht hinzugefügt werden. Man muß einfach einen
state für diesen Tag definieren und in begintoken()
und endtoken() definieren was bei diesen passieren soll.
Das Parsen an sich ist trivial, da Tags und Wörter
laut Definition nicht im selben String vorkommen
können. Deshalb muß nur überprüft werden, ob der
String mit '<' anfängt oder nicht.
formated() gibt dann den entstandenen String zurück.
Bei Fehler wird eine Exception geworfen.
Fr Jul 30 13:54:24 CEST 2021
