Tout d'abord, jetons un coup d'œil au segment de code que nous voulons analyser comme suit:
Le résultat de sortie est le suivant:
Résultat de sortie (a) .png
Résultat de sortie (b) .png
Résultat de sortie (c) .png
Il y a une expression binaire entre parenthèses: (codage de catégorie de mots, numéro de position de mot)
Le code est le suivant:
package yue.lexicalAnalyzer; Importer java.io. *; / * * Programme principal * / classe publique Main {public static void main (String [] args) lève ioException {lexer lexer = new lexer (); lexer.printToken (); lexer.printSymbolStable (); }} package yue.lexicalanalyzer; import java.io. *; import java.util. *; / * * Analyse et sortie lexicale * / classe publique Lexer {/ * Numéro de ligne d'enregistrement * / public static int line = 1; / * Stockage Les derniers caractères de lecture * / char caractères = ''; / * Reserve Words * / HashTable <String, Keyword> Keywords = new HashTable <String, Keyword> (); / * Séquence de token * / private ArrayList <Stacked> tokens = new ArrayList <Token> (); / * Table de symbole * / private ArrayList <Symbol> symtable = new ArrayList <Symbol> (); / * Lire la variable de fichier * / BufferedReader Reader = NULL; / * Enregistrez si la fin du fichier est actuellement lue * / private boolean isEnd = false; / * Si la fin du fichier est lue * / public boolean getRederstate () {return this.isend; } / * Séquence de jetons d'impression * / public void printtoken () lève ioException {filewriter writer = new FileWriter ("e: //lex.txt"); System.out.println ("Les résultats de l'analyse lexicale sont les suivants:"); System.out.print ("Du Yue-2015220201031 / R / N / N"); écrivain.write ("Du Yue-2015220201031 / r / n / r / n"); while (getReDerState () == false) {token tok = scan (); String str = "line" + tok.line + "/ t (" + tok.tag + "," + tok.pos + ") / t / t" + tok.name + ":" + tok.tostring () + "/ r / n"; écrivain.write (STR); System.out.print (STR); } writer.flush (); } / * Tableau de symboles d'impression * / public void impritsymbolStable () lève ioException {filewriter writer = new FileWriter ("e: //symtab1.txt"); System.out.print ("/ r / n / r / n Tableau de symbole / r / n"); System.out.print ("numéro / t Ligne numéro / t nom / r / n"); writer.write ("Table des symboles / r / n"); writer.write ("nombre" + "/ t Line numéro" + "/ t name / r / n"); Iterator <Symbol> e = symTable.Iterator (); while (e.hasnext ()) {symbole symbol = e.next (); String desc = symbol.pos + "/ t" + symbol.line + "/ t" + symbol.toString (); System.out.print (desc + "/ r / n"); writer.write (desc + "/ r / n"); } writer.flush (); } / * Imprimer Error * / public void printeror (token tok) lève ioException {filewriter writer = new FileWriter ("e: //error.txt"); System.out.print ("/ r / n / r / n La lexicographie des erreurs est la suivante: / r / n"); écrivain.write ("Lexicographie des erreurs est la suivante: / r / n"); String str = "line" + tok.line + "/ t (" + tok.tag + "," + tok.pos + ") / t / t" + tok.name + ":" + tok.tostring () + "/ r / n"; écrivain.write (STR); } / * Ajouter des mots réservés * / void réserve (mot-clé w) {keywords.put (w.lexme, w); } public lexer () {/ * Initialiser la variable de fichier de lecture * / try {Reader = new BuffereDReader (new FileReader ("e: //input.txt")); } catch (ioException e) {System.out.print (e); } / * Ajouter des mots réservés * / this.reserve (Keyword.Begin); this.reserve (Keyword.end); this.reserve (Keyword.Integer); this.reserve (Keyword.Function); this.reserve (Keyword.read); this.reserve (Keyword.Write); this.reserve (Keyword.aif); this.reserve (Keyword.athen); this.reserve (Keyword.aelse); } / * Lire par le caractère * / public void Readch () lève ioException {caractères = (char) reader.read (); if ((int) caractères == 0xffff) {this.isend = true; }} / * Juger si cela correspond * / public booléen Readch (char ch) lève ioException {readch (); if (this.character! = ch) {return false; } this.character = ''; Retour Vrai; } / * La reconnaissance des nombres * / public booléen isdigit () lève ioException {if (caractères.isdigit (caractères)) {int value = 0; while (caractères.isdigit (caractères)) {value = 10 * value + caractères.digit (caractères, 10); Readch (); } Num n = new num (valeur); n.line = ligne; tokens.add (n); Retour Vrai; } else return false; } / * La reconnaissance des mots et identifiants réservés * / public booléen iSletter () lève ioException {if (wories.isletter (caractères)) {stringBuffer sb = new StringBuffer (); / * Obtenez d'abord toute la division * / while (while.isletterordiGit (caractères)) {sb.append (caractère); Readch (); } / * Juger s'il s'agit d'un mot réservé ou d'un identifiant * / string s = sb.toString (); Mot-clé w = keywords.get (s); / * S'il s'agit d'un mot réservé, w ne doit pas être vide * / if (w! = Null) {w.line = line; tokens.add (w); } else {/ * Sinon, c'est un identifiant, ici il y a des instructions supplémentaires qui enregistrent le numéro d'identifiant * / symbole sy = nouveau symbole (s); Symbole mark = sy; // Utilisé pour marquer l'identifiant existant booléen isRepeat = false; sy.line = ligne; pour (symbole i: symntable) {if (sy.toString (). equals (i.toString ())) {mark = i; iSrepeat = true; }} if (! IsRepeat) {sy.pos = symtable.size () + 1; syntable.add (sy); } else if (isRepeat) {sy.pos = mark.pos; } tokens.add (sy); } return true; } else return false; } / * Reconnaissance du symbole * / public boolean issign () lève ioException {switch (caractère) {case '#': readch (); Allend.Allend.line = ligne; tokens.add (Allend.Allend); Retour Vrai; case '/ r': if (readch ('/ n')) {readch (); Lineend.lineend.line = ligne; tokens.add (lineend.lineend); line ++; Retour Vrai; } case '(': readch (); Delimiter.lpar.line = line; tokens.add (Delimiter.lpar); return true; case ')': Readch (); Delimiter.rpar.line = ligne; tokens.add (Delimiter.rpar); Retour Vrai; cas ';': Readch (); Delimiter.sem.line = ligne; tokens.add (Demiter.sem); Retour Vrai; case '+': Readch (); Calcword.add.line = ligne; tokens.add (calcword.add); Retour Vrai; case '-': Readch (); Calcword.sub.line = ligne; tokens.add (calcword.sub); Retour Vrai; case '*': Readch (); Calcword.mul.line = ligne; tokens.add (calcword.mul); Retour Vrai; case '/': Readch (); Calcword.div.line = ligne; tokens.add (calcword.div); Retour Vrai; case ':': if (readch ('=')) {readch (); Calcword.assign.line = ligne; tokens.add (calcword.assign); Retour Vrai; } casser; case '>': if (Readch ('=')) {Readch (); Calcword.ge.line = ligne; tokens.add (calcword.ge); Retour Vrai; } casser; Cas '<': if (Readch ('=')) {Readch (); Calcword.le.line = ligne; tokens.add (calcword.le); Retour Vrai; } casser; case '!': if (Readch ('=')) {Readch (); Calcword.ne.line = ligne; tokens.add (calcword.ne); Retour Vrai; } casser; } return false; } / * Ce qui suit commence à diviser les mots clés, les identifiants et autres informations * / public token scan () lève ioException {token tok; while (caractères == '') Readch (); if (isDigit () || issign () || iSletter ()) {tok = tokens.get (tokens.size () - 1); } else {tok = new token (caractère); Printeror (TOK); } return tok; }} package yue.lexicalanalyzer; / * * token Parent class * / public class token {public final int tag; Ligne int publique = 1; Nom de chaîne publique = ""; public int pos = 0; Token public (int t) {this.tag = t; } public String toString () {return "" + (char) tag; }} Package yue.lexicalAnalyzer; / * * Word Catégorie Affectation * / public class Tag {public final static int début = 1, // word réservé end = 2, // word réservé entier = 3, // word réservé function = 4, // word réservé lecture = 5, // word réservé write = 6, // word réservé si = 7 word réservé alors = 8, ^ 11, // Identifiant constant = 12, // constant add = 13, // opérateur "+" sub = 14, // opérateur "-" Mul = 15, // opérateur "*" div = 16, // opérateur "/" le = 18, // opérateur "<=" ge = 19, // opérateur "> =" ne = 20, // opératrice "! =" Assign = 23, // Operator ": =" lpar = 24, " // Opérateur "(" RPAR = 25, // Opérateur ")" SEM = 26, // Opérateur ";" Line_end = 27, // opérateur all_end = 28; // Opérateur "#"} Package yue.lexicalanalyzer; / ** * Mots réservés * / Mot-clé de classe publique étend Token {public String lexme = ""; mot-clé public (String s, int t) {super (t); this.lexme = s; this.name = "mots réservés"; } public String toString () {return this.lexme; } public static final mot-clé begin = nouveau mot-clé ("begin", tag.begin), end = nouveau mot clé ("end", tag.end), Integer = nouveau mot clé ("Integer", tag.integer), function = new Keyword ("function", tag.function), read = new Keyword ("read", tag.read), write = new Keyword ("write", tag), aif Mot-clé ("if", tag.if), athen = nouveau mot-clé ("alors", tag.phe), aelse = nouveau mot-clé ("else", tag.else);} package yue.lexicalanalyzer; / * * identifiant * / public class symbol étend token {public String lexme = ""; Symbole public (String S) {super (tag.Symbol); this.lexme = s; this.name = "identifiant"; } public String toString () {return this.lexme; }} package yue.lexicalanalyzer; / ** * opérateur * / classe publique calcword étend le jet de jet {public string lexme = ""; public calcword (String s, int t) {super (t); this.lexme = s; this.name = "opérateur"; } public String toString () {return this.lexme; } public static final calcword add = new calcword ("+", tag.add), sub = new calcword ("-", tag.sub), mul = new calcword ("*", tag.mul), div = new calcword ("/", tag.div), le = new calcword ("<=", tag.le), ge = new calcword ("> =", tag.ge), nne = new = "! ="! Tag.ne), attribution = nouveau calcword (": =", tag.assign);} package yue.lexicalanalyzer; / ** * Symbole de limite * / classe publique Delimiter étend le jet de jet {public String lexme = ""; public Delimiter (String S, int t) {super (t); this.lexme = s; this.name = "Symbole de limite"; } public String toString () {return this.lexme; } public static final Delimiter lpar = new Demiter ("(", tag.lpar), rpar = newlimiter (")", tag.rpar), sem = new Demiter (";", tag.sem);} package yue.lexicalanalyzer; / * * constante * / classe publique num étend le jet de token {public final int value; public num (int v) {super (tag.Constant); this.value = v; this.name = "constante"; } public String toString () {return "" + value; }} package yue.lexicalanalyzer; / ** * Fin de ligne des caractères * / classe publique Lineend étend le jet de jet {public string lexme = ""; public lineend (String s) {super (tag.line_end); this.lexme = s; this.name = "Fin of Line Characters"; } public String toString () {return this.lexme; } public static final lineend lineend = new Lineend ("/ r / n");} Package yue.lexicalanalyzer; / ** * Ending Caractor * / public class allend étend token {public String lexme = ""; public allend (String S) {super (tag.all_end); this.lexme = s; this.name = "End Character"; } public String toString () {return this.lexme; } Public statique final Allend Allend = New Allend ("#");}Résumer
Je vais coucher avec tout le contenu de cet article. J'espère que le contenu de cet article sera d'une aide à votre étude ou à votre travail. Si vous avez des questions, vous pouvez laisser un message pour communiquer.