Java-Building a Calculator

Lab #1 — Building a Calculator

Your task for Lab #1 is to build a calculator in Java that has two modes, controllable by command-line options postfix and infix. In both modes the calculator will read lines of input from standard input. For each input line, the calculator will evaluate the expression that was input and print the result on a separate line. The program ends when it encounters the EOF character,similar to the behavior of most Unix utilities.

To simplify matters regarding dealing with different types of numbers, in this assignment, all numbers are to be represented internally as either Java floatprimitives or Floatobjects depending on your implementation choices.

Your calculator will implement the following operations:

  • +, -, *, /
  • ^ (exponentiation: e.g., 2^3 = 8).

Your calculator will implement expressions containing either a sole number or operations applied to numbers.

Mode #1 — Postfix Notation

The first mode that you will implement is one where the calculator accepts anexpression that is expressed in postfix notation. For those of you familiar with HP’s line of scientific and graphing calculators, postfix notation is also known as RPN or Reverse Polish Notation, in honor of the Polish logician Jan Łukasiewicz who invented Polish notation, also known as prefix notation.

Here are examples of expressions written in postfix notation with their conversions to infix notation and their evaluations:

2 3 +

2 + 3


2 3 + 5 *

(2 + 3) * 5


2 3 5 * +

2 + (3 * 5)


2 3 2 ^ * -10 –

2 * (3 ^ 2) – -10


How an RPN calculator works internally is as follows: it maintains an internal stack that is used to store operands and intermediate results. Let’s use the expression “4 3 + 5 *” as an example. The first thing that we do is lexical analysis on the input string by first splitting the string by its whitespace characters and then performing the proper type conversions on the numbers, resulting in a list that looks like this:

[4.0, 3.0, “+”, 5.0, “*”]

Next, we iterate through the list. For each number, we push it onto the stack. Once we reach an operator on the list, we pop the stack twice, perform that operation on the popped numbers, and then push the result onto the stack. In this example, the elements 3.0 and 4.0 are popped from the stack. We then perform the “+” operation on the second and first elements popped from the stack ( matters for “-”, “/”, and “^”), and then push the result (12.0) onto the stack. Then, as we continue iterating through the list, we encounter 5.0, and thus we push it on the stack, resulting in a stack with the elements 12.0 (bottom) and 5.0 (top). Finally, the last token in the list is “*”, and so we pop the stack twice, multiplying 5.0 and 12.0 to get 60.0, and then we push it back on the stack.

When we have exhausted the list of tokens, we pop the stack and print the popped value as the result of the expression.

One of the nice properties of postfix notion is the lack of a need to specify operator precedence. It is this property that makes it possible to implement an RPN calculator without the need for specify a formal grammar for expressions. In fact, there are full-fledged programming languages such as Forth and PostScript that use postfix notation and rely on a stack.

Mode #2 — Infix Notation

Unlike a postfix calculator where parsing is a very straightforward task, parsing is not as straightforward in infix notation, since you have to concern yourself with expressions of arbitrary length and operator precedence. Your calculator will have to properly implement the PEMDAS (parentheses, exponents, multiplication, division, addition, subtraction) of operations that are from elementary algebra.

Thankfully with the help of parser generators such as ANTLR, you won’t have to deal with the labor of implementing parsing algorithms.

Here is an excellent tutorial for using ANTLR: (Links to an external site.). Please also refer to the main ANTLR website at (Links to an external site.).

Your goals are the following:

  1. Write a BNF or EBNF grammar that is able to represent expressions in infix notation that is also able to implement the PEMDAS of operations.
  2. Express that grammar as an ANTLR grammar.
  3. Use ANTLR to generate an abstract syntax tree.
  4. Traverse the abstract syntax tree to evaluate the expression. There are two ways of doing this: (1) either evaluating the abstract syntax tree directly, or (2) using the AST to generate a postfix notation representation of the expression, and then evaluating it as in Mode #1.

Some Examples:

$ java Calculator postfix

Calculator> 2 4 * 2 ^ 10 –


Calculator> 5


Calculator> 8 24 + 9 –


$ java Calculator infix

Calculator> (2 * 4)^2 – 10


Calculator> 5


Calculator> 8 + 24 – 9



A collection of Java and ANTLR source code files in a *.zip archive, where the main method is located in a class called Calculator and in a file called

Grading Rubric:

Mode #1 (Postfix Notation): 30%

Mode #2 (Infix Notation Grammar and Parsing): 50%

Mode #2 (Infix Notation Evaluation): 20%

Note:Your code must compile in for it to receive any credit; any submission that does not compile will receive a grade of 0%.


grammar Adder; WS : [ \t\r\n]+ -> skip ; Num : (‘-‘)?[0-9]+ | (‘-‘)?[0-9]+’.'[0-9]+ ; expr : expr ‘+’ expr # addExpr | Num # numExpr ; start : expr EOF ; Error : . ;

import  org . antlr . v4 . runtime . * ;
import  org . antlr . v4 . runtime . tree . * ;
import  java . io . * ;

public   class   Adder   {
public   static   void  main ( String []  args )   throws   IOException   {
BufferedReader  in  =
new   BufferedReader ( new   InputStreamReader ( System . in ));
CharStream  inputStream  =   CharStreams . fromReader ( in );
AdderLexer  lexer  =   new   AdderLexer ( inputStream );
CommonTokenStream  commonTokenStream  =   new   CommonTokenStream ( lexer );
AdderParser  parser  =   new   AdderParser ( commonTokenStream );
parser . setErrorHandler ( new   BailErrorStrategy ());

ParseTree  tree  =  parser . start ();
AdderInterpreter  interpreter  =   new   AdderInterpreter ();
Float  result  =  interpreter . visit ( tree );
System . out . println ( result . toString ());

public   class   AdderInterpreter   extends   AdderBaseVisitor < Float >   {
@ Override
public   Float  visitAddExpr ( AdderParser . AddExprContext  ctx )   {
float  result  =  visit ( ctx . expr ( 0 )). floatValue ()   +
visit ( ctx . expr ( 1 )). floatValue ();
return   Float . valueOf ( result );

@ Override
public   Float  visitNumExpr ( AdderParser . NumExprContext  ctx )   {
return   Float . valueOf ( ctx . Num (). getText ());

@ Override
public   Float  visitStart ( AdderParser . StartContext  ctx )   {
return  visit ( ctx . expr ());

Place your order
(550 words)

Approximate price: $22

Calculate the price of your order

550 words
We'll send you the first draft for approval by September 11, 2018 at 10:52 AM
Total price:
The price is based on these factors:
Academic level
Number of pages
Basic features
  • Free title page and bibliography
  • Unlimited revisions
  • Plagiarism-free guarantee
  • Money-back guarantee
  • 24/7 support
On-demand options
  • Writer’s samples
  • Part-by-part delivery
  • Overnight delivery
  • Copies of used sources
  • Expert Proofreading
Paper format
  • 275 words per page
  • 12 pt Arial/Times New Roman
  • Double line spacing
  • Any citation style (APA, MLA, Chicago/Turabian, Harvard)

Our guarantees

Delivering a high-quality product at a reasonable price is not enough anymore.
That’s why we have developed 5 beneficial guarantees that will make your experience with our service enjoyable, easy, and safe.

Money-back guarantee

You have to be 100% sure of the quality of your product to give a money-back guarantee. This describes us perfectly. Make sure that this guarantee is totally transparent.

Read more

Zero-plagiarism guarantee

Each paper is composed from scratch, according to your instructions. It is then checked by our plagiarism-detection software. There is no gap where plagiarism could squeeze in.

Read more

Free-revision policy

Thanks to our free revisions, there is no way for you to be unsatisfied. We will work on your paper until you are completely happy with the result.

Read more

Privacy policy

Your email is safe, as we store it according to international data protection rules. Your bank details are secure, as we use only reliable payment systems.

Read more

Fair-cooperation guarantee

By sending us your money, you buy the service we provide. Check out our terms and conditions if you prefer business talks to be laid out in official language.

Read more

Order your paper today and save 30% with the discount code HAPPY

Open chat
You can contact our live agent via WhatsApp! Via + 1 323 412 5597

Feel free to ask questions, clarifications, or discounts available when placing an order.

Order your essay today and save 30% with the discount code HAPPY