// MinRemMatchLen and MaxRemMatchLen are calculated on the fly during the matching process /* * // For future enhancement (don't forget CopyEx()) * public ListPatternElem (DownRepFactor downRepFactor, DisjunctiveSearchTerm altSearchTerms, AcrossRepFactor acrossRepFactor) * : base ("RANGE") // used by CopyEx * { * this.downRepFactor = downRepFactor; * this.altSearchTerms = altSearchTerms; * this.acrossRepFactor = acrossRepFactor; * * int n = TARGETOFFSET + (altSearchTerms == null ? 1 : altSearchTerms.Count); * args = new BaseTerm [n]; * * args [0] = HasAcrossRepFactor ? acrossRepFactor.minLenTerm : DecimalTerm.ZERO; * args [1] = HasAcrossRepFactor ? acrossRepFactor.maxLenTerm : DecimalTerm.ZERO; * args [2] = HasAcrossRepFactor ? acrossRepFactor.bindVar : null; * args [3] = HasAltSearchTerms ? altSearchTerms.bindVar : null; * * int i = TARGETOFFSET; * * if (altSearchTerms != null) * foreach (BaseTerm t in altSearchTerms.alternatives) * args [i++] = t; * * isNegSearch = (altSearchTerms == null) ? false : altSearchTerms.isNegSearch; * } */ public ListPatternElem(BaseTerm[] a, DownRepFactor downRepFactor, bool isNegSearch) : base("RANGE", a) // used by CopyEx { #if old this.isNegSearch = isNegSearch; #endif }
// MinRemMatchLen and MaxRemMatchLen are calculated on the fly during the matching process // DEZE UITEINDELIJK GEBRUIKEN !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! // DENK AAN CopyEx() public ListPatternElem(DownRepFactor downRepFactor, DisjunctiveSearchTerm altSearchTerms, AcrossRepFactor acrossRepFactor) : base("RANGE") // used by CopyEx { this.downRepFactor = downRepFactor; this.altSearchTerms = altSearchTerms; this.acrossRepFactor = acrossRepFactor; int n = TARGETOFFSET + (altSearchTerms == null ? 1 : altSearchTerms.Count); args = new BaseTerm [n]; args [0] = HasAcrossRepFactor ? acrossRepFactor.minLenTerm : DecimalTerm.ZERO; args [1] = HasAcrossRepFactor ? acrossRepFactor.maxLenTerm : DecimalTerm.ZERO; args [2] = HasAcrossRepFactor ? acrossRepFactor.bindVar : null; args [3] = HasAltSearchTerms ? altSearchTerms.bindVar : null; int i = TARGETOFFSET; if (altSearchTerms != null) { foreach (BaseTerm t in altSearchTerms.alternatives) { args [i++] = t; } } isNegSearch = (altSearchTerms == null) ? false : altSearchTerms.isNegSearch; }
public SearchTerm(DownRepFactor downRepFactor, BaseTerm term) { this.downRepFactor = downRepFactor; this.term = term; }
// each call processes one element of pattern[] bool UnifyTailEx(int ip, int it, VarStack varStack) { ListPatternElem e = (ListPatternElem)pattern[ip]; Variable rangeSpecVar = (Variable)e.RangeBindVar; NodeIterator subtreeIterator; int k; int marker; ListTerm RangeList = null; BaseTerm tail = null; int minLen; // minimum required range length (number of range elements) int maxLen; // maximum possible ... if (!DoLowerAndUpperboundChecks(ip, it, out minLen, out maxLen)) { return(false); } // scan the minimal number of range elements. Add them to the range list, // i.e. the last variable (if present) preceding the '{ , }' for (int i = 0; i < minLen; i++) { if ((k = it + i) >= target.Count) { return(false); } AppendToRangeList(ref RangeList, rangeSpecVar, target[k], ref tail); } marker = varStack.Count; // register the point to which we must possibly undo unifications if (e.HasSearchTerm) { // scan the elements up to the maximum range length, and the element immediately thereafter for (int i = minLen; i <= maxLen; i++) { BaseTerm t = null; k = it + i; if (k == target.Count) { return(false); } bool negSearchSucceeded = true; // iff none of the alternative term matches the target term for (int j = 4; j < e.Args.Length; j++) // scan all AltSearchTerm alternatives (separated by '|') { BaseTerm searchTerm = e.AltSearchTerms[j]; DownRepFactor downRepFactor = null; // e.downRepFactor [j]; t = target[k]; AltLoopStatus status = AltLoopStatus.TryNextAlt; if (downRepFactor == null) { status = TryOneAlternative(ip, varStack, e, k, marker, RangeList, i, t, ref negSearchSucceeded, searchTerm); if (status == AltLoopStatus.MatchFound) { return(true); } } else // traverse the downRepFactor tree, which in principle may yield more than one match { subtreeIterator = new NodeIterator(t, searchTerm, downRepFactor.minLenTerm, downRepFactor.maxLenTerm, false, downRepFactor.bindVar, varStack); foreach (BaseTerm match in subtreeIterator) // try -- if necessary -- each tree match with the current search term { status = TryOneAlternative(ip, varStack, e, k, marker, RangeList, i, match, ref negSearchSucceeded, searchTerm); if (status == AltLoopStatus.MatchFound) { return(true); } if (status == AltLoopStatus.Break) { break; } } } if (status == AltLoopStatus.Break) { break; } } // at this point sufficient alternatives have been tried if (e.IsNegSearch && negSearchSucceeded) // none of the terms matched => ok if binding succeeds { if (!TryBindingAltListVarToMatch(e.AltListBindVar, t, varStack) || // bind the AltListBindVar to the match !TryBindingRangeRelatedVars(e, i, RangeList, varStack)) // bind the range to the range variables { return(false); // binding failed } if (ip == pattern.Length - 1) // this was the last pattern element { if (k == target.Count - 1) // both pattern and target exhausted { return(true); } } else if (UnifyTailEx(ip + 1, k + 1, varStack)) // now deal with the rest { return(true); } } else if (i < maxLen) // append the rejected term to the range list and go try the next term { AppendToRangeList(ref RangeList, rangeSpecVar, t, ref tail); } } } else // a range without a subsequent search term (so followed by another range or end of pattern) { for (int i = minLen; i <= maxLen; i++) { k = it + i; if (k == target.Count) // ok, target[k] does not exist, end of target hit { return(TryBindingRangeRelatedVars(e, i, RangeList, varStack)); // i is actual range length } // k is ok if (i < maxLen) { AppendToRangeList(ref RangeList, rangeSpecVar, target[k], ref tail); } // now deal with the rest if (TryBindingRangeRelatedVars(e, i, RangeList, varStack) && UnifyTailEx(ip + 1, k, varStack)) { return(true); } } } // If we arrive here, no matching term was found in or immediately after the permitted range. // Therefore, undo any unifications made locally in this method and return with failure. if (marker != 0) { BaseTerm.UnbindToMarker(varStack, marker); } return(false); }
public SearchTerm (DownRepFactor downRepFactor, BaseTerm term) { this.downRepFactor = downRepFactor; this.term = term; }
public ListPatternElem (BaseTerm [] a, DownRepFactor downRepFactor, bool isNegSearch) : base ("RANGE", a) // used by CopyEx { #if old this.isNegSearch = isNegSearch; #endif }
// MinRemMatchLen and MaxRemMatchLen are calculated on the fly during the matching process // DEZE UITEINDELIJK GEBRUIKEN !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! // DENK AAN CopyEx() public ListPatternElem (DownRepFactor downRepFactor, DisjunctiveSearchTerm altSearchTerms, AcrossRepFactor acrossRepFactor) : base ("RANGE") // used by CopyEx { this.downRepFactor = downRepFactor; this.altSearchTerms = altSearchTerms; this.acrossRepFactor = acrossRepFactor; int n = TARGETOFFSET + (altSearchTerms == null ? 1 : altSearchTerms.Count); args = new BaseTerm [n]; args [0] = HasAcrossRepFactor ? acrossRepFactor.minLenTerm : DecimalTerm.ZERO; args [1] = HasAcrossRepFactor ? acrossRepFactor.maxLenTerm : DecimalTerm.ZERO; args [2] = HasAcrossRepFactor ? acrossRepFactor.bindVar : null; args [3] = HasAltSearchTerms ? altSearchTerms.bindVar : null; int i = TARGETOFFSET; if (altSearchTerms != null) foreach (BaseTerm t in altSearchTerms.alternatives) args [i++] = t; isNegSearch = (altSearchTerms == null) ? false : altSearchTerms.isNegSearch; }