public void Empty() { StringSet ss = new StringSet(new string[] { "" }); Assert.AreEqual(1, ss.Count); ss = new StringSet((string[])null); Assert.AreEqual(0, ss.Count); }
public void Enumerate() { StringSet ss = new StringSet(); int i = 0; foreach (string s in ss) { i++; Console.WriteLine(s); } Assert.AreEqual(0, i); ss.Add("bloo"); ss.Add("foo"); ss.Add("bar"); foreach (string s in ss) { i++; Console.WriteLine(s); } Assert.AreEqual(3, i); string[] arr = ss.GetStrings(); Array.Sort(arr); Assert.AreEqual("bar", arr[0]); Assert.AreEqual("bloo", arr[1]); Assert.AreEqual("foo", arr[2]); Assert.AreEqual(3, arr.Length); }
public void ShouldRemoveAndContainsReturnFalse() { var stringSet = new StringSet(); stringSet.Add("Test"); Assert.IsTrue(stringSet.Contains("Test")); stringSet.Remove("Test"); Assert.IsFalse(stringSet.Contains("Test")); }
public void ShouldCount() { var stringSet = new StringSet(); stringSet.Add("Test"); stringSet.Add("Test"); stringSet.Add("Test"); Assert.AreEqual(3, stringSet.Count); }
public void ShouldClearTheSet() { var stringSet = new StringSet(); stringSet.Add("Test"); stringSet.Add("Test"); stringSet.Add("Test"); stringSet.Clear(); Assert.AreEqual(0, stringSet.Count); }
public void ShouldEnumerate() { var stringSet = new StringSet(); stringSet.Add("Test"); stringSet.Add("Test"); stringSet.Add("Test"); foreach (var test in stringSet) { Assert.IsTrue(stringSet.Contains(test)); } }
public void ShouldUnionTwoSet() { var set1 = new StringSet(); var set2 = new StringSet(); set1.Add("Test1"); set2.Add("Test2"); StringSet union = set1.Union(set2); Assert.AreEqual(2, union.Count); Assert.IsTrue( union.Contains("Test1")); Assert.IsTrue( union.Contains("Test2")); }
public void Add() { StringSet ss = new StringSet(); ss.Add("foo"); ss.Add("foo"); ss.Add("bar"); Assert.IsTrue(ss["foo"]); Assert.AreEqual(2, ss.Count); Assert.AreEqual("foo\r\nbar\r\n", ss.ToString()); ss.Remove("bar"); Assert.AreEqual(1, ss.Count); Assert.IsFalse(ss["fool"]); ss = new StringSet(new string[] { "foo", "bar"}); ss.Add(new StringSet("baz")); Assert.AreEqual(3, ss.Count); }
public void ShouldIntersect() { var set1 = new StringSet(); var set2 = new StringSet(); set1.Add("Test1"); set1.Add("Common1"); set1.Add("Common2"); set2.Add("Common1"); set2.Add("Common2"); set2.Add("Test2"); StringSet intersect = set1.Intersect(set2); Assert.AreEqual(2, intersect.Count); Assert.IsTrue(intersect.Contains("Common1")); Assert.IsTrue(intersect.Contains("Common2")); }
internal static StringSet ComputeGroupedExpectedSetForState(Grammar grammar, ParserState state) { var terms = new TerminalSet(); terms.UnionWith(state.ExpectedTerminals); var result = new StringSet(); //Eliminate no-report terminals foreach(var group in grammar.TermReportGroups) if (group.GroupType == TermReportGroupType.DoNotReport) terms.ExceptWith(group.Terminals); //Add normal and operator groups foreach(var group in grammar.TermReportGroups) if((group.GroupType == TermReportGroupType.Normal || group.GroupType == TermReportGroupType.Operator) && terms.Overlaps(group.Terminals)) { result.Add(group.Alias); terms.ExceptWith(group.Terminals); } //Add remaining terminals "as is" foreach(var terminal in terms) result.Add(terminal.ErrorAlias); return result; }
public void Merge() { StringSet ss = new StringSet(); ss.Add("foo"); StringSet so = new StringSet(); so.Add("bar"); so.Add("baz"); ss.Add(so); Assert.AreEqual(3, ss.Count); so = new StringSet(); so.Add("boo"); so.Add("baz"); ss.Add(so); Assert.AreEqual(4, ss.Count); ss.Remove(so); Assert.AreEqual(2, ss.Count); Assert.IsTrue(ss["foo"]); Assert.IsTrue(ss["bar"]); Assert.IsFalse(ss["boo"]); Assert.IsFalse(ss["baz"]); Assert.IsFalse(ss["bloo"]); }
/// <summary> /// Add a single feature to the node. /// Does not fire OnFeatures, since this should mostly be used by /// things that are not querying externally. /// </summary> /// <param name="feature">The feature URI to add</param> public void AddFeature(string feature) { if (Features == null) Features = new StringSet(); Features.Add(feature); }
/// <summary> /// Add all of the features from the specified set. /// </summary> /// <param name="features"></param> public void AddFeatures(StringSet features) { if (features != null) { if (Features == null) Features = new StringSet(features); else Features.Add(features); } DoCallbacks(m_featureCallbacks); }
public void Create() { StringSet ss = new StringSet(); Assert.AreEqual(0, ss.Count); Assert.AreEqual("", ss.ToString()); }
static void Main() { StringSet ss = new StringSet(); // Check the interface methods first. ISet <string> s = ss; checkThat(s.Count == 0, "is initially empty"); checkThat(!s.Contains("key"), "doesn't contain inexistent element"); checkThat(!s.Remove("key"), "returns false when removing inexistent element"); checkThat(s.Add("key"), "returns true when adding a new element"); checkThat(!s.Add("key"), "returns false when adding an existing element"); checkThat(s.Contains("key"), "contains the just added element"); checkThat(s.Remove("key"), "returns true when removing an existing element"); checkThat(s.Count == 0, "is empty again"); checkThat(s.Add("key1"), "Add(key1) returns true"); checkThat(s.Add("key2"), "Add(key2) returns true"); checkThat(s.Add("key3"), "Add(key3) returns true"); // Also check a different interface, providing a different Add() (sic!). ICollection <string> coll = ss; coll.Add("key"); checkThat(ss.Count == 4, "contains 4 elements"); // Now use object-specific methods, mimicking HashSet<>. string val; checkThat(ss.TryGetValue("key1", out val), "could retrieve existing item"); checkThat(val.Equals("key1"), "value was returned correctly by TryGetValue()"); checkThat(!ss.TryGetValue("no-such-key", out val), "couldn't retrieve inexistent item"); checkThat(val == null, "value was reset after failed TryGetValue()"); IList <string> list = new List <string>(); foreach (string str in ss) { list.Add(str); } checkThat(list.Count == 4, "copy contains 4 elements"); ss.Clear(); checkThat(ss.Count == 0, "is empty after Clear()"); // Check set-theoretic methods. checkThat(new StringSet().SetEquals(new StringSet()), "SetEquals() works for empty sets"); checkThat(new StringSet { "foo" }.SetEquals(new StringSet { "foo" }), "SetEquals() works for non-empty sets"); checkThat(!new StringSet { "foo" }.SetEquals(new[] { "bar" }), "SetEquals() doesn't always return true"); ss = new StringSet { "foo", "bar", "baz" }; ss.ExceptWith(new[] { "baz", "quux" }); checkThat(ss.SetEquals(new[] { "foo", "bar" }), "ExceptWith works"); ss = new StringSet { "foo", "bar", "baz" }; ss.IntersectWith(new[] { "baz", "quux" }); checkThat(ss.SetEquals(new[] { "baz" }), "IntersectWith works"); checkThat(ss.IsProperSubsetOf(new[] { "bar", "baz" }), "IsProperSubsetOf works"); checkThat(!ss.IsProperSubsetOf(new[] { "baz" }), "!IsProperSubsetOf works"); checkThat(ss.IsSubsetOf(new[] { "bar", "baz" }), "IsSubsetOf works"); checkThat(!ss.IsSubsetOf(new[] { "bar" }), "!IsSubsetOf works"); ss = new StringSet { "foo", "bar", "baz" }; checkThat(ss.IsProperSupersetOf(new[] { "bar" }), "IsProperSupersetOf works"); checkThat(!ss.IsProperSupersetOf(new[] { "quux" }), "IsProperSupersetOf works"); checkThat(ss.IsSupersetOf(new[] { "foo", "bar", "baz" }), "IsProperSupersetOf works"); checkThat(!ss.IsSupersetOf(new[] { "foo", "bar", "baz", "quux" }), "IsProperSupersetOf works"); checkThat(ss.Overlaps(new[] { "foo" }), "Overlaps works"); checkThat(!ss.Overlaps(new[] { "moo" }), "!Overlaps works"); ss.SymmetricExceptWith(new[] { "baz", "quux" }); checkThat(ss.SetEquals(new[] { "foo", "bar", "quux" }), "SymmetricExceptWith works"); ss = new StringSet { "foo", "bar", "baz" }; ss.UnionWith(new[] { "baz", "quux" }); checkThat(ss.SetEquals(new[] { "foo", "bar", "baz", "quux" }), "UnionWith works"); }
public void ShouldAddStringAndContainsReturnTrue() { var stringSet = new StringSet(); stringSet.Add("Test"); Assert.IsTrue(stringSet.Contains("Test")); }
private static void addPackagesAndDependacies(CopyError copyError, PackageSet set, StringSet packageNames, PackageList all) { foreach (var packageName in packageNames) { Package package; if (all.TryGetValue(packageName, out package)) { set.Add(package); addPackagesAndDependacies(copyError, set, package.Dependencies, all); } else { copyError.AddError(new CopyError.Error { title = "Package not found!", message = string.Format("Could not find package with name '{0}'", packageName), }); } } }
/* Function: Start_ApplyProperties * A helper function that is used only by <Start()> to combine a <ConfigFileCommentType's> properties into <commentTypes> and * its keywords into <singularKeywords> and <pluralKeywords>. Assumes entries were already created for all of them by * <Start_CreateType()>. Returns whether it was able to do so without causing an error. */ private bool Start_ApplyProperties(ConfigFileCommentType configFileCommentType, Path sourceFile, StringSet ignoredKeywords, Errors.ErrorList errorList) { CommentType commentType = commentTypes[configFileCommentType.Name]; bool success = true; // Display names if (configFileCommentType.DisplayNameFromLocale != null) { commentType.DisplayName = Locale.Get("NaturalDocs.Engine", configFileCommentType.DisplayNameFromLocale); } else if (configFileCommentType.DisplayName != null) { commentType.DisplayName = configFileCommentType.DisplayName; } if (configFileCommentType.PluralDisplayNameFromLocale != null) { commentType.PluralDisplayName = Locale.Get("NaturalDocs.Engine", configFileCommentType.PluralDisplayNameFromLocale); } else if (configFileCommentType.PluralDisplayName != null) { commentType.PluralDisplayName = configFileCommentType.PluralDisplayName; } // Other properties if (configFileCommentType.SimpleIdentifier != null) { commentType.SimpleIdentifier = configFileCommentType.SimpleIdentifier; } if (configFileCommentType.Index != null) { commentType.Index = (CommentType.IndexValue)configFileCommentType.Index; if (commentType.Index == CommentType.IndexValue.IndexWith) { CommentType indexWithCommentType = commentTypes[configFileCommentType.IndexWith]; if (indexWithCommentType == null) { errorList.Add( Locale.Get("NaturalDocs.Engine", "Comments.txt.IndexWithCommentTypeDoesntExist(name)", configFileCommentType.IndexWith), sourceFile, configFileCommentType.LineNumber ); success = false; } else { commentType.IndexWith = indexWithCommentType.ID; } } } if (configFileCommentType.Scope != null) { commentType.Scope = (CommentType.ScopeValue)configFileCommentType.Scope; } if (configFileCommentType.Flags.AllConfigurationProperties != 0) { commentType.Flags.AllConfigurationProperties = configFileCommentType.Flags.AllConfigurationProperties; } if (configFileCommentType.BreakLists != null) { commentType.BreakLists = (bool)configFileCommentType.BreakLists; } // Keywords List <string> keywords = configFileCommentType.Keywords; for (int i = 0; i < keywords.Count; i += 2) { if (keywords[i] != null && !ignoredKeywords.Contains(keywords[i])) { singularKeywords.Add(keywords[i], commentType); pluralKeywords.Remove(keywords[i]); } if (keywords[i + 1] != null && !ignoredKeywords.Contains(keywords[i + 1])) { singularKeywords.Remove(keywords[i + 1]); pluralKeywords.Add(keywords[i + 1], commentType); } } return(success); }
// Group: Saving Functions // __________________________________________________________________________ /* Function: Save * Saves the current computed languages into <Languages.nd>. Throws an exception if unsuccessful. */ public void Save(Path filename, IDObjects.Manager <Language> languages, StringTable <Language> aliases, StringTable <Language> extensions, SortedStringTable <Language> shebangStrings, StringSet ignoredExtensions) { BinaryFile file = new BinaryFile(); file.OpenForWriting(filename); try { // [String: Language Name] // [Int32: ID] // [Byte: Type] // [String: Simple Identifier] // [Byte: Enum Values] // [Byte: Case Sensitive (1 or 0)] // [String: Member Operator Symbol] // [String: Line Extender Symbol] // [String: Line Comment Symbol] [] ... [String: null] // [String: Opening Block Comment Symbol] [String: Closing Block Comment Symbo] [] [] ... [String: null] // [String: Opening Javadoc Line Comment Symbol] [String: Remainder Javadoc Line Comment Symbol [] ... [String: null] // [String: Opening Javadoc Block Comment Symbol] [String: Closing Javadoc Block Comment Symbol] [] [] ... [String: null] // [String: XML Line Comment Symbol] [] ... [String: null] // [Int32: Comment Type ID] // [Byte: Include Line Breaks (0 or 1)] // [String: Prototype Ender Symbol] [] ... [String: null] // ... // [Int32: 0] // ... // [String: null] foreach (Language language in languages) { file.WriteString(language.Name); file.WriteInt32(language.ID); file.WriteByte((byte)language.Type); file.WriteString(language.SimpleIdentifier); file.WriteByte((byte)language.EnumValue); file.WriteByte((byte)(language.CaseSensitive ? 1 : 0)); file.WriteString(language.MemberOperator); file.WriteString(language.LineExtender); WriteStringArray(file, language.LineCommentStrings); WriteStringArray(file, language.BlockCommentStringPairs); WriteStringArray(file, language.JavadocLineCommentStringPairs); WriteStringArray(file, language.JavadocBlockCommentStringPairs); WriteStringArray(file, language.XMLLineCommentStrings); int[] commentTypes = language.GetCommentTypesWithPrototypeEnders(); if (commentTypes != null) { foreach (int commentType in commentTypes) { PrototypeEnders prototypeEnders = language.GetPrototypeEnders(commentType); file.WriteInt32(commentType); file.WriteByte((byte)(prototypeEnders.IncludeLineBreaks ? 1 : 0)); WriteStringArray(file, prototypeEnders.Symbols); } } file.WriteInt32(0); } file.WriteString(null); // [String: Alias] [Int32: Language ID] [] [] ... [String: Null] foreach (KeyValuePair <string, Language> pair in aliases) { file.WriteString(pair.Key); file.WriteInt32(pair.Value.ID); } file.WriteString(null); // [String: Extension] [Int32: Language ID] [] [] ... [String: Null] foreach (KeyValuePair <string, Language> pair in extensions) { file.WriteString(pair.Key); file.WriteInt32(pair.Value.ID); } file.WriteString(null); // [String: Shebang String] [Int32: Language ID] [] [] ... [String: Null] foreach (KeyValuePair <string, Language> pair in shebangStrings) { file.WriteString(pair.Key); file.WriteInt32(pair.Value.ID); } file.WriteString(null); // [String: Ignored Extension] [] ... [String: Null] foreach (string ignoredExtension in ignoredExtensions) { file.WriteString(ignoredExtension); } file.WriteString(null); } finally { file.Close(); } }
public static IObjectModel Resolve(LambdaExpression selector, ScopeParameterDictionary scopeParameters, StringSet scopeTables) { SelectorResolver resolver = new SelectorResolver(scopeParameters, scopeTables); return(resolver.Visit(selector)); }
internal void Read(EndianBinaryReader reader) { long boneIdsOffset = reader.ReadOffset(); long boneMatricesOffset = reader.ReadOffset(); long boneNamesOffset = reader.ReadOffset(); long exDataOffset = reader.ReadOffset(); int boneCount = reader.ReadInt32(); long boneParentIdsOffset = reader.ReadOffset(); reader.SkipNulls(2 * sizeof(uint)); reader.ReadAtOffset(boneIdsOffset, () => { Bones.Capacity = boneCount; for (int i = 0; i < boneCount; i++) { uint id = reader.ReadUInt32(); Bones.Add(new BoneInfo { Id = id, IsEx = (id & 0x8000) != 0 }); } }); reader.ReadAtOffset(boneMatricesOffset, () => { foreach (var bone in Bones) { bone.InverseBindPoseMatrix = reader.ReadMatrix4x4(); } }); reader.ReadAtOffset(boneNamesOffset, () => { foreach (var bone in Bones) { bone.Name = reader.ReadStringOffset(StringBinaryFormat.NullTerminated); } }); reader.ReadAtOffset(exDataOffset, () => { int osageNameCount = reader.ReadInt32(); int osageBoneCount = reader.ReadInt32(); reader.SkipNulls(sizeof(uint)); long osageBonesOffset = reader.ReadOffset(); long osageNamesOffset = reader.ReadOffset(); long blocksOffset = reader.ReadOffset(); int stringCount = reader.ReadInt32(); long stringsOffset = reader.ReadOffset(); long osageSiblingInfosOffset = reader.ReadOffset(); int clothCount = reader.ReadInt32(); reader.SkipNulls(7 * reader.AddressSpace.GetByteSize()); var stringSet = new StringSet(reader, stringsOffset, stringCount); var osageBones = new List <OsageBone>(osageBoneCount); reader.ReadAtOffset(osageBonesOffset, () => { for (int i = 0; i < osageBoneCount; i++) { var osageBone = new OsageBone(); osageBone.Read(reader, stringSet); osageBones.Add(osageBone); } }); reader.ReadAtOffset(blocksOffset, () => { while (true) { string blockSignature = reader.ReadStringOffset(StringBinaryFormat.NullTerminated); long blockOffset = reader.ReadOffset(); if (blockOffset == 0) { break; } reader.ReadAtOffset(blockOffset, () => { if (!BlockFactory.TryGetValue(blockSignature, out var blockConstructor)) { Debug.WriteLine("Skin.Read(): Unimplemented block ({0}) at 0x{1:X}", blockSignature, blockOffset); return; } var block = blockConstructor(); block.Read(reader, stringSet); if (block is OsageBlock osageNode) { for (int i = 0; i < osageNode.Count; i++) { osageNode.Bones.Add(osageBones[osageNode.StartIndex + i]); } } Blocks.Add(block); }); } }); reader.ReadAtOffset(osageSiblingInfosOffset, () => { while (true) { string boneName = stringSet.ReadString(reader); if (boneName == null) { break; } string siblingName = stringSet.ReadString(reader); float siblingDistance = reader.ReadSingle(); var osageBone = osageBones.FirstOrDefault(x => x.Name.Equals(boneName)); if (osageBone == null) { continue; } osageBone.SiblingName = siblingName; osageBone.SiblingDistance = siblingDistance; } }); }); reader.ReadAtOffset(boneParentIdsOffset, () => { foreach (var bone in Bones) { uint parentId = reader.ReadUInt32(); if (parentId != 0xFFFFFFFF) { bone.Parent = Bones.FirstOrDefault(x => x.Id == parentId); } } }); }
SelectorResolver(ScopeParameterDictionary scopeParameters, StringSet scopeTables) { this._scopeParameters = scopeParameters; this._scopeTables = scopeTables; }
/* Function: Start * * Loads and combines the two versions of <Languages.txt>, returning whether it was successful. If there were any errors * they will be added to errorList. * * Dependencies: * * - <Config.Manager> and <CommentTypes.Manager> must be started before using the rest of the class. */ public bool Start(Errors.ErrorList errorList) { List <ConfigFileLanguage> systemLanguageList; List <ConfigFileLanguage> projectLanguageList; List <string> ignoredSystemExtensions; List <string> ignoredProjectExtensions; List <Language> binaryLanguages; List <KeyValuePair <string, int> > binaryAliases; List <KeyValuePair <string, int> > binaryExtensions; List <KeyValuePair <string, int> > binaryShebangStrings; List <string> binaryIgnoredExtensions; // The return value, which is whether we were able to successfully load and parse the system Languages.txt, and if // it exists, the project Languages.txt. The project Languages.txt not existing is not a failure. bool success = true; // Whether anything has changed since the last run, as determined by Languages.nd. If Languages.nd doesn't exist // or is corrupt, we have to assume something changed. bool changed = false; // First add all the predefined languages, since they may be subclassed. foreach (Language language in predefinedLanguages) { languages.Add(language); } // We need the ID numbers to stay consistent between runs, so we create all the languages from the binary file // next. We'll worry about comparing their attributes with the text files and seeing if any were added or deleted later. Languages_nd languagesNDParser = new Languages_nd(this); // Don't bother going through the effort if we're rebuilding everything anyway. if (EngineInstance.Config.ReparseEverything == true) { binaryLanguages = new List <Language>(); binaryAliases = new List <KeyValuePair <string, int> >(); binaryExtensions = new List <KeyValuePair <string, int> >(); binaryShebangStrings = new List <KeyValuePair <string, int> >(); binaryIgnoredExtensions = new List <string>(); changed = true; } else if (languagesNDParser.Load(EngineInstance.Config.WorkingDataFolder + "/Languages.nd", out binaryLanguages, out binaryAliases, out binaryExtensions, out binaryShebangStrings, out binaryIgnoredExtensions) == false) { changed = true; // Even though it failed, LoadBinaryFiles will still have created valid empty objects for them. } else // LoadBinaryFile succeeded { // We use a try block so if anything screwy happens, like two languages having the same ID number and thus // causing an exception when added, we can continue as if the binary file didn't parse at all. try { foreach (Language binaryLanguage in binaryLanguages) { // We don't add the binary language itself because we only want those for comparison purposes. We otherwise // want the languages to be at their default values because the Languages.txt versions will only set some // attributes, not all. // Check for predefined languages of the same name. If any of the binary languages' IDs collide with the // predefined languages' ones, it will be taken care of by the exception handler. Language existingLanguage = languages[binaryLanguage.Name]; if (existingLanguage == null) { Language newLanguage = new Language(this, binaryLanguage.Name); newLanguage.ID = binaryLanguage.ID; newLanguage.InBinaryFile = true; languages.Add(newLanguage); } else { existingLanguage.InBinaryFile = true; } } } catch { languages.Clear(); changed = true; foreach (Language predefinedLanguage in predefinedLanguages) { languages.Add(predefinedLanguage); } // Clear them since they may be used later in this function. binaryLanguages.Clear(); binaryAliases.Clear(); binaryExtensions.Clear(); binaryShebangStrings.Clear(); binaryIgnoredExtensions.Clear(); // Otherwise ignore the exception and continue. } } Path systemFile = EngineInstance.Config.SystemConfigFolder + "/Languages.txt"; Path projectFile = EngineInstance.Config.ProjectConfigFolder + "/Languages.txt"; Languages_txt languagesTxtParser = new Languages_txt(); // Load the files. if (!languagesTxtParser.Load(systemFile, out systemLanguageList, out ignoredSystemExtensions, errorList)) { success = false; // Continue anyway because we want to show errors from both files. } if (System.IO.File.Exists(projectFile)) { if (!languagesTxtParser.Load(projectFile, out projectLanguageList, out ignoredProjectExtensions, errorList)) { success = false; } } else { // The project file not existing is not an error condition. Fill in the variables with empty structures. projectLanguageList = new List <ConfigFileLanguage>(); ignoredProjectExtensions = new List <string>(); } if (success == false) { return(false); } // Combine the ignored extensions. StringSet ignoredExtensions = new StringSet(KeySettingsForExtensions); foreach (string extension in ignoredSystemExtensions) { ignoredExtensions.Add(extension); } foreach (string extension in ignoredProjectExtensions) { ignoredExtensions.Add(extension); } // Add the languages. We don't need to do separate passes for standard entries and alter entries because alter // entries should only appear in the project file and only apply to types in the system file. Anything else is either an // error (system file can't alter a project entry) or would have been simplified out by LoadFile (a file with an alter // entry applying to a language in the same file.) Start_AddLanguage() also prevents inappropriate properties from // being set on languages, like Line Comment on one with full language support. foreach (ConfigFileLanguage configFileLanguage in systemLanguageList) { if (!Start_AddLanguage(configFileLanguage, systemFile, true, ignoredExtensions, errorList)) { success = false; } } foreach (ConfigFileLanguage configFileLanguage in projectLanguageList) { if (!Start_AddLanguage(configFileLanguage, projectFile, false, ignoredExtensions, errorList)) { success = false; } } if (success == false) { return(false); } // Now that everything's in languages we can delete the ones that weren't in the config files, such as predefined // languages that were removed or languages that were in the binary file from the last run but were deleted. We // have to put them on a list and delete them in a second pass because deleting them while iterating through would // screw up the iterator. List <string> deletedLanguageNames = new List <string>(); foreach (Language language in languages) { if (language.InConfigFiles == false) { deletedLanguageNames.Add(language.Name); // Check this flag so we don't set it to changed if we're deleting a predefined language that wasn't in the binary // file. if (language.InBinaryFile == true) { changed = true; } } } foreach (string deletedLanguageName in deletedLanguageNames) { languages.Remove(deletedLanguageName); } // Everything is okay at this point. Save the files again to reformat them. If the project file didn't exist, saving it // with the empty structures will create it. Start_FixCapitalization(systemLanguageList); Start_FixCapitalization(projectLanguageList); if (!languagesTxtParser.Save(projectFile, projectLanguageList, ignoredProjectExtensions, errorList, true, false)) { success = false; } ; if (!languagesTxtParser.Save(systemFile, systemLanguageList, ignoredSystemExtensions, errorList, false, true)) { success = false; } ; // Generate alternate comment styles. We don't want these included in the config files but we do want them in the // binary files in case the generation method changes in a future version. foreach (Language language in languages) { if (language.Type == Language.LanguageType.BasicSupport) { language.GenerateJavadocCommentStrings(); language.GenerateXMLCommentStrings(); } } // Compare the structures with the binary ones to see if anything changed. if (binaryLanguages.Count != languages.Count || binaryAliases.Count != aliases.Count || binaryExtensions.Count != extensions.Count || binaryShebangStrings.Count != shebangStrings.Count || binaryIgnoredExtensions.Count != ignoredExtensions.Count) { changed = true; } else if (changed == false) { // Do a detailed comparison now. foreach (Language binaryLanguage in binaryLanguages) { Language language = languages[binaryLanguage.Name]; if (language == null || binaryLanguage != language) { changed = true; break; } } if (changed == false) { foreach (string binaryIgnoredExtension in binaryIgnoredExtensions) { if (ignoredExtensions.Contains(binaryIgnoredExtension) == false) { changed = true; break; } } } if (changed == false) { foreach (KeyValuePair <string, int> binaryAliasPair in binaryAliases) { // We can use ID instead of Name because we know they match now. if (aliases.ContainsKey(binaryAliasPair.Key) == false || aliases[binaryAliasPair.Key].ID != binaryAliasPair.Value) { changed = true; break; } } } if (changed == false) { foreach (KeyValuePair <string, int> binaryExtensionPair in binaryExtensions) { // We can use ID instead of Name because we know they match now. if (extensions.ContainsKey(binaryExtensionPair.Key) == false || extensions[binaryExtensionPair.Key].ID != binaryExtensionPair.Value) { changed = true; break; } } } if (changed == false) { foreach (KeyValuePair <string, int> binaryShebangStringPair in binaryShebangStrings) { // We can use ID instead of Name because we know they match now. if (shebangStrings.ContainsKey(binaryShebangStringPair.Key) == false || shebangStrings[binaryShebangStringPair.Key].ID != binaryShebangStringPair.Value) { changed = true; break; } } } } languagesNDParser.Save(EngineInstance.Config.WorkingDataFolder + "/Languages.nd", languages, aliases, extensions, shebangStrings, ignoredExtensions); if (success == true && changed == true) { EngineInstance.Config.ReparseEverything = true; } return(success); }
/* Function: Start_AddLanguage * A helper function that is used only by <Start()> to add a <ConfigFileLanguage> into <languages>. * Returns whether it was able to do so without any errors. */ private bool Start_AddLanguage(ConfigFileLanguage configFileLanguage, Path sourceFile, bool isSystemFile, StringSet ignoredExtensions, Errors.ErrorList errorList) { bool success = true; // Validate or create the language. if (configFileLanguage.AlterLanguage == true) { // If altering a language that doesn't exist at all, at least not in the config files... if (languages.Contains(configFileLanguage.Name) == false || languages[configFileLanguage.Name].InConfigFiles == false) { errorList.Add( Locale.Get("NaturalDocs.Engine", "Languages.txt.AlteredLanguageDoesntExist(name)", configFileLanguage.Name), sourceFile, configFileLanguage.LineNumber ); success = false; } } else // define language, not alter { // Error if defining a language that already exists in the config files. Having it exist otherwise is fine. if (languages.Contains(configFileLanguage.Name)) { if (languages[configFileLanguage.Name].InConfigFiles == true) { errorList.Add( Locale.Get("NaturalDocs.Engine", "Languages.txt.LanguageAlreadyExists(name)", configFileLanguage.Name), sourceFile, configFileLanguage.LineNumber ); success = false; } } else { Language newLanguage = new Language(this, configFileLanguage.Name); languages.Add(newLanguage); } if (isSystemFile) { languages[configFileLanguage.Name].InSystemFile = true; } else { languages[configFileLanguage.Name].InProjectFile = true; } } if (success == false) { return(false); } // Apply the properties. Language language = languages[configFileLanguage.Name]; if (configFileLanguage.SimpleIdentifier != null) { language.SimpleIdentifier = configFileLanguage.SimpleIdentifier; } if (configFileLanguage.LineCommentStrings != null) { if (language.Type != Language.LanguageType.BasicSupport) { Start_CantDefinePropertyError(configFileLanguage, language.Type, sourceFile, "Line Comment", errorList); success = false; } else { language.LineCommentStrings = configFileLanguage.LineCommentStrings; } } if (configFileLanguage.BlockCommentStringPairs != null) { if (language.Type != Language.LanguageType.BasicSupport) { Start_CantDefinePropertyError(configFileLanguage, language.Type, sourceFile, "Block Comment", errorList); success = false; } else { language.BlockCommentStringPairs = configFileLanguage.BlockCommentStringPairs; } } if (configFileLanguage.MemberOperator != null) { if (language.Type != Language.LanguageType.BasicSupport && language.Type != Language.LanguageType.TextFile) { Start_CantDefinePropertyError(configFileLanguage, language.Type, sourceFile, "Member Operator", errorList); success = false; } else { language.MemberOperator = configFileLanguage.MemberOperator; } } if (configFileLanguage.LineExtender != null) { if (language.Type != Language.LanguageType.BasicSupport) { Start_CantDefinePropertyError(configFileLanguage, language.Type, sourceFile, "Line Extender", errorList); success = false; } else { language.LineExtender = configFileLanguage.LineExtender; } } if (configFileLanguage.EnumValue != null) { if (language.Type != Language.LanguageType.BasicSupport && language.Type != Language.LanguageType.TextFile) { Start_CantDefinePropertyError(configFileLanguage, language.Type, sourceFile, "Enum Value", errorList); success = false; } else { language.EnumValue = (Language.EnumValues)configFileLanguage.EnumValue; } } if (configFileLanguage.CaseSensitive != null) { if (language.Type != Language.LanguageType.BasicSupport && language.Type != Language.LanguageType.TextFile) { Start_CantDefinePropertyError(configFileLanguage, language.Type, sourceFile, "Case Sensitive", errorList); success = false; } else { language.CaseSensitive = (bool)configFileLanguage.CaseSensitive; } } string[] commentTypeNamesWithPrototypeEnders = configFileLanguage.GetCommentTypeNamesWithPrototypeEnders(); if (commentTypeNamesWithPrototypeEnders != null) { if (language.Type != Language.LanguageType.BasicSupport) { Start_CantDefinePropertyError(configFileLanguage, language.Type, sourceFile, "Prototype Enders", errorList); success = false; } else { foreach (string commentTypeName in commentTypeNamesWithPrototypeEnders) { CommentTypes.CommentType commentType = EngineInstance.CommentTypes.FromName(commentTypeName); if (commentType == null) { errorList.Add( Locale.Get("NaturalDocs.Engine", "Languages.txt.PrototypeEnderCommentTypeDoesntExist(name)", commentTypeName), sourceFile, configFileLanguage.LineNumber ); success = false; } else { string[] prototypeEnderStrings = configFileLanguage.GetPrototypeEnderStrings(commentTypeName); PrototypeEnders prototypeEnders = new PrototypeEnders(prototypeEnderStrings); language.SetPrototypeEnders(commentType.ID, prototypeEnders); } } } } // Apply the aliases, extensions, and shebang strings. if (configFileLanguage.Aliases != null) { // If using Replace Aliases, find all existing aliases pointing to this language and remove them. if (configFileLanguage.AlterLanguage == true && configFileLanguage.AddAliases == false) { List <string> removedAliases = new List <string>(); foreach (KeyValuePair <string, Language> pair in aliases) { if ((object)pair.Value == (object)language) { removedAliases.Add(pair.Key); } } foreach (string removedAlias in removedAliases) { aliases.Remove(removedAlias); } } // Add new aliases. foreach (string alias in configFileLanguage.Aliases) { aliases[alias] = language; } } if (configFileLanguage.Extensions != null) { // If using Replace Extensions, find all existing extensions pointing to this language and remove them. if (configFileLanguage.AlterLanguage == true && configFileLanguage.AddExtensions == false) { List <string> removedExtensions = new List <string>(); foreach (KeyValuePair <string, Language> pair in extensions) { if ((object)pair.Value == (object)language) { removedExtensions.Add(pair.Key); } } foreach (string removedExtension in removedExtensions) { extensions.Remove(removedExtension); } } // Add new extensions. foreach (string extension in configFileLanguage.Extensions) { if (ignoredExtensions.Contains(extension) == false) { extensions[extension] = language; } } } if (configFileLanguage.ShebangStrings != null) { // If using Replace Shebang Strings, find all existing shebang strings pointing to this language and remove them. if (configFileLanguage.AlterLanguage == true && configFileLanguage.AddShebangStrings == false) { List <string> removedShebangStrings = new List <string>(); foreach (KeyValuePair <string, Language> pair in shebangStrings) { if ((object)pair.Value == (object)language) { removedShebangStrings.Add(pair.Key); } } foreach (string removedShebangString in removedShebangStrings) { shebangStrings.Remove(removedShebangString); } } // Add new shebang strings. foreach (string shebangString in configFileLanguage.ShebangStrings) { shebangStrings[shebangString] = language; } } return(success); }
internal abstract void WriteBody(EndianBinaryWriter writer, StringSet stringSet, BinaryFormat format);
/* Function: Start * * Loads and combines the two versions of <Comments.txt>, returning whether it was successful. If there were any errors * they will be added to errorList. * * Dependencies: * * - <Config.Manager> must be started before this class can start. */ public bool Start(Errors.ErrorList errorList) { List <ConfigFileCommentType> systemCommentTypeList; List <ConfigFileCommentType> projectCommentTypeList; List <string> ignoredSystemKeywords; List <string> ignoredProjectKeywords; List <string> systemTags; List <string> projectTags; List <CommentType> binaryCommentTypes; List <Tag> binaryTags; List <KeyValuePair <string, int> > binarySingularKeywords; List <KeyValuePair <string, int> > binaryPluralKeywords; List <string> binaryIgnoredKeywords; // The return value, which is whether we were able to successfully load and parse the system Comments.txt, and if it exists, // the project Comments.txt. The project Comments.txt not existing is not a failure. bool success = true; // Whether anything has changed since the last run, as determined by Comments.nd. If Comments.nd doesn't exist or is corrupt, // we have to assume something changed. bool changed = false; Comments_nd commentsNDParser = new Comments_nd(); // We need the ID numbers to stay consistent between runs, so we need to create all the comment types and tags from the // binary file first. We'll worry about comparing their attributes and seeing if any were added or deleted later. if (EngineInstance.Config.ReparseEverything == true) { binaryCommentTypes = new List <CommentType>(); binaryTags = new List <Tag>(); binarySingularKeywords = new List <KeyValuePair <string, int> >(); binaryPluralKeywords = new List <KeyValuePair <string, int> >(); binaryIgnoredKeywords = new List <string>(); changed = true; } else if (commentsNDParser.Load(EngineInstance.Config.WorkingDataFolder + "/Comments.nd", out binaryCommentTypes, out binaryTags, out binarySingularKeywords, out binaryPluralKeywords, out binaryIgnoredKeywords) == false) { changed = true; // Even though it failed, LoadBinaryFile will still create valid empty objects for the variables. } else // Load binary file succeeded { // We use a try block so if anything screwy happens, like two things having the same ID number and thus causing // an exception when added, we can continue as if the binary file didn't parse at all. try { foreach (CommentType binaryCommentType in binaryCommentTypes) { // We don't add the binary comment type itself because we only want those for comparison purposes. We want // the types in commentTypes to be at their default values because the Comments.txt versions will only set some attributes, // not all, and we don't want the unset attributes influenced by the binary versions. CommentType newCommentType = new CommentType(binaryCommentType.Name); newCommentType.ID = binaryCommentType.ID; newCommentType.Flags.InBinaryFile = true; commentTypes.Add(newCommentType); } foreach (Tag binaryTag in binaryTags) { Tag newTag = new Tag(binaryTag.Name); newTag.ID = binaryTag.ID; newTag.InBinaryFile = true; tags.Add(newTag); } } catch { commentTypes.Clear(); tags.Clear(); changed = true; // Clear them since they may be used later in this function. binaryCommentTypes.Clear(); binarySingularKeywords.Clear(); binaryPluralKeywords.Clear(); binaryIgnoredKeywords.Clear(); // Otherwise ignore the exception and continue. } } Path systemFile = EngineInstance.Config.SystemConfigFolder + "/Comments.txt"; Path projectFile = EngineInstance.Config.ProjectConfigFolder + "/Comments.txt"; Path oldProjectFile = EngineInstance.Config.ProjectConfigFolder + "/Topics.txt"; Comments_txt commentsTxtParser = new Comments_txt(); // Load the files. if (!commentsTxtParser.Load(systemFile, out systemCommentTypeList, out ignoredSystemKeywords, out systemTags, errorList)) { success = false; // Continue anyway because we want to show errors from both files. } if (System.IO.File.Exists(projectFile)) { if (!commentsTxtParser.Load(projectFile, out projectCommentTypeList, out ignoredProjectKeywords, out projectTags, errorList)) { success = false; } } else if (System.IO.File.Exists(oldProjectFile)) { if (!commentsTxtParser.Load(oldProjectFile, out projectCommentTypeList, out ignoredProjectKeywords, out projectTags, errorList)) { success = false; } } else { // The project file not existing is not an error condition. Fill in the variables with empty structures. projectCommentTypeList = new List <ConfigFileCommentType>(); ignoredProjectKeywords = new List <string>(); projectTags = new List <string>(); } if (success == false) { return(false); } // Combine the ignored keywords. StringSet ignoredKeywords = new StringSet(KeySettingsForKeywords); foreach (string keyword in ignoredSystemKeywords) { if (keyword != null) { ignoredKeywords.Add(keyword); } } foreach (string keyword in ignoredProjectKeywords) { if (keyword != null) { ignoredKeywords.Add(keyword); } } // Combine the tags foreach (string tagName in systemTags) { Tag tag = tags[tagName]; if (tag == null) { tag = new Tag(tagName); tag.InSystemFile = true; tags.Add(tag); } else { tag.InSystemFile = true; // In case it changed since the binary version. tag.FixNameCapitalization(tagName); } } foreach (string tagName in projectTags) { Tag tag = tags[tagName]; if (tag == null) { tag = new Tag(tagName); tag.InProjectFile = true; tags.Add(tag); } else { tag.InProjectFile = true; tag.FixNameCapitalization(tagName); } } // All the comment types have to exist in IDObjects.Manager before the properties are set because Index With will need their // IDs. This pass only creates the types that were not already created by the binary file. // We don't need to do separate passes for standard entries and alter entries because alter entries should only appear // in the project file and only apply to types in the system file. Anything else is either an error (system file can't alter a // project entry) or would have been simplified out by LoadFile (a file with an alter entry applying to a type in the same // file.) foreach (ConfigFileCommentType commentType in systemCommentTypeList) { if (!Start_CreateType(commentType, systemFile, true, errorList)) { success = false; } } foreach (ConfigFileCommentType commentType in projectCommentTypeList) { if (!Start_CreateType(commentType, projectFile, false, errorList)) { success = false; } } // Need to exit early because Start_ApplyProperties assumes all the types were created correctly. if (success == false) { return(false); } // Now that everything's in commentTypes we can delete the ones that aren't in the text files, meaning they were in // the binary file from the last run but were deleted since then. We have to put them on a list and delete them in a // second pass because deleting them while iterating through would screw up the iterator. List <int> deletedIDs = new List <int>(); foreach (CommentType commentType in commentTypes) { if (commentType.Flags.InConfigFiles == false) { deletedIDs.Add(commentType.ID); changed = true; } } foreach (int deletedID in deletedIDs) { commentTypes.Remove(deletedID); } // Delete the tags that weren't in the text files as well. deletedIDs.Clear(); foreach (Tag tag in tags) { if (tag.InConfigFiles == false) { deletedIDs.Add(tag.ID); changed = true; } } foreach (int deletedID in deletedIDs) { tags.Remove(deletedID); } // Fill in the properties foreach (ConfigFileCommentType commentType in systemCommentTypeList) { if (!Start_ApplyProperties(commentType, systemFile, ignoredKeywords, errorList)) { success = false; } } foreach (ConfigFileCommentType commentType in projectCommentTypeList) { if (!Start_ApplyProperties(commentType, projectFile, ignoredKeywords, errorList)) { success = false; } } if (success == false) { return(false); } // Make sure there are no circular dependencies in Index With. foreach (CommentType commentType in commentTypes) { if (commentType.Index == CommentType.IndexValue.IndexWith) { IDObjects.NumberSet ids = new IDObjects.NumberSet(); CommentType currentType = commentType; do { ids.Add(currentType.ID); if (ids.Contains(currentType.IndexWith)) { // Start the dependency message on the repeated comment type, not on the one the loop started with because // it could go A > B > C > B, in which case reporting A is irrelevant. int repeatedID = currentType.IndexWith; CommentType iterator = commentTypes[repeatedID]; string repeatMessage = iterator.Name; // We want the error message to be on the repeated type only if that's the only one: A > A. Otherwise we // want it to be the second to last one: C in A > B > C > B. CommentType errorMessageTarget = currentType; for (;;) { iterator = commentTypes[iterator.IndexWith]; repeatMessage += " > " + iterator.Name; if (iterator.ID == repeatedID) { break; } errorMessageTarget = iterator; } Path errorMessageFile; List <ConfigFileCommentType> searchList; if (errorMessageTarget.Flags.InProjectFile) { errorMessageFile = projectFile; searchList = projectCommentTypeList; } else { errorMessageFile = systemFile; searchList = systemCommentTypeList; } int errorMessageLineNumber = 0; string lcErrorMessageTargetName = errorMessageTarget.Name.ToLower(); foreach (ConfigFileCommentType searchListType in searchList) { if (searchListType.Name.ToLower() == lcErrorMessageTargetName) { errorMessageLineNumber = searchListType.LineNumber; break; } } errorList.Add( Locale.Get("NaturalDocs.Engine", "Comments.txt.CircularDependencyInIndexWith(list)", repeatMessage), errorMessageFile, errorMessageLineNumber ); return(false); } currentType = commentTypes[currentType.IndexWith]; }while (currentType.Index == CommentType.IndexValue.IndexWith); } } // Simplify Index With. So A > B > C becomes A > C. Also A > B = no indexing becomes A = no indexing. foreach (CommentType commentType in commentTypes) { if (commentType.Index == CommentType.IndexValue.IndexWith) { CommentType targetCommentType = commentTypes[commentType.IndexWith]; while (targetCommentType.Index == CommentType.IndexValue.IndexWith) { targetCommentType = commentTypes[targetCommentType.IndexWith]; } if (targetCommentType.Index == CommentType.IndexValue.No) { commentType.Index = CommentType.IndexValue.No; } else { commentType.IndexWith = targetCommentType.ID; } } } // Everything is okay at this point. Save the files again to reformat them. If the project file didn't exist, saving it // with the empty structures we created will create it. Start_FixCapitalization(systemCommentTypeList); Start_FixCapitalization(projectCommentTypeList); if (!commentsTxtParser.Save(projectFile, projectCommentTypeList, ignoredProjectKeywords, projectTags, errorList, true, false)) { success = false; } ; if (!commentsTxtParser.Save(systemFile, systemCommentTypeList, ignoredSystemKeywords, systemTags, errorList, false, true)) { success = false; } ; // Compare the structures with the binary ones to see if anything changed. if (changed == false) { // First an easy comparison. if (binaryCommentTypes.Count != commentTypes.Count || binaryTags.Count != tags.Count || binaryIgnoredKeywords.Count != ignoredKeywords.Count || singularKeywords.Count != binarySingularKeywords.Count || pluralKeywords.Count != binaryPluralKeywords.Count) { changed = true; } } if (changed == false) { // Next a detailed comparison if necessary. foreach (CommentType binaryCommentType in binaryCommentTypes) { CommentType commentType = commentTypes[binaryCommentType.ID]; if (commentType == null || binaryCommentType != commentType) { changed = true; break; } } if (changed == false) { foreach (Tag binaryTag in binaryTags) { Tag tag = tags[binaryTag.ID]; if (tag == null || binaryTag != tag) { changed = true; break; } } } if (changed == false) { foreach (string binaryIgnoredKeyword in binaryIgnoredKeywords) { if (!ignoredKeywords.Contains(binaryIgnoredKeyword)) { changed = true; break; } } } if (changed == false) { foreach (KeyValuePair <string, int> binarySingularKeywordPair in binarySingularKeywords) { // We can use ID instead of Name because we know they match now. if (singularKeywords.ContainsKey(binarySingularKeywordPair.Key) == false || singularKeywords[binarySingularKeywordPair.Key].ID != binarySingularKeywordPair.Value) { changed = true; break; } } } if (changed == false) { foreach (KeyValuePair <string, int> binaryPluralKeywordPair in binaryPluralKeywords) { // We can use ID instead of Name because we know they match now. if (pluralKeywords.ContainsKey(binaryPluralKeywordPair.Key) == false || pluralKeywords[binaryPluralKeywordPair.Key].ID != binaryPluralKeywordPair.Value) { changed = true; break; } } } } commentsNDParser.Save(EngineInstance.Config.WorkingDataFolder + "/Comments.nd", commentTypes, tags, singularKeywords, pluralKeywords, ignoredKeywords); if (success == true && changed == true) { EngineInstance.Config.ReparseEverything = true; } groupCommentTypeID = IDFromKeyword("group"); return(success); }
/* Function: TestFolder * Tests all the input files contained in this folder. See <EngineInstanceManager.Start()> for how relative paths are handled. */ public void TestFolder(Path testDataFolder, Path projectConfigFolder = default(Path)) { TestList allTests = new TestList(); StringSet expectedOutputFiles = new StringSet(); engineInstanceManager = new EngineInstanceManager(); engineInstanceManager.Start(testDataFolder, projectConfigFolder); // Store this so we can still use it for error messages after the engine is disposed of. Path inputFolder = engineInstanceManager.InputFolder; try { engineInstanceManager.Run(); // Iterate through classes to build output files. using (Engine.CodeDB.Accessor accessor = EngineInstance.CodeDB.GetAccessor()) { // Class IDs should be assigned sequentially. It's not an ideal way to do this though. int classID = 1; accessor.GetReadOnlyLock(); try { for (;;) { List <Topic> classTopics = accessor.GetTopicsInClass(classID, Delegates.NeverCancel); ClassView.Merge(ref classTopics, engineInstanceManager.EngineInstance); if (classTopics == null || classTopics.Count == 0) { break; } string testName = classTopics[0].ClassString.Symbol.FormatWithSeparator("."); Path outputFilePath = Test.ActualOutputFileOf(testName, inputFolder); Test test = Test.FromActualOutputFile(outputFilePath); expectedOutputFiles.Add(test.ExpectedOutputFile); try { test.SetActualOutput(OutputOf(classTopics)); } catch (Exception e) { test.TestException = e; } test.Run(); allTests.Add(test); classID++; } } finally { accessor.ReleaseLock(); } } // Now search for any expected output files that didn't have corresponding actual output files. string[] files = System.IO.Directory.GetFiles(inputFolder); foreach (string file in files) { if (Test.IsExpectedOutputFile(file) && expectedOutputFiles.Contains(file) == false) { Test test = Test.FromExpectedOutputFile(file); test.Run(); allTests.Add(test); expectedOutputFiles.Add(file); } } } finally { engineInstanceManager.Dispose(); engineInstanceManager = null; } if (allTests.Count == 0) { Assert.Fail("There were no tests found in " + inputFolder); } else if (allTests.Passed == false) { Assert.Fail(allTests.BuildFailureMessage()); } }
public static void LoadPropertiesFromXmlStream(this IDictionary propertyBag, XmlReader reader) { while (reader.IsStartElement(PROPERTIES_ID) || reader.IsStartElement(PROPERTY_ID)) { string key = null; string value = null; bool isEmpty; if (reader.IsStartElement(PROPERTIES_ID)) { key = reader.GetAttribute(KEY_ID); string typeName = reader.GetAttribute(TYPE_ID); IDictionary nestedPropertyBag; if (String.IsNullOrEmpty(typeName)) { nestedPropertyBag = new PropertyBag(); } else { Type type = GetPropertyBagType(typeName); nestedPropertyBag = (IDictionary)Activator.CreateInstance(type); } propertyBag[key] = nestedPropertyBag; isEmpty = reader.IsEmptyElement; reader.ReadStartElement(PROPERTIES_ID); LoadPropertiesFromXmlStream(nestedPropertyBag, reader); if (!isEmpty) { reader.ReadEndElement(); } } else { key = reader.GetAttribute(KEY_ID); value = reader.GetAttribute(VALUE_ID); string typeName = reader.GetAttribute(TYPE_ID); isEmpty = reader.IsEmptyElement; if (typeName == STRING_SET_ID) { StringSet set = new StringSet(); propertyBag[key] = set; LoadStringSet(set, reader); if (!isEmpty) { reader.ReadEndElement(); } continue; } reader.ReadStartElement(PROPERTY_ID); Type propertyType = GetPropertyBagType(typeName); if (typeName == "System.Version") { Version version; bool succeeded = Version.TryParse(value, out version); Debug.Assert(succeeded); propertyBag[key] = version; continue; } TypeConverter tc = TypeDescriptor.GetConverter(propertyType); Debug.Assert(tc.CanConvertFrom(typeof(string))); object propertyValue = tc.ConvertFromString(value); propertyBag[key] = propertyValue; Debug.Assert(isEmpty); } } }
/* Function: Save * Saves the current computed comment types into <Comments.nd>. Throws an exception if unsuccessful. */ public void Save(Path filename, IDObjects.Manager <CommentType> commentTypes, IDObjects.Manager <Tag> tags, StringTable <CommentType> singularKeywords, StringTable <CommentType> pluralKeywords, StringSet ignoredKeywords) { BinaryFile file = new BinaryFile(); file.OpenForWriting(filename); try { // [String: Tag Name] // [Int32: ID] // ... // [String: null] foreach (Tag tag in tags) { file.WriteString(tag.Name); file.WriteInt32(tag.ID); } file.WriteString(null); // [String: Comment Type Name] // [Int32: ID] // [String: Display Name] // [String: Plural Display Name] // [String: Simple Identifier] // [Byte: Index] // [Int32: Index With ID]? // [Byte: Scope] // [Byte: Break Lists] // [UInt16: Flags] // ... // [String: null] foreach (CommentType commentType in commentTypes) { file.WriteString(commentType.Name); file.WriteInt32(commentType.ID); file.WriteString(commentType.DisplayName); file.WriteString(commentType.PluralDisplayName); file.WriteString(commentType.SimpleIdentifier); file.WriteByte((byte)commentType.Index); if (commentType.Index == CommentType.IndexValue.IndexWith) { file.WriteInt32(commentType.IndexWith); } file.WriteByte((byte)commentType.Scope); file.WriteByte((byte)(commentType.BreakLists ? 1 : 0)); file.WriteUInt16((ushort)commentType.Flags.AllConfigurationProperties); } file.WriteString(null); // [String: Singular Keyword] // [Int32: Comment Type ID] // ... // [String: null] foreach (KeyValuePair <string, CommentType> pair in singularKeywords) { file.WriteString(pair.Key); file.WriteInt32(pair.Value.ID); } file.WriteString(null); // [String: Plural Keyword] // [Int32: Comment Type ID] // ... // [String: null] foreach (KeyValuePair <string, CommentType> pair in pluralKeywords) { file.WriteString(pair.Key); file.WriteInt32(pair.Value.ID); } file.WriteString(null); // [String: Ignored Keyword] // ... // [String: null] foreach (string keyword in ignoredKeywords) { file.WriteString(keyword); } file.WriteString(null); } finally { file.Close(); } }
public void Operators() { StringSet ss = new StringSet(); ss = ss + "bloo" + "bar"; Assert.AreEqual(2, ss.Count); StringSet so = ss; Assert.AreEqual(ss, so); Assert.AreEqual(ss.GetHashCode(), so.GetHashCode()); so = new StringSet(so); Assert.AreEqual(ss, so); Assert.AreEqual(ss.GetHashCode(), so.GetHashCode()); so = ss - "bar"; Assert.AreEqual(1, so.Count); Assert.AreNotEqual(ss, so); Assert.IsTrue(ss != so); Assert.AreNotEqual(ss.GetHashCode(), so.GetHashCode()); }
private static void SaveStringSet(XmlWriter writer, StringSet items, string key) { writer.WriteStartElement(PROPERTY_ID); writer.WriteAttributeString(KEY_ID, key); writer.WriteAttributeString(TYPE_ID, "StringSet"); string[] sorted = new string[items.Count]; items.CopyTo(sorted, 0); Array.Sort(sorted); foreach (string item in sorted) { writer.WriteStartElement(ITEM_ID); writer.WriteString(item); writer.WriteEndElement(); // Item } writer.WriteEndElement(); // Property }
public QueryModel(ScopeParameterDictionary scopeParameters, StringSet scopeTables) : this(scopeParameters, scopeTables, false) { }
private static void LoadStringSet(StringSet set, XmlReader reader) { reader.ReadStartElement(PROPERTY_ID); while (reader.IsStartElement(ITEM_ID)) { string item; bool isEmptyItem; isEmptyItem = reader.IsEmptyElement; reader.ReadStartElement(); item = reader.ReadString(); set.Add(item); if (!isEmptyItem) reader.ReadEndElement(); } }
private static StringSet BuildApprovedFunctionsStringSet() { var result = new StringSet(); result.Add("_TlgWrite"); return result; }
public void Null() { StringSet ss = new StringSet(); ss.Add((string)null); }
public StringSet GetAllFeatures(CapsManager caps) { if (caps == null) throw new ArgumentNullException("caps"); StringSet features = new StringSet(); foreach (Presence p in m_all) { StringSet f = GetFeatures(caps, p); if (f != null) features.Add(f); } return features; }
private void CalculateTailFirsts() { foreach (Production prod in _data.Productions) { StringSet accumulatedFirsts = new StringSet(); bool allNullable = true; for (int i = prod.LR0Items.Count - 1; i >= 0; i--) { LR0Item item = prod.LR0Items[i]; if (i >= prod.LR0Items.Count - 2) { item.TailIsNullable = true; item.TailFirsts.Clear(); continue; } GrammarTerm term = prod.RValues[item.Position + 1]; NonTerminal ntElem = term as NonTerminal; if (ntElem == null || !ntElem.Nullable) { accumulatedFirsts.Clear(); allNullable = false; item.TailIsNullable = false; if (ntElem == null) { item.TailFirsts.Add(term.Key); accumulatedFirsts.Add(term.Key); } else { item.TailFirsts.AddRange(ntElem.Firsts); accumulatedFirsts.AddRange(ntElem.Firsts); } continue; } accumulatedFirsts.AddRange(ntElem.Firsts); item.TailFirsts.AddRange(accumulatedFirsts); item.TailIsNullable = allNullable; } } }
/// <summary> /// Clear all of the features from the /// </summary> public void ClearFeatures() { this.RemoveElems <DiscoFeature>(); m_features = null; }
public override JoinQueryResult ToJoinQueryResult(JoinType joinType, LambdaExpression conditionExpression, ScopeParameterDictionary scopeParameters, StringSet scopeTables, Func <string, string> tableAliasGenerator) { scopeParameters = scopeParameters.Clone(conditionExpression.Parameters.Last(), this.QueryModel.ResultModel); DbExpression condition = GeneralExpressionParser.Parse(conditionExpression, scopeParameters, scopeTables); DbJoinTableExpression joinTable = new DbJoinTableExpression(joinType.AsDbJoinType(), this.QueryModel.FromTable.Table, condition); if (!this.QueryModel.IgnoreFilters) { joinTable.Condition = joinTable.Condition.And(this.QueryModel.ContextFilters).And(this.QueryModel.GlobalFilters); } JoinQueryResult result = new JoinQueryResult(); result.ResultModel = this.QueryModel.ResultModel; result.JoinTable = joinTable; return(result); }
private void ValidateAll() { StringSet ntList = new StringSet(); foreach (NonTerminal nt in _data.NonTerminals) { if (nt == _data.AugmentedRoot) continue; BnfExpressionData data = nt.Rule.Data; if (data.Count == 1 && data[0].Count == 1 && data[0][0] is NonTerminal) ntList.Add(nt.Name); } if (ntList.Count > 0) { AddError("Warning: Possible non-terminal duplication. The following non-terminals have rules containing a single non-terminal: \r\n {0}. \r\n" + "Consider merging two non-terminals; you may need to use 'nt1 = nt2;' instead of 'nt1.Rule=nt2'."); } }
//Constructs the error message in situation when parser has no available action for current input. // override this method if you want to change this message public virtual string ConstructParserErrorMessage(ParsingContext context, StringSet expectedTerms) { return string.Format(Resources.ErrParserUnexpInput, expectedTerms.ToString(" ")); }
static QueryModel CreateQueryModel(RootQueryExpression rootQueryExp, ScopeParameterDictionary scopeParameters, StringSet scopeTables, Func <string, string> tableAliasGenerator) { Type entityType = rootQueryExp.ElementType; if (entityType.IsAbstract || entityType.IsInterface) { throw new ArgumentException("The type of input can not be abstract class or interface."); } QueryModel queryModel = new QueryModel(scopeParameters, scopeTables); TypeDescriptor typeDescriptor = EntityTypeContainer.GetDescriptor(entityType); DbTable dbTable = typeDescriptor.GenDbTable(rootQueryExp.ExplicitTable); string alias = null; if (tableAliasGenerator != null) { alias = tableAliasGenerator(dbTable.Name); } else { alias = queryModel.GenerateUniqueTableAlias(dbTable.Name); } queryModel.FromTable = CreateRootTable(dbTable, alias, rootQueryExp.Lock); DbTable aliasTable = new DbTable(alias); ComplexObjectModel model = typeDescriptor.GenObjectModel(aliasTable); model.DependentTable = queryModel.FromTable; queryModel.ResultModel = model; ParseFilters(queryModel, typeDescriptor.Definition.Filters, rootQueryExp.ContextFilters); return(queryModel); }
private StringList GetCurrentExpectedSymbols() { BnfTermList inputElements = new BnfTermList(); StringSet inputKeys = new StringSet(); inputKeys.AddRange(_currentState.Actions.Keys); //First check all NonTerminals foreach (NonTerminal nt in Data.NonTerminals) { if (!inputKeys.Contains(nt.Key)) continue; //nt is one of our available inputs; check if it has an alias. If not, don't add it to element list; // and we have already all its "Firsts" keys in the list. // If yes, add nt to element list and remove // all its "fists" symbols from the list. These removed symbols will be represented by single nt alias. if (string.IsNullOrEmpty(nt.DisplayName)) inputKeys.Remove(nt.Key); else { inputElements.Add(nt); foreach(string first in nt.Firsts) inputKeys.Remove(first); } } //Now terminals foreach (Terminal term in Data.Terminals) { if (inputKeys.Contains(term.Key)) inputElements.Add(term); } StringList result = new StringList(); foreach(BnfTerm term in inputElements) result.Add(string.IsNullOrEmpty(term.DisplayName)? term.Name : term.DisplayName); result.Sort(); return result; }
//Constructs the error message in situation when parser has no available action for current input. // override this method if you want to change this message public virtual string ConstructParserErrorMessage(ParsingContext context, StringSet expectedTerms) { if(expectedTerms.Count > 0) return string.Format(Resources.ErrSyntaxErrorExpected, expectedTerms.ToString(", ")); else return Resources.ErrParserUnexpectedInput; }
public void AddFeatures(DiscoFeature[] features) { if (Features == null) Features = new StringSet(); // features may be null when used from outside. if (features != null) { foreach (DiscoFeature f in features) Features.Add(f.Var); } DoCallbacks(m_featureCallbacks); }
public RootQueryState(RootQueryExpression rootQueryExp, ScopeParameterDictionary scopeParameters, StringSet scopeTables, Func <string, string> tableAliasGenerator) : base(CreateQueryModel(rootQueryExp, scopeParameters, scopeTables, tableAliasGenerator)) { this._rootQueryExp = rootQueryExp; }
/// <summary> /// Clear out any features already in the list. /// </summary> public void ClearFeatures() { Features = null; }
internal abstract void ReadBody(EndianBinaryReader reader, StringSet stringSet);
private StringSet FilterBracesInExpectedSet(StringSet stateExpectedSet) { var result = new StringSet(); result.UnionWith(stateExpectedSet); //Find what brace we expect var nextClosingBrace = string.Empty; if (OpenBraces.Count > 0) { var lastOpenBraceTerm = OpenBraces.Peek().KeyTerm; var nextClosingBraceTerm = lastOpenBraceTerm.IsPairFor as KeyTerm; if (nextClosingBraceTerm != null) nextClosingBrace = nextClosingBraceTerm.Text; } //Now check all closing braces in result set, and leave only nextClosingBrace foreach(var closingBrace in Language.GrammarData.ClosingBraces) { if (result.Contains(closingBrace) && closingBrace != nextClosingBrace) result.Remove(closingBrace); } return result; }
public RootQueryState(RootQueryExpression rootQueryExp, ScopeParameterDictionary scopeParameters, StringSet scopeTables) : this(rootQueryExp, scopeParameters, scopeTables, null) { }