mirror of
https://github.com/danbulant/Cosmos
synced 2026-05-20 04:48:53 +00:00
533 lines
16 KiB
C#
533 lines
16 KiB
C#
/***************************************************************************
|
|
|
|
Copyright (c) Microsoft Corporation. All rights reserved.
|
|
This code is licensed under the Visual Studio SDK license terms.
|
|
THIS CODE IS PROVIDED *AS IS* WITHOUT WARRANTY OF
|
|
ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING ANY
|
|
IMPLIED WARRANTIES OF FITNESS FOR A PARTICULAR
|
|
PURPOSE, MERCHANTABILITY, OR NON-INFRINGEMENT.
|
|
|
|
***************************************************************************/
|
|
|
|
using System;
|
|
using System.Collections;
|
|
using System.Diagnostics;
|
|
using System.Diagnostics.CodeAnalysis;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Text;
|
|
|
|
namespace Microsoft.VisualStudio.Project
|
|
{
|
|
/// <summary>
|
|
/// Replacement type
|
|
/// </summary>
|
|
public enum TokenReplaceType
|
|
{
|
|
ReplaceString,
|
|
ReplaceNumber,
|
|
ReplaceCode
|
|
}
|
|
|
|
/// <summary>
|
|
/// Contain a number of functions that handle token replacement
|
|
/// </summary>
|
|
[CLSCompliant(false)]
|
|
public class TokenProcessor
|
|
{
|
|
#region fields
|
|
// Internal fields
|
|
private ArrayList tokenlist;
|
|
|
|
|
|
#endregion
|
|
|
|
#region Initialization
|
|
/// <summary>
|
|
/// Constructor
|
|
/// </summary>
|
|
public TokenProcessor()
|
|
{
|
|
tokenlist = new ArrayList();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Reset list of TokenReplacer entries
|
|
/// </summary>
|
|
public virtual void Reset()
|
|
{
|
|
tokenlist.Clear();
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Add a replacement type entry
|
|
/// </summary>
|
|
/// <param name="token">token to replace</param>
|
|
/// <param name="replacement">replacement string</param>
|
|
public virtual void AddReplace(string token, string replacement)
|
|
{
|
|
tokenlist.Add(new ReplacePairToken(token, replacement));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Add replace between entry
|
|
/// </summary>
|
|
/// <param name="tokenStart">Start token</param>
|
|
/// <param name="tokenEnd">End token</param>
|
|
[SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "tokenid")]
|
|
public virtual void AddReplaceBetween(string tokenid, string tokenStart, string tokenEnd, string replacement)
|
|
{
|
|
tokenlist.Add(new ReplaceBetweenPairToken(tokenid, tokenStart, tokenEnd, replacement));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Add a deletion entry
|
|
/// </summary>
|
|
/// <param name="tokenToDelete">Token to delete</param>
|
|
public virtual void AddDelete(string tokenToDelete)
|
|
{
|
|
tokenlist.Add(new DeleteToken(tokenToDelete));
|
|
}
|
|
#endregion
|
|
|
|
#region TokenProcessing
|
|
/// <summary>
|
|
/// For all known token, replace token with correct value
|
|
/// </summary>
|
|
/// <param name="source">File of the source file</param>
|
|
/// <param name="destination">File of the destination file</param>
|
|
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1800:DoNotCastUnnecessarily"), SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Untoken")]
|
|
public virtual void UntokenFile(string source, string destination)
|
|
{
|
|
if(string.IsNullOrEmpty(source))
|
|
throw new ArgumentNullException("source");
|
|
|
|
if(string.IsNullOrEmpty(destination))
|
|
throw new ArgumentNullException("destination");
|
|
|
|
// Make sure that the destination folder exists.
|
|
string destinationFolder = Path.GetDirectoryName(destination);
|
|
if(!Directory.Exists(destinationFolder))
|
|
{
|
|
Directory.CreateDirectory(destinationFolder);
|
|
}
|
|
|
|
//Open the file. Check to see if the File is binary or text.
|
|
// NOTE: This is not correct because GetBinaryType will return true
|
|
// only if the file is executable, not if it is a dll, a library or
|
|
// any other type of binary file.
|
|
|
|
uint binaryType;
|
|
if(!NativeMethods.GetBinaryType(source, out binaryType))
|
|
{
|
|
Encoding encoding = Encoding.Default;
|
|
string buffer = null;
|
|
// Create the reader to get the text. Note that we will default to ASCII as
|
|
// encoding if the file does not contains a different signature.
|
|
using(StreamReader reader = new StreamReader(source, Encoding.ASCII, true))
|
|
{
|
|
// Get the content of the file.
|
|
buffer = reader.ReadToEnd();
|
|
// Detect the encoding of the source file. Note that we
|
|
// can get the encoding only after a read operation is
|
|
// performed on the file.
|
|
encoding = reader.CurrentEncoding;
|
|
}
|
|
foreach(object pair in tokenlist)
|
|
{
|
|
if(pair is DeleteToken)
|
|
DeleteTokens(ref buffer, (DeleteToken)pair);
|
|
if(pair is ReplaceBetweenPairToken)
|
|
ReplaceBetweenTokens(ref buffer, (ReplaceBetweenPairToken)pair);
|
|
if(pair is ReplacePairToken)
|
|
ReplaceTokens(ref buffer, (ReplacePairToken)pair);
|
|
}
|
|
File.WriteAllText(destination, buffer, encoding);
|
|
}
|
|
else
|
|
File.Copy(source, destination);
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Replaces the tokens in a buffer with the replacement string
|
|
/// </summary>
|
|
/// <param name="buffer">Buffer to update</param>
|
|
/// <param name="tokenToReplace">replacement data</param>
|
|
public virtual void ReplaceTokens(ref string buffer, ReplacePairToken tokenToReplace)
|
|
{
|
|
if (tokenToReplace == null)
|
|
{
|
|
throw new ArgumentNullException("tokenToReplace");
|
|
}
|
|
|
|
if (buffer == null)
|
|
{
|
|
throw new ArgumentNullException("buffer");
|
|
}
|
|
|
|
buffer = buffer.Replace(tokenToReplace.Token, tokenToReplace.Replacement);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Deletes the token from the buffer
|
|
/// </summary>
|
|
/// <param name="buffer">Buffer to update</param>
|
|
/// <param name="tokenToDelete">token to delete</param>
|
|
public virtual void DeleteTokens(ref string buffer, DeleteToken tokenToDelete)
|
|
{
|
|
if (tokenToDelete == null)
|
|
{
|
|
throw new ArgumentNullException("tokenToDelete");
|
|
}
|
|
|
|
if (buffer == null)
|
|
{
|
|
throw new ArgumentNullException("buffer");
|
|
}
|
|
|
|
buffer = buffer.Replace(tokenToDelete.StringToDelete, string.Empty);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Replaces the token from the buffer between the provided tokens
|
|
/// </summary>
|
|
/// <param name="buffer">Buffer to update</param>
|
|
/// <param name="rpBetweenToken">replacement token</param>
|
|
public virtual void ReplaceBetweenTokens(ref string buffer, ReplaceBetweenPairToken rpBetweenToken)
|
|
{
|
|
if (rpBetweenToken == null)
|
|
{
|
|
throw new ArgumentNullException("rpBetweenToken");
|
|
}
|
|
|
|
if (buffer == null)
|
|
{
|
|
throw new ArgumentNullException("buffer");
|
|
}
|
|
|
|
string regularExp = rpBetweenToken.TokenStart + "[^" + rpBetweenToken.TokenIdentifier + "]*" + rpBetweenToken.TokenEnd;
|
|
buffer = System.Text.RegularExpressions.Regex.Replace(buffer, regularExp, rpBetweenToken.TokenReplacement);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Guid generators
|
|
/// <summary>
|
|
/// Generates a string representation of a guid with the following format:
|
|
/// 0x01020304, 0x0506, 0x0708, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10
|
|
/// </summary>
|
|
/// <param name="value">Guid to be generated</param>
|
|
/// <returns>The guid as string</returns>
|
|
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic")]
|
|
public string GuidToForm1(Guid value)
|
|
{
|
|
byte[] GuidBytes = value.ToByteArray();
|
|
StringBuilder ResultingStr = new StringBuilder(80);
|
|
|
|
// First 4 bytes
|
|
int i = 0;
|
|
int Number = 0;
|
|
for(i = 0; i < 4; ++i)
|
|
{
|
|
int CurrentByte = GuidBytes[i];
|
|
Number += CurrentByte << (8 * i);
|
|
}
|
|
UInt32 FourBytes = (UInt32)Number;
|
|
ResultingStr.AppendFormat(CultureInfo.InvariantCulture, "0x{0}", FourBytes.ToString("X", CultureInfo.InvariantCulture));
|
|
|
|
// 2 chunks of 2 bytes
|
|
for(int j = 0; j < 2; ++j)
|
|
{
|
|
Number = 0;
|
|
for(int k = 0; k < 2; ++k)
|
|
{
|
|
int CurrentByte = GuidBytes[i++];
|
|
Number += CurrentByte << (8 * k);
|
|
}
|
|
UInt16 TwoBytes = (UInt16)Number;
|
|
ResultingStr.AppendFormat(CultureInfo.InvariantCulture, ", 0x{0}", TwoBytes.ToString("X", CultureInfo.InvariantCulture));
|
|
}
|
|
|
|
// 8 chunks of 1 bytes
|
|
for(int j = 0; j < 8; ++j)
|
|
{
|
|
ResultingStr.AppendFormat(CultureInfo.InvariantCulture, ", 0x{0}", GuidBytes[i++].ToString("X", CultureInfo.InvariantCulture));
|
|
}
|
|
|
|
return ResultingStr.ToString();
|
|
}
|
|
#endregion
|
|
|
|
#region Helper Methods
|
|
/// <summary>
|
|
/// This function will accept a subset of the characters that can create an
|
|
/// identifier name: there are other unicode char that can be inside the name, but
|
|
/// this function will not allow. By now it can work this way, but when and if the
|
|
/// VSIP package will handle also languages different from english, this function
|
|
/// must be changed.
|
|
/// </summary>
|
|
/// <param name="c">Character to validate</param>
|
|
/// <returns>true if successful false otherwise</returns>
|
|
[SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "c")]
|
|
protected static bool IsValidIdentifierChar(char c)
|
|
{
|
|
if((c >= 'a') && (c <= 'z'))
|
|
{
|
|
return true;
|
|
}
|
|
if((c >= 'A') && (c <= 'Z'))
|
|
{
|
|
return true;
|
|
}
|
|
if(c == '_')
|
|
{
|
|
return true;
|
|
}
|
|
if((c >= '0') && (c <= '9'))
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Verifies if the start character is valid
|
|
/// </summary>
|
|
/// <param name="c">Start character</param>
|
|
/// <returns>true if successful false otherwise</returns>
|
|
[SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "c")]
|
|
protected static bool IsValidIdentifierStartChar(char c)
|
|
{
|
|
if(!IsValidIdentifierChar(c))
|
|
{
|
|
return false;
|
|
}
|
|
if((c >= '0') && (c <= '9'))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// The goal here is to reduce the risk of name conflict between 2 classes
|
|
/// added in different directories. This code does NOT garanty uniqueness.
|
|
/// To garanty uniqueness, you should change this function to work with
|
|
/// the language service to verify that the namespace+class generated does
|
|
/// not conflict.
|
|
/// </summary>
|
|
/// <param name="fileFullPath">Full path to the new file</param>
|
|
/// <returns>Namespace to use for the new file</returns>
|
|
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic")]
|
|
public string GetFileNamespace(string fileFullPath, ProjectNode node)
|
|
{
|
|
if (node == null)
|
|
{
|
|
throw new ArgumentNullException("node");
|
|
}
|
|
|
|
// Get base namespace from the project
|
|
string namespce = node.GetProjectProperty("RootNamespace");
|
|
if(String.IsNullOrEmpty(namespce))
|
|
namespce = Path.GetFileNameWithoutExtension(fileFullPath); ;
|
|
|
|
// If the item is added to a subfolder, the name space should reflect this.
|
|
// This is done so that class names from 2 files with the same name but different
|
|
// directories don't conflict.
|
|
string relativePath = Path.GetDirectoryName(fileFullPath);
|
|
string projectPath = Path.GetDirectoryName(node.GetMkDocument());
|
|
// Our project system only support adding files that are sibling of the project file or that are in subdirectories.
|
|
if(String.Compare(projectPath, 0, relativePath, 0, projectPath.Length, true, CultureInfo.CurrentCulture) == 0)
|
|
{
|
|
relativePath = relativePath.Substring(projectPath.Length);
|
|
}
|
|
else
|
|
{
|
|
Debug.Fail("Adding an item to the project that is NOT under the project folder.");
|
|
// We are going to use the full file path for generating the namespace
|
|
}
|
|
|
|
// Get the list of parts
|
|
int index = 0;
|
|
string[] pathParts;
|
|
pathParts = relativePath.Split(Path.DirectorySeparatorChar);
|
|
|
|
// Use a string builder with default size being the expected size
|
|
StringBuilder result = new StringBuilder(namespce, namespce.Length + relativePath.Length + 1);
|
|
// For each path part
|
|
while(index < pathParts.Length)
|
|
{
|
|
string part = pathParts[index];
|
|
++index;
|
|
|
|
// This could happen if the path had leading/trailing slash, we want to ignore empty pieces
|
|
if(String.IsNullOrEmpty(part))
|
|
continue;
|
|
|
|
// If we reach here, we will be adding something, so add a namespace separator '.'
|
|
result.Append('.');
|
|
|
|
// Make sure it starts with a letter
|
|
if(!char.IsLetter(part, 0))
|
|
result.Append('N');
|
|
|
|
// Filter invalid namespace characters
|
|
foreach(char c in part)
|
|
{
|
|
if(char.IsLetterOrDigit(c))
|
|
result.Append(c);
|
|
}
|
|
}
|
|
return result.ToString();
|
|
}
|
|
#endregion
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Storage classes for replacement tokens
|
|
/// </summary>
|
|
public class ReplacePairToken
|
|
{
|
|
/// <summary>
|
|
/// token string
|
|
/// </summary>
|
|
private string token;
|
|
|
|
/// <summary>
|
|
/// Replacement string
|
|
/// </summary>
|
|
private string replacement;
|
|
|
|
/// <summary>
|
|
/// Constructor
|
|
/// </summary>
|
|
/// <param name="token">replaceable token</param>
|
|
/// <param name="replacement">replacement string</param>
|
|
public ReplacePairToken(string token, string replacement)
|
|
{
|
|
this.token = token;
|
|
this.replacement = replacement;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Token that needs to be replaced
|
|
/// </summary>
|
|
public string Token
|
|
{
|
|
get { return token; }
|
|
}
|
|
/// <summary>
|
|
/// String to replace the token with
|
|
/// </summary>
|
|
public string Replacement
|
|
{
|
|
get { return replacement; }
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Storage classes for token to be deleted
|
|
/// </summary>
|
|
public class DeleteToken
|
|
{
|
|
/// <summary>
|
|
/// String to delete
|
|
/// </summary>
|
|
private string token;
|
|
|
|
/// <summary>
|
|
/// Constructor
|
|
/// </summary>
|
|
/// <param name="token">Deletable token.</param>
|
|
public DeleteToken(string token)
|
|
{
|
|
this.token = token;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Token marking the end of the block to delete
|
|
/// </summary>
|
|
public string StringToDelete
|
|
{
|
|
get { return token; }
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Storage classes for string to be deleted between tokens to be deleted
|
|
/// </summary>
|
|
public class ReplaceBetweenPairToken
|
|
{
|
|
/// <summary>
|
|
/// Token start
|
|
/// </summary>
|
|
private string tokenStart;
|
|
|
|
/// <summary>
|
|
/// End token
|
|
/// </summary>
|
|
private string tokenEnd;
|
|
|
|
/// <summary>
|
|
/// Replacement string
|
|
/// </summary>
|
|
private string replacement;
|
|
|
|
/// <summary>
|
|
/// Token identifier string
|
|
/// </summary>
|
|
private string tokenidentifier;
|
|
|
|
/// <summary>
|
|
/// Constructor
|
|
/// </summary>
|
|
/// <param name="blockStart">Start token</param>
|
|
/// <param name="blockEnd">End Token</param>
|
|
/// <param name="replacement">Replacement string.</param>
|
|
[SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "tokenid")]
|
|
public ReplaceBetweenPairToken(string tokenid, string blockStart, string blockEnd, string replacement)
|
|
{
|
|
tokenStart = blockStart;
|
|
tokenEnd = blockEnd;
|
|
this.replacement = replacement;
|
|
tokenidentifier = tokenid;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Token marking the begining of the block to delete
|
|
/// </summary>
|
|
public string TokenStart
|
|
{
|
|
get { return tokenStart; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Token marking the end of the block to delete
|
|
/// </summary>
|
|
public string TokenEnd
|
|
{
|
|
get { return tokenEnd; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Token marking the end of the block to delete
|
|
/// </summary>
|
|
public string TokenReplacement
|
|
{
|
|
get { return replacement; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Token Identifier
|
|
/// </summary>
|
|
public string TokenIdentifier
|
|
{
|
|
get { return tokenidentifier; }
|
|
}
|
|
}
|
|
}
|