/// <summary>
/// Saves an AST term and returns a symbol uniquely identifying it.
/// Does no add term to set of root terms for rewriting.
/// </summary>
public Term StoreTerm(ITrlTerm parseResult)
{
if (parseResult is Identifier id)
{
return(StoreAtom(id.Name, SymbolType.Identifier));
}
else if (parseResult is StringValue str)
{
return(StoreAtom(str.Value, SymbolType.String));
}
else if (parseResult is NumericValue num)
{
return(StoreAtom(num.Value, SymbolType.Number));
}
else if (parseResult is TermList termList)
{
var arguments = termList.Terms.Select(t => StoreTerm(t)).ToArray();
return(StoreTermList(arguments));
}
else if (parseResult is NonAcTerm nonAcTerm)
{
var arguments = nonAcTerm.Arguments.Select(t => StoreTerm(t)).ToArray();
return(StoreNonAcTerm(nonAcTerm.TermName.Name, arguments, StoreMetadata(nonAcTerm)));
}
else if (parseResult is Variable var)
{
return(StoreVariable(var.Name));
}
else
{
throw new NotImplementedException();
}
}
private void CheckClassMappingMembers(ITrlTerm term, List <string> errorList)
{
var nonAcTerm = term as NonAcTerm;
if (nonAcTerm == null)
{
return;
}
// Check arguments
foreach (ITrlTerm arg in nonAcTerm.Arguments)
{
CheckClassMappingMembers(arg, errorList);
}
if (nonAcTerm.ClassMemberMappings == null)
{
return;
}
// Check that class member mappings count is the same as argument count
var classMemberCount = nonAcTerm.ClassMemberMappings.ClassMembers.Count;
if (classMemberCount != nonAcTerm.Arguments.Count)
{
errorList.Add(string.Format(Errors.NumberOfClassMembers, nonAcTerm.ToSourceCode()));
}
// Check that class member name mappings do not contain namespacing
if (classMemberCount > 0)
{
foreach (var member in nonAcTerm.ClassMemberMappings.ClassMembers)
{
if (member.Name.Contains("."))
{
errorList.Add(string.Format(Errors.NamespacedClassMembers, member.ToSourceCode()));
}
}
}
}
