| public IsValidIdentifier ( string value ) : bool | ||
| value | string | |
| return | bool | |
internal static string GenerateIdName(string name, CodeDomProvider codeProvider, bool useSuffix, int additionalCharsToTruncate)
{
if (!useSuffix)
{
name = GetBackwardCompatibleIdentifier(name, codeProvider);
}
if (codeProvider.IsValidIdentifier(name))
{
return name;
}
string str = name.Replace(' ', '_');
if (!codeProvider.IsValidIdentifier(str))
{
if (!useSuffix)
{
str = "_" + str;
}
for (int i = 0; i < str.Length; i++)
{
UnicodeCategory unicodeCategory = char.GetUnicodeCategory(str[i]);
if (((((unicodeCategory != UnicodeCategory.UppercaseLetter) && (UnicodeCategory.LowercaseLetter != unicodeCategory)) && ((UnicodeCategory.TitlecaseLetter != unicodeCategory) && (UnicodeCategory.ModifierLetter != unicodeCategory))) && (((UnicodeCategory.OtherLetter != unicodeCategory) && (UnicodeCategory.NonSpacingMark != unicodeCategory)) && ((UnicodeCategory.SpacingCombiningMark != unicodeCategory) && (UnicodeCategory.DecimalDigitNumber != unicodeCategory)))) && (UnicodeCategory.ConnectorPunctuation != unicodeCategory))
{
str = str.Replace(str[i], '_');
}
}
}
int num2 = 0;
string str2 = str;
while (!codeProvider.IsValidIdentifier(str) && (num2 < 200))
{
num2++;
str = "_" + str;
}
if (num2 >= 200)
{
str = str2;
while (!codeProvider.IsValidIdentifier(str) && (str.Length > 0))
{
str = str.Remove(str.Length - 1);
}
if (str.Length == 0)
{
return str2;
}
if (((additionalCharsToTruncate > 0) && (str.Length > additionalCharsToTruncate)) && codeProvider.IsValidIdentifier(str.Remove(str.Length - additionalCharsToTruncate)))
{
str = str.Remove(str.Length - additionalCharsToTruncate);
}
}
return str;
}
static bool NameIsLanguageKeyword (CodeDomProvider codeDomProvider, string[] names)
{
return names.Any (name => !codeDomProvider.IsValidIdentifier (name));
}
private static SortedList VerifyResourceNames(Dictionary<string, ResourceData> resourceList, CodeDomProvider codeProvider, ArrayList errors, out Hashtable reverseFixupTable)
{
reverseFixupTable = new Hashtable(0, StringComparer.InvariantCultureIgnoreCase);
SortedList list = new SortedList(StringComparer.InvariantCultureIgnoreCase, resourceList.Count);
foreach (KeyValuePair<string, ResourceData> pair in resourceList)
{
string key = pair.Key;
if ((string.Equals(key, "ResourceManager") || string.Equals(key, "Culture")) || (typeof(void) == pair.Value.Type))
{
errors.Add(key);
}
else
{
if (((key.Length <= 0) || (key[0] != '$')) && (((key.Length <= 1) || (key[0] != '>')) || (key[1] != '>')))
{
if (!codeProvider.IsValidIdentifier(key))
{
string str2 = VerifyResourceName(key, codeProvider, false);
if (str2 == null)
{
errors.Add(key);
goto Label_0185;
}
string item = (string) reverseFixupTable[str2];
if (item != null)
{
if (!errors.Contains(item))
{
errors.Add(item);
}
if (list.Contains(str2))
{
list.Remove(str2);
}
errors.Add(key);
goto Label_0185;
}
reverseFixupTable[str2] = key;
key = str2;
}
ResourceData data = pair.Value;
if (!list.Contains(key))
{
list.Add(key, data);
}
else
{
string str4 = (string) reverseFixupTable[key];
if (str4 != null)
{
if (!errors.Contains(str4))
{
errors.Add(str4);
}
reverseFixupTable.Remove(key);
}
errors.Add(pair.Key);
list.Remove(key);
}
}
Label_0185:;
}
}
return list;
}
private static string VerifyResourceName(string key, CodeDomProvider provider, bool isNameSpace)
{
if (key == null)
{
throw new ArgumentNullException("key");
}
if (provider == null)
{
throw new ArgumentNullException("provider");
}
foreach (char ch in CharsToReplace)
{
if (!isNameSpace || ((ch != '.') && (ch != ':')))
{
key = key.Replace(ch, '_');
}
}
if (provider.IsValidIdentifier(key))
{
return key;
}
key = provider.CreateValidIdentifier(key);
if (provider.IsValidIdentifier(key))
{
return key;
}
key = "_" + key;
if (provider.IsValidIdentifier(key))
{
return key;
}
return null;
}
private static CodeCompileUnit InternalCreate(Dictionary<string, ResourceData> resourceList, string baseName, string generatedCodeNamespace, string resourcesNamespace, CodeDomProvider codeProvider, bool internalClass, out string[] unmatchable)
{
Hashtable hashtable;
if (baseName == null)
{
throw new ArgumentNullException("baseName");
}
if (codeProvider == null)
{
throw new ArgumentNullException("codeProvider");
}
ArrayList errors = new ArrayList(0);
SortedList list2 = VerifyResourceNames(resourceList, codeProvider, errors, out hashtable);
string str = baseName;
if (!codeProvider.IsValidIdentifier(str))
{
string str2 = VerifyResourceName(str, codeProvider);
if (str2 != null)
{
str = str2;
}
}
if (!codeProvider.IsValidIdentifier(str))
{
throw new ArgumentException(Microsoft.Build.Tasks.SR.GetString("InvalidIdentifier", new object[] { str }));
}
if (!string.IsNullOrEmpty(generatedCodeNamespace) && !codeProvider.IsValidIdentifier(generatedCodeNamespace))
{
string str3 = VerifyResourceName(generatedCodeNamespace, codeProvider, true);
if (str3 != null)
{
generatedCodeNamespace = str3;
}
}
CodeCompileUnit e = new CodeCompileUnit();
e.ReferencedAssemblies.Add("System.dll");
e.UserData.Add("AllowLateBound", false);
e.UserData.Add("RequireVariableDeclaration", true);
CodeNamespace namespace2 = new CodeNamespace(generatedCodeNamespace);
namespace2.Imports.Add(new CodeNamespaceImport("System"));
e.Namespaces.Add(namespace2);
CodeTypeDeclaration declaration = new CodeTypeDeclaration(str);
namespace2.Types.Add(declaration);
AddGeneratedCodeAttributeforMember(declaration);
TypeAttributes attributes = internalClass ? TypeAttributes.AnsiClass : TypeAttributes.Public;
declaration.TypeAttributes = attributes;
declaration.Comments.Add(new CodeCommentStatement("<summary>", true));
declaration.Comments.Add(new CodeCommentStatement(Microsoft.Build.Tasks.SR.GetString("ClassDocComment"), true));
CodeCommentStatement statement = new CodeCommentStatement(Microsoft.Build.Tasks.SR.GetString("ClassComments1"), true);
declaration.Comments.Add(statement);
statement = new CodeCommentStatement(Microsoft.Build.Tasks.SR.GetString("ClassComments3"), true);
declaration.Comments.Add(statement);
declaration.Comments.Add(new CodeCommentStatement("</summary>", true));
CodeTypeReference attributeType = new CodeTypeReference(typeof(DebuggerNonUserCodeAttribute)) {
Options = CodeTypeReferenceOptions.GlobalReference
};
declaration.CustomAttributes.Add(new CodeAttributeDeclaration(attributeType));
CodeTypeReference reference2 = new CodeTypeReference(typeof(CompilerGeneratedAttribute)) {
Options = CodeTypeReferenceOptions.GlobalReference
};
declaration.CustomAttributes.Add(new CodeAttributeDeclaration(reference2));
bool useStatic = internalClass || codeProvider.Supports(GeneratorSupport.PublicStaticMembers);
bool supportsTryCatch = codeProvider.Supports(GeneratorSupport.TryCatchStatements);
EmitBasicClassMembers(declaration, generatedCodeNamespace, baseName, resourcesNamespace, internalClass, useStatic, supportsTryCatch);
foreach (DictionaryEntry entry in list2)
{
string key = (string) entry.Key;
string resourceName = (string) hashtable[key];
if (resourceName == null)
{
resourceName = key;
}
if (!DefineResourceFetchingProperty(key, resourceName, (ResourceData) entry.Value, declaration, internalClass, useStatic))
{
errors.Add(entry.Key);
}
}
unmatchable = (string[]) errors.ToArray(typeof(string));
CodeGenerator.ValidateIdentifiers(e);
return e;
}
public static string VerifyResourceName (string key, CodeDomProvider provider)
{
string keyToUse;
char [] charKey;
// check params
if (key == null)
throw new ArgumentNullException ("Parameter: key must not be null");
if (provider == null)
throw new ArgumentNullException ("Parameter: provider must not be null");
if (key == String.Empty) {
keyToUse = "_";
} else {
// replaces special chars
charKey = key.ToCharArray ();
for (int i = 0; i < charKey.Length; i++)
charKey [i] = VerifySpecialChar (charKey [i]);
keyToUse = new string(charKey);
}
// resolve if keyword
keyToUse = provider.CreateValidIdentifier (keyToUse);
// check if still not valid for provider
if (provider.IsValidIdentifier (keyToUse))
return keyToUse;
else
return null;
}
private static SortedList<string, ResourceData> VerifyResourceNames(Dictionary<string, ResourceData> resourceList,
CodeDomProvider codeProvider, List<ResourceErrorData> invalidResources, out Dictionary<string, string> reverseFixupTable)
{
reverseFixupTable = new Dictionary<string, string>(0, StringComparer.InvariantCultureIgnoreCase);
SortedList<string, ResourceData> validResources = new SortedList<string, ResourceData>(resourceList.Count,
StringComparer.InvariantCultureIgnoreCase);
Dictionary<string, ResourceData>.Enumerator resourceListEnumerator = resourceList.GetEnumerator();
try
{
while (resourceListEnumerator.MoveNext())
{
KeyValuePair<string, ResourceData> resourcePair = resourceListEnumerator.Current;
string resourceKey = resourcePair.Key;
if ((string.Equals(resourceKey, ResMgrPropertyName) ||
string.Equals(resourceKey, CultureInfoPropertyName) ||
string.Equals(resourceKey, InternalSyncObjectPropertyName)) ||
(typeof(void) == resourcePair.Value.Type))
{
invalidResources.Add(new ResourceErrorData(resourceKey,
string.Format(CultureInfo.CurrentCulture, CannotCreatePropertyForResource, resourceKey)));
continue;
}
if (((resourceKey.Length <= 0) || (resourceKey[0] != '$')) &&
(((resourceKey.Length <= 1) || (resourceKey[0] != '>')) || (resourceKey[1] != '>')))
{
if (!codeProvider.IsValidIdentifier(resourceKey))
{
string adjustedResourceKey = VerifyResourceName(resourceKey, codeProvider, false);
if (adjustedResourceKey == null)
{
invalidResources.Add(new ResourceErrorData(resourceKey,
string.Format(CultureInfo.CurrentCulture, CannotCreatePropertyForResource, resourceKey)));
continue;
}
string originalResourceKey;
if (reverseFixupTable.TryGetValue(adjustedResourceKey, out originalResourceKey))
{
if (!ContainsInvalidKey(invalidResources, originalResourceKey))
{
invalidResources.Add(new ResourceErrorData(originalResourceKey,
string.Format(CultureInfo.CurrentCulture, CannotCreatePropertyForResource,
originalResourceKey)));
}
if (validResources.ContainsKey(adjustedResourceKey))
validResources.Remove(adjustedResourceKey);
invalidResources.Add(new ResourceErrorData(resourceKey,
string.Format(CultureInfo.CurrentCulture, CannotCreatePropertyForResource, resourceKey)));
continue;
}
reverseFixupTable[adjustedResourceKey] = resourceKey;
resourceKey = adjustedResourceKey;
}
ResourceData resourceData = resourcePair.Value;
if (!validResources.ContainsKey(resourceKey))
{
validResources.Add(resourceKey, resourceData);
continue;
}
string initialResourceKey;
if (reverseFixupTable.TryGetValue(resourceKey, out initialResourceKey))
{
if (!ContainsInvalidKey(invalidResources, initialResourceKey))
{
invalidResources.Add(new ResourceErrorData(initialResourceKey,
string.Format(CultureInfo.CurrentCulture, CannotCreatePropertyForResource,
initialResourceKey)));
}
reverseFixupTable.Remove(resourceKey);
}
invalidResources.Add(new ResourceErrorData(resourcePair.Key,
string.Format(CultureInfo.CurrentCulture, CannotCreatePropertyForResource,
resourcePair.Key)));
validResources.Remove(resourceKey);
}
}
}
finally
{
resourceListEnumerator.Dispose();
}
return validResources;
}
private static string VerifyResourceName(string key, CodeDomProvider provider, bool isNameSpace)
{
if (null == key)
throw new ArgumentNullException("key");
if (null == provider)
throw new ArgumentNullException("provider");
for (int index = 0; index < charsToReplace.Length; index++)
{
char ch = charsToReplace[index];
if (!isNameSpace || ((ch != '.') && (ch != ':')))
key = key.Replace(ch, ReplacementChar);
}
if (provider.IsValidIdentifier(key))
return key;
key = provider.CreateValidIdentifier(key);
if (provider.IsValidIdentifier(key))
return key;
key = "_" + key;
if (provider.IsValidIdentifier(key))
return key;
return null;
}
private static CodeCompileUnit InternalCreate(Type callerType, Dictionary<string, ResourceData> resourceList,
string baseName, string generatedCodeNamespace, string resourcesNamespace,
CodeDomProvider codeProvider, bool internalClass, List<ResourceErrorData> unmatchable, string logicalName)
{
//logicalName added by Ðonny
if (null == baseName)
throw new ArgumentNullException("baseName");
if (null == codeProvider)
throw new ArgumentNullException("codeProvider");
Dictionary<string, string> reverseFixupTable;
SortedList<string, ResourceData> validResources = VerifyResourceNames(resourceList, codeProvider, unmatchable,
out reverseFixupTable);
string verifiedBaseName = baseName;
if (!codeProvider.IsValidIdentifier(verifiedBaseName))
{
string adjustedBaseName = VerifyResourceName(verifiedBaseName, codeProvider);
if (adjustedBaseName != null)
verifiedBaseName = adjustedBaseName;
}
if (!codeProvider.IsValidIdentifier(verifiedBaseName))
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, InvalidIdentifier, verifiedBaseName));
if (!string.IsNullOrEmpty(generatedCodeNamespace) &&
!codeProvider.IsValidIdentifier(generatedCodeNamespace))
{
string adjustedCodeNamespace = VerifyResourceName(generatedCodeNamespace, codeProvider, true);
if (adjustedCodeNamespace != null)
generatedCodeNamespace = adjustedCodeNamespace;
}
CodeCompileUnit codeCompileUnit = new CodeCompileUnit();
codeCompileUnit.ReferencedAssemblies.Add("System.dll");
codeCompileUnit.UserData.Add("AllowLateBound", false);
codeCompileUnit.UserData.Add("RequireVariableDeclaration", true);
CodeNamespace codeNamespace = new CodeNamespace(generatedCodeNamespace);
codeNamespace.Imports.Add(new CodeNamespaceImport("System"));
codeCompileUnit.Namespaces.Add(codeNamespace);
CodeTypeDeclaration codeTypeDeclaration = new CodeTypeDeclaration(verifiedBaseName);
codeNamespace.Types.Add(codeTypeDeclaration);
AddGeneratedCodeAttributeforMember(codeTypeDeclaration);
TypeAttributes typeAttributes = TypeAttributes.AutoLayout;
if (!internalClass)
typeAttributes |= TypeAttributes.Public;
codeTypeDeclaration.TypeAttributes = typeAttributes;
AddComments(codeTypeDeclaration, ClassDocComment);
if (codeProvider.FileExtension.ToLowerInvariant() == "vb")//Visual Basic - generate module
codeTypeDeclaration.UserData.Add("Module", true);
CodeTypeReference debuggerNonUserCodeTypeReference = new CodeTypeReference(typeof(DebuggerNonUserCodeAttribute),
CodeTypeReferenceOptions.GlobalReference);
codeTypeDeclaration.CustomAttributes.Add(new CodeAttributeDeclaration(debuggerNonUserCodeTypeReference));
CodeAttributeDeclaration suppressAttributeTypeDeclaration = new CodeAttributeDeclaration(new CodeTypeReference(typeof(SuppressMessageAttribute)));
suppressAttributeTypeDeclaration.AttributeType.Options = CodeTypeReferenceOptions.GlobalReference;
suppressAttributeTypeDeclaration.Arguments.Add(new CodeAttributeArgument(new CodePrimitiveExpression("Microsoft.Naming")));
suppressAttributeTypeDeclaration.Arguments.Add(new CodeAttributeArgument(new CodePrimitiveExpression("CA1724:TypeNamesShouldNotMatchNamespaces")));
codeTypeDeclaration.CustomAttributes.Add(suppressAttributeTypeDeclaration);
bool useStatic = internalClass || codeProvider.Supports(GeneratorSupport.PublicStaticMembers);
bool supportsTryCatch = codeProvider.Supports(GeneratorSupport.TryCatchStatements);
EmitBasicClassMembers(callerType, codeTypeDeclaration, generatedCodeNamespace, baseName,
resourcesNamespace, internalClass, useStatic, supportsTryCatch, logicalName, codeProvider.FileExtension.ToLowerInvariant() != "vb"); //logicalName added by Ðonny
SortedList<string, ResourceData> formatMethods = new SortedList<string, ResourceData>(validResources.Count,
StringComparer.InvariantCultureIgnoreCase);
// Generate resource fetching properties
foreach (KeyValuePair<string, ResourceData> validResourceEntry in validResources)
{
string initialResourceKey;
if (!reverseFixupTable.TryGetValue(validResourceEntry.Key, out initialResourceKey))
initialResourceKey = validResourceEntry.Key;
if (!DefineResourceFetchingProperty(validResourceEntry.Key, initialResourceKey,
validResourceEntry.Value, codeTypeDeclaration, internalClass, useStatic))
{
unmatchable.Add(new ResourceErrorData(validResourceEntry.Key.ToString(),
string.Format(CultureInfo.CurrentCulture, CannotCreatePropertyForResource,
validResourceEntry.Key.ToString())));
}
else if (typeof(string) == validResourceEntry.Value.Type)
formatMethods.Add(validResourceEntry.Key, validResourceEntry.Value);
}
// Generate resource fetching format methods
foreach (KeyValuePair<string, ResourceData> formatMethodEntry in formatMethods)
{
try
{
string methodName = formatMethodEntry.Key + FormatSuffix;
// Check for duplicate method names
bool uniqueMethodName = true;
foreach (CodeTypeMember codeTypeMember in codeTypeDeclaration.Members)
{
if (null == codeTypeMember)
continue;
if (codeTypeMember.Name == methodName)
{
uniqueMethodName = false;
break;
}
}
if (!uniqueMethodName)
continue;
int numberOfArguments = FormatValidator.Parse(formatMethodEntry.Value.ValueIfString);
if (codeProvider.IsValidIdentifier(methodName))
{
string initialResourceKey;
if (!reverseFixupTable.TryGetValue(formatMethodEntry.Key, out initialResourceKey))
initialResourceKey = formatMethodEntry.Key;
DefineFormattedResourceFetchingMethod(methodName, formatMethodEntry.Key,
initialResourceKey, formatMethodEntry.Value, codeTypeDeclaration,
internalClass, useStatic, numberOfArguments);
}
else
{
unmatchable.Add(new ResourceErrorData(methodName,
string.Format(CultureInfo.CurrentCulture, CannotCreateFormatMethod,
methodName, formatMethodEntry.Key)));
}
}
catch (FormatException ex)
{
unmatchable.Add(new ResourceErrorData(formatMethodEntry.Key.ToString(),
string.Format(CultureInfo.CurrentCulture, ErrorInFormatPropertyForResource,
ex.Message, formatMethodEntry.Key.ToString())));
}
}
CodeGenerator.ValidateIdentifiers(codeCompileUnit);
return codeCompileUnit;
}
private static SortedList VerifyResourceNames(Dictionary<String, ResourceData> resourceList, CodeDomProvider codeProvider, ArrayList errors, out Hashtable reverseFixupTable)
{
reverseFixupTable = new Hashtable(0, StringComparer.InvariantCultureIgnoreCase);
SortedList cleanedResourceList = new SortedList(StringComparer.InvariantCultureIgnoreCase, resourceList.Count);
foreach(KeyValuePair<String, ResourceData> entry in resourceList) {
String key = entry.Key;
// Disallow a property named ResourceManager or Culture - we add
// those. (Any other properties we add also must be listed here)
// Also disallow resource values of type Void.
if (String.Equals(key, ResMgrPropertyName) ||
String.Equals(key, CultureInfoPropertyName) ||
typeof(void) == entry.Value.Type)
{
errors.Add(key);
continue;
}
// Ignore WinForms design time and hierarchy information.
// Skip resources starting with $ or >>, like "$this.Text",
// ">>$this.Name" or ">>treeView1.Parent".
if ((key.Length > 0 && key[0] == '$') ||
(key.Length > 1 && key[0] == '>' && key[1] == '>')) {
continue;
}
if (!codeProvider.IsValidIdentifier(key)) {
String newKey = VerifyResourceName(key, codeProvider, false);
if (newKey == null) {
errors.Add(key);
continue;
}
// Now see if we've already mapped another key to the
// same name.
String oldDuplicateKey = (String) reverseFixupTable[newKey];
if (oldDuplicateKey != null) {
// We can't handle this key nor the previous one.
// Remove the old one.
if (!errors.Contains(oldDuplicateKey))
errors.Add(oldDuplicateKey);
if (cleanedResourceList.Contains(newKey))
cleanedResourceList.Remove(newKey);
errors.Add(key);
continue;
}
reverseFixupTable[newKey] = key;
key = newKey;
}
ResourceData value = entry.Value;
if (!cleanedResourceList.Contains(key))
cleanedResourceList.Add(key, value);
else {
// There was a case-insensitive conflict between two keys.
// Or possibly one key was fixed up in a way that conflicts
// with another key (ie, "A B" and "A_B").
String fixedUp = (String) reverseFixupTable[key];
if (fixedUp != null) {
if (!errors.Contains(fixedUp))
errors.Add(fixedUp);
reverseFixupTable.Remove(key);
}
errors.Add(entry.Key);
cleanedResourceList.Remove(key);
}
}
return cleanedResourceList;
}
// Once CodeDom provides a way to verify a namespace name, revisit this method.
private static String VerifyResourceName(String key, CodeDomProvider provider, bool isNameSpace) {
if (key == null)
throw new ArgumentNullException("key");
if (provider == null)
throw new ArgumentNullException("provider");
foreach(char c in CharsToReplace) {
// For namespaces, allow . and ::
if (!(isNameSpace && (c == '.' || c == ':')))
key = key.Replace(c, ReplacementChar);
}
if (provider.IsValidIdentifier(key))
return key;
// Now try fixing up keywords like "for".
key = provider.CreateValidIdentifier(key);
if (provider.IsValidIdentifier(key))
return key;
// make one last ditch effort by prepending _. This fixes keys that start with a number
key = "_" + key;
if (provider.IsValidIdentifier(key))
return key;
return null;
}
private static CodeCompileUnit InternalCreate(Dictionary<String, ResourceData> resourceList, String baseName, String generatedCodeNamespace, String resourcesNamespace, CodeDomProvider codeProvider, bool internalClass, out String[] unmatchable)
{
if (baseName == null)
throw new ArgumentNullException("baseName");
if (codeProvider == null)
throw new ArgumentNullException("codeProvider");
// Keep a list of errors describing known strings that couldn't be
// fixed up (like "4"), as well as listing all duplicate resources that
// were fixed up to the same name (like "A B" and "A-B" both going to
// "A_B").
ArrayList errors = new ArrayList(0);
// Verify the resource names are valid property names, and they don't
// conflict. This includes checking for language-specific keywords,
// translating spaces to underscores, etc.
SortedList cleanedResourceList;
Hashtable reverseFixupTable;
cleanedResourceList = VerifyResourceNames(resourceList, codeProvider, errors, out reverseFixupTable);
// Verify the class name is legal.
String className = baseName;
// Attempt to fix up class name, and throw an exception if it fails.
if (!codeProvider.IsValidIdentifier(className)) {
String fixedClassName = VerifyResourceName(className, codeProvider);
if (fixedClassName != null)
className = fixedClassName;
}
if (!codeProvider.IsValidIdentifier(className))
throw new ArgumentException(SR.GetString(SR.InvalidIdentifier, className));
// If we have a namespace, verify the namespace is legal,
// attempting to fix it up if needed.
if (!String.IsNullOrEmpty(generatedCodeNamespace)) {
if (!codeProvider.IsValidIdentifier(generatedCodeNamespace)) {
String fixedNamespace = VerifyResourceName(generatedCodeNamespace, codeProvider, true);
if (fixedNamespace != null)
generatedCodeNamespace = fixedNamespace;
}
// Note we cannot really ensure that the generated code namespace
// is a valid identifier, as namespaces can have '.' and '::', but
// identifiers cannot.
}
CodeCompileUnit ccu = new CodeCompileUnit();
ccu.ReferencedAssemblies.Add("System.dll");
ccu.UserData.Add("AllowLateBound", false);
ccu.UserData.Add("RequireVariableDeclaration", true);
CodeNamespace ns = new CodeNamespace(generatedCodeNamespace);
ns.Imports.Add(new CodeNamespaceImport("System"));
ccu.Namespaces.Add(ns);
// Generate class
CodeTypeDeclaration srClass = new CodeTypeDeclaration(className);
ns.Types.Add(srClass);
AddGeneratedCodeAttributeforMember(srClass);
TypeAttributes ta = internalClass ? TypeAttributes.NotPublic : TypeAttributes.Public;
//ta |= TypeAttributes.Sealed;
srClass.TypeAttributes = ta;
srClass.Comments.Add(new CodeCommentStatement(DocCommentSummaryStart, true));
srClass.Comments.Add(new CodeCommentStatement(SR.GetString(SR.ClassDocComment), true));
CodeCommentStatement comment = new CodeCommentStatement(SR.GetString(SR.ClassComments1), true);
srClass.Comments.Add(comment);
comment = new CodeCommentStatement(SR.GetString(SR.ClassComments3), true);
srClass.Comments.Add(comment);
srClass.Comments.Add(new CodeCommentStatement(DocCommentSummaryEnd, true));
CodeTypeReference debuggerAttrib = new CodeTypeReference(typeof(System.Diagnostics.DebuggerNonUserCodeAttribute));
debuggerAttrib.Options = CodeTypeReferenceOptions.GlobalReference;
srClass.CustomAttributes.Add(new CodeAttributeDeclaration(debuggerAttrib));
CodeTypeReference compilerGenedAttrib = new CodeTypeReference(typeof(System.Runtime.CompilerServices.CompilerGeneratedAttribute));
compilerGenedAttrib.Options = CodeTypeReferenceOptions.GlobalReference;
srClass.CustomAttributes.Add(new CodeAttributeDeclaration(compilerGenedAttrib));
// Figure out some basic restrictions to the code generation
bool useStatic = internalClass || codeProvider.Supports(GeneratorSupport.PublicStaticMembers);
bool supportsTryCatch = codeProvider.Supports(GeneratorSupport.TryCatchStatements);
EmitBasicClassMembers(srClass, generatedCodeNamespace, baseName, resourcesNamespace, internalClass, useStatic, supportsTryCatch);
// Now for each resource, add a property
foreach(DictionaryEntry entry in cleanedResourceList) {
String propertyName = (String) entry.Key;
// The resourceName will be the original value, before fixups,
// if any.
String resourceName = (String) reverseFixupTable[propertyName];
if (resourceName == null)
resourceName = propertyName;
bool r = DefineResourceFetchingProperty(propertyName, resourceName, (ResourceData) entry.Value, srClass, internalClass, useStatic);
if (!r) {
errors.Add(entry.Key);
}
}
unmatchable = (String[]) errors.ToArray(typeof(String));
// Validate the generated class now
CodeGenerator.ValidateIdentifiers(ccu);
return ccu;
}
private static string VerifyResourceName(string name, CodeDomProvider provider, bool isNameSpace)
{
if (null == name)
throw new ArgumentNullException("name");
if (null == provider)
throw new ArgumentNullException("provider");
for (int index = 0; index < _charsToReplace.Length; index++)
{
char ch = _charsToReplace[index];
if (!isNameSpace || ((ch != '.') && (ch != ':')))
name = name.Replace(ch, ReplacementChar);
}
if (provider.IsValidIdentifier(name))
return name;
name = provider.CreateValidIdentifier(name);
if (provider.IsValidIdentifier(name))
return name;
name = "_" + name;
if (provider.IsValidIdentifier(name))
return name;
return null;
}
string SanitizeResourceName (CodeDomProvider provider, string name)
{
if (provider.IsValidIdentifier (name))
return provider.CreateEscapedIdentifier (name);
var sb = new StringBuilder ();
char ch = name [0];
if (is_identifier_start_character (ch))
sb.Append (ch);
else {
sb.Append ('_');
if (ch >= '0' && ch <= '9')
sb.Append (ch);
}
for (int i = 1; i < name.Length; i++) {
ch = name [i];
if (is_identifier_part_character (ch))
sb.Append (ch);
else
sb.Append ('_');
}
return provider.CreateEscapedIdentifier (sb.ToString ());
}
// CodeDOM generation
void DomFromResource (string resfile, CodeCompileUnit unit, Dictionary <string,bool> assemblies,
CodeDomProvider provider)
{
if (String.IsNullOrEmpty (resfile))
return;
string fname, nsname, classname;
fname = Path.GetFileNameWithoutExtension (resfile);
nsname = Path.GetFileNameWithoutExtension (fname);
classname = Path.GetExtension (fname);
if (classname == null || classname.Length == 0) {
classname = nsname;
nsname = "Resources";
} else {
if (!nsname.StartsWith ("Resources", StringComparison.InvariantCulture))
nsname = String.Concat ("Resources.", nsname);
classname = classname.Substring(1);
}
if (!String.IsNullOrEmpty (classname))
classname = classname.Replace ('.', '_');
if (!String.IsNullOrEmpty (nsname))
nsname = nsname.Replace ('.', '_');
if (!provider.IsValidIdentifier (nsname) || !provider.IsValidIdentifier (classname))
throw new ApplicationException ("Invalid resource file name.");
ResourceReader res;
try {
res = new ResourceReader (resfile);
} catch (ArgumentException) {
// invalid stream, probably empty - ignore silently and abort
return;
}
CodeNamespace ns = new CodeNamespace (nsname);
CodeTypeDeclaration cls = new CodeTypeDeclaration (classname);
cls.IsClass = true;
cls.TypeAttributes = TypeAttributes.Public | TypeAttributes.Sealed;
CodeMemberField cmf = new CodeMemberField (typeof(CultureInfo), "_culture");
cmf.InitExpression = new CodePrimitiveExpression (null);
cmf.Attributes = MemberAttributes.Private | MemberAttributes.Final | MemberAttributes.Static;
cls.Members.Add (cmf);
cmf = new CodeMemberField (typeof(ResourceManager), "_resourceManager");
cmf.InitExpression = new CodePrimitiveExpression (null);
cmf.Attributes = MemberAttributes.Private | MemberAttributes.Final | MemberAttributes.Static;
cls.Members.Add (cmf);
// Property: ResourceManager
CodeMemberProperty cmp = new CodeMemberProperty ();
cmp.Attributes = MemberAttributes.Public | MemberAttributes.Final | MemberAttributes.Static;
cmp.Name = "ResourceManager";
cmp.HasGet = true;
cmp.Type = new CodeTypeReference (typeof(ResourceManager));
CodePropertyResourceManagerGet (cmp.GetStatements, resfile, classname);
cls.Members.Add (cmp);
// Property: Culture
cmp = new CodeMemberProperty ();
cmp.Attributes = MemberAttributes.Public | MemberAttributes.Final;
cmp.Attributes = MemberAttributes.Public | MemberAttributes.Final | MemberAttributes.Static;
cmp.Name = "Culture";
cmp.HasGet = true;
cmp.HasSet = true;
cmp.Type = new CodeTypeReference (typeof(CultureInfo));
CodePropertyGenericGet (cmp.GetStatements, "_culture", classname);
CodePropertyGenericSet (cmp.SetStatements, "_culture", classname);
cls.Members.Add (cmp);
// Add the resource properties
Dictionary<string,bool> imports = new Dictionary<string,bool> ();
try {
foreach (DictionaryEntry de in res) {
Type type = de.Value.GetType ();
if (!imports.ContainsKey (type.Namespace))
imports [type.Namespace] = true;
string asname = new AssemblyName (type.Assembly.FullName).Name;
if (!assemblies.ContainsKey (asname))
assemblies [asname] = true;
cmp = new CodeMemberProperty ();
cmp.Attributes = MemberAttributes.Public | MemberAttributes.Final | MemberAttributes.Static;
cmp.Name = SanitizeResourceName (provider, (string)de.Key);
cmp.HasGet = true;
CodePropertyResourceGet (cmp.GetStatements, (string)de.Key, type, classname);
cmp.Type = new CodeTypeReference (type);
cls.Members.Add (cmp);
}
} catch (Exception ex) {
throw new ApplicationException ("Failed to compile global resources.", ex);
}
foreach (KeyValuePair<string,bool> de in imports)
ns.Imports.Add (new CodeNamespaceImport(de.Key));
ns.Types.Add (cls);
unit.Namespaces.Add (ns);
}
