From 034aef3f578b337099834cf91caaa50940baa881 Mon Sep 17 00:00:00 2001
From: smover <sergio.mover@gmail.com>
Date: Fri, 9 Jun 2017 11:03:20 -0600
Subject: [PATCH 01/14] Add jimple grammar

---
 doc/scoot/language_subset.tex | 202 ++++++++++++++++++++++++++++++++++
 1 file changed, 202 insertions(+)
 create mode 100644 doc/scoot/language_subset.tex

diff --git a/doc/scoot/language_subset.tex b/doc/scoot/language_subset.tex
new file mode 100644
index 0000000..cdb3f1c
--- /dev/null
+++ b/doc/scoot/language_subset.tex
@@ -0,0 +1,202 @@
+\documentclass{report}
+
+\usepackage{syntax}
+\usepackage{mathpartir}
+
+\begin{document}
+\title{Jimpel syntax}
+
+\maketitle
+
+
+%%\begin{figure}[tb]\small
+
+
+
+%% <statement> ::= <ident> `=' <expr> 
+%% \alt `for' <ident> `=' <expr> `to' <expr> `do' <statement> 
+%% \alt `{' <stat-list> `}' 
+%% \alt <empty> 
+
+%% <stat-list> ::= <statement> `;' <stat-list> | <statement> 
+
+
+\begin{grammar}
+<jimple_method> ::= <local_declarations> <identity_stmts> <stmts> <exception_ranges>
+
+<local_declarations> ::= <local_declaration> <local_declarations>
+
+<stmts> ::= <label> ":" <stmt> ";" <stmts> \alt  <stmt> ";" <smts>
+
+<exception_ranges> ::= <exception_range> <exception_ranges>
+
+<local_declaration> ::= <type> <name> ";"
+
+<identity_stmts> ::= <identity_stmt> identity_stmts
+
+<stmt> ::= <breakpoint_stmt> \alt <assign_stmt> \alt <enter_monitor_stmt>
+<goto_stmt> \alt <if_stmt> \alt <invoke_stmt> \alt <lookup_switch_stmt> \alt <nop_stmt> \alt <ret_stmt> \alt <return_stmt> \alt <return_void_stmt> \alt <table_switch_stmt> \alt throw_stmt
+
+<breakpoint_stmt> ::= "breakpoint"
+
+<assign_stmt> ::= <variable> "=" rvalue
+
+<identity_stmt> ::= <local> ":=" identity_value
+
+<enter_monitor_stmt> ::= "entermonitor" immediate
+
+<exit_monitor_stmt> ::= "exitmonitor" immediate
+
+<goto_stmt> ::= "goto" label
+
+<if_stmt> ::= "if" <condition> "then" label
+
+<invoke_stmt> ::= invoke_expr
+
+<lookup_switch_stmt> ::= "lookupswitch(" <immediate> ") {" <cases> " default: <goto> " <label> "}" <nop_stmt> ::= "nop"
+
+<ret_stmt> ::= "ret" local
+
+<return_stmt> ::= "return" immediate
+
+<return_void_stmt> ::= "return" 
+
+<table_switch_stmt> ::= "tableswitch(" <immediate> ") {" <cases> " default: <goto> " <label> "}" <throw_stmt> ::= "throw" immediate
+
+<cases> ::= <case> cases
+
+<case> ::= "case " <int_constant> ": <goto> " label
+
+<condition> ::= <eq_expr> \alt <ge_expr> \alt <le_expr> \alt <lt_expr> \alt <ne_expr> \alt gt_expr
+
+<rvalue> ::= <array_ref> \alt <constant> \alt <expr> \alt <instance_field_ref> \alt <local> 
+
+<next_next_stmt_address> \alt static_field_ref
+
+<identity_value> ::= <caught_exception_ref> \alt <parameter_ref> \alt this_ref
+
+<variable> ::= <array_ref> \alt <instance_field_ref> \alt <static_field_ref> \alt local
+
+<immediate> ::= <constant> \alt local
+
+<expr> ::= <binop_expr> \alt <cast_expr> \alt <instance_of_expr> \alt <invoke_expr> \alt <new_array_expr> \alt <new_expr> \alt <new_multi_array_expr> \alt unop_expr
+
+<binop_expr> ::= <add_expr> \alt <and_expr> \alt <cmp_expr> \alt <cmpg_expr> \alt <cmpl_expr> \alt <div_expr> \alt <eq_expr> \alt <ge_expr> \alt <gt_expr> \alt <le_expr> \alt <lt_expr> \alt <mul_expr> \alt <ne_expr> \alt <or_expr> \alt <rem_expr> \alt <shl_expr> \alt <shr_expr> \alt <sub_expr> \alt <ushr_expr> \alt xor_expr
+
+<add_expr> ::= <immediate> "+" immediate
+
+<and_expr> ::= <immediate> "&" immediate
+
+<cmp_expr> ::= <immediate> "cmp" immediate
+
+<cmpg_expr> ::= <immediate> "cmpg" immediate
+
+<cmpl_expr> ::= <immediate> "cmpl" immediate
+
+<div_expr> ::= <immediate> "/" immediate
+
+<eq_expr> ::= <immediate> "==" immediate
+
+<ge_expr> ::= <immediate> ">=" immediate
+
+<gt_expr> ::= <immediate> ">" immediate
+
+<le_expr> ::= <immediate> "<=" immediate
+
+<lt_expr> ::= <immediate> "<" immediate
+
+<mul_expr> ::= <immediate> "*" immediate
+
+<ne_expr> ::= <immediate> "!=" immediate
+
+<or_expr> ::= <immediate> "\alt" immediate
+
+<rem_expr> ::= <immediate> "%" immediate
+
+<shl_expr> ::= <immediate> "<<" immediate
+
+<shr_expr> ::= <immediate> ">>" immediate
+
+<sub_expr> ::= <immediate> "-" immediate
+
+<ushr_expr> ::= <immediate> "ushr" immediate
+
+<xor_expr> ::= <immediate> "xor" immediate
+
+<cast_expr> ::= "(" <type> ")" immediate
+
+<instance_of_expr> ::= <immediate> "instanceof" ref_type
+
+<invoke_expr> ::= <interface_invoke_expr> \alt <special_invoke_expr> \alt <static_invoke_expr> virtual_invoke_expr
+
+<static_invoke_expr> ::= "staticinvoke" "[" <method_signature> "](" <immediate_list> ")"
+
+%%<interface_invoke_expr> ::= "interfaceinvoke" <immediate> \".[\" + <method_signature> \"] \"(\" <immediate_list> \")\"
+<interface_invoke_expr> ::= "interfaceinvoke" <immediate> ""
+
+%% <special_invoke_expr> ::= "specialinvoke" <immediate> ".[" <method_signature> "] "(" <immediate_list> ")"
+
+%% <virtual_invoke_expr> ::= "virtualinvoke" <immediate> ".[" <method_signature> "] "(" <immediate_list> ")"
+
+<immediate_list> ::= <immediate> \alt <immediate> immediate_next_list
+
+<immediate_next_list> ::= "," <immediate> immediate_next_list
+
+<new_array_expr> ::= "new" <type> "[" <immediate> "]"
+
+<new_expr> ::= "new" <ref_type> "()"
+
+<new_multi_array_expr> ::= "new <multiarray> " <type> sized_dims empty_dims
+
+<sized_dims> ::= "[" <immediate> "]" next_sized_dims
+
+<next_sized_dims> ::= "[" <immediate> "]" <next_sized_dims>
+
+<empty_dims> ::= "[]" <empty_dims> 
+
+<unop_expr> ::= <length_expr> | neg_expr
+
+<length_expr> ::= "length" immediate
+
+<neg_expr> ::= "-" immediate
+
+%% <array_ref> ::= <immediate> "[" <immediate> "]";
+
+%% <instance_field_ref> ::= <immediate> ".[" <field_signature> "]";
+
+%% <static_field_ref> ::= "[" <field_signature> "]";
+
+%% <method_signature> ::= <identifier> "(" <type_list> "):" type;
+
+<field_signature> ::= <identifier> ":" type
+
+<type_list> ::= <type> type_next_list
+
+<type_next_list> ::= "," <type> type_next_list
+
+<caught_exception_ref> ::= "@caughtexception"
+
+<parameter_ref> ::= "@parameter" int_constant
+
+<this_ref> ::= "@this"
+
+<label> ::= identifier
+
+<local> ::= identifier
+
+<constant> ::= <double_constant> \alt <float_constant> \alt <int_constant> \alt <long_constant>  <string_constant> \alt null_constant
+
+<type> ::= <int_type> \alt <long_type> \alt <float_type> \alt <double_type> \alt <ref_type> 
+
+<stmt_address_type> \alt void_type
+
+%% <exception_range> ::= ".catch" <ref_type> "from" <label> "to" <label> "using" label;
+
+\end{grammar}
+
+%% \caption{The syntax.}
+%% \label{fig:syntax-ls}
+%% \end{figure}
+
+
+\end{document}

From fe874b4a67200cfd47316f5fe8c3787a32857af1 Mon Sep 17 00:00:00 2001
From: smover <sergio.mover@gmail.com>
Date: Wed, 14 Jun 2017 08:50:18 -0600
Subject: [PATCH 02/14] minor

---
 doc/scoot/language_subset.tex | 194 +++++++++++++++++++---------------
 1 file changed, 109 insertions(+), 85 deletions(-)

diff --git a/doc/scoot/language_subset.tex b/doc/scoot/language_subset.tex
index cdb3f1c..02d1fcf 100644
--- a/doc/scoot/language_subset.tex
+++ b/doc/scoot/language_subset.tex
@@ -2,25 +2,55 @@
 
 \usepackage{syntax}
 \usepackage{mathpartir}
+\usepackage{url}
 
 \begin{document}
 \title{Jimpel syntax}
 
 \maketitle
 
+\section{MiniJava}
+MiniJava language
+\url{http://www.cambridge.org/resources/052182060X/}
+\footnote{\url{http://www.cs.tufts.edu/~sguyer/classes/comp181-2006/minijava.html}}:
+
+
+%% \begin{grammar}
+%%   Program	::=	MainClass ( ClassDeclaration )* <EOF>
+%% MainClass	::=	"class" Identifier "{" "public" "static" "void" "main" "(" "String" "[" "]" Identifier ")" "{" Statement "}" "}"
+%% ClassDeclaration	::=	"class" Identifier ( "extends" Identifier )? "{" ( VarDeclaration )* ( MethodDeclaration )* "}"
+%% VarDeclaration	::=	Type Identifier ";"
+%% MethodDeclaration	::=	"public" Type Identifier "(" ( Type Identifier ( "," Type Identifier )* )? ")" "{" ( VarDeclaration )* ( Statement )* "return" Expression ";" "}"
+%% Type	::=	"int" "[" "]"
+%% |	"boolean"
+%% |	"int"
+%% |	Identifier
+%% Statement	::=	"{" ( Statement )* "}"
+%% |	"if" "(" Expression ")" Statement "else" Statement
+%% |	"while" "(" Expression ")" Statement
+%% |	"System.out.println" "(" Expression ")" ";"
+%% |	Identifier "=" Expression ";"
+%% |	Identifier "[" Expression "]" "=" Expression ";"
+%% Expression	::=	Expression ( "&&" | "<" | "+" | "-" | "*" ) Expression
+%% |	Expression "[" Expression "]"
+%% |	Expression "." "length"
+%% |	Expression "." Identifier "(" ( Expression ( "," Expression )* )? ")"
+%% |	<INTEGER_LITERAL>
+%% |	"true"
+%% |	"false"
+%% |	Identifier
+%% |	"this"
+%% |	"new" "int" "[" Expression "]"
+%% |	"new" Identifier "(" ")"
+%% |	"!" Expression
+%% |	"(" Expression ")"
+%% Identifier	::=	<IDENTIFIER>
+
+%% \end{grammar}
 
 %%\begin{figure}[tb]\small
 
-
-
-%% <statement> ::= <ident> `=' <expr> 
-%% \alt `for' <ident> `=' <expr> `to' <expr> `do' <statement> 
-%% \alt `{' <stat-list> `}' 
-%% \alt <empty> 
-
-%% <stat-list> ::= <statement> `;' <stat-list> | <statement> 
-
-
+\section{Jimple Grammar}
 \begin{grammar}
 <jimple_method> ::= <local_declarations> <identity_stmts> <stmts> <exception_ranges>
 
@@ -32,171 +62,165 @@
 
 <local_declaration> ::= <type> <name> ";"
 
-<identity_stmts> ::= <identity_stmt> identity_stmts
+<identity_stmts> ::= <identity_stmt> <identity_stmts>
 
 <stmt> ::= <breakpoint_stmt> \alt <assign_stmt> \alt <enter_monitor_stmt>
-<goto_stmt> \alt <if_stmt> \alt <invoke_stmt> \alt <lookup_switch_stmt> \alt <nop_stmt> \alt <ret_stmt> \alt <return_stmt> \alt <return_void_stmt> \alt <table_switch_stmt> \alt throw_stmt
+<goto_stmt> \alt <if_stmt> \alt <invoke_stmt> \alt <lookup_switch_stmt> \alt <nop_stmt> \alt <ret_stmt> \alt <return_stmt> \alt <return_void_stmt> \alt <table_switch_stmt> \alt <throw_stmt>
 
 <breakpoint_stmt> ::= "breakpoint"
 
-<assign_stmt> ::= <variable> "=" rvalue
+<assign_stmt> ::= <variable> "=" <rvalue>
 
-<identity_stmt> ::= <local> ":=" identity_value
+<identity_stmt> ::= <local> ":=" <identity_value>
 
-<enter_monitor_stmt> ::= "entermonitor" immediate
+<enter_monitor_stmt> ::= "entermonitor" <immediate>
 
-<exit_monitor_stmt> ::= "exitmonitor" immediate
+<exit_monitor_stmt> ::= "exitmonitor" <immediate>
 
-<goto_stmt> ::= "goto" label
+<goto_stmt> ::= "goto" <label>
 
-<if_stmt> ::= "if" <condition> "then" label
+<if_stmt> ::= "if" <condition> "then" <label>
 
-<invoke_stmt> ::= invoke_expr
+<invoke_stmt> ::= <invoke_expr>
 
 <lookup_switch_stmt> ::= "lookupswitch(" <immediate> ") {" <cases> " default: <goto> " <label> "}" <nop_stmt> ::= "nop"
 
-<ret_stmt> ::= "ret" local
+<ret_stmt> ::= "ret" <local>
 
-<return_stmt> ::= "return" immediate
+<return_stmt> ::= "return" <immediate>
 
 <return_void_stmt> ::= "return" 
 
-<table_switch_stmt> ::= "tableswitch(" <immediate> ") {" <cases> " default: <goto> " <label> "}" <throw_stmt> ::= "throw" immediate
-
-<cases> ::= <case> cases
+<table_switch_stmt> ::= "tableswitch(" <immediate> ") {" <cases> " default: <goto> " <label> "}" <throw_stmt> ::= "throw" <immediate>
 
-<case> ::= "case " <int_constant> ": <goto> " label
+<cases> ::= <case> <cases>
 
-<condition> ::= <eq_expr> \alt <ge_expr> \alt <le_expr> \alt <lt_expr> \alt <ne_expr> \alt gt_expr
+<case> ::= "case " <int_constant> ": <goto> " <label>
 
-<rvalue> ::= <array_ref> \alt <constant> \alt <expr> \alt <instance_field_ref> \alt <local> 
+<condition> ::= <eq_expr> \alt <ge_expr> \alt <le_expr> \alt <lt_expr> \alt <ne_expr> \alt <gt_expr>
 
-<next_next_stmt_address> \alt static_field_ref
+<rvalue> ::= <array_ref> \alt <constant> \alt <expr> \alt <instance_field_ref> \alt <local> <next_next_stmt_address> \alt <static_field_ref>
 
-<identity_value> ::= <caught_exception_ref> \alt <parameter_ref> \alt this_ref
+<identity_value> ::= <caught_exception_ref> \alt <parameter_ref> \alt <this_ref>
 
-<variable> ::= <array_ref> \alt <instance_field_ref> \alt <static_field_ref> \alt local
+<variable> ::= <array_ref> \alt <instance_field_ref> \alt <static_field_ref> \alt <local>
 
-<immediate> ::= <constant> \alt local
+<immediate> ::= <constant> \alt <local>
 
-<expr> ::= <binop_expr> \alt <cast_expr> \alt <instance_of_expr> \alt <invoke_expr> \alt <new_array_expr> \alt <new_expr> \alt <new_multi_array_expr> \alt unop_expr
+<expr> ::= <binop_expr> \alt <cast_expr> \alt <instance_of_expr> \alt <invoke_expr> \alt <new_array_expr> \alt <new_expr> \alt <new_multi_array_expr> \alt <unop_expr>
 
-<binop_expr> ::= <add_expr> \alt <and_expr> \alt <cmp_expr> \alt <cmpg_expr> \alt <cmpl_expr> \alt <div_expr> \alt <eq_expr> \alt <ge_expr> \alt <gt_expr> \alt <le_expr> \alt <lt_expr> \alt <mul_expr> \alt <ne_expr> \alt <or_expr> \alt <rem_expr> \alt <shl_expr> \alt <shr_expr> \alt <sub_expr> \alt <ushr_expr> \alt xor_expr
+<binop_expr> ::= <add_expr> \alt <and_expr> \alt <cmp_expr> \alt <cmpg_expr> \alt <cmpl_expr> \alt <div_expr> \alt <eq_expr> \alt <ge_expr> \alt <gt_expr> \alt <le_expr> \alt <lt_expr> \alt <mul_expr> \alt <ne_expr> \alt <or_expr> \alt <rem_expr> \alt <shl_expr> \alt <shr_expr> \alt <sub_expr> \alt <ushr_expr> \alt <xor_expr>
 
-<add_expr> ::= <immediate> "+" immediate
+<add_expr> ::= <immediate> "+"<immediate>
 
-<and_expr> ::= <immediate> "&" immediate
+<and_expr> ::= <immediate> "&"<immediate>
 
-<cmp_expr> ::= <immediate> "cmp" immediate
+<cmp_expr> ::= <immediate> "cmp"<immediate>
 
-<cmpg_expr> ::= <immediate> "cmpg" immediate
+<cmpg_expr> ::= <immediate> "cmpg"<immediate>
 
-<cmpl_expr> ::= <immediate> "cmpl" immediate
+<cmpl_expr> ::= <immediate> "cmpl"<immediate>
 
-<div_expr> ::= <immediate> "/" immediate
+<div_expr> ::= <immediate> "/"<immediate>
 
-<eq_expr> ::= <immediate> "==" immediate
+<eq_expr> ::= <immediate> "=="<immediate>
 
-<ge_expr> ::= <immediate> ">=" immediate
+<ge_expr> ::= <immediate> ">="<immediate>
 
-<gt_expr> ::= <immediate> ">" immediate
+<gt_expr> ::= <immediate> ">"<immediate>
 
-<le_expr> ::= <immediate> "<=" immediate
+<le_expr> ::= <immediate> "<="<immediate>
 
-<lt_expr> ::= <immediate> "<" immediate
+<lt_expr> ::= <immediate> "<"<immediate>
 
-<mul_expr> ::= <immediate> "*" immediate
+<mul_expr> ::= <immediate> "*"<immediate>
 
-<ne_expr> ::= <immediate> "!=" immediate
+<ne_expr> ::= <immediate> "!="<immediate>
 
-<or_expr> ::= <immediate> "\alt" immediate
+<or_expr> ::= <immediate> "\alt"<immediate>
 
-<rem_expr> ::= <immediate> "%" immediate
+<rem_expr> ::= <immediate> "%"<immediate>
 
-<shl_expr> ::= <immediate> "<<" immediate
+<shl_expr> ::= <immediate> "<<"<immediate>
 
-<shr_expr> ::= <immediate> ">>" immediate
+<shr_expr> ::= <immediate> ">>"<immediate>
 
-<sub_expr> ::= <immediate> "-" immediate
+<sub_expr> ::= <immediate> "-"<immediate>
 
-<ushr_expr> ::= <immediate> "ushr" immediate
+<ushr_expr> ::= <immediate> "ushr"<immediate>
 
-<xor_expr> ::= <immediate> "xor" immediate
+<xor_expr> ::= <immediate> "xor"<immediate>
 
-<cast_expr> ::= "(" <type> ")" immediate
+<cast_expr> ::= "(" <type> ")"<immediate>
 
-<instance_of_expr> ::= <immediate> "instanceof" ref_type
+<instance_of_expr> ::= <immediate> "instanceof" <ref_type>
 
-<invoke_expr> ::= <interface_invoke_expr> \alt <special_invoke_expr> \alt <static_invoke_expr> virtual_invoke_expr
+<invoke_expr> ::= <interface_invoke_expr> \alt <special_invoke_expr> \alt <static_invoke_expr> <virtual_invoke_expr>
 
 <static_invoke_expr> ::= "staticinvoke" "[" <method_signature> "](" <immediate_list> ")"
 
-%%<interface_invoke_expr> ::= "interfaceinvoke" <immediate> \".[\" + <method_signature> \"] \"(\" <immediate_list> \")\"
-<interface_invoke_expr> ::= "interfaceinvoke" <immediate> ""
+<interface_invoke_expr> ::= "interfaceinvoke" <immediate> ".[" + <method_signature> "]" "(" <immediate_list> ")"
 
-%% <special_invoke_expr> ::= "specialinvoke" <immediate> ".[" <method_signature> "] "(" <immediate_list> ")"
+<special_invoke_expr> ::= "specialinvoke" <immediate> ".[" <method_signature> "]" "(" <immediate_list> ")"
 
-%% <virtual_invoke_expr> ::= "virtualinvoke" <immediate> ".[" <method_signature> "] "(" <immediate_list> ")"
+<virtual_invoke_expr> ::= "virtualinvoke" <immediate> ".[" <method_signature> "]" "(" <immediate_list> ")"
 
-<immediate_list> ::= <immediate> \alt <immediate> immediate_next_list
+<immediate_list> ::= <immediate> \alt <immediate> <immediate_next_list>
 
-<immediate_next_list> ::= "," <immediate> immediate_next_list
+<immediate_next_list> ::= "," <immediate> <immediate_next_list>
 
 <new_array_expr> ::= "new" <type> "[" <immediate> "]"
 
 <new_expr> ::= "new" <ref_type> "()"
 
-<new_multi_array_expr> ::= "new <multiarray> " <type> sized_dims empty_dims
+<new_multi_array_expr> ::= "new <multiarray> " <type> sized_dims <empty_dims>
 
-<sized_dims> ::= "[" <immediate> "]" next_sized_dims
+<sized_dims> ::= "[" <immediate> "]" <next_sized_dims>
 
 <next_sized_dims> ::= "[" <immediate> "]" <next_sized_dims>
 
 <empty_dims> ::= "[]" <empty_dims> 
 
-<unop_expr> ::= <length_expr> | neg_expr
+<unop_expr> ::= <length_expr> | <neg_expr>
 
-<length_expr> ::= "length" immediate
+<length_expr> ::= "length" <immediate>
 
-<neg_expr> ::= "-" immediate
+<neg_expr> ::= "-" <immediate>
 
-%% <array_ref> ::= <immediate> "[" <immediate> "]";
+<array_ref> ::= <immediate> "[" <immediate> "]";
 
-%% <instance_field_ref> ::= <immediate> ".[" <field_signature> "]";
+<instance_field_ref> ::= <immediate> ".[" <field_signature> "]";
 
-%% <static_field_ref> ::= "[" <field_signature> "]";
+<static_field_ref> ::= "[" <field_signature> "]";
 
-%% <method_signature> ::= <identifier> "(" <type_list> "):" type;
+<method_signature> ::= <identifier> "(" <type_list> "):" <type>;
 
-<field_signature> ::= <identifier> ":" type
+<field_signature> ::= <identifier> ":" <type>
 
-<type_list> ::= <type> type_next_list
+<type_list> ::= <type> <type_next_list>
 
-<type_next_list> ::= "," <type> type_next_list
+<type_next_list> ::= "," <type> <type_next_list>
 
 <caught_exception_ref> ::= "@caughtexception"
 
-<parameter_ref> ::= "@parameter" int_constant
+<parameter_ref> ::= "@parameter" <int_constant>
 
 <this_ref> ::= "@this"
 
-<label> ::= identifier
+<label> ::= <identifier>
 
-<local> ::= identifier
+<local> ::= <identifier>
 
-<constant> ::= <double_constant> \alt <float_constant> \alt <int_constant> \alt <long_constant>  <string_constant> \alt null_constant
+<constant> ::= <double_constant> \alt <float_constant> \alt <int_constant> \alt <long_constant>  <string_constant> \alt <null_constant>
 
-<type> ::= <int_type> \alt <long_type> \alt <float_type> \alt <double_type> \alt <ref_type> 
+<type> ::= <int_type> \alt <long_type> \alt <float_type> \alt <double_type> \alt <ref_type> <stmt_address_type> \alt <void_type>
 
-<stmt_address_type> \alt void_type
-
-%% <exception_range> ::= ".catch" <ref_type> "from" <label> "to" <label> "using" label;
+<exception_range> ::= ".catch" <ref_type> "from" <label> "to" <label> "using" <label>;
 
 \end{grammar}
 
-%% \caption{The syntax.}
-%% \label{fig:syntax-ls}
-%% \end{figure}
+
+\section{Jimple Grammar for MiniJava}
 
 
 \end{document}

From 6de693948b6d3b99f7fc2aa205be64a70db1f954 Mon Sep 17 00:00:00 2001
From: smover <sergio.mover@gmail.com>
Date: Wed, 14 Jun 2017 14:39:39 -0600
Subject: [PATCH 03/14] Structure, reference, minijava syntax

Structured docs around expected language subset, add references, minijava syntax.
---
 doc/scoot/Makefile            |   8 +
 doc/scoot/language_subset.tex | 290 ++++++++++++++++++++++++++++------
 doc/scoot/refs.bib            |  28 ++++
 3 files changed, 282 insertions(+), 44 deletions(-)
 create mode 100644 doc/scoot/Makefile
 create mode 100644 doc/scoot/refs.bib

diff --git a/doc/scoot/Makefile b/doc/scoot/Makefile
new file mode 100644
index 0000000..14ad2a0
--- /dev/null
+++ b/doc/scoot/Makefile
@@ -0,0 +1,8 @@
+language_subset.pdf: *.tex refs.bib
+	pdflatex language_subset
+	bibtex language_subset
+	pdflatex language_subset
+	pdflatex language_subset
+
+clean:
+	rm -f *.aux *.bbl *.blg *.log *.toc *.dvi *.out *.tdo *.gx.table *.gx.gnuplot language_subset.ps language_subset.pdf *~
diff --git a/doc/scoot/language_subset.tex b/doc/scoot/language_subset.tex
index 02d1fcf..d6bf10a 100644
--- a/doc/scoot/language_subset.tex
+++ b/doc/scoot/language_subset.tex
@@ -4,53 +4,26 @@
 \usepackage{mathpartir}
 \usepackage{url}
 
+\newcommand{\minijava}{MiniJava}
+
 \begin{document}
-\title{Jimpel syntax}
+\title{Java subsets and corresponding Jimple subset}
 
 \maketitle
 
-\section{MiniJava}
-MiniJava language
-\url{http://www.cambridge.org/resources/052182060X/}
-\footnote{\url{http://www.cs.tufts.edu/~sguyer/classes/comp181-2006/minijava.html}}:
-
-
-%% \begin{grammar}
-%%   Program	::=	MainClass ( ClassDeclaration )* <EOF>
-%% MainClass	::=	"class" Identifier "{" "public" "static" "void" "main" "(" "String" "[" "]" Identifier ")" "{" Statement "}" "}"
-%% ClassDeclaration	::=	"class" Identifier ( "extends" Identifier )? "{" ( VarDeclaration )* ( MethodDeclaration )* "}"
-%% VarDeclaration	::=	Type Identifier ";"
-%% MethodDeclaration	::=	"public" Type Identifier "(" ( Type Identifier ( "," Type Identifier )* )? ")" "{" ( VarDeclaration )* ( Statement )* "return" Expression ";" "}"
-%% Type	::=	"int" "[" "]"
-%% |	"boolean"
-%% |	"int"
-%% |	Identifier
-%% Statement	::=	"{" ( Statement )* "}"
-%% |	"if" "(" Expression ")" Statement "else" Statement
-%% |	"while" "(" Expression ")" Statement
-%% |	"System.out.println" "(" Expression ")" ";"
-%% |	Identifier "=" Expression ";"
-%% |	Identifier "[" Expression "]" "=" Expression ";"
-%% Expression	::=	Expression ( "&&" | "<" | "+" | "-" | "*" ) Expression
-%% |	Expression "[" Expression "]"
-%% |	Expression "." "length"
-%% |	Expression "." Identifier "(" ( Expression ( "," Expression )* )? ")"
-%% |	<INTEGER_LITERAL>
-%% |	"true"
-%% |	"false"
-%% |	Identifier
-%% |	"this"
-%% |	"new" "int" "[" Expression "]"
-%% |	"new" Identifier "(" ")"
-%% |	"!" Expression
-%% |	"(" Expression ")"
-%% Identifier	::=	<IDENTIFIER>
-
-%% \end{grammar}
-
-%%\begin{figure}[tb]\small
-
-\section{Jimple Grammar}
+% jimple - grammar for classes?
+
+
+\section{Java subset - (Javita?)}
+We define a subset of Java inspired by \minijava~\cite{} (a grammar
+for \minijava is available here \label{sec:minijava}).
+
+We define a different (bigger) subset of Java than \minijava that has
+less syntax restrictions.
+%
+Th \minijava syntax restrictions are not extremely imortant for
+Jimple (we already have parsing and typechecking).
+
 \begin{grammar}
 <jimple_method> ::= <local_declarations> <identity_stmts> <stmts> <exception_ranges>
 
@@ -219,8 +192,237 @@ \section{Jimple Grammar}
 
 \end{grammar}
 
+\bibliographystyle{plain}
+\bibliography{refs}
+
+\appendix
+
+\section{\minijava}
+\label{sec:minijava}
+
+\minijava language~\cite{miniJavaSyntax}
+
+MiniJava features:
+\begin{itemize}
+\item Integer and Boolean primitive types
+\item Integer array types (I don't see array of arrays)
+\item Classes without method overloading (no interfaces, generics, \ldots)
+\item Restricted control flow and expressions (no exception handling)
+\end{itemize}
+
+\begin{grammar}
+<Program>	::=	<MainClass> ( <ClassDeclaration> )*
+
+<MainClass>	::=	"class" <Identifier> "{" "public" "static" "void" "main" "(" "String" "[" "]" <Identifier> ")" "{" <Statement> "}" "}"
+
+<ClassDeclaration>	::=	"class" <Identifier> ( "extends" <Identifier> )? "{" ( <VarDeclaration> )* ( <MethodDeclaration> )* "}"
+
+<VarDeclaration>	::=	<Type> <Identifier> ";"
+
+<MethodDeclaration>	::=	"public" <Type> <Identifier> "(" ( <Type> <Identifier> ( "," <Type> <Identifier> )* )? ")" "{" ( <VarDeclaration> )* ( <Statement> )* "return" <Expression> ";" "}"
+
+<Type>	::=	"int" "[" "]"
+\alt	"boolean"
+\alt	"int"
+\alt	Identifier
+
+<Statement>	::=	"{" ( <Statement> )* "}"
+\alt	"if" "(" <Expression> ")" <Statement> "else" <Statement>
+\alt	"while" "(" Expression ")" <Statement>
+\alt	"System.out.println" "(" <Expression> ")" ";"
+\alt	<Identifier> "=" <Expression> ";"
+\alt	<Identifier> "[" <Expression> "]" "=" <Expression> ";"
+
+<Expression>	::=	<Expression> <Expression>
+\alt <Expression> "<" <Expression>
+\alt <Expression> "+" <Expression>
+\alt <Expression>  "-" <Expression>
+\alt <Expression> "*" <Expression>
+\alt	<Expression> "[" <Expression> "]"
+\alt	<Expression> "." "length"
+\alt	<Expression> "." <Identifier> "(" ( <Expression> ( "," <Expression> )* )? ")"
+\alt	<INTEGER_LITERAL>
+\alt	"true"
+\alt	"false"
+\alt	<Identifier>
+\alt	"this"
+\alt	"new" "int" "[" Expression "]"
+\alt	"new" <Identifier> "(" ")"
+\alt	"!" <Expression>
+\alt	"(" <Expression> ")"
+<Identifier>	::=	<IDENTIFIER>
+\end{grammar}
+
+\section{Jimple Syntax - Method Body}
+\label{sec:jimple}
+Full Jimple syntax for a single method ~\cite{Vallee-Rai98jimple:simplifying}
+
+\begin{grammar}
+<jimple_method> ::= <local_declarations> <identity_stmts> <stmts> <exception_ranges>
+
+<local_declarations> ::= <local_declaration> <local_declarations>
+
+<stmts> ::= <label> ":" <stmt> ";" <stmts> \alt  <stmt> ";" <smts>
+
+<exception_ranges> ::= <exception_range> <exception_ranges>
+
+<local_declaration> ::= <type> <name> ";"
+
+<identity_stmts> ::= <identity_stmt> <identity_stmts>
+
+<stmt> ::= <breakpoint_stmt> \alt <assign_stmt> \alt <enter_monitor_stmt>
+<goto_stmt> \alt <if_stmt> \alt <invoke_stmt> \alt <lookup_switch_stmt> \alt <nop_stmt> \alt <ret_stmt> \alt <return_stmt> \alt <return_void_stmt> \alt <table_switch_stmt> \alt <throw_stmt>
+
+<breakpoint_stmt> ::= "breakpoint"
+
+<assign_stmt> ::= <variable> "=" <rvalue>
+
+<identity_stmt> ::= <local> ":=" <identity_value>
+
+<enter_monitor_stmt> ::= "entermonitor" <immediate>
+
+<exit_monitor_stmt> ::= "exitmonitor" <immediate>
+
+<goto_stmt> ::= "goto" <label>
+
+<if_stmt> ::= "if" <condition> "then" <label>
+
+<invoke_stmt> ::= <invoke_expr>
+
+<lookup_switch_stmt> ::= "lookupswitch(" <immediate> ") {" <cases> " default: <goto> " <label> "}" <nop_stmt> ::= "nop"
+
+<ret_stmt> ::= "ret" <local>
+
+<return_stmt> ::= "return" <immediate>
+
+<return_void_stmt> ::= "return" 
+
+<table_switch_stmt> ::= "tableswitch(" <immediate> ") {" <cases> " default: <goto> " <label> "}" <throw_stmt> ::= "throw" <immediate>
+
+<cases> ::= <case> <cases>
 
-\section{Jimple Grammar for MiniJava}
+<case> ::= "case " <int_constant> ": <goto> " <label>
+
+<condition> ::= <eq_expr> \alt <ge_expr> \alt <le_expr> \alt <lt_expr> \alt <ne_expr> \alt <gt_expr>
+
+<rvalue> ::= <array_ref> \alt <constant> \alt <expr> \alt <instance_field_ref> \alt <local> <next_next_stmt_address> \alt <static_field_ref>
+
+<identity_value> ::= <caught_exception_ref> \alt <parameter_ref> \alt <this_ref>
+
+<variable> ::= <array_ref> \alt <instance_field_ref> \alt <static_field_ref> \alt <local>
+
+<immediate> ::= <constant> \alt <local>
+
+<expr> ::= <binop_expr> \alt <cast_expr> \alt <instance_of_expr> \alt <invoke_expr> \alt <new_array_expr> \alt <new_expr> \alt <new_multi_array_expr> \alt <unop_expr>
+
+<binop_expr> ::= <add_expr> \alt <and_expr> \alt <cmp_expr> \alt <cmpg_expr> \alt <cmpl_expr> \alt <div_expr> \alt <eq_expr> \alt <ge_expr> \alt <gt_expr> \alt <le_expr> \alt <lt_expr> \alt <mul_expr> \alt <ne_expr> \alt <or_expr> \alt <rem_expr> \alt <shl_expr> \alt <shr_expr> \alt <sub_expr> \alt <ushr_expr> \alt <xor_expr>
+
+<add_expr> ::= <immediate> "+"<immediate>
+
+<and_expr> ::= <immediate> "&"<immediate>
+
+<cmp_expr> ::= <immediate> "cmp"<immediate>
+
+<cmpg_expr> ::= <immediate> "cmpg"<immediate>
+
+<cmpl_expr> ::= <immediate> "cmpl"<immediate>
+
+<div_expr> ::= <immediate> "/"<immediate>
+
+<eq_expr> ::= <immediate> "=="<immediate>
+
+<ge_expr> ::= <immediate> ">="<immediate>
+
+<gt_expr> ::= <immediate> ">"<immediate>
 
+<le_expr> ::= <immediate> "<="<immediate>
+
+<lt_expr> ::= <immediate> "<"<immediate>
+
+<mul_expr> ::= <immediate> "*"<immediate>
+
+<ne_expr> ::= <immediate> "!="<immediate>
+
+<or_expr> ::= <immediate> "\alt"<immediate>
+
+<rem_expr> ::= <immediate> "%"<immediate>
+
+<shl_expr> ::= <immediate> "<<"<immediate>
+
+<shr_expr> ::= <immediate> ">>"<immediate>
+
+<sub_expr> ::= <immediate> "-"<immediate>
+
+<ushr_expr> ::= <immediate> "ushr"<immediate>
+
+<xor_expr> ::= <immediate> "xor"<immediate>
+
+<cast_expr> ::= "(" <type> ")"<immediate>
+
+<instance_of_expr> ::= <immediate> "instanceof" <ref_type>
+
+<invoke_expr> ::= <interface_invoke_expr> \alt <special_invoke_expr> \alt <static_invoke_expr> <virtual_invoke_expr>
+
+<static_invoke_expr> ::= "staticinvoke" "[" <method_signature> "](" <immediate_list> ")"
+
+<interface_invoke_expr> ::= "interfaceinvoke" <immediate> ".[" + <method_signature> "]" "(" <immediate_list> ")"
+
+<special_invoke_expr> ::= "specialinvoke" <immediate> ".[" <method_signature> "]" "(" <immediate_list> ")"
+
+<virtual_invoke_expr> ::= "virtualinvoke" <immediate> ".[" <method_signature> "]" "(" <immediate_list> ")"
+
+<immediate_list> ::= <immediate> \alt <immediate> <immediate_next_list>
+
+<immediate_next_list> ::= "," <immediate> <immediate_next_list>
+
+<new_array_expr> ::= "new" <type> "[" <immediate> "]"
+
+<new_expr> ::= "new" <ref_type> "()"
+
+<new_multi_array_expr> ::= "new <multiarray> " <type> sized_dims <empty_dims>
+
+<sized_dims> ::= "[" <immediate> "]" <next_sized_dims>
+
+<next_sized_dims> ::= "[" <immediate> "]" <next_sized_dims>
+
+<empty_dims> ::= "[]" <empty_dims> 
+
+<unop_expr> ::= <length_expr> | <neg_expr>
+
+<length_expr> ::= "length" <immediate>
+
+<neg_expr> ::= "-" <immediate>
+
+<array_ref> ::= <immediate> "[" <immediate> "]";
+
+<instance_field_ref> ::= <immediate> ".[" <field_signature> "]";
+
+<static_field_ref> ::= "[" <field_signature> "]";
+
+<method_signature> ::= <identifier> "(" <type_list> "):" <type>;
+
+<field_signature> ::= <identifier> ":" <type>
+
+<type_list> ::= <type> <type_next_list>
+
+<type_next_list> ::= "," <type> <type_next_list>
+
+<caught_exception_ref> ::= "@caughtexception"
+
+<parameter_ref> ::= "@parameter" <int_constant>
+
+<this_ref> ::= "@this"
+
+<label> ::= <identifier>
+
+<local> ::= <identifier>
+
+<constant> ::= <double_constant> \alt <float_constant> \alt <int_constant> \alt <long_constant>  <string_constant> \alt <null_constant>
+
+<type> ::= <int_type> \alt <long_type> \alt <float_type> \alt <double_type> \alt <ref_type> <stmt_address_type> \alt <void_type>
+
+<exception_range> ::= ".catch" <ref_type> "from" <label> "to" <label> "using" <label>;
+
+\end{grammar}
 
 \end{document}
diff --git a/doc/scoot/refs.bib b/doc/scoot/refs.bib
new file mode 100644
index 0000000..9b72214
--- /dev/null
+++ b/doc/scoot/refs.bib
@@ -0,0 +1,28 @@
+@Misc{MiniJavaSyntax,
+  key =       {MiniJavaSyntax},
+  author =    {Joao Cangussu, Jens Palsberg and Vidyut Samanta},
+  title =     {MiniJava Syntax},
+  OPThowpublished = {},
+  OPTmonth =     {},
+  OPTyear =      {},
+  note =      {\url{http://www.cambridge.org/resources/052182060X/MCIIJ2e/grammar.htm}},
+  OPTannote =    {}
+}
+
+@Misc{MiniJavaTypes,
+  key =       {MiniJavaTypeSystem},
+  author =    {Joao Cangussu, Jens Palsberg and Vidyut Samanta},
+  title =     {MiniJava  type system},
+  OPThowpublished = {},
+  OPTmonth =     {},
+  OPTyear =      {},
+  note =      {\url{http://web.cs.ucla.edu/~palsberg/course/cs132/MiniJava-typesystem.pdf}},
+  OPTannote =    {}
+}
+
+
+@MISC{Vallee-Rai98jimple:simplifying,
+    author = {Raja Vallee-Rai and Laurie J. Hendren},
+    title = {Jimple: Simplifying Java Bytecode for Analyses and Transformations},
+    year = {1998}
+}

From b3567b7f183798149339ba6f4e2fac7167e597a5 Mon Sep 17 00:00:00 2001
From: smover <sergio.mover@gmail.com>
Date: Fri, 23 Jun 2017 09:36:19 -0600
Subject: [PATCH 04/14] Minor

---
 doc/scoot/language_subset.tex | 24 ++++++++++++++++++++----
 1 file changed, 20 insertions(+), 4 deletions(-)

diff --git a/doc/scoot/language_subset.tex b/doc/scoot/language_subset.tex
index d6bf10a..918412e 100644
--- a/doc/scoot/language_subset.tex
+++ b/doc/scoot/language_subset.tex
@@ -1,10 +1,11 @@
 \documentclass{report}
 
 \usepackage{syntax}
+\usepackage{xspace}
 \usepackage{mathpartir}
 \usepackage{url}
 
-\newcommand{\minijava}{MiniJava}
+\newcommand{\minijava}{MiniJava\xspace}
 
 \begin{document}
 \title{Java subsets and corresponding Jimple subset}
@@ -19,11 +20,26 @@ \section{Java subset - (Javita?)}
 for \minijava is available here \label{sec:minijava}).
 
 We define a different (bigger) subset of Java than \minijava that has
-less syntax restrictions.
+less language syntax restrictions.
 %
-Th \minijava syntax restrictions are not extremely imortant for
-Jimple (we already have parsing and typechecking).
+The \minijava syntax restrictions are not imortant when using soot as
+frontend (we already have parsing and typechecking).
 
+Features that we want:
+\begin{itemize}
+\item Integer and Boolean primitive types
+\item Integer and Boolean array types
+\item Classes without method overloading (no interfaces, generics, \ldots)
+\item Restricted control flow and expressions (no exception handling)
+\end{itemize}
+
+\section{Correspondent Jimple subset}
+\begin{grammar}
+  
+\end{grammar}
+
+
+\section{Jimple subset}
 \begin{grammar}
 <jimple_method> ::= <local_declarations> <identity_stmts> <stmts> <exception_ranges>
 

From 584cfcd7e14f8977aae6d5344bd4ed6c0cb43b78 Mon Sep 17 00:00:00 2001
From: smover <sergio.mover@gmail.com>
Date: Wed, 9 Aug 2017 10:51:21 -0600
Subject: [PATCH 05/14] minor

---
 doc/scoot/language_subset.tex | 51 ++++++++++++++++++++++++++---------
 1 file changed, 39 insertions(+), 12 deletions(-)

diff --git a/doc/scoot/language_subset.tex b/doc/scoot/language_subset.tex
index 918412e..862f3f7 100644
--- a/doc/scoot/language_subset.tex
+++ b/doc/scoot/language_subset.tex
@@ -19,27 +19,54 @@ \section{Java subset - (Javita?)}
 We define a subset of Java inspired by \minijava~\cite{} (a grammar
 for \minijava is available here \label{sec:minijava}).
 
-We define a different (bigger) subset of Java than \minijava that has
-less language syntax restrictions.
+We define a different subset of Java than \minijava that has less
+language syntax restrictions.
 %
-The \minijava syntax restrictions are not imortant when using soot as
+The \minijava syntax restrictions are not important when using soot as
 frontend (we already have parsing and typechecking).
 
-Features that we want:
+We first define a subset of Java with:
 \begin{itemize}
-\item Integer and Boolean primitive types
+\item Integer and Boolean variables
+\item Control flow  control flow: 
+\item only calls static static methods
+\item 
+\end{itemize} 
+
+What is outside the fragment:
+\begin{itemize}
+\item No dynamic memory allocation (no arrays, no creation of new
+  objects)
+\item No object oriented features (call to 
+\end{itemize}
+The language does not include dynamic memory allocation, object
+oriented features as 
+
+ with the following features:
+\begin{itemize}
+\item Class declarations:
+  \begin{itemize}
+  \item Class declaration without inheritance, implementation of interfaces and generics.
+  \end{itemize}
+\item Method declarations:
+  \begin{itemize}
+    
+  \end{itemize}
+\item Variable declarations:
+  \begin{itemize}
+  \item Only Integer and Boolean primitive types
+  \end{itemize}
+\item Restriction on the type of the variables:
+\item 
 \item Integer and Boolean array types
-\item Classes without method overloading (no interfaces, generics, \ldots)
-\item Restricted control flow and expressions (no exception handling)
+\item Class declarations
+Classes without method overloading (no interfaces, generics, \ldots)
+\item Restriction on the control flow and expressions (no exception handling)
 \end{itemize}
 
-\section{Correspondent Jimple subset}
-\begin{grammar}
-  
-\end{grammar}
 
 
-\section{Jimple subset}
+\section{Jimple grammar}
 \begin{grammar}
 <jimple_method> ::= <local_declarations> <identity_stmts> <stmts> <exception_ranges>
 

From 2113d9a29d4539c2e7c89939ecb52e839be26f61 Mon Sep 17 00:00:00 2001
From: smover <sergio.mover@gmail.com>
Date: Thu, 14 Sep 2017 22:55:10 -0600
Subject: [PATCH 06/14] Fix tests for arithmetic expressions

---
 .../plv/cuanto/javita/ClassDeclaration.java   |  7 +++
 .../plv/cuanto/javita/FieldDeclarations.java  |  7 +++
 .../plv/cuanto/javita/MethodDeclaration.java  |  7 +++
 .../cuanto/javita/TestJavitaSemantic.scala    | 50 +++++++++++++++++++
 4 files changed, 71 insertions(+)
 create mode 100644 src/test/java/edu/colorado/plv/cuanto/javita/ClassDeclaration.java
 create mode 100644 src/test/java/edu/colorado/plv/cuanto/javita/FieldDeclarations.java
 create mode 100644 src/test/java/edu/colorado/plv/cuanto/javita/MethodDeclaration.java
 create mode 100644 src/test/scala/edu/colorado/plv/cuanto/javita/TestJavitaSemantic.scala

diff --git a/src/test/java/edu/colorado/plv/cuanto/javita/ClassDeclaration.java b/src/test/java/edu/colorado/plv/cuanto/javita/ClassDeclaration.java
new file mode 100644
index 0000000..3a0c113
--- /dev/null
+++ b/src/test/java/edu/colorado/plv/cuanto/javita/ClassDeclaration.java
@@ -0,0 +1,7 @@
+package edu.colorado.plv.cuanto.javita;
+
+/**
+ * @author Sergio Mover
+ */
+public class ClassDeclaration {
+}
diff --git a/src/test/java/edu/colorado/plv/cuanto/javita/FieldDeclarations.java b/src/test/java/edu/colorado/plv/cuanto/javita/FieldDeclarations.java
new file mode 100644
index 0000000..13b5c45
--- /dev/null
+++ b/src/test/java/edu/colorado/plv/cuanto/javita/FieldDeclarations.java
@@ -0,0 +1,7 @@
+package edu.colorado.plv.cuanto.javita;
+
+/**
+ * @author Sergio Mover
+ */
+public class FieldDeclarations {
+}
diff --git a/src/test/java/edu/colorado/plv/cuanto/javita/MethodDeclaration.java b/src/test/java/edu/colorado/plv/cuanto/javita/MethodDeclaration.java
new file mode 100644
index 0000000..8406841
--- /dev/null
+++ b/src/test/java/edu/colorado/plv/cuanto/javita/MethodDeclaration.java
@@ -0,0 +1,7 @@
+package edu.colorado.plv.cuanto.javita;
+
+/**
+ * @author Sergio Mover
+ */
+public class MethodDeclaration {
+}
diff --git a/src/test/scala/edu/colorado/plv/cuanto/javita/TestJavitaSemantic.scala b/src/test/scala/edu/colorado/plv/cuanto/javita/TestJavitaSemantic.scala
new file mode 100644
index 0000000..ca45475
--- /dev/null
+++ b/src/test/scala/edu/colorado/plv/cuanto/javita/TestJavitaSemantic.scala
@@ -0,0 +1,50 @@
+package edu.colorado.plv.cuanto.javita
+
+import edu.colorado.plv.cuanto.CuantoSpec
+
+/**
+  * @author Sergio Mover
+  */
+class TestJavitaSemantic extends CuantoSpec {
+  import edu.colorado.plv.cuanto.javita.Expressions
+
+  def runMethods[A](table : org.scalatest.prop.TableFor2[() => A, A]) : Unit = {
+    it should s"Compute correct result" in {
+      forAll (table) { (e, n) => {
+        (e()) should equal (n)
+      }}
+    }
+  }
+
+  behavior of "Arithmetic operators"
+
+  val exprTests = Table(
+    ("Method call","Result"),
+    (Expressions.testExpr1 _,3),
+    (Expressions.testExpr2 _, 13),
+    (Expressions.testExpr3 _, 1),
+    (Expressions.testExpr4 _, 6),
+    (Expressions.testExpr5 _, 5),
+    (Expressions.testExpr6 _, 2),
+    (Expressions.testExpr7 _, 5),
+    (Expressions.testExpr8 _, 9),
+    (Expressions.testExpr9 _, 4),
+    (Expressions.testExpr10 _, 1),
+    (Expressions.testExpr11 _, 6),
+    (Expressions.testExpr12 _, 3),
+    (Expressions.testExpr13 _, 0)
+  )
+
+  runMethods(exprTests)
+
+  behavior of "Comparison operators"
+
+  val compTests = Table(
+    ("Method call","Result"),
+    (Expressions.testComparisons1 _, true),
+    (Expressions.testComparisons2 _, true),
+    (Expressions.testComparisons3 _, false)
+  )
+  runMethods(compTests)
+
+}

From a333cb220ce8dd6feef4c0e2cb9fd8ec14ec414c Mon Sep 17 00:00:00 2001
From: smover <sergio.mover@gmail.com>
Date: Fri, 15 Sep 2017 08:50:57 -0600
Subject: [PATCH 07/14] Add test for boolean expressions for Javita

Add simple test cases for boolean operators.
---
 .../plv/cuanto/javita/Expressions.java        | 45 +++++++++++++++++++
 .../cuanto/javita/TestJavitaSemantic.scala    | 19 ++++++--
 2 files changed, 61 insertions(+), 3 deletions(-)
 create mode 100644 src/test/java/edu/colorado/plv/cuanto/javita/Expressions.java

diff --git a/src/test/java/edu/colorado/plv/cuanto/javita/Expressions.java b/src/test/java/edu/colorado/plv/cuanto/javita/Expressions.java
new file mode 100644
index 0000000..06cbcaa
--- /dev/null
+++ b/src/test/java/edu/colorado/plv/cuanto/javita/Expressions.java
@@ -0,0 +1,45 @@
+package edu.colorado.plv.cuanto.javita;
+
+/**
+ * @author Sergio Mover
+ *
+ * 
+ */
+public class Expressions {
+
+  // TODO: do we want the bitwise operators for integers?
+  public static boolean testBool1() {return true && true;}
+  public static boolean testBool2() {return true && false;}
+  public static boolean testBool3() {return false && true;}
+  public static boolean testBool4() {return false && false;}
+
+  public static boolean testBool5() {return true || true;}
+  public static boolean testBool6() {return true || false;}
+  public static boolean testBool7() {return false || true;}
+  public static boolean testBool8() {return false || false;}
+
+  public static boolean testBool9() {return ! true;}
+  public static boolean testBool10() {return ! false;}
+
+  public static int testExpr1() {return 1 + 2;} // 3
+  public static int testExpr2() {return 1 + 2 + 10;} // 13
+  public static int testExpr3() {return 2 - 1;} // 1
+  public static int testExpr4() {return 2 * 3;} // 6
+  public static int testExpr5() {return 10 / 2;} // 5
+  public static int testExpr6() {return 10 % 4;} // 2
+  public static int testExpr7() {return 3 * 1 + 2;} // 5
+  public static int testExpr8() {return 3 * (1 + 2);} // 9
+  public static int testExpr9() {return 6 / 3 + 2;} // 4
+  public static int testExpr10() {return 6 / (3 + 2);} // 1
+  public static int testExpr11() {return 3 * 2 + 2 / 3;} // 6
+  public static int testExpr12() {return 4 * 3 / 4;} // 3
+  public static int testExpr13() {return (3 / 4);} // 0
+
+  /**
+   * Test comparison operators: <=, >=, <, >, !=, == 
+   */ 
+  public static boolean testComparisons1() {return 0 <= 0;} // true
+  public static boolean testComparisons2() {return 0 <= 1;} // true
+  public static boolean testComparisons3() {return 2 <= 0;} // faslse
+
+}
diff --git a/src/test/scala/edu/colorado/plv/cuanto/javita/TestJavitaSemantic.scala b/src/test/scala/edu/colorado/plv/cuanto/javita/TestJavitaSemantic.scala
index ca45475..89e8b12 100644
--- a/src/test/scala/edu/colorado/plv/cuanto/javita/TestJavitaSemantic.scala
+++ b/src/test/scala/edu/colorado/plv/cuanto/javita/TestJavitaSemantic.scala
@@ -17,7 +17,6 @@ class TestJavitaSemantic extends CuantoSpec {
   }
 
   behavior of "Arithmetic operators"
-
   val exprTests = Table(
     ("Method call","Result"),
     (Expressions.testExpr1 _,3),
@@ -34,11 +33,25 @@ class TestJavitaSemantic extends CuantoSpec {
     (Expressions.testExpr12 _, 3),
     (Expressions.testExpr13 _, 0)
   )
-
   runMethods(exprTests)
 
-  behavior of "Comparison operators"
+  behavior of "Boolean operators"
+  val boolTests = Table(
+    ("Method call","Result"),
+    (Expressions.testBool1 _, true),
+    (Expressions.testBool2 _, false),
+    (Expressions.testBool3 _, false),
+    (Expressions.testBool4 _, false),
+    (Expressions.testBool5 _, true),
+    (Expressions.testBool6 _, true),
+    (Expressions.testBool7 _, true),
+    (Expressions.testBool8 _, false),
+    (Expressions.testBool9 _, false),
+    (Expressions.testBool10 _, true)
+  )
+  runMethods(boolTests)
 
+  behavior of "Comparison operators"
   val compTests = Table(
     ("Method call","Result"),
     (Expressions.testComparisons1 _, true),

From 54df8bf069a65c4fe37b201357c45d25b31f2c57 Mon Sep 17 00:00:00 2001
From: smover <sergio.mover@gmail.com>
Date: Fri, 15 Sep 2017 08:59:22 -0600
Subject: [PATCH 08/14] Add test for comparison operator for Javita

Add the test cases for the comparison operators supported in Javita.
---
 .../plv/cuanto/javita/Expressions.java        | 19 ++++++++++++++++---
 .../cuanto/javita/TestJavitaSemantic.scala    | 15 ++++++++++++++-
 2 files changed, 30 insertions(+), 4 deletions(-)

diff --git a/src/test/java/edu/colorado/plv/cuanto/javita/Expressions.java b/src/test/java/edu/colorado/plv/cuanto/javita/Expressions.java
index 06cbcaa..a2b5ef7 100644
--- a/src/test/java/edu/colorado/plv/cuanto/javita/Expressions.java
+++ b/src/test/java/edu/colorado/plv/cuanto/javita/Expressions.java
@@ -38,8 +38,21 @@ public class Expressions {
   /**
    * Test comparison operators: <=, >=, <, >, !=, == 
    */ 
-  public static boolean testComparisons1() {return 0 <= 0;} // true
-  public static boolean testComparisons2() {return 0 <= 1;} // true
-  public static boolean testComparisons3() {return 2 <= 0;} // faslse
+  public static boolean testComparisons1() {return 0 <= 0;}  // true
+  public static boolean testComparisons2() {return 0 <= 1;}  // true
+  public static boolean testComparisons3() {return 2 <= 0;}  // faslse
+  public static boolean testComparisons4() {return 0 >= 0;}  // true
+  public static boolean testComparisons5() {return 1 >= 0;}  // true
+  public static boolean testComparisons6() {return 0 >= 2;}  // faslse
+  public static boolean testComparisons7() {return 0 < 0;}   // false
+  public static boolean testComparisons8() {return 0 < 1;}   // true
+  public static boolean testComparisons9() {return 2 < 0;}   // faslse
+  public static boolean testComparisons10() {return 0 > 0;}  // false
+  public static boolean testComparisons11() {return 1 > 0;}  // true
+  public static boolean testComparisons12() {return 0 > 2;}  // faslse
+  public static boolean testComparisons13() {return 0 == 0;} // true
+  public static boolean testComparisons14() {return 0 == 1;} // false
+  public static boolean testComparisons15() {return 0 != 0;} // false
+  public static boolean testComparisons16() {return 0 != 1;} // true
 
 }
diff --git a/src/test/scala/edu/colorado/plv/cuanto/javita/TestJavitaSemantic.scala b/src/test/scala/edu/colorado/plv/cuanto/javita/TestJavitaSemantic.scala
index 89e8b12..b54d8d3 100644
--- a/src/test/scala/edu/colorado/plv/cuanto/javita/TestJavitaSemantic.scala
+++ b/src/test/scala/edu/colorado/plv/cuanto/javita/TestJavitaSemantic.scala
@@ -56,7 +56,20 @@ class TestJavitaSemantic extends CuantoSpec {
     ("Method call","Result"),
     (Expressions.testComparisons1 _, true),
     (Expressions.testComparisons2 _, true),
-    (Expressions.testComparisons3 _, false)
+    (Expressions.testComparisons3 _, false),
+    (Expressions.testComparisons4 _, true),
+    (Expressions.testComparisons5 _, true),
+    (Expressions.testComparisons6 _, false),
+    (Expressions.testComparisons7 _, false),
+    (Expressions.testComparisons8 _, true),
+    (Expressions.testComparisons9 _, false),
+    (Expressions.testComparisons10 _, false),
+    (Expressions.testComparisons11 _, true),
+    (Expressions.testComparisons12 _, false),
+    (Expressions.testComparisons13 _, true),
+    (Expressions.testComparisons14 _, false),
+    (Expressions.testComparisons15 _, false),
+    (Expressions.testComparisons16 _, true)
   )
   runMethods(compTests)
 

From 0e39c499f2b70cae1d8ae2e17128953a52364c02 Mon Sep 17 00:00:00 2001
From: smover <sergio.mover@gmail.com>
Date: Fri, 15 Sep 2017 10:10:13 -0600
Subject: [PATCH 09/14] Add test for control flow for the Javita subset

Add the test cases for the control flow (sequences, conditionals,
loops, static method calls).
---
 .../plv/cuanto/javita/ControlFlow.java        | 180 ++++++++++++++++++
 .../plv/cuanto/javita/FieldDeclarations.java  |   7 -
 .../plv/cuanto/javita/MethodDeclaration.java  |   7 -
 .../cuanto/javita/TestJavitaSemantic.scala    |  31 +++
 4 files changed, 211 insertions(+), 14 deletions(-)
 create mode 100644 src/test/java/edu/colorado/plv/cuanto/javita/ControlFlow.java
 delete mode 100644 src/test/java/edu/colorado/plv/cuanto/javita/FieldDeclarations.java
 delete mode 100644 src/test/java/edu/colorado/plv/cuanto/javita/MethodDeclaration.java

diff --git a/src/test/java/edu/colorado/plv/cuanto/javita/ControlFlow.java b/src/test/java/edu/colorado/plv/cuanto/javita/ControlFlow.java
new file mode 100644
index 0000000..629a049
--- /dev/null
+++ b/src/test/java/edu/colorado/plv/cuanto/javita/ControlFlow.java
@@ -0,0 +1,180 @@
+package edu.colorado.plv.cuanto.javita;
+
+/**
+ * @author Sergio Mover
+ *
+ * Test the different control flow supported in Javita subset.
+ *
+ * By convention, the execution of all the public static method must
+ * return true.
+ */
+public class ControlFlow {
+  static int classField1 = 0;
+  static boolean classField2 = true;
+
+  public static boolean sequence1() {
+    int a = 2;
+    int b = 3;
+    int c = 0;
+
+    c = a + b;
+    a += b;
+
+    return c == a;
+  }
+
+  public static boolean if1() {
+    int a = 2;
+    int b = 2;
+    boolean result = false;
+
+    if (a == b) {
+      result = true;
+    }
+
+    return result;
+  }
+
+  public static boolean if2() {
+    int a = 2;
+    int b = 2;
+    boolean result = false;
+
+    if (a != b) {
+      result = false;
+    }
+    else {
+      if (a != b) {
+        result = false;
+      } else {
+        result = true;
+      }
+    }
+
+    return result;
+  }
+  
+  public static boolean switch1() {
+    // Test the table switch
+    int var = 2;
+    boolean result = false;
+
+    switch (var) {
+    case 0: break;
+    case 1: break;
+    case 2:
+      result = true;
+      break;
+    default:
+      result = false;
+      break;
+    }
+
+    return result;
+  }
+
+  public static boolean switch2() {
+    // Test the lookup switch
+    int var = 100;
+    boolean result = false;
+
+    switch (var) {
+    case 1: break;
+    case 10: break;
+    case 100:
+      result = true;
+      break;
+    case 1000: break;
+    default:
+      result = false;
+      break;
+    }
+    return result;
+  }
+
+  public static boolean switch3() {
+    // Test break
+    int var = 2;
+    boolean result = false;
+
+    switch (var) {
+    case 0: break;
+    case 1: break;
+    case 2:
+    case 3:
+      result = true;
+      break;
+    default:
+      result = false;
+      break;
+    }
+    return result;
+  }
+
+  public static boolean switch4() {
+    // Test default
+    int var = 65;
+    boolean result = false;
+
+    switch (var) {
+    case 0: break;
+    case 1: break;
+    case 2: break;
+    default:
+      result = true;
+      break;
+    }
+    return result;
+  }
+
+  public static boolean testWhile() {
+    int var = 0;
+    while (var < 100) {
+      var += 1;
+    }
+
+    return var == 100;
+  }
+
+  public static boolean testDoWhile() {
+    int var = 0;
+
+    do {
+      var += 1;
+    } while (var < 100);
+
+    return var == 100;
+  }
+
+  public static boolean testFor() {
+    int var = 200;
+
+    for (var = 0; var < 100; var++) {
+    }
+
+    return var == 100;
+  }
+
+  public static boolean testReadClassField() {
+    return classField1 == 0;
+  }
+
+  public static boolean testWriteClassField() {
+    classField1 = 25;
+    return classField1 == 25;
+  }
+
+  public static int sum(int a, int b) {
+    return a + b;
+  }
+
+  public static boolean testMethodCall() {
+    int a = 3;
+    int b = 2;
+    int result;
+
+    result = ControlFlow.sum(a, b);
+
+    return result == 5;
+  }
+}
diff --git a/src/test/java/edu/colorado/plv/cuanto/javita/FieldDeclarations.java b/src/test/java/edu/colorado/plv/cuanto/javita/FieldDeclarations.java
deleted file mode 100644
index 13b5c45..0000000
--- a/src/test/java/edu/colorado/plv/cuanto/javita/FieldDeclarations.java
+++ /dev/null
@@ -1,7 +0,0 @@
-package edu.colorado.plv.cuanto.javita;
-
-/**
- * @author Sergio Mover
- */
-public class FieldDeclarations {
-}
diff --git a/src/test/java/edu/colorado/plv/cuanto/javita/MethodDeclaration.java b/src/test/java/edu/colorado/plv/cuanto/javita/MethodDeclaration.java
deleted file mode 100644
index 8406841..0000000
--- a/src/test/java/edu/colorado/plv/cuanto/javita/MethodDeclaration.java
+++ /dev/null
@@ -1,7 +0,0 @@
-package edu.colorado.plv.cuanto.javita;
-
-/**
- * @author Sergio Mover
- */
-public class MethodDeclaration {
-}
diff --git a/src/test/scala/edu/colorado/plv/cuanto/javita/TestJavitaSemantic.scala b/src/test/scala/edu/colorado/plv/cuanto/javita/TestJavitaSemantic.scala
index b54d8d3..b6bb6bb 100644
--- a/src/test/scala/edu/colorado/plv/cuanto/javita/TestJavitaSemantic.scala
+++ b/src/test/scala/edu/colorado/plv/cuanto/javita/TestJavitaSemantic.scala
@@ -7,6 +7,7 @@ import edu.colorado.plv.cuanto.CuantoSpec
   */
 class TestJavitaSemantic extends CuantoSpec {
   import edu.colorado.plv.cuanto.javita.Expressions
+  import edu.colorado.plv.cuanto.javita.ControlFlow
 
   def runMethods[A](table : org.scalatest.prop.TableFor2[() => A, A]) : Unit = {
     it should s"Compute correct result" in {
@@ -73,4 +74,34 @@ class TestJavitaSemantic extends CuantoSpec {
   )
   runMethods(compTests)
 
+  behavior of "Control flow"
+  val cfTests = Table(
+    ("Method call","Result"),
+    (ControlFlow.sequence1 _, true),
+    (ControlFlow.if1 _, true),
+    (ControlFlow.if2 _, true),
+    (ControlFlow.switch1 _, true),
+    (ControlFlow.switch2 _, true),
+    (ControlFlow.switch3 _, true),
+    (ControlFlow.switch4 _, true),
+    (ControlFlow.testWhile _, true),
+    (ControlFlow.testDoWhile _, true),
+    (ControlFlow.testFor _, true)
+  )
+  runMethods(cfTests)
+
+  behavior of "Access fields"
+  val fieldsTests = Table(
+    ("Method call","Result"),
+    (ControlFlow.testReadClassField _, true),
+    (ControlFlow.testWriteClassField _, true)
+  )
+  runMethods(fieldsTests)
+
+  behavior of "Static method call"
+  val methodCallsTests = Table(
+    ("Method call","Result"),
+    (ControlFlow.testMethodCall _, true)
+  )
+  runMethods(methodCallsTests)
 }

From 97eb39bf82ce8042c0c375132aa58b06feff9592 Mon Sep 17 00:00:00 2001
From: smover <sergio.mover@gmail.com>
Date: Fri, 15 Sep 2017 10:27:51 -0600
Subject: [PATCH 10/14] Informal and quick description of the Javita language

Add a list of features included and excluded in the Javita language.
---
 doc/scoot/language_subset.tex | 75 +++++++++++++----------------------
 1 file changed, 28 insertions(+), 47 deletions(-)

diff --git a/doc/scoot/language_subset.tex b/doc/scoot/language_subset.tex
index 862f3f7..a5c19aa 100644
--- a/doc/scoot/language_subset.tex
+++ b/doc/scoot/language_subset.tex
@@ -6,65 +6,52 @@
 \usepackage{url}
 
 \newcommand{\minijava}{MiniJava\xspace}
+\newcommand{\javita}{Javita\xspace}
 
 \begin{document}
-\title{Java subsets and corresponding Jimple subset}
+\title{Javita}
 
 \maketitle
 
 % jimple - grammar for classes?
 
 
-\section{Java subset - (Javita?)}
-We define a subset of Java inspired by \minijava~\cite{} (a grammar
-for \minijava is available here \label{sec:minijava}).
+\section{\javita - Java subset handled in Cuanto}
+We informally define \javita, a subset of Java inspired by \minijava
+(a grammar for \minijava is available here \label{sec:minijava}).
 
 We define a different subset of Java than \minijava that has less
-language syntax restrictions.
-%
-The \minijava syntax restrictions are not important when using soot as
-frontend (we already have parsing and typechecking).
+language syntax restrictions. The \minijava syntax restrictions are
+not important when using soot as frontend (we already have parsing and
+typechecking).
 
-We first define a subset of Java with:
+The \javita fragment contains:
 \begin{itemize}
-\item Integer and Boolean variables
-\item Control flow  control flow: 
-\item only calls static static methods
-\item 
+\item Integer and Boolean variables;
+\item Operations on Integer variables (sum, difference,
+  multiplication, division, modulo);
+\item Operations on Boolean variables (and, or, negation, xor, ...); 
+\item Control flow: Sequences, for loops, while loops, do while loops;
+\item Declare static methods, with Integer and Boolean return values
+  and parameters;
+\item Call to static methods;
+\item Declaration of classes with static (Integer or Boolean) fields.
 \end{itemize} 
 
-What is outside the fragment:
+The rest of the Java language is outside the fragment:
 \begin{itemize}
-\item No dynamic memory allocation (no arrays, no creation of new
-  objects)
-\item No object oriented features (call to 
-\end{itemize}
-The language does not include dynamic memory allocation, object
-oriented features as 
-
- with the following features:
-\begin{itemize}
-\item Class declarations:
-  \begin{itemize}
-  \item Class declaration without inheritance, implementation of interfaces and generics.
-  \end{itemize}
-\item Method declarations:
-  \begin{itemize}
-    
-  \end{itemize}
-\item Variable declarations:
-  \begin{itemize}
-  \item Only Integer and Boolean primitive types
-  \end{itemize}
-\item Restriction on the type of the variables:
-\item 
-\item Integer and Boolean array types
-\item Class declarations
-Classes without method overloading (no interfaces, generics, \ldots)
-\item Restriction on the control flow and expressions (no exception handling)
+\item No variables of type different from Boolean or Integer;
+\item No dynamic memory allocation (no arrays, no creation of new objects);;
+\item No calls to methods on objects, no dynamic dispatch;
+\item No handling of exception;
+\item No declaration of non-static fields, no inheritance, no
+  implementation of interfaces, no generics types.
 \end{itemize}
 
+\bibliographystyle{plain}
+\bibliography{refs}
 
+\appendix
 
 \section{Jimple grammar}
 \begin{grammar}
@@ -234,12 +221,6 @@ \section{Jimple grammar}
 <exception_range> ::= ".catch" <ref_type> "from" <label> "to" <label> "using" <label>;
 
 \end{grammar}
-
-\bibliographystyle{plain}
-\bibliography{refs}
-
-\appendix
-
 \section{\minijava}
 \label{sec:minijava}
 

From 0ab21c5a0e1857fe2bd1242bb19590a0bf092d84 Mon Sep 17 00:00:00 2001
From: smover <sergio.mover@gmail.com>
Date: Fri, 15 Sep 2017 10:30:15 -0600
Subject: [PATCH 11/14] Rename the tex file

---
 doc/scoot/{language_subset.tex => javita.tex} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename doc/scoot/{language_subset.tex => javita.tex} (100%)

diff --git a/doc/scoot/language_subset.tex b/doc/scoot/javita.tex
similarity index 100%
rename from doc/scoot/language_subset.tex
rename to doc/scoot/javita.tex

From 3dd23f3a956b13a95a4a28e63d9aa18fd7cb5981 Mon Sep 17 00:00:00 2001
From: smover <sergio.mover@gmail.com>
Date: Fri, 15 Sep 2017 10:36:22 -0600
Subject: [PATCH 12/14] Fix code warning due to the use of the default package

---
 src/test/java/edu/colorado/plv/cuanto/javita/ControlFlow.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/test/java/edu/colorado/plv/cuanto/javita/ControlFlow.java b/src/test/java/edu/colorado/plv/cuanto/javita/ControlFlow.java
index 629a049..c150ac7 100644
--- a/src/test/java/edu/colorado/plv/cuanto/javita/ControlFlow.java
+++ b/src/test/java/edu/colorado/plv/cuanto/javita/ControlFlow.java
@@ -9,8 +9,8 @@
  * return true.
  */
 public class ControlFlow {
-  static int classField1 = 0;
-  static boolean classField2 = true;
+  private static int classField1 = 0;
+  private static boolean classField2 = true;
 
   public static boolean sequence1() {
     int a = 2;

From a2600ceb92cb531690a87e4a672ac47e6a5c51b8 Mon Sep 17 00:00:00 2001
From: smover <sergio.mover@gmail.com>
Date: Fri, 15 Sep 2017 10:38:40 -0600
Subject: [PATCH 13/14] Fix code style warnings in the Javita tests

Fix the code style warning for the use of duplicate string literals
and duplicate imports whthout using string brackets.
---
 .../plv/cuanto/javita/TestJavitaSemantic.scala | 18 ++++++++++--------
 1 file changed, 10 insertions(+), 8 deletions(-)

diff --git a/src/test/scala/edu/colorado/plv/cuanto/javita/TestJavitaSemantic.scala b/src/test/scala/edu/colorado/plv/cuanto/javita/TestJavitaSemantic.scala
index b6bb6bb..9dec094 100644
--- a/src/test/scala/edu/colorado/plv/cuanto/javita/TestJavitaSemantic.scala
+++ b/src/test/scala/edu/colorado/plv/cuanto/javita/TestJavitaSemantic.scala
@@ -6,8 +6,10 @@ import edu.colorado.plv.cuanto.CuantoSpec
   * @author Sergio Mover
   */
 class TestJavitaSemantic extends CuantoSpec {
-  import edu.colorado.plv.cuanto.javita.Expressions
-  import edu.colorado.plv.cuanto.javita.ControlFlow
+  import edu.colorado.plv.cuanto.javita.{Expressions, ControlFlow}
+
+  val mcString = "Method call"
+  val resString = "Result"
 
   def runMethods[A](table : org.scalatest.prop.TableFor2[() => A, A]) : Unit = {
     it should s"Compute correct result" in {
@@ -19,7 +21,7 @@ class TestJavitaSemantic extends CuantoSpec {
 
   behavior of "Arithmetic operators"
   val exprTests = Table(
-    ("Method call","Result"),
+    (mcString, resString),
     (Expressions.testExpr1 _,3),
     (Expressions.testExpr2 _, 13),
     (Expressions.testExpr3 _, 1),
@@ -38,7 +40,7 @@ class TestJavitaSemantic extends CuantoSpec {
 
   behavior of "Boolean operators"
   val boolTests = Table(
-    ("Method call","Result"),
+    (mcString, resString),
     (Expressions.testBool1 _, true),
     (Expressions.testBool2 _, false),
     (Expressions.testBool3 _, false),
@@ -54,7 +56,7 @@ class TestJavitaSemantic extends CuantoSpec {
 
   behavior of "Comparison operators"
   val compTests = Table(
-    ("Method call","Result"),
+    (mcString, resString),
     (Expressions.testComparisons1 _, true),
     (Expressions.testComparisons2 _, true),
     (Expressions.testComparisons3 _, false),
@@ -76,7 +78,7 @@ class TestJavitaSemantic extends CuantoSpec {
 
   behavior of "Control flow"
   val cfTests = Table(
-    ("Method call","Result"),
+    (mcString, resString),
     (ControlFlow.sequence1 _, true),
     (ControlFlow.if1 _, true),
     (ControlFlow.if2 _, true),
@@ -92,7 +94,7 @@ class TestJavitaSemantic extends CuantoSpec {
 
   behavior of "Access fields"
   val fieldsTests = Table(
-    ("Method call","Result"),
+    (mcString, resString),
     (ControlFlow.testReadClassField _, true),
     (ControlFlow.testWriteClassField _, true)
   )
@@ -100,7 +102,7 @@ class TestJavitaSemantic extends CuantoSpec {
 
   behavior of "Static method call"
   val methodCallsTests = Table(
-    ("Method call","Result"),
+    (mcString, resString),
     (ControlFlow.testMethodCall _, true)
   )
   runMethods(methodCallsTests)

From 7358e627ecea5e8b29238b548ebb30f0117c0f13 Mon Sep 17 00:00:00 2001
From: smover <sergio.mover@gmail.com>
Date: Fri, 15 Sep 2017 10:48:03 -0600
Subject: [PATCH 14/14] Fix code issue (unused field)

---
 src/test/java/edu/colorado/plv/cuanto/javita/ControlFlow.java | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/test/java/edu/colorado/plv/cuanto/javita/ControlFlow.java b/src/test/java/edu/colorado/plv/cuanto/javita/ControlFlow.java
index c150ac7..128f679 100644
--- a/src/test/java/edu/colorado/plv/cuanto/javita/ControlFlow.java
+++ b/src/test/java/edu/colorado/plv/cuanto/javita/ControlFlow.java
@@ -10,7 +10,6 @@
  */
 public class ControlFlow {
   private static int classField1 = 0;
-  private static boolean classField2 = true;
 
   public static boolean sequence1() {
     int a = 2;