/// <summary> /// Creates a new code scope for a type is one does not already exist, else it turns the existing scope for the type. /// </summary> /// <param name="typeName">Name of the type</param> /// <param name="definitionAddress">Guerilla definition address for the type</param> /// <param name="scopeType">Type of code scope to be created</param> /// <returns>The code scope for the type.</returns> public MutationCodeScope CreateCodeScopeForType(string typeName, int definitionAddress, MutationCodeScopeType scopeType) { // Check if there is an entry in the Types list with the same definition address. MutationCodeScope codeScope = FindExistingCodeScope(definitionAddress); if (codeScope != null) { // There is an existing code scope for this type so just return that. return(codeScope); } // Create a code safe type name for the new type. string newTypeName, displayName, units, tooltip; EditorMarkUpFlags markupFlags; MutationCodeFormatter.ProcessFieldName(typeName, out newTypeName, out displayName, out units, out tooltip, out markupFlags); if (newTypeName == "" || MutationCodeFormatter.IsValidFieldName(newTypeName) == false) { // For now we will create a no name type for it, and I will create a preprocessing function later on. newTypeName = this.CreateNoNameType(); } // Check if the type is an enum or flags and append the corresponding character. if (scopeType == MutationCodeScopeType.Bitmask) { // Append 'b' for bitmask. newTypeName = newTypeName.Insert(0, char.IsUpper(newTypeName[0]) == true ? "b" : "b_"); } else if (scopeType == MutationCodeScopeType.Enum) { // Append 'e' for enum. newTypeName = newTypeName.Insert(0, char.IsUpper(newTypeName[0]) == true ? "e" : "e_"); } // Check if the type name is unique or if it already exists. if (this.Types.Keys.Contains(newTypeName) == true) { string tempTypeName = ""; // This shouldn't really happen, but if it does loop until we have a valid type name. int uniqueInt = 1; do { // Append an integer to the type name to try and make it unique. tempTypeName = string.Format("{0}{1}", newTypeName, uniqueInt++); }while (this.Types.Keys.Contains(tempTypeName) == true); // Save the temp type name. newTypeName = tempTypeName; } // Create a new code scope for this type. codeScope = new MutationCodeScope(newTypeName, this.Namespace, definitionAddress, scopeType); // Add the new type to the types dictionary. this.Types.Add(newTypeName, codeScope); // Return the new code scope for the type. return(codeScope); }
/// <summary> /// Creates a new code safe flag name that is unique in the current code scope and adds it to the fields list. /// </summary> /// <param name="fieldName">Name of the flag.</param> /// <returns>The new code safe representation of the flag name.</returns> public string CreateCodeSafeFlagName(string fieldName) { // Convert the flag name to a code safe representation. string newFlagName = MutationCodeFormatter.CreateCodeSafeFieldName(fieldName); // Make sure the new flag name is unique in the code scope. if (this.Fields.Contains(newFlagName) == true) { string tempFlagName = ""; // Loop and append an integer until the flag name becomes unique. int uniqueInt = 1; do { // Append an integer to the flag name to try and make it unique. tempFlagName = String.Format("{0}{1}", tempFlagName, uniqueInt++); }while (this.Fields.Contains(tempFlagName) == true); // Save the new field name. newFlagName = tempFlagName; } // Add the new flag name to the fields list. this.Fields.Add(newFlagName); // Return the new flag name. return(newFlagName); }
/// <summary> /// Creates a new code safe field name that is unique in the current scope and adds it to the fields list for this scope. /// </summary> /// <param name="fieldType">Type of field.</param> /// <param name="fieldName">Name of the field</param> /// <param name="displayName">The UI mark up display name for the field.</param> /// <param name="units">String to receive the units specifier is one is present</param> /// <param name="tooltip">String to receive the tooltip text if it is present</param> /// <param name="markupFlags">The UI markup flags for this field.</param> /// <returns>The new code safe field name for the field</returns> public string CreateCodeSafeFieldName(field_type fieldType, string fieldName, out string displayName, out string units, out string tooltip, out EditorMarkUpFlags markupFlags) { string newFieldName = ""; // Satisfy the compiler. displayName = string.Empty; units = string.Empty; tooltip = string.Empty; markupFlags = EditorMarkUpFlags.None; // Check if the field is a padding field. if (fieldType == field_type._field_pad || fieldType == field_type._field_skip || fieldType == field_type._field_useless_pad) { // Create a new padding field name. return(AddPaddingField()); } else if (fieldType == field_type._field_explanation) { // Create a new explanation field name. return(AddExplanationField()); } // Check if the name is invalid. if (MutationCodeFormatter.IsValidFieldName(fieldName) == false) { // Create a new no-name field name. return(AddNoNameField()); } // Convert the field name to a code safe representation. MutationCodeFormatter.ProcessFieldName(fieldName, out newFieldName, out displayName, out units, out tooltip, out markupFlags); if (newFieldName == "") { // Create a new no-name field name. return(AddNoNameField()); } // Make sure the new field name is unique in the code scope. if (this.Fields.Contains(newFieldName) == true) { string tempFieldName = ""; // Loop and append an integer until the field name becomes unique. int uniqueInt = 1; do { // Append an integer to the field name to try and make it unique. tempFieldName = String.Format("{0}{1}", newFieldName, uniqueInt++); }while (this.Fields.Contains(tempFieldName) == true); // Save the new field name. newFieldName = tempFieldName; } // Add the new field name to the fields list. this.Fields.Add(newFieldName); // Return the new field name. return(newFieldName); }
public void WriteToFile(string folder) { // Check if the definition is a tag group or tag block and write it to the correct location. if (this.TagBlockDefinition.IsTagGroup == true) { // Write the tag group to file. this.CodeCreator.WriteToFile(string.Format("{0}\\{1}.cs", folder, MutationCodeFormatter.CreateCodeSafeFieldName(this.TagBlockDefinition.s_tag_block_definition.Name))); } else { // Write the block definition to file. this.CodeCreator.WriteToFile(string.Format("{0}\\BlockDefinitions\\{1}.cs", folder, MutationCodeFormatter.CreateCodeSafeFieldName(this.TagBlockDefinition.s_tag_block_definition.Name))); } }
/// <summary> /// Creates a new field for the specified type and adds it to the current code object. /// </summary> /// <param name="fieldType">Guerilla field type of the field.</param> /// <param name="fieldName">Name of the field.</param> /// <param name="attributeCollection">Collection of attributes to be put on the field.</param> public void AddField(field_type fieldType, string fieldName, CodeAttributeDeclarationCollection attributeCollection = null) { // Get the underlying type for this field. Type standardFieldType = ValueTypeDictionary[fieldType]; // Create a new code member field for the tag field. CodeMemberField field = new CodeMemberField(MutationCodeFormatter.CreateShortCodeTypeReference(standardFieldType, MutationNamespaces), fieldName); field.Attributes = MemberAttributes.Public; // Add any attributes for this field. field.CustomAttributes = attributeCollection; // Add the field to the class definition. this.CodeClass.Members.Add(field); }
/// <summary> /// Creates a new tag block field and adds it to the current code object. /// </summary> /// <param name="fieldName">Name of the field.</param> /// <param name="blockTypeName">Name of the underlying tag block definition type.</param> /// <param name="attributeCollection">Collection of attributes to be put on the field.</param> public void AddTagBlockField(string fieldName, string blockTypeName, CodeAttributeDeclarationCollection attributeCollection = null) { // Create a new code type reference to reference the tag_block data type. CodeTypeReference tagBlockType = MutationCodeFormatter.CreateShortCodeTypeReference(ValueTypeDictionary[field_type._field_block], MutationNamespaces); tagBlockType.TypeArguments.Add(blockTypeName); // Create a new code member field for the tag field. CodeMemberField field = new CodeMemberField(tagBlockType, fieldName); field.Attributes = MemberAttributes.Public; // Add any attributes for this field. field.CustomAttributes = attributeCollection; // Add the field to the class definition. this.CodeClass.Members.Add(field); }
/// <summary> /// Creates a new Explanation field using the information provided. /// </summary> /// <param name="fieldName">Name of the explanation field.</param> /// <param name="blockName">Name of the explanation block.</param> /// <param name="explanation">Explanation for the block.</param> /// <param name="attributeCollection">Collection of attributes to be put on the field.</param> public void AddExplanationField(string fieldName, string blockName = "", string explanation = "", CodeAttributeDeclarationCollection attributeCollection = null) { // Get the underlying type for this field. Type standardFieldType = ValueTypeDictionary[field_type._field_explanation]; // Create a new code member field for the explanation block. CodeMemberField field = new CodeMemberField(MutationCodeFormatter.CreateShortCodeTypeReference(standardFieldType, MutationNamespaces), fieldName); field.Attributes = MemberAttributes.Public; // Create a list of parameters to give to the explanation constructor. List <CodeExpression> initializers = new List <CodeExpression>(); // Check if the block name is present. if (blockName != string.Empty) { // Create a code expression for the block name initializer. initializers.Add(new CodeSnippetExpression(string.Format("name: \"{0}\"", blockName))); } // Check if the explanation is present. if (MutationCodeFormatter.IsValidFieldName(explanation) == true) { // Create a code expression for the explanation initializer. initializers.Add(new CodeSnippetExpression(string.Format("explanation: {0}", MutationCodeFormatter.CreateCodeSafeStringLiteral(explanation)))); } // Create the init expression which will call the constructor of the Explanation object. field.InitExpression = new CodeObjectCreateExpression(MutationCodeFormatter.CreateShortCodeTypeReference(standardFieldType, MutationNamespaces), initializers.ToArray()); // Add any attributes for this field. field.CustomAttributes = attributeCollection; // Add the field to the class definition. this.CodeClass.Members.Add(field); }