mono/linux-packaging-mono
0
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Imported Upstream version 4.6.0.125

Browse Source 
Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4
This commit is contained in:
Xamarin Public Jenkins (auto-signing)
2016-08-03 10:59:49 +00:00
parent a569aebcfd
commit e79aa3c0ed
17047 changed files with 3137615 additions and 392334 deletions
Download Patch File Download Diff File Expand all files Collapse all files

406
mcs/class/referencesource/System.Data.Entity.Design/System/Data/EntityModel/Emitters/FixUp.cs Normal file
View File

@ -0,0 +1,406 @@
//---------------------------------------------------------------------
// <copyright file="FixUp.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
//
// @owner [....]
// @backupOwner [....]
//---------------------------------------------------------------------
using System;
using System.Data.EntityModel.SchemaObjectModel;
using System.Data.Entity.Design;
namespace System.Data.EntityModel.Emitters
{
/// <summary>
///
/// </summary>
internal sealed class FixUp
{
#region Internal Property
internal delegate string FixMethod(string line);
#endregion
#region Instance Fields
FixUpType m_type;
private string _class = null;
private string _method = null;
private string _property = null;
#endregion
#region static
private static readonly FixMethod[] _CSFixMethods = new FixMethod[]
{
null,
new FixMethod(CSMarkOverrideMethodAsSealed),
new FixMethod(CSMarkPropertySetAsInternal),
new FixMethod(CSMarkClassAsStatic),
new FixMethod(CSMarkPropertyGetAsPrivate),
new FixMethod(CSMarkPropertyGetAsInternal),
new FixMethod(CSMarkPropertyGetAsPublic),
new FixMethod(CSMarkPropertySetAsPrivate),
new FixMethod(CSMarkPropertySetAsPublic),
new FixMethod(CSMarkMethodAsPartial),
new FixMethod(CSMarkPropertyGetAsProtected),
new FixMethod(CSMarkPropertySetAsProtected)
};
private static readonly FixMethod[] _VBFixMethods = new FixMethod[]
{
null,
new FixMethod(VBMarkOverrideMethodAsSealed),
new FixMethod(VBMarkPropertySetAsInternal),
null, // VB doesn't support static classes (during CodeGen we added a private ctor to the class)
new FixMethod(VBMarkPropertyGetAsPrivate),
new FixMethod(VBMarkPropertyGetAsInternal),
new FixMethod(VBMarkPropertyGetAsPublic),
new FixMethod(VBMarkPropertySetAsPrivate),
new FixMethod(VBMarkPropertySetAsPublic),
new FixMethod(VBMarkMethodAsPartial),
new FixMethod(VBMarkPropertyGetAsProtected),
new FixMethod(VBMarkPropertySetAsProtected)
};
#endregion
#region Public Methods
/// <summary>
///
/// </summary>
/// <param name="fqName"></param>
/// <param name="type"></param>
public FixUp(string fqName,FixUpType type)
{
Type = type;
string[] nameParts = Utils.SplitName(fqName);
if ( type == FixUpType.MarkClassAsStatic )
{
Class = nameParts[nameParts.Length-1];
}
else
{
Class = nameParts[nameParts.Length-2];
string name = nameParts[nameParts.Length-1];
switch ( type )
{
case FixUpType.MarkAbstractMethodAsPartial:
case FixUpType.MarkOverrideMethodAsSealed:
Method = name;
break;
case FixUpType.MarkPropertyGetAsPrivate:
case FixUpType.MarkPropertyGetAsInternal:
case FixUpType.MarkPropertyGetAsPublic:
case FixUpType.MarkPropertyGetAsProtected:
case FixUpType.MarkPropertySetAsPrivate:
case FixUpType.MarkPropertySetAsInternal:
case FixUpType.MarkPropertySetAsPublic:
case FixUpType.MarkPropertySetAsProtected:
Property = name;
break;
}
}
}
/// <summary>
///
/// </summary>
/// <param name="language"></param>
/// <param name="line"></param>
/// <returns></returns>
public string Fix(LanguageOption language, string line)
{
FixMethod method = null;
if ( language == LanguageOption.GenerateCSharpCode )
{
method = _CSFixMethods[(int)Type];
}
else if ( language == LanguageOption.GenerateVBCode )
{
method = _VBFixMethods[(int)Type];
}
if ( method != null )
{
line = method( line );
}
return line;
}
#endregion
#region Public Properties
/// <summary>
///
/// </summary>
/// <value></value>
public string Class
{
get
{
return _class;
}
private set
{
_class = value;
}
}
/// <summary>
///
/// </summary>
/// <value></value>
public string Property
{
get
{
return _property;
}
private set
{
_property = value;
}
}
/// <summary>
///
/// </summary>
/// <value></value>
public string Method
{
get
{
return _method;
}
private set
{
_method = value;
}
}
/// <summary>
///
/// </summary>
/// <value></value>
public FixUpType Type
{
get
{
return m_type;
}
private set
{
m_type = value;
}
}
#endregion
#region Private Methods
/// <summary>
///
/// </summary>
/// <param name="line"></param>
/// <returns></returns>
private static string CSMarkMethodAsPartial(string line)
{
line = ReplaceFirst(line, "public abstract", "partial");
return line;
}
/// <summary>
///
/// </summary>
/// <param name="line"></param>
/// <returns></returns>
private static string VBMarkMethodAsPartial(string line)
{
line = ReplaceFirst(line, "Public MustOverride", "Partial Private");
line += Environment.NewLine + " End Sub";
return line;
}
private static string ReplaceFirst(string line, string str1, string str2)
{
int idx = line.IndexOf(str1, StringComparison.Ordinal);
if (idx >= 0)
{
line = line.Remove(idx, str1.Length);
line = line.Insert(idx, str2);
}
return line;
}
/// <summary>
///
/// </summary>
/// <param name="line"></param>
/// <returns></returns>
private static string CSMarkOverrideMethodAsSealed(string line)
{
return InsertBefore(line,"override","sealed");
}
/// <summary>
///
/// </summary>
/// <param name="line"></param>
/// <returns></returns>
private static string VBMarkOverrideMethodAsSealed(string line)
{
return InsertBefore(line, "Overrides", "NotOverridable");
}
/// <summary>
///
/// </summary>
/// <param name="line"></param>
/// <returns></returns>
private static string CSMarkPropertySetAsInternal(string line)
{
return InsertBefore(line,"set","internal");
}
/// <summary>
///
/// </summary>
/// <param name="line"></param>
/// <returns></returns>
private static string VBMarkPropertySetAsInternal(string line)
{
return InsertBefore(line,"Set","Friend");
}
private static string CSMarkPropertyGetAsPrivate(string line)
{
return InsertBefore(line, "get", "private");
}
private static string VBMarkPropertyGetAsPrivate(string line)
{
return InsertBefore(line, "Get", "Private");
}
private static string CSMarkPropertyGetAsInternal(string line)
{
return InsertBefore(line, "get", "internal");
}
private static string VBMarkPropertyGetAsInternal(string line)
{
return InsertBefore(line, "Get", "Friend");
}
private static string CSMarkPropertySetAsProtected(string line)
{
return InsertBefore(line, "set", "protected");
}
private static string VBMarkPropertySetAsProtected(string line)
{
return InsertBefore(line, "Set", "Protected");
}
private static string CSMarkPropertyGetAsProtected(string line)
{
return InsertBefore(line, "get", "protected");
}
private static string VBMarkPropertyGetAsProtected(string line)
{
return InsertBefore(line, "Get", "Protected");
}
private static string CSMarkPropertyGetAsPublic(string line)
{
return InsertBefore(line, "get", "public");
}
private static string VBMarkPropertyGetAsPublic(string line)
{
return InsertBefore(line, "Get", "Public");
}
private static string CSMarkPropertySetAsPrivate(string line)
{
return InsertBefore(line, "set", "private");
}
private static string VBMarkPropertySetAsPrivate(string line)
{
return InsertBefore(line, "Set", "Private");
}
private static string CSMarkPropertySetAsPublic(string line)
{
return InsertBefore(line, "set", "public");
}
private static string VBMarkPropertySetAsPublic(string line)
{
return InsertBefore(line, "Set", "Public");
}
/// <summary>
///
/// </summary>
/// <param name="line"></param>
/// <returns></returns>
private static string CSMarkClassAsStatic(string line)
{
if ( IndexOfKeyword(line,"static") >= 0 )
return line;
int insertPoint = IndexOfKeyword(line,"class");
if ( insertPoint < 0 )
return line;
// nothing can be between partial and class
int partialIndex = IndexOfKeyword(line,"partial");
if ( partialIndex >= 0 )
insertPoint = partialIndex;
return line.Insert(insertPoint,"static ");
}
/// <summary>
/// Inserts one keyword before another one.
/// Does nothing if the keyword to be inserted already exists in the line OR if the keyword to insert before doesn't
/// </summary>
/// <param name="line">line of text to examine</param>
/// <param name="searchText">keyword to search for </param>
/// <param name="insertText">keyword to be inserted</param>
/// <returns>the possibly modified line line</returns>
private static string InsertBefore(string line,string searchText,string insertText)
{
if ( IndexOfKeyword(line,insertText) >= 0 )
return line;
int index = IndexOfKeyword(line,searchText);
if ( index < 0 )
return line;
return line.Insert(index,insertText+" ");
}
/// <summary>
/// Finds location of a keyword in a line.
/// keyword must be at the beginning of the line or preceeded by whitespace AND at the end of the line or followed by whitespace
/// </summary>
/// <param name="line">line to seach</param>
/// <param name="keyword">keyword to search for</param>
/// <returns>location of first character of keyword</returns>
private static int IndexOfKeyword(string line,string keyword)
{
int index = line.IndexOf(keyword,StringComparison.Ordinal);
if ( index < 0 )
return index;
int indexAfter = index+keyword.Length;
if ( (index == 0 || char.IsWhiteSpace(line,index-1)) && (indexAfter == line.Length || char.IsWhiteSpace(line,indexAfter)) )
return index;
return -1;
}
#endregion
}
}