public void Handle(KAOSCoreElement element, ParsedElement attribute)
{
foreach (var builder in attributeBuilders)
{
var genericArguments = builder.GetType().BaseType.GetGenericArguments();
if (genericArguments[0].IsAssignableFrom(element.GetType()) &&
genericArguments[1].IsAssignableFrom(attribute.GetType()))
{
var method = builder.GetType().GetMethod("Handle", new[] { genericArguments[0], genericArguments[1], typeof(KAOSModel) });
if (method == null)
{
throw new Exception("Cannot find method Handle with generic parameters.");
}
try
{
method.Invoke(builder, new object[] { element, attribute, model });
}
catch (TargetInvocationException e)
{
Console.WriteLine(e.InnerException);
throw e.InnerException;
}
}
}
}
public BuilderException(string message, ParsedElement element, Exception innerException = null)
: base(string.Format("{0}\nAt {1}:{2},{3}",
message,
element.Filename,
element.Line,
element.Col), innerException)
{
}
public virtual string AppendHorizontalRule(string text, ParsedElement element, IChildTagsFormatter childTagsFormatter)
{
if (text.Length > 0)
{
text = EndWithNewLine(text);
}
text += "<alpha=#b0><s><alpha=#00><align=flush> .</align></color></s></color>";
return(text);
}
public static string ParseMultiplicity(string identifier, ParsedElement secondParameter)
{
if (secondParameter is NParsedAttributeAtomic)
{
return(ParseMultiplicity(identifier, (NParsedAttributeAtomic)secondParameter));
}
throw new InvalidParameterAttributeException(identifier,
InvalidParameterAttributeException.ATOMIC_ONLY);
}
public Formula BuildPredicateFormula(KAOSTools.Core.Predicate p, ParsedElement value)
{
var dict = new Dictionary <string, KAOSTools.Core.Entity> ();
foreach (var attr in p.Arguments)
{
dict.Add(attr.Name, attr.Type);
}
return(BuildFormula(value, dict));
}
static void AddChild(NParsedAttributeAtomic value, List <string> v)
{
ParsedElement child = value.Value;
if (child is IdentifierExpression)
{
string identifier = ((IdentifierExpression)child).Value;
v.Add(identifier);
}
else
{
throw new ParserException();
}
}
void ParseRefinementPattern(ParsedElement parameter)
{
if (parameter is IdentifierExpression)
{
var patternId = ((IdentifierExpression)parameter).Value;
switch (patternId)
{
case "case":
parsedRefinementPattern = new ParsedRefinementPattern {
Name = ParsedRefinementPatternName.Case
};
break;
case "milestone":
parsedRefinementPattern = new ParsedRefinementPattern {
Name = ParsedRefinementPatternName.Milestone
};
break;
case "introduce_guard":
parsedRefinementPattern = new ParsedRefinementPattern {
Name = ParsedRefinementPatternName.IntroduceGuard
};
break;
case "divide_and_conquer":
parsedRefinementPattern = new ParsedRefinementPattern {
Name = ParsedRefinementPatternName.DivideAndConquer
};
break;
case "unmonitorability":
parsedRefinementPattern = new ParsedRefinementPattern {
Name = ParsedRefinementPatternName.Unmonitorability
};
break;
case "uncontrollability":
parsedRefinementPattern = new ParsedRefinementPattern {
Name = ParsedRefinementPatternName.Uncontrollability
};
break;
default:
throw new NotImplementedException("Refinement pattern '" + patternId + "' is not defined.");
}
}
}
private static string ParseDistributionName(string identifier, ParsedElement item)
{
string distribution_name = null;
if (item is IdentifierExpression)
{
distribution_name = ((IdentifierExpression)item).Value;
}
else
{
throw new InvalidAttributeValueException(identifier,
InvalidAttributeValueException.IDENTIFIER);
}
return(distribution_name);
}
private static void TestInvalidColonValueHelper(ParsedElement left, ParsedElement right)
{
var ap = new ArgumentAttributeParser();
const string attIdentifier = "argument";
var e = Assert.Catch(() => {
ap.ParsedAttribute(attIdentifier,
null,
new NParsedAttributeColon(left, right));
});
Assert.IsInstanceOf(typeof(InvalidAttributeValueException), e);
StringAssert.AreEqualIgnoringCase(
string.Format(InvalidAttributeValueException.IDENTIFIER, attIdentifier),
e.Message
);
}
void ParseParameter(string identifier, ParsedElement parameters)
{
if (parameters is NParsedAttributeAtomic)
{
var parameter = ((NParsedAttributeAtomic)parameters).Value;
ParseRefinementPattern(parameter);
}
else if (parameters is NParsedAttributeEqual)
{
var left = ((NParsedAttributeEqual)parameters).Left;
var right = ((NParsedAttributeEqual)parameters).Right;
if (left is IdentifierExpression ie)
{
if (ie.Value == "context" & (right is IdentifierExpression))
{
var ie2 = (IdentifierExpression)right;
contextIdentifier = ie2.Value;
}
else if (ie.Value == "pattern")
{
ParseRefinementPattern(right);
}
else
{
throw new NotImplementedException($"Parameter '{ie.Value}' was not recognized.");
}
}
else
{
throw new NotImplementedException($"Parameter '{left}' was not recognized.");
}
}
else if (parameters is NParsedAttributeList l)
{
foreach (var item in l.Values)
{
ParseParameter(identifier, item);
}
}
else
{
throw new NotImplementedException("Attribute '" + identifier + "' unrecognized parameter.");
}
}
private static void AddValueToList(string identifier, ParsedElement value, List <ParsedElement> v)
{
if (!(value is NParsedAttributeAtomic))
{
throw new InvalidAttributeValueException(identifier,
InvalidAttributeValueException.ATOMIC_ONLY);
}
var atomic = ((NParsedAttributeAtomic)value);
if (atomic.Value is IdentifierExpression)
{
v.Add(atomic.Value);
}
else
{
throw new InvalidAttributeValueException(identifier,
InvalidAttributeValueException.IDENTIFIER);
}
}
private IList <ParsedElement> ParseHtml(Uri uri)
{
if (SaveUri(uri))
{
var htmlCode = _dataProvider.GetFrom(uri.ToString()).Result;
var document = htmlParser.ParseDocument(htmlCode);
var parsedElement = new ParsedElement()
{
Content = htmlCode,
BaseName = uri.AbsolutePath.Length == 0 ? "index.html" : uri.AbsolutePath,
BaseFolder = _setting.SaveDir
};
var result = VisitTagA(document, uri);
result.Add(parsedElement);
return(result);
}
return(null);
}
private static List <double> ParseDistributionParameter(string identifier, ParsedElement param)
{
List <double> distribution_parameters = new List <double> ();
if (param is NParsedAttributeAtomic)
{
ParseDistributionParameter(identifier, distribution_parameters, ((NParsedAttributeAtomic)param).Value);
}
else if (param is NParsedAttributeList)
{
foreach (var p in ((NParsedAttributeList)param).Values)
{
ParseDistributionParameter(identifier, distribution_parameters, p);
}
}
else
{
throw new InvalidAttributeValueException(identifier,
InvalidAttributeValueException.ATOMIC_OR_LIST);
}
return(distribution_parameters);
}
static void ParseDistributionParameter(string identifier, List <double> distribution_parameters, ParsedElement p)
{
if (p is NParsedAttributeAtomic)
{
var pp = ((NParsedAttributeAtomic)p).Value;
if (pp is ParsedInteger)
{
distribution_parameters.Add(((ParsedInteger)pp).Value);
}
else if (pp is ParsedFloat)
{
distribution_parameters.Add(((ParsedFloat)pp).Value);
}
else if (pp is ParsedPercentage)
{
distribution_parameters.Add(((ParsedPercentage)pp).Value / 100d);
}
else
{
throw new InvalidAttributeValueException(identifier,
InvalidAttributeValueException.INVALID_VALUE);
}
}
else
{
throw new InvalidAttributeValueException(identifier,
InvalidAttributeValueException.ATOMIC_ONLY);
}
}
public Formula BuildFormula(ParsedElement value)
{
var declaredVariables = new Dictionary<string, Entity> ();
return BuildFormula (value, declaredVariables);
}
public Formula BuildFormula(ParsedElement value)
{
var declaredVariables = new Dictionary <string, Entity> ();
return(BuildFormula(value, declaredVariables));
}
public GivenTypeNotFound(string identifier, ParsedElement element)
: base("Given type '" + identifier + "' is not defined", element)
{
}
public EntityNotFound(string identifier, ParsedElement element)
: base("Entity '" + identifier + "' is not defined", element)
{
}
public Formula BuildPredicateFormula(KAOSTools.MetaModel.Predicate p, ParsedElement value)
{
var dict = new Dictionary<string, KAOSTools.MetaModel.Entity> ();
foreach (var attr in p.Arguments) {
dict.Add (attr.Name, attr.Type);
}
return BuildFormula (value, dict);
}
public ParsedSpec Run()
{
var vkXml = this.xmlCache.GetVkXml();
var knownExtensions = new List <string>();
foreach (var vkExtension in vkXml.Element("registry").Element("extensions").Elements("extension"))
{
string name = vkExtension.Attribute("name").Value;
var nameParts = name.Split('_');
string extensionSuffix = nameParts[1].ToLower();
if (!knownExtensions.Contains(extensionSuffix))
{
knownExtensions.Add(extensionSuffix);
}
}
var typeXml = new Dictionary <string, ParsedType>();
foreach (var vkType in vkXml.Element("registry").Element("types").Elements("type"))
{
string name = vkType.Attribute("name")?.Value ?? vkType.Element("name").Value;
var categoryAttribute = vkType.Attribute("category");
TypeCategory category = categoryAttribute == null
? TypeCategory.None
: (TypeCategory)Enum.Parse(typeof(TypeCategory), categoryAttribute.Value);
string requires = vkType.Attribute("requires")?.Value;
string parent = vkType.Attribute("parent")?.Value;
string returnedOnly = vkType.Attribute("returnedonly")?.Value;
bool isReturnedOnly = returnedOnly != null
? bool.Parse(returnedOnly)
: false;
bool isTypePointer = false;
string type = vkType.Element("type")?.Value;
if (type == "VK_MAKE_VERSION")
{
type += vkType.Element("type").NextNode.ToString();
}
if (category == TypeCategory.funcpointer)
{
type = ((XText)vkType.Nodes().First()).Value.Split(' ')[1];
if (type.EndsWith("*"))
{
type = type.TrimEnd('*');
isTypePointer = true;
}
}
string extension;
string[] nameParts = GetNameParts(category == TypeCategory.funcpointer ? name.Substring(4) : name, out extension, knownExtensions);
// VkDisplayModeKHR has two parents defined, but associated
// handle should cover the requirements for the second
// so just take the first
if (parent != null)
{
parent = parent.Split(',').First();
}
var newType = new ParsedType
{
VkName = name,
Category = category,
Requires = requires,
Parent = parent,
IsReturnedOnly = isReturnedOnly,
NameParts = nameParts,
Extension = extension,
Type = type,
IsTypePointer = isTypePointer
};
foreach (var vkMember in vkType.Elements("member"))
{
var nameElement = vkMember.Element("name");
string memberName = nameElement.Value;
string memberType = vkMember.Element("type").Value;
string optional = vkMember.Attribute("optional")?.Value;
bool isOptional = optional != null
? bool.Parse(optional)
: false;
ParsedFixedLength fixedLength = new ParsedFixedLength();
var typeNodes = nameElement.NodesBeforeSelf();
PointerType pointerType = GetPointerType(typeNodes);
if (nameElement.NodesAfterSelf().Any())
{
string enumName = vkMember.Element("enum")?.Value;
if (enumName != null)
{
fixedLength.Value = enumName;
fixedLength.Type = FixedLengthType.EnumReference;
}
else
{
fixedLength.Value = fixedLengthParser.Parse(nameElement.NextNode.ToString());
fixedLength.Type = FixedLengthType.IntegerLiteral;
}
}
else
{
int fixedLengthIndex = memberName.IndexOf('[');
if (fixedLengthIndex >= 0)
{
string fixedLengthString = memberName.Substring(fixedLengthIndex);
memberName = memberName.Substring(0, fixedLengthIndex);
fixedLength.Value = fixedLengthParser.Parse(fixedLengthString);
fixedLength.Type = FixedLengthType.IntegerLiteral;
}
}
string vkName = memberName;
int pointerCount = pointerType.GetPointerCount();
while (pointerCount > 0 && memberName.StartsWith("p"))
{
memberName = memberName.Substring(1);
pointerCount--;
}
ParsedLen[] dimensions = GetDimensions(name, vkMember, memberName);
// Capture member name without array suffix
string memberExtension;
string[] memberNameParts = GetNameParts(memberName, out memberExtension, knownExtensions, false);
string typeExtension;
string[] typeNameParts = GetNameParts(memberType, out typeExtension, knownExtensions, true);
string typeWithoutExtension = typeNameParts != null
? "Vk" + string.Join("", typeNameParts.Select(CapitaliseFirst))
: null;
string values = vkMember.Attribute("values")?.Value;
if (vkName == "sType" && values == null)
{
//HACK VkDebugReportLayerFlagsEXT doesn't specify a
// fixed value for the sType field, so it must be
// scraped from the following comment.
if (vkMember.NextNode != null)
{
// Split on spaces and skip "Must" & "be"
values = ((XComment)vkMember.NextNode).Value.Trim().Split(' ')[2];
}
}
newType.Members.Add(new ParsedMember
{
VkName = vkName,
Type = memberType,
TypeWithoutExtension = typeWithoutExtension,
TypeExtension = typeExtension,
IsOptional = isOptional,
FixedLength = fixedLength,
PointerType = pointerType,
NameParts = memberNameParts,
Extension = extension,
Dimensions = dimensions,
Values = values
});
}
// Special parsing is required for funcpointer parameters
if (category == TypeCategory.funcpointer)
{
var functionTail = vkType.Element("name").NodesAfterSelf();
foreach (var typeElement in functionTail.Where(x => x.NodeType == XmlNodeType.Element).Cast <XElement>())
{
string pre = ((XText)typeElement.PreviousNode).Value.Split(',').Last().Trim('(', ')', ';').TrimStart();
string post = ((XText)typeElement.NextNode).Value.Split(',').First().Trim('(', ')', ';').TrimEnd();
string paramName = new string(post.Reverse().TakeWhile(char.IsLetterOrDigit).Reverse().ToArray());
string typeString = pre + "@" + (post.Substring(0, post.Length - paramName.Length).Trim());
string paramType = typeElement.Value;
PointerType pointerType = MapTypeString(typeString);
string paramExtension;
string[] paramNameParts = GetNameParts(paramName, out paramExtension, knownExtensions, false);
newType.Members.Add(new ParsedMember
{
VkName = paramName,
Type = paramType,
PointerType = pointerType,
NameParts = paramNameParts,
Extension = paramExtension
});
}
}
typeXml.Add(name, newType);
}
var enumXml = new Dictionary <string, ParsedEnum>();
foreach (var vkEnum in vkXml.Element("registry").Elements("enums"))
{
string name = vkEnum.Attribute("name").Value;
string type = vkEnum.Attribute("type")?.Value;
string extension;
string[] nameParts = GetNameParts(name, out extension, knownExtensions);
var newEnum = new ParsedEnum
{
VkName = name,
Type = type,
NameParts = nameParts,
Extension = extension
};
foreach (var vkField in vkEnum.Elements("enum"))
{
string fieldName = vkField.Attribute("name").Value;
bool isBitmask = true;
string value = vkField.Attribute("bitpos")?.Value;
string comment = NormaliseComment(vkField.Attribute("comment")?.Value);
if (value == null)
{
isBitmask = false;
value = vkField.Attribute("value").Value;
// Special case for mapping C "unsigned long long"
// (64-bit unsigned integer) to C# UInt64
if (value == "(~0ULL)")
{
value = "(~0UL)";
}
value = value.Trim('(', ')');
}
IEnumerable <string> fieldNameParts = GetEnumFieldNameParts(nameParts, fieldName, knownExtensions);
newEnum.Fields.Add(fieldName, new ParsedEnumField
{
VkName = fieldName,
NameParts = fieldNameParts.ToArray(),
IsBitmask = isBitmask,
Value = value,
Comment = comment != null ? new List <string> {
comment
} : null
});
}
enumXml.Add(name, newEnum);
}
var commandXml = new Dictionary <string, ParsedCommand>();
foreach (var vkCommand in vkXml.Element("registry").Element("commands").Elements("command"))
{
string name = vkCommand.Element("proto").Element("name").Value;
string type = vkCommand.Element("proto").Element("type").Value;
string extension;
string[] nameParts = GetNameParts(name, out extension, knownExtensions);
string[] verbExceptions = new[] { "cmd", "queue", "device" };
string verb = verbExceptions.Contains(nameParts[0]) ? nameParts[1] : nameParts[0];
string[] successCodes = vkCommand.Attribute("successcodes")?.Value?.Split(',');
var newCommand = new ParsedCommand
{
VkName = name,
Type = type,
NameParts = nameParts,
Extension = extension,
Verb = verb,
SuccessCodes = successCodes
};
commandXml.Add(name, newCommand);
foreach (var vkParam in vkCommand.Elements("param"))
{
var nameElement = vkParam.Element("name");
string paramName = nameElement.Value;
string paramType = vkParam.Element("type").Value;
string optional = vkParam.Attribute("optional")?.Value;
bool isOptional;
bool.TryParse(optional, out isOptional);
var typeNodes = nameElement.NodesBeforeSelf();
PointerType pointerType = GetPointerType(typeNodes);
ParsedLen[] dimensions = GetDimensions(name, vkParam, paramName);
string paramExtension;
string[] paramNameParts = GetNameParts(paramName, out paramExtension, knownExtensions, false);
string typeExtension;
string[] typeNameParts = GetNameParts(paramType, out typeExtension, knownExtensions, true);
string typeWithoutExtension = typeNameParts != null
? "Vk" + string.Join("", typeNameParts.Select(CapitaliseFirst))
: null;
newCommand.Params.Add(new ParsedParam
{
VkName = paramName,
Type = paramType,
TypeWithoutExtension = typeWithoutExtension,
TypeExtension = typeExtension,
PointerType = pointerType,
NameParts = paramNameParts,
Extension = paramExtension,
IsOptional = isOptional,
Dimensions = dimensions
});
}
}
var vkFeature = vkXml.Element("registry").Elements("feature").Single(x => x.Attribute("api").Value == "vulkan");
var vkExtensions = vkXml.Element("registry").Element("extensions").Elements("extension").Where(x => x.Attribute("supported").Value == "vulkan");
var filteredSpec = FilterRequiredElement(typeXml, enumXml, commandXml, vkFeature, vkExtensions, knownExtensions);
foreach (var defineType in typeXml.Values.Where(x => x.Category == TypeCategory.define && x.VkName.StartsWith("VK_API_VERSION_")))
{
IEnumerable <string> fieldNameParts = GetEnumFieldNameParts(null, defineType.VkName, knownExtensions);
filteredSpec.Constants.Add(defineType.VkName, new ParsedEnumField
{
VkName = defineType.VkName,
NameParts = fieldNameParts.ToArray(),
IsBitmask = false,
Value = defineType.Type,
Comment = null
});
}
var vkDocsXmlCache = new DownloadedFileCache(this.tempFilePath, "https://raw.githubusercontent.com/FacticiusVir/SharpVk-Docs/master/Docs/vkDocs.xml");
var vkDocsXml = XDocument.Load(vkDocsXmlCache.GetFileLocation().Result);
foreach (var vkDocType in vkDocsXml.Element("docs").Element("types").Elements("type"))
{
string typeName = vkDocType.Attribute("name").Value;
ParsedElement parsedElement = null;
if (filteredSpec.Enumerations.ContainsKey(typeName))
{
parsedElement = filteredSpec.Enumerations[typeName];
}
else if (filteredSpec.Types.ContainsKey(typeName))
{
parsedElement = filteredSpec.Types[typeName];
}
if (parsedElement != null)
{
var comment = new List <string> {
vkDocType.Attribute("summary").Value
};
var specification = vkDocType.Element("specification");
comment.AddRange(specification.Elements("para").Select(x => x.Value));
var description = vkDocType.Element("description");
parsedElement.Comment = new List <string>();
comment.AddRange(description.Elements("para").Select(x => x.Value));
comment.RemoveAll(x => x.StartsWith(".Valid Usage"));
int totalLength = 0;
foreach (var para in comment)
{
totalLength += para.Length;
if (totalLength > 2000)
{
break;
}
else
{
parsedElement.Comment.Add(NormaliseComment(para));
}
}
IEnumerable <ParsedElement> members = null;
var parsedType = parsedElement as ParsedType;
var parsedEnum = parsedElement as ParsedEnum;
if (parsedType != null)
{
members = parsedType.Members;
}
else if (parsedEnum != null)
{
members = parsedEnum.Fields.Values;
}
if (members != null)
{
foreach (var vkDocMember in vkDocType.Element("members").Elements("member"))
{
string memberName = vkDocMember.Attribute("name").Value;
string memberSummary = NormaliseComment(vkDocMember.Value);
var member = members.FirstOrDefault(x => x.VkName == memberName);
if (member != null)
{
member.Comment = new List <string> {
memberSummary
};
}
}
}
}
}
foreach (var vkDocCommand in vkDocsXml.Element("docs").Element("commands").Elements("command"))
{
string commandName = vkDocCommand.Attribute("name").Value;
if (filteredSpec.Commands.ContainsKey(commandName))
{
var parsedCommand = filteredSpec.Commands[commandName];
parsedCommand.Comment = new List <string> {
vkDocCommand.Attribute("summary").Value
};
}
}
return(filteredSpec);
}
public Formula BuildFormula(ParsedElement value, Dictionary<string, Entity> declaredVariables)
{
if (value == null)
throw new ArgumentNullException ("value");
if (value.GetType() == typeof (ParsedForallExpression)) {
var a = new Forall ();
var d2 = new Dictionary<string, KAOSTools.MetaModel.Entity> (declaredVariables);
foreach (var arg in (value as ParsedForallExpression).arguments) {
var name = arg.VariableName;
var type = GetOrCreateEntity (arg.Type);
if (declaredVariables.ContainsKey(name)) {
throw new CompilationException (string.Format ("'{0}' is already defined", name));
}
a.Declarations.Add (new KAOSTools.MetaModel.ArgumentDeclaration() {
Name = name,
Type = type
});
d2.Add (name, type);
}
a.Enclosed = BuildFormula ((value as ParsedForallExpression).Enclosed, d2);
return a;
} else if (value.GetType() == typeof (ParsedExistsExpression)) {
var a = new Exists ();
var d2 = new Dictionary<string, KAOSTools.MetaModel.Entity> (declaredVariables);
foreach (var arg in (value as ParsedExistsExpression).arguments) {
var name = arg.VariableName;
var type = GetOrCreateEntity (arg.Type);
if (declaredVariables.ContainsKey(name)) {
throw new CompilationException (string.Format ("'{0}' is already defined", name));
}
a.Declarations.Add (new KAOSTools.MetaModel.ArgumentDeclaration() {
Name = name,
Type = type
});
d2.Add (name, type);
}
a.Enclosed = BuildFormula ((value as ParsedExistsExpression).Enclosed, d2);
return a;
} else if (value.GetType() == typeof (ParsedStrongImplyExpression)) {
return new StrongImply () {
Left = BuildFormula ((value as ParsedStrongImplyExpression).Left, declaredVariables),
Right = BuildFormula ((value as ParsedStrongImplyExpression).Right, declaredVariables)
};
} else if (value.GetType() == typeof (ParsedImplyExpression)) {
return new Imply () {
Left = BuildFormula ((value as ParsedImplyExpression).Left, declaredVariables),
Right = BuildFormula ((value as ParsedImplyExpression).Right, declaredVariables)
};
} else if (value.GetType() == typeof (ParsedEquivalenceExpression)) {
return new Equivalence () {
Left = BuildFormula ((value as ParsedEquivalenceExpression).Left, declaredVariables),
Right = BuildFormula ((value as ParsedEquivalenceExpression).Right, declaredVariables)
};
} else if (value.GetType() == typeof (ParsedUntilExpression)) {
return new Until () {
Left = BuildFormula ((value as ParsedUntilExpression).Left, declaredVariables),
Right = BuildFormula ((value as ParsedUntilExpression).Right, declaredVariables)
};
} else if (value.GetType() == typeof (ParsedUnlessExpression)) {
return new Unless () {
Left = BuildFormula ((value as ParsedUnlessExpression).Left, declaredVariables),
Right = BuildFormula ((value as ParsedUnlessExpression).Right, declaredVariables)
};
} else if (value.GetType() == typeof (ParsedReleaseExpression)) {
return new Release () {
Left = BuildFormula ((value as ParsedReleaseExpression).Left, declaredVariables),
Right = BuildFormula ((value as ParsedReleaseExpression).Right, declaredVariables)
};
} else if (value.GetType() == typeof (ParsedAndExpression)) {
return new And () {
Left = BuildFormula ((value as ParsedAndExpression).Left, declaredVariables),
Right = BuildFormula ((value as ParsedAndExpression).Right, declaredVariables)
};
} else if (value.GetType() == typeof (ParsedOrExpression)) {
return new Or () {
Left = BuildFormula ((value as ParsedOrExpression).Left, declaredVariables),
Right = BuildFormula ((value as ParsedOrExpression).Right, declaredVariables)
};
} else if (value.GetType() == typeof (ParsedNotExpression)) {
return new Not () {
Enclosed = BuildFormula ((value as ParsedNotExpression).Enclosed, declaredVariables)
};
} else if (value.GetType() == typeof (ParsedNextExpression)) {
return new Next () {
Enclosed = BuildFormula ((value as ParsedNextExpression).Enclosed, declaredVariables)
};
} else if (value.GetType() == typeof (ParsedEventuallyExpression)) {
return new Eventually () {
Enclosed = BuildFormula ((value as ParsedEventuallyExpression).Enclosed, declaredVariables),
TimeBound = BuildTimeBound ((value as ParsedEventuallyExpression).TimeBound)
};
} else if (value.GetType() == typeof (ParsedEventuallyBeforeExpression)) {
return new EventuallyBefore () {
Left = BuildFormula ((value as ParsedEventuallyBeforeExpression).Left, declaredVariables),
Right = BuildFormula ((value as ParsedEventuallyBeforeExpression).Right, declaredVariables),
TimeBound = BuildTimeBound ((value as ParsedEventuallyBeforeExpression).TimeBound)
};
} else if (value.GetType() == typeof (ParsedGloballyExpression)) {
return new Globally () {
Enclosed = BuildFormula ((value as ParsedGloballyExpression).Enclosed, declaredVariables),
TimeBound = BuildTimeBound ((value as ParsedGloballyExpression).TimeBound)
};
} else if (value.GetType() == typeof (ParsedPredicateReferenceExpression)) {
var prel = value as ParsedPredicateReferenceExpression;
// Check if arguments are all defined
foreach (var arg in prel.ActualArguments) {
if (!declaredVariables.ContainsKey (arg)) {
throw new CompilationException (string.Format("'{0}' is not declared ({1}:{2},{3})",
arg, prel.Filename, prel.Line, prel.Col));
}
}
return new PredicateReference () {
Predicate = GetOrCreatePredicate (prel, declaredVariables),
ActualArguments = prel.ActualArguments
};
} else if (value.GetType() == typeof (ParsedInRelationExpression)) {
var prel = value as ParsedInRelationExpression;
foreach (var arg in prel.Variables) {
if (!declaredVariables.ContainsKey (arg)) {
throw new CompilationException (string.Format("'{0}' is not declared", arg));
}
}
return new RelationReference () {
Relation = GetOrCreateRelation (value as ParsedInRelationExpression, declaredVariables),
ActualArguments = prel.Variables
};
} else if (value.GetType() == typeof (ParsedAttributeReferenceExpression)) {
var pref = value as ParsedAttributeReferenceExpression;
if (declaredVariables.ContainsKey(pref.Variable)) {
return new AttributeReference () {
Variable = pref.Variable,
Entity = declaredVariables[pref.Variable],
Attribute = GetOrCreateAttribute (value as ParsedAttributeReferenceExpression, declaredVariables[pref.Variable])
};
} else {
throw new CompilationException (string.Format ("Variable '{0}' is not declared", pref.Variable));
}
} else if (value.GetType() == typeof (ParsedComparisonExpression)) {
var pref = value as ParsedComparisonExpression;
ComparisonCriteria criteria;
if (pref.criteria == ParsedComparisonCriteria.Equals) {
criteria = ComparisonCriteria.Equals;
} else if (pref.criteria == ParsedComparisonCriteria.NotEquals) {
criteria = ComparisonCriteria.NotEquals;
} else if (pref.criteria == ParsedComparisonCriteria.BiggerThan) {
criteria = ComparisonCriteria.BiggerThan;
} else if (pref.criteria == ParsedComparisonCriteria.BiggerThanOrEquals) {
criteria = ComparisonCriteria.BiggerThanOrEquals;
} else if (pref.criteria == ParsedComparisonCriteria.LessThan) {
criteria = ComparisonCriteria.LessThan;
} else if (pref.criteria == ParsedComparisonCriteria.LessThanOrEquals) {
criteria = ComparisonCriteria.LessThanOrEquals;
} else {
throw new NotImplementedException ();
}
return new ComparisonPredicate () {
Criteria = criteria,
Left = BuildFormula (pref.Left, declaredVariables),
Right = BuildFormula (pref.Right, declaredVariables)
};
} else if (value.GetType() == typeof (ParsedStringConstantExpression)) {
return new StringConstant { Value = Sanitize((value as ParsedStringConstantExpression).Value) };
} else if (value.GetType() == typeof (ParsedNumericConstantExpression)) {
return new NumericConstant { Value = (value as ParsedNumericConstantExpression).Value };
} else if (value.GetType() == typeof (ParsedBoolConstantExpression)) {
return new BoolConstant { Value = (value as ParsedBoolConstantExpression).Value };
} else if (value.GetType() == typeof (ParsedVariableReference)) {
if (!declaredVariables.ContainsKey((value as ParsedVariableReference).Value)) {
throw new CompilationException (string.Format ("Variable '{0}' is not declared", (value as ParsedVariableReference).Value));
}
return new VariableReference { Name = (value as ParsedVariableReference).Value };
}
throw new NotImplementedException (string.Format ("{0} is not yet supported",
value.GetType ().Name));
}
public Formula BuildFormula(ParsedElement value, Dictionary <string, Entity> declaredVariables)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
if (value.GetType() == typeof(ParsedForallExpression))
{
var a = new Forall();
var d2 = new Dictionary <string, KAOSTools.Core.Entity> (declaredVariables);
foreach (var arg in (value as ParsedForallExpression).arguments)
{
var name = arg.VariableName;
var type = GetOrCreateEntity(arg.Type);
if (declaredVariables.ContainsKey(name))
{
throw new BuilderException(string.Format("'{0}' is already defined", name),
value.Filename, value.Line, value.Col);
}
a.Declarations.Add(new KAOSTools.Core.ArgumentDeclaration()
{
Name = name,
Type = type.Identifier
});
d2.Add(name, type);
}
a.Enclosed = BuildFormula((value as ParsedForallExpression).Enclosed, d2);
return(a);
}
else if (value.GetType() == typeof(ParsedExistsExpression))
{
var a = new Exists();
var d2 = new Dictionary <string, KAOSTools.Core.Entity> (declaredVariables);
foreach (var arg in (value as ParsedExistsExpression).arguments)
{
var name = arg.VariableName;
var type = GetOrCreateEntity(arg.Type);
if (declaredVariables.ContainsKey(name))
{
throw new BuilderException(string.Format("'{0}' is already defined", name),
value.Filename, value.Line, value.Col);
}
a.Declarations.Add(new KAOSTools.Core.ArgumentDeclaration()
{
Name = name,
Type = type.Identifier
});
d2.Add(name, type);
}
a.Enclosed = BuildFormula((value as ParsedExistsExpression).Enclosed, d2);
return(a);
}
else if (value.GetType() == typeof(ParsedStrongImplyExpression))
{
return(new StrongImply()
{
Left = BuildFormula((value as ParsedStrongImplyExpression).Left, declaredVariables),
Right = BuildFormula((value as ParsedStrongImplyExpression).Right, declaredVariables)
});
}
else if (value.GetType() == typeof(ParsedImplyExpression))
{
return(new Imply()
{
Left = BuildFormula((value as ParsedImplyExpression).Left, declaredVariables),
Right = BuildFormula((value as ParsedImplyExpression).Right, declaredVariables)
});
}
else if (value.GetType() == typeof(ParsedEquivalenceExpression))
{
return(new Equivalence()
{
Left = BuildFormula((value as ParsedEquivalenceExpression).Left, declaredVariables),
Right = BuildFormula((value as ParsedEquivalenceExpression).Right, declaredVariables)
});
}
else if (value.GetType() == typeof(ParsedUntilExpression))
{
return(new Until()
{
Left = BuildFormula((value as ParsedUntilExpression).Left, declaredVariables),
Right = BuildFormula((value as ParsedUntilExpression).Right, declaredVariables)
});
}
else if (value.GetType() == typeof(ParsedUnlessExpression))
{
return(new Unless()
{
Left = BuildFormula((value as ParsedUnlessExpression).Left, declaredVariables),
Right = BuildFormula((value as ParsedUnlessExpression).Right, declaredVariables)
});
}
else if (value.GetType() == typeof(ParsedReleaseExpression))
{
return(new Release()
{
Left = BuildFormula((value as ParsedReleaseExpression).Left, declaredVariables),
Right = BuildFormula((value as ParsedReleaseExpression).Right, declaredVariables)
});
}
else if (value.GetType() == typeof(ParsedAndExpression))
{
return(new And()
{
Left = BuildFormula((value as ParsedAndExpression).Left, declaredVariables),
Right = BuildFormula((value as ParsedAndExpression).Right, declaredVariables)
});
}
else if (value.GetType() == typeof(ParsedOrExpression))
{
return(new Or()
{
Left = BuildFormula((value as ParsedOrExpression).Left, declaredVariables),
Right = BuildFormula((value as ParsedOrExpression).Right, declaredVariables)
});
}
else if (value.GetType() == typeof(ParsedNotExpression))
{
return(new Not()
{
Enclosed = BuildFormula((value as ParsedNotExpression).Enclosed, declaredVariables)
});
}
else if (value.GetType() == typeof(ParsedNextExpression))
{
return(new Next()
{
Enclosed = BuildFormula((value as ParsedNextExpression).Enclosed, declaredVariables)
});
}
else if (value.GetType() == typeof(ParsedEventuallyExpression))
{
return(new Eventually()
{
Enclosed = BuildFormula((value as ParsedEventuallyExpression).Enclosed, declaredVariables),
TimeBound = BuildTimeBound((value as ParsedEventuallyExpression).TimeBound)
});
}
else if (value.GetType() == typeof(ParsedGloballyExpression))
{
return(new Globally()
{
Enclosed = BuildFormula((value as ParsedGloballyExpression).Enclosed, declaredVariables),
TimeBound = BuildTimeBound((value as ParsedGloballyExpression).TimeBound)
});
}
else if (value.GetType() == typeof(ParsedPredicateReferenceExpression))
{
var prel = value as ParsedPredicateReferenceExpression;
// Check if arguments are all defined
foreach (var arg in prel.ActualArguments)
{
if (!declaredVariables.ContainsKey(arg))
{
throw new BuilderException(string.Format("'{0}' is not declared"),
value.Filename, value.Line, value.Col);
}
}
return(new PredicateReference()
{
PredicateIdentifier = GetOrCreatePredicate(prel, declaredVariables).Identifier,
ActualArguments = prel.ActualArguments
});
}
else if (value.GetType() == typeof(ParsedInRelationExpression))
{
var prel = value as ParsedInRelationExpression;
foreach (var arg in prel.Variables)
{
if (!declaredVariables.ContainsKey(arg))
{
throw new BuilderException(string.Format("'{0}' is not declared", arg),
value.Filename, value.Line, value.Col);
}
}
return(new RelationReference()
{
Relation = GetOrCreateRelation(value as ParsedInRelationExpression, declaredVariables).Identifier,
ActualArguments = prel.Variables
});
}
else if (value.GetType() == typeof(ParsedAttributeReferenceExpression))
{
var pref = value as ParsedAttributeReferenceExpression;
if (declaredVariables.ContainsKey(pref.Variable))
{
var boolType = GetOrCreateGivenType("boolean");
return(new AttributeReference()
{
Variable = pref.Variable,
Entity = declaredVariables [pref.Variable].Identifier,
Attribute = GetOrCreateAttribute(value as ParsedAttributeReferenceExpression,
declaredVariables [pref.Variable],
boolType).Identifier
});
}
else
{
throw new BuilderException(string.Format("Variable '{0}' is not declared", pref.Variable),
value.Filename, value.Line, value.Col);
}
}
else if (value.GetType() == typeof(ParsedComparisonExpression))
{
var pref = value as ParsedComparisonExpression;
ComparisonCriteria criteria;
if (pref.criteria == ParsedComparisonCriteria.Equals)
{
criteria = ComparisonCriteria.Equals;
}
else if (pref.criteria == ParsedComparisonCriteria.NotEquals)
{
criteria = ComparisonCriteria.NotEquals;
}
else if (pref.criteria == ParsedComparisonCriteria.BiggerThan)
{
criteria = ComparisonCriteria.BiggerThan;
}
else if (pref.criteria == ParsedComparisonCriteria.BiggerThanOrEquals)
{
criteria = ComparisonCriteria.BiggerThanOrEquals;
}
else if (pref.criteria == ParsedComparisonCriteria.LessThan)
{
criteria = ComparisonCriteria.LessThan;
}
else if (pref.criteria == ParsedComparisonCriteria.LessThanOrEquals)
{
criteria = ComparisonCriteria.LessThanOrEquals;
}
else
{
throw new NotImplementedException();
}
return(new ComparisonPredicate()
{
Criteria = criteria,
Left = BuildFormula(pref.Left, declaredVariables),
Right = BuildFormula(pref.Right, declaredVariables)
});
}
else if (value.GetType() == typeof(ParsedStringConstantExpression))
{
return(new StringConstant {
Value = Sanitize((value as ParsedStringConstantExpression).Value)
});
}
else if (value.GetType() == typeof(ParsedNumericConstantExpression))
{
return(new NumericConstant {
Value = (value as ParsedNumericConstantExpression).Value
});
}
else if (value.GetType() == typeof(ParsedBoolConstantExpression))
{
return(new BoolConstant {
Value = (value as ParsedBoolConstantExpression).Value
});
}
else if (value.GetType() == typeof(ParsedVariableReference))
{
if (!declaredVariables.ContainsKey((value as ParsedVariableReference).Value))
{
throw new BuilderException(string.Format("Variable '{0}' is not declared", (value as ParsedVariableReference).Value),
value.Filename, value.Line, value.Col);
}
return(new VariableReference {
Name = (value as ParsedVariableReference).Value
});
}
throw new NotImplementedException(string.Format("{0} is not yet supported",
value.GetType().Name));
}
