internal override void Read(NetIncomingMessage Message)
{
base.Read(Message);
Language = (CodeLanguage)Enum.Parse(typeof(CodeLanguage), Message.ReadString());
Location = (CodeLocation)Enum.Parse(typeof(CodeLocation), Message.ReadString());
Source = Message.ReadString();
}
/// <summary>
/// Initializes a new instance of the Whitespace class.
/// </summary>
/// <param name="text">The whitespace text.</param>
/// <param name="location">The location of the whitespace in the code.</param>
/// <param name="parent">The parent code unit.</param>
/// <param name="generated">True if the token is inside of a block of generated code.</param>
internal Whitespace(
string text,
CodeLocation location,
Reference<ICodePart> parent,
bool generated)
: base(text,
CsTokenType.WhiteSpace,
CsTokenClass.Whitespace,
location,
parent,
generated)
{
Param.AssertValidString(text, "text");
Param.AssertNotNull(location, "location");
Param.AssertNotNull(parent, "parent");
Param.Ignore(generated);
for (int i = 0; i < text.Length; ++i)
{
if (text[i] == ' ')
{
++this.spaceCount;
}
else if (text[i] == '\t')
{
++this.tabCount;
}
}
}
static DToken SearchBackward(TextDocument doc, int caretOffset, CodeLocation caret,out DToken lastToken)
{
var ttp = doc.GetText(0, caretOffset);
var sr = new StringReader(ttp);
var lexer = new Lexer(sr);
lexer.NextToken();
var stk=new Stack<DToken>();
while (lexer.LookAhead.Kind!=DTokens.EOF)
{
if (lexer.LookAhead.Kind == DTokens.OpenParenthesis || lexer.LookAhead.Kind==DTokens.OpenSquareBracket || lexer.LookAhead.Kind==DTokens.OpenCurlyBrace)
stk.Push(lexer.LookAhead);
else if (lexer.LookAhead.Kind == DTokens.CloseParenthesis || lexer.LookAhead.Kind == DTokens.CloseSquareBracket || lexer.LookAhead.Kind == DTokens.CloseCurlyBrace)
{
if (stk.Peek().Kind == getOppositeBracketToken( lexer.LookAhead.Kind))
stk.Pop();
}
lexer.NextToken();
}
lastToken = lexer.CurrentToken;
sr.Close();
lexer.Dispose();
if (stk.Count < 1)
return null;
return stk.Pop();
}
public ParserError(bool IsSemanticError, string Message, int KeyToken, CodeLocation ErrorLocation)
{
IsSemantic = IsSemanticError;
this.Message = Message;
this.Token = KeyToken;
this.Location = ErrorLocation;
}
public void Constructor(string filename, int line, int column)
{
var location = new CodeLocation(filename, line, column);
Assert.AreEqual(filename, location.Path);
Assert.AreEqual(line, location.Line);
Assert.AreEqual(column, location.Column);
}
public static BracketSearchResult SearchBrackets(TextDocument doc, int caretOffset, TextLocation caret)
{
var caretLocation = new CodeLocation(caret.Column, caret.Line);
try
{
if (caretOffset < 1 || caretOffset>=doc.TextLength-2)
return null;
// Search backward
DToken lastToken=null;
var tk_start = SearchBackward(doc, caretOffset, caretLocation,out lastToken);
if (tk_start == null)
return null;
// Search forward
var tk_end = SearchForward(doc,
doc.GetOffset(lastToken.EndLocation.Line,lastToken.EndLocation.Column),
lastToken.EndLocation,
getOppositeBracketToken(tk_start.Kind));
if (tk_end == null)
return null;
int start = doc.GetOffset(tk_start.Location.Line, tk_start.Location.Column),
end = doc.GetOffset(tk_end.Location.Line, tk_end.Location.Column);
return new BracketSearchResult(start, 1, end, 1);
}
catch { return null; }
}
public EVException([CallerFilePath] string callerFilePath = "",
[CallerLineNumber] int callerLineNumber = 0,
[CallerMemberName] string callerMemberName = "")
{
CodeLocation codeLocation = new CodeLocation(callerFilePath, callerLineNumber, callerMemberName);
this.AddNamedProperty("EVExceptionConstructionLocation", codeLocation.ToString());
}
public IEnumerable<DMethod> FindFitting(ResolverContextStack ctxt, CodeLocation currentLocation, ISemantic firstArgument, string nameFilter = null)
{
if (IsProcessing)
return null;
var preMatchList = new List<DMethod>();
bool dontUseNameFilter = nameFilter == null;
lock(CachedMethods)
foreach (var kv in CachedMethods)
{
// First test if arg is matching the parameter
if ((dontUseNameFilter || kv.Key.Name == nameFilter) &&
ResultComparer.IsImplicitlyConvertible(firstArgument, kv.Value, ctxt))
preMatchList.Add(kv.Key);
}
// Then filter out methods which cannot be accessed in the current context
// (like when the method is defined in a module that has not been imported)
var mv = new MatchFilterVisitor<DMethod>(ctxt, preMatchList);
mv.IterateThroughScopeLayers(currentLocation);
return mv.filteredList;
}
public void ForStatement()
{
var code = @"module A; // 1
void main(){
for(
int
i= // 5
0;
i<100;
i++)
{ // 10
}";
var mod = DParser.ParseString(code);
var main = mod["main"].First() as DMethod;
var l = new CodeLocation(1,4);
var off = DocumentHelper.LocationToOffset(code,l);
ParserTrackerVariables ptr;
CodeLocation caretLoc;
//var parsedBlock = AbstractCompletionProvider.FindCurrentCaretContext(code,main, off,l,out ptr, out caretLoc);
/*
* a) Test if completion popup would open in each code situation
* b) Test in which case iteration variables can be found.
*/
//TODO
}
public ISyntaxRegion GetNextMetaBlockOrStatStmt(CodeLocation until)
{
if (nextStatStmt == null && StaticStatementEnum != null) {
if (StaticStatementEnum.MoveNext ())
nextStatStmt = StaticStatementEnum.Current;
else
StaticStatementEnum = null;
}
if (nextMetaDecl == null && MetaBlockEnum != null) {
if (MetaBlockEnum.MoveNext ())
nextMetaDecl = MetaBlockEnum.Current;
else
MetaBlockEnum = null;
}
ISyntaxRegion sr;
if (nextStatStmt != null) {
if (nextMetaDecl == null)
sr = nextStatStmt;
else
sr = nextStatStmt.First (nextMetaDecl);
} else if (nextMetaDecl != null)
sr = nextMetaDecl;
else
return null;
return sr.Location < until ? sr : null;
}
/// <summary>
/// Initializes a new instance of the Argument class.
/// </summary>
/// <param name="name">The optional name of the argument.</param>
/// <param name="modifiers">Modifers applied to this argument.</param>
/// <param name="argumentExpression">The expression that forms the body of the argument.</param>
/// <param name="location">The location of the argument in the code.</param>
/// <param name="parent">The parent code part.</param>
/// <param name="tokens">The tokens that form the argument.</param>
/// <param name="generated">Indicates whether the argument is located within a block of generated code.</param>
internal Argument(
CsToken name,
ParameterModifiers modifiers,
Expression argumentExpression,
CodeLocation location,
Reference<ICodePart> parent,
CsTokenList tokens,
bool generated)
{
Param.Ignore(name);
Param.Ignore(modifiers);
Param.AssertNotNull(argumentExpression, "argumentExpression");
Param.AssertNotNull(location, "location");
Param.AssertNotNull(parent, "parent");
Param.Ignore(tokens);
Param.Ignore(generated);
this.name = name;
this.modifiers = modifiers;
this.argumentExpression = argumentExpression;
this.location = location;
this.parent = parent;
this.tokens = tokens;
this.generated = generated;
}
public void Set(IBlockNode b, CodeLocation caret)
{
scopedBlock = b;
Caret = caret;
ConditionalCompilation.EnumConditions(DeclarationCondititons, b, ctxt, caret);
}
/// <summary>
/// Initializes a new instance of the ParamsToken class.
/// </summary>
/// <param name="document">The parent document.</param>
/// <param name="text">The text of the item.</param>
/// <param name="location">The location of the item.</param>
/// <param name="generated">Indicates whether the item is generated.</param>
internal ParamsToken(CsDocument document, string text, CodeLocation location, bool generated)
: base(document, text, TokenType.Params, location, generated)
{
Param.AssertNotNull(document, "document");
Param.AssertValidString(text, "text");
Param.AssertNotNull(location, "location");
Param.Ignore(generated);
}
/// <summary>
/// Initializes a new instance of the BitwiseComplementOperator class.
/// </summary>
/// <param name="document">The parent document.</param>
/// <param name="text">The text of the item.</param>
/// <param name="location">The location of the item.</param>
/// <param name="generated">Indicates whether the item is generated.</param>
internal BitwiseComplementOperator(CsDocument document, string text, CodeLocation location, bool generated)
: base(document, text, OperatorCategory.Unary, OperatorType.BitwiseComplement, location, generated)
{
Param.AssertNotNull(document, "document");
Param.AssertValidString(text, "text");
Param.AssertNotNull(location, "location");
Param.Ignore(generated);
}
/// <summary>
/// Initializes a new instance of the LogicalAndOperator class.
/// </summary>
/// <param name="document">The parent document.</param>
/// <param name="text">The text of the item.</param>
/// <param name="location">The location of the item.</param>
/// <param name="generated">Indicates whether the item is generated.</param>
internal LogicalAndOperator(CsDocument document, string text, CodeLocation location, bool generated)
: base(document, text, OperatorCategory.Logical, OperatorType.LogicalAnd, location, generated)
{
Param.AssertNotNull(document, "document");
Param.AssertValidString(text, "text");
Param.AssertNotNull(location, "location");
Param.Ignore(generated);
}
/// <summary>
/// Initializes a new instance of the XorEqualsOperator class.
/// </summary>
/// <param name="document">The parent document.</param>
/// <param name="text">The text of the item.</param>
/// <param name="location">The location of the item.</param>
/// <param name="generated">Indicates whether the item is generated.</param>
internal XorEqualsOperator(CsDocument document, string text, CodeLocation location, bool generated)
: base(document, text, OperatorCategory.Assignment, OperatorType.XorEquals, location, generated)
{
Param.AssertNotNull(document, "document");
Param.AssertValidString(text, "text");
Param.AssertNotNull(location, "location");
Param.Ignore(generated);
}
/// <summary>
/// Initializes a new instance of the ConditionalQuestionMarkOperator class.
/// </summary>
/// <param name="document">The parent document.</param>
/// <param name="text">The text of the item.</param>
/// <param name="location">The location of the item.</param>
/// <param name="generated">Indicates whether the item is generated.</param>
internal ConditionalQuestionMarkOperator(CsDocument document, string text, CodeLocation location, bool generated)
: base(document, text, OperatorCategory.Conditional, OperatorType.ConditionalQuestionMark, location, generated)
{
Param.AssertNotNull(document, "document");
Param.AssertValidString(text, "text");
Param.AssertNotNull(location, "location");
Param.Ignore(generated);
}
public ConditionVisitor(ConditionSet cs,ResolutionContext ctxt, CodeLocation caret)
{
this.caret = caret;
this.cs = cs;
this.ctxt = ctxt;
this.l = new MutableConditionFlagSet();
cs.LocalFlags = l;
}
/// <summary>
/// Initializes a new instance of the SimpleToken class.
/// </summary>
/// <param name="document">The parent document.</param>
/// <param name="text">The token string.</param>
/// <param name="tokenType">The token type.</param>
/// <param name="location">The location of the token within the code document.</param>
/// <param name="generated">True if the token is inside of a block of generated code.</param>
internal SimpleToken(CsDocument document, string text, int tokenType, CodeLocation location, bool generated)
: base(new CodeUnitProxy(document), tokenType, location)
{
Param.Ignore(document, text, tokenType, location, generated);
this.Text = text;
this.Generated = generated;
}
/// <summary>
/// Initializes a new instance of the RegionDirective class.
/// </summary>
/// <param name="document">The parent document.</param>
/// <param name="text">The line text.</param>
/// <param name="location">The location of the preprocessor in the code.</param>
/// <param name="generated">Indicates whether the preprocessor lies within a block of generated code.</param>
internal RegionDirective(CsDocument document, string text, CodeLocation location, bool generated)
: base(document, text, PreprocessorType.Region, location, generated)
{
Param.AssertNotNull(document, "document");
Param.AssertValidString(text, "text");
Param.AssertNotNull(location, "location");
Param.Ignore(generated);
}
public Comment(Type commentType, string comment, bool commentStartsLine, CodeLocation startPosition, CodeLocation endPosition)
{
this.CommentType = commentType;
this.CommentText = comment;
this.CommentStartsLine = commentStartsLine;
this.StartPosition = startPosition;
this.EndPosition = endPosition;
}
/// <summary>
/// Initializes a new instance of the MultiplicationOperator class.
/// </summary>
/// <param name="document">The parent document.</param>
/// <param name="text">The text of the item.</param>
/// <param name="location">The location of the item.</param>
/// <param name="generated">Indicates whether the item is generated.</param>
internal MultiplicationOperator(CsDocument document, string text, CodeLocation location, bool generated)
: base(document, text, OperatorCategory.Arithmetic, OperatorType.Multiplication, location, generated)
{
Param.AssertNotNull(document, "document");
Param.AssertValidString(text, "text");
Param.AssertNotNull(location, "location");
Param.Ignore(generated);
}
/// <summary>
/// Inserts import statement into correct place
/// </summary>
static void ApplySolution(string import, Document doc)
{
var eData = DResolverWrapper.GetEditorData(doc);
var loc = new CodeLocation(0, DParser.FindLastImportStatementEndLocation(eData.SyntaxTree, eData.ModuleCode).Line + 1);
doc.Editor.Insert(doc.Editor.GetLine(loc.Line).Offset, import.Trim() + doc.Editor.EolMarker);
//IOInterface.InsertIntoCode(loc, "import " + mod.ModuleName + ";\n");
}
/// <summary>
/// Initializes a new instance of the ElementHeaderLine class.
/// </summary>
/// <param name="document">The parent document.</param>
/// <param name="text">The text of the item.</param>
/// <param name="location">The location of the item.</param>
/// <param name="generated">Indicates whether the item is generated.</param>
internal ElementHeaderLine(CsDocument document, string text, CodeLocation location, bool generated)
: base(document, text, CommentType.ElementHeaderLine, location, generated)
{
Param.AssertNotNull(document, "document");
Param.AssertValidString(text, "text");
Param.AssertNotNull(location, "location");
Param.Ignore(generated);
}
public static List<AbstractType> SearchAndResolve(ResolutionContext ctxt, CodeLocation caret, int nameHash, ISyntaxRegion idObject=null)
{
var scan = new NameScan(ctxt, nameHash, idObject);
scan.IterateThroughScopeLayers(caret);
return scan.matches_types;
}
/// <summary>
/// Initializes a new instance of the PointerOperator class.
/// </summary>
/// <param name="document">The parent document.</param>
/// <param name="text">The text of the item.</param>
/// <param name="location">The location of the item.</param>
/// <param name="generated">Indicates whether the item is generated.</param>
internal PointerOperator(CsDocument document, string text, CodeLocation location, bool generated)
: base(document, text, OperatorCategory.Reference, OperatorType.Pointer, location, generated)
{
Param.AssertNotNull(document, "document");
Param.AssertValidString(text, "text");
Param.AssertNotNull(location, "location");
Param.Ignore(generated);
}
public static EditorData CreateEditorData(Document EditorDocument, DModule Ast, CodeCompletionContext ctx, char triggerChar = '\0')
{
bool removeChar = char.IsLetter(triggerChar) || triggerChar == '_';
var deltaOffset = 0;//removeChar ? 1 : 0;
var caretOffset = ctx.TriggerOffset - (removeChar ? 1 : 0);
var caretLocation = new CodeLocation(ctx.TriggerLineOffset - deltaOffset, ctx.TriggerLine);
var codeCache = CreateCacheList(EditorDocument);
var ed = new EditorData
{
CaretLocation = caretLocation,
CaretOffset = caretOffset,
ModuleCode = removeChar ? EditorDocument.Editor.Text.Remove(ctx.TriggerOffset - 1, 1) : EditorDocument.Editor.Text,
SyntaxTree = Ast,
ParseCache = codeCache
};
if (EditorDocument.HasProject)
{
var cfg = EditorDocument.Project.GetConfiguration(IdeApp.Workspace.ActiveConfiguration);
if (cfg is DProjectConfiguration)
{
var dcfg = cfg as DProjectConfiguration;
ed.GlobalDebugIds = dcfg.CustomDebugIdentifiers;
ed.IsDebug = dcfg.DebugMode;
ed.DebugLevel = dcfg.DebugLevel;
ed.GlobalVersionIds = dcfg.GlobalVersionIdentifiers;
double d;
ulong v;
if (Double.TryParse(EditorDocument.Project.Version, out d))
ed.VersionNumber = (ulong)d;
else if (UInt64.TryParse(EditorDocument.Project.Version, out v))
ed.VersionNumber = v;
}
else if (cfg is DubProjectConfiguration)
{
var versions = new List<string>(VersionIdEvaluation.GetOSAndCPUVersions());
var dcfg = cfg as DubProjectConfiguration;
ed.IsDebug = dcfg.DebugMode;
HandleDubSettingsConditionExtraction(versions, (dcfg.ParentItem as DubProject).CommonBuildSettings);
HandleDubSettingsConditionExtraction(versions, dcfg.BuildSettings);
ed.GlobalVersionIds = versions.ToArray();
}
}
if (ed.GlobalVersionIds == null)
{
ed.GlobalVersionIds = VersionIdEvaluation.GetOSAndCPUVersions();
}
return ed;
}
/// <summary>
/// Initializes a new instance of the Token class.
/// </summary>
/// <param name="proxy">Proxy object for the token.</param>
/// <param name="tokenType">The token type.</param>
/// <param name="location">The location of the code unit.</param>
internal Token(CodeUnitProxy proxy, int tokenType, CodeLocation location)
: base(proxy, tokenType, location)
{
Param.Ignore(tokenType);
Param.AssertNotNull(proxy, "proxy");
Param.Ignore(location);
CsLanguageService.Debug.Assert(System.Enum.IsDefined(typeof(TokenType), this.TokenType), "The type is invalid.");
}
public static void GenerateActivityPluginCode(CodeLocation codeLocation, PluginManager pluginManager,
ICodeBlock codeBlock, IElement element)
{
foreach (ComponentPluginPair cpp in GetPluginsIn(pluginManager, codeLocation))
{
GenerateWithException(cpp.Generator.GenerateActivity, codeBlock, element, cpp.Plugin, pluginManager);
}
}
/// <summary>
/// Initializes a new instance of the GenericType class.
/// </summary>
/// <param name="childTokens">
/// The list of child tokens that form the generic token.
/// </param>
/// <param name="location">
/// The location of the generic in the code.
/// </param>
/// <param name="parent">
/// The parent of the token.
/// </param>
/// <param name="generated">
/// True if the token is inside of a block of generated code.
/// </param>
internal GenericType(MasterList<CsToken> childTokens, CodeLocation location, Reference<ICodePart> parent, bool generated)
: base(childTokens, location, parent, CsTokenClass.GenericType, generated)
{
Param.AssertNotNull(childTokens, "childTokens");
Param.AssertGreaterThanOrEqualTo(childTokens.Count, 3, "childTokens");
Param.AssertNotNull(location, "location");
Param.AssertNotNull(parent, "parent");
Param.Ignore(generated);
}
/// <returns>Either CurrentScope, a BlockStatement object that is associated with the parent method or a complete new DModule object</returns>
public static object FindCurrentCaretContext(string code,
IBlockNode CurrentScope,
int caretOffset, CodeLocation caretLocation,
out ParserTrackerVariables TrackerVariables)
{
bool ParseDecl = false;
int blockStart = 0;
var blockStartLocation = CurrentScope.BlockStartLocation;
if (CurrentScope is DMethod)
{
var block = (CurrentScope as DMethod).GetSubBlockAt(caretLocation);
if (block != null)
{
blockStart = DocumentHelper.LocationToOffset(code, blockStartLocation = block.Location);
}
else
{
return(FindCurrentCaretContext(code, CurrentScope.Parent as IBlockNode, caretOffset, caretLocation, out TrackerVariables));
}
}
else if (CurrentScope != null)
{
if (CurrentScope.BlockStartLocation.IsEmpty || caretLocation < CurrentScope.BlockStartLocation && caretLocation > CurrentScope.Location)
{
ParseDecl = true;
blockStart = DocumentHelper.LocationToOffset(code, blockStartLocation = CurrentScope.Location);
}
else
{
blockStart = DocumentHelper.LocationToOffset(code, CurrentScope.BlockStartLocation);
}
}
if (blockStart >= 0 && caretOffset - blockStart > 0)
{
var codeToParse = code.Substring(blockStart, caretOffset - blockStart);
var sr = new StringReader(codeToParse);
var psr = DParser.Create(sr);
/* Deadly important! For correct resolution behaviour,
* it is required to set the parser virtually to the blockStart position,
* so that everything using the returned object is always related to
* the original code file, not our code extraction!
*/
psr.Lexer.SetInitialLocation(blockStartLocation);
object ret = null;
if (CurrentScope == null || CurrentScope is IAbstractSyntaxTree)
{
ret = psr.Parse();
}
else if (CurrentScope is DMethod)
{
psr.Step();
ret = psr.BlockStatement(CurrentScope);
}
else if (CurrentScope is DModule)
{
ret = psr.Root();
}
else
{
psr.Step();
if (ParseDecl)
{
var ret2 = psr.Declaration(CurrentScope);
if (ret2 != null && ret2.Length > 0)
{
ret = ret2[0];
}
}
else
{
DBlockNode bn = null;
if (CurrentScope is DClassLike)
{
var t = new DClassLike((CurrentScope as DClassLike).ClassType);
t.AssignFrom(CurrentScope);
bn = t;
}
else if (CurrentScope is DEnum)
{
var t = new DEnum();
t.AssignFrom(CurrentScope);
bn = t;
}
bn.Clear();
psr.ClassBody(bn);
ret = bn;
}
}
TrackerVariables = psr.TrackerVariables;
sr.Close();
return(ret);
}
TrackerVariables = null;
return(null);
}
public IDisposable Push(INode newScope, CodeLocation caret)
{
return(Push_(newScope, caret) ? new PopDisposable(this) : null);
}
/// <summary>
/// Initializes a new instance of the OperatorSymbol class.
/// </summary>
/// <param name="text">
/// The text of the operator symbol.
/// </param>
/// <param name="category">
/// The category of the operator.
/// </param>
/// <param name="symbolType">
/// The specific symbol type.
/// </param>
/// <param name="location">
/// The location of the operator symbol in the code document.
/// </param>
/// <param name="parent">
/// Reference to the parent code part.
/// </param>
/// <param name="generated">
/// Indicates whether the operator lies within a block of generated code.
/// </param>
internal OperatorSymbol(string text, OperatorCategory category, OperatorType symbolType, CodeLocation location, Reference <ICodePart> parent, bool generated)
: base(text, CsTokenType.OperatorSymbol, CsTokenClass.OperatorSymbol, location, parent, generated)
{
Param.AssertValidString(text, "text");
Param.Ignore(category);
Param.Ignore(symbolType);
Param.AssertNotNull(location, "location");
Param.AssertNotNull(parent, "parent");
Param.Ignore(generated);
this.category = category;
this.symbolType = symbolType;
}
private void UpdatePath(object sender, Mono.TextEditor.DocumentLocationEventArgs e)
{
var ast = Document.ParsedDocument as ParsedDModule;
if (ast == null)
{
return;
}
var SyntaxTree = ast.DDom;
if (SyntaxTree == null)
{
return;
}
// Resolve the hovered piece of code
var loc = new CodeLocation(Document.Editor.Caret.Location.Column, Document.Editor.Caret.Location.Line);
IStatement stmt = null;
var currentblock = DResolver.SearchBlockAt(SyntaxTree, loc, out stmt) as IBlockNode;
//could be an enum value, which is not IBlockNode
if (currentblock is DEnum)
{
foreach (INode nd in (currentblock as DEnum).Children)
{
if ((nd is DEnumValue) &&
((nd.Location <= loc) && (nd.EndLocation >= loc)))
{
currentblock = nd as IBlockNode;
break;
}
}
}
List <PathEntry> result = new List <PathEntry>();
INode node = currentblock;
while ((node != null) && ((node is IBlockNode) || (node is DEnumValue)))
{
PathEntry entry;
var icon = DCompletionData.GetNodeIcon(node as DNode);
entry = new PathEntry(icon.IsNull?null: ImageService.GetPixbuf(icon.Name, IconSize.Menu), node.Name + DParameterDataProvider.GetNodeParamString(node));
entry.Position = EntryPosition.Left;
entry.Tag = node;
//do not include the module in the path bar
if ((node.Parent != null) && !((node is DNode) && (node as DNode).IsAnonymous))
{
result.Insert(0, entry);
}
node = node.Parent;
}
if (!((currentblock is DMethod) || (currentblock is DEnumValue)))
{
PathEntry noSelection = new PathEntry(GettextCatalog.GetString("No Selection"))
{
Tag = new NoSelectionCustomNode(currentblock)
};
result.Add(noSelection);
}
var prev = CurrentPath;
CurrentPath = result.ToArray();
OnPathChanged(new DocumentPathChangedEventArgs(prev));
}
public override void InsertIntoCode(CodeLocation location, string codeToInsert)
{
doc.Editor.Insert(doc.Editor.GetLine(location.Line).Offset, codeToInsert.Trim() + doc.Editor.EolMarker);
}
public void GetTip(string filename, int startLine, int startIndex, int endLine, int endIndex)
{
var ast = GetModule(filename);
if (ast == null)
{
throw new COMException("module not found", 1);
}
_tipStart = new CodeLocation(startIndex + 1, startLine);
_tipEnd = new CodeLocation(startIndex + 2, startLine);
_tipText.Clear();
_setupEditorData();
_editorData.CaretLocation = _tipStart;
_editorData.SyntaxTree = ast as DModule;
_editorData.ModuleCode = _sources[filename];
// codeOffset+1 because otherwise it does not work on the first character
_editorData.CaretOffset = getCodeOffset(_editorData.ModuleCode, _tipStart) + 1;
ISyntaxRegion sr;
DResolver.NodeResolutionAttempt attempt;
var types = DResolver.ResolveTypeLoosely(_editorData, out attempt, out sr);
_tipText.Clear();
if (types != null)
{
if (sr != null)
{
_tipStart = sr.Location;
_tipEnd = sr.EndLocation;
}
DNode dn = null;
foreach (var t in AmbiguousType.TryDissolve(types))
{
_tipText.Append(NodeToolTipContentGen.Instance.GenTooltipSignature(t)).Append("\a");
if (t is DSymbol)
{
dn = (t as DSymbol).Definition;
}
}
while (_tipText.Length > 0 && _tipText[_tipText.Length - 1] == '\a')
{
_tipText.Length--;
}
if (dn != null)
{
VDServerCompletionDataGenerator.GenerateNodeTooltipBody(dn, _tipText);
}
while (_tipText.Length > 0 && _tipText[_tipText.Length - 1] == '\a')
{
_tipText.Length--;
}
}
}
protected override CodeElement CreateCodeElement(string name, string fullName, CodeLocation location, CodeElement parent)
{
CodeField field = new CodeField(name, fullName, location, parent);
return(field);
}
private object ParseProperty(StatSubtypeDefinition subtype, string propertyName, object value, CodeLocation location,
string declarationName)
{
if (!subtype.Fields.TryGetValue(propertyName, out StatField field))
{
Context.LogError(DiagnosticCode.StatPropertyUnsupported, $"Property '{propertyName}' is not supported on {subtype.Name} '{declarationName}'",
location?.FileName, location?.StartLine ?? 0, declarationName);
return(null);
}
bool succeeded = false;
string errorText = null;
object parsed;
if (field.Type != "Passthrough")
{
var parser = field.GetParser(ParserFactory, Context.Definitions);
parsed = parser.Parse((string)value, ref succeeded, ref errorText);
}
else
{
parsed = value;
succeeded = true;
}
if (errorText != null)
{
Context.LogError(DiagnosticCode.StatPropertyValueInvalid, $"{subtype.Name} '{declarationName}' has invalid {propertyName}: '{value}' ({errorText})",
location?.FileName, location?.StartLine ?? 0, declarationName);
}
if (succeeded)
{
return(parsed);
}
else
{
return(null);
}
}
void PushNewScope(IBlockNode scope, CodeLocation caret)
{
new ContextFrame(this, scope, caret);
}
/// <summary>
/// Calculates the indentation from the inner-most to the outer-most block/section.
/// </summary>
public static int CalculateBackward(IBlockNode n, CodeLocation caret)
{
int i = 0;
var line = caret.Line;
while (n != null)
{
var db = n as DBlockNode;
if (db != null)
{
if (!n.BlockStartLocation.IsEmpty)
{
i += GetBlockindent(n, n.BlockStartLocation, GetLastBlockAstChild(db), caret);
}
var metaStack = db.GetMetaBlockStack(caret, true, true);
for (int k = metaStack.Length; k != 0; k--)
{
var mb = metaStack[k];
var mbb = mb as IMetaDeclarationBlock;
if (mbb != null)
{
i += GetBlockindent(metaStack[i], mbb.BlockStartLocation, k == 0 ? null : metaStack[k - 1], caret);
}
else if (line > mb.Location.Line)
{
/*
* pragma(lib,
* "kernel32.lib");
* private:
* int a;
*/
i++;
}
}
}
else if (n is DMethod)
{
var dm = (DMethod)n;
/*
* Xvoid foo() Y{ }Z // Do not indent because 1) the method is one line large and 2) the caret is at the first line
*
* Xint foo()
* @trusted
* @safe nothrow // 5)
* in Y{ // 3) do not indent because of the brace
* a + b;
* }Z
* body
* { | } // 4) do not indent if it's a one-lined block statement
* out(r) // 5) do not indent after the first definition part, if we're not inside a block
* {
* assert(r>3456);
* if(r > 10000)
* a + b; } | // 6) Though we're outside the block, it's needed to indent dependent on the block's contents
*
* void foo()
* { } | // 7) same as 4)
*/
if (line > dm.Location.Line // 1), 2)
/* No check for dm.EndLocation.Line > dm.Location.Line required due to the first check
* -- if the method was single-line but the line > the location line, it wasn't handled right now ;) */)
{
var s = dm.GetSubBlockAt(caret) as IStatement;
if (s != null)
{
if (s.EndLocation.Line > s.Location.Line && // 4)
line > s.Location.Line) // 3)
{
i += Calculate(ref s, caret);
}
}
else
{
// Get the block that is the most nearest to the caret
foreach (var b in new[] { dm.In, dm.Body, dm.Out })
{
if (b != null && caret > b.EndLocation && line == b.EndLocation.Line && // 6)
(s == null || b.Location > s.EndLocation))
{
s = b;
}
}
if (s != null && s.EndLocation.Line > s.Location.Line) // 7)
{
i += Calculate(ref s, caret);
}
}
}
}
// Handle non-IBlockNode nodes because they were not regarded during SeachBlockAt()
// TODO: Are anonymous classes handled by SearchBlockAt()?
if (n.Count != 0)
{
foreach (var subNode in n.Children)
{
if (subNode is DVariable)
{
var dv = (DVariable)subNode;
/*
* // 1) The variable definition must take at least two lines
* Xint a=
* 1234 // 2) indent after the first line
* ;Z // 3) though it ends here, indent anyway.
*
* Xint a
* = 1234;Z // 4)
*/
if (dv.EndLocation.Line > dv.Location.Line) // 1)
{
if (line > dv.Location.Line && // 2)
line <= dv.EndLocation.Line) // 3)
{
i++;
}
var x = dv.Initializer;
if (x != null && line > x.Location.Line && caret < x.EndLocation) // 4)
{
i += Calculate(ref x, caret);
}
}
}
}
}
if (n.Parent != null)
{
i++;
n = n.Parent as IBlockNode;
}
}
return(i);
}
public static int CalculateForward(IBlockNode module, CodeLocation caret)
{
return(CalculateBackward(DResolver.SearchBlockAt(module, caret), caret));
}
public static ResolutionContext Create(ParseCacheView pcl, ConditionalCompilationFlags globalConditions, IBlockNode scopedBlock, CodeLocation caret)
{
return(new ResolutionContext(pcl, globalConditions, scopedBlock, caret));
}
/// <summary>
/// Generate barcode and save on server
/// </summary>
/// <param name="name">The image name.</param>
/// <param name="text">Barcode's text.</param>
/// <param name="type">The barcode type.</param>
/// <param name="format">The image format.</param>
/// <param name="codeLocation">Property of the barcode.</param>
/// <param name="grUnit">Measurement of barcode properties.</param>
/// <param name="autoSize">Sets if barcode size will be updated automatically.</param>
/// <param name="barHeight">Height of the bar.</param>
/// <param name="imageHeight">Height of the image.</param>
/// <param name="imageWidth">Width of the image.</param>
/// <param name="imageQuality">Determines quality of the barcode image.</param>
/// <param name="rotAngle">Angle of barcode orientation.</param>
/// <param name="topMargin">Top margin.</param>
/// <param name="bottomMargin">Bottom margin.</param>
/// <param name="leftMargin">Left margin.</param>
/// <param name="rightMargin">Right margin.</param>
/// <param name="enableChecksum">Sets if checksum will be generated.</param>
/// <param name="storage">Image's storage.</param>
/// <param name="folder">Image's folder.</param>
/// <param name="resolutionX">Horizontal resolution in DPI. Default is 96</param>
/// <param name="resolutionY">Vertical resolution in DPI. Default is 96</param>
/// <param name="dimensionX">Smallest width of barcode unit (bar or space). Default is 0.7</param>
/// <param name="dimensionY">Smallest height of barcode unit (for 2D barcodes). Default is 2</param>
public void GenerateBarCodeAndSaveOnServer(string name, string text, BarCodeType type,
float barHeight, float imageHeight, float imageWidth, float rotAngle,
float topMargin, float bottomMargin, float leftMargin, float rightMargin, string storage,
string folder,
BarCodeImageFormat format = BarCodeImageFormat.PNG, CodeLocation codeLocation = CodeLocation.Below, GrUnit grUnit = GrUnit.MM,
bool autoSize = true, ImageQuality imageQuality = ImageQuality.Default, EnableChecksum enableChecksum = EnableChecksum.No,
float resolutionX = 96, float resolutionY = 96, double dimensionX = 0.7, float dimensionY = 2)
{
// PUT barcode/{name}/generate?appSid={appSid}&text={text}&type={type}&format={format}&resolutionX={resolutionX}&resolutionY={resolutionY}&dimensionX={dimensionX}&dimensionY={dimensionY}&codeLocation={codeLocation}&grUnit={grUnit}&autoSize={autoSize}&barHeight={barHeight}&imageHeight={imageHeight}&imageWidth={imageWidth}&imageQuality={imageQuality}&rotAngle={rotAngle}&topMargin={topMargin}&bottomMargin={bottomMargin}&leftMargin={leftMargin}&rightMargin={rightMargin}&enableChecksum={enableChecksum}&storage={storage}&folder={folder}
string apiUrl = string.Format(@"barcode/{0}/generate?text={1}&type={2}&format={3}&resolutionX={4}&resolutionY={5}&dimensionX={6}&dimensionY={7}&codeLocation={8}&grUnit={9}&autoSize={10}&barHeight={11}&imageHeight={12}&imageWidth={13}&imageQuality={14}&rotAngle={15}&topMargin={16}&bottomMargin={17}&leftMargin={18}&rightMargin={19}&enableChecksum={20}&storage={21}&folder={22}",
name, text, type, format, resolutionX, resolutionY, dimensionX, dimensionY, codeLocation, grUnit, autoSize, barHeight,
imageHeight, imageWidth, imageQuality, rotAngle, topMargin, bottomMargin, leftMargin, rightMargin, enableChecksum,
storage, folder);
ServiceController.Put(apiUrl, AppSid, AppKey);
}
public void GetSourceLocationForMethod_ReturnsUnknownIfMethodIsAbstract()
{
CodeLocation codeLocation = GetSourceLocationForMethod("AbstractMethod");
Assert.AreEqual(CodeLocation.Unknown, codeLocation);
}
public ResolutionContext(ParseCacheView parseCache, ConditionalCompilationFlags gFlags, IBlockNode bn, CodeLocation caret)
{
this.CompilationEnvironment = gFlags;
this.ParseCache = parseCache;
//Cache = new ResolutionCache<AbstractType[]>(this);
//ValueCache = new ResolutionCache<ISymbolValue>(this);
MixinCache = new ResolutionCache <Tuple <string, VariableValue> >(this);
new ContextFrame(this, bn, caret);
}
public void GetTip(string filename, int startLine, int startIndex, int endLine, int endIndex)
{
filename = normalizePath(filename);
var ast = GetModule(filename);
if (ast == null)
{
throw new COMException("module not found", 1);
}
_tipStart = new CodeLocation(startIndex + 1, startLine);
_tipEnd = new CodeLocation(startIndex + 2, startLine);
_request = Request.Tip;
_result = "__pending__";
Action dg = () =>
{
_setupEditorData();
_editorData.CaretLocation = _tipStart;
_editorData.SyntaxTree = ast as DModule;
_editorData.ModuleCode = _sources[filename];
// codeOffset+1 because otherwise it does not work on the first character
_editorData.CaretOffset = getCodeOffset(_editorData.ModuleCode, _tipStart) + 1;
ISyntaxRegion sr = DResolver.GetScopedCodeObject(_editorData);
LooseResolution.NodeResolutionAttempt attempt;
AbstractType types = sr != null?LooseResolution.ResolveTypeLoosely(_editorData, sr, out attempt, true) : null;
if (_editorData.CancelToken.IsCancellationRequested)
{
return;
}
StringBuilder tipText = new StringBuilder();
if (types != null)
{
if (sr != null)
{
_tipStart = sr.Location;
_tipEnd = sr.EndLocation;
}
DNode dn = null;
foreach (var t in AmbiguousType.TryDissolve(types))
{
tipText.Append(NodeToolTipContentGen.Instance.GenTooltipSignature(t)).Append("\a");
if (t is DSymbol)
{
dn = (t as DSymbol).Definition;
}
}
while (tipText.Length > 0 && tipText[tipText.Length - 1] == '\a')
{
tipText.Length--;
}
if (dn != null)
{
VDServerCompletionDataGenerator.GenerateNodeTooltipBody(dn, tipText);
}
while (tipText.Length > 0 && tipText[tipText.Length - 1] == '\a')
{
tipText.Length--;
}
}
if (_request == Request.Tip)
{
_result = tipText.ToString();
}
};
runAsync(dg);
}
public int ToOffset(CodeLocation loc)
{
return(document.GetOffset(loc.Line, loc.Column));
}
void UpdateOutlineSelection(object sender, Mono.TextEditor.DocumentLocationEventArgs e)
{
if (clickedOnOutlineItem || SyntaxTree == null || TreeStore == null)
{
return;
}
IStatement stmt;
var caretLocation = Document.Editor.Caret.Location;
var caretLocationD = new CodeLocation(caretLocation.Column, caretLocation.Line);
var currentblock = DResolver.SearchBlockAt(SyntaxTree, caretLocationD, out stmt);
INode selectedASTNode = null;
if (currentblock == null)
{
return;
}
foreach (var n in currentblock)
{
if (caretLocationD >= n.Location && caretLocationD <= n.EndLocation)
{
selectedASTNode = n;
break;
}
}
// Select parameter node if needed
if (selectedASTNode == null && currentblock is DMethod)
{
foreach (var n in (currentblock as DMethod).Parameters)
{
if (caretLocationD >= n.Location && caretLocationD <= n.EndLocation)
{
selectedASTNode = n;
break;
}
}
}
if (selectedASTNode == null)
{
selectedASTNode = stmt != null ? stmt.ParentNode : currentblock;
}
if (selectedASTNode == null)
{
return;
}
TreeStore.Foreach((TreeModel model, TreePath path, TreeIter iter) =>
{
var n = model.GetValue(iter, 0);
if (n == selectedASTNode)
{
dontJumpToDeclaration = true;
//var parentPath = path.Copy().Up();
TreeView.ExpandToPath(path);
TreeView.Selection.SelectIter(iter);
dontJumpToDeclaration = false;
return(true);
}
return(false);
});
}
public ScopedObjectVisitor(CodeLocation caret)
{
this.caret = caret;
}
void BuildTreeChildren(TreeIter ParentTreeNode, IBlockNode ParentAstNode, CodeLocation editorSelectionLocation)
{
if (ParentAstNode == null)
{
return;
}
if (ParentAstNode is DMethod)
{
if (DCompilerService.Instance.Outline.ShowFuncParams)
{
var dm = ParentAstNode as DMethod;
if (dm.Parameters != null)
{
foreach (var p in dm.Parameters)
{
if (p.Name != "")
{
TreeIter childIter;
if (!ParentTreeNode.Equals(TreeIter.Zero))
{
childIter = TreeStore.AppendValues(ParentTreeNode, p);
}
else
{
childIter = TreeStore.AppendValues(p);
}
if (editorSelectionLocation >= p.Location &&
editorSelectionLocation < p.EndLocation)
{
TreeView.Selection.SelectIter(childIter);
}
}
}
}
}
}
foreach (var n in ParentAstNode)
{
if (n is DEnum && (n as DEnum).IsAnonymous)
{
BuildTreeChildren(ParentTreeNode, n as IBlockNode, editorSelectionLocation);
continue;
}
if (!DCompilerService.Instance.Outline.ShowFuncVariables &&
ParentAstNode is DMethod &&
n is DVariable)
{
continue;
}
if (n is DMethod && string.IsNullOrEmpty(n.Name)) // Check against delegates & unittests
{
continue;
}
TreeIter childIter;
if (!ParentTreeNode.Equals(TreeIter.Zero))
{
childIter = TreeStore.AppendValues(ParentTreeNode, n);
}
else
{
childIter = TreeStore.AppendValues(n);
}
if (editorSelectionLocation >= n.Location &&
editorSelectionLocation < n.EndLocation)
{
TreeView.Selection.SelectIter(childIter);
}
BuildTreeChildren(childIter, n as IBlockNode, editorSelectionLocation);
}
}
void EnforceBraceStyle(BraceStyle braceStyle, CodeLocation lBrace, int rBraceLine, int rBraceColumn)
{
if (lBrace.IsEmpty)
{
return;
}
int lbraceOffset = document.ToOffset(lBrace);
int rbraceOffset = document.ToOffset(rBraceLine, rBraceColumn);
int whitespaceStart = SearchWhitespaceStart(lbraceOffset);
int whitespaceEnd = SearchWhitespaceLineStart(rbraceOffset);
string startIndent = "";
string endIndent = "";
switch (braceStyle)
{
case BraceStyle.DoNotChange:
startIndent = endIndent = null;
break;
case BraceStyle.EndOfLineWithoutSpace:
startIndent = "";
endIndent = IsLineIsEmptyUpToEol(rbraceOffset) ? curIndent.IndentString : this.options.EolMarker + curIndent.IndentString;
break;
case BraceStyle.EndOfLine:
int lastNonWs;
var lastComments = GetCommentsBefore(lBrace, out lastNonWs);
if (lastComments.Count != 0)
{
// delete old bracket
AddChange(whitespaceStart, lbraceOffset - whitespaceStart + 1, "");
lbraceOffset = whitespaceStart = lastNonWs + 1;
startIndent = " {";
}
else
{
startIndent = " ";
}
endIndent = IsLineIsEmptyUpToEol(rbraceOffset) ? curIndent.IndentString : this.options.EolMarker + curIndent.IndentString;
break;
case BraceStyle.NextLine:
startIndent = this.options.EolMarker + curIndent.IndentString;
endIndent = IsLineIsEmptyUpToEol(rbraceOffset) ? curIndent.IndentString : this.options.EolMarker + curIndent.IndentString;
break;
case BraceStyle.NextLineShifted2:
case BraceStyle.NextLineShifted:
curIndent.Push(IndentType.Block);
startIndent = this.options.EolMarker + curIndent.IndentString;
endIndent = IsLineIsEmptyUpToEol(rbraceOffset) ? curIndent.IndentString : this.options.EolMarker + curIndent.IndentString;
curIndent.Pop();
break;
}
if (lbraceOffset > 0 && startIndent != null)
{
AddChange(whitespaceStart, lbraceOffset - whitespaceStart, startIndent);
}
if (rbraceOffset > 0 && endIndent != null)
{
AddChange(whitespaceEnd, rbraceOffset - whitespaceEnd, endIndent);
}
}
protected override CodeElement CreateCodeElement(string name, string fullName, CodeLocation location, CodeElement parent)
{
CodeParameter parameter = new CodeParameter(name, fullName, location, parent);
return(parameter);
}
public static int CalculateRelativeIndentation(IExpression Expression, CodeLocation Caret)
{
return(0);
}
public async Task ClaimLock_Given_AlreadyLocked_Gives_FulcrumTryAgainException()
{
var createItem = new TestItemBare
{
Value = "x"
};
var item = await _table.CreateAndReturnAsync(createItem);
Assert.IsNotNull(item);
bool?lock2Success = null;
var claimLock1Success = new ManualResetEvent(false);
var hasTriedToClaimLock2 = new ManualResetEvent(false);
var thread1 = ThreadHelper.FireAndForget(async() =>
{
using (var scope = CreateStandardScope())
{
var lockedItem = await _table.SearchSingleAndLockWhereAsync("Id=@Id", new { Id = item.Id });
FulcrumAssert.IsNotNull(lockedItem);
claimLock1Success.Set();
FulcrumAssert.IsTrue(hasTriedToClaimLock2.WaitOne(TimeSpan.FromSeconds(1)), CodeLocation.AsString());
scope.Complete();
}
});
var thread2 = ThreadHelper.FireAndForget(async() =>
{
FulcrumAssert.IsTrue(claimLock1Success.WaitOne(TimeSpan.FromSeconds(1)));
using (var scope = CreateStandardScope())
{
try
{
var lockedItem = await _table.SearchSingleAndLockWhereAsync("Id=@Id", new { Id = item.Id });
FulcrumAssert.IsNotNull(lockedItem);
lock2Success = true;
scope.Complete();
}
catch (FulcrumTryAgainException)
{
lock2Success = false;
}
}
hasTriedToClaimLock2.Set();
});
Assert.IsTrue(thread2.Join(TimeSpan.FromSeconds(5)));
Assert.IsNotNull(lock2Success);
Assert.IsFalse(lock2Success);
Assert.IsTrue(thread1.Join(TimeSpan.FromSeconds(1)));
}
static int Calculate(ref IStatement s, CodeLocation caret)
{
int i = 0;
return(i);
}
public void GetDefinition(string filename, int startLine, int startIndex, int endLine, int endIndex)
{
filename = normalizePath(filename);
var ast = GetModule(filename);
if (ast == null)
{
throw new COMException("module not found", 1);
}
_tipStart = new CodeLocation(startIndex + 1, startLine);
_tipEnd = new CodeLocation(endIndex + 1, endLine);
_request = Request.Definition;
_result = "__pending__";
Action dg = () =>
{
_setupEditorData();
_editorData.CaretLocation = _tipEnd;
_editorData.SyntaxTree = ast as DModule;
_editorData.ModuleCode = _sources[filename];
// codeOffset+1 because otherwise it does not work on the first character
_editorData.CaretOffset = getCodeOffset(_editorData.ModuleCode, _tipStart) + 2;
ISyntaxRegion sr = DResolver.GetScopedCodeObject(_editorData);
LooseResolution.NodeResolutionAttempt attempt;
var rr = sr != null?LooseResolution.ResolveTypeLoosely(_editorData, sr, out attempt, true) : null;
StringBuilder tipText = new StringBuilder();
if (rr != null)
{
DNode n = null;
foreach (var t in AmbiguousType.TryDissolve(rr))
{
n = DResolver.GetResultMember(t, true);
if (n != null)
{
break;
}
}
if (n != null)
{
if (tipText.Length > 0)
{
tipText.Append("\n");
}
bool decl = false;
var mthd = n as DMethod;
if (mthd != null)
{
decl = mthd.Body == null;
}
else if (n.ContainsAttribute(DTokens.Extern))
{
decl = true;
}
if (decl)
{
tipText.Append("EXTERN:");
}
_tipStart = n.Location;
_tipEnd = n.EndLocation;
INode node = n.NodeRoot;
if (node is DModule)
{
tipText.Append((node as DModule).FileName);
}
}
}
if (!_editorData.CancelToken.IsCancellationRequested && _request == Request.Definition)
{
_result = tipText.ToString();
}
};
runAsync(dg);
}
static int Calculate(ref IExpression x, CodeLocation caret)
{
int i = 0;
return(i);
}
/// <summary>
/// Checks the positioning of method parameters which are split across multiple lines.
/// </summary>
/// <param name="element">
/// The element.
/// </param>
/// <param name="arguments">
/// The method arguments.
/// </param>
/// <param name="openingBracketNode">
/// The opening bracket token.
/// </param>
/// <param name="friendlyTypeText">
/// The friendly type text to use in reporting violations.
/// </param>
private void CheckSplitMethodArgumentList(CsElement element, IArgumentList arguments, Node <CsToken> openingBracketNode, string friendlyTypeText)
{
Param.AssertNotNull(element, "element");
Param.AssertNotNull(arguments, "arguments");
Param.AssertNotNull(openingBracketNode, "openingBracketNode");
Node <CsToken> previousComma = null;
bool commaOnSameLineAsPreviousParameterViolation = false;
for (int i = 0; i < arguments.Count; ++i)
{
CodeLocation location = arguments.Location(i);
int argumentStartLine = location.LineNumber;
CsTokenList tokens = arguments.Tokens(i);
// Some types of parameters or arguments are not allowed to span across multiple lines.
if (location.LineSpan > 1 && !arguments.MaySpanMultipleLines(i))
{
this.AddViolation(element, argumentStartLine, Rules.ParameterMustNotSpanMultipleLines);
}
if (i == 0)
{
// The first argument must start on the line after the opening bracket
if (argumentStartLine != openingBracketNode.Value.LineNumber + 1)
{
int commentLineSpan = MeasureCommentLinesAfter(openingBracketNode);
if (argumentStartLine != openingBracketNode.Value.LineNumber + commentLineSpan + 1)
{
this.AddViolation(element, argumentStartLine, Rules.SplitParametersMustStartOnLineAfterDeclaration, friendlyTypeText);
}
}
}
else
{
// The parameter must begin on the line after the previous comma.
Debug.Assert(previousComma != null, "The previous comma should have been set.");
if (!commaOnSameLineAsPreviousParameterViolation)
{
if (argumentStartLine != previousComma.Value.LineNumber + 1)
{
int commentLineSpan = MeasureCommentLinesAfter(previousComma);
if (argumentStartLine != previousComma.Value.LineNumber + commentLineSpan + 1)
{
this.AddViolation(element, argumentStartLine, Rules.ParameterMustFollowComma);
}
}
}
}
commaOnSameLineAsPreviousParameterViolation = false;
// Find the comma after the token list.
if (i < arguments.Count - 1)
{
for (Node <CsToken> tokenNode = tokens.Last.Next; tokenNode != null; tokenNode = tokenNode.Next)
{
if (tokenNode.Value.CsTokenType == CsTokenType.Comma)
{
previousComma = tokenNode;
// The comma must be on the same line as the previous parameter.
if (previousComma.Value.LineNumber != location.EndPoint.LineNumber)
{
int commentLineSpan = MeasureCommentLinesBetween(tokens.Last, previousComma, false);
if (previousComma.Value.LineNumber != location.EndPoint.LineNumber + commentLineSpan)
{
this.AddViolation(element, tokenNode.Value.LineNumber, Rules.CommaMustBeOnSameLineAsPreviousParameter);
commaOnSameLineAsPreviousParameterViolation = true;
}
}
break;
}
}
}
}
}
public void SetLocation(CodeLocation location)
{
_current = location;
}
/// <summary>
/// Binary search implementation for ordered syntax region (derivative) lists.
/// </summary>
public static SR SearchRegionAt <SR>(Func <int, SR> childGetter, int childCount, CodeLocation Where) where SR : ISyntaxRegion
{
int start = 0;
SR midElement = default(SR);
int midIndex = 0;
int len = childCount;
while (len > 0)
{
midIndex = (len % 2 + len) / 2;
// Take an element from the middle
if ((midElement = childGetter(start + midIndex - 1)) == null)
{
break;
}
// If 'Where' is beyond its start location
if (Where >= midElement.Location)
{
start += midIndex;
// If we've reached the (temporary) goal, break immediately
if (Where <= midElement.EndLocation)
{
break;
}
// If it's the last tested element and if the caret is beyond the end location,
// return the Parent instead the last tested child
else if (midIndex == len)
{
midElement = default(SR);
break;
}
}
else if (midIndex == len)
{
midElement = default(SR);
break;
}
len -= midIndex;
}
return(midElement);
}
