/// <summary> /// Add a statement to the current "cursor" point. /// </summary> /// <param name="s"></param> public void Add(IStatement s) { if (s == null) { throw new ArgumentNullException("Cannot add a statement that is null"); } CurrentScopePointer.Add(s); /// /// Change the statement scope if there something that goes down a level. /// if (s is IBookingStatementBlock) { _scopeState.Push(CurrentScope); } if (s is IStatementCompound) { CurrentScopePointer = s as IStatementCompound; } if (s is IBookingStatementBlock) { PreviousDeclarationScopePointer = CurrentDeclarationScopePointer; CurrentDeclarationScopePointer = s as IBookingStatementBlock; Depth++; } }
public BlockRenamer(IBookingStatementBlock holderOldStatements, IBookingStatementBlock holderNewStatements) { if (holderOldStatements == null) throw new ArgumentNullException("holder"); this._holderBlockOld = holderOldStatements; if (holderNewStatements == null) throw new ArgumentNullException("holder"); this._holderBlockNew = holderNewStatements; }
public BlockRenamer(IBookingStatementBlock holderOldStatements, IBookingStatementBlock holderNewStatements) { if (holderOldStatements == null) { throw new ArgumentNullException("holder"); } this._holderBlockOld = holderOldStatements; if (holderNewStatements == null) { throw new ArgumentNullException("holder"); } this._holderBlockNew = holderNewStatements; }
public static IBookingStatementBlock GetDeepestBookingLevel(GeneratedCode target) { IBookingStatementBlock result = target.CodeBody; IBookingStatementBlock last = result; while (last != null) { result = last; last = result.Statements.LastOrDefault() as IBookingStatementBlock; } return(result); }
public static void DumpCodeToConsole(this IBookingStatementBlock code) { code.DumpCode().DumpToConsole(); }
public IStatement CombineAndMark(IStatement statement, IBookingStatementBlock parent, bool appendIfNoCombine = true) { throw new NotImplementedException(); }
public bool Combine(IEnumerable <IStatement> statements, IBookingStatementBlock parent, bool appendIfNoCombine = true, bool moveIfIdentical = false) { throw new NotImplementedException(); }
/// <summary> /// The current booking scope is set to be the result scope. /// </summary> public void SetCurrentScopeAsResultScope() { CurrentResultScope = CurrentDeclarationScopePointer; }
/// <summary> /// Try to combine a single statement. Return the statement that it was combined with. If appendIfNoCombine /// is true, then add it on, and still return null. /// </summary> /// <param name="statement"></param> /// <param name="appendIfNoCombine">The statement will always be added on the end.</param> /// <returns>The statement it was merged with, if merging took place.</returns> public IStatement CombineAndMark(IStatement statement, IBookingStatementBlock parent, bool appendIfNoCombine = true) { var s = CombineInternal(new IStatement[] { statement }, parent, appendIfNoCombine); return(s == null ? null : s.FirstOrDefault()); }
/// <summary> /// Combine a list of statements with a common parent into the this block. /// </summary> /// <param name="statements">List of statements to combine</param> /// <param name="parent">The common parent of the list of statements</param> /// <param name="appendIfCantCombine">If true always add the statements onto the end of the block</param> /// <returns>True if the statements were merged or appended onto the end of the block</returns> public bool Combine(IEnumerable <IStatement> statements, IBookingStatementBlock parent, bool appendIfCantCombine = true, bool moveIfIdentical = false) { return(CombineInternal(statements, parent, appendIfCantCombine, moveIfIdentical) != null || appendIfCantCombine); }
/// <summary> /// Given a list of statements, attempt to combine them with the ones we already have /// internally. If we can't, then just append them. This is like our "Add" above, but we /// first check to see if any of the statements can be added in. This always /// succeeds (no need for a bool return) because we just add things onto the end. /// </summary> /// <param name="statements">List of statements that we need to combine</param> /// <remarks>Assume that the ordering given in the statements must be obeyed. /// - Never insert a later statement before an earlier one! /// </remarks> private List <IStatement> CombineInternal(IEnumerable <IStatement> statements, IBookingStatementBlock parent, bool appendIfCantCombine = true, bool moveIfIdentical = false) { bool didAllCombine = true; ICodeOptimizationService myopt; var mergedIntoList = new List <IStatement>(); if (parent != null) { myopt = new BlockRenamer(parent, this); } else { myopt = new FailingCodeOptimizer(); } // when we move through this we have to be careful - the try combine has side effects! var currentStatements = Statements.ToArray(); var firstStatement = currentStatements.Length == 0 ? null : currentStatements[0]; var statementsToRemove = new List <IStatement>(); foreach (var s in statements) { var firstGood = currentStatements.SkipWhile(sinner => !sinner.TryCombineStatement(s, myopt)).ToArray(); // If we couldn't find a way to combine this guy, then we will put it as the first statement in our list. if (firstGood.Length == 0) { if (appendIfCantCombine) { s.Parent = null; if (firstStatement != null) { AddBefore(s, firstStatement); } else { Add(s); } } else { didAllCombine = false; } } else { // Add to our list of merged statements. Ignore this guy if it is the same one. // Remove this guy from its old parent. currentStatements = firstGood; if (currentStatements[0] != s) { mergedIntoList.Add(currentStatements[0]); if (moveIfIdentical) { statementsToRemove.Add(s); } } currentStatements = currentStatements.Skip(1).ToArray(); firstStatement = currentStatements.Length == 0 ? null : currentStatements[0]; } } // Remove any statements that were combined foreach (var s in statementsToRemove) { (s.Parent as IBookingStatementBlock).Remove(s); } return(didAllCombine ? mergedIntoList : null); }
public bool Combine(IEnumerable<IStatement> statements, IBookingStatementBlock parent, bool appendIfNoCombine = true, bool moveIfIdentical = false) { throw new NotImplementedException(); }
/// <summary> /// Add a statement to the current "cursor" point. /// </summary> /// <param name="s"></param> public void Add(IStatement s) { if (s == null) { throw new ArgumentNullException("Cannot add a statement that is null"); } CurrentScopePointer.Add(s); /// /// Change the statement scope if there something that goes down a level. /// if (s is IBookingStatementBlock) { _scopeState.Push(CurrentScope); } if (s is IStatementCompound) CurrentScopePointer = s as IStatementCompound; if (s is IBookingStatementBlock) { PreviousDeclarationScopePointer = CurrentDeclarationScopePointer; CurrentDeclarationScopePointer = s as IBookingStatementBlock; Depth++; } }