Builds, but doesn't actually do anything with the VariableStrings yet

AngledLuffa · AngledLuffa · commit 57a7e72ca0fe · 2025-06-28T20:13:03.000-07:00
diff --git a/src/edu/stanford/nlp/semgraph/semgrex/Attribute.java b/src/edu/stanford/nlp/semgraph/semgrex/Attribute.java
@@ -1,18 +1,28 @@
 package edu.stanford.nlp.semgraph.semgrex;
 
 import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import edu.stanford.nlp.util.Pair;
 
 public class Attribute implements Serializable {
   final String key;
   final Object cased;
   final Object caseless;
   final boolean negated;
 
-  Attribute(String key, Object cased, Object caseless, boolean negated) {
+  // specifies the groups in a regex that are captured as
+  // matcher-global string variables
+  final List<Pair<Integer, String>> variableGroups;
+
+  Attribute(String key, Object cased, Object caseless, boolean negated, List<Pair<Integer, String>> varGroups) {
     this.key = key;
     this.cased = cased;
     this.caseless = caseless;
     this.negated = negated;
+    this.variableGroups = Collections.unmodifiableList(new ArrayList<>(varGroups));
   }
 
   private static final long serialVersionUID = 973567614155612487L;
diff --git a/src/edu/stanford/nlp/semgraph/semgrex/NodeAttributes.java b/src/edu/stanford/nlp/semgraph/semgrex/NodeAttributes.java
@@ -6,8 +6,8 @@
 import java.util.List;
 import java.util.Set;
 
+import edu.stanford.nlp.util.Pair;
 import edu.stanford.nlp.util.Quadruple;
-import edu.stanford.nlp.util.Triple;
 
 /**
  * Stores attributes for a Semgrex NodePattern.
@@ -25,7 +25,7 @@ public class NodeAttributes {
   private boolean root;
   private boolean empty;
   // String, String, Boolean: key, value, negated
-  private List<Triple<String, String, Boolean>> attributes;
+  private List<Quadruple<String, String, Boolean, List<Pair<Integer, String>>>> attributes;
   private Set<String> positiveAttributes;
   // Some annotations, especially morpho freatures (CoreAnnotations.CoNLLUFeats)
   // are represented by Maps.  In some cases it will be easier to search
@@ -59,21 +59,21 @@ public boolean empty() {
     return empty;
   }
 
-  public void setAttribute(String key, String value, boolean negated) {
+  public void setAttribute(String key, String value, boolean negated, List<Pair<Integer, String>> varGroups) {
     if (!negated) {
       if (positiveAttributes.contains(key)) {
         throw new SemgrexParseException("Duplicate attribute " + key + " found in semgrex expression");
       }
       positiveAttributes.add(key);
     }
-    attributes.add(new Triple(key, value, negated));
+    attributes.add(new Quadruple<>(key, value, negated, varGroups));
   }
 
   public void addContains(String annotation, String key, String value, Boolean negated) {
     contains.add(new Quadruple(annotation, key, value, negated));
   }
 
-  public List<Triple<String, String, Boolean>> attributes() {
+  public List<Quadruple<String, String, Boolean, List<Pair<Integer, String>>>> attributes() {
     return Collections.unmodifiableList(attributes);
   }
 
diff --git a/src/edu/stanford/nlp/semgraph/semgrex/NodePattern.java b/src/edu/stanford/nlp/semgraph/semgrex/NodePattern.java
@@ -47,13 +47,9 @@ public class NodePattern extends SemgrexPattern  {
   private final String name;
   private String descString;
   SemgrexPattern child;
-  // specifies the groups in a regex that are captured as
-  // matcher-global string variables
-  private final List<Pair<Integer, String>> variableGroups;
 
   public NodePattern(GraphRelation r, boolean negDesc,
-                     NodeAttributes attrs, boolean isLink, String name,
-                     List<Pair<Integer, String>> variableGroups) {
+                     NodeAttributes attrs, boolean isLink, String name) {
     this.reln = r;
     this.negDesc = negDesc;
     this.isLink = isLink;
@@ -65,20 +61,21 @@ public NodePattern(GraphRelation r, boolean negDesc,
     this.regexPartialAttributes = new ArrayList<>();
 
     descString = "{";
-    for (Triple<String, String, Boolean> entry : attrs.attributes()) {
+    for (Quadruple<String, String, Boolean, List<Pair<Integer, String>>> entry : attrs.attributes()) {
       if (!descString.equals("{"))
         descString += ";";
       String key = entry.first();
       String value = entry.second();
       boolean negated = entry.third();
+      List<Pair<Integer, String>> varGroups = entry.fourth();
 
       // Add the attributes for this key
       if (value.equals("__")) {
-        attributes.add(new Attribute(key, true, true, negated));
+        attributes.add(new Attribute(key, true, true, negated, varGroups));
       } else if (value.matches("/.*/")) {
-        attributes.add(buildRegexAttribute(key, value, negated));
+        attributes.add(buildRegexAttribute(key, value, negated, varGroups));
       } else { // raw description
-        attributes.add(new Attribute(key, value, value, negated));
+        attributes.add(new Attribute(key, value, value, negated, varGroups));
       }
 
       if (negated) {
@@ -93,6 +90,8 @@ public NodePattern(GraphRelation r, boolean negDesc,
       String key = entry.second();
       String value = entry.third();
       boolean negated = entry.fourth();
+      // TODO: can add varGroups, especially for the regex matches
+      List<Pair<Integer, String>> varGroups = Collections.emptyList();
 
       Class<?> clazz = AnnotationLookup.getValueType(AnnotationLookup.toCoreKey(annotation));
       boolean isMap = clazz != null && Map.class.isAssignableFrom(clazz);
@@ -108,11 +107,11 @@ public NodePattern(GraphRelation r, boolean negDesc,
       } else {
         // Add the attributes for this key
         if (value.equals("__")) {
-          attr = new Attribute(key, true, true, negated);
+          attr = new Attribute(key, true, true, negated, varGroups);
         } else if (value.matches("/.*/")) {
-          attr = buildRegexAttribute(key, value, negated);
+          attr = buildRegexAttribute(key, value, negated, varGroups);
         } else { // raw description
-          attr = new Attribute(key, value, value, negated);
+          attr = new Attribute(key, value, value, negated, varGroups);
         }
         partialAttributes.add(new Pair<>(annotation, attr));
       }
@@ -141,15 +140,13 @@ public NodePattern(GraphRelation r, boolean negDesc,
     this.child = null;
     this.isRoot = attrs.root();
     this.isEmpty = attrs.empty();
-
-    this.variableGroups = Collections.unmodifiableList(variableGroups);
   }
 
   /**
    * Tests the value to see if it's really a regex, or just a string wrapped in regex.
    * Return an Attribute which matches this expression
    */
-  private Attribute buildRegexAttribute(String key, String value, boolean negated) {
+  private Attribute buildRegexAttribute(String key, String value, boolean negated, List<Pair<Integer, String>> varGroups) {
     boolean isRegexp = false;
     for (int i = 1; i < value.length() - 1; ++i) {
       char chr = value.charAt(i);
@@ -163,9 +160,9 @@ private Attribute buildRegexAttribute(String key, String value, boolean negated)
       return new Attribute(key,
                            Pattern.compile(patternContent),
                            Pattern.compile(patternContent, Pattern.CASE_INSENSITIVE|Pattern.UNICODE_CASE),
-                           negated);
+                           negated, varGroups);
     } else {
-      return new Attribute(key, patternContent, patternContent, negated);
+      return new Attribute(key, patternContent, patternContent, negated, varGroups);
     }
   }
 
@@ -233,7 +230,9 @@ public boolean nodeAttrMatch(IndexedWord node, final SemanticGraph sg, boolean i
       // }
       // System.out.println(nodeValue);
 
+      // TODO: check varGroups here
       boolean matches = checkMatch(attr, ignoreCase, nodeValue);
+
       if (!matches) {
         // System.out.println("doesn't match");
         // System.out.println("");
@@ -404,6 +403,7 @@ private static class NodeMatcher extends SemgrexMatcher {
     private SemgrexMatcher childMatcher;
     private boolean matchedOnce = false;
     private boolean committedVariables = false;
+    private VariableStrings localVariableStrings = null;
 
     private String nextMatchReln = null;
     private SemanticGraphEdge nextMatchEdge = null;
@@ -413,7 +413,7 @@ private static class NodeMatcher extends SemgrexMatcher {
     private boolean relnNamedFirst = false;
     private boolean edgeNamedFirst = false;
 
-    private boolean ignoreCase = false;
+    private final boolean ignoreCase;
 
     // universal: childMatcher is null if and only if
     // myNode.child == null OR resetChild has never been called
@@ -470,7 +470,8 @@ private void goToNextNodeMatch() {
       decommitNamedNodes();
       decommitNamedRelations();
       finished = true;
-      Matcher m = null;
+      VariableStrings tempVariableStrings = new VariableStrings();
+
       while (nodeMatchCandidateIterator.hasNext()) {
         if (myNode.reln.getName() != null) {
           String foundReln = namesToRelations.get(myNode.reln.getName());
@@ -508,47 +509,23 @@ private void goToNextNodeMatch() {
               }
             }
           } else {
+            // TODO: pass in all varstrings and local varstrings
             boolean found = myNode.nodeAttrMatch(nextMatch,
                                                  hyp ? sg : sg_aligned,
                                                  ignoreCase);
             if (found) {
-              for (Pair<Integer, String> varGroup : myNode.variableGroups) {
-                // if variables have been captured from a regex, they
-                // must match any previous matchings
-                String thisVariable = varGroup.second();
-                String thisVarString = variableStrings.getString(thisVariable);
-                if (thisVarString != null &&
-                    !thisVarString.equals(m.group(varGroup.first()))) {
-                  // failed to match a variable
-                  found = false;
-                  break;
-                }
-              }
-
               // nodeAttrMatch already checks negDesc, so no need to
               // check for that here
               finished = false;
               break;
             }
           }
         } else { // try to match the description pattern.
+          // TODO: pass in all varstrings and local varstrings
           boolean found = myNode.nodeAttrMatch(nextMatch,
                                                hyp ? sg : sg_aligned,
                                                ignoreCase);
           if (found) {
-            for (Pair<Integer, String> varGroup : myNode.variableGroups) {
-              // if variables have been captured from a regex, they
-              // must match any previous matchings
-              String thisVariable = varGroup.second();
-              String thisVarString = variableStrings.getString(thisVariable);
-              if (thisVarString != null &&
-                  !thisVarString.equals(m.group(varGroup.first()))) {
-                // failed to match a variable
-                found = false;
-                break;
-              }
-            }
-
             // nodeAttrMatch already checks negDesc, so no need to
             // check for that here
             finished = false;
@@ -582,30 +559,23 @@ private void goToNextNodeMatch() {
         // TODO FIXME: this would need to read all of the matchers used
         // (eg, from the various attributes)
         // and commit all of them
-        commitVariableGroups(m); // commit my variable groups.
+        commitVariableGroups(tempVariableStrings); // commit my variable groups.
       }
       // finished is false exiting this if and only if nextChild exists
       // and has a label or backreference that matches
       // (also it will just have been reset)
     }
 
-    private void commitVariableGroups(Matcher m) {
+    private void commitVariableGroups(VariableStrings tempVariableStrings) {
       committedVariables = true; // commit all my variable groups.
-      if (myNode.variableGroups.size() > 0) {
-        System.out.println(myNode.variableGroups);
-      }
-      for (Pair<Integer, String> varGroup : myNode.variableGroups) {
-        System.out.println(varGroup);
-        String thisVarString = m.group(varGroup.first());
-        variableStrings.setVar(varGroup.second(), thisVarString);
-      }
+      localVariableStrings = tempVariableStrings;
+      variableStrings.setVars(tempVariableStrings);
     }
 
     private void decommitVariableGroups() {
       if (committedVariables) {
-        for (Pair<Integer, String> varGroup : myNode.variableGroups) {
-          variableStrings.unsetVar(varGroup.second());
-        }
+        variableStrings.unsetVars(localVariableStrings);
+        localVariableStrings = null;
       }
       committedVariables = false;
     }
diff --git a/src/edu/stanford/nlp/semgraph/semgrex/SemgrexParser.java b/src/edu/stanford/nlp/semgraph/semgrex/SemgrexParser.java
@@ -572,13 +572,14 @@ final public SemgrexPattern Root() throws ParseException {// Root pattern for th
     throw new Error("Missing return statement in function");
 }
 
-  final public void AddAttribute(NodeAttributes attributes, List<Pair<Integer,String>> varGroups) throws ParseException {Token attr = null;
+  final public void AddAttribute(NodeAttributes attributes) throws ParseException {Token attr = null;
         Token key = null;
         Token value = null;
         Token attrType = null;
         boolean negated = false;
         Token groupNum;
         Token groupVar;
+        List<Pair<Integer,String>> varGroups = new ArrayList<Pair<Integer,String>>();
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
     case UNIQ:
     case IDENTIFIER:{
@@ -615,10 +616,6 @@ final public SemgrexPattern Root() throws ParseException {// Root pattern for th
           jj_consume_token(-1);
           throw new ParseException();
         }
-if (attr != null && value != null) {
-                 negated = attrType.image.equals("!:");
-                 attributes.setAttribute(attr.image, value.image, negated);
-               }
         label_7:
         while (true) {
           switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
@@ -637,6 +634,10 @@ final public SemgrexPattern Root() throws ParseException {// Root pattern for th
 // TODO: this should have been NUMBER, but that doesn't seem to exist
                 varGroups.add(new Pair<Integer,String>(Integer.parseInt(groupNum.image),groupVar.image));
         }
+if (attr != null && value != null) {
+                 negated = attrType.image.equals("!:");
+                 attributes.setAttribute(attr.image, value.image, negated, varGroups);
+               }
         break;
         }
       case 26:{
@@ -785,14 +786,13 @@ final public SemgrexPattern Root() throws ParseException {// Root pattern for th
         boolean link = false;
         NodeAttributes attributes = new NodeAttributes();
         NodePattern pat;
-        List<Pair<Integer,String>> varGroups = new ArrayList<Pair<Integer,String>>();
     jj_consume_token(29);
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
     case UNIQ:
     case IDENTIFIER:
     case EMPTY:
     case ROOT:{
-      AddAttribute(attributes, varGroups);
+      AddAttribute(attributes);
       label_9:
       while (true) {
         switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
@@ -805,7 +805,7 @@ final public SemgrexPattern Root() throws ParseException {// Root pattern for th
           break label_9;
         }
         jj_consume_token(27);
-        AddAttribute(attributes, varGroups);
+        AddAttribute(attributes);
       }
       break;
       }
@@ -833,7 +833,7 @@ final public SemgrexPattern Root() throws ParseException {// Root pattern for th
       jj_la1[39] = jj_gen;
       ;
     }
-pat = new NodePattern(r, underNodeNegation, attributes, link, name != null ? name.image : null, varGroups);
+pat = new NodePattern(r, underNodeNegation, attributes, link, name != null ? name.image : null);
           {if ("" != null) return pat;}
     throw new Error("Missing return statement in function");
 }
diff --git a/src/edu/stanford/nlp/semgraph/semgrex/SemgrexParser.jj b/src/edu/stanford/nlp/semgraph/semgrex/SemgrexParser.jj
diff --git a/src/edu/stanford/nlp/util/VariableStrings.java b/src/edu/stanford/nlp/util/VariableStrings.java
