--- a/stage3/stage3.cc	Tue Aug 14 19:40:01 2012 +0200
+++ b/stage3/stage3.cc	Wed Aug 22 16:46:17 2012 +0200
@@ -1,8 +1,10 @@
 /*
  *  matiec - a compiler for the programming languages defined in IEC 61131-3
  *
- *  Copyright (C) 2009-2011  Mario de Sousa (msousa@fe.up.pt)
+ *  Copyright (C) 2009-2012  Mario de Sousa (msousa@fe.up.pt)
  *  Copyright (C) 2007-2011  Laurent Bessard and Edouard Tisserant
+ *  Copyright (C) 2012       Manuele Conti (manuele.conti@sirius-es.it)
+ *  Copyright (C) 2012       Matteo Facchinetti (matteo.facchinetti@sirius-es.it)
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
@@ -32,17 +34,80 @@
 
 #include "stage3.hh"
 
-int type_safety(symbol_c *tree_root){
-	visit_expression_type_c visit_expression_type(tree_root);
+#include "flow_control_analysis.hh"
+#include "fill_candidate_datatypes.hh"
+#include "narrow_candidate_datatypes.hh"
+#include "print_datatypes_error.hh"
+#include "lvalue_check.hh"
+#include "array_range_check.hh"
+#include "constant_folding.hh"
 
-	(*tree_root).accept(visit_expression_type);
 
-	if (visit_expression_type.get_error_found())
-	  return -1;
+
+static int flow_control_analysis(symbol_c *tree_root){
+    flow_control_analysis_c flow_control_analysis(tree_root);
+    tree_root->accept(flow_control_analysis);
+    return 0;
+}
+
+
+/* Constant folding assumes that flow control analysis has been completed!
+ * so be sure to call flow_control_analysis() before calling this function!
+ */
+static int constant_folding(symbol_c *tree_root){
+    constant_folding_c constant_folding(tree_root);
+    tree_root->accept(constant_folding);
+    return constant_folding.get_error_count();
+}
+
+
+/* Type safety analysis assumes that 
+ *    - flow control analysis 
+ *    - constant folding (constant check)
+ * has already been completed, so be sure to call those semantic checkers
+ * before calling this function
+ */
+static int type_safety(symbol_c *tree_root){
+	fill_candidate_datatypes_c fill_candidate_datatypes(tree_root);
+	tree_root->accept(fill_candidate_datatypes);
+	narrow_candidate_datatypes_c narrow_candidate_datatypes(tree_root);
+	tree_root->accept(narrow_candidate_datatypes);
+	print_datatypes_error_c print_datatypes_error(tree_root);
+	tree_root->accept(print_datatypes_error);
+	return print_datatypes_error.get_error_count();
+}
+
+
+/* Left value checking assumes that data type analysis has already been completed,
+ * so be sure to call type_safety() before calling this function
+ */
+static int lvalue_check(symbol_c *tree_root){
+	lvalue_check_c lvalue_check(tree_root);
+	tree_root->accept(lvalue_check);
+	return lvalue_check.get_error_count();
+}
+
+/* Array range check assumes that constant folding has been completed!
+ * so be sure to call constant_folding() before calling this function!
+ */
+static int array_range_check(symbol_c *tree_root){
+	array_range_check_c array_range_check(tree_root);
+	tree_root->accept(array_range_check);
+	return array_range_check.get_error_count();
+}
+
+
+int stage3(symbol_c *tree_root){
+	int error_count = 0;
+	error_count += flow_control_analysis(tree_root);
+	error_count += constant_folding(tree_root);
+	error_count += type_safety(tree_root);
+	error_count += lvalue_check(tree_root);
+	error_count += array_range_check(tree_root);
 	
+	if (error_count > 0) {
+		fprintf(stderr, "%d error(s) found. Bailing out!\n", error_count); 
+		return -1;
+	}
 	return 0;
 }
-
-int stage3(symbol_c *tree_root){
-	return type_safety(tree_root);
-}