Compiler Type Promotion - casting

Question

I am making a compiler as an exercise before applying to jobs, and am working by myself but following a college course website (thus I have already graduated, this is not schoolwork).
Currently, I am unsure how to resolve typecasting with post-fix notation. If I have:
"1.0 plus 2 equals" + 1.0 + 2
and
1+2/(3-4)
Then in post fix notation, I can obtain
STR[1,0]:"1.0 plus 2 equals"
DBL[1,22]:1.0
INT[1,28]:2
ADD[1,26]:+
ADD[1,20]:+
and
INT[0,0]:1
INT[0,2]:2
INT[0,5]:3
INT[0,7]:4
SUB[0,6]:-
DIV[0,3]:/
ADD[0,1]:+
I am unsure of how to evaluate the first. Currently I have assumed everything to (incorrectly) be doubles and have obtained this code (under Compiler.java):
static Object evaluate(List<Token> tokens)
{
Stack<Double> stack = new Stack<>();
for (Token token : tokens)
{
if (token.isEX())
stack.push(Double.parseDouble(token.getLexeme()));
else
{
Double a = stack.pop();
Double b = stack.pop();
switch (token.getType())
{
case ADD:
stack.push(b+a);
break;
case SUB:
stack.push(b-a);
break;
case MUL:
stack.push(b*a);
break;
case DIV:
stack.push(b/a);
break;
case MOD:
stack.push(b%a);
break;
}
}
}
return stack.pop();
}
I can correctly evaluate the second to -1, but this has two obvious problems, it promotes an integer when it doesn't need to, and it doesn't work for string concatenation.
A direct answer would be nice, but some hints/websites or guides would be greatly appreciated instead.
Here are the files for understanding this code (though it is generic to many other homemade compilers):
Compiler.java:
import java.util.List;
import java.util.Stack;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Compiler
{
/**
* Converts code string to direct stack of tokens
*
* #param line source of code
* #param lineNum line number
* #return stack of tokens in line order
*/
static Stack<Token> tokenize(String line, int lineNum)
{
Stack<Token> tokens = new Stack<>();
Pattern p = Pattern.compile(Token.regex);
Matcher m = p.matcher(line);
while (m.find())
tokens.push(new Token(m.group(), lineNum, m.start()));
return tokens;
}
/**
* Formats stack of tokens to postfix notation (Shunting-Yard Algorithm)
*
* #param tokens to be added.
* #return stack tokens in postfix notation
*/
static Stack<Token> format(Stack<Token> tokens)
{
Stack<Token> out = new Stack<>();
Stack<Token> tmp = new Stack<>();
for (Token token : tokens)
{
Token.Type type = token.getType();
if (type.rank > 0) // if token is operation
{
while (!tmp.isEmpty() && tmp.peek().getType().rank > type.rank)
out.add(tmp.pop());
tmp.push(token);
}
else if (type == Token.Type.LPR)
tmp.push(token);
else if (type == Token.Type.RPR)
{
while (tmp.peek().getType() != Token.Type.LPR)
out.add(tmp.pop());
tmp.pop();
}
else
out.add(token);
}
while (!tmp.isEmpty())
out.add(tmp.pop());
return out;
}
static Object evaluate(List<Token> tokens)
{
Stack<Double> stack = new Stack<>();
for (Token token : tokens)
{
if (token.isEX())
stack.push(Double.parseDouble(token.getLexeme()));
else
{
// TODO: don't just assume it's double here?
Double a = stack.pop();
Double b = stack.pop();
// TODO: only allow add if either token is a string
switch (token.getType())
{
case ADD:
stack.push(b+a);
break;
case SUB:
stack.push(b-a);
break;
case MUL:
stack.push(b*a);
break;
case DIV:
stack.push(b/a);
break;
case MOD:
stack.push(b%a);
break;
}
}
}
return stack.pop();
}
}
Token.java:
public class Token
{
enum Type
{
LSH(3, "<<"), // Left shift
RSH(3, ">>"), // Right shift
MUL(2, "\\*"), // Multiply
DIV(2, "/"), // Divide
MOD(2, "/"), // Modulo
ADD(1, "\\+"), // Add
SUB(1, "-"), // Subtract
DBL("\\d+\\.\\d*"), // Double
INT("\\d+"), // Integer
STR("\".*\""), // String
LPR("\\("), // Left parenthesis
RPR("\\)"), // Right parenthesis
;
//REF(0, "\\w+(\\.\\w+)+"),
final String symbol;
final int rank;
Type(String symbol)
{
this.symbol = symbol;
this.rank = 0;
}
Type(int rank, String symbol)
{
this.symbol = symbol;
this.rank = rank;
}
}
/**
* Regular expression for expressions and operations
*/
final static String regex;
static
{
StringBuilder sb = new StringBuilder();
Type[] t = Type.values();
for (int i = 0; i < t.length; i++)
{
if (i != 0)
sb.append('|');
sb.append(t[i].symbol);
}
regex = sb.toString();
}
/**
* Text literal
*/
private String lexeme;
/**
* Expression/operation type
*/
private Type type;
/**
* line number
*/
private int lineNum;
/**
* character number
*/
private int posNum;
/**
* Creates a token with debugging information
*
* #param lexeme Text literal
* #param lineNum Line number
* #param posNum Character number
* #return Token with processed type of lexeme
*/
Token(String lexeme, int lineNum, int posNum)
{
this.lexeme = lexeme;
for (Type type : Type.values())
if (lexeme.matches(type.symbol))
{
this.type = type;
break;
}
this.lineNum = lineNum;
this.posNum = posNum;
}
boolean isEX()
{
return type.rank == 0;
}
boolean isOP()
{
return type.rank > 0;
}
String getLexeme()
{
return lexeme;
}
Type getType()
{
return type;
}
public int getLineNum()
{
return lineNum;
}
public int getPosNum()
{
return posNum;
}
#Override
public String toString()
{
return String.format("%s[%d,%d]:%s", type, lineNum, posNum, lexeme);
}
}
Driver.java (for some simple test cases):
import java.util.Stack;
public class Driver
{
public static void main(String[] args)
{
String simpleTest = "1+2/(3-4)";
Stack<Token> tokens;
tokens = Compiler.format(Compiler.tokenize(simpleTest, 0));
System.out.println("Simple Test");
tokens.forEach(System.out::println);
System.out.println(Compiler.evaluate(tokens));
String hardTest = "\"1.0 plus 2 equals\" + 1.0 + 2";
tokens = Compiler.format(Compiler.tokenize(hardTest, 1));
System.out.println("\nHard Test");
tokens.forEach(System.out::println);
}
}