/// <summary>
/// Creates a FunctionInfo object from the given XML. Because it
/// has to resolve Type objects, this should only be done after
/// all referenced assemblies are loaded into the current AppDomain.
/// </summary>
/// <param name="rootElement"></param>
/// <returns></returns>
public virtual FunctionInfo ReadFunction(XmlNode rootElement)
{
if (rootElement == null)
{
throw new DeserialisationException("Could not find Function node");
}
CheckVersion(rootElement);
NodeProcessor proc = new NodeProcessor(rootElement);
var name = proc.GetString("Name");
bool isTemplateFunc = proc.GetBool("IsTemplateFunction");
bool isExtMethod = proc.GetBool("IsExtensionMethod");
var extendedType = proc.GetString("ExtendedType");
var scriptLang = proc.GetEnum <SyntaxEditorHelper.ScriptLanguageTypes>("ScriptLanguage");
var description = proc.GetString("Description");
var category = proc.GetString("Category");
var bodyText = proc.GetString("Body");
var returnType = GetTypeNamed(proc.GetString("ReturnType"));
var templateReturnLang = proc.GetString("TemplateReturnLanguage");
FunctionInfo fi = new FunctionInfo(name, returnType, bodyText, isTemplateFunc, scriptLang, description, templateReturnLang, category, isExtMethod, extendedType);
ProcessFunctionParameters(fi, rootElement);
return(fi);
}
public NodeProcessorTests()
{
_stringParserMock = new Mock <IStringParser>();
_creatorMock = new Mock <INodeCreator>();
_returnedMmsi = 11111111;
HtmlNode childNode1 = HtmlNode.CreateNode("<h2> This is h2 heading1</h2>");
HtmlNode childNode2 = HtmlNode.CreateNode("<h2> This is h2 heading2</h2>");
HtmlNode node = new HtmlNode(new HtmlNodeType(), new HtmlDocument(), 0)
{
InnerHtml = "some_html"
};
node.AppendChild(childNode1);
node.AppendChild(childNode2);
_returnedNodeCollection = new HtmlNodeCollection(new HtmlNode(new HtmlNodeType(), new HtmlDocument(), 0));
_returnedNodeCollection.Append(node);
_creatorMock.Setup(mock => mock.CreateNodeCollection(It.IsAny <string>(), It.IsAny <string>())).Returns(_returnedNodeCollection);
_creatorMock.Setup(mock => mock.CreatePrepareAndVerifyRowNodeOuterHtml(It.IsAny <string>(), It.IsAny <string>())).Returns("some_node_string");
_stringParserMock.Setup(mock => mock.IsContainingMmsi(It.IsAny <string>())).Returns(true);
_stringParserMock.Setup(mock => mock.ParsedInt(It.IsAny <string>())).Returns(_returnedMmsi);
_stringParserMock.Setup(mock => mock.GetAisStatusTrimmed(It.IsAny <string>())).Returns("some_status_string");
_stringParserMock.Setup(mock => mock.GetTrimmedTime1(It.IsAny <string>())).Returns("some_date_time_string1");
_stringParserMock.Setup(mock => mock.GetTrimmedTime2(It.IsAny <string>())).Returns("some_date_time_string2");
_stringParserMock.Setup(mock => mock.IsRowTimeRow(It.IsAny <string>())).Returns(true);
_stringParserMock.Setup(mock => mock.ParsedTrimmedNullableDateTime(It.IsAny <string>())).Returns(new DateTime(2020, 10, 08));
_service = new NodeProcessor(_stringParserMock.Object, _creatorMock.Object);
}
public IIndex ProcessIndexNode(XmlNode node, ITable parent, IDatabase db)
{
IIndex index = new Index();
index.Parent = parent;
ProcessScriptBase(index, node);
/*
* <IsUnique>True</IsUnique>
* <IsClustered>False</IsClustered>
* <Datatype>Unique</Datatype>
* <Columns>
* <ColumnName>ColumnT13</ColumnName>
* </Columns>
*/
NodeProcessor proc = new NodeProcessor(node);
index.IsUnique = proc.GetBool("IsUnique");
index.IsClustered = proc.GetBool("IsClustered");
index.IndexType = proc.GetEnum <DatabaseIndexType>("Datatype");
var columnNodeList = node.SelectNodes("Columns/ColumnName");
if (columnNodeList != null)
{
foreach (XmlNode columnRef in columnNodeList)
{
index.AddColumn(columnRef.InnerText);
}
}
return(index);
}
public IKey ProcessKeyNode(XmlNode node, ITable parent, IDatabase db)
{
IKey key = new Key();
key.Parent = parent;
ProcessScriptBase(key, node);
/*
* <Keytype>Primary</Keytype>
* <Columns>
* <ColumnName>ColumnT11</ColumnName>
* </Columns>
* <ReferencedKey>
* <KeyName>ForeignKey</KeyName>
* <TableName>Table2</TableName>
* </ReferencedKey>
*/
NodeProcessor proc = new NodeProcessor(node);
key.Keytype = proc.GetEnum <DatabaseKeyType>("Keytype");
key.IsUnique = proc.GetBool("IsUnique");
var columnNodeList = node.SelectNodes("Columns/ColumnName");
if (columnNodeList != null)
{
foreach (XmlNode columnRef in columnNodeList)
{
key.AddColumn(columnRef.InnerText);
}
}
return(key);
}
public IUserOption DeserialiseVirtualProperty(XmlNode virtualPropertyNode)
{
NodeProcessor proc = new NodeProcessor(virtualPropertyNode);
string name = proc.Attributes.GetString("name");
string typeName = proc.Attributes.GetString("type");
Type type = GetTypeNamed(typeName);
if (type == null)
throw new Exception(string.Format("Could not find type named \"{0}\" for virtual property {1}", typeName, name));
string valueString = proc.GetString("Value");
IUserOption option = new UserOption();
option.Name = name;
option.DataType = type;
if (type == TypePropertiesForThisEntity)
option.Value = valueString;
else
option.Value = valueString.As(option.DataType);
return option;
}
public IUserOption DeserialiseVirtualProperty(XmlNode virtualPropertyNode)
{
NodeProcessor proc = new NodeProcessor(virtualPropertyNode);
string name = proc.Attributes.GetString("name");
string typeName = proc.Attributes.GetString("type");
Type type = GetTypeNamed(typeName);
if (type == null)
{
throw new Exception(string.Format("Could not find type named \"{0}\" for virtual property {1}", typeName, name));
}
string valueString = proc.GetString("Value");
IUserOption option = new UserOption();
option.Name = name;
option.DataType = type;
if (type == TypePropertiesForThisEntity)
{
option.Value = valueString;
}
else
{
option.Value = valueString.As(option.DataType);
}
return(option);
}
public void ProcessScriptBase(IScriptBase scriptBase, XmlNode scriptBaseNode)
{
/*
* <Name>Table1</Name>
* <Description />
* <Enabled>False</Enabled>
* <IsUserDefined>False</IsUserDefined>
* <UID>00000000-0000-0000-0000-000000000000</UID>
*/
NodeProcessor proc = new NodeProcessor(scriptBaseNode);
scriptBase.Name = proc.GetString("Name");
scriptBase.Schema = proc.GetString("Schema");
scriptBase.Description = proc.GetString("Description");
scriptBase.Enabled = proc.GetBool("Enabled");
scriptBase.IsUserDefined = proc.GetBool("IsUserDefined");
if (proc.Exists(VirtualPropertyDeserialiser.VirtualPropertiesNodeName))
{
var deserialiser = new VirtualPropertyDeserialiser();
scriptBase.Ex =
deserialiser.DeserialiseVirtualProperties(
scriptBaseNode.SelectSingleNode(VirtualPropertyDeserialiser.VirtualPropertiesNodeName));
}
}
public ComponentSpecification DeserialiseComponentSpecification(XmlNode specNode, EntitySet entitySet)
{
NodeProcessor proc = new NodeProcessor(specNode);
string name = proc.Attributes.GetString("name");
ComponentSpecification spec = new ComponentSpecificationImpl(name);
entitySet.AddComponentSpecification(spec);
var propertyNodes = specNode.SelectNodes("Property");
if (propertyNodes != null)
{
foreach (XmlNode node in propertyNodes)
{
var property = DeserialiseComponentProperty(node, spec);
spec.AddProperty(property);
}
}
var componentNodes = specNode.SelectNodes("Component");
if (componentNodes != null)
{
foreach (XmlNode node in componentNodes)
{
// This adds the component as well as creating it.
DeserialiseComponent(node, spec);
}
}
return(spec);
}
protected virtual void ProcessConfig(XmlNode node, IDesignerProject project, string projectFilename)
{
NodeProcessor proc = new NodeProcessor(node);
string relativeCompilePath = proc.GetString("RelativeCompilePath");
project.CompileFolderName = controller.ToAbsolutePath(relativeCompilePath, projectFilename);
project.Version = proc.GetString("Version");
project.ProjType = proc.GetEnum <ProjectTypes>("ProjectType");
string relativeDebugProjectFile = proc.GetString("DebugProjectFile");
project.DebugProjectFile = controller.ToAbsolutePath(relativeDebugProjectFile, projectFilename);
var relativeTestGenerateDirectory = proc.GetString("TestGenerateDirectory");
project.TestGenerateDirectory = controller.ToAbsolutePath(relativeTestGenerateDirectory, projectFilename);
var namespaceNodes = node.SelectNodes("IncludedNamespaces/Namespace");
if (namespaceNodes != null)
{
foreach (XmlNode namespaceNode in namespaceNodes)
{
project.AddNamespace(namespaceNode.InnerText);
}
}
var refereceNodes = node.SelectNodes("References/Reference");
ProcessProjectReferences(refereceNodes, project, projectFilename);
}
public void TestLinerNodeDependency()
{
// [0]--->[1]
Nodes._0.SetRequireNodes(new[] { Profiles._1 });
NodeProcessor.SetBeRequiredNodes(new[] { Nodes._0, Nodes._1 });
Assert.That(Nodes._1.Sources.Any(x => x.Equals(Profiles._0)));
}
protected virtual void ProcessProjectReferences(XmlNodeList nodes, IDesignerProject project, string projectFilename)
{
if (nodes == null)
{
return;
}
List <ReferencedFile> referencedFiles = new List <ReferencedFile>();
foreach (XmlNode referenceNode in nodes)
{
NodeProcessor proc = new NodeProcessor(referenceNode);
string relativeFileName = proc.Attributes.GetString("filename");
bool mergeWithAssembly = proc.Attributes.GetBool("mergewithassembly");
bool useInWorkbench = proc.Attributes.GetBool("useinworkbench");
bool isProvider = proc.Attributes.GetBool("isprovider");
string fileName = controller.ToAbsolutePath(relativeFileName, projectFilename);
ReferencedFile file = new ReferencedFile(fileName, mergeWithAssembly, useInWorkbench);
file.IsProvider = isProvider;
referencedFiles.Add(file);
}
project.SetReferencedFiles(referencedFiles);
}
public static TemplateDefinition GetTemplateDefinitionFromXML(List <string> providerNames, string file, string refFilesXML)
{
XmlDocument doc = new XmlDocument();
doc.LoadXml(refFilesXML);
if (doc.DocumentElement == null)
{
throw new DeserialisationException("Template XML is empty");
}
string description = doc.DocumentElement.SelectSingleNode("Project/Description").InnerText;
var referenceNodes = doc.DocumentElement.SelectNodes("Project/Config/References/Reference");
if (referenceNodes != null)
{
foreach (XmlNode refNode in referenceNodes)
{
NodeProcessor proc = new NodeProcessor(refNode);
if (proc.Attributes.GetBool("isprovider"))
{
providerNames.Add(Path.GetFileNameWithoutExtension(proc.Attributes.GetString("filename")));
}
}
}
TemplateDefinition template = new TemplateDefinition(Path.GetFileName(file), description, file, providerNames);
return(template);
}
/// <summary>
/// Initializes a new instance of the <see cref="ShaderVisitor"/> class.
/// </summary>
/// <param name="buildScopeDeclaration">if set to <c>true</c> [build scope declaration].</param>
/// <param name="useNodeStack">if set to <c>true</c> [use node stack].</param>
protected ShaderVisitor(bool buildScopeDeclaration, bool useNodeStack) : base(useNodeStack)
{
nodeProcessor = OnNodeProcessor;
if (buildScopeDeclaration)
{
ScopeStack = new Stack<ScopeDeclaration>();
ScopeStack.Push(this.NewScope());
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ShaderVisitor"/> class.
/// </summary>
/// <param name="buildScopeDeclaration">if set to <c>true</c> [build scope declaration].</param>
/// <param name="useNodeStack">if set to <c>true</c> [use node stack].</param>
protected ShaderVisitor(bool buildScopeDeclaration, bool useNodeStack) : base(useNodeStack)
{
nodeProcessor = OnNodeProcessor;
if (buildScopeDeclaration)
{
ScopeStack = new Stack <ScopeDeclaration>();
ScopeStack.Push(this.NewScope());
}
}
/**
* Traverses the children nodes of this node.
*/
public void TraverseChildren(NodeProcessor visitor)
{
int count = Children.Count;
for (int i = 0; i < count; ++i)
{
visitor(Children[i]);
}
}
public void SetUpBeforeEveryTest()
{
Nodes.Init();
// [0]--->[1]--->[2]<---[3] [4]
Nodes._0.SetRequireNodes(new[] { Profiles._1 });
Nodes._1.SetRequireNodes(new[] { Profiles._2 });
Nodes._3.SetRequireNodes(new[] { Profiles._2 });
NodeProcessor.SetBeRequiredNodes(new[] { Nodes._0, Nodes._1, Nodes._2, Nodes._3, Nodes._4 });
}
public Relationship DeserialiseRelationship(XmlNode node, IDatabase database)
{
NodeProcessor proc = new NodeProcessor(node);
var rel = new RelationshipImpl();
rel.Identifier = proc.Attributes.GetGuid("identifier");
rel.Name = proc.GetString("Name");
ITable table1 = database.GetTable(proc.GetString("PrimaryTable"), proc.GetString("PrimarySchema"));
ITable table2 = database.GetTable(proc.GetString("ForeignTable"), proc.GetString("ForeignSchema"));
if (table1 == null)
{
table1 = database.GetView(proc.GetString("PrimaryTable"), proc.GetString("PrimarySchema"));
}
if (table2 == null)
{
table2 = database.GetView(proc.GetString("ForeignTable"), proc.GetString("ForeignSchema"));
}
if (table1 == null || table2 == null)
{
return(null);
}
var key1 = table1.GetKey(proc.GetString("PrimaryKey"));
var key2 = table2.GetKey(proc.GetString("ForeignKey"));
if (key1 == null || key2 == null)
{
return(null); // The foreign key has probably been removed
}
if (key1.Keytype == DatabaseKeyType.Foreign)
{
// The keys are around the wrong way.
var tempKey = key2;
key2 = key1;
key1 = tempKey;
var tempTable = table2;
table2 = table1;
table1 = tempTable;
}
rel.AddThisTo(table1, table2);
rel.PrimaryKey = key1;
rel.ForeignKey = key2;
rel.PrimaryCardinality = rel.ForeignKey.IsUnique ? Cardinality.One : Cardinality.Many;
rel.ForeignCardinality = rel.PrimaryKey.IsUnique ? Cardinality.One : Cardinality.Many;
rel.Database = database;
return(rel);
}
public void TestSomeNodeDependency()
{
Nodes.SetSomeNodeDependency();
NodeProcessor.SetBeRequiredNodes(Nodes.All);
// 0
Assert.That(Nodes._0.Sources, Is.Empty);
Assert.That(Nodes._0.Destinations.Count, Is.EqualTo(2));
Assert.That(Nodes._0.Destinations.Any(x => x == Profiles._1));
Assert.That(Nodes._0.Destinations.Any(x => x == Profiles._2));
// 1
Assert.That(Nodes._1.Destinations.Count, Is.EqualTo(1));
Assert.That(Nodes._1.Sources.Any(x => x == Profiles._0));
Assert.That(Nodes._1.Destinations.Count, Is.EqualTo(1));
Assert.That(Nodes._1.Destinations.Any(x => x == Profiles._4));
// 2
Assert.That(Nodes._2.Sources.Count, Is.EqualTo(1));
Assert.That(Nodes._2.Sources.Any(x => x == Profiles._0));
Assert.That(Nodes._2.Destinations.Count, Is.EqualTo(2));
Assert.That(Nodes._2.Destinations.Any(x => x == Profiles._3));
Assert.That(Nodes._2.Destinations.Any(x => x == Profiles._4));
// 3
Assert.That(Nodes._3.Sources.Count, Is.EqualTo(2));
Assert.That(Nodes._3.Sources.Any(x => x == Profiles._2));
Assert.That(Nodes._3.Sources.Any(x => x == Profiles._5));
Assert.That(Nodes._3.Destinations, Is.Empty);
// 4
Assert.That(Nodes._4.Sources.Count, Is.EqualTo(2));
Assert.That(Nodes._4.Sources.Any(x => x == Profiles._1));
Assert.That(Nodes._4.Sources.Any(x => x == Profiles._2));
Assert.That(Nodes._4.Destinations.Count, Is.EqualTo(1));
Assert.That(Nodes._4.Destinations.Any(x => x == Profiles._5));
// 5
Assert.That(Nodes._5.Sources.Count, Is.EqualTo(1));
Assert.That(Nodes._5.Sources.Any(x => x == Profiles._4));
Assert.That(Nodes._5.Destinations.Count, Is.EqualTo(2));
Assert.That(Nodes._5.Destinations.Any(x => x == Profiles._3));
Assert.That(Nodes._5.Destinations.Any(x => x == Profiles._6));
// 6
Assert.That(Nodes._6.Sources.Count, Is.EqualTo(1));
Assert.That(Nodes._6.Sources.Any(x => x == Profiles._5));
Assert.That(Nodes._6.Destinations, Is.Empty);
// 7
Assert.That(Nodes._7.Sources, Is.Empty);
Assert.That(Nodes._7.Destinations.Count, Is.EqualTo(1));
Assert.That(Nodes._7.Destinations.Any(x => x == Profiles._8));
// 8
Assert.That(Nodes._8.Sources.Count, Is.EqualTo(1));
Assert.That(Nodes._8.Sources.Any(x => x == Profiles._7));
Assert.That(Nodes._8.Destinations, Is.Empty);
// 9
Assert.That(Nodes._9.Sources, Is.Empty);
Assert.That(Nodes._9.Destinations, Is.Empty);
}
public EntityKey DeserialiseKey(XmlNode keyNode, Entity parentEntity)
{
var key = new EntityKeyImpl();
key.Parent = parentEntity;
if (keyNode.InnerXml == "")
{
return(key);
}
NodeProcessor keyProc = new NodeProcessor(keyNode);
bool propertiesExist = false;
bool componentExists = false;
var nodes = keyNode.SelectNodes("Properties/Property");
if (nodes != null)
{
propertiesExist = true;
foreach (XmlNode node in nodes)
{
key.AddProperty(node.InnerText);
}
}
if (keyProc.Exists("Component"))
{
componentExists = true;
string componentName = keyProc.SubNode("Component").Attributes.GetString("name");
Component component = parentEntity.Components.FirstOrDefault(c => c.Name == componentName);
if (component == null)
{
throw new DeserialisationException(string.Format("Could not find component named {0} on Entity {1}", componentName, parentEntity.Name));
}
key.Component = component;
}
if (keyProc.Attributes.Exists("keytype"))
{
key.KeyType = keyProc.Attributes.GetEnum <EntityKeyType>("keytype");
}
else if (propertiesExist && componentExists)
{
throw new DeserialisationException(string.Format("Both a Component and a set of Properties were listed as the Key for entity {0}, but no keytype attribute was found on the Key node in the Entity Model XML.", parentEntity.Name));
}
ProcessScriptBase(key, keyNode);
return(key);
}
public void ProcessReferencedKey(IKey key, XmlNode keyNode, IDatabase db)
{
var referencedKeyNode = keyNode.SelectSingleNode("ReferencedKey");
if (referencedKeyNode != null)
{
NodeProcessor proc = new NodeProcessor(referencedKeyNode);
string tableName = proc.GetString("TableName");
string schema = proc.GetString("Schema");
string keyName = proc.GetString("KeyName");
key.ReferencedKey = db.GetKey(tableName, schema, keyName);
}
}
public TreeFactory(Dictionary <int, Point> coordinates)
{
this.visitors = new List <IVisitor>();
this.coordinates = coordinates;
var space = new Space(coordinates);
this.sumCalculator = new SumOfSquareCalculator(space);
this.prune = new Prune(space.PointMapping.Count);
this.nodeProcessor = new NodeProcessor(coordinates.Keys, sumCalculator);
this.threadCount = new ThreadCount();
this.searchCollection = new DfsSearch <NodeModel>();
}
public virtual void ReadProject(XmlNode projectElement, IDesignerProject project, string projectFilename)
{
if (projectElement == null)
{
throw new DeserialisationException("Could not find Project node");
}
NodeProcessor proc = new NodeProcessor(projectElement);
project.ProjectName = proc.GetString("Name");
project.ProjectDescription = proc.GetString("Description");
ProcessConfig(projectElement.SelectSingleNode("Config"), project, projectFilename);
}
public TableReferenceMapping DeserialiseReferenceMapping(XmlNode referenceMappingNode, IDatabase database, EntitySet set)
{
NodeProcessor proc = new NodeProcessor(referenceMappingNode);
TableReferenceMapping mapping = new TableReferenceMappingImpl();
string fromTableName = proc.GetString("FromTable");
string fromSchema = proc.GetString("FromSchema");
Guid toReferenceIdentifier = proc.GetGuid("ToReference");
var reference = set.References.FirstOrDefault(r => r.Identifier == toReferenceIdentifier);
mapping.FromTable = database.GetTable(fromTableName, fromSchema);
mapping.ToReference = reference;
ProcessScriptBase(mapping, referenceMappingNode);
return(mapping);
}
public ComponentMapping DeserialiseComponentMapping(XmlNode mappingNode, IDatabase database, EntitySet set)
{
NodeProcessor proc = new NodeProcessor(mappingNode);
ComponentMapping mapping = new ComponentMappingImpl();
mapping.FromTable = database.GetTable(proc.GetString("FromTable"), proc.GetString("FromSchema"));
NodeProcessor specProcessor = new NodeProcessor(mappingNode.SelectSingleNode("ToComponent"));
var specification = set.GetComponentSpecification(specProcessor.Attributes.GetString("specification"));
var parentEntity = set.GetEntity(specProcessor.Attributes.GetString("parent-entity"));
string name = specProcessor.Attributes.GetString("name");
if (parentEntity == null)
throw new DeserialisationException(string.Format("Could not find the Entity named {0}", name));
if (specification == null)
throw new DeserialisationException(string.Format("Could not find the Component Specification named {0}", name));
var component = specification.ImplementedComponents.FirstOrDefault(c => ReferenceEquals(c.ParentEntity, parentEntity) && c.Name == name);
if (component == null)
throw new DeserialisationException(string.Format("Could not find the component named {0}", name));
mapping.ToComponent = component;
var columnNodes = mappingNode.SelectNodes("FromColumns/Column");
var propNodes = mappingNode.SelectNodes("ToProperties/Property");
if (columnNodes == null) throw new DeserialisationException("There were no columns in this Mapping xml");
if (propNodes == null) throw new DeserialisationException("There were no properties in this Mapping xml");
List<IColumn> columns = new List<IColumn>();
foreach (XmlNode columnNode in columnNodes)
{
columns.Add(mapping.FromTable.GetColumn(columnNode.InnerText));
}
List<ComponentPropertyMarker> properties = new List<ComponentPropertyMarker>();
foreach (XmlNode propNode in propNodes)
{
properties.Add(mapping.ToComponent.GetProperty(propNode.InnerText));
}
if (columns.Count != properties.Count) throw new DeserialisationException("Mapping contains different numbers of columns and properties");
for (int i = 0; i < columns.Count; i++)
{
mapping.AddPropertyAndColumn(properties[i], columns[i]);
}
ProcessScriptBase(mapping, mappingNode);
return mapping;
}
public Discriminator DeserialiseDiscriminator(XmlNode discriminatorNode)
{
NodeProcessor processor = new NodeProcessor(discriminatorNode);
Discriminator discriminator = new Discriminator();
discriminator.AllowNull = processor.GetBool("AllowNull");
discriminator.ColumnName = processor.GetString("ColumnName");
discriminator.DiscriminatorType = (Enums.DiscriminatorTypes)Enum.Parse(typeof(Enums.DiscriminatorTypes), processor.GetString("DiscriminatorType"), true);
discriminator.Force = processor.GetBool("Force");
discriminator.Formula = processor.GetString("Formula");
discriminator.Insert = processor.GetBool("Insert");
return(discriminator);
}
//public Discriminator DeserialiseDiscriminator(XmlNode disNode, IDatabase database)
//{
// var discriminator = new DiscriminatorImpl();
// discriminator.RootGrouping = new AndGrouping();
// var andNode = disNode.SelectSingleNode("AndGrouping");
// if (andNode != null)
// {
// discriminator.RootGrouping = DeserialiseGrouping(andNode, database);
// }
// return discriminator;
//}
//private Grouping DeserialiseGrouping(XmlNode node, IDatabase database)
//{
// AndGrouping group = new AndGrouping();
// var conditionNodes = node.SelectNodes("Condition");
// if (conditionNodes != null)
// foreach (XmlNode condNode in conditionNodes)
// {
// group.AddCondition(DeserialiseCondition(condNode, database));
// }
// return group;
//}
//private Condition DeserialiseCondition(XmlNode node, IDatabase database)
//{
// NodeProcessor proc = new NodeProcessor(node);
// var condition = new ConditionImpl();
// // Find column in database
// condition.Column = GetColumn(node, database);
// // Get the operator
// string opName = proc.GetString("Operator");
// condition.Operator = Operator.FromString(opName);
// condition.ExpressionValue = new ExpressionValueImpl(proc.GetString("ExpressionValue"));
// return condition;
//}
private IColumn GetColumn(XmlNode node, IDatabase database)
{
XmlNode columnNode = node.SelectSingleNode("Column");
if (columnNode == null)
{
throw new DeserialisationException("Could not find Column definition in Discriminator condition.");
}
NodeProcessor proc = new NodeProcessor(columnNode);
string columnName = proc.Attributes.GetString("name");
string tableName = proc.Attributes.GetString("table");
string schemaName = proc.Attributes.GetString("schema");
return(database.GetTable(tableName, schemaName).GetColumn(columnName));
}
private OutputFile ReadScriptFile(XmlNode node)
{
NodeProcessor proc = new NodeProcessor(node);
string name = proc.Attributes.GetString("name");
string id = proc.Attributes.GetString("id");
string scriptName = proc.Attributes.GetString("scriptname");
if (string.IsNullOrEmpty(scriptName))
{
throw new DeserialisationException(string.Format("File {0} has no ScriptName", name));
}
return(new OutputFile(name, OutputFileTypes.Script, scriptName, id));
}
public Property DeserialiseProperty(XmlNode propertyNode, EntityImpl parentEntity)
{
Property property = new PropertyImpl();
property.Entity = parentEntity;
NodeProcessor processor = new NodeProcessor(propertyNode);
if (processor.Exists("IsKey"))
{
property.IsKeyProperty = processor.GetBool("IsKey");
}
property.Name = processor.GetString("Name");
property.ReadOnly = processor.GetBool("ReadOnly");
property.Type = processor.GetString("Type");
if (processor.Exists("NHibernateType"))
{
property.NHibernateType = processor.GetString("NHibernateType");
}
if (processor.Exists("Validation"))
{
property.ValidationOptions = DeserialiseValidationOptions(propertyNode.SelectSingleNode("Validation"));
}
else
{
property.ValidationOptions = new ValidationOptions();
}
if (processor.Exists("IsHiddenByAbstractParent"))
{
property.IsHiddenByAbstractParent = processor.GetBool("IsHiddenByAbstractParent");
}
if (processor.Exists("IsPartOfHiddenKey"))
{
property.IsPartOfHiddenKey = processor.GetBool("IsPartOfHiddenKey");
}
ProcessScriptBase(property, propertyNode);
return(property);
}
protected virtual OutputFolder ReadFolder(XmlNode node)
{
NodeProcessor proc = new NodeProcessor(node);
string name = proc.Attributes.GetString("name");
string id = proc.Attributes.GetString("id");
string iteratorType = proc.Attributes.Exists("iterator") ? proc.Attributes.GetString("iterator") : null;
OutputFolder folder = new OutputFolder(name, id);
if (iteratorType != null)
{
folder.IteratorType = Deserialiser.GetTypeNamed(iteratorType);
}
// Process child folders.
ProcessChildrenOfFolder(node, folder);
return folder;
}
/// <summary>
/// Iterate on childrens and apply the specified transform function.
/// </summary>
/// <param name="node">The node.</param>
/// <param name="nodeProcessor">The process.</param>
/// <param name="listProcessor">The list processor. Default is null using default implementation.</param>
/// <returns>The source node</returns>
public static Node Childrens(this Node node, NodeProcessor nodeProcessor, NodeListProcessor listProcessor = null)
{
if (node == null)
{
return(null);
}
var type = node.GetType();
var process = RegisteredProcessors.GetOrAdd(type, BuildChildrensIterator);
if (listProcessor == null)
{
listProcessor = DefaultListProcessor;
}
var context = new NodeProcessorContext(nodeProcessor, listProcessor);
return(process(node, ref context));
}
protected virtual ApiExtensionMethod ReadApiExtension(XmlNode extensionNode, Type extendedType)
{
NodeProcessor proc = new NodeProcessor(extensionNode);
var methodName = proc.GetString("MethodName");
MethodInfo method = extendedType.GetMethod(methodName);
if (method == null)
{
throw new DeserialisationException(string.Format("Cannot find method named {0} on type {1}", methodName, extendedType.FullName));
}
string overrideText = proc.GetString("OverrideFunctionText");
ApiExtensionMethod extMethod = new ApiExtensionMethod(method);
extMethod.OverridingFunctionBody = overrideText;
return(extMethod);
}
public Reference DeserialiseReference(XmlNode refNode, EntitySet set)
{
Reference reference = new ReferenceImpl();
NodeProcessor processor = new NodeProcessor(refNode);
reference.Identifier = processor.Attributes.GetGuid("identifier");
reference.End1Name = processor.GetString("End1Name");
reference.End2Name = processor.GetString("End2Name");
reference.End1Enabled = processor.GetBool("End1Enabled");
reference.End2Enabled = processor.GetBool("End2Enabled");
reference.Entity1 = set.GetEntity(processor.GetString("Entity1"));
reference.Entity2 = set.GetEntity(processor.GetString("Entity2"));
reference.Cardinality1 = DeserialiseCardinality(refNode.SelectSingleNode("Cardinality1"));
reference.Cardinality2 = DeserialiseCardinality(refNode.SelectSingleNode("Cardinality2"));
if (Version >= 2)
{
reference.IncludeForeignKey = processor.GetBool("IncludeForeignKey");
}
ProcessScriptBase(reference, refNode);
// Fixup virtual properties of type PropertiesForThisEntity
foreach (var uo in reference.Ex.Where(v => v.DataType == TypePropertiesForThisEntity))
{
object obj = null;
if (reference.Entity1 != null)
{
obj = reference.Entity1.Properties.SingleOrDefault(p => p.Name.Equals(uo.Value.ToString(), StringComparison.InvariantCultureIgnoreCase));
}
if (obj == null && reference.Entity2 != null)
{
obj = reference.Entity2.Properties.SingleOrDefault(p => p.Name.Equals(uo.Value.ToString(), StringComparison.InvariantCultureIgnoreCase));
}
uo.Value = obj;
}
return(reference);
}
protected virtual OutputFolder ReadFolder(XmlNode node)
{
NodeProcessor proc = new NodeProcessor(node);
string name = proc.Attributes.GetString("name");
string id = proc.Attributes.GetString("id");
string iteratorType = proc.Attributes.Exists("iterator") ? proc.Attributes.GetString("iterator") : null;
OutputFolder folder = new OutputFolder(name, id);
if (iteratorType != null)
{
folder.IteratorType = Deserialiser.GetTypeNamed(iteratorType);
}
// Process child folders.
ProcessChildrenOfFolder(node, folder);
return(folder);
}
internal CodeFragmentManager(IParsedScript iParsedScript)
{
// TODO: Complete member initialization
this.parsedScript = iParsedScript;
CodeBlockNode parsedResults = iParsedScript.GetParsedResults();
if (null != parsedResults)
{
NodeProcessor nodeProcessor = new NodeProcessor(parsedResults.Body);
nodeProcessor.GenerateFragments(out fragmentArray);
Array.Sort(fragmentArray);
}
else
{
// Create a dummy fragment just for the heck of it.
fragmentArray = new CodeFragment[] { new CodeFragment(-1, -1, -1) };
}
}
public static string GetProjectFilesFolder(string projectFilename)
{
XmlDocument doc = new XmlDocument();
doc.Load(projectFilename);
string folder = GetProjectFilesDirectoryName(projectFilename);
if (!Directory.Exists(RelativePaths.RelativeToAbsolutePath(Path.GetDirectoryName(projectFilename), folder)))
try
{
NodeProcessor proc = new NodeProcessor(doc.DocumentElement);
folder = proc.GetString("Folder");
}
catch
{
throw new Exception("Files folder not found for this project.\nIf your project file is called 'xyz.wbproj' then the files folder should be called 'xyz_files'.");
}
return RelativePaths.RelativeToAbsolutePath(Path.GetDirectoryName(projectFilename), folder);
}
public Mapping DeserialiseMapping(XmlNode node, IDatabase database, EntitySet set)
{
NodeProcessor proc = new NodeProcessor(node);
Mapping mapping = new MappingImpl();
mapping.FromTable = database.GetTable(proc.GetString("FromTable"), proc.GetString("FromSchema"));
if (mapping.FromTable == null)
mapping.FromTable = database.GetView(proc.GetString("FromTable"), proc.GetString("FromSchema"));
mapping.ToEntity = set.GetEntity(proc.GetString("ToEntity"));
if (mapping.FromTable == null || mapping.ToEntity == null)
return null;
var columnNodes = node.SelectNodes("FromColumns/Column");
var propNodes = node.SelectNodes("ToProperties/Property");
if (columnNodes == null) throw new DeserialisationException("There were no columns in this Mapping xml");
if (propNodes == null) throw new DeserialisationException("There were no properties in this Mapping xml");
List<IColumn> columns = new List<IColumn>();
foreach (XmlNode columnNode in columnNodes)
columns.Add(mapping.FromTable.GetColumn(columnNode.InnerText));
List<Property> properties = new List<Property>();
foreach (XmlNode propNode in propNodes)
properties.Add(mapping.ToEntity.GetProperty(propNode.InnerText));
if (columns.Count != properties.Count) throw new DeserialisationException("Mapping contains different numbers of columns and properties");
for (int i = 0; i < columns.Count; i++)
{
if (properties[i] != null && columns[i] != null)
mapping.AddPropertyAndColumn(properties[i], columns[i]);
}
ProcessScriptBase(mapping, node);
return mapping;
}
public void TestAssociativeVariableDeclaration()
{
//a :int = 100;
string content = "a :int = 100;";
Scanner scanner = new Scanner(ConvertToStream(content));
parser = new DesignScript.Parser.Parser(scanner, core);
parser.Parse();
nodeProcessor = new NodeProcessor(parser.root.Body);
nodeProcessor.GenerateFragments(out fragmentArray);
Assert.AreEqual(fragmentArray.Length, 6);
Assert.AreEqual(fragmentArray[4].CodeType, CodeFragment.Type.Keyword);
Assert.AreEqual(fragmentArray[4].Text, "int");
Assert.AreEqual(fragmentArray[4].Line, 0);
Assert.AreEqual(fragmentArray[4].ColStart, 3);
Assert.AreEqual(fragmentArray[4].ColEnd, 5);
Assert.AreEqual(fragmentArray[3].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[3].Text, ":");
Assert.AreEqual(fragmentArray[3].Line, 0);
Assert.AreEqual(fragmentArray[3].ColStart, 2);
Assert.AreEqual(fragmentArray[3].ColEnd, 2);
Assert.AreEqual(fragmentArray[2].CodeType, CodeFragment.Type.Local);
Assert.AreEqual(fragmentArray[2].Text, "a");
Assert.AreEqual(fragmentArray[2].Line, 0);
Assert.AreEqual(fragmentArray[2].ColStart, 0);
Assert.AreEqual(fragmentArray[2].ColEnd, 0);
Assert.AreEqual(fragmentArray[1].CodeType, CodeFragment.Type.Number);
Assert.AreEqual(fragmentArray[1].Text, "100");
Assert.AreEqual(fragmentArray[1].Line, 0);
Assert.AreEqual(fragmentArray[1].ColStart, 9);
Assert.AreEqual(fragmentArray[1].ColEnd, 11);
Assert.AreEqual(fragmentArray[5].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[5].Text, "=");
Assert.AreEqual(fragmentArray[5].Line, 0);
Assert.AreEqual(fragmentArray[5].ColStart, 7);
Assert.AreEqual(fragmentArray[5].ColEnd, 7);
}
public void TestAssociativeBaseConstructor()
{
//class Derived extends Base {
// constructor DerivedConstr(derivedValue : int) : base.BaseConstructor(derivedValue + 2) { }
//}
string content = "class Derived extends Base { constructor DerivedConstr(derivedValue : int) : base.BaseConstructor(derivedValue + 2) { } }";
Scanner scanner = new Scanner(ConvertToStream(content));
parser = new DesignScript.Parser.Parser(scanner, core);
parser.Parse();
nodeProcessor = new NodeProcessor(parser.root.Body);
nodeProcessor.GenerateFragments(out fragmentArray);
Assert.AreEqual(fragmentArray.Length, 24);
Assert.AreEqual(fragmentArray[8].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[8].Text, ".");
Assert.AreEqual(fragmentArray[8].Line, 0);
Assert.AreEqual(fragmentArray[8].ColStart, 81);
Assert.AreEqual(fragmentArray[8].ColEnd, 81);
Assert.AreEqual(fragmentArray[10].CodeType, CodeFragment.Type.Keyword);
Assert.AreEqual(fragmentArray[10].Text, "base");
Assert.AreEqual(fragmentArray[10].Line, 0);
Assert.AreEqual(fragmentArray[10].ColStart, 77);
Assert.AreEqual(fragmentArray[10].ColEnd, 80);
Assert.AreEqual(fragmentArray[11].CodeType, CodeFragment.Type.Function);
Assert.AreEqual(fragmentArray[11].Text, "BaseConstructor");
Assert.AreEqual(fragmentArray[11].Line, 0);
Assert.AreEqual(fragmentArray[11].ColStart, 82);
Assert.AreEqual(fragmentArray[11].ColEnd, 96);
Assert.AreEqual(fragmentArray[12].CodeType, CodeFragment.Type.Local);
Assert.AreEqual(fragmentArray[12].Text, "derivedValue");
Assert.AreEqual(fragmentArray[12].Line, 0);
Assert.AreEqual(fragmentArray[12].ColStart, 98);
Assert.AreEqual(fragmentArray[12].ColEnd, 109);
Assert.AreEqual(fragmentArray[13].CodeType, CodeFragment.Type.Number);
Assert.AreEqual(fragmentArray[13].Text, "2");
Assert.AreEqual(fragmentArray[13].Line, 0);
Assert.AreEqual(fragmentArray[13].ColStart, 113);
Assert.AreEqual(fragmentArray[13].ColEnd, 113);
Assert.AreEqual(fragmentArray[14].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[14].Text, "+");
Assert.AreEqual(fragmentArray[14].Line, 0);
Assert.AreEqual(fragmentArray[14].ColStart, 111);
Assert.AreEqual(fragmentArray[14].ColEnd, 111);
Assert.AreEqual(fragmentArray[15].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[15].Text, "(");
Assert.AreEqual(fragmentArray[15].Line, 0);
Assert.AreEqual(fragmentArray[15].ColStart, 97);
Assert.AreEqual(fragmentArray[15].ColEnd, 97);
Assert.AreEqual(fragmentArray[16].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[16].Text, ")");
Assert.AreEqual(fragmentArray[16].Line, 0);
Assert.AreEqual(fragmentArray[16].ColStart, 114);
Assert.AreEqual(fragmentArray[16].ColEnd, 114);
Assert.AreEqual(fragmentArray[17].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[17].Text, "}");
Assert.AreEqual(fragmentArray[17].Line, 0);
Assert.AreEqual(fragmentArray[17].ColStart, 118);
Assert.AreEqual(fragmentArray[17].ColEnd, 118);
Assert.AreEqual(fragmentArray[18].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[18].Text, "{");
Assert.AreEqual(fragmentArray[18].Line, 0);
Assert.AreEqual(fragmentArray[18].ColStart, 116);
Assert.AreEqual(fragmentArray[18].ColEnd, 116);
}
public void TestAssociativeImportNegativeNode()
{
string content = "import (filename01); a = 1; import(filename02); b = 2; ";
Scanner scanner = new Scanner(ConvertToStream(content));
parser = new DesignScript.Parser.Parser(scanner, core);
parser.Parse();
nodeProcessor = new NodeProcessor(parser.root.Body);
nodeProcessor.GenerateFragments(out fragmentArray);
Assert.AreEqual(fragmentArray.Length, 18);
Assert.AreEqual(fragmentArray[3].CodeType, CodeFragment.Type.Local);
Assert.AreEqual(fragmentArray[3].Text, "filename01");
Assert.AreEqual(fragmentArray[3].Line, 0);
Assert.AreEqual(fragmentArray[3].ColStart, 8);
Assert.AreEqual(fragmentArray[3].ColEnd, 17);
Assert.AreEqual(fragmentArray[4].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[4].Text, ";");
Assert.AreEqual(fragmentArray[4].Line, 0);
Assert.AreEqual(fragmentArray[4].ColStart, 19);
Assert.AreEqual(fragmentArray[4].ColEnd, 19);
Assert.AreEqual(fragmentArray[5].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[5].Text, ";");
Assert.AreEqual(fragmentArray[5].Line, 0);
Assert.AreEqual(fragmentArray[5].ColStart, 26);
Assert.AreEqual(fragmentArray[5].ColEnd, 26);
Assert.AreEqual(fragmentArray[6].CodeType, CodeFragment.Type.Local);
Assert.AreEqual(fragmentArray[6].Text, "a");
Assert.AreEqual(fragmentArray[6].Line, 0);
Assert.AreEqual(fragmentArray[6].ColStart, 21);
Assert.AreEqual(fragmentArray[6].ColEnd, 21);
Assert.AreEqual(fragmentArray[7].CodeType, CodeFragment.Type.Number);
Assert.AreEqual(fragmentArray[7].Text, "1");
Assert.AreEqual(fragmentArray[7].Line, 0);
Assert.AreEqual(fragmentArray[7].ColStart, 25);
Assert.AreEqual(fragmentArray[7].ColEnd, 25);
Assert.AreEqual(fragmentArray[8].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[8].Text, "=");
Assert.AreEqual(fragmentArray[8].Line, 0);
Assert.AreEqual(fragmentArray[8].ColStart, 23);
Assert.AreEqual(fragmentArray[8].ColEnd, 23);
Assert.AreEqual(fragmentArray[9].CodeType, CodeFragment.Type.Keyword);
Assert.AreEqual(fragmentArray[9].Text, "");
Assert.AreEqual(fragmentArray[9].Line, -2);
Assert.AreEqual(fragmentArray[9].ColStart, -2);
Assert.AreEqual(fragmentArray[9].ColEnd, -3);
}
public void TestAssociativeIdentifierListNode()
{
string content = "[Associative] d.b.c;";
Scanner scanner = new Scanner(ConvertToStream(content));
parser = new DesignScript.Parser.Parser(scanner, core);
parser.Parse();
nodeProcessor = new NodeProcessor(parser.root.Body);
nodeProcessor.GenerateFragments(out fragmentArray);
Assert.AreEqual(fragmentArray.Length, 9);
Assert.AreEqual(fragmentArray[4].CodeType, CodeFragment.Type.Local);
Assert.AreEqual(fragmentArray[4].Text, "d");
Assert.AreEqual(fragmentArray[4].Line, 0);
Assert.AreEqual(fragmentArray[4].ColStart, 14);
Assert.AreEqual(fragmentArray[4].ColEnd, 14);
Assert.AreEqual(fragmentArray[5].CodeType, CodeFragment.Type.Local);
Assert.AreEqual(fragmentArray[5].Text, "b");
Assert.AreEqual(fragmentArray[5].Line, 0);
Assert.AreEqual(fragmentArray[5].ColStart, 16);
Assert.AreEqual(fragmentArray[5].ColEnd, 16);
Assert.AreEqual(fragmentArray[6].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[6].Text, ".");
Assert.AreEqual(fragmentArray[6].Line, 0);
Assert.AreEqual(fragmentArray[6].ColStart, 15);
Assert.AreEqual(fragmentArray[6].ColEnd, 15);
Assert.AreEqual(fragmentArray[7].CodeType, CodeFragment.Type.Local);
Assert.AreEqual(fragmentArray[7].Text, "c");
Assert.AreEqual(fragmentArray[7].Line, 0);
Assert.AreEqual(fragmentArray[7].ColStart, 18);
Assert.AreEqual(fragmentArray[7].ColEnd, 18);
Assert.AreEqual(fragmentArray[8].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[8].Text, ".");
Assert.AreEqual(fragmentArray[8].Line, 0);
Assert.AreEqual(fragmentArray[8].ColStart, 17);
Assert.AreEqual(fragmentArray[8].ColEnd, 17);
}
public void TestAssociativeFunctionDeclarationAsBinaryExpr()
{
//[Associative]
//{
// def fooX(x) = 2 * x;
//}
string content = "[Associative]{ def fooX(x) = 2 * x; }";
Scanner scanner = new Scanner(ConvertToStream(content));
parser = new DesignScript.Parser.Parser(scanner, core);
parser.Parse();
nodeProcessor = new NodeProcessor(parser.root.Body);
nodeProcessor.GenerateFragments(out fragmentArray);
Assert.AreEqual(fragmentArray.Length, 16);
Assert.AreEqual(fragmentArray[5].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[5].Text, ";");
Assert.AreEqual(fragmentArray[5].Line, 0);
Assert.AreEqual(fragmentArray[5].ColStart, 34);
Assert.AreEqual(fragmentArray[5].ColEnd, 34);
Assert.AreEqual(fragmentArray[6].CodeType, CodeFragment.Type.Keyword);
Assert.AreEqual(fragmentArray[6].Text, "def");
Assert.AreEqual(fragmentArray[6].Line, 0);
Assert.AreEqual(fragmentArray[6].ColStart, 15);
Assert.AreEqual(fragmentArray[6].ColEnd, 17);
Assert.AreEqual(fragmentArray[7].CodeType, CodeFragment.Type.Function);
Assert.AreEqual(fragmentArray[7].Text, "fooX");
Assert.AreEqual(fragmentArray[7].Line, 0);
Assert.AreEqual(fragmentArray[7].ColStart, 19);
Assert.AreEqual(fragmentArray[7].ColEnd, 22);
Assert.AreEqual(fragmentArray[9].CodeType, CodeFragment.Type.Number);
Assert.AreEqual(fragmentArray[9].Text, "2");
Assert.AreEqual(fragmentArray[9].Line, 0);
Assert.AreEqual(fragmentArray[9].ColStart, 29);
Assert.AreEqual(fragmentArray[9].ColEnd, 29);
Assert.AreEqual(fragmentArray[10].CodeType, CodeFragment.Type.Local);
Assert.AreEqual(fragmentArray[10].Text, "x");
Assert.AreEqual(fragmentArray[10].Line, 0);
Assert.AreEqual(fragmentArray[10].ColStart, 33);
Assert.AreEqual(fragmentArray[10].ColEnd, 33);
Assert.AreEqual(fragmentArray[11].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[11].Text, "*");
Assert.AreEqual(fragmentArray[11].Line, 0);
Assert.AreEqual(fragmentArray[11].ColStart, 31);
Assert.AreEqual(fragmentArray[11].ColEnd, 31);
Assert.AreEqual(fragmentArray[12].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[12].Text, "=");
Assert.AreEqual(fragmentArray[12].Line, 0);
Assert.AreEqual(fragmentArray[12].ColStart, 27);
Assert.AreEqual(fragmentArray[12].ColEnd, 27);
Assert.AreEqual(fragmentArray[13].CodeType, CodeFragment.Type.Local);
Assert.AreEqual(fragmentArray[13].Text, "x");
Assert.AreEqual(fragmentArray[13].Line, 0);
Assert.AreEqual(fragmentArray[13].ColStart, 24);
Assert.AreEqual(fragmentArray[13].ColEnd, 24);
Assert.AreEqual(fragmentArray[14].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[14].Text, ")");
Assert.AreEqual(fragmentArray[14].Line, 0);
Assert.AreEqual(fragmentArray[14].ColStart, 25);
Assert.AreEqual(fragmentArray[14].ColEnd, 25);
Assert.AreEqual(fragmentArray[15].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[15].Text, "(");
Assert.AreEqual(fragmentArray[15].Line, 0);
Assert.AreEqual(fragmentArray[15].ColStart, 23);
Assert.AreEqual(fragmentArray[15].ColEnd, 23);
}
public void TestAssociativeArrayExprList()
{
//[Associative]
//{
// Hello = { pt1, pt2 }.Translate();
//}
string content = "[Associative]{ Hello = { pt1, pt2 }.Translate(); }";
Scanner scanner = new Scanner(ConvertToStream(content));
parser = new DesignScript.Parser.Parser(scanner, core);
parser.Parse();
nodeProcessor = new NodeProcessor(parser.root.Body);
nodeProcessor.GenerateFragments(out fragmentArray);
Assert.AreEqual(fragmentArray.Length, 17);
Assert.AreEqual(fragmentArray[6].CodeType, CodeFragment.Type.Local);
Assert.AreEqual(fragmentArray[6].Text, "Hello");
Assert.AreEqual(fragmentArray[6].Line, 0);
Assert.AreEqual(fragmentArray[6].ColStart, 15);
Assert.AreEqual(fragmentArray[6].ColEnd, 19);
Assert.AreEqual(fragmentArray[7].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[7].Text, ",");
Assert.AreEqual(fragmentArray[7].Line, 0);
Assert.AreEqual(fragmentArray[7].ColStart, 28);
Assert.AreEqual(fragmentArray[7].ColEnd, 28);
Assert.AreEqual(fragmentArray[8].CodeType, CodeFragment.Type.Local);
Assert.AreEqual(fragmentArray[8].Text, "pt1");
Assert.AreEqual(fragmentArray[8].Line, 0);
Assert.AreEqual(fragmentArray[8].ColStart, 25);
Assert.AreEqual(fragmentArray[8].ColEnd, 27);
Assert.AreEqual(fragmentArray[9].CodeType, CodeFragment.Type.Local);
Assert.AreEqual(fragmentArray[9].Text, "pt2");
Assert.AreEqual(fragmentArray[9].Line, 0);
Assert.AreEqual(fragmentArray[9].ColStart, 30);
Assert.AreEqual(fragmentArray[9].ColEnd, 32);
Assert.AreEqual(fragmentArray[10].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[10].Text, "{");
Assert.AreEqual(fragmentArray[10].Line, 0);
Assert.AreEqual(fragmentArray[10].ColStart, 23);
Assert.AreEqual(fragmentArray[10].ColEnd, 23);
Assert.AreEqual(fragmentArray[11].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[11].Text, "}");
Assert.AreEqual(fragmentArray[11].Line, 0);
Assert.AreEqual(fragmentArray[11].ColStart, 34);
Assert.AreEqual(fragmentArray[11].ColEnd, 34);
Assert.AreEqual(fragmentArray[12].CodeType, CodeFragment.Type.Function);
Assert.AreEqual(fragmentArray[12].Text, "Translate");
Assert.AreEqual(fragmentArray[12].Line, 0);
Assert.AreEqual(fragmentArray[12].ColStart, 36);
Assert.AreEqual(fragmentArray[12].ColEnd, 44);
Assert.AreEqual(fragmentArray[13].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[13].Text, "(");
Assert.AreEqual(fragmentArray[13].Line, 0);
Assert.AreEqual(fragmentArray[13].ColStart, 45);
Assert.AreEqual(fragmentArray[13].ColEnd, 45);
Assert.AreEqual(fragmentArray[14].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[14].Text, ")");
Assert.AreEqual(fragmentArray[14].Line, 0);
Assert.AreEqual(fragmentArray[14].ColStart, 46);
Assert.AreEqual(fragmentArray[14].ColEnd, 46);
Assert.AreEqual(fragmentArray[15].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[15].Text, ".");
Assert.AreEqual(fragmentArray[15].Line, 0);
Assert.AreEqual(fragmentArray[15].ColStart, 35);
Assert.AreEqual(fragmentArray[15].ColEnd, 35);
Assert.AreEqual(fragmentArray[16].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[16].Text, "=");
Assert.AreEqual(fragmentArray[16].Line, 0);
Assert.AreEqual(fragmentArray[16].ColStart, 21);
Assert.AreEqual(fragmentArray[16].ColEnd, 21);
}
public void TestAssociativeDoubleNode()
{
string content = "[Associative] x = 2.1;";
Scanner scanner = new Scanner(ConvertToStream(content));
parser = new DesignScript.Parser.Parser(scanner, core);
parser.Parse();
nodeProcessor = new NodeProcessor(parser.root.Body);
nodeProcessor.GenerateFragments(out fragmentArray);
Assert.IsTrue(fragmentArray.Length == 7);
Assert.AreEqual(fragmentArray[4].CodeType, CodeFragment.Type.Local);
Assert.AreEqual(fragmentArray[4].Text, "x");
Assert.AreEqual(fragmentArray[4].Line, 0);
Assert.AreEqual(fragmentArray[4].ColStart, 14);
Assert.AreEqual(fragmentArray[4].ColEnd, 14);
Assert.AreEqual(fragmentArray[5].CodeType, CodeFragment.Type.Number);
Assert.AreEqual(fragmentArray[5].Text, "2.1");
Assert.AreEqual(fragmentArray[5].Line, 0);
Assert.AreEqual(fragmentArray[5].ColStart, 18);
Assert.AreEqual(fragmentArray[5].ColEnd, 20);
Assert.AreEqual(fragmentArray[6].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[6].Text, "=");
Assert.AreEqual(fragmentArray[6].Line, 0);
Assert.AreEqual(fragmentArray[6].ColStart, 16);
Assert.AreEqual(fragmentArray[6].ColEnd, 16);
}
public void TestAssociativeBinaryExpressionNode()
{
string content = "[Associative]x = 0;";
Scanner scanner = new Scanner(ConvertToStream(content));
parser = new DesignScript.Parser.Parser(scanner, core);
parser.Parse();
nodeProcessor = new NodeProcessor(parser.root.Body);
nodeProcessor.GenerateFragments(out fragmentArray);
Assert.IsTrue(fragmentArray.Length == 7);
Assert.AreEqual(fragmentArray[0].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[0].Text, "[");
Assert.AreEqual(fragmentArray[0].Line, 0);
Assert.AreEqual(fragmentArray[0].ColStart, 0);
Assert.AreEqual(fragmentArray[0].ColEnd, 0);
Assert.AreEqual(fragmentArray[1].CodeType, CodeFragment.Type.Keyword);
Assert.AreEqual(fragmentArray[1].Text, "Associative");
Assert.AreEqual(fragmentArray[1].Line, 0);
Assert.AreEqual(fragmentArray[1].ColStart, 1);
Assert.AreEqual(fragmentArray[1].ColEnd, 11);
Assert.AreEqual(fragmentArray[2].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[2].Text, "]");
Assert.AreEqual(fragmentArray[2].Line, 0);
Assert.AreEqual(fragmentArray[2].ColStart, 12);
Assert.AreEqual(fragmentArray[2].ColEnd, 12);
Assert.AreEqual(fragmentArray[3].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[3].Text, ";");
Assert.AreEqual(fragmentArray[3].Line, 0);
Assert.AreEqual(fragmentArray[3].ColStart, 18);
Assert.AreEqual(fragmentArray[3].ColEnd, 18);
Assert.AreEqual(fragmentArray[4].CodeType, CodeFragment.Type.Local);
Assert.AreEqual(fragmentArray[4].Text, "x");
Assert.AreEqual(fragmentArray[4].Line, 0);
Assert.AreEqual(fragmentArray[4].ColStart, 13);
Assert.AreEqual(fragmentArray[4].ColEnd, 13);
Assert.AreEqual(fragmentArray[5].CodeType, CodeFragment.Type.Number);
Assert.AreEqual(fragmentArray[5].Text, "0");
Assert.AreEqual(fragmentArray[5].Line, 0);
Assert.AreEqual(fragmentArray[5].ColStart, 17);
Assert.AreEqual(fragmentArray[5].ColEnd, 17);
Assert.AreEqual(fragmentArray[6].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[6].Text, "=");
Assert.AreEqual(fragmentArray[6].Line, 0);
Assert.AreEqual(fragmentArray[6].ColStart, 15);
Assert.AreEqual(fragmentArray[6].ColEnd, 15);
}
public void TestAssociativeNegativeUnaryExpr()
{
//[Associative]{
// a = 10;
// b = -a;
//}
string content = "[Associative]{ a = 10; b = -a; }";
Scanner scanner = new Scanner(ConvertToStream(content));
parser = new DesignScript.Parser.Parser(scanner, core);
parser.Parse();
nodeProcessor = new NodeProcessor(parser.root.Body);
nodeProcessor.GenerateFragments(out fragmentArray);
Assert.AreEqual(fragmentArray.Length, 14);
Assert.AreEqual(fragmentArray[10].CodeType, CodeFragment.Type.Local);
Assert.AreEqual(fragmentArray[10].Text, "b");
Assert.AreEqual(fragmentArray[10].Line, 0);
Assert.AreEqual(fragmentArray[10].ColStart, 23);
Assert.AreEqual(fragmentArray[10].ColEnd, 23);
Assert.AreEqual(fragmentArray[11].CodeType, CodeFragment.Type.Local);
Assert.AreEqual(fragmentArray[11].Text, "a");
Assert.AreEqual(fragmentArray[11].Line, 0);
Assert.AreEqual(fragmentArray[11].ColStart, 28);
Assert.AreEqual(fragmentArray[11].ColEnd, 28);
Assert.AreEqual(fragmentArray[12].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[12].Text, "-");
Assert.AreEqual(fragmentArray[12].Line, 0);
Assert.AreEqual(fragmentArray[12].ColStart, 27);
Assert.AreEqual(fragmentArray[12].ColEnd, 27);
Assert.AreEqual(fragmentArray[13].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[13].Text, "=");
Assert.AreEqual(fragmentArray[13].Line, 0);
Assert.AreEqual(fragmentArray[13].ColStart, 25);
Assert.AreEqual(fragmentArray[13].ColEnd, 25);
}
public void TestAssociativeModifierStack()
{
//a = {
// 1 => a1;
// +1 => a2;
//}
string content = "[Associative]{ a = { 1 => a1; +1 => a2; } }";
Scanner scanner = new Scanner(ConvertToStream(content));
parser = new DesignScript.Parser.Parser(scanner, core);
parser.Parse();
nodeProcessor = new NodeProcessor(parser.root.Body);
nodeProcessor.GenerateFragments(out fragmentArray);
Assert.AreEqual(fragmentArray.Length, 25);
Assert.AreEqual(fragmentArray[5].CodeType, CodeFragment.Type.Local);
Assert.AreEqual(fragmentArray[5].Text, "a");
Assert.AreEqual(fragmentArray[5].Line, 0);
Assert.AreEqual(fragmentArray[5].ColStart, 15);
Assert.AreEqual(fragmentArray[5].ColEnd, 15);
Assert.AreEqual(fragmentArray[14].CodeType, CodeFragment.Type.Local);
Assert.AreEqual(fragmentArray[14].Text, "a");
Assert.AreEqual(fragmentArray[14].Line, 0);
Assert.AreEqual(fragmentArray[14].ColStart, 15);
Assert.AreEqual(fragmentArray[14].ColEnd, 15);
Assert.AreEqual(fragmentArray[17].CodeType, CodeFragment.Type.Local);
Assert.AreEqual(fragmentArray[17].Text, "a");
Assert.AreEqual(fragmentArray[17].Line, 0);
Assert.AreEqual(fragmentArray[17].ColStart, 15);
Assert.AreEqual(fragmentArray[17].ColEnd, 15);
Assert.AreEqual(fragmentArray[18].CodeType, CodeFragment.Type.Local);
Assert.AreEqual(fragmentArray[18].Text, "a");
Assert.AreEqual(fragmentArray[18].Line, 0);
Assert.AreEqual(fragmentArray[18].ColStart, 15);
Assert.AreEqual(fragmentArray[18].ColEnd, 15);
Assert.AreEqual(fragmentArray[20].CodeType, CodeFragment.Type.Number);
Assert.AreEqual(fragmentArray[20].Text, "1");
Assert.AreEqual(fragmentArray[20].Line, 0);
Assert.AreEqual(fragmentArray[20].ColStart, 31);
Assert.AreEqual(fragmentArray[20].ColEnd, 31);
Assert.AreEqual(fragmentArray[16].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[16].Text, "=");
Assert.AreEqual(fragmentArray[16].Line, 0);
Assert.AreEqual(fragmentArray[16].ColStart, 17);
Assert.AreEqual(fragmentArray[16].ColEnd, 17);
Assert.AreEqual(fragmentArray[22].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[22].Text, "=");
Assert.AreEqual(fragmentArray[22].Line, 0);
Assert.AreEqual(fragmentArray[22].ColStart, 17);
Assert.AreEqual(fragmentArray[22].ColEnd, 17);
Assert.AreEqual(fragmentArray[8].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[8].Text, "=>");
Assert.AreEqual(fragmentArray[8].Line, 0);
Assert.AreEqual(fragmentArray[8].ColStart, 23);
Assert.AreEqual(fragmentArray[8].ColEnd, 24);
Assert.AreEqual(fragmentArray[9].CodeType, CodeFragment.Type.Local);
Assert.AreEqual(fragmentArray[9].Text, "a1");
Assert.AreEqual(fragmentArray[9].Line, 0);
Assert.AreEqual(fragmentArray[9].ColStart, 26);
Assert.AreEqual(fragmentArray[9].ColEnd, 27);
Assert.AreEqual(fragmentArray[10].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[10].Text, "=>");
Assert.AreEqual(fragmentArray[10].Line, 0);
Assert.AreEqual(fragmentArray[10].ColStart, 33);
Assert.AreEqual(fragmentArray[10].ColEnd, 34);
Assert.AreEqual(fragmentArray[11].CodeType, CodeFragment.Type.Local);
Assert.AreEqual(fragmentArray[11].Text, "a2");
Assert.AreEqual(fragmentArray[11].Line, 0);
Assert.AreEqual(fragmentArray[11].ColStart, 36);
Assert.AreEqual(fragmentArray[11].ColEnd, 37);
Assert.AreEqual(fragmentArray[15].CodeType, CodeFragment.Type.Number);
Assert.AreEqual(fragmentArray[15].Text, "1");
Assert.AreEqual(fragmentArray[15].Line, 0);
Assert.AreEqual(fragmentArray[15].ColStart, 21);
Assert.AreEqual(fragmentArray[15].ColEnd, 21);
Assert.AreEqual(fragmentArray[21].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[21].Text, "+");
Assert.AreEqual(fragmentArray[21].Line, 0);
Assert.AreEqual(fragmentArray[21].ColStart, 30);
Assert.AreEqual(fragmentArray[21].ColEnd, 30);
}
public void TestAssociativeInlineConditionExpr()
{
//[Associative]
//{
// a = 3.141593;
// b = 100 ;
// i = 2 ;
// j : double = (i == 2) ? a : b;
//}
string content = "[Associative]{ a = 3.141593 ; b = 100 ; i = 2 ; j : double = (i == 2) ? a : b; }";
Scanner scanner = new Scanner(ConvertToStream(content));
parser = new DesignScript.Parser.Parser(scanner, core);
parser.Parse();
nodeProcessor = new NodeProcessor(parser.root.Body);
nodeProcessor.GenerateFragments(out fragmentArray);
Assert.AreEqual(fragmentArray.Length, 31);
Assert.AreEqual(fragmentArray[29].CodeType, CodeFragment.Type.Keyword);
Assert.AreEqual(fragmentArray[29].Text, "double");
Assert.AreEqual(fragmentArray[29].Line, 0);
Assert.AreEqual(fragmentArray[29].ColStart, 52);
Assert.AreEqual(fragmentArray[29].ColEnd, 57);
Assert.AreEqual(fragmentArray[28].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[28].Text, ":");
Assert.AreEqual(fragmentArray[28].Line, 0);
Assert.AreEqual(fragmentArray[28].ColStart, 50);
Assert.AreEqual(fragmentArray[28].ColEnd, 50);
Assert.AreEqual(fragmentArray[27].CodeType, CodeFragment.Type.Local);
Assert.AreEqual(fragmentArray[27].Text, "j");
Assert.AreEqual(fragmentArray[27].Line, 0);
Assert.AreEqual(fragmentArray[27].ColStart, 48);
Assert.AreEqual(fragmentArray[27].ColEnd, 48);
Assert.AreEqual(fragmentArray[18].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[18].Text, "(");
Assert.AreEqual(fragmentArray[18].Line, 0);
Assert.AreEqual(fragmentArray[18].ColStart, 61);
Assert.AreEqual(fragmentArray[18].ColEnd, 61);
Assert.AreEqual(fragmentArray[19].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[19].Text, ")");
Assert.AreEqual(fragmentArray[19].Line, 0);
Assert.AreEqual(fragmentArray[19].ColStart, 68);
Assert.AreEqual(fragmentArray[19].ColEnd, 68);
Assert.AreEqual(fragmentArray[20].CodeType, CodeFragment.Type.Local);
Assert.AreEqual(fragmentArray[20].Text, "i");
Assert.AreEqual(fragmentArray[20].Line, 0);
Assert.AreEqual(fragmentArray[20].ColStart, 62);
Assert.AreEqual(fragmentArray[20].ColEnd, 62);
Assert.AreEqual(fragmentArray[21].CodeType, CodeFragment.Type.Number);
Assert.AreEqual(fragmentArray[21].Text, "2");
Assert.AreEqual(fragmentArray[21].Line, 0);
Assert.AreEqual(fragmentArray[21].ColStart, 67);
Assert.AreEqual(fragmentArray[21].ColEnd, 67);
Assert.AreEqual(fragmentArray[22].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[22].Text, "==");
Assert.AreEqual(fragmentArray[22].Line, 0);
Assert.AreEqual(fragmentArray[22].ColStart, 64);
Assert.AreEqual(fragmentArray[22].ColEnd, 65);
Assert.AreEqual(fragmentArray[23].CodeType, CodeFragment.Type.Local);
Assert.AreEqual(fragmentArray[23].Text, "a");
Assert.AreEqual(fragmentArray[23].Line, 0);
Assert.AreEqual(fragmentArray[23].ColStart, 72);
Assert.AreEqual(fragmentArray[23].ColEnd, 72);
Assert.AreEqual(fragmentArray[24].CodeType, CodeFragment.Type.Local);
Assert.AreEqual(fragmentArray[24].Text, "b");
Assert.AreEqual(fragmentArray[24].Line, 0);
Assert.AreEqual(fragmentArray[24].ColStart, 76);
Assert.AreEqual(fragmentArray[24].ColEnd, 76);
Assert.AreEqual(fragmentArray[25].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[25].Text, "?");
Assert.AreEqual(fragmentArray[25].Line, 0);
Assert.AreEqual(fragmentArray[25].ColStart, 70);
Assert.AreEqual(fragmentArray[25].ColEnd, 70);
Assert.AreEqual(fragmentArray[26].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[26].Text, ":");
Assert.AreEqual(fragmentArray[26].Line, 0);
Assert.AreEqual(fragmentArray[26].ColStart, 74);
Assert.AreEqual(fragmentArray[26].ColEnd, 74);
}
public void TestAssociativeImportNode()
{
string content = "import (filename); ";
Scanner scanner = new Scanner(ConvertToStream(content));
parser = new DesignScript.Parser.Parser(scanner, core);
parser.Parse();
nodeProcessor = new NodeProcessor(parser.root.Body);
nodeProcessor.GenerateFragments(out fragmentArray);
Assert.AreEqual(fragmentArray.Length, 5);
Assert.AreEqual(fragmentArray[0].CodeType, CodeFragment.Type.Keyword);
Assert.AreEqual(fragmentArray[0].Text, "import");
Assert.AreEqual(fragmentArray[0].Line, 0);
Assert.AreEqual(fragmentArray[0].ColStart, 0);
Assert.AreEqual(fragmentArray[0].ColEnd, 5);
Assert.AreEqual(fragmentArray[1].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[1].Text, "(");
Assert.AreEqual(fragmentArray[1].Line, 0);
Assert.AreEqual(fragmentArray[1].ColStart, 7);
Assert.AreEqual(fragmentArray[1].ColEnd, 7);
Assert.AreEqual(fragmentArray[2].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[2].Text, ")");
Assert.AreEqual(fragmentArray[2].Line, 0);
Assert.AreEqual(fragmentArray[2].ColStart, 16);
Assert.AreEqual(fragmentArray[2].ColEnd, 16);
Assert.AreEqual(fragmentArray[3].CodeType, CodeFragment.Type.Local);
Assert.AreEqual(fragmentArray[3].Text, "filename");
Assert.AreEqual(fragmentArray[3].Line, 0);
Assert.AreEqual(fragmentArray[3].ColStart, 8);
Assert.AreEqual(fragmentArray[3].ColEnd, 15);
Assert.AreEqual(fragmentArray[4].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[4].Text, ";");
Assert.AreEqual(fragmentArray[4].Line, 0);
Assert.AreEqual(fragmentArray[4].ColStart, 17);
Assert.AreEqual(fragmentArray[4].ColEnd, 17);
}
public void TestAssociativeCommentNode()
{
string content = "//test";
Scanner scanner = new Scanner(ConvertToStream(content));
parser = new DesignScript.Parser.Parser(scanner, core);
parser.Parse();
nodeProcessor = new NodeProcessor(parser.root.Body);
nodeProcessor.GenerateFragments(out fragmentArray);
Assert.AreEqual(fragmentArray.Length, 1);
Assert.AreEqual(fragmentArray[0].CodeType, CodeFragment.Type.Comment);
Assert.AreEqual(fragmentArray[0].Text, "//test");
Assert.AreEqual(fragmentArray[0].Line, 0);
Assert.AreEqual(fragmentArray[0].ColStart, 0);
Assert.AreEqual(fragmentArray[0].ColEnd, 5);
}
public void TestAssociativeParenExpressionNode()
{
string content = "[Associative] a=(b+c);";
Scanner scanner = new Scanner(ConvertToStream(content));
parser = new DesignScript.Parser.Parser(scanner, core);
parser.Parse();
nodeProcessor = new NodeProcessor(parser.root.Body);
nodeProcessor.GenerateFragments(out fragmentArray);
Assert.AreEqual(fragmentArray.Length, 11);
Assert.AreEqual(fragmentArray[5].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[5].Text, "(");
Assert.AreEqual(fragmentArray[5].Line, 0);
Assert.AreEqual(fragmentArray[5].ColStart, 16);
Assert.AreEqual(fragmentArray[5].ColEnd, 16);
Assert.AreEqual(fragmentArray[6].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[6].Text, ")");
Assert.AreEqual(fragmentArray[6].Line, 0);
Assert.AreEqual(fragmentArray[6].ColStart, 20);
Assert.AreEqual(fragmentArray[6].ColEnd, 20);
Assert.AreEqual(fragmentArray[7].CodeType, CodeFragment.Type.Local);
Assert.AreEqual(fragmentArray[7].Text, "b");
Assert.AreEqual(fragmentArray[7].Line, 0);
Assert.AreEqual(fragmentArray[7].ColStart, 17);
Assert.AreEqual(fragmentArray[7].ColEnd, 17);
Assert.AreEqual(fragmentArray[8].CodeType, CodeFragment.Type.Local);
Assert.AreEqual(fragmentArray[8].Text, "c");
Assert.AreEqual(fragmentArray[8].Line, 0);
Assert.AreEqual(fragmentArray[8].ColStart, 19);
Assert.AreEqual(fragmentArray[8].ColEnd, 19);
Assert.AreEqual(fragmentArray[9].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[9].Text, "+");
Assert.AreEqual(fragmentArray[9].Line, 0);
Assert.AreEqual(fragmentArray[9].ColStart, 18);
Assert.AreEqual(fragmentArray[9].ColEnd, 18);
Assert.AreEqual(fragmentArray[10].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[10].Text, "=");
Assert.AreEqual(fragmentArray[10].Line, 0);
Assert.AreEqual(fragmentArray[10].ColStart, 15);
Assert.AreEqual(fragmentArray[10].ColEnd, 15);
}
public void TestAssociativeExpressionListNode()
{
//somelist[] = {11,102,1003,1004};
string content = "[Associative] somelist[] = {11,102,1003,1004};";
Scanner scanner = new Scanner(ConvertToStream(content));
parser = new DesignScript.Parser.Parser(scanner, core);
parser.Parse();
nodeProcessor = new NodeProcessor(parser.root.Body);
nodeProcessor.GenerateFragments(out fragmentArray);
Assert.AreEqual(fragmentArray.Length, 17);
Assert.AreEqual(fragmentArray[7].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[7].Text, ",");
Assert.AreEqual(fragmentArray[7].Line, 0);
Assert.AreEqual(fragmentArray[7].ColStart, 30);
Assert.AreEqual(fragmentArray[7].ColEnd, 30);
Assert.AreEqual(fragmentArray[8].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[8].Text, ",");
Assert.AreEqual(fragmentArray[8].Line, 0);
Assert.AreEqual(fragmentArray[8].ColStart, 34);
Assert.AreEqual(fragmentArray[8].ColEnd, 34);
Assert.AreEqual(fragmentArray[9].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[9].Text, ",");
Assert.AreEqual(fragmentArray[9].Line, 0);
Assert.AreEqual(fragmentArray[9].ColStart, 39);
Assert.AreEqual(fragmentArray[9].ColEnd, 39);
Assert.AreEqual(fragmentArray[10].CodeType, CodeFragment.Type.Number);
Assert.AreEqual(fragmentArray[10].Text, "11");
Assert.AreEqual(fragmentArray[10].Line, 0);
Assert.AreEqual(fragmentArray[10].ColStart, 28);
Assert.AreEqual(fragmentArray[10].ColEnd, 29);
Assert.AreEqual(fragmentArray[11].CodeType, CodeFragment.Type.Number);
Assert.AreEqual(fragmentArray[11].Text, "102");
Assert.AreEqual(fragmentArray[11].Line, 0);
Assert.AreEqual(fragmentArray[11].ColStart, 31);
Assert.AreEqual(fragmentArray[11].ColEnd, 33);
Assert.AreEqual(fragmentArray[12].CodeType, CodeFragment.Type.Number);
Assert.AreEqual(fragmentArray[12].Text, "1003");
Assert.AreEqual(fragmentArray[12].Line, 0);
Assert.AreEqual(fragmentArray[12].ColStart, 35);
Assert.AreEqual(fragmentArray[12].ColEnd, 38);
Assert.AreEqual(fragmentArray[13].CodeType, CodeFragment.Type.Number);
Assert.AreEqual(fragmentArray[13].Text, "1004");
Assert.AreEqual(fragmentArray[13].Line, 0);
Assert.AreEqual(fragmentArray[13].ColStart, 40);
Assert.AreEqual(fragmentArray[13].ColEnd, 43);
Assert.AreEqual(fragmentArray[14].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[14].Text, "{");
Assert.AreEqual(fragmentArray[14].Line, 0);
Assert.AreEqual(fragmentArray[14].ColStart, 27);
Assert.AreEqual(fragmentArray[14].ColEnd, 27);
Assert.AreEqual(fragmentArray[15].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[15].Text, "}");
Assert.AreEqual(fragmentArray[15].Line, 0);
Assert.AreEqual(fragmentArray[15].ColStart, 44);
Assert.AreEqual(fragmentArray[15].ColEnd, 44);
}
public void TestAssociativeRangeExpNode()
{
//a = 1..100..#1;
string content = "[Associative] a = 1..100..#1;";
Scanner scanner = new Scanner(ConvertToStream(content));
parser = new DesignScript.Parser.Parser(scanner, core);
parser.Parse();
nodeProcessor = new NodeProcessor(parser.root.Body);
nodeProcessor.GenerateFragments(out fragmentArray);
Assert.AreEqual(fragmentArray.Length, 12);
Assert.AreEqual(fragmentArray[5].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[5].Text, "..");
Assert.AreEqual(fragmentArray[5].Line, 0);
Assert.AreEqual(fragmentArray[5].ColStart, 19);
Assert.AreEqual(fragmentArray[5].ColEnd, 20);
Assert.AreEqual(fragmentArray[6].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[6].Text, "..");
Assert.AreEqual(fragmentArray[6].Line, 0);
Assert.AreEqual(fragmentArray[6].ColStart, 24);
Assert.AreEqual(fragmentArray[6].ColEnd, 25);
Assert.AreEqual(fragmentArray[7].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[7].Text, "#");
Assert.AreEqual(fragmentArray[7].Line, 0);
Assert.AreEqual(fragmentArray[7].ColStart, 26);
Assert.AreEqual(fragmentArray[7].ColEnd, 26);
Assert.AreEqual(fragmentArray[8].CodeType, CodeFragment.Type.Number);
Assert.AreEqual(fragmentArray[8].Text, "100");
Assert.AreEqual(fragmentArray[8].Line, 0);
Assert.AreEqual(fragmentArray[8].ColStart, 21);
Assert.AreEqual(fragmentArray[8].ColEnd, 23);
Assert.AreEqual(fragmentArray[9].CodeType, CodeFragment.Type.Number);
Assert.AreEqual(fragmentArray[9].Text, "1");
Assert.AreEqual(fragmentArray[9].Line, 0);
Assert.AreEqual(fragmentArray[9].ColStart, 27);
Assert.AreEqual(fragmentArray[9].ColEnd, 27);
Assert.AreEqual(fragmentArray[10].CodeType, CodeFragment.Type.Number);
Assert.AreEqual(fragmentArray[10].Text, "1");
Assert.AreEqual(fragmentArray[10].Line, 0);
Assert.AreEqual(fragmentArray[10].ColStart, 18);
Assert.AreEqual(fragmentArray[10].ColEnd, 18);
}
public void TestAssociativeFunctionCallNode()
{
string content = "[Associative] aVar = func(a, b, c);";
Scanner scanner = new Scanner(ConvertToStream(content));
parser = new DesignScript.Parser.Parser(scanner, core);
parser.Parse();
nodeProcessor = new NodeProcessor(parser.root.Body);
nodeProcessor.GenerateFragments(out fragmentArray);
Assert.AreEqual(fragmentArray.Length, 14);
Assert.AreEqual(fragmentArray[5].CodeType, CodeFragment.Type.Function);
Assert.AreEqual(fragmentArray[5].Text, "func");
Assert.AreEqual(fragmentArray[5].Line, 0);
Assert.AreEqual(fragmentArray[5].ColStart, 21);
Assert.AreEqual(fragmentArray[5].ColEnd, 24);
Assert.AreEqual(fragmentArray[6].CodeType, CodeFragment.Type.Local);
Assert.AreEqual(fragmentArray[6].Text, "a");
Assert.AreEqual(fragmentArray[6].Line, 0);
Assert.AreEqual(fragmentArray[6].ColStart, 26);
Assert.AreEqual(fragmentArray[6].ColEnd, 26);
Assert.AreEqual(fragmentArray[7].CodeType, CodeFragment.Type.Local);
Assert.AreEqual(fragmentArray[7].Text, "b");
Assert.AreEqual(fragmentArray[7].Line, 0);
Assert.AreEqual(fragmentArray[7].ColStart, 29);
Assert.AreEqual(fragmentArray[7].ColEnd, 29);
Assert.AreEqual(fragmentArray[8].CodeType, CodeFragment.Type.Local);
Assert.AreEqual(fragmentArray[8].Text, "c");
Assert.AreEqual(fragmentArray[8].Line, 0);
Assert.AreEqual(fragmentArray[8].ColStart, 32);
Assert.AreEqual(fragmentArray[8].ColEnd, 32);
Assert.AreEqual(fragmentArray[9].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[9].Text, ",");
Assert.AreEqual(fragmentArray[9].Line, 0);
Assert.AreEqual(fragmentArray[9].ColStart, 27);
Assert.AreEqual(fragmentArray[9].ColEnd, 27);
Assert.AreEqual(fragmentArray[10].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[10].Text, ",");
Assert.AreEqual(fragmentArray[10].Line, 0);
Assert.AreEqual(fragmentArray[10].ColStart, 30);
Assert.AreEqual(fragmentArray[10].ColEnd, 30);
Assert.AreEqual(fragmentArray[11].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[11].Text, "(");
Assert.AreEqual(fragmentArray[11].Line, 0);
Assert.AreEqual(fragmentArray[11].ColStart, 25);
Assert.AreEqual(fragmentArray[11].ColEnd, 25);
Assert.AreEqual(fragmentArray[12].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[12].Text, ")");
Assert.AreEqual(fragmentArray[12].Line, 0);
Assert.AreEqual(fragmentArray[12].ColStart, 33);
Assert.AreEqual(fragmentArray[12].ColEnd, 33);
}
public void TestAssociativeReplicationGuides()
{
//[Associative]
//{
// a = { 1, 2 };
// b = { 2, 3 };
// c = a<1> + b<2>;
//}
string content = "[Associative]{ a = { 1, 2 }; b = { 2, 3 }; c = a<1> + b<2>; }";
Scanner scanner = new Scanner(ConvertToStream(content));
parser = new DesignScript.Parser.Parser(scanner, core);
parser.Parse();
nodeProcessor = new NodeProcessor(parser.root.Body);
nodeProcessor.GenerateFragments(out fragmentArray);
Assert.AreEqual(fragmentArray.Length, 33);
Assert.AreEqual(fragmentArray[22].CodeType, CodeFragment.Type.Local);
Assert.AreEqual(fragmentArray[22].Text, "c");
Assert.AreEqual(fragmentArray[22].Line, 0);
Assert.AreEqual(fragmentArray[22].ColStart, 43);
Assert.AreEqual(fragmentArray[22].ColEnd, 43);
Assert.AreEqual(fragmentArray[23].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[23].Text, "<");
Assert.AreEqual(fragmentArray[23].Line, 0);
Assert.AreEqual(fragmentArray[23].ColStart, 48);
Assert.AreEqual(fragmentArray[23].ColEnd, 48);
Assert.AreEqual(fragmentArray[24].CodeType, CodeFragment.Type.Number);
Assert.AreEqual(fragmentArray[24].Text, "1");
Assert.AreEqual(fragmentArray[24].Line, 0);
Assert.AreEqual(fragmentArray[24].ColStart, 49);
Assert.AreEqual(fragmentArray[24].ColEnd, 49);
Assert.AreEqual(fragmentArray[25].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[25].Text, ">");
Assert.AreEqual(fragmentArray[25].Line, 0);
Assert.AreEqual(fragmentArray[25].ColStart, 50);
Assert.AreEqual(fragmentArray[25].ColEnd, 50);
Assert.AreEqual(fragmentArray[26].CodeType, CodeFragment.Type.Local);
Assert.AreEqual(fragmentArray[26].Text, "a");
Assert.AreEqual(fragmentArray[26].Line, 0);
Assert.AreEqual(fragmentArray[26].ColStart, 47);
Assert.AreEqual(fragmentArray[26].ColEnd, 47);
Assert.AreEqual(fragmentArray[27].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[27].Text, "<");
Assert.AreEqual(fragmentArray[27].Line, 0);
Assert.AreEqual(fragmentArray[27].ColStart, 55);
Assert.AreEqual(fragmentArray[27].ColEnd, 55);
Assert.AreEqual(fragmentArray[28].CodeType, CodeFragment.Type.Number);
Assert.AreEqual(fragmentArray[28].Text, "2");
Assert.AreEqual(fragmentArray[28].Line, 0);
Assert.AreEqual(fragmentArray[28].ColStart, 56);
Assert.AreEqual(fragmentArray[28].ColEnd, 56);
Assert.AreEqual(fragmentArray[29].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[29].Text, ">");
Assert.AreEqual(fragmentArray[29].Line, 0);
Assert.AreEqual(fragmentArray[29].ColStart, 57);
Assert.AreEqual(fragmentArray[29].ColEnd, 57);
Assert.AreEqual(fragmentArray[30].CodeType, CodeFragment.Type.Local);
Assert.AreEqual(fragmentArray[30].Text, "b");
Assert.AreEqual(fragmentArray[30].Line, 0);
Assert.AreEqual(fragmentArray[30].ColStart, 54);
Assert.AreEqual(fragmentArray[30].ColEnd, 54);
Assert.AreEqual(fragmentArray[31].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[31].Text, "+");
Assert.AreEqual(fragmentArray[31].Line, 0);
Assert.AreEqual(fragmentArray[31].ColStart, 52);
Assert.AreEqual(fragmentArray[31].ColEnd, 52);
Assert.AreEqual(fragmentArray[32].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[32].Text, "=");
Assert.AreEqual(fragmentArray[32].Line, 0);
Assert.AreEqual(fragmentArray[32].ColStart, 45);
Assert.AreEqual(fragmentArray[32].ColEnd, 45);
}
public void TestAssociativeFunctionDefinitionNode()
{
//def func : int (a : int, b : double, c : int){result = a + b * c;}
string content = "[Associative] def func : int (a : int, b : double, c : int){result = a + b * c;}";
Scanner scanner = new Scanner(ConvertToStream(content));
parser = new DesignScript.Parser.Parser(scanner, core);
parser.Parse();
nodeProcessor = new NodeProcessor(parser.root.Body);
nodeProcessor.GenerateFragments(out fragmentArray);
Assert.AreEqual(fragmentArray.Length, 30);
Assert.AreEqual(fragmentArray[3].CodeType, CodeFragment.Type.Keyword);
Assert.AreEqual(fragmentArray[3].Text, "def");
Assert.AreEqual(fragmentArray[3].Line, 0);
Assert.AreEqual(fragmentArray[3].ColStart, 14);// Expected 15 check!! It is 13
Assert.AreEqual(fragmentArray[3].ColEnd, 16);
Assert.AreEqual(fragmentArray[4].CodeType, CodeFragment.Type.Function);
Assert.AreEqual(fragmentArray[4].Text, "func");
Assert.AreEqual(fragmentArray[4].Line, 0);
Assert.AreEqual(fragmentArray[4].ColStart, 18);
Assert.AreEqual(fragmentArray[4].ColEnd, 21);
Assert.AreEqual(fragmentArray[5].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[5].Text, "}");
Assert.AreEqual(fragmentArray[5].Line, 0);
Assert.AreEqual(fragmentArray[5].ColStart, 79);
Assert.AreEqual(fragmentArray[5].ColEnd, 79);
Assert.AreEqual(fragmentArray[6].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[6].Text, "{");
Assert.AreEqual(fragmentArray[6].Line, 0);
Assert.AreEqual(fragmentArray[6].ColStart, 59);
Assert.AreEqual(fragmentArray[6].ColEnd, 59);
Assert.AreEqual(fragmentArray[7].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[7].Text, ";");
Assert.AreEqual(fragmentArray[7].Line, 0);
Assert.AreEqual(fragmentArray[7].ColStart, 78);
Assert.AreEqual(fragmentArray[7].ColEnd, 78);
Assert.AreEqual(fragmentArray[8].CodeType, CodeFragment.Type.Local);
Assert.AreEqual(fragmentArray[8].Text, "result");
Assert.AreEqual(fragmentArray[8].Line, 0);
Assert.AreEqual(fragmentArray[8].ColStart, 60);//Another one should be 64!!
Assert.AreEqual(fragmentArray[8].ColEnd, 65);
Assert.AreEqual(fragmentArray[9].CodeType, CodeFragment.Type.Local);
Assert.AreEqual(fragmentArray[9].Text, "a");
Assert.AreEqual(fragmentArray[9].Line, 0);
Assert.AreEqual(fragmentArray[9].ColStart, 69);
Assert.AreEqual(fragmentArray[9].ColEnd, 69);
Assert.AreEqual(fragmentArray[10].CodeType, CodeFragment.Type.Local);
Assert.AreEqual(fragmentArray[10].Text, "b");
Assert.AreEqual(fragmentArray[10].Line, 0);
Assert.AreEqual(fragmentArray[10].ColStart, 73);
Assert.AreEqual(fragmentArray[10].ColEnd, 73);
Assert.AreEqual(fragmentArray[11].CodeType, CodeFragment.Type.Local);
Assert.AreEqual(fragmentArray[11].Text, "c");
Assert.AreEqual(fragmentArray[11].Line, 0);
Assert.AreEqual(fragmentArray[11].ColStart, 77);
Assert.AreEqual(fragmentArray[11].ColEnd, 77);
Assert.AreEqual(fragmentArray[12].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[12].Text, "*");
Assert.AreEqual(fragmentArray[12].Line, 0);
Assert.AreEqual(fragmentArray[12].ColStart, 75);
Assert.AreEqual(fragmentArray[12].ColEnd, 75);
Assert.AreEqual(fragmentArray[13].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[13].Text, "+");
Assert.AreEqual(fragmentArray[13].Line, 0);
Assert.AreEqual(fragmentArray[13].ColStart, 71);
Assert.AreEqual(fragmentArray[13].ColEnd, 71);
Assert.AreEqual(fragmentArray[14].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[14].Text, "=");
Assert.AreEqual(fragmentArray[14].Line, 0);
Assert.AreEqual(fragmentArray[14].ColStart, 67);
Assert.AreEqual(fragmentArray[14].ColEnd, 67);
Assert.AreEqual(fragmentArray[15].CodeType, CodeFragment.Type.Local);
Assert.AreEqual(fragmentArray[15].Text, "a");
Assert.AreEqual(fragmentArray[15].Line, 0);
Assert.AreEqual(fragmentArray[15].ColStart, 30);
Assert.AreEqual(fragmentArray[15].ColEnd, 30);
Assert.AreEqual(fragmentArray[16].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[16].Text, ":");
Assert.AreEqual(fragmentArray[16].Line, 0);
Assert.AreEqual(fragmentArray[16].ColStart, 32);
Assert.AreEqual(fragmentArray[16].ColEnd, 32);
Assert.AreEqual(fragmentArray[17].CodeType, CodeFragment.Type.Keyword);
Assert.AreEqual(fragmentArray[17].Text, "int");
Assert.AreEqual(fragmentArray[17].Line, 0);
Assert.AreEqual(fragmentArray[17].ColStart, 34);
Assert.AreEqual(fragmentArray[17].ColEnd, 36);
Assert.AreEqual(fragmentArray[18].CodeType, CodeFragment.Type.Local);
Assert.AreEqual(fragmentArray[18].Text, "b");
Assert.AreEqual(fragmentArray[18].Line, 0);
Assert.AreEqual(fragmentArray[18].ColStart, 39);
Assert.AreEqual(fragmentArray[18].ColEnd, 39);
Assert.AreEqual(fragmentArray[19].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[19].Text, ":");
Assert.AreEqual(fragmentArray[19].Line, 0);
Assert.AreEqual(fragmentArray[19].ColStart, 41);
Assert.AreEqual(fragmentArray[19].ColEnd, 41);
Assert.AreEqual(fragmentArray[20].CodeType, CodeFragment.Type.Keyword);
Assert.AreEqual(fragmentArray[20].Text, "double");
Assert.AreEqual(fragmentArray[20].Line, 0);
Assert.AreEqual(fragmentArray[20].ColStart, 43);
Assert.AreEqual(fragmentArray[20].ColEnd, 48);
Assert.AreEqual(fragmentArray[21].CodeType, CodeFragment.Type.Local);
Assert.AreEqual(fragmentArray[21].Text, "c");
Assert.AreEqual(fragmentArray[21].Line, 0);
Assert.AreEqual(fragmentArray[21].ColStart, 51);
Assert.AreEqual(fragmentArray[21].ColEnd, 51);
Assert.AreEqual(fragmentArray[22].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[22].Text, ":");
Assert.AreEqual(fragmentArray[22].Line, 0);
Assert.AreEqual(fragmentArray[22].ColStart, 53);
Assert.AreEqual(fragmentArray[22].ColEnd, 53);
Assert.AreEqual(fragmentArray[23].CodeType, CodeFragment.Type.Keyword);
Assert.AreEqual(fragmentArray[23].Text, "int");
Assert.AreEqual(fragmentArray[23].Line, 0);
Assert.AreEqual(fragmentArray[23].ColStart, 55);
Assert.AreEqual(fragmentArray[23].ColEnd, 57);
Assert.AreEqual(fragmentArray[24].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[24].Text, ")");
Assert.AreEqual(fragmentArray[24].Line, 0);
Assert.AreEqual(fragmentArray[24].ColStart, 58);
Assert.AreEqual(fragmentArray[24].ColEnd, 58);
Assert.AreEqual(fragmentArray[25].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[25].Text, "(");
Assert.AreEqual(fragmentArray[25].Line, 0);
Assert.AreEqual(fragmentArray[25].ColStart, 29);
Assert.AreEqual(fragmentArray[25].ColEnd, 29);
Assert.AreEqual(fragmentArray[26].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[26].Text, ",");
Assert.AreEqual(fragmentArray[26].Line, 0);
Assert.AreEqual(fragmentArray[26].ColStart, 37);
Assert.AreEqual(fragmentArray[26].ColEnd, 37);
Assert.AreEqual(fragmentArray[27].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[27].Text, ",");
Assert.AreEqual(fragmentArray[27].Line, 0);
Assert.AreEqual(fragmentArray[27].ColStart, 49);
Assert.AreEqual(fragmentArray[27].ColEnd, 49);
Assert.AreEqual(fragmentArray[28].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[28].Text, ":");
Assert.AreEqual(fragmentArray[28].Line, 0);
Assert.AreEqual(fragmentArray[28].ColStart, 23);
Assert.AreEqual(fragmentArray[28].ColEnd, 23);
Assert.AreEqual(fragmentArray[29].CodeType, CodeFragment.Type.Keyword);
Assert.AreEqual(fragmentArray[29].Text, "int");
Assert.AreEqual(fragmentArray[29].Line, 0);
Assert.AreEqual(fragmentArray[29].ColStart, 25);
Assert.AreEqual(fragmentArray[29].ColEnd, 27);
}
public void TestAssociativeReplicationGuidesWithRangeExpr()
{
//[Associative]
//{
// x = 1..4;
// y = 5..8;
// d = (1..4) < 1 >..y < 2 > ..2;
//}
string content = "[Associative]{ x = 1..4; y = 5..8; d = (1..4)<1>..y<2>..2; }";
Scanner scanner = new Scanner(ConvertToStream(content));
parser = new DesignScript.Parser.Parser(scanner, core);
parser.Parse();
nodeProcessor = new NodeProcessor(parser.root.Body);
nodeProcessor.GenerateFragments(out fragmentArray);
Assert.AreEqual(fragmentArray.Length, 35);
Assert.AreEqual(fragmentArray[19].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[19].Text, "..");
Assert.AreEqual(fragmentArray[19].Line, 0);
Assert.AreEqual(fragmentArray[19].ColStart, 48);
Assert.AreEqual(fragmentArray[19].ColEnd, 49);
Assert.AreEqual(fragmentArray[20].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[20].Text, "..");
Assert.AreEqual(fragmentArray[20].Line, 0);
Assert.AreEqual(fragmentArray[20].ColStart, 54);
Assert.AreEqual(fragmentArray[20].ColEnd, 55);
Assert.AreEqual(fragmentArray[21].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[21].Text, "<");
Assert.AreEqual(fragmentArray[21].Line, 0);
Assert.AreEqual(fragmentArray[21].ColStart, 51);
Assert.AreEqual(fragmentArray[21].ColEnd, 51);
Assert.AreEqual(fragmentArray[22].CodeType, CodeFragment.Type.Number);
Assert.AreEqual(fragmentArray[22].Text, "2");
Assert.AreEqual(fragmentArray[22].Line, 0);
Assert.AreEqual(fragmentArray[22].ColStart, 52);
Assert.AreEqual(fragmentArray[22].ColEnd, 52);
Assert.AreEqual(fragmentArray[23].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[23].Text, ">");
Assert.AreEqual(fragmentArray[23].Line, 0);
Assert.AreEqual(fragmentArray[23].ColStart, 53);
Assert.AreEqual(fragmentArray[23].ColEnd, 53);
Assert.AreEqual(fragmentArray[24].CodeType, CodeFragment.Type.Local);
Assert.AreEqual(fragmentArray[24].Text, "y");
Assert.AreEqual(fragmentArray[24].Line, 0);
Assert.AreEqual(fragmentArray[24].ColStart, 50);
Assert.AreEqual(fragmentArray[24].ColEnd, 50);
Assert.AreEqual(fragmentArray[25].CodeType, CodeFragment.Type.Number);
Assert.AreEqual(fragmentArray[25].Text, "2");
Assert.AreEqual(fragmentArray[25].Line, 0);
Assert.AreEqual(fragmentArray[25].ColStart, 56);
Assert.AreEqual(fragmentArray[25].ColEnd, 56);
Assert.AreEqual(fragmentArray[26].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[26].Text, "<");
Assert.AreEqual(fragmentArray[26].Line, 0);
Assert.AreEqual(fragmentArray[26].ColStart, 45);
Assert.AreEqual(fragmentArray[26].ColEnd, 45);
Assert.AreEqual(fragmentArray[27].CodeType, CodeFragment.Type.Number);
Assert.AreEqual(fragmentArray[27].Text, "1");
Assert.AreEqual(fragmentArray[27].Line, 0);
Assert.AreEqual(fragmentArray[27].ColStart, 46);
Assert.AreEqual(fragmentArray[27].ColEnd, 46);
Assert.AreEqual(fragmentArray[28].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[28].Text, ">");
Assert.AreEqual(fragmentArray[28].Line, 0);
Assert.AreEqual(fragmentArray[28].ColStart, 47);
Assert.AreEqual(fragmentArray[28].ColEnd, 47);
Assert.AreEqual(fragmentArray[29].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[29].Text, "(");
Assert.AreEqual(fragmentArray[29].Line, 0);
Assert.AreEqual(fragmentArray[29].ColStart, 39);
Assert.AreEqual(fragmentArray[29].ColEnd, 39);
Assert.AreEqual(fragmentArray[30].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[30].Text, ")");
Assert.AreEqual(fragmentArray[30].Line, 0);
Assert.AreEqual(fragmentArray[30].ColStart, 44);
Assert.AreEqual(fragmentArray[30].ColEnd, 44);
Assert.AreEqual(fragmentArray[31].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[31].Text, "..");
Assert.AreEqual(fragmentArray[31].Line, 0);
Assert.AreEqual(fragmentArray[31].ColStart, 41);
Assert.AreEqual(fragmentArray[31].ColEnd, 42);
Assert.AreEqual(fragmentArray[32].CodeType, CodeFragment.Type.Number);
Assert.AreEqual(fragmentArray[32].Text, "4");
Assert.AreEqual(fragmentArray[32].Line, 0);
Assert.AreEqual(fragmentArray[32].ColStart, 43);
Assert.AreEqual(fragmentArray[32].ColEnd, 43);
Assert.AreEqual(fragmentArray[33].CodeType, CodeFragment.Type.Number);
Assert.AreEqual(fragmentArray[33].Text, "1");
Assert.AreEqual(fragmentArray[33].Line, 0);
Assert.AreEqual(fragmentArray[33].ColStart, 40);
Assert.AreEqual(fragmentArray[33].ColEnd, 40);
}
public void TestAssociativeIdentifierNode()
{
//a;
string content = "[Associative] a";
Scanner scanner = new Scanner(ConvertToStream(content));
parser = new DesignScript.Parser.Parser(scanner, core);
parser.Parse();
nodeProcessor = new NodeProcessor(parser.root.Body);
nodeProcessor.GenerateFragments(out fragmentArray);
Assert.AreEqual(fragmentArray.Length, 4);
Assert.AreEqual(fragmentArray[3].CodeType, CodeFragment.Type.Local);
Assert.AreEqual(fragmentArray[3].Text, "a");
Assert.AreEqual(fragmentArray[3].Line, 0);
Assert.AreEqual(fragmentArray[3].ColStart, 14);
Assert.AreEqual(fragmentArray[3].ColEnd, 14);
}
public void TestAssociativeTextNode()
{
//[Associative]
//{
// c = 'h';
// d = "This is an Assoc Block";
//}
string content = "[Associative]{ c = 'h'; d = \"This is an Assoc Block\"; }";
Scanner scanner = new Scanner(ConvertToStream(content));
parser = new DesignScript.Parser.Parser(scanner, core);
parser.Parse();
nodeProcessor = new NodeProcessor(parser.root.Body);
nodeProcessor.GenerateFragments(out fragmentArray);
Assert.AreEqual(fragmentArray.Length, 13);
Assert.AreEqual(fragmentArray[7].CodeType, CodeFragment.Type.Text);
Assert.AreEqual(fragmentArray[7].Text, "'h'");
Assert.AreEqual(fragmentArray[7].Line, 0);
Assert.AreEqual(fragmentArray[7].ColStart, 19);
Assert.AreEqual(fragmentArray[7].ColEnd, 21);
Assert.AreEqual(fragmentArray[11].CodeType, CodeFragment.Type.Text);
Assert.AreEqual(fragmentArray[11].Text, "\"This is an Assoc Block\"");
Assert.AreEqual(fragmentArray[11].Line, 0);
Assert.AreEqual(fragmentArray[11].ColStart, 28);
Assert.AreEqual(fragmentArray[11].ColEnd, 51);
}
public void TestAssociativeArrayNode()
{
//list[1]
string content = "[Associative] list[1] = 0;";
Scanner scanner = new Scanner(ConvertToStream(content));
parser = new DesignScript.Parser.Parser(scanner, core);
parser.Parse();
nodeProcessor = new NodeProcessor(parser.root.Body);
nodeProcessor.GenerateFragments(out fragmentArray);
Assert.AreEqual(fragmentArray.Length, 10);
Assert.AreEqual(fragmentArray[4].CodeType, CodeFragment.Type.Number);
Assert.AreEqual(fragmentArray[4].Text, "1");
Assert.AreEqual(fragmentArray[4].Line, 0);
Assert.AreEqual(fragmentArray[4].ColStart, 19);
Assert.AreEqual(fragmentArray[4].ColEnd, 19);
Assert.AreEqual(fragmentArray[5].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[5].Text, "[");
Assert.AreEqual(fragmentArray[5].Line, 0);
Assert.AreEqual(fragmentArray[5].ColStart, 18);
Assert.AreEqual(fragmentArray[5].ColEnd, 18);
Assert.AreEqual(fragmentArray[6].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[6].Text, "]");
Assert.AreEqual(fragmentArray[6].Line, 0);
Assert.AreEqual(fragmentArray[6].ColStart, 20);
Assert.AreEqual(fragmentArray[6].ColEnd, 20);
Assert.AreEqual(fragmentArray[7].CodeType, CodeFragment.Type.Local);
Assert.AreEqual(fragmentArray[7].Text, "list");
Assert.AreEqual(fragmentArray[7].Line, 0);
Assert.AreEqual(fragmentArray[7].ColStart, 14);
Assert.AreEqual(fragmentArray[7].ColEnd, 17);
Assert.AreEqual(fragmentArray[8].CodeType, CodeFragment.Type.Number);
Assert.AreEqual(fragmentArray[8].Text, "0");
Assert.AreEqual(fragmentArray[8].Line, 0);
Assert.AreEqual(fragmentArray[8].ColStart, 24);
Assert.AreEqual(fragmentArray[8].ColEnd, 24);
}
public void TestAssociativeUnaryExpressionNode()
{
string content = "[Associative] b=~a;";
Scanner scanner = new Scanner(ConvertToStream(content));
parser = new DesignScript.Parser.Parser(scanner, core);
parser.Parse();
nodeProcessor = new NodeProcessor(parser.root.Body);
nodeProcessor.GenerateFragments(out fragmentArray);
Assert.AreEqual(fragmentArray.Length, 8);
Assert.AreEqual(fragmentArray[3].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[3].Text, ";");
Assert.AreEqual(fragmentArray[3].Line, 0);
Assert.AreEqual(fragmentArray[3].ColStart, 18);
Assert.AreEqual(fragmentArray[3].ColEnd, 18);
Assert.AreEqual(fragmentArray[4].CodeType, CodeFragment.Type.Local);
Assert.AreEqual(fragmentArray[4].Text, "b");
Assert.AreEqual(fragmentArray[4].Line, 0);
Assert.AreEqual(fragmentArray[4].ColStart, 14);
Assert.AreEqual(fragmentArray[4].ColEnd, 14);
Assert.AreEqual(fragmentArray[5].CodeType, CodeFragment.Type.Local);
Assert.AreEqual(fragmentArray[5].Text, "a");
Assert.AreEqual(fragmentArray[5].Line, 0);
Assert.AreEqual(fragmentArray[5].ColStart, 17);
Assert.AreEqual(fragmentArray[5].ColEnd, 17);
Assert.AreEqual(fragmentArray[6].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[6].Text, "~");
Assert.AreEqual(fragmentArray[6].Line, 0);
Assert.AreEqual(fragmentArray[6].ColStart, 16);
Assert.AreEqual(fragmentArray[6].ColEnd, 16);
Assert.AreEqual(fragmentArray[7].CodeType, CodeFragment.Type.Punctuation);
Assert.AreEqual(fragmentArray[7].Text, "=");
Assert.AreEqual(fragmentArray[7].Line, 0);
Assert.AreEqual(fragmentArray[7].ColStart, 15);
Assert.AreEqual(fragmentArray[7].ColEnd, 15);
}
