Java Programming Below are the lexerjava tokenjava and .pdf

Java Programming: Below are the lexer.java, token.java, and shank.java. Shank.java is the main
method file. The goal is to make sure to read the shank.txt file as a series of tokens & show the
screenshot of shank.txt printed in console of eclipse. Make sure the lexer has all the state
machines. Attached is rubric where all the required components a lexer must have. Attached is
images of the errors the lexer has so make sure to fix those errors as well. Attached is image of
how the output must be printed out as after all the errors are fixed.
Lexer.java
package mypack;
import java.util.ArrayList;
import java.util.List;
import mypack.Token.TokenType;
import java .util.HashMap;
public class Lexer {
private static final int INTEGER_STATE = 1;
private static final int DECIMAL_STATE = 2;
private static final int IDENTIFIER_STATE = 3;
private static final int ERROR_STATE = 4;
private static final int SYMBOL_STATE = 5;
private static final int STRING_STATE = 6;
private static final int CHAR_STATE = 7;
private static final int COMMENT_STATE = 8;
private static final char EOF = (char) -1;
private static String input;
private static int index;
private static char currentChar;
private static int lineNumber = 1;
private static int indentLevel = 0;
private static int lastIndentLevel = 0;
private static HashMap<String, TokenType> keywords = new HashMap<String, TokenType>() {{
put("while", TokenType.WHILE);
put("if", TokenType.IF);
put("else", TokenType.ELSE);
put("print", TokenType.PRINT);
}};
private static HashMap<Character, TokenType> symbols = new HashMap<Character,
TokenType>() {{
put('+', TokenType.PLUS);
put('-', TokenType.MINUS);
put('*', TokenType.MULTIPLY);
put('/', TokenType.DIVIDE);

put('=', TokenType.EQUALS);
put(':', TokenType.COLON);
put(';', TokenType.SEMICOLON);
put('(', TokenType.LEFT_PAREN);
put(')', TokenType.RIGHT_PAREN);
put('{', TokenType.LEFT_BRACE);
put('}', TokenType.RIGHT_BRACE);
put('<', TokenType.LESS_THAN);
put('>', TokenType.GREATER_THAN);
}};
public Lexer(String input) {
Lexer.input = input;
index = 0;
currentChar = input.charAt(index);
}
private void nextChar() {
index++;
if (index >= input.length()) {
currentChar = EOF;
} else {
}
}
private void skipWhiteSpace() {
while (Character.isWhitespace(currentChar)) {
nextChar();
}
}
private int getIndentLevel() {
int level = 0;
int i = index;
char c = input.charAt(i);
while (c == ' ' || c == 't') {
if (c == 't') {
level += 1;
} else if (c == ' ') {
level += 1;
}
i++;
if (i >= input.length()) {

break;
}
c = input.charAt(i);
}
return level;
}
public List<Token> lex(String inputString) throws Exception {
input = inputString;
index = 0;
List<Token> tokens = new ArrayList<Token>();
while (currentChar != EOF) {
switch (currentState()) {
case INTEGER_STATE:
integerState(tokens);
break;
case DECIMAL_STATE:
decimalState(tokens);
break;
case IDENTIFIER_STATE:
identifierState(tokens);
break;
case ERROR_STATE:
errorState(tokens);
break;
case SYMBOL_STATE:
symbolState(tokens);
break;
case STRING_STATE:
stringState(tokens);
break;
case CHAR_STATE:
charState(tokens);
break;
case COMMENT_STATE:
commentState(tokens);
break;
default:
break;
}
}
return tokens;
}
private void s (List<Token> tokens) {

//TODO Auto-generated method stub
}
private static int currentState() {
if (Character.isDigit(currentChar)) {
return INTEGER_STATE;
} else if (Character.isLetter(currentChar)) {
return IDENTIFIER_STATE;
} else if (currentChar == '.') {
return DECIMAL_STATE;
return STRING_STATE;
return CHAR_STATE;
}else if (Character.isLetter(currentChar)) {
return COMMENT_STATE;
}else if (Character.isDigit(currentChar)) {
return SYMBOL_STATE;
} else {
return ERROR_STATE;
}
}
private static void integerState(List<Token> tokens) {
StringBuilder builder = new StringBuilder();
while (Character.isDigit(currentChar)) {
builder.append(currentChar);
advance();
}
tokens.add(new Token(Token.TokenType.NUMBER, builder.toString()));
}
private static void decimalState(List<Token> tokens) {
advance();
while (Character.isDigit(currentChar)) {
advance();
}
tokens.add(new Token(Token.TokenType.NUMBER, builder.toString()));
}
private static void identifierState(List<Token> tokens) {

while (Character.isLetterOrDigit(currentChar)) {
advance();
}
tokens.add(new Token(Token.TokenType.WORD, builder.toString()));
}
private static void errorState(List<Token> tokens) {
advance();
}
}
private static void symbolState(List<Token> tokens) {
advance();
}
tokens.add(new Token(Token.TokenType.SYMBOL, builder.toString()));
}
private static void stringState(List<Token> tokens) {
advance();
}
}
private static void charState(List<Token> tokens) {
advance();
}
}
private static void commentState(List<Token> tokens) {

advance();
}
}
private static void advance() {
index++;
if (index >= input.length()) {
currentChar = EOF;
} else {
}
}
}
Token.java
package mypack;
public class Token {
public enum TokenType {
WORD, WHILE, IF, ELSE,
NUMBER,
SYMBOL, PLUS, MINUS, MULTIPLY, DIVIDE, EQUALS, COLON, SEMICOLON, LEFT_PAREN,
RIGHT_PAREN, LEFT_BRACE, RIGHT_BRACE, LESS_THAN, GREATER_THAN, PRINT
}
public TokenType tokenType;
private String value;
public Token(TokenType type, String val) {
this.tokenType = type;
this.value = val;
}
public TokenType getTokenType() {
return this.tokenType;
}
public String toString() {
return this.tokenType + ": " + this.value;
}
}

Shank.java
package mypack;
import java.io.IOException;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.List;
public class Shank {
public static void main(String[] args) {
Path filePath = Paths.get("shank.txt");
Charset charset = StandardCharsets.UTF_8;
if (args.length != 1) {
System.out.println("Error: Exactly one argument is required.");
System.exit(0);
}
String filename = args[0];
try {
List<String> lines = Files.readAllLines(Paths.get(filename));
for (String line : lines) {
try {
Lexer lexer = new Lexer(line);
List<Token> tokens = lexer.lex(line);
for (Token token : tokens) {
System.out.println(token);
}
} catch (Exception e) {
System.out.println("Exception: " + e.getMessage());
}
}
} catch (IOException e) {
System.out.println("Error: Could not read file '" + filename + "'.");
}
}
}
shank.txt
Fibonoacci (Iterative)

define add (num1,num2:integer var sum : integer)
variable counter : integer
Finonacci(N)
int N = 10;
while counter < N
define start ()
variables num1,num2,num3 : integer
add num1,num2,var num3
{num1 and num2 are added together to get num3}
num1 = num2;
num2 = num3;
counter = counter + 1;
GCD (Recursive)
define add (int a,int b : gcd)
if b = 0
sum = a
sum gcd(b, a % b)
GCD (Iterative)
define add (inta, intb : gcd)
if a = 0
sum = b
if b = 0
sum = a
while counter a != b
if a > b
a = a - b;
else
b = b - a;
sum = a;
variables a,b : integer
a = 60
b = 96
subtract a,b
input. addnum1num2varnum3num1andnum2nreaddedtogethertogetnum3num1=num2num2=
num3counter=counter+1GCDRecurgivedefineaddidentifieridentifieridentifieridentifieridentifier
identifieridentifieridentifieridentifieridentifieridentifieridentifieridentifieridentifieridentifieroperator
identifieridentifieroperatoridentifieridentifieroperatoridentifieroperatorintegerliternlidentifieridentifier
keywordidentifierCompilation failed due to following error(s).

Java Programming Below are the lexerjava tokenjava and .pdf

Recommended

Recommended

More Related Content

Similar to Java Programming Below are the lexerjava tokenjava and .pdf

Similar to Java Programming Below are the lexerjava tokenjava and .pdf (19)

More from adinathassociates

More from adinathassociates (20)

Recently uploaded

Recently uploaded (20)

Java Programming Below are the lexerjava tokenjava and .pdf