commit 89ee1e1beb8b3d49e1756530f6bc9da49287dbb7 Author: Humenius Date: Mon Apr 27 13:22:01 2020 +0200 Initial commit diff --git a/README.md b/README.md new file mode 100644 index 0000000..bf4484b --- /dev/null +++ b/README.md @@ -0,0 +1 @@ +Java diff --git a/ÜB-Praxis-JFlex Scanner für AS-Leer/.classpath b/ÜB-Praxis-JFlex Scanner für AS-Leer/.classpath new file mode 100644 index 0000000..b32c1c1 --- /dev/null +++ b/ÜB-Praxis-JFlex Scanner für AS-Leer/.classpath @@ -0,0 +1,8 @@ + + + + + + + + diff --git a/ÜB-Praxis-JFlex Scanner für AS-Leer/.externalToolBuilders/JFlex Ant AS [Builder].launch b/ÜB-Praxis-JFlex Scanner für AS-Leer/.externalToolBuilders/JFlex Ant AS [Builder].launch new file mode 100644 index 0000000..0f8180b --- /dev/null +++ b/ÜB-Praxis-JFlex Scanner für AS-Leer/.externalToolBuilders/JFlex Ant AS [Builder].launch @@ -0,0 +1,22 @@ + + + + + + + + + + + + + + + + + + + + + + diff --git a/ÜB-Praxis-JFlex Scanner für AS-Leer/.idea/.gitignore b/ÜB-Praxis-JFlex Scanner für AS-Leer/.idea/.gitignore new file mode 100644 index 0000000..73f69e0 --- /dev/null +++ b/ÜB-Praxis-JFlex Scanner für AS-Leer/.idea/.gitignore @@ -0,0 +1,8 @@ +# Default ignored files +/shelf/ +/workspace.xml +# Datasource local storage ignored files +/dataSources/ +/dataSources.local.xml +# Editor-based HTTP Client requests +/httpRequests/ diff --git a/ÜB-Praxis-JFlex Scanner für AS-Leer/.idea/ant.xml b/ÜB-Praxis-JFlex Scanner für AS-Leer/.idea/ant.xml new file mode 100644 index 0000000..362825d --- /dev/null +++ b/ÜB-Praxis-JFlex Scanner für AS-Leer/.idea/ant.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/ÜB-Praxis-JFlex Scanner für AS-Leer/.idea/libraries/lib.xml b/ÜB-Praxis-JFlex Scanner für AS-Leer/.idea/libraries/lib.xml new file mode 100644 index 0000000..fa8838a --- /dev/null +++ b/ÜB-Praxis-JFlex Scanner für AS-Leer/.idea/libraries/lib.xml @@ -0,0 +1,10 @@ + + + + + + + + + + \ No newline at end of file diff --git a/ÜB-Praxis-JFlex Scanner für AS-Leer/.idea/misc.xml b/ÜB-Praxis-JFlex Scanner für AS-Leer/.idea/misc.xml new file mode 100644 index 0000000..18e6fc0 --- /dev/null +++ b/ÜB-Praxis-JFlex Scanner für AS-Leer/.idea/misc.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/ÜB-Praxis-JFlex Scanner für AS-Leer/.idea/modules.xml b/ÜB-Praxis-JFlex Scanner für AS-Leer/.idea/modules.xml new file mode 100644 index 0000000..87e01f1 --- /dev/null +++ b/ÜB-Praxis-JFlex Scanner für AS-Leer/.idea/modules.xml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/ÜB-Praxis-JFlex Scanner für AS-Leer/.idea/vcs.xml b/ÜB-Praxis-JFlex Scanner für AS-Leer/.idea/vcs.xml new file mode 100644 index 0000000..94a25f7 --- /dev/null +++ b/ÜB-Praxis-JFlex Scanner für AS-Leer/.idea/vcs.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/ÜB-Praxis-JFlex Scanner für AS-Leer/.project b/ÜB-Praxis-JFlex Scanner für AS-Leer/.project new file mode 100644 index 0000000..17e56b3 --- /dev/null +++ b/ÜB-Praxis-JFlex Scanner für AS-Leer/.project @@ -0,0 +1,27 @@ + + + ÜB-Praxis-JFlex Scanner für AS-Leer + + + + + + org.eclipse.ui.externaltools.ExternalToolBuilder + + + LaunchConfigHandle + <project>/.externalToolBuilders/JFlex Ant AS [Builder].launch + + + + + org.eclipse.jdt.core.javabuilder + + + + + + pi.eclipse.cle.CupLexNature + org.eclipse.jdt.core.javanature + + diff --git a/ÜB-Praxis-JFlex Scanner für AS-Leer/.settings/org.eclipse.jdt.core.prefs b/ÜB-Praxis-JFlex Scanner für AS-Leer/.settings/org.eclipse.jdt.core.prefs new file mode 100644 index 0000000..7341ab1 --- /dev/null +++ b/ÜB-Praxis-JFlex Scanner für AS-Leer/.settings/org.eclipse.jdt.core.prefs @@ -0,0 +1,11 @@ +eclipse.preferences.version=1 +org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled +org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.7 +org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve +org.eclipse.jdt.core.compiler.compliance=1.7 +org.eclipse.jdt.core.compiler.debug.lineNumber=generate +org.eclipse.jdt.core.compiler.debug.localVariable=generate +org.eclipse.jdt.core.compiler.debug.sourceFile=generate +org.eclipse.jdt.core.compiler.problem.assertIdentifier=error +org.eclipse.jdt.core.compiler.problem.enumIdentifier=error +org.eclipse.jdt.core.compiler.source=1.7 diff --git a/ÜB-Praxis-JFlex Scanner für AS-Leer/.settings/pi.eclipse.cle.prefs b/ÜB-Praxis-JFlex Scanner für AS-Leer/.settings/pi.eclipse.cle.prefs new file mode 100644 index 0000000..48b3b42 --- /dev/null +++ b/ÜB-Praxis-JFlex Scanner für AS-Leer/.settings/pi.eclipse.cle.prefs @@ -0,0 +1,5 @@ +//src/de/dhbw/compiler/JFlexASScanner/JFlexASScanner.lex/lex-code-method=0 +//src/de/dhbw/compiler/JFlexASScanner/JFlexASScanner.lex/lex-comply-jlex=false +//src/de/dhbw/compiler/JFlexASScanner/JFlexASScanner.lex/lex-output=src +//src/de/dhbw/compiler/JFlexASScanner/JFlexASScanner.lex/lex-skip-min=false +eclipse.preferences.version=1 diff --git a/ÜB-Praxis-JFlex Scanner für AS-Leer/bin/de/dhbw/compiler/jflexasscanner/FracToken.class b/ÜB-Praxis-JFlex Scanner für AS-Leer/bin/de/dhbw/compiler/jflexasscanner/FracToken.class new file mode 100644 index 0000000..dee394c Binary files /dev/null and b/ÜB-Praxis-JFlex Scanner für AS-Leer/bin/de/dhbw/compiler/jflexasscanner/FracToken.class differ diff --git a/ÜB-Praxis-JFlex Scanner für AS-Leer/bin/de/dhbw/compiler/jflexasscanner/JFlexASScanner.class b/ÜB-Praxis-JFlex Scanner für AS-Leer/bin/de/dhbw/compiler/jflexasscanner/JFlexASScanner.class new file mode 100644 index 0000000..86ce69b Binary files /dev/null and b/ÜB-Praxis-JFlex Scanner für AS-Leer/bin/de/dhbw/compiler/jflexasscanner/JFlexASScanner.class differ diff --git a/ÜB-Praxis-JFlex Scanner für AS-Leer/bin/de/dhbw/compiler/jflexasscanner/JFlexASScannerMain.class b/ÜB-Praxis-JFlex Scanner für AS-Leer/bin/de/dhbw/compiler/jflexasscanner/JFlexASScannerMain.class new file mode 100644 index 0000000..908dab8 Binary files /dev/null and b/ÜB-Praxis-JFlex Scanner für AS-Leer/bin/de/dhbw/compiler/jflexasscanner/JFlexASScannerMain.class differ diff --git a/ÜB-Praxis-JFlex Scanner für AS-Leer/bin/de/dhbw/compiler/jflexasscanner/NumToken.class b/ÜB-Praxis-JFlex Scanner für AS-Leer/bin/de/dhbw/compiler/jflexasscanner/NumToken.class new file mode 100644 index 0000000..0d18168 Binary files /dev/null and b/ÜB-Praxis-JFlex Scanner für AS-Leer/bin/de/dhbw/compiler/jflexasscanner/NumToken.class differ diff --git a/ÜB-Praxis-JFlex Scanner für AS-Leer/bin/de/dhbw/compiler/jflexasscanner/StringToken.class b/ÜB-Praxis-JFlex Scanner für AS-Leer/bin/de/dhbw/compiler/jflexasscanner/StringToken.class new file mode 100644 index 0000000..b07c168 Binary files /dev/null and b/ÜB-Praxis-JFlex Scanner für AS-Leer/bin/de/dhbw/compiler/jflexasscanner/StringToken.class differ diff --git a/ÜB-Praxis-JFlex Scanner für AS-Leer/bin/de/dhbw/compiler/jflexasscanner/TestASScanner1.class b/ÜB-Praxis-JFlex Scanner für AS-Leer/bin/de/dhbw/compiler/jflexasscanner/TestASScanner1.class new file mode 100644 index 0000000..f954a21 Binary files /dev/null and b/ÜB-Praxis-JFlex Scanner für AS-Leer/bin/de/dhbw/compiler/jflexasscanner/TestASScanner1.class differ diff --git a/ÜB-Praxis-JFlex Scanner für AS-Leer/bin/de/dhbw/compiler/jflexasscanner/TestASScanner2.class b/ÜB-Praxis-JFlex Scanner für AS-Leer/bin/de/dhbw/compiler/jflexasscanner/TestASScanner2.class new file mode 100644 index 0000000..c43a693 Binary files /dev/null and b/ÜB-Praxis-JFlex Scanner für AS-Leer/bin/de/dhbw/compiler/jflexasscanner/TestASScanner2.class differ diff --git a/ÜB-Praxis-JFlex Scanner für AS-Leer/bin/de/dhbw/compiler/jflexasscanner/TestASScanner3.class b/ÜB-Praxis-JFlex Scanner für AS-Leer/bin/de/dhbw/compiler/jflexasscanner/TestASScanner3.class new file mode 100644 index 0000000..cf020e1 Binary files /dev/null and b/ÜB-Praxis-JFlex Scanner für AS-Leer/bin/de/dhbw/compiler/jflexasscanner/TestASScanner3.class differ diff --git a/ÜB-Praxis-JFlex Scanner für AS-Leer/bin/de/dhbw/compiler/jflexasscanner/TestASScanner4.class b/ÜB-Praxis-JFlex Scanner für AS-Leer/bin/de/dhbw/compiler/jflexasscanner/TestASScanner4.class new file mode 100644 index 0000000..8f6bb12 Binary files /dev/null and b/ÜB-Praxis-JFlex Scanner für AS-Leer/bin/de/dhbw/compiler/jflexasscanner/TestASScanner4.class differ diff --git a/ÜB-Praxis-JFlex Scanner für AS-Leer/bin/de/dhbw/compiler/jflexasscanner/TestASScanner5.class b/ÜB-Praxis-JFlex Scanner für AS-Leer/bin/de/dhbw/compiler/jflexasscanner/TestASScanner5.class new file mode 100644 index 0000000..324295d Binary files /dev/null and b/ÜB-Praxis-JFlex Scanner für AS-Leer/bin/de/dhbw/compiler/jflexasscanner/TestASScanner5.class differ diff --git a/ÜB-Praxis-JFlex Scanner für AS-Leer/bin/de/dhbw/compiler/jflexasscanner/TestsAll.class b/ÜB-Praxis-JFlex Scanner für AS-Leer/bin/de/dhbw/compiler/jflexasscanner/TestsAll.class new file mode 100644 index 0000000..5b44bed Binary files /dev/null and b/ÜB-Praxis-JFlex Scanner für AS-Leer/bin/de/dhbw/compiler/jflexasscanner/TestsAll.class differ diff --git a/ÜB-Praxis-JFlex Scanner für AS-Leer/bin/de/dhbw/compiler/jflexasscanner/Token.class b/ÜB-Praxis-JFlex Scanner für AS-Leer/bin/de/dhbw/compiler/jflexasscanner/Token.class new file mode 100644 index 0000000..70f35c5 Binary files /dev/null and b/ÜB-Praxis-JFlex Scanner für AS-Leer/bin/de/dhbw/compiler/jflexasscanner/Token.class differ diff --git a/ÜB-Praxis-JFlex Scanner für AS-Leer/bin/de/dhbw/compiler/jflexasscanner/TokenStreamTest.class b/ÜB-Praxis-JFlex Scanner für AS-Leer/bin/de/dhbw/compiler/jflexasscanner/TokenStreamTest.class new file mode 100644 index 0000000..2120f9d Binary files /dev/null and b/ÜB-Praxis-JFlex Scanner für AS-Leer/bin/de/dhbw/compiler/jflexasscanner/TokenStreamTest.class differ diff --git a/ÜB-Praxis-JFlex Scanner für AS-Leer/lib/hamcrest-all-1.3.jar b/ÜB-Praxis-JFlex Scanner für AS-Leer/lib/hamcrest-all-1.3.jar new file mode 100644 index 0000000..6f62ba0 Binary files /dev/null and b/ÜB-Praxis-JFlex Scanner für AS-Leer/lib/hamcrest-all-1.3.jar differ diff --git a/ÜB-Praxis-JFlex Scanner für AS-Leer/lib/jflex-1.6.1.jar b/ÜB-Praxis-JFlex Scanner für AS-Leer/lib/jflex-1.6.1.jar new file mode 100644 index 0000000..001e0e5 Binary files /dev/null and b/ÜB-Praxis-JFlex Scanner für AS-Leer/lib/jflex-1.6.1.jar differ diff --git a/ÜB-Praxis-JFlex Scanner für AS-Leer/lib/jflexant.xml b/ÜB-Praxis-JFlex Scanner für AS-Leer/lib/jflexant.xml new file mode 100644 index 0000000..e277a1a --- /dev/null +++ b/ÜB-Praxis-JFlex Scanner für AS-Leer/lib/jflexant.xml @@ -0,0 +1,13 @@ + + + + Generate Scanner from lex-files + + + + + + + + + \ No newline at end of file diff --git a/ÜB-Praxis-JFlex Scanner für AS-Leer/src/de/dhbw/compiler/jflexasscanner/FracToken.java b/ÜB-Praxis-JFlex Scanner für AS-Leer/src/de/dhbw/compiler/jflexasscanner/FracToken.java new file mode 100644 index 0000000..ffb87e1 --- /dev/null +++ b/ÜB-Praxis-JFlex Scanner für AS-Leer/src/de/dhbw/compiler/jflexasscanner/FracToken.java @@ -0,0 +1,28 @@ +/* ********************************************** + * Duale Hochschule Baden-Württemberg Karlsruhe + * Prof. Dr. Jörn Eisenbiegler + * + * Vorlesung Übersetzerbau + * Praxis AS-Scanner mit JFlex + * - Token-Definition frac + * + * ********************************************** + */ + +package de.dhbw.compiler.jflexasscanner; + +public class FracToken extends Token { + + private double value; + + public FracToken(int type, String text, int line, int column, double value) { + super(type,text,line,column); + this.value = value; + } + + double getValue() { + return value; + } + + +} diff --git a/ÜB-Praxis-JFlex Scanner für AS-Leer/src/de/dhbw/compiler/jflexasscanner/JFlexASScanner.flex b/ÜB-Praxis-JFlex Scanner für AS-Leer/src/de/dhbw/compiler/jflexasscanner/JFlexASScanner.flex new file mode 100644 index 0000000..8d3f1c1 --- /dev/null +++ b/ÜB-Praxis-JFlex Scanner für AS-Leer/src/de/dhbw/compiler/jflexasscanner/JFlexASScanner.flex @@ -0,0 +1,54 @@ +/* ********************************************** + * Duale Hochschule Baden-Württemberg Karlsruhe + * Prof. Dr. Jörn Eisenbiegler + * + * Vorlesung Übersetzerbau + * Praxis AS-Scanner mit JFlex 4 + * + * ********************************************** + */ + +package de.dhbw.compiler.jflexasscanner; + +%% + +%class JFlexASScanner +%function nextToken +%type Token + +%unicode +%line +%column +%public +%final + +%xstate NUM, FRAC, EXP, STR, NULL + +WhiteSpace = [ \t\b\r\n]+ +SmallChars = [a-z]+ +CapitalChars = [A-Z]+ +Numbers = [0-9]+ +AllChars = [a-zA-Z0-9]+ + + +%{ +%} + +%eofval{ + return new Token(Token.EOF, "", yyline+1, yycolumn+1); +%eofval} + +%% +//[^] { return new Token(Token.INVALID, yytext(), yyline+1, yycolumn+1); } +"null" { return new Token(Token.NULL, yytext(), yyline+1, yycolumn+1); } +{Numbers} { return new Token(Token.NUM, yytext(), yyline+1, yycolumn+1); } +{AllChars} { return new Token(Token.ID, yytext(), yyline+1, yycolumn+1); } +[\[] { return new Token(Token.LSBR, yytext(), yyline+1, yycolumn+1); } +[\]] { return new Token(Token.RSBR, yytext(), yyline+1, yycolumn+1); } +[,] { return new Token(Token.COMMA, yytext(), yyline+1, yycolumn+1); } +{WhiteSpace} { /* Ignore */ } +[^] { return new Token(Token.INVALID, yytext(), yyline+1, yycolumn+1); + /*throw new Error("Illegal character <" + yytext() + ">"); */} + + + diff --git a/ÜB-Praxis-JFlex Scanner für AS-Leer/src/de/dhbw/compiler/jflexasscanner/JFlexASScanner.java b/ÜB-Praxis-JFlex Scanner für AS-Leer/src/de/dhbw/compiler/jflexasscanner/JFlexASScanner.java new file mode 100644 index 0000000..cdfcec6 --- /dev/null +++ b/ÜB-Praxis-JFlex Scanner für AS-Leer/src/de/dhbw/compiler/jflexasscanner/JFlexASScanner.java @@ -0,0 +1,659 @@ +/* The following code was generated by JFlex 1.6.1 */ + +/* ********************************************** + * Duale Hochschule Baden-Württemberg Karlsruhe + * Prof. Dr. Jörn Eisenbiegler + * + * Vorlesung Übersetzerbau + * Praxis AS-Scanner mit JFlex 4 + * + * ********************************************** + */ + +package de.dhbw.compiler.jflexasscanner; + + +/** + * This class is a scanner generated by + * JFlex 1.6.1 + * from the specification file C:/Development/Schule/Java/ÜB-Praxis-JFlex Scanner für AS-Leer/src/de/dhbw/compiler/jflexasscanner/JFlexASScanner.flex + */ +public final class JFlexASScanner { + + /** This character denotes the end of file */ + public static final int YYEOF = -1; + + /** initial size of the lookahead buffer */ + private static final int ZZ_BUFFERSIZE = 16384; + + /** lexical states */ + public static final int YYINITIAL = 0; + public static final int NUM = 2; + public static final int FRAC = 4; + public static final int EXP = 6; + public static final int STR = 8; + public static final int NULL = 10; + + /** + * ZZ_LEXSTATE[l] is the state in the DFA for the lexical state l + * ZZ_LEXSTATE[l+1] is the state in the DFA for the lexical state l + * at the beginning of a line + * l is of the form l = 2*k, k a non negative integer + */ + private static final int ZZ_LEXSTATE[] = { + 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 + }; + + /** + * Translates characters to character classes + */ + private static final String ZZ_CMAP_PACKED = + "\10\0\3\1\2\0\1\1\22\0\1\1\13\0\1\11\3\0\12\3"+ + "\7\0\32\2\1\7\1\0\1\10\3\0\13\2\1\6\1\2\1\4"+ + "\6\2\1\5\5\2\uffff\0\uffff\0\uffff\0\uffff\0\uffff\0\uffff\0\uffff\0\uffff\0\uffff\0\uffff\0\uffff\0\uffff\0\uffff\0\uffff\0\uffff\0\uffff\0\uff95\0"; + + /** + * Translates characters to character classes + */ + private static final char [] ZZ_CMAP = zzUnpackCMap(ZZ_CMAP_PACKED); + + /** + * Translates DFA states to action switch labels. + */ + private static final int [] ZZ_ACTION = zzUnpackAction(); + + private static final String ZZ_ACTION_PACKED_0 = + "\2\0\1\1\1\2\1\3\1\4\1\3\1\5\1\6"+ + "\1\7\2\3\1\10"; + + private static int [] zzUnpackAction() { + int [] result = new int[13]; + int offset = 0; + offset = zzUnpackAction(ZZ_ACTION_PACKED_0, offset, result); + return result; + } + + private static int zzUnpackAction(String packed, int offset, int [] result) { + int i = 0; /* index in packed string */ + int j = offset; /* index in unpacked array */ + int l = packed.length(); + while (i < l) { + int count = packed.charAt(i++); + int value = packed.charAt(i++); + do result[j++] = value; while (--count > 0); + } + return j; + } + + + /** + * Translates a state to a row index in the transition table + */ + private static final int [] ZZ_ROWMAP = zzUnpackRowMap(); + + private static final String ZZ_ROWMAP_PACKED_0 = + "\0\0\0\12\0\12\0\24\0\36\0\50\0\62\0\12"+ + "\0\12\0\12\0\74\0\106\0\36"; + + private static int [] zzUnpackRowMap() { + int [] result = new int[13]; + int offset = 0; + offset = zzUnpackRowMap(ZZ_ROWMAP_PACKED_0, offset, result); + return result; + } + + private static int zzUnpackRowMap(String packed, int offset, int [] result) { + int i = 0; /* index in packed string */ + int j = offset; /* index in unpacked array */ + int l = packed.length(); + while (i < l) { + int high = packed.charAt(i++) << 16; + result[j++] = high | packed.charAt(i++); + } + return j; + } + + /** + * The transition table of the DFA + */ + private static final int [] ZZ_TRANS = zzUnpackTrans(); + + private static final String ZZ_TRANS_PACKED_0 = + "\1\3\1\4\1\5\1\6\1\7\2\5\1\10\1\11"+ + "\1\12\13\0\1\4\12\0\5\5\5\0\1\5\1\6"+ + "\3\5\5\0\3\5\1\13\1\5\5\0\4\5\1\14"+ + "\5\0\4\5\1\15\3\0"; + + private static int [] zzUnpackTrans() { + int [] result = new int[80]; + int offset = 0; + offset = zzUnpackTrans(ZZ_TRANS_PACKED_0, offset, result); + return result; + } + + private static int zzUnpackTrans(String packed, int offset, int [] result) { + int i = 0; /* index in packed string */ + int j = offset; /* index in unpacked array */ + int l = packed.length(); + while (i < l) { + int count = packed.charAt(i++); + int value = packed.charAt(i++); + value--; + do result[j++] = value; while (--count > 0); + } + return j; + } + + + /* error codes */ + private static final int ZZ_UNKNOWN_ERROR = 0; + private static final int ZZ_NO_MATCH = 1; + private static final int ZZ_PUSHBACK_2BIG = 2; + + /* error messages for the codes above */ + private static final String ZZ_ERROR_MSG[] = { + "Unknown internal scanner error", + "Error: could not match input", + "Error: pushback value was too large" + }; + + /** + * ZZ_ATTRIBUTE[aState] contains the attributes of state aState + */ + private static final int [] ZZ_ATTRIBUTE = zzUnpackAttribute(); + + private static final String ZZ_ATTRIBUTE_PACKED_0 = + "\1\0\1\10\1\11\4\1\3\11\3\1"; + + private static int [] zzUnpackAttribute() { + int [] result = new int[13]; + int offset = 0; + offset = zzUnpackAttribute(ZZ_ATTRIBUTE_PACKED_0, offset, result); + return result; + } + + private static int zzUnpackAttribute(String packed, int offset, int [] result) { + int i = 0; /* index in packed string */ + int j = offset; /* index in unpacked array */ + int l = packed.length(); + while (i < l) { + int count = packed.charAt(i++); + int value = packed.charAt(i++); + do result[j++] = value; while (--count > 0); + } + return j; + } + + /** the input device */ + private java.io.Reader zzReader; + + /** the current state of the DFA */ + private int zzState; + + /** the current lexical state */ + private int zzLexicalState = YYINITIAL; + + /** this buffer contains the current text to be matched and is + the source of the yytext() string */ + private char zzBuffer[] = new char[ZZ_BUFFERSIZE]; + + /** the textposition at the last accepting state */ + private int zzMarkedPos; + + /** the current text position in the buffer */ + private int zzCurrentPos; + + /** startRead marks the beginning of the yytext() string in the buffer */ + private int zzStartRead; + + /** endRead marks the last character in the buffer, that has been read + from input */ + private int zzEndRead; + + /** number of newlines encountered up to the start of the matched text */ + private int yyline; + + /** the number of characters up to the start of the matched text */ + private int yychar; + + /** + * the number of characters from the last newline up to the start of the + * matched text + */ + private int yycolumn; + + /** + * zzAtBOL == true <=> the scanner is currently at the beginning of a line + */ + private boolean zzAtBOL = true; + + /** zzAtEOF == true <=> the scanner is at the EOF */ + private boolean zzAtEOF; + + /** denotes if the user-EOF-code has already been executed */ + private boolean zzEOFDone; + + /** + * The number of occupied positions in zzBuffer beyond zzEndRead. + * When a lead/high surrogate has been read from the input stream + * into the final zzBuffer position, this will have a value of 1; + * otherwise, it will have a value of 0. + */ + private int zzFinalHighSurrogate = 0; + + /* user code: */ + + + /** + * Creates a new scanner + * + * @param in the java.io.Reader to read input from. + */ + public JFlexASScanner(java.io.Reader in) { + this.zzReader = in; + } + + + /** + * Unpacks the compressed character translation table. + * + * @param packed the packed character translation table + * @return the unpacked character translation table + */ + private static char [] zzUnpackCMap(String packed) { + char [] map = new char[0x110000]; + int i = 0; /* index in packed string */ + int j = 0; /* index in unpacked array */ + while (i < 80) { + int count = packed.charAt(i++); + char value = packed.charAt(i++); + do map[j++] = value; while (--count > 0); + } + return map; + } + + + /** + * Refills the input buffer. + * + * @return false, iff there was new input. + * + * @exception java.io.IOException if any I/O-Error occurs + */ + private boolean zzRefill() throws java.io.IOException { + + /* first: make room (if you can) */ + if (zzStartRead > 0) { + zzEndRead += zzFinalHighSurrogate; + zzFinalHighSurrogate = 0; + System.arraycopy(zzBuffer, zzStartRead, + zzBuffer, 0, + zzEndRead-zzStartRead); + + /* translate stored positions */ + zzEndRead-= zzStartRead; + zzCurrentPos-= zzStartRead; + zzMarkedPos-= zzStartRead; + zzStartRead = 0; + } + + /* is the buffer big enough? */ + if (zzCurrentPos >= zzBuffer.length - zzFinalHighSurrogate) { + /* if not: blow it up */ + char newBuffer[] = new char[zzBuffer.length*2]; + System.arraycopy(zzBuffer, 0, newBuffer, 0, zzBuffer.length); + zzBuffer = newBuffer; + zzEndRead += zzFinalHighSurrogate; + zzFinalHighSurrogate = 0; + } + + /* fill the buffer with new input */ + int requested = zzBuffer.length - zzEndRead; + int numRead = zzReader.read(zzBuffer, zzEndRead, requested); + + /* not supposed to occur according to specification of java.io.Reader */ + if (numRead == 0) { + throw new java.io.IOException("Reader returned 0 characters. See JFlex examples for workaround."); + } + if (numRead > 0) { + zzEndRead += numRead; + /* If numRead == requested, we might have requested to few chars to + encode a full Unicode character. We assume that a Reader would + otherwise never return half characters. */ + if (numRead == requested) { + if (Character.isHighSurrogate(zzBuffer[zzEndRead - 1])) { + --zzEndRead; + zzFinalHighSurrogate = 1; + } + } + /* potentially more input available */ + return false; + } + + /* numRead < 0 ==> end of stream */ + return true; + } + + + /** + * Closes the input stream. + */ + public final void yyclose() throws java.io.IOException { + zzAtEOF = true; /* indicate end of file */ + zzEndRead = zzStartRead; /* invalidate buffer */ + + if (zzReader != null) + zzReader.close(); + } + + + /** + * Resets the scanner to read from a new input stream. + * Does not close the old reader. + * + * All internal variables are reset, the old input stream + * cannot be reused (internal buffer is discarded and lost). + * Lexical state is set to ZZ_INITIAL. + * + * Internal scan buffer is resized down to its initial length, if it has grown. + * + * @param reader the new input stream + */ + public final void yyreset(java.io.Reader reader) { + zzReader = reader; + zzAtBOL = true; + zzAtEOF = false; + zzEOFDone = false; + zzEndRead = zzStartRead = 0; + zzCurrentPos = zzMarkedPos = 0; + zzFinalHighSurrogate = 0; + yyline = yychar = yycolumn = 0; + zzLexicalState = YYINITIAL; + if (zzBuffer.length > ZZ_BUFFERSIZE) + zzBuffer = new char[ZZ_BUFFERSIZE]; + } + + + /** + * Returns the current lexical state. + */ + public final int yystate() { + return zzLexicalState; + } + + + /** + * Enters a new lexical state + * + * @param newState the new lexical state + */ + public final void yybegin(int newState) { + zzLexicalState = newState; + } + + + /** + * Returns the text matched by the current regular expression. + */ + public final String yytext() { + return new String( zzBuffer, zzStartRead, zzMarkedPos-zzStartRead ); + } + + + /** + * Returns the character at position pos from the + * matched text. + * + * It is equivalent to yytext().charAt(pos), but faster + * + * @param pos the position of the character to fetch. + * A value from 0 to yylength()-1. + * + * @return the character at position pos + */ + public final char yycharat(int pos) { + return zzBuffer[zzStartRead+pos]; + } + + + /** + * Returns the length of the matched text region. + */ + public final int yylength() { + return zzMarkedPos-zzStartRead; + } + + + /** + * Reports an error that occured while scanning. + * + * In a wellformed scanner (no or only correct usage of + * yypushback(int) and a match-all fallback rule) this method + * will only be called with things that "Can't Possibly Happen". + * If this method is called, something is seriously wrong + * (e.g. a JFlex bug producing a faulty scanner etc.). + * + * Usual syntax/scanner level error handling should be done + * in error fallback rules. + * + * @param errorCode the code of the errormessage to display + */ + private void zzScanError(int errorCode) { + String message; + try { + message = ZZ_ERROR_MSG[errorCode]; + } + catch (ArrayIndexOutOfBoundsException e) { + message = ZZ_ERROR_MSG[ZZ_UNKNOWN_ERROR]; + } + + throw new Error(message); + } + + + /** + * Pushes the specified amount of characters back into the input stream. + * + * They will be read again by then next call of the scanning method + * + * @param number the number of characters to be read again. + * This number must not be greater than yylength()! + */ + public void yypushback(int number) { + if ( number > yylength() ) + zzScanError(ZZ_PUSHBACK_2BIG); + + zzMarkedPos -= number; + } + + + /** + * Resumes scanning until the next regular expression is matched, + * the end of input is encountered or an I/O-Error occurs. + * + * @return the next token + * @exception java.io.IOException if any I/O-Error occurs + */ + public Token nextToken() throws java.io.IOException { + int zzInput; + int zzAction; + + // cached fields: + int zzCurrentPosL; + int zzMarkedPosL; + int zzEndReadL = zzEndRead; + char [] zzBufferL = zzBuffer; + char [] zzCMapL = ZZ_CMAP; + + int [] zzTransL = ZZ_TRANS; + int [] zzRowMapL = ZZ_ROWMAP; + int [] zzAttrL = ZZ_ATTRIBUTE; + + while (true) { + zzMarkedPosL = zzMarkedPos; + + boolean zzR = false; + int zzCh; + int zzCharCount; + for (zzCurrentPosL = zzStartRead ; + zzCurrentPosL < zzMarkedPosL ; + zzCurrentPosL += zzCharCount ) { + zzCh = Character.codePointAt(zzBufferL, zzCurrentPosL, zzMarkedPosL); + zzCharCount = Character.charCount(zzCh); + switch (zzCh) { + case '\u000B': + case '\u000C': + case '\u0085': + case '\u2028': + case '\u2029': + yyline++; + yycolumn = 0; + zzR = false; + break; + case '\r': + yyline++; + yycolumn = 0; + zzR = true; + break; + case '\n': + if (zzR) + zzR = false; + else { + yyline++; + yycolumn = 0; + } + break; + default: + zzR = false; + yycolumn += zzCharCount; + } + } + + if (zzR) { + // peek one character ahead if it is \n (if we have counted one line too much) + boolean zzPeek; + if (zzMarkedPosL < zzEndReadL) + zzPeek = zzBufferL[zzMarkedPosL] == '\n'; + else if (zzAtEOF) + zzPeek = false; + else { + boolean eof = zzRefill(); + zzEndReadL = zzEndRead; + zzMarkedPosL = zzMarkedPos; + zzBufferL = zzBuffer; + if (eof) + zzPeek = false; + else + zzPeek = zzBufferL[zzMarkedPosL] == '\n'; + } + if (zzPeek) yyline--; + } + zzAction = -1; + + zzCurrentPosL = zzCurrentPos = zzStartRead = zzMarkedPosL; + + zzState = ZZ_LEXSTATE[zzLexicalState]; + + // set up zzAction for empty match case: + int zzAttributes = zzAttrL[zzState]; + if ( (zzAttributes & 1) == 1 ) { + zzAction = zzState; + } + + + zzForAction: { + while (true) { + + if (zzCurrentPosL < zzEndReadL) { + zzInput = Character.codePointAt(zzBufferL, zzCurrentPosL, zzEndReadL); + zzCurrentPosL += Character.charCount(zzInput); + } + else if (zzAtEOF) { + zzInput = YYEOF; + break zzForAction; + } + else { + // store back cached positions + zzCurrentPos = zzCurrentPosL; + zzMarkedPos = zzMarkedPosL; + boolean eof = zzRefill(); + // get translated positions and possibly new buffer + zzCurrentPosL = zzCurrentPos; + zzMarkedPosL = zzMarkedPos; + zzBufferL = zzBuffer; + zzEndReadL = zzEndRead; + if (eof) { + zzInput = YYEOF; + break zzForAction; + } + else { + zzInput = Character.codePointAt(zzBufferL, zzCurrentPosL, zzEndReadL); + zzCurrentPosL += Character.charCount(zzInput); + } + } + int zzNext = zzTransL[ zzRowMapL[zzState] + zzCMapL[zzInput] ]; + if (zzNext == -1) break zzForAction; + zzState = zzNext; + + zzAttributes = zzAttrL[zzState]; + if ( (zzAttributes & 1) == 1 ) { + zzAction = zzState; + zzMarkedPosL = zzCurrentPosL; + if ( (zzAttributes & 8) == 8 ) break zzForAction; + } + + } + } + + // store back cached position + zzMarkedPos = zzMarkedPosL; + + if (zzInput == YYEOF && zzStartRead == zzCurrentPos) { + zzAtEOF = true; + { return new Token(Token.EOF, "", yyline+1, yycolumn+1); + } + } + else { + switch (zzAction < 0 ? zzAction : ZZ_ACTION[zzAction]) { + case 1: + { return new Token(Token.INVALID, yytext(), yyline+1, yycolumn+1); + /*throw new Error("Illegal character <" + yytext() + ">"); */ + } + case 9: break; + case 2: + { /* Ignore */ + } + case 10: break; + case 3: + { return new Token(Token.ID, yytext(), yyline+1, yycolumn+1); + } + case 11: break; + case 4: + { return new Token(Token.NUM, yytext(), yyline+1, yycolumn+1); + } + case 12: break; + case 5: + { return new Token(Token.LSBR, yytext(), yyline+1, yycolumn+1); + } + case 13: break; + case 6: + { return new Token(Token.RSBR, yytext(), yyline+1, yycolumn+1); + } + case 14: break; + case 7: + { return new Token(Token.COMMA, yytext(), yyline+1, yycolumn+1); + } + case 15: break; + case 8: + { return new Token(Token.NULL, yytext(), yyline+1, yycolumn+1); + } + case 16: break; + default: + zzScanError(ZZ_NO_MATCH); + } + } + } + } + + +} diff --git a/ÜB-Praxis-JFlex Scanner für AS-Leer/src/de/dhbw/compiler/jflexasscanner/JFlexASScanner.java~ b/ÜB-Praxis-JFlex Scanner für AS-Leer/src/de/dhbw/compiler/jflexasscanner/JFlexASScanner.java~ new file mode 100644 index 0000000..1e1efe7 --- /dev/null +++ b/ÜB-Praxis-JFlex Scanner für AS-Leer/src/de/dhbw/compiler/jflexasscanner/JFlexASScanner.java~ @@ -0,0 +1,658 @@ +/* The following code was generated by JFlex 1.6.1 */ + +/* ********************************************** + * Duale Hochschule Baden-Württemberg Karlsruhe + * Prof. Dr. Jörn Eisenbiegler + * + * Vorlesung Übersetzerbau + * Praxis AS-Scanner mit JFlex 4 + * + * ********************************************** + */ + +package de.dhbw.compiler.jflexasscanner; + + +/** + * This class is a scanner generated by + * JFlex 1.6.1 + * from the specification file C:/Development/Schule/Java/ÜB-Praxis-JFlex Scanner für AS-Leer/src/de/dhbw/compiler/jflexasscanner/JFlexASScanner.flex + */ +public final class JFlexASScanner { + + /** This character denotes the end of file */ + public static final int YYEOF = -1; + + /** initial size of the lookahead buffer */ + private static final int ZZ_BUFFERSIZE = 16384; + + /** lexical states */ + public static final int YYINITIAL = 0; + public static final int NUM = 2; + public static final int FRAC = 4; + public static final int EXP = 6; + public static final int STR = 8; + public static final int NULL = 10; + + /** + * ZZ_LEXSTATE[l] is the state in the DFA for the lexical state l + * ZZ_LEXSTATE[l+1] is the state in the DFA for the lexical state l + * at the beginning of a line + * l is of the form l = 2*k, k a non negative integer + */ + private static final int ZZ_LEXSTATE[] = { + 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 + }; + + /** + * Translates characters to character classes + */ + private static final String ZZ_CMAP_PACKED = + "\10\0\3\1\2\0\1\1\22\0\1\1\13\0\1\11\3\0\12\3"+ + "\7\0\32\2\1\7\1\0\1\10\3\0\13\2\1\6\1\2\1\4"+ + "\6\2\1\5\5\2\uffff\0\uffff\0\uffff\0\uffff\0\uffff\0\uffff\0\uffff\0\uffff\0\uffff\0\uffff\0\uffff\0\uffff\0\uffff\0\uffff\0\uffff\0\uffff\0\uff95\0"; + + /** + * Translates characters to character classes + */ + private static final char [] ZZ_CMAP = zzUnpackCMap(ZZ_CMAP_PACKED); + + /** + * Translates DFA states to action switch labels. + */ + private static final int [] ZZ_ACTION = zzUnpackAction(); + + private static final String ZZ_ACTION_PACKED_0 = + "\2\0\1\1\1\2\1\3\1\4\1\3\1\5\1\6"+ + "\1\7\2\3\1\10"; + + private static int [] zzUnpackAction() { + int [] result = new int[13]; + int offset = 0; + offset = zzUnpackAction(ZZ_ACTION_PACKED_0, offset, result); + return result; + } + + private static int zzUnpackAction(String packed, int offset, int [] result) { + int i = 0; /* index in packed string */ + int j = offset; /* index in unpacked array */ + int l = packed.length(); + while (i < l) { + int count = packed.charAt(i++); + int value = packed.charAt(i++); + do result[j++] = value; while (--count > 0); + } + return j; + } + + + /** + * Translates a state to a row index in the transition table + */ + private static final int [] ZZ_ROWMAP = zzUnpackRowMap(); + + private static final String ZZ_ROWMAP_PACKED_0 = + "\0\0\0\12\0\12\0\24\0\36\0\50\0\62\0\12"+ + "\0\12\0\12\0\74\0\106\0\36"; + + private static int [] zzUnpackRowMap() { + int [] result = new int[13]; + int offset = 0; + offset = zzUnpackRowMap(ZZ_ROWMAP_PACKED_0, offset, result); + return result; + } + + private static int zzUnpackRowMap(String packed, int offset, int [] result) { + int i = 0; /* index in packed string */ + int j = offset; /* index in unpacked array */ + int l = packed.length(); + while (i < l) { + int high = packed.charAt(i++) << 16; + result[j++] = high | packed.charAt(i++); + } + return j; + } + + /** + * The transition table of the DFA + */ + private static final int [] ZZ_TRANS = zzUnpackTrans(); + + private static final String ZZ_TRANS_PACKED_0 = + "\1\3\1\4\1\5\1\6\1\7\2\5\1\10\1\11"+ + "\1\12\13\0\1\4\12\0\5\5\5\0\1\5\1\6"+ + "\3\5\5\0\3\5\1\13\1\5\5\0\4\5\1\14"+ + "\5\0\4\5\1\15\3\0"; + + private static int [] zzUnpackTrans() { + int [] result = new int[80]; + int offset = 0; + offset = zzUnpackTrans(ZZ_TRANS_PACKED_0, offset, result); + return result; + } + + private static int zzUnpackTrans(String packed, int offset, int [] result) { + int i = 0; /* index in packed string */ + int j = offset; /* index in unpacked array */ + int l = packed.length(); + while (i < l) { + int count = packed.charAt(i++); + int value = packed.charAt(i++); + value--; + do result[j++] = value; while (--count > 0); + } + return j; + } + + + /* error codes */ + private static final int ZZ_UNKNOWN_ERROR = 0; + private static final int ZZ_NO_MATCH = 1; + private static final int ZZ_PUSHBACK_2BIG = 2; + + /* error messages for the codes above */ + private static final String ZZ_ERROR_MSG[] = { + "Unknown internal scanner error", + "Error: could not match input", + "Error: pushback value was too large" + }; + + /** + * ZZ_ATTRIBUTE[aState] contains the attributes of state aState + */ + private static final int [] ZZ_ATTRIBUTE = zzUnpackAttribute(); + + private static final String ZZ_ATTRIBUTE_PACKED_0 = + "\1\0\1\10\1\11\4\1\3\11\3\1"; + + private static int [] zzUnpackAttribute() { + int [] result = new int[13]; + int offset = 0; + offset = zzUnpackAttribute(ZZ_ATTRIBUTE_PACKED_0, offset, result); + return result; + } + + private static int zzUnpackAttribute(String packed, int offset, int [] result) { + int i = 0; /* index in packed string */ + int j = offset; /* index in unpacked array */ + int l = packed.length(); + while (i < l) { + int count = packed.charAt(i++); + int value = packed.charAt(i++); + do result[j++] = value; while (--count > 0); + } + return j; + } + + /** the input device */ + private java.io.Reader zzReader; + + /** the current state of the DFA */ + private int zzState; + + /** the current lexical state */ + private int zzLexicalState = YYINITIAL; + + /** this buffer contains the current text to be matched and is + the source of the yytext() string */ + private char zzBuffer[] = new char[ZZ_BUFFERSIZE]; + + /** the textposition at the last accepting state */ + private int zzMarkedPos; + + /** the current text position in the buffer */ + private int zzCurrentPos; + + /** startRead marks the beginning of the yytext() string in the buffer */ + private int zzStartRead; + + /** endRead marks the last character in the buffer, that has been read + from input */ + private int zzEndRead; + + /** number of newlines encountered up to the start of the matched text */ + private int yyline; + + /** the number of characters up to the start of the matched text */ + private int yychar; + + /** + * the number of characters from the last newline up to the start of the + * matched text + */ + private int yycolumn; + + /** + * zzAtBOL == true <=> the scanner is currently at the beginning of a line + */ + private boolean zzAtBOL = true; + + /** zzAtEOF == true <=> the scanner is at the EOF */ + private boolean zzAtEOF; + + /** denotes if the user-EOF-code has already been executed */ + private boolean zzEOFDone; + + /** + * The number of occupied positions in zzBuffer beyond zzEndRead. + * When a lead/high surrogate has been read from the input stream + * into the final zzBuffer position, this will have a value of 1; + * otherwise, it will have a value of 0. + */ + private int zzFinalHighSurrogate = 0; + + /* user code: */ + + + /** + * Creates a new scanner + * + * @param in the java.io.Reader to read input from. + */ + public JFlexASScanner(java.io.Reader in) { + this.zzReader = in; + } + + + /** + * Unpacks the compressed character translation table. + * + * @param packed the packed character translation table + * @return the unpacked character translation table + */ + private static char [] zzUnpackCMap(String packed) { + char [] map = new char[0x110000]; + int i = 0; /* index in packed string */ + int j = 0; /* index in unpacked array */ + while (i < 80) { + int count = packed.charAt(i++); + char value = packed.charAt(i++); + do map[j++] = value; while (--count > 0); + } + return map; + } + + + /** + * Refills the input buffer. + * + * @return false, iff there was new input. + * + * @exception java.io.IOException if any I/O-Error occurs + */ + private boolean zzRefill() throws java.io.IOException { + + /* first: make room (if you can) */ + if (zzStartRead > 0) { + zzEndRead += zzFinalHighSurrogate; + zzFinalHighSurrogate = 0; + System.arraycopy(zzBuffer, zzStartRead, + zzBuffer, 0, + zzEndRead-zzStartRead); + + /* translate stored positions */ + zzEndRead-= zzStartRead; + zzCurrentPos-= zzStartRead; + zzMarkedPos-= zzStartRead; + zzStartRead = 0; + } + + /* is the buffer big enough? */ + if (zzCurrentPos >= zzBuffer.length - zzFinalHighSurrogate) { + /* if not: blow it up */ + char newBuffer[] = new char[zzBuffer.length*2]; + System.arraycopy(zzBuffer, 0, newBuffer, 0, zzBuffer.length); + zzBuffer = newBuffer; + zzEndRead += zzFinalHighSurrogate; + zzFinalHighSurrogate = 0; + } + + /* fill the buffer with new input */ + int requested = zzBuffer.length - zzEndRead; + int numRead = zzReader.read(zzBuffer, zzEndRead, requested); + + /* not supposed to occur according to specification of java.io.Reader */ + if (numRead == 0) { + throw new java.io.IOException("Reader returned 0 characters. See JFlex examples for workaround."); + } + if (numRead > 0) { + zzEndRead += numRead; + /* If numRead == requested, we might have requested to few chars to + encode a full Unicode character. We assume that a Reader would + otherwise never return half characters. */ + if (numRead == requested) { + if (Character.isHighSurrogate(zzBuffer[zzEndRead - 1])) { + --zzEndRead; + zzFinalHighSurrogate = 1; + } + } + /* potentially more input available */ + return false; + } + + /* numRead < 0 ==> end of stream */ + return true; + } + + + /** + * Closes the input stream. + */ + public final void yyclose() throws java.io.IOException { + zzAtEOF = true; /* indicate end of file */ + zzEndRead = zzStartRead; /* invalidate buffer */ + + if (zzReader != null) + zzReader.close(); + } + + + /** + * Resets the scanner to read from a new input stream. + * Does not close the old reader. + * + * All internal variables are reset, the old input stream + * cannot be reused (internal buffer is discarded and lost). + * Lexical state is set to ZZ_INITIAL. + * + * Internal scan buffer is resized down to its initial length, if it has grown. + * + * @param reader the new input stream + */ + public final void yyreset(java.io.Reader reader) { + zzReader = reader; + zzAtBOL = true; + zzAtEOF = false; + zzEOFDone = false; + zzEndRead = zzStartRead = 0; + zzCurrentPos = zzMarkedPos = 0; + zzFinalHighSurrogate = 0; + yyline = yychar = yycolumn = 0; + zzLexicalState = YYINITIAL; + if (zzBuffer.length > ZZ_BUFFERSIZE) + zzBuffer = new char[ZZ_BUFFERSIZE]; + } + + + /** + * Returns the current lexical state. + */ + public final int yystate() { + return zzLexicalState; + } + + + /** + * Enters a new lexical state + * + * @param newState the new lexical state + */ + public final void yybegin(int newState) { + zzLexicalState = newState; + } + + + /** + * Returns the text matched by the current regular expression. + */ + public final String yytext() { + return new String( zzBuffer, zzStartRead, zzMarkedPos-zzStartRead ); + } + + + /** + * Returns the character at position pos from the + * matched text. + * + * It is equivalent to yytext().charAt(pos), but faster + * + * @param pos the position of the character to fetch. + * A value from 0 to yylength()-1. + * + * @return the character at position pos + */ + public final char yycharat(int pos) { + return zzBuffer[zzStartRead+pos]; + } + + + /** + * Returns the length of the matched text region. + */ + public final int yylength() { + return zzMarkedPos-zzStartRead; + } + + + /** + * Reports an error that occured while scanning. + * + * In a wellformed scanner (no or only correct usage of + * yypushback(int) and a match-all fallback rule) this method + * will only be called with things that "Can't Possibly Happen". + * If this method is called, something is seriously wrong + * (e.g. a JFlex bug producing a faulty scanner etc.). + * + * Usual syntax/scanner level error handling should be done + * in error fallback rules. + * + * @param errorCode the code of the errormessage to display + */ + private void zzScanError(int errorCode) { + String message; + try { + message = ZZ_ERROR_MSG[errorCode]; + } + catch (ArrayIndexOutOfBoundsException e) { + message = ZZ_ERROR_MSG[ZZ_UNKNOWN_ERROR]; + } + + throw new Error(message); + } + + + /** + * Pushes the specified amount of characters back into the input stream. + * + * They will be read again by then next call of the scanning method + * + * @param number the number of characters to be read again. + * This number must not be greater than yylength()! + */ + public void yypushback(int number) { + if ( number > yylength() ) + zzScanError(ZZ_PUSHBACK_2BIG); + + zzMarkedPos -= number; + } + + + /** + * Resumes scanning until the next regular expression is matched, + * the end of input is encountered or an I/O-Error occurs. + * + * @return the next token + * @exception java.io.IOException if any I/O-Error occurs + */ + public Token nextToken() throws java.io.IOException { + int zzInput; + int zzAction; + + // cached fields: + int zzCurrentPosL; + int zzMarkedPosL; + int zzEndReadL = zzEndRead; + char [] zzBufferL = zzBuffer; + char [] zzCMapL = ZZ_CMAP; + + int [] zzTransL = ZZ_TRANS; + int [] zzRowMapL = ZZ_ROWMAP; + int [] zzAttrL = ZZ_ATTRIBUTE; + + while (true) { + zzMarkedPosL = zzMarkedPos; + + boolean zzR = false; + int zzCh; + int zzCharCount; + for (zzCurrentPosL = zzStartRead ; + zzCurrentPosL < zzMarkedPosL ; + zzCurrentPosL += zzCharCount ) { + zzCh = Character.codePointAt(zzBufferL, zzCurrentPosL, zzMarkedPosL); + zzCharCount = Character.charCount(zzCh); + switch (zzCh) { + case '\u000B': + case '\u000C': + case '\u0085': + case '\u2028': + case '\u2029': + yyline++; + yycolumn = 0; + zzR = false; + break; + case '\r': + yyline++; + yycolumn = 0; + zzR = true; + break; + case '\n': + if (zzR) + zzR = false; + else { + yyline++; + yycolumn = 0; + } + break; + default: + zzR = false; + yycolumn += zzCharCount; + } + } + + if (zzR) { + // peek one character ahead if it is \n (if we have counted one line too much) + boolean zzPeek; + if (zzMarkedPosL < zzEndReadL) + zzPeek = zzBufferL[zzMarkedPosL] == '\n'; + else if (zzAtEOF) + zzPeek = false; + else { + boolean eof = zzRefill(); + zzEndReadL = zzEndRead; + zzMarkedPosL = zzMarkedPos; + zzBufferL = zzBuffer; + if (eof) + zzPeek = false; + else + zzPeek = zzBufferL[zzMarkedPosL] == '\n'; + } + if (zzPeek) yyline--; + } + zzAction = -1; + + zzCurrentPosL = zzCurrentPos = zzStartRead = zzMarkedPosL; + + zzState = ZZ_LEXSTATE[zzLexicalState]; + + // set up zzAction for empty match case: + int zzAttributes = zzAttrL[zzState]; + if ( (zzAttributes & 1) == 1 ) { + zzAction = zzState; + } + + + zzForAction: { + while (true) { + + if (zzCurrentPosL < zzEndReadL) { + zzInput = Character.codePointAt(zzBufferL, zzCurrentPosL, zzEndReadL); + zzCurrentPosL += Character.charCount(zzInput); + } + else if (zzAtEOF) { + zzInput = YYEOF; + break zzForAction; + } + else { + // store back cached positions + zzCurrentPos = zzCurrentPosL; + zzMarkedPos = zzMarkedPosL; + boolean eof = zzRefill(); + // get translated positions and possibly new buffer + zzCurrentPosL = zzCurrentPos; + zzMarkedPosL = zzMarkedPos; + zzBufferL = zzBuffer; + zzEndReadL = zzEndRead; + if (eof) { + zzInput = YYEOF; + break zzForAction; + } + else { + zzInput = Character.codePointAt(zzBufferL, zzCurrentPosL, zzEndReadL); + zzCurrentPosL += Character.charCount(zzInput); + } + } + int zzNext = zzTransL[ zzRowMapL[zzState] + zzCMapL[zzInput] ]; + if (zzNext == -1) break zzForAction; + zzState = zzNext; + + zzAttributes = zzAttrL[zzState]; + if ( (zzAttributes & 1) == 1 ) { + zzAction = zzState; + zzMarkedPosL = zzCurrentPosL; + if ( (zzAttributes & 8) == 8 ) break zzForAction; + } + + } + } + + // store back cached position + zzMarkedPos = zzMarkedPosL; + + if (zzInput == YYEOF && zzStartRead == zzCurrentPos) { + zzAtEOF = true; + { return new Token(Token.EOF, "", yyline+1, yycolumn+1); + } + } + else { + switch (zzAction < 0 ? zzAction : ZZ_ACTION[zzAction]) { + case 1: + { throw new Error("Illegal character <" + yytext() + ">"); + } + case 9: break; + case 2: + { /* Ignore */ + } + case 10: break; + case 3: + { return new Token(Token.ID, yytext(), yyline+1, yycolumn+1); + } + case 11: break; + case 4: + { return new Token(Token.NUM, yytext(), yyline+1, yycolumn+1); + } + case 12: break; + case 5: + { return new Token(Token.LSBR, yytext(), yyline+1, yycolumn+1); + } + case 13: break; + case 6: + { return new Token(Token.RSBR, yytext(), yyline+1, yycolumn+1); + } + case 14: break; + case 7: + { return new Token(Token.COMMA, yytext(), yyline+1, yycolumn+1); + } + case 15: break; + case 8: + { return new Token(Token.NULL, yytext(), yyline+1, yycolumn+1); + } + case 16: break; + default: + zzScanError(ZZ_NO_MATCH); + } + } + } + } + + +} diff --git a/ÜB-Praxis-JFlex Scanner für AS-Leer/src/de/dhbw/compiler/jflexasscanner/JFlexASScannerMain.java b/ÜB-Praxis-JFlex Scanner für AS-Leer/src/de/dhbw/compiler/jflexasscanner/JFlexASScannerMain.java new file mode 100644 index 0000000..1385a8f --- /dev/null +++ b/ÜB-Praxis-JFlex Scanner für AS-Leer/src/de/dhbw/compiler/jflexasscanner/JFlexASScannerMain.java @@ -0,0 +1,31 @@ +/* ********************************************** + * Duale Hochschule Baden-Württemberg Karlsruhe + * Prof. Dr. Jörn Eisenbiegler + * + * Vorlesung Übersetzerbau + * Praxis AS-Scanner mit JFlex + * + * ********************************************** + */ + +package de.dhbw.compiler.jflexasscanner; + +import java.io.StringReader; + + +public class JFlexASScannerMain { + + private static final String TEST = "[34, x,peter, 34kurt, g56, null,null, 8] "; + + public static void main(String[] args) throws Exception { + + JFlexASScanner scanner = new JFlexASScanner(new StringReader(TEST)); + + /* + * Lesen Sie hier die einzelnen Token des oben angebenen String mit Hilfe des + * Scanners ein und geben Sie sie auf die Konsole aus. + */ + + } + +} diff --git a/ÜB-Praxis-JFlex Scanner für AS-Leer/src/de/dhbw/compiler/jflexasscanner/NumToken.java b/ÜB-Praxis-JFlex Scanner für AS-Leer/src/de/dhbw/compiler/jflexasscanner/NumToken.java new file mode 100644 index 0000000..18f3c13 --- /dev/null +++ b/ÜB-Praxis-JFlex Scanner für AS-Leer/src/de/dhbw/compiler/jflexasscanner/NumToken.java @@ -0,0 +1,25 @@ +/* ********************************************** + * Duale Hochschule Baden-Württemberg Karlsruhe + * Prof. Dr. Jörn Eisenbiegler + * + * Vorlesung Übersetzerbau + * Praxis AS-Scanner mit JFlex + * - Token-Definition num + * + * ********************************************** + */ + +package de.dhbw.compiler.jflexasscanner; + +public class NumToken extends Token { + + public NumToken(int type, String text, int line, int column) { + super(type,text,line,column); + } + + int getValue() { + return 0; + } + + +} diff --git a/ÜB-Praxis-JFlex Scanner für AS-Leer/src/de/dhbw/compiler/jflexasscanner/StringToken.java b/ÜB-Praxis-JFlex Scanner für AS-Leer/src/de/dhbw/compiler/jflexasscanner/StringToken.java new file mode 100644 index 0000000..8b21f27 --- /dev/null +++ b/ÜB-Praxis-JFlex Scanner für AS-Leer/src/de/dhbw/compiler/jflexasscanner/StringToken.java @@ -0,0 +1,28 @@ +/* ********************************************** + * Duale Hochschule Baden-Württemberg Karlsruhe + * Prof. Dr. Jörn Eisenbiegler + * + * Vorlesung Übersetzerbau + * Praxis AS-Scanner mit JFlex + * - Token-Definition frac + * + * ********************************************** + */ + +package de.dhbw.compiler.jflexasscanner; + +public class StringToken extends Token { + + private String value; + + public StringToken(int type, String text, int line, int column, String value) { + super(type,text,line,column); + this.value = value; + } + + String getValue() { + return value; + } + + +} diff --git a/ÜB-Praxis-JFlex Scanner für AS-Leer/src/de/dhbw/compiler/jflexasscanner/TestASScanner1.java b/ÜB-Praxis-JFlex Scanner für AS-Leer/src/de/dhbw/compiler/jflexasscanner/TestASScanner1.java new file mode 100644 index 0000000..60725a7 --- /dev/null +++ b/ÜB-Praxis-JFlex Scanner für AS-Leer/src/de/dhbw/compiler/jflexasscanner/TestASScanner1.java @@ -0,0 +1,131 @@ +/* ********************************************** + * Duale Hochschule Baden-Württemberg Karlsruhe + * Prof. Dr. Jörn Eisenbiegler + * + * Vorlesung Übersetzerbau + * Praxis AS-Scanner mit JFlex + * - Testfälle Aufgabe 1 + * + * ********************************************** + */ + +package de.dhbw.compiler.jflexasscanner; + +import org.junit.Test; + +public class TestASScanner1 extends TokenStreamTest { + + @Test + public void tokenLSBR() throws Exception { + testTokenList(" [ ", false, new Token(Token.LSBR,"[",1,3)); + } + + @Test + public void tokenRSBR() throws Exception { + testTokenList(" ] ", false, new Token(Token.RSBR,"]",1,3)); + } + + @Test + public void tokenCOMMA() throws Exception { + testTokenList(" , ", false, new Token(Token.COMMA,",",1,3)); + } + + @Test + public void tokenZAHL() throws Exception { + testTokenList(" 0 ", false, new Token(Token.NUM,"0",1,3)); + testTokenList(" 9 ", false, new Token(Token.NUM,"9",1,3)); + testTokenList(" 1234567890 ", false, new Token(Token.NUM,"1234567890",1,3)); + } + + @Test + public void tokenID() throws Exception { + testTokenList(" a ", false, new Token(Token.ID,"a",1,3)); + testTokenList(" A ", false, new Token(Token.ID,"A",1,3)); + testTokenList(" x ", false, new Token(Token.ID,"x",1,3)); + testTokenList(" X ", false, new Token(Token.ID,"X",1,3)); + testTokenList(" 0a ", false, new Token(Token.ID,"0a",1,3)); + testTokenList(" X0 ", false, new Token(Token.ID,"X0",1,3)); + testTokenList(" 1234567890a ", false, new Token(Token.ID,"1234567890a",1,3)); + testTokenList(" abcdefghijklmnopqrstuvwxyz ", false, new Token(Token.ID,"abcdefghijklmnopqrstuvwxyz",1,3)); + testTokenList(" ABCDEFGHIJKLMNOPQRSTUVWXYZ ", false, new Token(Token.ID,"ABCDEFGHIJKLMNOPQRSTUVWXYZ",1,3)); + testTokenList(" NULL ", false, new Token(Token.ID,"NULL",1,3)); + testTokenList(" NulL ", false, new Token(Token.ID,"NulL",1,3)); + } + + @Test + public void tokenNULL() throws Exception { + testTokenList(" null ", false, new Token(Token.NULL,"null",1,3)); + } + + @Test + public void tokenEOF() throws Exception { + testTokenList(" ", false); + testTokenList(" ", false, new Token(Token.EOF,"",1,2)); + testTokenList("", false, new Token(Token.EOF,"",1,1)); + } + + @Test + public void invalidÄ() throws Exception { + testTokenList(" ä ", false, new Token(Token.INVALID,"ä",1,2)); + } + + public void invalidGatter() throws Exception { + testTokenList(" # ", false, new Token(Token.INVALID,"#",1,3)); + } + + @Test + public void sentence1() throws Exception { + testTokenList(" [ [ ] hallo ,,,Duda,123,76", false, + new Token(Token.LSBR,"[",1,2), + new Token(Token.LSBR,"[",1,4), + new Token(Token.RSBR,"]",1,6), + new Token(Token.ID,"hallo",1,8), + new Token(Token.COMMA,",",1,14), + new Token(Token.COMMA,",",1,15), + new Token(Token.COMMA,",",1,16), + new Token(Token.ID,"Duda",1,17), + new Token(Token.COMMA,",",1,21), + new Token(Token.NUM,"123",1,22), + new Token(Token.COMMA,",",1,25), + new Token(Token.NUM,"76",1,26)); + } + + + @Test + public void sentence2() throws Exception { + testTokenList("[34, x,peter, 34kurt, g56, null,null, 8]", false, + new Token(Token.LSBR,"[",1,1), + new Token(Token.NUM,"34",1,2), + new Token(Token.COMMA,",",1,4), + new Token(Token.ID,"x",1,6), + new Token(Token.COMMA,",",1,7), + new Token(Token.ID,"peter",1,8), + new Token(Token.COMMA,",",1,13), + new Token(Token.ID,"34kurt",1,16), + new Token(Token.COMMA,",",1,22), + new Token(Token.ID,"g56",1,24), + new Token(Token.COMMA,",",1,27), + new Token(Token.NULL,"null",1,29), + new Token(Token.COMMA,",",1,33), + new Token(Token.NULL,"null",1,34), + new Token(Token.COMMA,",",1,38), + new Token(Token.NUM,"8",1,40), + new Token(Token.RSBR,"]",1,41)); + } + + @Test + public void sentence3() throws Exception { + testTokenList("[ a, b, \n c, \r\nd]", false, + new Token(Token.LSBR,"[",1,1), + new Token(Token.ID,"a",1,3), + new Token(Token.COMMA,",",1,4), + new Token(Token.ID,"b",1,6), + new Token(Token.COMMA,",",1,7), + new Token(Token.ID,"c",2,2), + new Token(Token.COMMA,",",2,3), + new Token(Token.ID,"d",3,1), + new Token(Token.RSBR,"]",3,2)); + } + + +} diff --git a/ÜB-Praxis-JFlex Scanner für AS-Leer/src/de/dhbw/compiler/jflexasscanner/TestASScanner2.java b/ÜB-Praxis-JFlex Scanner für AS-Leer/src/de/dhbw/compiler/jflexasscanner/TestASScanner2.java new file mode 100644 index 0000000..46fdf26 --- /dev/null +++ b/ÜB-Praxis-JFlex Scanner für AS-Leer/src/de/dhbw/compiler/jflexasscanner/TestASScanner2.java @@ -0,0 +1,97 @@ +/* ********************************************** + * Duale Hochschule Baden-Württemberg Karlsruhe + * Prof. Dr. Jörn Eisenbiegler + * + * Vorlesung Übersetzerbau + * Praxis AS-Scanner mit JFlex + * - Testfälle Aufgabe 1 + * + * ********************************************** + */ + +package de.dhbw.compiler.jflexasscanner; + +import org.junit.Test; + +public class TestASScanner2 extends TokenStreamTest { + + @Test + public void token1_1() throws Exception { + testTokenList(" 1.1 ", false, new Token(Token.FRAC,"1.1",1,3)); + } + + @Test + public void token1_() throws Exception { + testTokenList(" 1. ", false, new Token(Token.FRAC,"1.",1,3)); + } + + @Test + public void token_1() throws Exception { + testTokenList(" .1 ", false, + new Token(Token.INVALID,".",1,3), + new Token(Token.NUM,"1",1,4)); + } + + @Test + public void token1_1_1() throws Exception { + testTokenList(" 1.1^1 ", false, new Token(Token.FRAC,"1.1^1",1,3)); + } + + @Test + public void token1__1() throws Exception { + testTokenList(" 1.^1 ", false, new Token(Token.FRAC,"1.^1",1,3)); + } + + @Test + public void token0120_01230_01230() throws Exception { + testTokenList(" 01234567890.01234567890^01234567890 ", false, + new Token(Token.FRAC,"01234567890.01234567890^01234567890",1,3)); + } + + @Test + public void token0120_01230_() throws Exception { + testTokenList(" 01230.01230^ ", false, + new Token(Token.FRAC,"01230.01230",1,3), + new Token(Token.INVALID,"^",1,14)); + } + + @Test + public void token0120_0abc() throws Exception { + testTokenList(" 01230.0abc",false, + new Token(Token.FRAC,"01230.0",1,3), + new Token(Token.ID,"abc",1,10)); + } + + @Test + public void token0120_abc() throws Exception { + testTokenList(" 01230.abc", false, + new Token(Token.FRAC,"01230.",1,3), + new Token(Token.ID,"abc",1,9)); + } + + @Test + public void token0120_0_45LSBR() throws Exception { + testTokenList(" 01230.0^45[", false, + new Token(Token.FRAC,"01230.0^45",1,3), + new Token(Token.LSBR,"[",1,13)); + } + + @Test + public void sentence1() throws Exception { + testTokenList("[ hallo, 23.45, 4., 5.^56, 0.0^00, 78]", false, + new Token(Token.LSBR,"[",1,1), + new Token(Token.ID,"hallo",1,3), + new Token(Token.COMMA,",",1,8), + new Token(Token.FRAC,"23.45",1,10), + new Token(Token.COMMA,",",1,15), + new Token(Token.FRAC,"4.",1,17), + new Token(Token.COMMA,",",1,19), + new Token(Token.FRAC,"5.^56",1,21), + new Token(Token.COMMA,",",1,26), + new Token(Token.FRAC,"0.0^00",1,28), + new Token(Token.COMMA,",",1,34), + new Token(Token.NUM,"78",1,36), + new Token(Token.RSBR,"]",1,38)); + } + +} diff --git a/ÜB-Praxis-JFlex Scanner für AS-Leer/src/de/dhbw/compiler/jflexasscanner/TestASScanner3.java b/ÜB-Praxis-JFlex Scanner für AS-Leer/src/de/dhbw/compiler/jflexasscanner/TestASScanner3.java new file mode 100644 index 0000000..2501bd9 --- /dev/null +++ b/ÜB-Praxis-JFlex Scanner für AS-Leer/src/de/dhbw/compiler/jflexasscanner/TestASScanner3.java @@ -0,0 +1,57 @@ +/* ********************************************** + * Duale Hochschule Baden-Württemberg Karlsruhe + * Prof. Dr. Jörn Eisenbiegler + * + * Vorlesung Übersetzerbau + * Praxis AS-Scanner mit JFlex + * - Testfälle Aufgabe 2 + * + * ********************************************** + */ + +package de.dhbw.compiler.jflexasscanner; + +import org.junit.Test; + +public class TestASScanner3 extends TokenStreamTest { + + @Test + public void tokenInt() throws Exception { + testTokenList(" 0 ", true, new Token(Token.NUM,"0",1,3)); + testTokenList(" 00 ", true, new Token(Token.NUM,"00",1,3)); + testTokenList(" 1 ", true, new Token(Token.NUM,"1",1,3)); + testTokenList(" 12 ", true, new Token(Token.NUM,"12",1,3)); + testTokenList(" 123 ", true, new Token(Token.NUM,"123",1,3)); + testTokenList(" 1234567890 ", true, new Token(Token.NUM,"1234567890",1,3)); + testTokenList(" 078 ", true, new Token(Token.NUM,"078",1,3)); + testTokenList(" 004500 ", true, new Token(Token.NUM,"004500",1,3)); + } + + @Test + public void tokenFrac0() throws Exception { + testTokenList(" 0. ", true, new Token(Token.FRAC,"0.",1,3)); + testTokenList(" 0.0 ", true, new Token(Token.FRAC,"0.0",1,3)); + testTokenList(" 0.0^0 ", true, new Token(Token.FRAC,"0.0^0",1,3)); + } + + @Test + public void tokenFrac1() throws Exception { + testTokenList(" 1. ", true, new Token(Token.FRAC,"1.",1,3)); + testTokenList(" 1.1 ", true, new Token(Token.FRAC,"1.1",1,3)); + testTokenList(" 1.1^1 ", true, new Token(Token.FRAC,"1.1^1",1,3)); + } + + @Test + public void tokenFrac123() throws Exception { + testTokenList(" 0.12^34 ", true, new Token(Token.FRAC,"0.12^34",1,3)); + testTokenList(" 0.045^0023 ", true, new Token(Token.FRAC,"0.045^0023",1,3)); + testTokenList(" 123.4560^7890 ", true, new Token(Token.FRAC,"123.4560^7890",1,3)); + } + + @Test + public void tokenID() throws Exception { + testTokenList(" 012abc ", true, new Token(Token.ID,"012abc",1,3)); + testTokenList(" 012abc34 ", true, new Token(Token.ID,"012abc34",1,3)); + } + +} diff --git a/ÜB-Praxis-JFlex Scanner für AS-Leer/src/de/dhbw/compiler/jflexasscanner/TestASScanner4.java b/ÜB-Praxis-JFlex Scanner für AS-Leer/src/de/dhbw/compiler/jflexasscanner/TestASScanner4.java new file mode 100644 index 0000000..ae6d153 --- /dev/null +++ b/ÜB-Praxis-JFlex Scanner für AS-Leer/src/de/dhbw/compiler/jflexasscanner/TestASScanner4.java @@ -0,0 +1,60 @@ +/* ********************************************** + * Duale Hochschule Baden-Württemberg Karlsruhe + * Prof. Dr. Jörn Eisenbiegler + * + * Vorlesung Übersetzerbau + * Praxis AS-Scanner mit JFlex + * - Testfälle Aufgabe 3 + * + * ********************************************** + */ + +package de.dhbw.compiler.jflexasscanner; + +import org.junit.Test; + +public class TestASScanner4 extends TokenStreamTest { + + @Test + public void tokenTo() throws Exception { + testTokenList(" .. ", false, new Token(Token.TO,"..",1,3)); + } + + @Test + public void tokenNumToNum() throws Exception { + testTokenList(" 4 .. 5 ", false, + new Token(Token.NUM,"4",1,3), + new Token(Token.TO,"..",1,5), + new Token(Token.NUM,"5",1,8)); + testTokenList(" 4..5 ", false, + new Token(Token.NUM,"4",1,3), + new Token(Token.TO,"..",1,4), + new Token(Token.NUM,"5",1,6)); + testTokenList(" 4......5 ", false, + new Token(Token.NUM,"4",1,3), + new Token(Token.TO,"..",1,4), + new Token(Token.TO,"..",1,6), + new Token(Token.TO,"..",1,8), + new Token(Token.NUM,"5",1,10)); + } + + @Test + public void tokenFracToNum() throws Exception { + testTokenList(" 4. .. 5 ", false, + new Token(Token.FRAC,"4.",1,3), + new Token(Token.TO,"..",1,6), + new Token(Token.NUM,"5",1,9)); + testTokenList(" 4.5 ", false, new Token(Token.FRAC,"4.5",1,3)); + testTokenList(" 4...5 ", false, + new Token(Token.FRAC,"4.",1,3), + new Token(Token.TO,"..",1,5), + new Token(Token.NUM,"5",1,7)); + testTokenList(" 4.......5 ", false, + new Token(Token.FRAC,"4.",1,3), + new Token(Token.TO,"..",1,5), + new Token(Token.TO,"..",1,7), + new Token(Token.TO,"..",1,9), + new Token(Token.NUM,"5",1,11)); + } + +} diff --git a/ÜB-Praxis-JFlex Scanner für AS-Leer/src/de/dhbw/compiler/jflexasscanner/TestASScanner5.java b/ÜB-Praxis-JFlex Scanner für AS-Leer/src/de/dhbw/compiler/jflexasscanner/TestASScanner5.java new file mode 100644 index 0000000..0a028d6 --- /dev/null +++ b/ÜB-Praxis-JFlex Scanner für AS-Leer/src/de/dhbw/compiler/jflexasscanner/TestASScanner5.java @@ -0,0 +1,54 @@ +/* ********************************************** + * Duale Hochschule Baden-Württemberg Karlsruhe + * Prof. Dr. Jörn Eisenbiegler + * + * Vorlesung Übersetzerbau + * Praxis AS-Scanner mit JFlex + * - Testfälle Aufgabe 3 + * + * ********************************************** + */ + +package de.dhbw.compiler.jflexasscanner; + +import org.junit.Test; + +public class TestASScanner5 extends TokenStreamTest { + + @Test + public void stringABC() throws Exception { + testTokenList("\"abc\"", true, + new Token(Token.STR,"\"abc\"",1,1)); + testTokenList(" \"abc\" ", true, + new Token(Token.STR,"\"abc\"",1,2)); + } + + @Test + public void stringEmpty() throws Exception { + testTokenList(" \"\" ", true, + new Token(Token.STR,"\"\"",1,2)); + testTokenList(" \" \" ", true, + new Token(Token.STR,"\" \"",1,2)); + } + + @Test + public void stringEscape() throws Exception { + testTokenList("\"\\\"\"", true, + new Token(Token.STR,"\"\\\"\"",1,1)); + testTokenList(" \"\\\"\\\"\\\"\" ", true, + new Token(Token.STR,"\"\\\"\\\"\\\"\"",1,2)); + testTokenList(" \" \\\" \" ", true, + new Token(Token.STR,"\" \\\" \"",1,2)); + } + + @Test + public void stringAll() throws Exception { + testTokenList("\"abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ\\\" \"", true, + new Token(Token.STR,"\"abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ\\\" \"",1,1)); + testTokenList("\"abcde\\\"\"\"fg\\\"hi\" \"jkl\\\"\"", true, + new Token(Token.STR,"\"abcde\\\"\"",1,1), + new Token(Token.STR,"\"fg\\\"hi\"",1,10), + new Token(Token.STR,"\"jkl\\\"\"",1,19)); + } + +} diff --git a/ÜB-Praxis-JFlex Scanner für AS-Leer/src/de/dhbw/compiler/jflexasscanner/TestsAll.java b/ÜB-Praxis-JFlex Scanner für AS-Leer/src/de/dhbw/compiler/jflexasscanner/TestsAll.java new file mode 100644 index 0000000..63baf79 --- /dev/null +++ b/ÜB-Praxis-JFlex Scanner für AS-Leer/src/de/dhbw/compiler/jflexasscanner/TestsAll.java @@ -0,0 +1,22 @@ +/* ********************************************** + * Duale Hochschule Baden-Württemberg Karlsruhe + * Prof. Dr. Jörn Eisenbiegler + * + * Vorlesung Übersetzerbau + * Praxis AS-Scanner mit JFlex + * - Testsuite + * + * ********************************************** + */ + +package de.dhbw.compiler.jflexasscanner; + +import org.junit.runner.RunWith; +import org.junit.runners.Suite; +import org.junit.runners.Suite.SuiteClasses; + +@RunWith(Suite.class) +@SuiteClasses({ TestASScanner1.class, TestASScanner2.class, TestASScanner3.class, TestASScanner4.class, TestASScanner5.class }) +public class TestsAll { + +} diff --git a/ÜB-Praxis-JFlex Scanner für AS-Leer/src/de/dhbw/compiler/jflexasscanner/Token.java b/ÜB-Praxis-JFlex Scanner für AS-Leer/src/de/dhbw/compiler/jflexasscanner/Token.java new file mode 100644 index 0000000..60c78e4 --- /dev/null +++ b/ÜB-Praxis-JFlex Scanner für AS-Leer/src/de/dhbw/compiler/jflexasscanner/Token.java @@ -0,0 +1,82 @@ +/* ********************************************** + * Duale Hochschule Baden-Württemberg Karlsruhe + * Prof. Dr. Jörn Eisenbiegler + * + * Vorlesung Übersetzerbau + * Praxis AS-Scanner mit JFlex + * - Token-Definition + * + * ********************************************** + */ + +package de.dhbw.compiler.jflexasscanner; + +public class Token { + + public static final int EOF = 0; + public static final int INVALID = -1; + public static final int LSBR = 1; + public static final int RSBR = 2; + public static final int COMMA = 3; + public static final int NUM = 4; + public static final int ID = 5; + public static final int NULL = 6; + public static final int FRAC = 7; + public static final int TO = 8; + public static final int STR = 9; + + private int type; + private String text; + private int line; + private int columnm; + + public Token(int type, String text, int line, int column) { + this.type = type; + this.text = text; + this.line = line; + this.columnm = column; + } + + public Token(int type, String text) { + this(type,text,0,0); + } + + public int getType() { + return type; + } + + public String getText() { + return text; + } + + public int getLine() { + return line; + } + + public int getColumn() { + return columnm; + } + + public String toString() { + return "(" + getTypeName(type) + "," + text + "," + line + "," + columnm + ")"; + } + + public static String getTypeName(int tokenType) { + switch (tokenType) { + case EOF: return "EOF"; + case INVALID: return "INVALID"; + case LSBR: return "LSBR"; + case RSBR: return "RSBR"; + case COMMA: return "COMMA"; + case NUM: return "NUM"; + case ID: return "ID"; + case NULL: return "NULL"; + case FRAC: return "FRAC"; + case TO: return "TO"; + case STR: return "STR"; + default: return "Unknown token type!"; + } + + } + +} diff --git a/ÜB-Praxis-JFlex Scanner für AS-Leer/src/de/dhbw/compiler/jflexasscanner/TokenStreamTest.java b/ÜB-Praxis-JFlex Scanner für AS-Leer/src/de/dhbw/compiler/jflexasscanner/TokenStreamTest.java new file mode 100644 index 0000000..57f414e --- /dev/null +++ b/ÜB-Praxis-JFlex Scanner für AS-Leer/src/de/dhbw/compiler/jflexasscanner/TokenStreamTest.java @@ -0,0 +1,60 @@ +/* ********************************************** + * Duale Hochschule Baden-Württemberg Karlsruhe + * Prof. Dr. Jörn Eisenbiegler + * + * Vorlesung Übersetzerbau + * Praxis AS-Scanner mit JFlex + * - Testfall-Utility + * + * ********************************************** + */ + +package de.dhbw.compiler.jflexasscanner; + +import static org.junit.Assert.assertEquals; + +import java.io.StringReader; + +public abstract class TokenStreamTest { + + protected void testTokenList(String in, boolean convert, Token... TokenList) throws Exception { + JFlexASScanner scanner = new JFlexASScanner(new StringReader(in)); + Token myToken; + + for (Token expected : TokenList) { + myToken = scanner.nextToken(); + assertEquals("Expect Token "+expected.toString()+". Error in type.", + expected.getType(), myToken.getType()); + assertEquals("Expect Token "+expected.toString()+". Error in text.", + expected.getText(), myToken.getText()); + assertEquals("Expect Token "+expected.toString()+". Error in line.", + expected.getLine(), myToken.getLine()); + assertEquals("Expect Token "+expected.toString()+". Error in column.", + expected.getColumn(), myToken.getColumn()); + if (convert) { + switch (myToken.getType()) { + case Token.NUM: + int intValue = Integer.parseInt(expected.getText()); + assertEquals("Expected Token value "+intValue, + intValue,((NumToken)myToken).getValue()); + break; + case Token.FRAC: + double doubleValue = Double.parseDouble(expected.getText().replace("^", "e")); + assertEquals("Expected Token value "+doubleValue, + doubleValue,((FracToken)myToken).getValue(), doubleValue*0.0000001); + break; + case Token.STR: + String stringValue = expected.getText().replace("\\\"", "\""); + stringValue = stringValue.substring(1,stringValue.length()-1); + assertEquals("Expected Token value "+stringValue, + stringValue,((StringToken)myToken).getValue()); + break; + } + } + } + + myToken = scanner.nextToken(); + assertEquals("Expected End of File (EOF), read " + myToken.toString() + ".", Token.EOF, myToken.getType()); + } + +} diff --git a/ÜB-Praxis-JFlex Scanner für AS-Leer/ÜB-Praxis-JFlex Scanner für AS-Leer.iml b/ÜB-Praxis-JFlex Scanner für AS-Leer/ÜB-Praxis-JFlex Scanner für AS-Leer.iml new file mode 100644 index 0000000..705a317 --- /dev/null +++ b/ÜB-Praxis-JFlex Scanner für AS-Leer/ÜB-Praxis-JFlex Scanner für AS-Leer.iml @@ -0,0 +1,37 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/ÜB-Praxis-Scanner für Namen-Leer/.classpath b/ÜB-Praxis-Scanner für Namen-Leer/.classpath new file mode 100644 index 0000000..b74be30 --- /dev/null +++ b/ÜB-Praxis-Scanner für Namen-Leer/.classpath @@ -0,0 +1,7 @@ + + + + + + + diff --git a/ÜB-Praxis-Scanner für Namen-Leer/.idea/.gitignore b/ÜB-Praxis-Scanner für Namen-Leer/.idea/.gitignore new file mode 100644 index 0000000..73f69e0 --- /dev/null +++ b/ÜB-Praxis-Scanner für Namen-Leer/.idea/.gitignore @@ -0,0 +1,8 @@ +# Default ignored files +/shelf/ +/workspace.xml +# Datasource local storage ignored files +/dataSources/ +/dataSources.local.xml +# Editor-based HTTP Client requests +/httpRequests/ diff --git a/ÜB-Praxis-Scanner für Namen-Leer/.idea/libraries/lib.xml b/ÜB-Praxis-Scanner für Namen-Leer/.idea/libraries/lib.xml new file mode 100644 index 0000000..fa8838a --- /dev/null +++ b/ÜB-Praxis-Scanner für Namen-Leer/.idea/libraries/lib.xml @@ -0,0 +1,10 @@ + + + + + + + + + + \ No newline at end of file diff --git a/ÜB-Praxis-Scanner für Namen-Leer/.idea/misc.xml b/ÜB-Praxis-Scanner für Namen-Leer/.idea/misc.xml new file mode 100644 index 0000000..18e6fc0 --- /dev/null +++ b/ÜB-Praxis-Scanner für Namen-Leer/.idea/misc.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/ÜB-Praxis-Scanner für Namen-Leer/.idea/modules.xml b/ÜB-Praxis-Scanner für Namen-Leer/.idea/modules.xml new file mode 100644 index 0000000..edd803a --- /dev/null +++ b/ÜB-Praxis-Scanner für Namen-Leer/.idea/modules.xml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/ÜB-Praxis-Scanner für Namen-Leer/.project b/ÜB-Praxis-Scanner für Namen-Leer/.project new file mode 100644 index 0000000..0455dd9 --- /dev/null +++ b/ÜB-Praxis-Scanner für Namen-Leer/.project @@ -0,0 +1,18 @@ + + + ÜB-Praxis-Scanner für Namen-Leer + + + + + + org.eclipse.jdt.core.javabuilder + + + + + + pi.eclipse.cle.CupLexNature + org.eclipse.jdt.core.javanature + + diff --git a/ÜB-Praxis-Scanner für Namen-Leer/.settings/org.eclipse.jdt.core.prefs b/ÜB-Praxis-Scanner für Namen-Leer/.settings/org.eclipse.jdt.core.prefs new file mode 100644 index 0000000..7341ab1 --- /dev/null +++ b/ÜB-Praxis-Scanner für Namen-Leer/.settings/org.eclipse.jdt.core.prefs @@ -0,0 +1,11 @@ +eclipse.preferences.version=1 +org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled +org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.7 +org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve +org.eclipse.jdt.core.compiler.compliance=1.7 +org.eclipse.jdt.core.compiler.debug.lineNumber=generate +org.eclipse.jdt.core.compiler.debug.localVariable=generate +org.eclipse.jdt.core.compiler.debug.sourceFile=generate +org.eclipse.jdt.core.compiler.problem.assertIdentifier=error +org.eclipse.jdt.core.compiler.problem.enumIdentifier=error +org.eclipse.jdt.core.compiler.source=1.7 diff --git a/ÜB-Praxis-Scanner für Namen-Leer/.settings/pi.eclipse.cle.prefs b/ÜB-Praxis-Scanner für Namen-Leer/.settings/pi.eclipse.cle.prefs new file mode 100644 index 0000000..48b3b42 --- /dev/null +++ b/ÜB-Praxis-Scanner für Namen-Leer/.settings/pi.eclipse.cle.prefs @@ -0,0 +1,5 @@ +//src/de/dhbw/compiler/JFlexASScanner/JFlexASScanner.lex/lex-code-method=0 +//src/de/dhbw/compiler/JFlexASScanner/JFlexASScanner.lex/lex-comply-jlex=false +//src/de/dhbw/compiler/JFlexASScanner/JFlexASScanner.lex/lex-output=src +//src/de/dhbw/compiler/JFlexASScanner/JFlexASScanner.lex/lex-skip-min=false +eclipse.preferences.version=1 diff --git a/ÜB-Praxis-Scanner für Namen-Leer/bin/de/dhbw/compiler/namenscanner/NamenScanner$NamenState.class b/ÜB-Praxis-Scanner für Namen-Leer/bin/de/dhbw/compiler/namenscanner/NamenScanner$NamenState.class new file mode 100644 index 0000000..4b09640 Binary files /dev/null and b/ÜB-Praxis-Scanner für Namen-Leer/bin/de/dhbw/compiler/namenscanner/NamenScanner$NamenState.class differ diff --git a/ÜB-Praxis-Scanner für Namen-Leer/bin/de/dhbw/compiler/namenscanner/NamenScanner.class b/ÜB-Praxis-Scanner für Namen-Leer/bin/de/dhbw/compiler/namenscanner/NamenScanner.class new file mode 100644 index 0000000..0eb9b75 Binary files /dev/null and b/ÜB-Praxis-Scanner für Namen-Leer/bin/de/dhbw/compiler/namenscanner/NamenScanner.class differ diff --git a/ÜB-Praxis-Scanner für Namen-Leer/bin/de/dhbw/compiler/namenscanner/NamenScannerMain.class b/ÜB-Praxis-Scanner für Namen-Leer/bin/de/dhbw/compiler/namenscanner/NamenScannerMain.class new file mode 100644 index 0000000..f845463 Binary files /dev/null and b/ÜB-Praxis-Scanner für Namen-Leer/bin/de/dhbw/compiler/namenscanner/NamenScannerMain.class differ diff --git a/ÜB-Praxis-Scanner für Namen-Leer/bin/de/dhbw/compiler/namenscanner/TestNamenScanner1.class b/ÜB-Praxis-Scanner für Namen-Leer/bin/de/dhbw/compiler/namenscanner/TestNamenScanner1.class new file mode 100644 index 0000000..bf8d3af Binary files /dev/null and b/ÜB-Praxis-Scanner für Namen-Leer/bin/de/dhbw/compiler/namenscanner/TestNamenScanner1.class differ diff --git a/ÜB-Praxis-Scanner für Namen-Leer/bin/de/dhbw/compiler/namenscanner/TestsAll.class b/ÜB-Praxis-Scanner für Namen-Leer/bin/de/dhbw/compiler/namenscanner/TestsAll.class new file mode 100644 index 0000000..37d78f7 Binary files /dev/null and b/ÜB-Praxis-Scanner für Namen-Leer/bin/de/dhbw/compiler/namenscanner/TestsAll.class differ diff --git a/ÜB-Praxis-Scanner für Namen-Leer/bin/de/dhbw/compiler/namenscanner/Token.class b/ÜB-Praxis-Scanner für Namen-Leer/bin/de/dhbw/compiler/namenscanner/Token.class new file mode 100644 index 0000000..7323299 Binary files /dev/null and b/ÜB-Praxis-Scanner für Namen-Leer/bin/de/dhbw/compiler/namenscanner/Token.class differ diff --git a/ÜB-Praxis-Scanner für Namen-Leer/bin/de/dhbw/compiler/namenscanner/TokenStreamTest.class b/ÜB-Praxis-Scanner für Namen-Leer/bin/de/dhbw/compiler/namenscanner/TokenStreamTest.class new file mode 100644 index 0000000..42135c5 Binary files /dev/null and b/ÜB-Praxis-Scanner für Namen-Leer/bin/de/dhbw/compiler/namenscanner/TokenStreamTest.class differ diff --git a/ÜB-Praxis-Scanner für Namen-Leer/lib/hamcrest-all-1.3.jar b/ÜB-Praxis-Scanner für Namen-Leer/lib/hamcrest-all-1.3.jar new file mode 100644 index 0000000..6f62ba0 Binary files /dev/null and b/ÜB-Praxis-Scanner für Namen-Leer/lib/hamcrest-all-1.3.jar differ diff --git a/ÜB-Praxis-Scanner für Namen-Leer/lib/jflex-1.6.1.jar b/ÜB-Praxis-Scanner für Namen-Leer/lib/jflex-1.6.1.jar new file mode 100644 index 0000000..001e0e5 Binary files /dev/null and b/ÜB-Praxis-Scanner für Namen-Leer/lib/jflex-1.6.1.jar differ diff --git a/ÜB-Praxis-Scanner für Namen-Leer/lib/jflexant.xml b/ÜB-Praxis-Scanner für Namen-Leer/lib/jflexant.xml new file mode 100644 index 0000000..aeedd5f --- /dev/null +++ b/ÜB-Praxis-Scanner für Namen-Leer/lib/jflexant.xml @@ -0,0 +1,12 @@ + + + + Generate Scanner from lex-files + + + + + + + + \ No newline at end of file diff --git a/ÜB-Praxis-Scanner für Namen-Leer/src/de/dhbw/compiler/namenscanner/NamenScanner.java b/ÜB-Praxis-Scanner für Namen-Leer/src/de/dhbw/compiler/namenscanner/NamenScanner.java new file mode 100644 index 0000000..dddb925 --- /dev/null +++ b/ÜB-Praxis-Scanner für Namen-Leer/src/de/dhbw/compiler/namenscanner/NamenScanner.java @@ -0,0 +1,117 @@ +/* ********************************************** + * Duale Hochschule Baden-Württemberg Karlsruhe + * Prof. Dr. Jörn Eisenbiegler + * + * Vorlesung Übersetzerbau + * Praxis AS-Scanner tabellengesteuert 1 + * + * ********************************************** + */ + +package de.dhbw.compiler.namenscanner; + +import java.io.IOException; +import java.io.Reader; + +import de.dhbw.compiler.namenscanner.Token; + +public class NamenScanner { + + private final int ignore = -2; + + private Reader in = null; + private StringBuffer text = new StringBuffer(); + + private enum NamenState { WS, P, PE, PET, PETR, PETRA, PETE, PETER, A, AN, ANN, ANNA, EOF}; + + private NamenState state = NamenState.WS; + private int tokentype = Token.INVALID; + + + public NamenScanner(Reader input) { + this.in = input; + } + + private Token step(int c, NamenState newState, boolean create, int newTokenType) { + Token res = null; + if (create) { + res = new Token(tokentype, text.toString()); + text = new StringBuffer(); + } + if (c!=ignore) { + text.append((char)c); + } + state = newState; + tokentype = newTokenType; + return res; + } + + public Token nextToken() throws Exception { + Token token = null; + while (token == null) { + char c = nextCharacter(); + + // peter + switch (state) { + case WS: + switch (c) { + case (char) -1: token = step(ignore, NamenState.EOF, false, Token.EOF); break; + case ' ': case '\t': case '\n': case '\r': token = step(ignore, NamenState.WS, false, Token.INVALID); break; + case 'p': token = step(c, NamenState.P, false, Token.INVALID); break; + case 'a': token = step(c, NamenState.A, false, Token.INVALID); break; + default: + if (('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z')) { + token = step(c, NamenState.WS, false, Token.INVALID); + } else { + throw new Exception("Unexpected character: " + c + " (" + (int) c + ")"); + } break; + } break; + case P: + switch (c) { + case (char) -1: token = step(ignore, NamenState.EOF, false, Token.EOF); break; + case ' ': case '\t': case '\n': case '\r': token = step(ignore, NamenState.WS, false, Token.INVALID); break; + case '': token = step(c, NamenState.P, false, Token.INVALID); break; + case 'A': token = step(c, NamenState.A, false, Token.INVALID); break; + default: + if (('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z')) { + token = step(c, NamenState.WS, false, Token.INVALID); + } else { + throw new Exception("Unexpected character: " + c + " (" + (int) c + ")"); + } break; + } break; + case PE: + break; + case PET: + break; + case PETR: + break; + case PETRA: + break; + case PETE: + break; + case PETER: + break; + case A: + break; + case AN: + break; + case ANN: + break; + case ANNA: + break; + case EOF: + break; + } + } + return token; + } + + private char nextCharacter() { + try { + return (char) in.read(); + } catch (IOException e) { + e.printStackTrace(); + } + } + +} diff --git a/ÜB-Praxis-Scanner für Namen-Leer/src/de/dhbw/compiler/namenscanner/NamenScannerMain.java b/ÜB-Praxis-Scanner für Namen-Leer/src/de/dhbw/compiler/namenscanner/NamenScannerMain.java new file mode 100644 index 0000000..fc527cd --- /dev/null +++ b/ÜB-Praxis-Scanner für Namen-Leer/src/de/dhbw/compiler/namenscanner/NamenScannerMain.java @@ -0,0 +1,34 @@ +/* ********************************************** + * Duale Hochschule Baden-Württemberg Karlsruhe + * Prof. Dr. Jörn Eisenbiegler + * + * Vorlesung Übersetzerbau + * Praxis AS-Scanner mit JFlex 1 + * + * ********************************************** + */ + +package de.dhbw.compiler.namenscanner; + +import java.io.StringReader; + + +public class NamenScannerMain { + + private static final String TEST = "anna peter petra"; + + public static void main(String[] args) throws Exception { + + NamenScanner scanner = new NamenScanner(new StringReader(TEST)); + + Token mytoken = scanner.nextToken(); + + while (mytoken.getType()!=Token.EOF) { + System.out.println(mytoken); + mytoken = scanner.nextToken(); + } + + System.out.println(mytoken); + } + +} diff --git a/ÜB-Praxis-Scanner für Namen-Leer/src/de/dhbw/compiler/namenscanner/TestNamenScanner1.java b/ÜB-Praxis-Scanner für Namen-Leer/src/de/dhbw/compiler/namenscanner/TestNamenScanner1.java new file mode 100644 index 0000000..2d52166 --- /dev/null +++ b/ÜB-Praxis-Scanner für Namen-Leer/src/de/dhbw/compiler/namenscanner/TestNamenScanner1.java @@ -0,0 +1,219 @@ +/* ********************************************** + * Duale Hochschule Baden-Württemberg Karlsruhe + * Prof. Dr. Jörn Eisenbiegler + * + * Vorlesung Übersetzerbau + * Praxis AS-Scanner mit JFlex + * - Testfälle Aufgabe 1 + * + * ********************************************** + */ + +package de.dhbw.compiler.namenscanner; + +import org.junit.Test; + +public class TestNamenScanner1 extends TokenStreamTest { + + @Test + public void tokenPeter() throws Exception { + testTokenList("peter", new Token(Token.PETER, "peter")); + testTokenList(" peter ", new Token(Token.PETER, "peter")); + testTokenList(" peter peter ", new Token(Token.PETER, "peter"), + new Token(Token.PETER, "peter")); + testTokenList(" peterpeter ", new Token(Token.PETER, "peter"), + new Token(Token.PETER, "peter")); + testTokenList("peterpeter", new Token(Token.PETER, "peter"), + new Token(Token.PETER, "peter")); + } + + @Test + public void tokenPetra() throws Exception { + testTokenList("petra", new Token(Token.PETRA, "petra")); + testTokenList(" petra ", new Token(Token.PETRA, "petra")); + testTokenList(" petra petra ", new Token(Token.PETRA, "petra"), + new Token(Token.PETRA, "petra")); + testTokenList(" petrapetra ", new Token(Token.PETRA, "petra"), + new Token(Token.PETRA, "petra")); + testTokenList("petrapetra", new Token(Token.PETRA, "petra"), + new Token(Token.PETRA, "petra")); + } + + @Test + public void tokenAnna() throws Exception { + testTokenList("anna", new Token(Token.ANNA, "anna")); + testTokenList(" anna ", new Token(Token.ANNA, "anna")); + testTokenList(" anna anna ", new Token(Token.ANNA, "anna"), + new Token(Token.ANNA, "anna")); + testTokenList(" annaanna ", new Token(Token.ANNA, "anna"), + new Token(Token.ANNA, "anna")); + testTokenList("annaanna", new Token(Token.ANNA, "anna"), + new Token(Token.ANNA, "anna")); + } + + @Test + public void tokenPeterPetraAnna() throws Exception { + testTokenList("peter petra anna", new Token(Token.PETER, "peter"), + new Token(Token.PETRA, "petra"), + new Token(Token.ANNA, "anna")); + testTokenList(" peter petra anna ", new Token(Token.PETER, "peter"), + new Token(Token.PETRA, "petra"), + new Token(Token.ANNA, "anna")); + testTokenList("peterpetraanna", new Token(Token.PETER, "peter"), + new Token(Token.PETRA, "petra"), + new Token(Token.ANNA, "anna")); + } + + @Test + public void tokenAnnaPetraPeter() throws Exception { + testTokenList("anna petra peter", + new Token(Token.ANNA, "anna"), + new Token(Token.PETRA, "petra"), + new Token(Token.PETER, "peter")); + testTokenList(" anna petra peter ", + new Token(Token.ANNA, "anna"), + new Token(Token.PETRA, "petra"), + new Token(Token.PETER, "peter")); + testTokenList("annapetrapeter", + new Token(Token.ANNA, "anna"), + new Token(Token.PETRA, "petra"), + new Token(Token.PETER, "peter")); + } + + @Test + public void tokenPetraAnnaPeter() throws Exception { + testTokenList("petra anna peter", + new Token(Token.PETRA, "petra"), + new Token(Token.ANNA, "anna"), + new Token(Token.PETER, "peter")); + testTokenList(" petra anna peter ", + new Token(Token.PETRA, "petra"), + new Token(Token.ANNA, "anna"), + new Token(Token.PETER, "peter")); + testTokenList("petraannapeter", + new Token(Token.PETRA, "petra"), + new Token(Token.ANNA, "anna"), + new Token(Token.PETER, "peter")); + } + + @Test + public void tokenViele() throws Exception { + testTokenList("petra anna peterannapeterpetra petra annaanna peter", + new Token(Token.PETRA, "petra"), + new Token(Token.ANNA, "anna"), + new Token(Token.PETER, "peter"), + new Token(Token.ANNA, "anna"), + new Token(Token.PETER, "peter"), + new Token(Token.PETRA, "petra"), + new Token(Token.PETRA, "petra"), + new Token(Token.ANNA, "anna"), + new Token(Token.ANNA, "anna"), + new Token(Token.PETER, "peter")); + } + + @Test(expected = Exception.class) + public void tokenX() throws Exception { + testTokenList("x", new Token(Token.PETER, "peter")); + } + + @Test(expected = Exception.class) + public void tokenWSx() throws Exception { + testTokenList(" x", new Token(Token.PETER, "peter")); + } + + @Test(expected = Exception.class) + public void tokenP() throws Exception { + testTokenList("p", new Token(Token.PETER, "peter")); + } + + @Test(expected = Exception.class) + public void tokenPe() throws Exception { + testTokenList("pe", new Token(Token.PETER, "peter")); + } + + @Test(expected = Exception.class) + public void tokenPet() throws Exception { + testTokenList("pet", new Token(Token.PETER, "peter")); + } + + @Test(expected = Exception.class) + public void tokenPetr() throws Exception { + testTokenList("petr", new Token(Token.PETER, "peter")); + } + + @Test(expected = Exception.class) + public void tokenPete() throws Exception { + testTokenList("pete", new Token(Token.PETER, "peter")); + } + + @Test(expected = Exception.class) + public void tokenA() throws Exception { + testTokenList("a", new Token(Token.ANNA, "anna")); + } + + @Test(expected = Exception.class) + public void tokenAn() throws Exception { + testTokenList("an", new Token(Token.ANNA, "anna")); + } + + @Test(expected = Exception.class) + public void tokenAnn() throws Exception { + testTokenList("ann", new Token(Token.ANNA, "anna")); + } + + @Test(expected = Exception.class) + public void tokenPx() throws Exception { + testTokenList("px", new Token(Token.PETER, "peter")); + } + + @Test(expected = Exception.class) + public void tokenPex() throws Exception { + testTokenList("pex", new Token(Token.PETER, "peter")); + } + + @Test(expected = Exception.class) + public void tokenPetx() throws Exception { + testTokenList("petx", new Token(Token.PETER, "peter")); + } + + @Test(expected = Exception.class) + public void tokenPetrx() throws Exception { + testTokenList("petrx", new Token(Token.PETER, "peter")); + } + + @Test(expected = Exception.class) + public void tokenPetrax() throws Exception { + testTokenList("petrax", new Token(Token.PETER, "peter")); + } + + @Test(expected = Exception.class) + public void tokenPetex() throws Exception { + testTokenList("petex", new Token(Token.PETER, "peter")); + } + + @Test(expected = Exception.class) + public void tokenPeterx() throws Exception { + testTokenList("peterx", new Token(Token.PETER, "peter")); + } + + @Test(expected = Exception.class) + public void tokenAx() throws Exception { + testTokenList("ax", new Token(Token.ANNA, "anna")); + } + + @Test(expected = Exception.class) + public void tokenAnx() throws Exception { + testTokenList("anx", new Token(Token.ANNA, "anna")); + } + + @Test(expected = Exception.class) + public void tokenAnnx() throws Exception { + testTokenList("annx", new Token(Token.ANNA, "anna")); + } + + @Test(expected = Exception.class) + public void tokenAnnax() throws Exception { + testTokenList("annx", new Token(Token.ANNA, "anna")); + } + +} diff --git a/ÜB-Praxis-Scanner für Namen-Leer/src/de/dhbw/compiler/namenscanner/TestsAll.java b/ÜB-Praxis-Scanner für Namen-Leer/src/de/dhbw/compiler/namenscanner/TestsAll.java new file mode 100644 index 0000000..166acca --- /dev/null +++ b/ÜB-Praxis-Scanner für Namen-Leer/src/de/dhbw/compiler/namenscanner/TestsAll.java @@ -0,0 +1,22 @@ +/* ********************************************** + * Duale Hochschule Baden-Württemberg Karlsruhe + * Prof. Dr. Jörn Eisenbiegler + * + * Vorlesung Übersetzerbau + * Praxis AS-Scanner mit JFlex + * - Testsuite + * + * ********************************************** + */ + +package de.dhbw.compiler.namenscanner; + +import org.junit.runner.RunWith; +import org.junit.runners.Suite; +import org.junit.runners.Suite.SuiteClasses; + +@RunWith(Suite.class) +@SuiteClasses({ TestNamenScanner1.class }) +public class TestsAll { + +} diff --git a/ÜB-Praxis-Scanner für Namen-Leer/src/de/dhbw/compiler/namenscanner/Token.java b/ÜB-Praxis-Scanner für Namen-Leer/src/de/dhbw/compiler/namenscanner/Token.java new file mode 100644 index 0000000..9e9beaf --- /dev/null +++ b/ÜB-Praxis-Scanner für Namen-Leer/src/de/dhbw/compiler/namenscanner/Token.java @@ -0,0 +1,54 @@ +/* ********************************************** + * Duale Hochschule Baden-Württemberg Karlsruhe + * Prof. Dr. Jörn Eisenbiegler + * + * Vorlesung Übersetzerbau + * Praxis AS-Scanner mit JFlex + * - Token-Definition + * + * ********************************************** + */ + +package de.dhbw.compiler.namenscanner; + +public class Token { + + public static final int EOF = 0; + public static final int INVALID = -1; + public static final int PETER = 1; + public static final int PETRA = 2; + public static final int ANNA = 3; + + private int type; + private String text; + + public Token(int type, String text) { + this.type = type; + this.text = text; + } + + public int getType() { + return type; + } + + public String getText() { + return text; + } + + public String toString() { + return "(" + getTypeName(type) + "," + text + ")"; + } + + public static String getTypeName(int tokenType) { + switch (tokenType) { + case EOF: return "EOF"; + case INVALID: return "INVALID"; + case PETER: return "peter"; + case PETRA: return "petra"; + case ANNA: return "anna"; + default: return "Unknown token type!"; + } + + } + +} diff --git a/ÜB-Praxis-Scanner für Namen-Leer/src/de/dhbw/compiler/namenscanner/TokenStreamTest.java b/ÜB-Praxis-Scanner für Namen-Leer/src/de/dhbw/compiler/namenscanner/TokenStreamTest.java new file mode 100644 index 0000000..444340a --- /dev/null +++ b/ÜB-Praxis-Scanner für Namen-Leer/src/de/dhbw/compiler/namenscanner/TokenStreamTest.java @@ -0,0 +1,39 @@ +/* ********************************************** + * Duale Hochschule Baden-Württemberg Karlsruhe + * Prof. Dr. Jörn Eisenbiegler + * + * Vorlesung Übersetzerbau + * Praxis AS-Scanner mit JFlex + * - Testfall-Utility + * + * ********************************************** + */ + +package de.dhbw.compiler.namenscanner; + +import static org.junit.Assert.assertEquals; + +import java.io.StringReader; + +import de.dhbw.compiler.namenscanner.NamenScanner; +import de.dhbw.compiler.namenscanner.Token; + +public abstract class TokenStreamTest { + + protected void testTokenList(String in, Token... TokenList) throws Exception { + NamenScanner scanner = new NamenScanner(new StringReader(in)); + Token myToken; + + for (Token expected : TokenList) { + myToken = scanner.nextToken(); + assertEquals("Expect Token "+expected.toString()+". Error in type.", + expected.getType(), myToken.getType()); + assertEquals("Expect Token "+expected.toString()+". Error in text.", + expected.getText(), myToken.getText()); + } + + myToken = scanner.nextToken(); + assertEquals("Expected End of File (EOF), read " + myToken.toString() + ".", Token.EOF, myToken.getType()); + } + +} diff --git a/ÜB-Praxis-Scanner für Namen-Leer/ÜB-Praxis-Scanner für Namen-Leer.iml b/ÜB-Praxis-Scanner für Namen-Leer/ÜB-Praxis-Scanner für Namen-Leer.iml new file mode 100644 index 0000000..8b58b70 --- /dev/null +++ b/ÜB-Praxis-Scanner für Namen-Leer/ÜB-Praxis-Scanner für Namen-Leer.iml @@ -0,0 +1,22 @@ + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file