Working on (structural + elements) read/writes.

6 files changed, 417 insertions, 93 deletions

diff --git a/ast-to-instr/src/Expressions.java b/ast-to-instr/src/Expressions.java
index a4c4bbf..0ea741b 100644
--- a/ast-to-instr/src/Expressions.java
+++ b/ast-to-instr/src/Expressions.java
@@ -1,76 +1,114 @@
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+
+import java.util.ArrayList;
+import java.util.List;
 import java.util.Map;
 import java.util.HashMap;
 
+import javax.xml.xpath.XPathConstants;
 import javax.xml.xpath.XPathExpression;
 import javax.xml.xpath.XPathExpressionException;
 
 public class Expressions
 {
-   private static final XPathExpression XPE_GET_LEFT, XPE_GET_RIGHT;
+   private static final XPathExpression XPE_GET_LEFT_SIDE;
+   private static final XPathExpression XPE_GET_RIGHT_SIDE;
+   private static final XPathExpression XPE_GET_OPERAND;
+   private static final XPathExpression XPE_GET_FUN_PARAMETERS;
+   private static final XPathExpression XPE_GET_INDEX_LIST;
+   private static final XPathExpression XPE_GET_NAMED_ENTITY;
+   private static final XPathExpression XPE_GET_PREFIX_NAMED_ENTITY;
 
    static
    {
-      XPE_GET_LEFT = XMLManager.compile_or_die("./left");
-      XPE_GET_RIGHT = XMLManager.compile_or_die("./right");
+      XPE_GET_LEFT_SIDE = XMLManager.compile_or_die("./left");
+      XPE_GET_RIGHT_SIDE = XMLManager.compile_or_die("./right");
+      XPE_GET_OPERAND = XMLManager.compile_or_die("./operand");
+
+      XPE_GET_FUN_PARAMETERS =
+         XMLManager.compile_or_die
+         (
+            "./parameter_association_chain/el"
+         );
+
+      XPE_GET_INDEX_LIST = XMLManager.compile_or_die("./index_list/el");
+
+      XPE_GET_NAMED_ENTITY = XMLManager.compile_or_die("./named_entity");
+      XPE_GET_PREFIX_NAMED_ENTITY =
+         XMLManager.compile_or_die
+         (
+            "./prefix/named_entity"
+         );
    }
 
    private static enum Operator
    {
       /* From GHDL's ./src/vhdl/nodes_meta.adb */
-      IDENTITY("identity_operator", false), /* assuming it means "+ number" */
-      NEGATION("negation_operator", false), /* assuming it means "- number" */
-      ABSOLUTE("absolute_operator", false),
+      IDENTITY("identity_operator", "+", false), /* assuming it means "+ number" */
+      NEGATION("negation_operator", "-", false), /* assuming it means "- number" */
+      ABSOLUTE("absolute_operator", "abs", false),
 
-      NOT("not_operator", false),
+      NOT("not_operator", "not", false),
 
-      CONDITION("condition_operator", true), /* FIXME: what's this? */
+      CONDITION("condition_operator", "???", true), /* FIXME: what's this? */
 
       /* Flattens vectors using an operator. */
-      REDUCTION_AND("reduction_and_operator", false),
-      REDUCTION_OR("reduction_or_operator", false),
-      REDUCTION_NAND("reduction_nand_operator", false),
-      REDUCTION_NOR("reduction_nor_operator", false),
-      REDUCTION_XOR("reduction_xor_operator", false),
-      REDUCTION_XNOR("reduction_xnor_operator", false),
-
-      AND("and_operator", true),
-      OR("or_operator", true),
-      NAND("nand_operator", true),
-      NOR("nor_operator", true),
-      XOR("xor_operator", true),
-      XNOR("xnor_operator", true),
-
-      EQUALITY("equality_operator", true),
-      INEQUALITY("inequality_operator", true),
-      LESS_THAN("less_than_operator", true),
-      LESS_THAN_OR_EQUAL("less_than_or_equal_operator", true),
-      GREATER_THAN("greater_than_operator", true),
-      GREATER_THAN_OR_EQUAL("greater_than_or_equal_operator", true),
+      REDUCTION_AND("reduction_and_operator", "and", false),
+      REDUCTION_OR("reduction_or_operator", "or", false),
+      REDUCTION_NAND("reduction_nand_operator", "nand", false),
+      REDUCTION_NOR("reduction_nor_operator", "nor", false),
+      REDUCTION_XOR("reduction_xor_operator", "xor", false),
+      REDUCTION_XNOR("reduction_xnor_operator", "xnor", false),
+
+      AND("and_operator", "and", true),
+      OR("or_operator", "or", true),
+      NAND("nand_operator", "nand", true),
+      NOR("nor_operator", "nor", true),
+      XOR("xor_operator", "xor", true),
+      XNOR("xnor_operator", "xnor", true),
+
+      EQUALITY("equality_operator", "=", true),
+      INEQUALITY("inequality_operator", "/=", true),
+      LESS_THAN("less_than_operator", "<", true),
+      LESS_THAN_OR_EQUAL("less_than_or_equal_operator", "<=", true),
+      GREATER_THAN("greater_than_operator", ">", true),
+      GREATER_THAN_OR_EQUAL("greater_than_or_equal_operator", ">=", true),
 
       /* FIXME: What are those? */
-      MATCH_EQUALITY("match_equality_operator", true),
-      MATCH_INEQUALITY("match_inequality_operator", true),
-      MATCH_LESS_THAN("match_less_than_operator", true),
-      MATCH_LESS_THAN_OR_EQUAL("match_less_than_or_equal_operator", true),
-      MATCH_GREATER_THAN("match_greater_than_operator", true),
-      MATCH_GREATER_THAN_OR_EQUAL("match_greater_than_or_equal_operator", true),
+      MATCH_EQUALITY("match_equality_operator", "???", true),
+      MATCH_INEQUALITY("match_inequality_operator", "???", true),
+      MATCH_LESS_THAN("match_less_than_operator", "???", true),
+      MATCH_LESS_THAN_OR_EQUAL
+      (
+         "match_less_than_or_equal_operator",
+         "???",
+         true
+      ),
+      MATCH_GREATER_THAN("match_greater_than_operator", "???", true),
+      MATCH_GREATER_THAN_OR_EQUAL
+      (
+         "match_greater_than_or_equal_operator",
+         "???",
+         true
+      ),
 
       /* Called using "logical array OP integer", apparently. */
-      SLL("sll_operator", true),
-      SLA("sla_operator", true),
-      SRL("srl_operator", true),
-      SRA("sra_operator", true),
-      ROL("rol_operator", true),
-      ROR("ror_operator", true),
-
-      ADDITION("addition_operator", true),
-      SUBSTRACTION("substraction_operator", true),
-      CONCATENATION("concatenation_operator", true),
-      MULTIPLICATION("multiplication_operator", true),
-      DIVISION("division_operator", true),
-      MODULUS("modulus_operator", true),
-      REMAINDER("remainder_operator", true),
-      EXPONENTIATION("exponentiation_operator", true);
+      SLL("sll_operator", "sll", true),
+      SLA("sla_operator", "sla", true),
+      SRL("srl_operator", "srl", true),
+      SRA("sra_operator", "sra", true),
+      ROL("rol_operator", "rol", true),
+      ROR("ror_operator", "ror", true),
+
+      ADDITION("addition_operator", "+", true),
+      SUBSTRACTION("substraction_operator", "-", true),
+      CONCATENATION("concatenation_operator", "&", true),
+      MULTIPLICATION("multiplication_operator", "*", true),
+      DIVISION("division_operator", "/", true),
+      MODULUS("modulus_operator", "mod", true),
+      REMAINDER("remainder_operator", "rem", true),
+      EXPONENTIATION("exponentiation_operator", "**", true);
 
       /** Static **************************************************************/
       private static final Map<String, Operator> FROM_TAG;
@@ -91,17 +129,253 @@ public class Expressions
 
       /** Non-Static **********************************************************/
       private final String tag;
+      private final String symbol;
       private final boolean is_binary;
 
       private Operator
       (
          final String tag,
+         final String symbol,
          final boolean is_binary
       )
       {
          this.tag = tag;
+         this.symbol = symbol;
          this.is_binary = is_binary;
       }
    }
-   /***************************************************************************/
+
+   public static void process
+   (
+      final List<IDs> elements,
+      final StringBuilder structure,
+      final Node current_node
+   )
+   throws XPathExpressionException
+   {
+      final String kind;
+      final Operator op;
+
+      kind = XMLManager.get_attribute(current_node, "kind");
+
+      op = Operator.FROM_TAG.get(kind);
+
+      if (op == null)
+      {
+         process_non_operator(elements, structure, current_node, kind);
+      }
+      else if (op.is_binary)
+      {
+         structure.append("(?");
+         elements.add
+         (
+            Strings.get_id_from_string
+            (
+               op.symbol
+            )
+         );
+
+         process
+         (
+            elements,
+            structure,
+            (Node) XPE_GET_LEFT_SIDE.evaluate
+            (
+               current_node,
+               XPathConstants.NODE
+            )
+         );
+
+         process
+         (
+            elements,
+            structure,
+            (Node) XPE_GET_RIGHT_SIDE.evaluate
+            (
+               current_node,
+               XPathConstants.NODE
+            )
+         );
+
+         structure.append(")"); /* TODO */
+      }
+      else
+      {
+         structure.append("(?");
+         elements.add
+         (
+            Strings.get_id_from_string
+            (
+               op.symbol
+            )
+         );
+
+         process
+         (
+            elements,
+            structure,
+            (Node) XPE_GET_OPERAND.evaluate
+            (
+               current_node,
+               XPathConstants.NODE
+            )
+         );
+
+         structure.append(")");
+      }
+   }
+
+   public static void process_non_operator
+   (
+      final List<IDs> elements,
+      final StringBuilder structure,
+      final Node current_node,
+      final String kind
+   )
+   throws XPathExpressionException
+   {
+      if (kind.equals("simple_name"))
+      {
+         final Node named_entity;
+
+         named_entity =
+            (Node) XPE_GET_NAMED_ENTITY.evaluate
+            (
+               current_node,
+               XPathConstants.NODE
+            );
+
+         structure.append("?");
+
+         elements.add
+         (
+            Waveforms.get_associated_waveform_id
+            (
+               IDs.get_id_from_xml_id
+               (
+                  XMLManager.get_attribute(named_entity, "ref"),
+                  null
+               )
+            )
+         );
+      }
+      else if (kind.equals("function_call"))
+      {
+         final Node named_entity;
+         final NodeList params;
+         final int params_length;
+
+         named_entity =
+            (Node) XPE_GET_PREFIX_NAMED_ENTITY.evaluate
+            (
+               current_node,
+               XPathConstants.NODE
+            );
+
+         structure.append("(?");
+
+         elements.add
+         (
+            Waveforms.get_associated_waveform_id
+            (
+               IDs.get_id_from_xml_id
+               (
+                  XMLManager.get_attribute(named_entity, "ref"),
+                  null
+               )
+            )
+         );
+
+         params =
+            (NodeList) XPE_GET_FUN_PARAMETERS.evaluate
+            (
+               current_node,
+               XPathConstants.NODESET
+            );
+
+         params_length = params.getLength();
+
+         for (int i = 0; i < params_length; ++i)
+         {
+            process
+            (
+               elements,
+               structure,
+               params.item(i)
+            );
+         }
+
+         structure.append(")");
+      }
+      else if (kind.equals("indexed_name")) /* vector */
+      {
+         final Node named_entity;
+         final NodeList params;
+         final int params_length;
+
+         named_entity =
+            (Node) XPE_GET_PREFIX_NAMED_ENTITY.evaluate
+            (
+               current_node,
+               XPathConstants.NODE
+            );
+
+         structure.append("(?");
+
+         elements.add
+         (
+            Waveforms.get_associated_waveform_id
+            (
+               IDs.get_id_from_xml_id
+               (
+                  XMLManager.get_attribute(named_entity, "ref"),
+                  null
+               )
+            )
+         );
+
+         params =
+            (NodeList) XPE_GET_INDEX_LIST.evaluate
+            (
+               current_node,
+               XPathConstants.NODESET
+            );
+
+         params_length = params.getLength();
+
+         for (int i = 0; i < params_length; ++i)
+         {
+            process
+            (
+               elements,
+               structure,
+               params.item(i)
+            );
+         }
+
+         structure.append(")");
+      }
+      else if (kind.contains("literal"))
+      {
+         /*
+          grep "Kind.*Literal" ./src/vhdl/nodes_meta.adb | sort | uniq -u
+          points to:
+         "character_literal";
+         "enumeration_literal";
+         "floating_point_literal";
+         "integer_literal";
+         "null_literal";
+         "overflow_literal";
+         "physical_fp_literal";
+         "physical_int_literal";
+         "physical_literal"; (unsure if it can happen)
+         "string_literal8";
+
+         They don't all use the same structure, so we're going to handle them
+         latter.
+         */
+
+         structure.append("l");
+      }
+   }
 }
diff --git a/ast-to-instr/src/VHDLCSNode.java b/ast-to-instr/src/VHDLCSNode.java
index 7989c67..3e991f0 100644
--- a/ast-to-instr/src/VHDLCSNode.java
+++ b/ast-to-instr/src/VHDLCSNode.java
@@ -181,7 +181,7 @@ public class VHDLCSNode extends VHDLNode
             XPathConstants.NODE
          );
 
-      handle_expression(local_id, sources);
+      handle_read_expr_predicates(local_id, sources);
    }
 
    /***************************************************************************/
diff --git a/ast-to-instr/src/VHDLISNode.java b/ast-to-instr/src/VHDLISNode.java
index 6f70aa8..62fc3da 100644
--- a/ast-to-instr/src/VHDLISNode.java
+++ b/ast-to-instr/src/VHDLISNode.java
@@ -179,7 +179,7 @@ public class VHDLISNode extends VHDLNode
             XPathConstants.NODE
          );
 
-      handle_expression(local_id, sources);
+      handle_read_expr_predicates(local_id, sources);
    }
 
    /***************************************************************************/
diff --git a/ast-to-instr/src/VHDLNode.java b/ast-to-instr/src/VHDLNode.java
index 970be9a..b05f08c 100644
--- a/ast-to-instr/src/VHDLNode.java
+++ b/ast-to-instr/src/VHDLNode.java
@@ -1,70 +1,116 @@
 import org.w3c.dom.Node;
 
+import java.util.ArrayList;
+import java.util.List;
+
 import javax.xml.xpath.XPathExpressionException;
-import javax.xml.xpath.XPathExpression;
 
 public abstract class VHDLNode extends ParsableXML
 {
-   /** Static *****************************************************************/
-   private static XPathExpression XPE_FIND_EXPR_NAMED_ENTITIES;
+   protected final IDs next_node;
+   protected final int depth;
+   protected final String[] attributes;
+   protected final OutputFile output;
 
-   static
+   public VHDLNode
+   (
+      final OutputFile output,
+      final IDs parent_id,
+      final Node xml_node,
+      final IDs next_node,
+      final int depth,
+      final String[] attributes
+   )
    {
-      XPE_FIND_EXPR_NAMED_ENTITIES =
-         XMLManager.compile_or_die
-         (
-            ".//named_entity"
-         );
+      super(parent_id, xml_node);
+
+      this.output = output;
+      this.next_node = next_node;
+      this.depth = depth;
+      this.attributes = attributes;
    }
 
-   protected void handle_expression
+   protected void handle_read_expr_predicates
    (
       final IDs local_id,
-      final Node expression_start
+      final Node expr_node
    )
    throws XPathExpressionException
    {
-      final String ref;
+      final List<IDs> elements;
+      final StringBuilder structure;
+      final int elements_count;
 
-      ref = XMLManager.get_attribute(expression_start, "ref");
+      elements = new ArrayList<IDs>();
+      structure = new StringBuilder();
 
-      if (!Main.node_is_function_or_literal(ref))
+      Expressions.process(elements, structure, expr_node);
+
+      Predicates.add_entry
+      (
+         output,
+         "is_read_structure",
+         local_id,
+         Strings.get_id_from_string
+         (
+            structure.toString()
+         )
+      );
+
+      elements_count = elements.size();
+
+      for (int i = 0; i < elements_count; ++i)
       {
          Predicates.add_entry
          (
             output,
-            "expr_reads",
+            "is_read_element",
             local_id,
-            Waveforms.get_associated_waveform_id
-            (
-               IDs.get_id_from_xml_id(ref, (String) null)
-            )
+            Strings.get_id_from_string(Integer.toString(i)),
+            elements.get(i)
          );
       }
    }
 
-   /** Non-Static *************************************************************/
-   protected final IDs next_node;
-   protected final int depth;
-   protected final String[] attributes;
-   protected final OutputFile output;
-
-   public VHDLNode
+   protected void handle_written_expr_predicates
    (
-      final OutputFile output,
-      final IDs parent_id,
-      final Node xml_node,
-      final IDs next_node,
-      final int depth,
-      final String[] attributes
+      final IDs local_id,
+      final Node expr_node
    )
+   throws XPathExpressionException
    {
-      super(parent_id, xml_node);
+      final List<IDs> elements;
+      final StringBuilder structure;
+      final int elements_count;
 
-      this.output = output;
-      this.next_node = next_node;
-      this.depth = depth;
-      this.attributes = attributes;
-   }
+      elements = new ArrayList<IDs>();
+      structure = new StringBuilder();
 
+      Expressions.process(elements, structure, expr_node);
+
+      Predicates.add_entry
+      (
+         output,
+         "is_written_structure",
+         local_id,
+         Strings.get_id_from_string
+         (
+            structure.toString()
+         )
+      );
+
+      elements_count = elements.size();
+
+      for (int i = 0; i < elements_count; ++i)
+      {
+         Predicates.add_entry
+         (
+            output,
+            "is_written_element",
+            local_id,
+            Strings.get_id_from_string(Integer.toString(i)),
+            elements.get(i)
+         );
+      }
+   }
 }
diff --git a/ast-to-instr/src/VHDLSSASNode.java b/ast-to-instr/src/VHDLSSASNode.java
index 05d8af0..ef08f6f 100644
--- a/ast-to-instr/src/VHDLSSASNode.java
+++ b/ast-to-instr/src/VHDLSSASNode.java
@@ -22,7 +22,7 @@ public class VHDLSSASNode extends VHDLNode
       XPE_FIND_SOURCES =
          XMLManager.compile_or_die
          (
-            "./waveform_chain"/* //named_entity" */
+            "./waveform_chain/el/we_value"/* //named_entity" */
          );
 
       XPE_FIND_PREFIXED_NE = XMLManager.compile_or_die("./prefix/named_entity");
@@ -173,7 +173,7 @@ public class VHDLSSASNode extends VHDLNode
             XPathConstants.NODE
          );
 
-      handle_expression(local_id, sources);
+      handle_read_expr_predicates(local_id, sources);
    }
 
    private void handle_predicate_expr_writes
diff --git a/ast-to-instr/src/VHDLWNode.java b/ast-to-instr/src/VHDLWNode.java
index 66d0c00..84cebb9 100644
--- a/ast-to-instr/src/VHDLWNode.java
+++ b/ast-to-instr/src/VHDLWNode.java
@@ -168,7 +168,11 @@ public class VHDLWNode extends VHDLNode
             XPathConstants.NODE
          );
 
-      handle_expression(local_id, sources);
+      if (sources != (Node) null)
+      {
+         /* Not "others" */
+         handle_read_expr_predicates(local_id, sources);
+      }
    }
 
    /***************************************************************************/