public static string ToSourceCode(this Substitution substitution, TermDatabase database)
{
var head = substitution.MatchTerm.ToSourceCode(database);
var tail = substitution.SubstituteTerm.ToSourceCode(database);
return($"{head} => {tail};");
}
/// <summary>
/// Loads the object into the database, returns the term that represents it.
/// </summary>
/// <param name="inputObject">Object to load</param>
/// <param name="termDatabase">Database to load it into.</param>
/// <returns>Database term created for object</returns>
public Term BuildTermForObject(object inputObject, TermDatabase termDatabase)
{
var knownConstant = _nameAndTypeMappings.GetIdentifierForConstantValue(inputObject);
if (!string.IsNullOrWhiteSpace(knownConstant))
{
return termDatabase.Writer.StoreAtom(knownConstant, SymbolType.Identifier);
}
else if (inputObject is string)
{
return termDatabase.Writer.StoreAtom(Convert.ToString(inputObject), SymbolType.String);
}
// NB: IEnumerable must be after string because string is IEnumerable
else if (inputObject is IEnumerable)
{
var listMembers = new List<Term>();
var inputEnumerable = (IEnumerable)inputObject;
foreach (var item in inputEnumerable)
{
listMembers.Add(BuildTermForObject(item, termDatabase));
}
return termDatabase.Writer.StoreTermList(listMembers.ToArray());
}
else if (_nameAndTypeMappings.IsNumeric(inputObject))
{
return termDatabase.Writer.StoreAtom(Convert.ToString(inputObject), SymbolType.Number);
}
else
{
return GenerateNonAcTerm(inputObject, termDatabase);
}
}
private Term GenerateNonAcTermWithoutFieldMappings(object inputObject, TermDatabase termDatabase)
{
var type = inputObject.GetType();
var deconstructor = _nameAndTypeMappings.GetBestDeconstructorMethodForAcTerm(type);
if (deconstructor == null)
{
return null;
}
var isExtensionMethod = deconstructor.IsDefined(typeof(ExtensionAttribute));
// Run deconstructor
var parms = new object[deconstructor.GetParameters().Length];
if (isExtensionMethod)
{
parms[0] = inputObject;
}
deconstructor.Invoke(inputObject, parms);
// Extract "out" parameter values
var arguments = new List<Term>();
int startIndex = isExtensionMethod ? 1 : 0;
for (int i = startIndex; i < parms.Length; i++)
{
arguments.Add(BuildTermForObject(parms[i], termDatabase));
}
var termName = _nameAndTypeMappings.GetTermNameForType(type);
var metaData = new Dictionary<TermMetaData, Term>();
return termDatabase.Writer.StoreNonAcTerm(termName, arguments.ToArray(), metaData);
}
internal StatementList BuildAst<TObject>(TObject inputObject, string rootLabel)
{
var termDatabase = new TermDatabase();
var root = BuildTermForObject(inputObject, termDatabase);
termDatabase.Writer.LabelTerm(root, rootLabel);
termDatabase.Writer.SetAsRootTerm(root);
termDatabase.MutateDatabase(new ConvertCommonTermsToRewriteRules());
return termDatabase.Reader.ReadCurrentFrame();
}
protected static void InitDb()
{
database = new TermDatabase(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "TermDB.db3"));
// seed init data
// create term
var term = new Term
{
TermStartDate = DateTime.Now,
TermEndDate = DateTime.Now.AddDays(150),
TermTitle = "Spring Term"
};
database.SaveTermAsync(term);
// create course
var course = new Course
{
TermId = 1,
CourseId = 0,
CourseTitle = "Software Engineering",
StartCourseDate = DateTime.Now,
EndCourseDate = DateTime.Now.AddDays(14),
StartDateAlert = true,
DueDateAlert = true,
ProfessorName = "Jordan Pritt",
ProfessorEmail = "*****@*****.**",
ProfessorPhone = "(540)-336-5725",
CourseStatus = "in progress",
CourseNotes = "This is the first course of the term. Hoot hoot for being a night owl!"
};
database.SaveCourseAsync(course);
// create assessments
var ass1 = new Assessment
{
CourseId = 1,
DueDate = DateTime.Now.AddDays(14),
Name = "Software Project",
Type = "Objective",
};
var ass2 = new Assessment
{
CourseId = 1,
DueDate = DateTime.Now.AddDays(14),
Name = "Software Test",
Type = "Performance",
};
database.SaveAssessmentAsync(ass1);
database.SaveAssessmentAsync(ass2);
}
public static TermDatabase LoadStatements(string statements)
{
var termDatabase = new TermDatabase();
var parser = new TrlParser();
var parseResult = parser.ParseToAst(statements);
if (!parseResult.Succeed)
{
throw new Exception(parseResult.Errors.First());
}
termDatabase.Writer.StoreStatements(parseResult.Statements);
return(termDatabase);
}
internal TObject BuildObject <TObject>(string inputString, string rootLabel, int maxRewriteIterations = 100000)
{
var database = new TermDatabase();
var result = _parser.ParseToAst(inputString);
if (!result.Succeed)
{
throw new Exception(string.Join(Environment.NewLine, result.Errors));
}
database.Writer.StoreStatements(result.Statements);
database.ExecuteRewriteRules(maxRewriteIterations);
var statementList = database.Reader.ReadStatementsForLabel(rootLabel);
if (statementList == default || statementList.Statements.Count == 0)
{
return(default);
/// <summary>
/// Generate a new unique name based on the source string.
/// This name can be used as a identifier name.
/// </summary>
internal string GenerateUniqueIdentifierName(Term existingTerm, TermDatabase termDatabase)
{
string existingName = existingTerm.Name.Type switch
{
SymbolType.NonAcTerm => termDatabase.StringMapper.ReverseMap(existingTerm.Name.AssociatedStringValue),
SymbolType.TermList => "list",
_ => throw new Exception("Unexpected term type")
};
_ = _sourceStringCountCache.TryGetValue(existingName, out ulong count);
string testString = $"{existingName[0]}{count}";
while (termDatabase.StringMapper.TryGetMappedValue(testString, out _))
{
count++;
testString = $"{existingName[0]}{count}";
}
_sourceStringCountCache.Add(existingName, count);
return(testString);
}
}
static void Main()
{
var input = "0; 0 => inc(0);";
// Parse input
var parser = new TrlParser();
var parseResult = parser.ParseToAst(input);
if (!parseResult.Succeed)
{
Console.WriteLine("Syntax error.");
return;
}
// Execute substitutions
var termDatabase = new TermDatabase();
termDatabase.Writer.StoreStatements(parseResult.Statements);
// Track changes
termDatabase.Writer.SetTermReplacementObserver(replacement =>
{
var originalTerm = replacement.OriginalRootTerm.ToSourceCode(termDatabase);
var newTerm = replacement.NewRootTerm.ToSourceCode(termDatabase);
Console.WriteLine($"{replacement.RewriteIteration}> Replaced {originalTerm} with {newTerm}");
});
// Execute the rewrite rules
termDatabase.ExecuteRewriteRules(4);
// Print output
Console.WriteLine();
Console.WriteLine("Output:");
var output = termDatabase.Reader.ReadCurrentFrame();
Console.WriteLine(output.ToSourceCode(true));
}
private Term GenerateNonAcTermWithFieldMappings(object inputObject, TermDatabase termDatabase)
{
// Assume we are creating a non ac term in the default case
var type = inputObject.GetType();
var properties = type.GetProperties(Bindings)
.Where(p => p.CanRead).OrderBy(p => p.Name);
var fields = type.GetFields(Bindings)
.OrderBy(p => p.Name);
// Build arguments
var fieldMappingIdentifiers = new List<Term>();
var arguments = new List<Term>();
foreach (var prop in properties)
{
var value = prop.GetValue(inputObject);
if (value != null)
{
fieldMappingIdentifiers.Add(termDatabase.Writer.StoreAtom(prop.Name, SymbolType.Identifier));
arguments.Add(BuildTermForObject(value, termDatabase));
}
}
foreach (var field in fields)
{
var value = field.GetValue(inputObject);
if (value != null)
{
fieldMappingIdentifiers.Add(termDatabase.Writer.StoreAtom(field.Name, SymbolType.Identifier));
arguments.Add(BuildTermForObject(value, termDatabase));
}
}
Dictionary<TermMetaData, Term> metadata = new Dictionary<TermMetaData, Term>();
var fieldList = termDatabase.Writer.StoreTermList(fieldMappingIdentifiers.ToArray());
metadata.Add(TermMetaData.ClassMemberMappings, fieldList);
return termDatabase.Writer.StoreNonAcTerm(_nameAndTypeMappings.GetTermNameForType(type), arguments.ToArray(), metadata);
}
public static string ToSourceCode(this Term @this, TermDatabase database)
{
var reader = database.Reader;
return(reader.ReadTerm(@this).ToSourceCode());
}
public UnifierCalculation(TermDatabase termDatabase)
{
_termDatabase = termDatabase;
}
private Term GenerateNonAcTerm(object inputObject, TermDatabase termDatabase)
{
return GenerateNonAcTermWithoutFieldMappings(inputObject, termDatabase)
?? GenerateNonAcTermWithFieldMappings(inputObject, termDatabase);
}
public TermDatabaseTests()
{
_termDatabase = new TermDatabase();
_parser = new TrlParser();
}
