aboutsummaryrefslogtreecommitdiffhomepage
path: root/src/sdlang/ast.d
diff options
context:
space:
mode:
Diffstat (limited to 'src/sdlang/ast.d')
-rw-r--r--src/sdlang/ast.d1834
1 files changed, 1834 insertions, 0 deletions
diff --git a/src/sdlang/ast.d b/src/sdlang/ast.d
new file mode 100644
index 0000000..7ad1c30
--- /dev/null
+++ b/src/sdlang/ast.d
@@ -0,0 +1,1834 @@
+// SDLang-D
+// Written in the D programming language.
+
+module sdlang.ast;
+
+import std.algorithm;
+import std.array;
+import std.conv;
+import std.range;
+import std.string;
+
+version(sdlangUnittest)
+version(unittest)
+{
+ import std.stdio;
+ import std.exception;
+}
+
+import sdlang.exception;
+import sdlang.token;
+import sdlang.util;
+
+class Attribute
+{
+ Value value;
+ Location location;
+
+ private Tag _parent;
+ /// Get parent tag. To set a parent, attach this Attribute to its intended
+ /// parent tag by calling 'Tag.add(...)', or by passing it to
+ /// the parent tag's constructor.
+ @property Tag parent()
+ {
+ return _parent;
+ }
+
+ private string _namespace;
+ @property string namespace()
+ {
+ return _namespace;
+ }
+ /// Not particularly efficient, but it works.
+ @property void namespace(string value)
+ {
+ if(_parent && _namespace != value)
+ {
+ // Remove
+ auto saveParent = _parent;
+ if(_parent)
+ this.remove();
+
+ // Change namespace
+ _namespace = value;
+
+ // Re-add
+ if(saveParent)
+ saveParent.add(this);
+ }
+ else
+ _namespace = value;
+ }
+
+ private string _name;
+ /// Not including namespace. Use 'fullName' if you want the namespace included.
+ @property string name()
+ {
+ return _name;
+ }
+ /// Not the most efficient, but it works.
+ @property void name(string value)
+ {
+ if(_parent && _name != value)
+ {
+ _parent.updateId++;
+
+ void removeFromGroupedLookup(string ns)
+ {
+ // Remove from _parent._attributes[ns]
+ auto sameNameAttrs = _parent._attributes[ns][_name];
+ auto targetIndex = sameNameAttrs.countUntil(this);
+ _parent._attributes[ns][_name].removeIndex(targetIndex);
+ }
+
+ // Remove from _parent._tags
+ removeFromGroupedLookup(_namespace);
+ removeFromGroupedLookup("*");
+
+ // Change name
+ _name = value;
+
+ // Add to new locations in _parent._attributes
+ _parent._attributes[_namespace][_name] ~= this;
+ _parent._attributes["*"][_name] ~= this;
+ }
+ else
+ _name = value;
+ }
+
+ @property string fullName()
+ {
+ return _namespace==""? _name : text(_namespace, ":", _name);
+ }
+
+ this(string namespace, string name, Value value, Location location = Location(0, 0, 0))
+ {
+ this._namespace = namespace;
+ this._name = name;
+ this.location = location;
+ this.value = value;
+ }
+
+ this(string name, Value value, Location location = Location(0, 0, 0))
+ {
+ this._namespace = "";
+ this._name = name;
+ this.location = location;
+ this.value = value;
+ }
+
+ /// Removes 'this' from its parent, if any. Returns 'this' for chaining.
+ /// Inefficient ATM, but it works.
+ Attribute remove()
+ {
+ if(!_parent)
+ return this;
+
+ void removeFromGroupedLookup(string ns)
+ {
+ // Remove from _parent._attributes[ns]
+ auto sameNameAttrs = _parent._attributes[ns][_name];
+ auto targetIndex = sameNameAttrs.countUntil(this);
+ _parent._attributes[ns][_name].removeIndex(targetIndex);
+ }
+
+ // Remove from _parent._attributes
+ removeFromGroupedLookup(_namespace);
+ removeFromGroupedLookup("*");
+
+ // Remove from _parent.allAttributes
+ auto allAttrsIndex = _parent.allAttributes.countUntil(this);
+ _parent.allAttributes.removeIndex(allAttrsIndex);
+
+ // Remove from _parent.attributeIndicies
+ auto sameNamespaceAttrs = _parent.attributeIndicies[_namespace];
+ auto attrIndiciesIndex = sameNamespaceAttrs.countUntil(allAttrsIndex);
+ _parent.attributeIndicies[_namespace].removeIndex(attrIndiciesIndex);
+
+ // Fixup other indicies
+ foreach(ns, ref nsAttrIndicies; _parent.attributeIndicies)
+ foreach(k, ref v; nsAttrIndicies)
+ if(v > allAttrsIndex)
+ v--;
+
+ _parent.removeNamespaceIfEmpty(_namespace);
+ _parent.updateId++;
+ _parent = null;
+ return this;
+ }
+
+ override bool opEquals(Object o)
+ {
+ auto a = cast(Attribute)o;
+ if(!a)
+ return false;
+
+ return
+ _namespace == a._namespace &&
+ _name == a._name &&
+ value == a.value;
+ }
+
+ string toSDLString()()
+ {
+ Appender!string sink;
+ this.toSDLString(sink);
+ return sink.data;
+ }
+
+ void toSDLString(Sink)(ref Sink sink) if(isOutputRange!(Sink,char))
+ {
+ if(_namespace != "")
+ {
+ sink.put(_namespace);
+ sink.put(':');
+ }
+
+ sink.put(_name);
+ sink.put('=');
+ value.toSDLString(sink);
+ }
+}
+
+class Tag
+{
+ Location location;
+ Value[] values;
+
+ private Tag _parent;
+ /// Get parent tag. To set a parent, attach this Tag to its intended
+ /// parent tag by calling 'Tag.add(...)', or by passing it to
+ /// the parent tag's constructor.
+ @property Tag parent()
+ {
+ return _parent;
+ }
+
+ private string _namespace;
+ @property string namespace()
+ {
+ return _namespace;
+ }
+ /// Not particularly efficient, but it works.
+ @property void namespace(string value)
+ {
+ if(_parent && _namespace != value)
+ {
+ // Remove
+ auto saveParent = _parent;
+ if(_parent)
+ this.remove();
+
+ // Change namespace
+ _namespace = value;
+
+ // Re-add
+ if(saveParent)
+ saveParent.add(this);
+ }
+ else
+ _namespace = value;
+ }
+
+ private string _name;
+ /// Not including namespace. Use 'fullName' if you want the namespace included.
+ @property string name()
+ {
+ return _name;
+ }
+ /// Not the most efficient, but it works.
+ @property void name(string value)
+ {
+ if(_parent && _name != value)
+ {
+ _parent.updateId++;
+
+ void removeFromGroupedLookup(string ns)
+ {
+ // Remove from _parent._tags[ns]
+ auto sameNameTags = _parent._tags[ns][_name];
+ auto targetIndex = sameNameTags.countUntil(this);
+ _parent._tags[ns][_name].removeIndex(targetIndex);
+ }
+
+ // Remove from _parent._tags
+ removeFromGroupedLookup(_namespace);
+ removeFromGroupedLookup("*");
+
+ // Change name
+ _name = value;
+
+ // Add to new locations in _parent._tags
+ _parent._tags[_namespace][_name] ~= this;
+ _parent._tags["*"][_name] ~= this;
+ }
+ else
+ _name = value;
+ }
+
+ /// This tag's name, including namespace if one exists.
+ @property string fullName()
+ {
+ return _namespace==""? _name : text(_namespace, ":", _name);
+ }
+
+ // Tracks dirtiness. This is incremented every time a change is made which
+ // could invalidate existing ranges. This way, the ranges can detect when
+ // they've been invalidated.
+ private size_t updateId=0;
+
+ this(Tag parent = null)
+ {
+ if(parent)
+ parent.add(this);
+ }
+
+ this(
+ string namespace, string name,
+ Value[] values=null, Attribute[] attributes=null, Tag[] children=null
+ )
+ {
+ this(null, namespace, name, values, attributes, children);
+ }
+
+ this(
+ Tag parent, string namespace, string name,
+ Value[] values=null, Attribute[] attributes=null, Tag[] children=null
+ )
+ {
+ this._namespace = namespace;
+ this._name = name;
+
+ if(parent)
+ parent.add(this);
+
+ this.values = values;
+ this.add(attributes);
+ this.add(children);
+ }
+
+ private Attribute[] allAttributes; // In same order as specified in SDL file.
+ private Tag[] allTags; // In same order as specified in SDL file.
+ private string[] allNamespaces; // In same order as specified in SDL file.
+
+ private size_t[][string] attributeIndicies; // allAttributes[ attributes[namespace][i] ]
+ private size_t[][string] tagIndicies; // allTags[ tags[namespace][i] ]
+
+ private Attribute[][string][string] _attributes; // attributes[namespace or "*"][name][i]
+ private Tag[][string][string] _tags; // tags[namespace or "*"][name][i]
+
+ /// Adds a Value, Attribute, Tag (or array of such) as a member/child of this Tag.
+ /// Returns 'this' for chaining.
+ /// Throws 'SDLangValidationException' if trying to add an Attribute or Tag
+ /// that already has a parent.
+ Tag add(Value val)
+ {
+ values ~= val;
+ updateId++;
+ return this;
+ }
+
+ ///ditto
+ Tag add(Value[] vals)
+ {
+ foreach(val; vals)
+ add(val);
+
+ return this;
+ }
+
+ ///ditto
+ Tag add(Attribute attr)
+ {
+ if(attr._parent)
+ {
+ throw new SDLangValidationException(
+ "Attribute is already attached to a parent tag. "~
+ "Use Attribute.remove() before adding it to another tag."
+ );
+ }
+
+ if(!allNamespaces.canFind(attr._namespace))
+ allNamespaces ~= attr._namespace;
+
+ attr._parent = this;
+
+ allAttributes ~= attr;
+ attributeIndicies[attr._namespace] ~= allAttributes.length-1;
+ _attributes[attr._namespace][attr._name] ~= attr;
+ _attributes["*"] [attr._name] ~= attr;
+
+ updateId++;
+ return this;
+ }
+
+ ///ditto
+ Tag add(Attribute[] attrs)
+ {
+ foreach(attr; attrs)
+ add(attr);
+
+ return this;
+ }
+
+ ///ditto
+ Tag add(Tag tag)
+ {
+ if(tag._parent)
+ {
+ throw new SDLangValidationException(
+ "Tag is already attached to a parent tag. "~
+ "Use Tag.remove() before adding it to another tag."
+ );
+ }
+
+ if(!allNamespaces.canFind(tag._namespace))
+ allNamespaces ~= tag._namespace;
+
+ tag._parent = this;
+
+ allTags ~= tag;
+ tagIndicies[tag._namespace] ~= allTags.length-1;
+ _tags[tag._namespace][tag._name] ~= tag;
+ _tags["*"] [tag._name] ~= tag;
+
+ updateId++;
+ return this;
+ }
+
+ ///ditto
+ Tag add(Tag[] tags)
+ {
+ foreach(tag; tags)
+ add(tag);
+
+ return this;
+ }
+
+ /// Removes 'this' from its parent, if any. Returns 'this' for chaining.
+ /// Inefficient ATM, but it works.
+ Tag remove()
+ {
+ if(!_parent)
+ return this;
+
+ void removeFromGroupedLookup(string ns)
+ {
+ // Remove from _parent._tags[ns]
+ auto sameNameTags = _parent._tags[ns][_name];
+ auto targetIndex = sameNameTags.countUntil(this);
+ _parent._tags[ns][_name].removeIndex(targetIndex);
+ }
+
+ // Remove from _parent._tags
+ removeFromGroupedLookup(_namespace);
+ removeFromGroupedLookup("*");
+
+ // Remove from _parent.allTags
+ auto allTagsIndex = _parent.allTags.countUntil(this);
+ _parent.allTags.removeIndex(allTagsIndex);
+
+ // Remove from _parent.tagIndicies
+ auto sameNamespaceTags = _parent.tagIndicies[_namespace];
+ auto tagIndiciesIndex = sameNamespaceTags.countUntil(allTagsIndex);
+ _parent.tagIndicies[_namespace].removeIndex(tagIndiciesIndex);
+
+ // Fixup other indicies
+ foreach(ns, ref nsTagIndicies; _parent.tagIndicies)
+ foreach(k, ref v; nsTagIndicies)
+ if(v > allTagsIndex)
+ v--;
+
+ _parent.removeNamespaceIfEmpty(_namespace);
+ _parent.updateId++;
+ _parent = null;
+ return this;
+ }
+
+ private void removeNamespaceIfEmpty(string namespace)
+ {
+ // If namespace has no attributes, remove it from attributeIndicies/_attributes
+ if(namespace in attributeIndicies && attributeIndicies[namespace].length == 0)
+ {
+ attributeIndicies.remove(namespace);
+ _attributes.remove(namespace);
+ }
+
+ // If namespace has no tags, remove it from tagIndicies/_tags
+ if(namespace in tagIndicies && tagIndicies[namespace].length == 0)
+ {
+ tagIndicies.remove(namespace);
+ _tags.remove(namespace);
+ }
+
+ // If namespace is now empty, remove it from allNamespaces
+ if(
+ namespace !in tagIndicies &&
+ namespace !in attributeIndicies
+ )
+ {
+ auto allNamespacesIndex = allNamespaces.length - allNamespaces.find(namespace).length;
+ allNamespaces = allNamespaces[0..allNamespacesIndex] ~ allNamespaces[allNamespacesIndex+1..$];
+ }
+ }
+
+ struct NamedMemberRange(T, string membersGrouped)
+ {
+ private Tag tag;
+ private string namespace; // "*" indicates "all namespaces" (ok since it's not a valid namespace name)
+ private string name;
+ private size_t updateId; // Tag's updateId when this range was created.
+
+ this(Tag tag, string namespace, string name, size_t updateId)
+ {
+ this.tag = tag;
+ this.namespace = namespace;
+ this.name = name;
+ this.updateId = updateId;
+ frontIndex = 0;
+
+ if(
+ namespace in mixin("tag."~membersGrouped) &&
+ name in mixin("tag."~membersGrouped~"[namespace]")
+ )
+ endIndex = mixin("tag."~membersGrouped~"[namespace][name].length");
+ else
+ endIndex = 0;
+ }
+
+ invariant()
+ {
+ assert(
+ this.updateId == tag.updateId,
+ "This range has been invalidated by a change to the tag."
+ );
+ }
+
+ @property bool empty()
+ {
+ return frontIndex == endIndex;
+ }
+
+ private size_t frontIndex;
+ @property T front()
+ {
+ return this[0];
+ }
+ void popFront()
+ {
+ if(empty)
+ throw new SDLangRangeException("Range is empty");
+
+ frontIndex++;
+ }
+
+ private size_t endIndex; // One past the last element
+ @property T back()
+ {
+ return this[$-1];
+ }
+ void popBack()
+ {
+ if(empty)
+ throw new SDLangRangeException("Range is empty");
+
+ endIndex--;
+ }
+
+ alias length opDollar;
+ @property size_t length()
+ {
+ return endIndex - frontIndex;
+ }
+
+ @property typeof(this) save()
+ {
+ auto r = typeof(this)(this.tag, this.namespace, this.name, this.updateId);
+ r.frontIndex = this.frontIndex;
+ r.endIndex = this.endIndex;
+ return r;
+ }
+
+ typeof(this) opSlice()
+ {
+ return save();
+ }
+
+ typeof(this) opSlice(size_t start, size_t end)
+ {
+ auto r = save();
+ r.frontIndex = this.frontIndex + start;
+ r.endIndex = this.frontIndex + end;
+
+ if(
+ r.frontIndex > this.endIndex ||
+ r.endIndex > this.endIndex ||
+ r.frontIndex > r.endIndex
+ )
+ throw new SDLangRangeException("Slice out of range");
+
+ return r;
+ }
+
+ T opIndex(size_t index)
+ {
+ if(empty)
+ throw new SDLangRangeException("Range is empty");
+
+ return mixin("tag."~membersGrouped~"[namespace][name][frontIndex+index]");
+ }
+ }
+
+ struct MemberRange(T, string allMembers, string memberIndicies, string membersGrouped)
+ {
+ private Tag tag;
+ private string namespace; // "*" indicates "all namespaces" (ok since it's not a valid namespace name)
+ private bool isMaybe;
+ private size_t updateId; // Tag's updateId when this range was created.
+ private size_t initialEndIndex;
+
+ this(Tag tag, string namespace, bool isMaybe)
+ {
+ this.tag = tag;
+ this.namespace = namespace;
+ this.updateId = tag.updateId;
+ this.isMaybe = isMaybe;
+ frontIndex = 0;
+
+ if(namespace == "*")
+ initialEndIndex = mixin("tag."~allMembers~".length");
+ else if(namespace in mixin("tag."~memberIndicies))
+ initialEndIndex = mixin("tag."~memberIndicies~"[namespace].length");
+ else
+ initialEndIndex = 0;
+
+ endIndex = initialEndIndex;
+ }
+
+ invariant()
+ {
+ assert(
+ this.updateId == tag.updateId,
+ "This range has been invalidated by a change to the tag."
+ );
+ }
+
+ @property bool empty()
+ {
+ return frontIndex == endIndex;
+ }
+
+ private size_t frontIndex;
+ @property T front()
+ {
+ return this[0];
+ }
+ void popFront()
+ {
+ if(empty)
+ throw new SDLangRangeException("Range is empty");
+
+ frontIndex++;
+ }
+
+ private size_t endIndex; // One past the last element
+ @property T back()
+ {
+ return this[$-1];
+ }
+ void popBack()
+ {
+ if(empty)
+ throw new SDLangRangeException("Range is empty");
+
+ endIndex--;
+ }
+
+ alias length opDollar;
+ @property size_t length()
+ {
+ return endIndex - frontIndex;
+ }
+
+ @property typeof(this) save()
+ {
+ auto r = typeof(this)(this.tag, this.namespace, this.isMaybe);
+ r.frontIndex = this.frontIndex;
+ r.endIndex = this.endIndex;
+ r.initialEndIndex = this.initialEndIndex;
+ r.updateId = this.updateId;
+ return r;
+ }
+
+ typeof(this) opSlice()
+ {
+ return save();
+ }
+
+ typeof(this) opSlice(size_t start, size_t end)
+ {
+ auto r = save();
+ r.frontIndex = this.frontIndex + start;
+ r.endIndex = this.frontIndex + end;
+
+ if(
+ r.frontIndex > this.endIndex ||
+ r.endIndex > this.endIndex ||
+ r.frontIndex > r.endIndex
+ )
+ throw new SDLangRangeException("Slice out of range");
+
+ return r;
+ }
+
+ T opIndex(size_t index)
+ {
+ if(empty)
+ throw new SDLangRangeException("Range is empty");
+
+ if(namespace == "*")
+ return mixin("tag."~allMembers~"[ frontIndex+index ]");
+ else
+ return mixin("tag."~allMembers~"[ tag."~memberIndicies~"[namespace][frontIndex+index] ]");
+ }
+
+ alias NamedMemberRange!(T,membersGrouped) ThisNamedMemberRange;
+ ThisNamedMemberRange opIndex(string name)
+ {
+ if(frontIndex != 0 || endIndex != initialEndIndex)
+ {
+ throw new SDLangRangeException(
+ "Cannot lookup tags/attributes by name on a subset of a range, "~
+ "only across the entire tag. "~
+ "Please make sure you haven't called popFront or popBack on this "~
+ "range and that you aren't using a slice of the range."
+ );
+ }
+
+ if(!isMaybe && empty)
+ throw new SDLangRangeException("Range is empty");
+
+ if(!isMaybe && name !in this)
+ throw new SDLangRangeException(`No such `~T.stringof~` named: "`~name~`"`);
+
+ return ThisNamedMemberRange(tag, namespace, name, updateId);
+ }
+
+ bool opBinaryRight(string op)(string name) if(op=="in")
+ {
+ if(frontIndex != 0 || endIndex != initialEndIndex)
+ {
+ throw new SDLangRangeException(
+ "Cannot lookup tags/attributes by name on a subset of a range, "~
+ "only across the entire tag. "~
+ "Please make sure you haven't called popFront or popBack on this "~
+ "range and that you aren't using a slice of the range."
+ );
+ }
+
+ return
+ namespace in mixin("tag."~membersGrouped) &&
+ name in mixin("tag."~membersGrouped~"[namespace]") &&
+ mixin("tag."~membersGrouped~"[namespace][name].length") > 0;
+ }
+ }
+
+ struct NamespaceRange
+ {
+ private Tag tag;
+ private bool isMaybe;
+ private size_t updateId; // Tag's updateId when this range was created.
+
+ this(Tag tag, bool isMaybe)
+ {
+ this.tag = tag;
+ this.isMaybe = isMaybe;
+ this.updateId = tag.updateId;
+ frontIndex = 0;
+ endIndex = tag.allNamespaces.length;
+ }
+
+ invariant()
+ {
+ assert(
+ this.updateId == tag.updateId,
+ "This range has been invalidated by a change to the tag."
+ );
+ }
+
+ @property bool empty()
+ {
+ return frontIndex == endIndex;
+ }
+
+ private size_t frontIndex;
+ @property NamespaceAccess front()
+ {
+ return this[0];
+ }
+ void popFront()
+ {
+ if(empty)
+ throw new SDLangRangeException("Range is empty");
+
+ frontIndex++;
+ }
+
+ private size_t endIndex; // One past the last element
+ @property NamespaceAccess back()
+ {
+ return this[$-1];
+ }
+ void popBack()
+ {
+ if(empty)
+ throw new SDLangRangeException("Range is empty");
+
+ endIndex--;
+ }
+
+ alias length opDollar;
+ @property size_t length()
+ {
+ return endIndex - frontIndex;
+ }
+
+ @property NamespaceRange save()
+ {
+ auto r = NamespaceRange(this.tag, this.isMaybe);
+ r.frontIndex = this.frontIndex;
+ r.endIndex = this.endIndex;
+ r.updateId = this.updateId;
+ return r;
+ }
+
+ typeof(this) opSlice()
+ {
+ return save();
+ }
+
+ typeof(this) opSlice(size_t start, size_t end)
+ {
+ auto r = save();
+ r.frontIndex = this.frontIndex + start;
+ r.endIndex = this.frontIndex + end;
+
+ if(
+ r.frontIndex > this.endIndex ||
+ r.endIndex > this.endIndex ||
+ r.frontIndex > r.endIndex
+ )
+ throw new SDLangRangeException("Slice out of range");
+
+ return r;
+ }
+
+ NamespaceAccess opIndex(size_t index)
+ {
+ if(empty)
+ throw new SDLangRangeException("Range is empty");
+
+ auto namespace = tag.allNamespaces[frontIndex+index];
+ return NamespaceAccess(
+ namespace,
+ AttributeRange(tag, namespace, isMaybe),
+ TagRange(tag, namespace, isMaybe)
+ );
+ }
+
+ NamespaceAccess opIndex(string namespace)
+ {
+ if(!isMaybe && empty)
+ throw new SDLangRangeException("Range is empty");
+
+ if(!isMaybe && namespace !in this)
+ throw new SDLangRangeException(`No such namespace: "`~namespace~`"`);
+
+ return NamespaceAccess(
+ namespace,
+ AttributeRange(tag, namespace, isMaybe),
+ TagRange(tag, namespace, isMaybe)
+ );
+ }
+
+ /// Inefficient when range is a slice or has used popFront/popBack, but it works.
+ bool opBinaryRight(string op)(string namespace) if(op=="in")
+ {
+ if(frontIndex == 0 && endIndex == tag.allNamespaces.length)
+ {
+ return
+ namespace in tag.attributeIndicies ||
+ namespace in tag.tagIndicies;
+ }
+ else
+ // Slower fallback method
+ return tag.allNamespaces[frontIndex..endIndex].canFind(namespace);
+ }
+ }
+
+ struct NamespaceAccess
+ {
+ string name;
+ AttributeRange attributes;
+ TagRange tags;
+ }
+
+ alias MemberRange!(Attribute, "allAttributes", "attributeIndicies", "_attributes") AttributeRange;
+ alias MemberRange!(Tag, "allTags", "tagIndicies", "_tags" ) TagRange;
+ static assert(isRandomAccessRange!AttributeRange);
+ static assert(isRandomAccessRange!TagRange);
+ static assert(isRandomAccessRange!NamespaceRange);
+
+ /// Access all attributes that don't have a namespace
+ @property AttributeRange attributes()
+ {
+ return AttributeRange(this, "", false);
+ }
+
+ /// Access all direct-child tags that don't have a namespace
+ @property TagRange tags()
+ {
+ return TagRange(this, "", false);
+ }
+
+ /// Access all namespaces in this tag, and the attributes/tags within them.
+ @property NamespaceRange namespaces()
+ {
+ return NamespaceRange(this, false);
+ }
+
+ /// Access all attributes and tags regardless of namespace.
+ @property NamespaceAccess all()
+ {
+ // "*" isn't a valid namespace name, so we can use it to indicate "all namespaces"
+ return NamespaceAccess(
+ "*",
+ AttributeRange(this, "*", false),
+ TagRange(this, "*", false)
+ );
+ }
+
+ struct MaybeAccess
+ {
+ Tag tag;
+
+ /// Access all attributes that don't have a namespace
+ @property AttributeRange attributes()
+ {
+ return AttributeRange(tag, "", true);
+ }
+
+ /// Access all direct-child tags that don't have a namespace
+ @property TagRange tags()
+ {
+ return TagRange(tag, "", true);
+ }
+
+ /// Access all namespaces in this tag, and the attributes/tags within them.
+ @property NamespaceRange namespaces()
+ {
+ return NamespaceRange(tag, true);
+ }
+
+ /// Access all attributes and tags regardless of namespace.
+ @property NamespaceAccess all()
+ {
+ // "*" isn't a valid namespace name, so we can use it to indicate "all namespaces"
+ return NamespaceAccess(
+ "*",
+ AttributeRange(tag, "*", true),
+ TagRange(tag, "*", true)
+ );
+ }
+ }
+
+ /// Access 'attributes', 'tags', 'namespaces' and 'all' like normal,
+ /// except that looking up a non-existant name/namespace with
+ /// opIndex(string) results in an empty array instead of a thrown SDLangRangeException.
+ @property MaybeAccess maybe()
+ {
+ return MaybeAccess(this);
+ }
+
+ override bool opEquals(Object o)
+ {
+ auto t = cast(Tag)o;
+ if(!t)
+ return false;
+
+ if(_namespace != t._namespace || _name != t._name)
+ return false;
+
+ if(
+ values .length != t.values .length ||
+ allAttributes .length != t.allAttributes.length ||
+ allNamespaces .length != t.allNamespaces.length ||
+ allTags .length != t.allTags .length
+ )
+ return false;
+
+ if(values != t.values)
+ return false;
+
+ if(allNamespaces != t.allNamespaces)
+ return false;
+
+ if(allAttributes != t.allAttributes)
+ return false;
+
+ // Ok because cycles are not allowed
+ //TODO: Actually check for or prevent cycles.
+ return allTags == t.allTags;
+ }
+
+ /// Treats 'this' as the root tag. Note that root tags cannot have
+ /// values or attributes, and cannot be part of a namespace.
+ /// If this isn't a valid root tag, 'SDLangValidationException' will be thrown.
+ string toSDLDocument()(string indent="\t", int indentLevel=0)
+ {
+ Appender!string sink;
+ toSDLDocument(sink, indent, indentLevel);
+ return sink.data;
+ }
+
+ ///ditto
+ void toSDLDocument(Sink)(ref Sink sink, string indent="\t", int indentLevel=0)
+ if(isOutputRange!(Sink,char))
+ {
+ if(values.length > 0)
+ throw new SDLangValidationException("Root tags cannot have any values, only child tags.");
+
+ if(allAttributes.length > 0)
+ throw new SDLangValidationException("Root tags cannot have any attributes, only child tags.");
+
+ if(_namespace != "")
+ throw new SDLangValidationException("Root tags cannot have a namespace.");
+
+ foreach(tag; allTags)
+ tag.toSDLString(sink, indent, indentLevel);
+ }
+
+ /// Output this entire tag in SDL format. Does *not* treat 'this' as
+ /// a root tag. If you intend this to be the root of a standard SDL
+ /// document, use 'toSDLDocument' instead.
+ string toSDLString()(string indent="\t", int indentLevel=0)
+ {
+ Appender!string sink;
+ toSDLString(sink, indent, indentLevel);
+ return sink.data;
+ }
+
+ ///ditto
+ void toSDLString(Sink)(ref Sink sink, string indent="\t", int indentLevel=0)
+ if(isOutputRange!(Sink,char))
+ {
+ if(_name == "" && values.length == 0)
+ throw new SDLangValidationException("Anonymous tags must have at least one value.");
+
+ if(_name == "" && _namespace != "")
+ throw new SDLangValidationException("Anonymous tags cannot have a namespace.");
+
+ // Indent
+ foreach(i; 0..indentLevel)
+ sink.put(indent);
+
+ // Name
+ if(_namespace != "")
+ {
+ sink.put(_namespace);
+ sink.put(':');
+ }
+ sink.put(_name);
+
+ // Values
+ foreach(i, v; values)
+ {
+ // Omit the first space for anonymous tags
+ if(_name != "" || i > 0)
+ sink.put(' ');
+
+ v.toSDLString(sink);
+ }
+
+ // Attributes
+ foreach(attr; allAttributes)
+ {
+ sink.put(' ');
+ attr.toSDLString(sink);
+ }
+
+ // Child tags
+ bool foundChild=false;
+ foreach(tag; allTags)
+ {
+ if(!foundChild)
+ {
+ sink.put(" {\n");
+ foundChild = true;
+ }
+
+ tag.toSDLString(sink, indent, indentLevel+1);
+ }
+ if(foundChild)
+ {
+ foreach(i; 0..indentLevel)
+ sink.put(indent);
+
+ sink.put("}\n");
+ }
+ else
+ sink.put("\n");
+ }
+
+ /// Not the most efficient, but it works.
+ string toDebugString()
+ {
+ import std.algorithm : sort;
+
+ Appender!string buf;
+
+ buf.put("\n");
+ buf.put("Tag ");
+ if(_namespace != "")
+ {
+ buf.put("[");
+ buf.put(_namespace);
+ buf.put("]");
+ }
+ buf.put("'%s':\n".format(_name));
+
+ // Values
+ foreach(val; values)
+ buf.put(" (%s): %s\n".format(.toString(val.type), val));
+
+ // Attributes
+ foreach(attrNamespace; _attributes.keys.sort())
+ if(attrNamespace != "*")
+ foreach(attrName; _attributes[attrNamespace].keys.sort())
+ foreach(attr; _attributes[attrNamespace][attrName])
+ {
+ string namespaceStr;
+ if(attr._namespace != "")
+ namespaceStr = "["~attr._namespace~"]";
+
+ buf.put(
+ " %s%s(%s): %s\n".format(
+ namespaceStr, attr._name, .toString(attr.value.type), attr.value
+ )
+ );
+ }
+
+ // Children
+ foreach(tagNamespace; _tags.keys.sort())
+ if(tagNamespace != "*")
+ foreach(tagName; _tags[tagNamespace].keys.sort())
+ foreach(tag; _tags[tagNamespace][tagName])
+ buf.put( tag.toDebugString().replace("\n", "\n ") );
+
+ return buf.data;
+ }
+}
+
+version(sdlangUnittest)
+{
+ private void testRandomAccessRange(R, E)(R range, E[] expected, bool function(E, E) equals=null)
+ {
+ static assert(isRandomAccessRange!R);
+ static assert(is(ElementType!R == E));
+ static assert(hasLength!R);
+ static assert(!isInfinite!R);
+
+ assert(range.length == expected.length);
+ if(range.length == 0)
+ {
+ assert(range.empty);
+ return;
+ }
+
+ static bool defaultEquals(E e1, E e2)
+ {
+ return e1 == e2;
+ }
+ if(equals is null)
+ equals = &defaultEquals;
+
+ assert(equals(range.front, expected[0]));
+ assert(equals(range.front, expected[0])); // Ensure consistent result from '.front'
+ assert(equals(range.front, expected[0])); // Ensure consistent result from '.front'
+
+ assert(equals(range.back, expected[$-1]));
+ assert(equals(range.back, expected[$-1])); // Ensure consistent result from '.back'
+ assert(equals(range.back, expected[$-1])); // Ensure consistent result from '.back'
+
+ // Forward iteration
+ auto original = range.save;
+ auto r2 = range.save;
+ foreach(i; 0..expected.length)
+ {
+ //trace("Forward iteration: ", i);
+
+ // Test length/empty
+ assert(range.length == expected.length - i);
+ assert(range.length == r2.length);
+ assert(!range.empty);
+ assert(!r2.empty);
+
+ // Test front
+ assert(equals(range.front, expected[i]));
+ assert(equals(range.front, r2.front));
+
+ // Test back
+ assert(equals(range.back, expected[$-1]));
+ assert(equals(range.back, r2.back));
+
+ // Test opIndex(0)
+ assert(equals(range[0], expected[i]));
+ assert(equals(range[0], r2[0]));
+
+ // Test opIndex($-1)
+ assert(equals(range[$-1], expected[$-1]));
+ assert(equals(range[$-1], r2[$-1]));
+
+ // Test popFront
+ range.popFront();
+ assert(range.length == r2.length - 1);
+ r2.popFront();
+ assert(range.length == r2.length);
+ }
+ assert(range.empty);
+ assert(r2.empty);
+ assert(original.length == expected.length);
+
+ // Backwards iteration
+ range = original.save;
+ r2 = original.save;
+ foreach(i; iota(0, expected.length).retro())
+ {
+ //trace("Backwards iteration: ", i);
+
+ // Test length/empty
+ assert(range.length == i+1);
+ assert(range.length == r2.length);
+ assert(!range.empty);
+ assert(!r2.empty);
+
+ // Test front
+ assert(equals(range.front, expected[0]));
+ assert(equals(range.front, r2.front));
+
+ // Test back
+ assert(equals(range.back, expected[i]));
+ assert(equals(range.back, r2.back));
+
+ // Test opIndex(0)
+ assert(equals(range[0], expected[0]));
+ assert(equals(range[0], r2[0]));
+
+ // Test opIndex($-1)
+ assert(equals(range[$-1], expected[i]));
+ assert(equals(range[$-1], r2[$-1]));
+
+ // Test popBack
+ range.popBack();
+ assert(range.length == r2.length - 1);
+ r2.popBack();
+ assert(range.length == r2.length);
+ }
+ assert(range.empty);
+ assert(r2.empty);
+ assert(original.length == expected.length);
+
+ // Random access
+ range = original.save;
+ r2 = original.save;
+ foreach(i; 0..expected.length)
+ {
+ //trace("Random access: ", i);
+
+ // Test length/empty
+ assert(range.length == expected.length);
+ assert(range.length == r2.length);
+ assert(!range.empty);
+ assert(!r2.empty);
+
+ // Test front
+ assert(equals(range.front, expected[0]));
+ assert(equals(range.front, r2.front));
+
+ // Test back
+ assert(equals(range.back, expected[$-1]));
+ assert(equals(range.back, r2.back));
+
+ // Test opIndex(i)
+ assert(equals(range[i], expected[i]));
+ assert(equals(range[i], r2[i]));
+ }
+ assert(!range.empty);
+ assert(!r2.empty);
+ assert(original.length == expected.length);
+ }
+}
+
+version(sdlangUnittest)
+unittest
+{
+ import sdlang.parser;
+ writeln("Unittesting sdlang ast...");
+ stdout.flush();
+
+ Tag root;
+ root = parseSource("");
+ testRandomAccessRange(root.attributes, cast( Attribute[])[]);
+ testRandomAccessRange(root.tags, cast( Tag[])[]);
+ testRandomAccessRange(root.namespaces, cast(Tag.NamespaceAccess[])[]);
+
+ root = parseSource(`
+ blue 3 "Lee" isThree=true
+ blue 5 "Chan" 12345 isThree=false
+ stuff:orange 1 2 3 2 1
+ stuff:square points=4 dimensions=2 points="Still four"
+ stuff:triangle data:points=3 data:dimensions=2
+ nothing
+ namespaces small:A=1 med:A=2 big:A=3 small:B=10 big:B=30
+
+ people visitor:a=1 b=2 {
+ chiyo "Small" "Flies?" nemesis="Car" score=100
+ yukari
+ visitor:sana
+ tomo
+ visitor:hayama
+ }
+ `);
+
+ auto blue3 = new Tag(
+ null, "", "blue",
+ [ Value(3), Value("Lee") ],
+ [ new Attribute("isThree", Value(true)) ],
+ null
+ );
+ auto blue5 = new Tag(
+ null, "", "blue",
+ [ Value(5), Value("Chan"), Value(12345) ],
+ [ new Attribute("isThree", Value(false)) ],
+ null
+ );
+ auto orange = new Tag(
+ null, "stuff", "orange",
+ [ Value(1), Value(2), Value(3), Value(2), Value(1) ],
+ null,
+ null
+ );
+ auto square = new Tag(
+ null, "stuff", "square",
+ null,
+ [
+ new Attribute("points", Value(4)),
+ new Attribute("dimensions", Value(2)),
+ new Attribute("points", Value("Still four")),
+ ],
+ null
+ );
+ auto triangle = new Tag(
+ null, "stuff", "triangle",
+ null,
+ [
+ new Attribute("data", "points", Value(3)),
+ new Attribute("data", "dimensions", Value(2)),
+ ],
+ null
+ );
+ auto nothing = new Tag(
+ null, "", "nothing",
+ null, null, null
+ );
+ auto namespaces = new Tag(
+ null, "", "namespaces",
+ null,
+ [
+ new Attribute("small", "A", Value(1)),
+ new Attribute("med", "A", Value(2)),
+ new Attribute("big", "A", Value(3)),
+ new Attribute("small", "B", Value(10)),
+ new Attribute("big", "B", Value(30)),
+ ],
+ null
+ );
+ auto chiyo = new Tag(
+ null, "", "chiyo",
+ [ Value("Small"), Value("Flies?") ],
+ [
+ new Attribute("nemesis", Value("Car")),
+ new Attribute("score", Value(100)),
+ ],
+ null
+ );
+ auto chiyo_ = new Tag(
+ null, "", "chiyo_",
+ [ Value("Small"), Value("Flies?") ],
+ [
+ new Attribute("nemesis", Value("Car")),
+ new Attribute("score", Value(100)),
+ ],
+ null
+ );
+ auto yukari = new Tag(
+ null, "", "yukari",
+ null, null, null
+ );
+ auto sana = new Tag(
+ null, "visitor", "sana",
+ null, null, null
+ );
+ auto sana_ = new Tag(
+ null, "visitor", "sana_",
+ null, null, null
+ );
+ auto sanaVisitor_ = new Tag(
+ null, "visitor_", "sana_",
+ null, null, null
+ );
+ auto tomo = new Tag(
+ null, "", "tomo",
+ null, null, null
+ );
+ auto hayama = new Tag(
+ null, "visitor", "hayama",
+ null, null, null
+ );
+ auto people = new Tag(
+ null, "", "people",
+ null,
+ [
+ new Attribute("visitor", "a", Value(1)),
+ new Attribute("b", Value(2)),
+ ],
+ [chiyo, yukari, sana, tomo, hayama]
+ );
+
+ assert(blue3 .opEquals( blue3 ));
+ assert(blue5 .opEquals( blue5 ));
+ assert(orange .opEquals( orange ));
+ assert(square .opEquals( square ));
+ assert(triangle .opEquals( triangle ));
+ assert(nothing .opEquals( nothing ));
+ assert(namespaces .opEquals( namespaces ));
+ assert(people .opEquals( people ));
+ assert(chiyo .opEquals( chiyo ));
+ assert(yukari .opEquals( yukari ));
+ assert(sana .opEquals( sana ));
+ assert(tomo .opEquals( tomo ));
+ assert(hayama .opEquals( hayama ));
+
+ assert(!blue3.opEquals(orange));
+ assert(!blue3.opEquals(people));
+ assert(!blue3.opEquals(sana));
+ assert(!blue3.opEquals(blue5));
+ assert(!blue5.opEquals(blue3));
+
+ alias Tag.NamespaceAccess NSA;
+ static bool namespaceEquals(NSA n1, NSA n2)
+ {
+ return n1.name == n2.name;
+ }
+
+ testRandomAccessRange(root.attributes, cast(Attribute[])[]);
+ testRandomAccessRange(root.tags, [blue3, blue5, nothing, namespaces, people]);
+ testRandomAccessRange(root.namespaces, [NSA(""), NSA("stuff")], &namespaceEquals);
+ testRandomAccessRange(root.namespaces[0].tags, [blue3, blue5, nothing, namespaces, people]);
+ testRandomAccessRange(root.namespaces[1].tags, [orange, square, triangle]);
+ assert("" in root.namespaces);
+ assert("stuff" in root.namespaces);
+ assert("foobar" !in root.namespaces);
+ testRandomAccessRange(root.namespaces[ ""].tags, [blue3, blue5, nothing, namespaces, people]);
+ testRandomAccessRange(root.namespaces["stuff"].tags, [orange, square, triangle]);
+ testRandomAccessRange(root.all.attributes, cast(Attribute[])[]);
+ testRandomAccessRange(root.all.tags, [blue3, blue5, orange, square, triangle, nothing, namespaces, people]);
+ testRandomAccessRange(root.all.tags[], [blue3, blue5, orange, square, triangle, nothing, namespaces, people]);
+ testRandomAccessRange(root.all.tags[3..6], [square, triangle, nothing]);
+ assert("blue" in root.tags);
+ assert("nothing" in root.tags);
+ assert("people" in root.tags);
+ assert("orange" !in root.tags);
+ assert("square" !in root.tags);
+ assert("foobar" !in root.tags);
+ assert("blue" in root.all.tags);
+ assert("nothing" in root.all.tags);
+ assert("people" in root.all.tags);
+ assert("orange" in root.all.tags);
+ assert("square" in root.all.tags);
+ assert("foobar" !in root.all.tags);
+ assert("orange" in root.namespaces["stuff"].tags);
+ assert("square" in root.namespaces["stuff"].tags);
+ assert("square" in root.namespaces["stuff"].tags);
+ assert("foobar" !in root.attributes);
+ assert("foobar" !in root.all.attributes);
+ assert("foobar" !in root.namespaces["stuff"].attributes);
+ assert("blue" !in root.attributes);
+ assert("blue" !in root.all.attributes);
+ assert("blue" !in root.namespaces["stuff"].attributes);
+ testRandomAccessRange(root.tags["nothing"], [nothing]);
+ testRandomAccessRange(root.tags["blue"], [blue3, blue5]);
+ testRandomAccessRange(root.namespaces["stuff"].tags["orange"], [orange]);
+ testRandomAccessRange(root.all.tags["nothing"], [nothing]);
+ testRandomAccessRange(root.all.tags["blue"], [blue3, blue5]);
+ testRandomAccessRange(root.all.tags["orange"], [orange]);
+
+ assertThrown!SDLangRangeException(root.tags["foobar"]);
+ assertThrown!SDLangRangeException(root.all.tags["foobar"]);
+ assertThrown!SDLangRangeException(root.attributes["foobar"]);
+ assertThrown!SDLangRangeException(root.all.attributes["foobar"]);
+
+ // DMD Issue #12585 causes a segfault in these two tests when using 2.064 or 2.065,
+ // so work around it.
+ //assertThrown!SDLangRangeException(root.namespaces["foobar"].tags["foobar"]);
+ //assertThrown!SDLangRangeException(root.namespaces["foobar"].attributes["foobar"]);
+ bool didCatch = false;
+ try
+ auto x = root.namespaces["foobar"].tags["foobar"];
+ catch(SDLangRangeException e)
+ didCatch = true;
+ assert(didCatch);
+
+ didCatch = false;
+ try
+ auto x = root.namespaces["foobar"].attributes["foobar"];
+ catch(SDLangRangeException e)
+ didCatch = true;
+ assert(didCatch);
+
+ testRandomAccessRange(root.maybe.tags["nothing"], [nothing]);
+ testRandomAccessRange(root.maybe.tags["blue"], [blue3, blue5]);
+ testRandomAccessRange(root.maybe.namespaces["stuff"].tags["orange"], [orange]);
+ testRandomAccessRange(root.maybe.all.tags["nothing"], [nothing]);
+ testRandomAccessRange(root.maybe.all.tags["blue"], [blue3, blue5]);
+ testRandomAccessRange(root.maybe.all.tags["blue"][], [blue3, blue5]);
+ testRandomAccessRange(root.maybe.all.tags["blue"][0..1], [blue3]);
+ testRandomAccessRange(root.maybe.all.tags["blue"][1..2], [blue5]);
+ testRandomAccessRange(root.maybe.all.tags["orange"], [orange]);
+ testRandomAccessRange(root.maybe.tags["foobar"], cast(Tag[])[]);
+ testRandomAccessRange(root.maybe.all.tags["foobar"], cast(Tag[])[]);
+ testRandomAccessRange(root.maybe.namespaces["foobar"].tags["foobar"], cast(Tag[])[]);
+ testRandomAccessRange(root.maybe.attributes["foobar"], cast(Attribute[])[]);
+ testRandomAccessRange(root.maybe.all.attributes["foobar"], cast(Attribute[])[]);
+ testRandomAccessRange(root.maybe.namespaces["foobar"].attributes["foobar"], cast(Attribute[])[]);
+
+ testRandomAccessRange(blue3.attributes, [ new Attribute("isThree", Value(true)) ]);
+ testRandomAccessRange(blue3.tags, cast(Tag[])[]);
+ testRandomAccessRange(blue3.namespaces, [NSA("")], &namespaceEquals);
+ testRandomAccessRange(blue3.all.attributes, [ new Attribute("isThree", Value(true)) ]);
+ testRandomAccessRange(blue3.all.tags, cast(Tag[])[]);
+
+ testRandomAccessRange(blue5.attributes, [ new Attribute("isThree", Value(false)) ]);
+ testRandomAccessRange(blue5.tags, cast(Tag[])[]);
+ testRandomAccessRange(blue5.namespaces, [NSA("")], &namespaceEquals);
+ testRandomAccessRange(blue5.all.attributes, [ new Attribute("isThree", Value(false)) ]);
+ testRandomAccessRange(blue5.all.tags, cast(Tag[])[]);
+
+ testRandomAccessRange(orange.attributes, cast(Attribute[])[]);
+ testRandomAccessRange(orange.tags, cast(Tag[])[]);
+ testRandomAccessRange(orange.namespaces, cast(NSA[])[], &namespaceEquals);
+ testRandomAccessRange(orange.all.attributes, cast(Attribute[])[]);
+ testRandomAccessRange(orange.all.tags, cast(Tag[])[]);
+
+ testRandomAccessRange(square.attributes, [
+ new Attribute("points", Value(4)),
+ new Attribute("dimensions", Value(2)),
+ new Attribute("points", Value("Still four")),
+ ]);
+ testRandomAccessRange(square.tags, cast(Tag[])[]);
+ testRandomAccessRange(square.namespaces, [NSA("")], &namespaceEquals);
+ testRandomAccessRange(square.all.attributes, [
+ new Attribute("points", Value(4)),
+ new Attribute("dimensions", Value(2)),
+ new Attribute("points", Value("Still four")),
+ ]);
+ testRandomAccessRange(square.all.tags, cast(Tag[])[]);
+
+ testRandomAccessRange(triangle.attributes, cast(Attribute[])[]);
+ testRandomAccessRange(triangle.tags, cast(Tag[])[]);
+ testRandomAccessRange(triangle.namespaces, [NSA("data")], &namespaceEquals);
+ testRandomAccessRange(triangle.namespaces[0].attributes, [
+ new Attribute("data", "points", Value(3)),
+ new Attribute("data", "dimensions", Value(2)),
+ ]);
+ assert("data" in triangle.namespaces);
+ assert("foobar" !in triangle.namespaces);
+ testRandomAccessRange(triangle.namespaces["data"].attributes, [
+ new Attribute("data", "points", Value(3)),
+ new Attribute("data", "dimensions", Value(2)),
+ ]);
+ testRandomAccessRange(triangle.all.attributes, [
+ new Attribute("data", "points", Value(3)),
+ new Attribute("data", "dimensions", Value(2)),
+ ]);
+ testRandomAccessRange(triangle.all.tags, cast(Tag[])[]);
+
+ testRandomAccessRange(nothing.attributes, cast(Attribute[])[]);
+ testRandomAccessRange(nothing.tags, cast(Tag[])[]);
+ testRandomAccessRange(nothing.namespaces, cast(NSA[])[], &namespaceEquals);
+ testRandomAccessRange(nothing.all.attributes, cast(Attribute[])[]);
+ testRandomAccessRange(nothing.all.tags, cast(Tag[])[]);
+
+ testRandomAccessRange(namespaces.attributes, cast(Attribute[])[]);
+ testRandomAccessRange(namespaces.tags, cast(Tag[])[]);
+ testRandomAccessRange(namespaces.namespaces, [NSA("small"), NSA("med"), NSA("big")], &namespaceEquals);
+ testRandomAccessRange(namespaces.namespaces[], [NSA("small"), NSA("med"), NSA("big")], &namespaceEquals);
+ testRandomAccessRange(namespaces.namespaces[1..2], [NSA("med")], &namespaceEquals);
+ testRandomAccessRange(namespaces.namespaces[0].attributes, [
+ new Attribute("small", "A", Value(1)),
+ new Attribute("small", "B", Value(10)),
+ ]);
+ testRandomAccessRange(namespaces.namespaces[1].attributes, [
+ new Attribute("med", "A", Value(2)),
+ ]);
+ testRandomAccessRange(namespaces.namespaces[2].attributes, [
+ new Attribute("big", "A", Value(3)),
+ new Attribute("big", "B", Value(30)),
+ ]);
+ testRandomAccessRange(namespaces.namespaces[1..2][0].attributes, [
+ new Attribute("med", "A", Value(2)),
+ ]);
+ assert("small" in namespaces.namespaces);
+ assert("med" in namespaces.namespaces);
+ assert("big" in namespaces.namespaces);
+ assert("foobar" !in namespaces.namespaces);
+ assert("small" !in namespaces.namespaces[1..2]);
+ assert("med" in namespaces.namespaces[1..2]);
+ assert("big" !in namespaces.namespaces[1..2]);
+ assert("foobar" !in namespaces.namespaces[1..2]);
+ testRandomAccessRange(namespaces.namespaces["small"].attributes, [
+ new Attribute("small", "A", Value(1)),
+ new Attribute("small", "B", Value(10)),
+ ]);
+ testRandomAccessRange(namespaces.namespaces["med"].attributes, [
+ new Attribute("med", "A", Value(2)),
+ ]);
+ testRandomAccessRange(namespaces.namespaces["big"].attributes, [
+ new Attribute("big", "A", Value(3)),
+ new Attribute("big", "B", Value(30)),
+ ]);
+ testRandomAccessRange(namespaces.all.attributes, [
+ new Attribute("small", "A", Value(1)),
+ new Attribute("med", "A", Value(2)),
+ new Attribute("big", "A", Value(3)),
+ new Attribute("small", "B", Value(10)),
+ new Attribute("big", "B", Value(30)),
+ ]);
+ testRandomAccessRange(namespaces.all.attributes[], [
+ new Attribute("small", "A", Value(1)),
+ new Attribute("med", "A", Value(2)),
+ new Attribute("big", "A", Value(3)),
+ new Attribute("small", "B", Value(10)),
+ new Attribute("big", "B", Value(30)),
+ ]);
+ testRandomAccessRange(namespaces.all.attributes[2..4], [
+ new Attribute("big", "A", Value(3)),
+ new Attribute("small", "B", Value(10)),
+ ]);
+ testRandomAccessRange(namespaces.all.tags, cast(Tag[])[]);
+ assert("A" !in namespaces.attributes);
+ assert("B" !in namespaces.attributes);
+ assert("foobar" !in namespaces.attributes);
+ assert("A" in namespaces.all.attributes);
+ assert("B" in namespaces.all.attributes);
+ assert("foobar" !in namespaces.all.attributes);
+ assert("A" in namespaces.namespaces["small"].attributes);
+ assert("B" in namespaces.namespaces["small"].attributes);
+ assert("foobar" !in namespaces.namespaces["small"].attributes);
+ assert("A" in namespaces.namespaces["med"].attributes);
+ assert("B" !in namespaces.namespaces["med"].attributes);
+ assert("foobar" !in namespaces.namespaces["med"].attributes);
+ assert("A" in namespaces.namespaces["big"].attributes);
+ assert("B" in namespaces.namespaces["big"].attributes);
+ assert("foobar" !in namespaces.namespaces["big"].attributes);
+ assert("foobar" !in namespaces.tags);
+ assert("foobar" !in namespaces.all.tags);
+ assert("foobar" !in namespaces.namespaces["small"].tags);
+ assert("A" !in namespaces.tags);
+ assert("A" !in namespaces.all.tags);
+ assert("A" !in namespaces.namespaces["small"].tags);
+ testRandomAccessRange(namespaces.namespaces["small"].attributes["A"], [
+ new Attribute("small", "A", Value(1)),
+ ]);
+ testRandomAccessRange(namespaces.namespaces["med"].attributes["A"], [
+ new Attribute("med", "A", Value(2)),
+ ]);
+ testRandomAccessRange(namespaces.namespaces["big"].attributes["A"], [
+ new Attribute("big", "A", Value(3)),
+ ]);
+ testRandomAccessRange(namespaces.all.attributes["A"], [
+ new Attribute("small", "A", Value(1)),
+ new Attribute("med", "A", Value(2)),
+ new Attribute("big", "A", Value(3)),
+ ]);
+ testRandomAccessRange(namespaces.all.attributes["B"], [
+ new Attribute("small", "B", Value(10)),
+ new Attribute("big", "B", Value(30)),
+ ]);
+
+ testRandomAccessRange(chiyo.attributes, [
+ new Attribute("nemesis", Value("Car")),
+ new Attribute("score", Value(100)),
+ ]);
+ testRandomAccessRange(chiyo.tags, cast(Tag[])[]);
+ testRandomAccessRange(chiyo.namespaces, [NSA("")], &namespaceEquals);
+ testRandomAccessRange(chiyo.all.attributes, [
+ new Attribute("nemesis", Value("Car")),
+ new Attribute("score", Value(100)),
+ ]);
+ testRandomAccessRange(chiyo.all.tags, cast(Tag[])[]);
+
+ testRandomAccessRange(yukari.attributes, cast(Attribute[])[]);
+ testRandomAccessRange(yukari.tags, cast(Tag[])[]);
+ testRandomAccessRange(yukari.namespaces, cast(NSA[])[], &namespaceEquals);
+ testRandomAccessRange(yukari.all.attributes, cast(Attribute[])[]);
+ testRandomAccessRange(yukari.all.tags, cast(Tag[])[]);
+
+ testRandomAccessRange(sana.attributes, cast(Attribute[])[]);
+ testRandomAccessRange(sana.tags, cast(Tag[])[]);
+ testRandomAccessRange(sana.namespaces, cast(NSA[])[], &namespaceEquals);
+ testRandomAccessRange(sana.all.attributes, cast(Attribute[])[]);
+ testRandomAccessRange(sana.all.tags, cast(Tag[])[]);
+
+ testRandomAccessRange(people.attributes, [new Attribute("b", Value(2))]);
+ testRandomAccessRange(people.tags, [chiyo, yukari, tomo]);
+ testRandomAccessRange(people.namespaces, [NSA("visitor"), NSA("")], &namespaceEquals);
+ testRandomAccessRange(people.namespaces[0].attributes, [new Attribute("visitor", "a", Value(1))]);
+ testRandomAccessRange(people.namespaces[1].attributes, [new Attribute("b", Value(2))]);
+ testRandomAccessRange(people.namespaces[0].tags, [sana, hayama]);
+ testRandomAccessRange(people.namespaces[1].tags, [chiyo, yukari, tomo]);
+ assert("visitor" in people.namespaces);
+ assert("" in people.namespaces);
+ assert("foobar" !in people.namespaces);
+ testRandomAccessRange(people.namespaces["visitor"].attributes, [new Attribute("visitor", "a", Value(1))]);
+ testRandomAccessRange(people.namespaces[ ""].attributes, [new Attribute("b", Value(2))]);
+ testRandomAccessRange(people.namespaces["visitor"].tags, [sana, hayama]);
+ testRandomAccessRange(people.namespaces[ ""].tags, [chiyo, yukari, tomo]);
+ testRandomAccessRange(people.all.attributes, [
+ new Attribute("visitor", "a", Value(1)),
+ new Attribute("b", Value(2)),
+ ]);
+ testRandomAccessRange(people.all.tags, [chiyo, yukari, sana, tomo, hayama]);
+
+ people.attributes["b"][0].name = "b_";
+ people.namespaces["visitor"].attributes["a"][0].name = "a_";
+ people.tags["chiyo"][0].name = "chiyo_";
+ people.namespaces["visitor"].tags["sana"][0].name = "sana_";
+
+ assert("b_" in people.attributes);
+ assert("a_" in people.namespaces["visitor"].attributes);
+ assert("chiyo_" in people.tags);
+ assert("sana_" in people.namespaces["visitor"].tags);
+
+ assert(people.attributes["b_"][0] == new Attribute("b_", Value(2)));
+ assert(people.namespaces["visitor"].attributes["a_"][0] == new Attribute("visitor", "a_", Value(1)));
+ assert(people.tags["chiyo_"][0] == chiyo_);
+ assert(people.namespaces["visitor"].tags["sana_"][0] == sana_);
+
+ assert("b" !in people.attributes);
+ assert("a" !in people.namespaces["visitor"].attributes);
+ assert("chiyo" !in people.tags);
+ assert("sana" !in people.namespaces["visitor"].tags);
+
+ assert(people.maybe.attributes["b"].length == 0);
+ assert(people.maybe.namespaces["visitor"].attributes["a"].length == 0);
+ assert(people.maybe.tags["chiyo"].length == 0);
+ assert(people.maybe.namespaces["visitor"].tags["sana"].length == 0);
+
+ people.tags["tomo"][0].remove();
+ people.namespaces["visitor"].tags["hayama"][0].remove();
+ people.tags["chiyo_"][0].remove();
+ testRandomAccessRange(people.tags, [yukari]);
+ testRandomAccessRange(people.namespaces, [NSA("visitor"), NSA("")], &namespaceEquals);
+ testRandomAccessRange(people.namespaces[0].tags, [sana_]);
+ testRandomAccessRange(people.namespaces[1].tags, [yukari]);
+ assert("visitor" in people.namespaces);
+ assert("" in people.namespaces);
+ assert("foobar" !in people.namespaces);
+ testRandomAccessRange(people.namespaces["visitor"].tags, [sana_]);
+ testRandomAccessRange(people.namespaces[ ""].tags, [yukari]);
+ testRandomAccessRange(people.all.tags, [yukari, sana_]);
+
+ people.attributes["b_"][0].namespace = "_";
+ people.namespaces["visitor"].attributes["a_"][0].namespace = "visitor_";
+ assert("_" in people.namespaces);
+ assert("visitor_" in people.namespaces);
+ assert("" in people.namespaces);
+ assert("visitor" in people.namespaces);
+ people.namespaces["visitor"].tags["sana_"][0].namespace = "visitor_";
+ assert("_" in people.namespaces);
+ assert("visitor_" in people.namespaces);
+ assert("" in people.namespaces);
+ assert("visitor" !in people.namespaces);
+
+ assert(people.namespaces["_" ].attributes["b_"][0] == new Attribute("_", "b_", Value(2)));
+ assert(people.namespaces["visitor_"].attributes["a_"][0] == new Attribute("visitor_", "a_", Value(1)));
+ assert(people.namespaces["visitor_"].tags["sana_"][0] == sanaVisitor_);
+
+ people.tags["yukari"][0].remove();
+ people.namespaces["visitor_"].tags["sana_"][0].remove();
+ people.namespaces["visitor_"].attributes["a_"][0].namespace = "visitor";
+ people.namespaces["_"].attributes["b_"][0].namespace = "";
+ testRandomAccessRange(people.tags, cast(Tag[])[]);
+ testRandomAccessRange(people.namespaces, [NSA("visitor"), NSA("")], &namespaceEquals);
+ testRandomAccessRange(people.namespaces[0].tags, cast(Tag[])[]);
+ testRandomAccessRange(people.namespaces[1].tags, cast(Tag[])[]);
+ assert("visitor" in people.namespaces);
+ assert("" in people.namespaces);
+ assert("foobar" !in people.namespaces);
+ testRandomAccessRange(people.namespaces["visitor"].tags, cast(Tag[])[]);
+ testRandomAccessRange(people.namespaces[ ""].tags, cast(Tag[])[]);
+ testRandomAccessRange(people.all.tags, cast(Tag[])[]);
+
+ people.namespaces["visitor"].attributes["a_"][0].remove();
+ testRandomAccessRange(people.attributes, [new Attribute("b_", Value(2))]);
+ testRandomAccessRange(people.namespaces, [NSA("")], &namespaceEquals);
+ testRandomAccessRange(people.namespaces[0].attributes, [new Attribute("b_", Value(2))]);
+ assert("visitor" !in people.namespaces);
+ assert("" in people.namespaces);
+ assert("foobar" !in people.namespaces);
+ testRandomAccessRange(people.namespaces[""].attributes, [new Attribute("b_", Value(2))]);
+ testRandomAccessRange(people.all.attributes, [
+ new Attribute("b_", Value(2)),
+ ]);
+
+ people.attributes["b_"][0].remove();
+ testRandomAccessRange(people.attributes, cast(Attribute[])[]);
+ testRandomAccessRange(people.namespaces, cast(NSA[])[], &namespaceEquals);
+ assert("visitor" !in people.namespaces);
+ assert("" !in people.namespaces);
+ assert("foobar" !in people.namespaces);
+ testRandomAccessRange(people.all.attributes, cast(Attribute[])[]);
+}
+
+// Regression test, issue #11: https://github.com/Abscissa/SDLang-D/issues/11
+version(sdlangUnittest)
+unittest
+{
+ import sdlang.parser;
+ writeln("ast: Regression test issue #11...");
+ stdout.flush();
+
+ auto root = parseSource(
+`//
+a`);
+
+ assert("a" in root.tags);
+
+ root = parseSource(
+`//
+parent {
+ child
+}
+`);
+
+ auto child = new Tag(
+ null, "", "child",
+ null, null, null
+ );
+
+ assert("parent" in root.tags);
+ assert("child" !in root.tags);
+ testRandomAccessRange(root.tags["parent"][0].tags, [child]);
+ assert("child" in root.tags["parent"][0].tags);
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-04 11:15:37 +0000