ICode Convert(MethodCallExpression method)
{
var chain = GetMethodChains(method);
if (chain.Count == 0)
{
return(ResolveExpressionObject(method));
}
//convert symbol.
var code = new ICode[chain.Count];
for (int i = 0; i < code.Length; i++)
{
code[i] = chain[i].GetMethodConverter().Convert(chain[i], this);
}
var core = new VCode(code);
var topQuery = code[0] as ITopQueryCode;
return(topQuery != null ?
(ICode)topQuery.Create(core) :
new QueryCode(core));
}
internal static ICode AddCode(ICode lhs, ICode rhs)
{
if (lhs.IsEmpty)
{
return(rhs);
}
if (rhs.IsEmpty)
{
return(lhs);
}
var topQueryLeft = lhs as ITopQueryCode;
var topQueryRight = rhs as ITopQueryCode;
if (topQueryLeft == null && topQueryRight == null)
{
return(new VCode(lhs, rhs));
}
if (topQueryLeft == null && topQueryRight != null)
{
return(new VCode(lhs, topQueryRight.Core));
}
if (topQueryLeft != null && topQueryRight == null)
{
return(topQueryLeft.Create(new VCode(topQueryLeft.Core, rhs)));
}
return(topQueryLeft.Create(new VCode(topQueryLeft.Core, topQueryRight.Core)));
}
public static Dictionary <ICode, BlockInfo> GetInfo(ICode ast)
{
var v = new FindSuitableBlocks();
v.Visit(ast);
return(v.blockCounts);
}
public static string V(ICode c) {
var method = c.Ctx.MRef;
StringBuilder sb = new StringBuilder();
sb.Append(method.FullName);
var seen = new HashSet<ICode>() { c };
var todo = new Queue<Stmt>();
todo.Enqueue((Stmt)c);
while (todo.Any()) {
var cBlock = todo.Dequeue();
var v = new ShowVisitor();
v.Visit(cBlock);
sb.AppendLine();
sb.Append(GetStmtName(cBlock) + ":");
sb.Append(v.Code);
foreach (var continuation in v.Continuations) {
if (seen.Add(continuation.To)) {
todo.Enqueue(continuation.To);
}
}
}
sb.AppendLine();
sb.Append("}");
return sb.ToString();
}
protected override void BlockStart(ICode block)
{
base.BlockStart(block);
this.knownTrue.Clear();
this.knownTrue.Push(new List <Expr>());
this.assignmentsTo.Clear();
}
public static bool Only(ICode ast, params Stmt.NodeType[] stmtTypes)
{
var v = new VisitorOnlyStatements(stmtTypes);
v.Visit(ast);
return(v.IsOnlyRequestedTypes);
}
public static IEnumerable <FieldReference> V(ICode ast)
{
var v = new VisitorFindFieldAccesses();
v.Visit(ast);
return(v.fieldAccesses);
}
public static IEnumerable <TypeReference> V(ICode ast)
{
var v = new VisitorFindRequiredTypes();
v.Visit(ast);
return(v.types);
}
public void Fill(Database database, string connectionString)
{
ICode code = null;
try
{
if ((database.Options.Ignore.FilterStoreProcedure) || (database.Options.Ignore.FilterView) || (database.Options.Ignore.FilterFunction) || (database.Options.Ignore.FilterTrigger))
{
root.RaiseOnReading(new ProgressEventArgs("Reading Text Objects...", Constants.READING_TEXTOBJECTS));
using (SqlConnection conn = new SqlConnection(connectionString))
{
using (SqlCommand command = new SqlCommand(GetSQL(database.Options), conn))
{
conn.Open();
command.CommandTimeout = 0;
using (SqlDataReader reader = command.ExecuteReader())
{
while (reader.Read())
{
code = null;
root.RaiseOnReadingOne(reader["name"]);
string type = reader["Type"].ToString().Trim();
string name = reader["name"].ToString();
string definition = reader["Text"].ToString();
int id = (int)reader["object_id"];
if (type.Equals("V"))
{
code = (ICode)database.Views.Find(id);
}
if (type.Equals("TR"))
{
code = (ICode)database.Find(id);
}
if (type.Equals("P"))
{
((ICode)database.Procedures.Find(id)).Text = GetObjectDefinition(type, name, definition);
}
if (type.Equals("IF") || type.Equals("FN") || type.Equals("TF"))
{
code = (ICode)database.Functions.Find(id);
}
if (code != null)
{
code.Text = reader["Text"].ToString();
}
}
}
}
}
}
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// Converts an FXCM OrderStatus to a QuantConnect <see cref="OrderStatus"/>
/// </summary>
/// <param name="status"></param>
/// <returns></returns>
private static OrderStatus ConvertOrderStatus(ICode status)
{
var result = OrderStatus.None;
switch (status.getCode())
{
case IFixValueDefs.__Fields.FXCMORDSTATUS_INPROCESS:
case IFixValueDefs.__Fields.FXCMORDSTATUS_WAITING:
case IFixValueDefs.__Fields.FXCMORDSTATUS_EXECUTING:
result = OrderStatus.Submitted;
break;
case IFixValueDefs.__Fields.FXCMORDSTATUS_EXECUTED:
result = OrderStatus.Filled;
break;
case IFixValueDefs.__Fields.FXCMORDSTATUS_CANCELLED:
case IFixValueDefs.__Fields.FXCMORDSTATUS_EXPIRED:
result = OrderStatus.Canceled;
break;
case IFixValueDefs.__Fields.FXCMORDSTATUS_REJECTED:
result = OrderStatus.Invalid;
break;
}
return(result);
}
// TODO: Restrict movement across try/catch/finally borders
public static ICode V(ICode ast) {
var v = new VisitorSsaCopyPropagation();
var ast2 = v.Visit(ast);
var alreadyReplaced = new Dictionary<Expr, Expr>();
foreach (var a in v.assignments.Values) {
if (a.mustKeep) {
continue;
}
if (a.assignment == null) {
continue;
}
if (a.count == 1) {
if (!VisitorFindSpecials.Any(a.assignment, Expr.Special.PossibleSideEffects)) {
ast2 = VisitorReplace.V(ast2, a.assignment, null);
}
} else if (a.count == 2 /*||
(IsSimple(alreadyReplaced.ValueOrDefault(a.assignment.Expr, a.assignment.Expr)) && !a.assignment.Expr.Type.IsNonPrimitiveValueType())*/) {
var updater = new Updater(a.assignment.Target);
ast2 = updater.Visit(ast2);
foreach (var replaced in updater.Replaced) {
alreadyReplaced[replaced.Item1] = replaced.Item2;
}
}
}
return ast2;
}
public static IEnumerable <ICall> V(ICode ast)
{
var v = new VisitorFindCalls();
v.Visit(ast);
return(v.calls);
}
public static int GetCount(ICode ast, ICode toCount) {
var v = new VisitorCounter {
toCount = toCount
};
v.Visit(ast);
return v.count;
}
public override void Deserialize(Stream input)
{
var dataType = input.ReadValueU32();
var length = input.ReadValueS32();
this.GlobalVariableCount = input.ReadValueU32();
var codeStream = input.ReadToMemoryStream(length);
ICode code;
if (dataType == 1)
{
code = new SourceCode();
}
else if (dataType == 5)
{
code = new CompiledCode();
}
else
{
throw new InvalidOperationException();
}
code.Deserialize(codeStream);
this.Code = code;
}
private static void AnalyzeCode(ICode code, int errorsCount, int?decodingThreadsCount = null)
{
var informationWord = Enumerable.Repeat(code.Field.Zero(), code.InformationWordLength).ToArray();
var codeword = code.Encode(informationWord);
var processedNoises = 0;
Parallel.ForEach(
NoiseGenerator.VariatePositionsAndValues(code.Field, code.CodewordLength, errorsCount),
new ParallelOptions {
MaxDegreeOfParallelism = decodingThreadsCount ?? (int)(Environment.ProcessorCount * 1.5d)
},
x =>
{
var decodingResults = code.DecodeViaList(codeword.AddNoise(x), errorsCount);
if (decodingResults.Contains(informationWord, WordsComparer) == false)
{
throw new InvalidOperationException($"Failed to process noise {string.Join<FieldElement>(",", x)}");
}
if (Interlocked.Increment(ref processedNoises) % 50 == 0)
{
Logger.LogInformation($"[{Thread.CurrentThread.ManagedThreadId}]: Current noise value ({string.Join<FieldElement>(",", x)})");
}
if (TelemetryCollector.ProcessedSamplesCount % 100 == 0)
{
Logger.LogInformation(TelemetryCollector.ToString());
}
}
);
}
/// <summary>
/// Setup a <see cref="JsTreeNode"/> from a <c>CodeBean</c>
/// </summary>
/// <param name="node">
/// The <see cref="JsTreeNode"/>
/// </param>
/// <param name="artefact">
/// The <c>CodeBean</c>
/// </param>
protected static void SetupNode(JsTreeNode node, ICode artefact)
{
string entitle = "[" + artefact.Id + "]";
string format = string.Format(CultureInfo.InvariantCulture, ArtefactFormat, entitle);
SetupNode(node, artefact, entitle, format);
}
public MethodCallExpression(string name, Expression expression)
{
this.name = name;
this.caller = expression;
parameters = new List<Expression>();
genericArgumentTypes = new List<CsType>();
}
public static string V(ICode c)
{
var method = c.Ctx.MRef;
StringBuilder sb = new StringBuilder();
sb.Append(method.FullName);
var seen = new HashSet <ICode>()
{
c
};
var todo = new Queue <Stmt>();
todo.Enqueue((Stmt)c);
while (todo.Any())
{
var cBlock = todo.Dequeue();
var v = new ShowVisitor();
v.Visit(cBlock);
sb.AppendLine();
sb.Append(GetStmtName(cBlock) + ":");
sb.Append(v.Code);
foreach (var continuation in v.Continuations)
{
if (seen.Add(continuation.To))
{
todo.Enqueue(continuation.To);
}
}
}
sb.AppendLine();
sb.Append("}");
return(sb.ToString());
}
internal static ICode ConvertTable(ExpressionConverter decoder, Expression exp)
{
//where query, write tables side by side.
var arry = exp as NewArrayExpression;
if (arry != null)
{
var multiTables = new ICode[arry.Expressions.Count];
for (int i = 0; i < multiTables.Length; i++)
{
multiTables[i] = ConvertTable(decoder, arry.Expressions[i]);
}
return(Arguments(multiTables));
}
var table = decoder.ConvertToCode(exp);
if (table.IsEmpty)
{
return(string.Empty.ToCode());
}
//sub query.
var body = GetSubQuery(exp);
if (body != null)
{
return(new SubQueryAndNameCode(body, table));
}
return(table);
}
public CodeLambda(string lhsSymbol, IEnumerable <FuncParameter> parameters, string resultTypeName, ICode body)
{
this.Body = body;
this.LhsSymbol = lhsSymbol;
this.Parameters = parameters.ToArray();
// this is safe but conservative, in case when user named some parameter this param will be counted as use
// which does not have to be true, to be 100% sure we should analyse the given code -- but it takes some work
// and is error prone, so for now -- let's stick with params only
this.RhsUnusedParamsCount = this.Parameters.TakeWhile(it => it.IsDummy).Count();
this.ResultTypeName = resultTypeName;
if (this.Parameters.Any(it => it == null))
{
throw new ArgumentNullException();
}
var dups = this.Parameters
.GroupBy(it => it.Name)
.Where(it => it.Count() > 1)
.Select(it => it.Key)
.ToArray();
if (dups.Any())
{
throw new ArgumentException("Duplicate parameter names: " + dups.Join(", "));
}
}
protected virtual ICode TopLevel(ICode c) {
this.seen.Add(c);
this.todo.Enqueue(c);
ICode ret = null;
while (todo.Any()) {
var node = todo.Dequeue();
this.BlockStart(node);
var transformed = this.Visit(node);
this.BlockEnd(node, transformed);
if (ret == null) {
ret = transformed;
}
}
bool anyChanges = false;
foreach (var continuation in this.continuations) {
var mapped = this.map.ValueOrDefault(continuation.To);
if (mapped != null) {
continuation.To = (Stmt)mapped;
anyChanges = true;
}
}
if (anyChanges) {
// Cloned to make sure the returned object will be different from ICode argument
// Other code relies on it being different if this visitor has made changes to the AST
ret = (ICode)ret.Clone();
}
return ret;
}
internal static HCode Clause(ICode clause, params ICode[] args)
{
var code = new HCode() { AddIndentNewLine = true, Separator = " " };
code.Add(clause);
code.AddRange(args);
return code;
}
public static ICode V(ICode ast) {
var ctx = ast.Ctx;
var blockInfo = VisitorSubstituteIrreducable.FindSuitableBlocks.GetInfo(ast);
var bInfo = blockInfo.Select(x => new {
toCount = VisitorContToCounter.GetCount(x.Key, ast),
ast = x.Key,
codeCount = x.Value.numICodes,
}).ToArray();
var block = bInfo.Where(x => x.toCount >= 2).OrderBy(x => x.toCount * x.codeCount).FirstOrDefault();
if (block == null) {
return ast;
}
var phis = new Dictionary<Expr,Expr>();
var blockCopies = Enumerable.Range(0, block.toCount - 1)
.Select(x => {
var v = new VisitorDuplicateCode();
var ret = v.Visit(block.ast);
phis = phis.Merge(v.phiMap, (a, b) => new ExprVarPhi(ctx) { Exprs = new[] { a, b } });
return ret;
})
.Concat(block.ast)
.ToArray();
var contTos = VisitorFindContinuationsRecursive.Get(ast).Where(x => x.To == block.ast).ToArray();
for (int i = 0; i < contTos.Length; i++) {
var contTo = contTos[i];
var blockCopy = blockCopies[i];
ast = VisitorReplace.V(ast, contTo, blockCopy);
}
ast = VisitorReplaceExprUse.V(ast, phis);
return ast;
}
public static IEnumerable <ExprVar> V(ICode ast)
{
var v = new VisitorFindVars();
v.Visit(ast);
return(v.vars);
}
private void CreateCodeInstance()
{
// Auto generated code
Code = new global::CodeInstance.CodeInstance();
CodeParameters = new List <CodeParameterBase>(Code.GetParameters().Select(ToCodeParameters));
}
public static IEnumerable <Stmt> Find(ICode ast)
{
var v = new VisitorFindDuplicateStmts();
v.Visit(ast);
return(v.duplicates);
}
public static int Count(ICode ast, ICode toCount)
{
var v = new VisitorCounter(toCount);
v.Visit(ast);
return(v.count);
}
bool TryGetDbDesignParamCode(MemberExpression exp, out ICode code)
{
var member = exp;
code = null;
var names = new List <string>();
while (member != null)
{
names.Insert(0, member.Member.Name);
var table = member.GetMemberTableConverter();
if (table != null)
{
if (!string.IsNullOrEmpty(table.Name))
{
names[0] = table.Name;
}
var lambdaName = string.Join(".", names.ToArray());
code = (names.Count == 1) ?
(ICode) new DbTableCode(new TableInfo(lambdaName, lambdaName)) :
new DbColumnCode(new ColumnInfo(exp.Type, lambdaName, lambdaName, names[names.Count - 1]));
return(true);
}
if (member.Expression is ParameterExpression)
{
//using ParameterExpression with LambdicSql only when it represents a component of db.
//for example, Sql<DB>.Create(db =>
var lambdaName = string.Join(".", names.ToArray());
code = ResolveLambdicElement(lambdaName);
return(true);
}
member = member.Expression as MemberExpression;
}
return(false);
}
public static bool Any(ICode ast)
{
var v = new VisitorFindContinuationsRecursive();
v.Visit(ast);
return(v.Continuations.Any());
}
/// <summary>
/// Convert expression to code.
/// </summary>
/// <param name="expression">Expression.</param>
/// <param name="converter">Expression converter.</param>
/// <returns>Parts.</returns>
public override ICode Convert(MethodCallExpression expression, ExpressionConverter converter)
{
//ALL, DISTINCT, TOP
int expressionIndex = expression.SkipMethodChain(0);
var selectParts = new ICode[expression.Arguments.Count - expressionIndex];
selectParts[0] = string.IsNullOrEmpty(Name) ? SelectClause : Name.ToCode();
for (int i = 0; i < selectParts.Length - 1; i++, expressionIndex++)
{
selectParts[i + 1] = converter.ConvertToCode(expression.Arguments[expressionIndex]);
}
var select = LineSpace(selectParts);
//select elemnts.
var selectTargets = expression.Arguments[expression.Arguments.Count - 1];
//*
if (typeof(AsteriskBase).IsAssignableFromEx(selectTargets.Type))
{
select.Add(converter.ConvertToCode(selectTargets));
return(new SelectClauseCode(select));
}
//new []{ a, b, c} recursive.
else if (selectTargets.Type.IsArray)
{
var newArrayExp = selectTargets as NewArrayExpression;
if (newArrayExp != null)
{
var array = new ICode[newArrayExp.Expressions.Count];
for (int i = 0; i < array.Length; i++)
{
array[i] = converter.ConvertToCode(newArrayExp.Expressions[i]);
}
var coreCode = new VCode(select, new VCode(array)
{
Indent = 1, Separator = ","
});
return(new SelectClauseCode(coreCode));
}
}
//new { item = db.tbl.column }
{
var createInfo = ObjectCreateAnalyzer.MakeObjectCreateInfo(selectTargets);
var elements = new ICode[createInfo.Members.Length];
for (int i = 0; i < elements.Length; i++)
{
elements[i] = ConvertSelectedElement(converter, createInfo.Members[i]);
}
var coreCode = new VCode(select, new VCode(elements)
{
Indent = 1, Separator = ","
});
return(new SelectClauseCode(coreCode));
}
}
public static IEnumerable <StmtContinuation> Get(ICode ast)
{
var v = new VisitorFindContinuationsRecursive();
v.Visit(ast);
return(v.Continuations);
}
private void ObfuscateAssembly(string filePath, PeFile peFile, ICode code)
{
var fileObfuscated = Path.GetFileNameWithoutExtension(filePath) +
"Obf" + Path.GetExtension(filePath);
m_codeObfuscator.Obfuscate(fileObfuscated, peFile, code);
}
public static IEnumerable <MethodReference> V(ICode ast)
{
var v = new VisitorFindStaticConstructors();
v.Visit(ast);
return(v.staticConstructors);
}
private IfBuilder GenerateDataInterfaceIfClause(
ObjectTypeDescriptor objectTypeDescriptor,
bool isNonNullable,
string variableName)
{
ICode ifCondition = MethodCallBuilder
.Inline()
.SetMethodName(
_dataParameterName.MakeNullable(!isNonNullable),
WellKnownNames.TypeName,
nameof(string.Equals))
.AddArgument(objectTypeDescriptor.Name.AsStringToken())
.AddArgument(TypeNames.OrdinalStringComparison);
if (!isNonNullable)
{
ifCondition = NullCheckBuilder
.New()
.SetCondition(ifCondition)
.SetSingleLine()
.SetDetermineStatement(false)
.SetCode("false");
}
MethodCallBuilder constructorCall = MethodCallBuilder
.Inline()
.SetNew()
.SetMethodName(objectTypeDescriptor.RuntimeType.Name);
foreach (PropertyDescriptor prop in objectTypeDescriptor.Properties)
{
var propAccess = $"{_dataParameterName}.{prop.Name}";
if (prop.Type.IsEntityType() || prop.Type.IsDataType())
{
constructorCall.AddArgument(BuildMapMethodCall(_dataParameterName, prop, true));
}
else if (prop.Type.IsNullableType())
{
constructorCall.AddArgument(propAccess);
}
else
{
constructorCall
.AddArgument(
NullCheckBuilder
.Inline()
.SetCondition(propAccess)
.SetCode(ExceptionBuilder.Inline(TypeNames.ArgumentNullException)));
}
}
return(IfBuilder
.New()
.SetCondition(ifCondition)
.AddCode(AssignmentBuilder
.New()
.SetLefthandSide(variableName)
.SetRighthandSide(constructorCall)));
}
public void Save(ICode code)
{
if (code == null)
throw new ArgumentNullException("code");
if (code.Configuration != null)
Storage.Store(SavePath(code), code.Configuration.Settings);
}
public static ICode V(ICode ast) {
var phiClusters = VisitorPhiClusters.V(ast);
var v = new VisitorDefiniteAssignment {
phiComparer = new VisitorPhiClusters.EqualityComparer(phiClusters),
};
v.stack.Push(new List<ExprVar>());
return v.Visit(ast);
}
public DetailItem(ICode location)
: base(new string[3])
{
_location = location;
base.SubItems[0].Text = location.CODE;
base.SubItems[1].Text = location.Name;
base.SubItems[2].Text = location.Description;
}
public override void process(ICode iCode, SymbolTableStack symbolTableStack)
{
long startTime = DateTime.Now.Ticks;
float elapsedTime = (DateTime.Now.Ticks - startTime) / 1000f;
int instructionCount = 0;
sendMessage(new Message(MessageType.COMPILER_SUMMARY, new Object[] {instructionCount, elapsedTime}));
}
public static ICode V(ICode ast) {
var v = new VisitorIfSimplification(ast);
var ret = v.Visit(ast);
foreach (var replace in v.replaceVars) {
ret = VisitorReplace.V(ret, replace.Item1, replace.Item2);
}
return ret;
}
internal SubQueryAndNameCode(string body, ICode table)
{
_body = body;
_define = new HCode(table, _body.ToCode())
{
Separator = " ", EnableChangeLine = false
};
}
public MethodCallExpression(string name, CsType csType)
{
this.name = name;
this.caller = csType;
IsStaticMethodCall = true;
parameters = new List<Expression>();
genericArgumentTypes = new List<CsType>();
}
public static void Main ()
{
IEnumerable<object> array = new ICode[10];
IEnumerator<object> x = array.GetEnumerator ();
x.MoveNext ();
object o = x.Current;
}
/// <summary>
/// Add text.
/// </summary>
/// <param name="text">Text.</param>
public void Add(ICode text)
{
if (text.IsEmpty)
{
return;
}
_core.Add(text);
}
public static string Create(MethodReference mRef, Resolver resolver, ICode ast) {
if (mRef.ContainsGenericParameters()) {
throw new ArgumentException("Cannot create JS for method with open generic parameters");
}
var mDef = mRef.Resolve();
if (mDef.IsAbstract) {
throw new ArgumentException("Should never need to transcode an abstract method");
}
var tRef = mRef.DeclaringType;
var tDef = tRef.Resolve();
var v = new JsMethod(resolver);
v.Visit(ast);
var js = v.js.ToString();
var sb = new StringBuilder();
// Method declaration
var methodName = resolver.MethodNames[mRef];
//var parameterNames = mRef.Parameters.Select(x => v.parameters.ValueOrDefault(x).NullThru(y => resolver.LocalVarNames[y])).ToArray();
// Match parameters, but have to do by position, as method built may be a custom method replacing a BCL method,
// so parameters are not the same.
var parameterNames = mRef.Parameters.Select(x => v.parameters.FirstOrDefault(y => y.Key.Sequence == x.Sequence).Value.NullThru(y => resolver.LocalVarNames[y])).ToArray();
if (!mDef.IsStatic) {
var thisName = v.vars.FirstOrDefault(x => x.ExprType == Expr.NodeType.VarThis).NullThru(x => resolver.LocalVarNames[x]);
parameterNames = parameterNames.Prepend(thisName).ToArray();
}
var unusedParameterNameGen = new NameGenerator();
parameterNames = parameterNames.Select(x => x ?? ("_" + unusedParameterNameGen.GetNewName())).ToArray();
sb.AppendFormat("// {0}", mRef.FullName);
sb.AppendLine();
sb.AppendFormat("var {0} = function({1}) {{", methodName, string.Join(", ", parameterNames));
// Variable declarations
var declVars = v.vars
.Select(x => new { name = resolver.LocalVarNames[x], type = x.Type })
.Where(x => !parameterNames.Contains(x.name))
.Select(x => {
var name = x.name;
if (x.type.IsValueType) {
name += " = " + DefaultValuer.Get(x.type, resolver.FieldNames);
}
return name;
})
.Distinct() // Bit of a hack, but works for now
.ToArray();
if (declVars.Any()) {
sb.AppendLine();
sb.Append(' ', tabSize);
sb.AppendFormat("var {0};", string.Join(", ", declVars));
}
// Method body
sb.AppendLine(js);
// Method ending
sb.AppendLine("};");
var sbStr = sb.ToString();
return sbStr;
}
public override bool Compare(ICode obj)
{
if (obj == null) throw new ArgumentNullException("obj");
if (!this.ToSql().Equals(obj.ToSql())) return false;
if (this.InsteadOf != ((Trigger)obj).InsteadOf) return false;
if (this.IsDisabled != ((Trigger)obj).IsDisabled) return false;
if (this.NotForReplication != ((Trigger)obj).NotForReplication) return false;
return true;
}
// Only have if, switch, cil, continuation, try - no other type of statement
// Blocks will only start with cil or try
// Will end with null, if, switch or continuation
// If ending in 'if', 'then' and 'else' will both have continuations only
// 'try' statements will have only 0 or 1 catch clauses
public static ICode V(ICode ast) {
var v = new VisitorConvertCilToSsa(ast);
ast = v.Visit(ast);
foreach (var instResult in v.instResults.Values) {
var var = new ExprVarLocal(ast.Ctx, instResult.Type);
ast = VisitorReplace.V(ast, instResult, var);
}
return ast;
}
public override string SavePath(ICode code)
{
if (code == null)
throw new ArgumentNullException("code");
if (code.Configuration != null)
return String.Format("\\{0}\\{1}", code.Configuration.SettingsIdentifier, code.Configuration.Settings.Version);
else
return null;
}
public override IEnumerable<string> LoadPaths(ICode code)
{
if (code == null)
throw new ArgumentNullException("code");
if (code.Configuration != null)
{
for (int i = code.Configuration.SupportedSettingsVersions.To; i >= code.Configuration.SupportedSettingsVersions.From; i--)
yield return String.Format("\\{0}\\{1}", code.Configuration.SettingsIdentifier, i);
}
}
public CodeRefObjectBaseCore(IHierarchy Ihierarchy,
IHierarchicalCode codeRef, IList<ICodelistObject> codelists) : base(codeRef) {
Icode = IGetCode(Ihierarchy, codeRef, codelists);
if (codeRef.CodeRefs != null) {
_codeRefs = new List<IHierarchicalCodeObjectBase>();
/* foreach */
foreach (IHierarchicalCode currentCodeRef in codeRef.CodeRefs)
_codeRefs.Add(new CodeRefObjectBaseCore(Ihierarchy,
currentCodeRef, codelists));
}
}
private VisitorConvertCilToSsa(ICode root) {
this.ctx = root.Ctx;
var v = new VisitorFindInstResults();
v.Visit(root);
this.instResults = v.instResults.ToDictionary(x => x.Inst);
this.CreateOrMergeBsi((Stmt)root, new ExprVarPhi[0],
this.ctx.MDef.Body.Variables.Select(x => (Expr)new ExprVarLocal(this.ctx, x.VariableType.FullResolve(this.ctx))).ToArray(),
this.ctx.MRef.Parameters.Select(x => (Expr)new ExprVarParameter(this.ctx, x)).ToArray());
if (this.ctx.HasFakeThis) {
this.blockStartInfos[root].Args[0] = new ExprVarPhi(this.ctx) { Exprs = new Expr[] { ctx.This } };
}
}
/// <summary>
/// Convert expression to code.
/// </summary>
/// <param name="expression">Expression.</param>
/// <param name="converter">Expression converter.</param>
/// <returns>Parts.</returns>
public override ICode Convert(MethodCallExpression expression, ExpressionConverter converter)
{
//ALL, DISTINCT, TOP
int expressionIndex = expression.SkipMethodChain(0);
var selectParts = new ICode[expression.Arguments.Count - expressionIndex];
selectParts[0] = SelectClause;
for (int i = 0; i < selectParts.Length - 1; i++, expressionIndex++)
{
selectParts[i + 1] = converter.ConvertToCode(expression.Arguments[expressionIndex]);
}
var select = LineSpace(selectParts);
//select elemnts.
var selectTargets = expression.Arguments[expression.Arguments.Count - 1];
//*
if (typeof(IAsterisk).IsAssignableFromEx(selectTargets.Type))
{
select.Add("*".ToCode());
return new SelectClauseCode(select);
}
//new []{ a, b, c} recursive.
else if (selectTargets.Type.IsArray)
{
var newArrayExp = selectTargets as NewArrayExpression;
var array = new ICode[newArrayExp.Expressions.Count];
for (int i = 0; i < array.Length; i++)
{
array[i] = converter.ConvertToCode(newArrayExp.Expressions[i]);
}
var coreCode = new VCode(select, new VCode(array) { Indent = 1, Separator = "," });
return new SelectClauseCode(coreCode);
}
//new { item = db.tbl.column }
else
{
var createInfo = ObjectCreateAnalyzer.MakeSelectInfo(selectTargets);
var elements = new ICode[createInfo.Members.Length];
for (int i = 0; i < elements.Length; i++)
{
elements[i] = ConvertSelectedElement(converter, createInfo.Members[i]);
}
var coreCode = new VCode(select, new VCode(elements) { Indent = 1, Separator = "," });
return new SelectClauseCode(coreCode);
}
}
public static ICode V(ICode ast) {
var nowReplace = new Dictionary<ExprVar, ExprVarLocal>();
for (; ; ) {
var v = new VisitorTypeCorrector {
nowReplace = nowReplace
};
ast = v.Visit(ast);
if (!v.toReplace.Any()) {
return ast;
}
nowReplace = v.toReplace;
}
}
public virtual void Process(ICode code, ISymbolTable symTab)
{
Stopwatch.Start();
Stopwatch.Stop();
int executionCount = 0;
int runtimeError = 0;
OnMessageEmitted(this, MessageType.InterpreterSummary, new Dictionary<string, object>()
{
{"ExecutionCount", executionCount},
{"RuntimeError", runtimeError},
{"Elapsed", Stopwatch.Elapsed}
});
}
public override ICode Visit(ICode c) {
if (this.first) {
this.first = false;
return this.TopLevel(c);
} else {
var ret = base.Visit(c);
if (c != ret) {
if (c.CodeType == CodeType.Statement) {
this.map.Add(c, ret);
}
}
return ret;
}
}
public OrderFormController(IOrderForms repoOrderForm
, IOrderData repoOrderData
, ICode repoCode
, IItem repoItem
, IContainer repoContainer
, IBusinessTasks repoBusinessTasks)
{
this.dalorderform = repoOrderForm;
this.dalorderdata = repoOrderData;
this.dalCode = repoCode;
this.dalItem = repoItem;
this.dalContainer = repoContainer;
this.dalBusinessTasks = repoBusinessTasks;
}
public override void process(ICode iCode, SymbolTableStack symbolTableStack)
{
this.symbolTableStack = symbolTableStack;
this.iCode = iCode;
long startTime = DateTime.Now.Ticks;
ICodeNode rootNode = iCode.GetRoot();
StatementExecutor statementExecutor = new StatementExecutor(this);
statementExecutor.Execute(rootNode);
float elapsedTime = (DateTime.Now.Ticks - startTime) / 1000f;
int runtimeErrors = RuntimeErrorHandler.errorCount;
sendMessage(new Message(MessageType.INTERPRETER_SUMMARY, new Object[] { executionCount, runtimeErrors, elapsedTime }));
}
internal IEnumerable<ICode> InitAndConvertArguments(MethodCallExpression expression, ExpressionConverter converter)
{
lock (this)
{
if (string.IsNullOrEmpty(Name)) Name = expression.Method.Name.ToUpper();
if (NameCode == null) NameCode = Name.ToCode();
if (_startIndex == -1) _startIndex = expression.SkipMethodChain(0);
if (_isParamArray == null)
{
var paramsInfo = expression.Method.GetParameters();
_isParamArray = new bool[paramsInfo.Length];
for (int i = 0; i < paramsInfo.Length; i++)
{
_isParamArray[i] = paramsInfo[i].GetAttribute<ParamArrayAttribute>() != null;
}
}
}
var args = new List<ICode>();
for (int i = _startIndex; i < expression.Arguments.Count; i++)
{
var argExp = expression.Arguments[i];
if (_isParamArray[i])
{
var newArrayExp = argExp as NewArrayExpression;
if (newArrayExp != null)
{
foreach (var e in newArrayExp.Expressions) args.Add(converter.ConvertToCode(e));
}
else
{
var obj = converter.ConvertToObject(argExp);
foreach (var e in (IEnumerable)obj) args.Add(converter.ConvertToCode(e));
}
}
else
{
args.Add(converter.ConvertToCode(argExp));
}
}
return args;
}
public Pascal(string operation, string filePath, string flags)
{
try
{
bool intermediate = flags.IndexOf('i') > -1;
bool xref = flags.IndexOf('x') > -1;
source = new Source(new StreamReader(filePath));
source.addMessageListener(new SourceMessageListener());
parser = FrontendFactory.createParser("Pascal", "top-down", source);
parser.addMessageListener(new ParserMessageListener());
backend = BackendFactory.createBackend(operation);
backend.addMessageListener(new BackendMessageListener());
parser.parse();
source.close();
iCode = parser.iCode;
symbolTableStack = Parser.symbolTableStack;
if (xref)
{
CrossReferencer crossReferencer = new CrossReferencer();
crossReferencer.Print(symbolTableStack);
}
if (intermediate)
{
ParseTreePrinter treePrinter = new ParseTreePrinter(Console.Out);
treePrinter.Print(iCode);
}
backend.process(iCode, symbolTableStack);
}
catch (Exception e)
{
Console.WriteLine("***** Internal translator error. *****");
Console.WriteLine(e.StackTrace);
}
}
public static ICode V(ICode ast) {
var s = (Stmt)ast;
if (s.StmtType == Stmt.NodeType.Return) {
var sRet = (StmtReturn)s;
if (sRet.Expr == null) {
return new StmtEmpty(ast.Ctx);
}
}
if (s.StmtType == Stmt.NodeType.Block) {
var sBlock = (StmtBlock)s;
var last = sBlock.Statements.LastOrDefault();
if (last != null && last.StmtType == Stmt.NodeType.Return) {
var lastRet = (StmtReturn)last;
if (lastRet.Expr == null) {
return new StmtBlock(ast.Ctx, sBlock.Statements.TakeWhile(x => x != last));
}
}
}
return ast;
}
public void Load(ICode code)
{
if (code == null)
throw new ArgumentNullException("code");
if (code.Configuration != null)
{
foreach (string path in LoadPaths(code))
{
try
{
code.Configuration.Load(Storage.Restore(path) as ISettings);
break;
}
catch (ArgumentNullException)
{
continue;
}
}
}
}