public override bool Visit(IPrimitiveExpression <ushort> expression, object context)
{
_stack.Push(expression);
try
{
return(base.Visit(expression, context));
}
finally
{
_stack.Pop();
}
}
public override bool Visit(IPrimitiveExpression <int> expression, object context)
{
/* Simple logic: The follow method predictions are all simple machines that follow a common routine.
* The assignments are state, so the states will be different, but should be equivalent should the logical flow of all else be equivalent,
* The ints that show up in the switches should be equivalent, unless we're actually returning what we should be doing, which needs to be the same.
* If everything else, from a control-flow standpoint, is the same, the machines are equivalent in function.
* A caveat: we do lose the parse tree context, from the comments, but in all honesty that is of little consequence. */
var returnContext = this.ActiveContext.OfType <IReturnStatement>().FirstOrDefault();
var switchContext = this.ActiveContext.OfType <ISwitchStatement>().FirstOrDefault();
var assignContext = this.ActiveContext.OfType <IAssignmentExpression>().FirstOrDefault();
if (returnContext == null && switchContext != null || assignContext != null)
{
return(true);
}
return(base.Visit(expression, context));
}
public void Dispose()
{
if (this.autoMember != null)
{
this.autoMember.Dispose();
this.autoMember = null;
}
if (this.dataMember != null)
{
this.dataMember.Dispose();
this.dataMember = null;
}
if (this.declarationTarget != null)
{
this.declarationTarget = null;
}
this.namePrimitive = null;
this.name = null;
this.value = null;
}
public void Rebuild()
{
if (this.autoMember != null)
{
this.declarationTarget.Properties.Remove(this.autoMember);
this.autoMember.Dispose();
}
if (this.dataMember != null)
{
this.declarationTarget.Fields.Remove(this.dataMember);
this.dataMember.Dispose();
}
switch (this.declarationTarget.GenerationType)
{
case ResourceGenerationType.GeneratedClass:
this.autoMember = declarationTarget.Properties.AddNew(new TypedName(name, typeof(string)), true, false);
this.autoMember.AccessLevel = DeclarationAccessLevel.Internal;
this.namePrimitive = new PrimitiveExpression(name);
this.autoMember.GetPart.Return(declarationTarget.ResourceManager.GetReference().GetMethod("GetString").Invoke(namePrimitive));
break;
case ResourceGenerationType.GeneratedClassWithCache:
this.dataMember = declarationTarget.Fields.AddNew(new TypedName(string.Format("__{0}_dm_", name), typeof(string)));
this.autoMember = declarationTarget.Properties.AddNew(new TypedName(name, typeof(string)), true, false);
this.dataMember.IsStatic = true;
this.autoMember.IsStatic = true;
this.dataMember.AccessLevel = DeclarationAccessLevel.Private;
this.autoMember.AccessLevel = DeclarationAccessLevel.Internal;
IFieldReferenceExpression dataMemberReference = dataMember.GetReference();
IConditionStatement ics = this.autoMember.GetPart.IfThen((Expression.Expression)dataMemberReference == PrimitiveExpression.NullValue);
this.namePrimitive = new PrimitiveExpression(name);
ics.Assign(dataMemberReference, declarationTarget.ResourceManager.GetReference().GetMethod("GetString").Invoke(namePrimitive));
this.autoMember.GetPart.Return(dataMemberReference);
break;
default:
break;
}
}
TransformationImpact IPrimitiveVisitor <TransformationImpact> .Visit(IPrimitiveExpression <ulong> primitive)
{
throw new NotImplementedException();
}
public abstract void TranslateExpression(IPrimitiveExpression primitiveExpression);
public override void TranslateExpression(IPrimitiveExpression primitiveExpression)
{
this.Provider.GenerateCodeFromExpression(primitiveExpression.GenerateCodeDom(this.Options), base.Target, this.Options.Options);
}
/// <summary><para>Creates a C♯ compiler warning, relative to the abstract model, (level 4) #78:</para><para>The 'l' suffix is easily confused with the digit '1' -- use 'L' for clarity</para></summary>
/// <param name="expression">The <see cref="IPrimitiveExpression{T}"/> of type <see cref="UInt64"/>
/// which contains the potentially confusing suffix.</param>
public static ICompilerSourceModelWarning <IPrimitiveExpression <ulong> > WarningCS0078(IPrimitiveExpression <ulong> expression)
{
var start = expression.Start ?? LineColumnPair.Zero;
var end = expression.End ?? LineColumnPair.Zero;
return(new CompilerSourceModelWarning <IPrimitiveExpression <ulong> >(CS0078, expression, expression.Location, start, end));
}
public abstract void Translate(IPrimitiveExpression <char> primitive);
public abstract void Translate(IPrimitiveExpression <ulong> primitive);
/// <summary>
/// Parses the text in the specified PrimitiveExpression, collecting and returning a dictionary of FormatItems, indexed by the format item number.
/// </summary>
public static FormatItems GetFormatItems(IPrimitiveExpression primitiveExpression)
{
FormatItems formatItems = new FormatItems();
formatItems.ParentMethodCall = GetValidMethodCallExpression(primitiveExpression.Parent) as IWithArguments;
int argumentCount = formatItems.ParentMethodCall.Args.Count;
formatItems.PrimitiveExpression = primitiveExpression;
if (primitiveExpression == null)
return formatItems;
string text = primitiveExpression.Value as string;
if (String.IsNullOrEmpty(text))
return formatItems;
bool lastCharWasOpenBrace = false;
bool insideFormatItem = false;
bool collectingFormatItemNumber = false;
string numberStr = String.Empty;
int lastOpenBraceOffset = 0;
int length = 0;
for (int i = 0; i < text.Length; i++)
{
char thisChar = text[i];
if (thisChar == '{')
{
lastCharWasOpenBrace = !lastCharWasOpenBrace;
lastOpenBraceOffset = i;
}
else if (thisChar == '}')
{
if (insideFormatItem)
{
insideFormatItem = false;
if (numberStr != String.Empty)
{
int number = int.Parse(numberStr);
const int INT_CountForBraceDelimeters = 2;
int argumentIndex = number + 1;
IExpression argument = null;
if (argumentIndex < argumentCount)
argument = formatItems.ParentMethodCall.Args[argumentIndex];
if (!formatItems.HasFormatItem(number))
formatItems.AddFormatItem(number, argument);
formatItems[number].AddPosition(lastOpenBraceOffset, length + INT_CountForBraceDelimeters);
}
}
}
else if (lastCharWasOpenBrace)
{
length = 0;
lastCharWasOpenBrace = false;
insideFormatItem = true;
collectingFormatItemNumber = true;
numberStr = String.Empty;
if (char.IsDigit(thisChar))
numberStr = thisChar.ToString(); // First digit...
}
else if (collectingFormatItemNumber)
{
if (char.IsDigit(thisChar))
numberStr += thisChar.ToString(); // Subsequent digit...
else
collectingFormatItemNumber = false;
}
length++;
}
return formatItems;
}
public abstract void Translate(IPrimitiveExpression <float> primitive);
public abstract void Translate(IPrimitiveExpression <sbyte> primitive);
public abstract void Translate(IPrimitiveExpression <decimal> primitive);
void IPrimitiveVisitor.Visit(IPrimitiveExpression <double> primitive)
{
this.Translate(primitive);
}
public TestLinkerResult Visit(IPrimitiveExpression <decimal> expression, ICompilationContext context)
{
throw new NotImplementedException();
}
void IPrimitiveVisitor.Visit(IPrimitiveExpression <ulong> primitive)
{
this.Translate(primitive);
}
public TransformationKind Visit(IPrimitiveExpression <decimal> expression, ITransformationContext context)
{
return(TransformationKind.Ignore);
}
