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(); }