private void frmMain_Load(object sender, EventArgs e)
{
try
{
//login
UserApiClient _userApiClient = new UserApiClient(Core.Client);
//user
RoleApiClient apiClientRole = new RoleApiClient(Core.Client);
_userController = new UserController(_userApiClient, apiClientRole);
//
timer1.Enabled = true;
timerCheckLogin.Enabled = true;
MasterList.Innit(Core.User, Core.Path);
if (Core.IsLogin)
{
lbUser.Text = Core.User;
}
else
{
lbUser.Text = "no login";
if (!_userController.IsLogin())
{
Login();
}
}
}
catch (Exception)
{
}
}
private void RefreshServers()
{
RefreshBtn.Enabled = false;
var masterList = new MasterList("http://185.5.97.181:8000/master/public_servers");
if (masterList.ListGot)
{
networkList = new NetworkList();
if (networkList.InitSocket())
{
Application.UseWaitCursor = true;
networkList.Start();
foreach (var server in masterList.Servers)
{
networkList.ServerData(server);
}
timerRefresh.Start();
}
else
{
RefreshBtn.Enabled = true;
}
}
else
{
RefreshBtn.Enabled = true;
}
}
void MasterExecSave()
{
int i = -1;
_dataService.UpdateLightZone(MasterCurrentObject, (updatedCount, error) =>
{
if (error != null)
{
return;
} // Report error here
i = updatedCount;
});
MasterObjectButtonsVisibility = Visibility.Collapsed;
MasterListCurtainVisibility = Visibility.Collapsed;
DetailListCurtainVisibility = Visibility.Collapsed;
ProxyListCurtainVisibility = Visibility.Collapsed;
if (MasterAddMode)
{
MasterList.Add(MasterCurrentObject);
MasterSelectedItem = MasterCurrentObject;
}
// if (MasterEditMode) //in EditMode MasterSelectedItem always not null
// {
// if (!partitionChanged)
// {
// MasterList[msix] = MasterCurrentObject;
// //MasterSelectedItem.RaiseIsLinkedChanged();
// MasterSelectedItem = MasterCurrentObject;
// //if (savedDsix != -1)
// // DetailSelectedItem = DetailList[savedDsix];
// }
// else
// {
// MasterList.Remove(MasterSelectedItem);
// //DetailContentVisibility = Visibility.Hidden;
// partitionChanged = false;
// }
// }
MasterAddMode = false;
MasterEditMode = false;
MasterRemoveCmd.RaiseCanExecuteChanged();
MasterAddCmd.RaiseCanExecuteChanged();
// //if (DetailSelectedItem != null)
// //{
// // // при выполнении Save происходит замена .net объекта в MasterList
// // // необходимо восстановить Visual State
// // LightElement letmp = MasterSelectedItem;
// // ControlChannel tmp = DetailSelectedItem;
// // DetailSelectedItem = null;
// // DetailSelectedItem = tmp;
// // MasterSelectedItem = letmp;
// //}
//}
MessengerInstance.Send("", AppContext.UnBlockUIMsg);
}
private void UpdateMastets()
{
var selectedMaster = SelectedMaster?.Id;
MasterList.Clear();
if (_showAllMasters)
{
foreach (var master in _requestService.GetMasters(null))
{
MasterList.Add(master);
}
SelectedMaster = MasterList.FirstOrDefault(m => m.Id == selectedMaster);
}
else
{
if (_selectedHouseId.HasValue)
{
foreach (var master in _requestService.GetWorkersByHouseAndService(_selectedHouseId.Value, SelectedParentService.Id))
{
MasterList.Add(master);
}
SelectedMaster = MasterList.FirstOrDefault();
}
}
}
/// <summary>
/// Adds recurring appointments.
/// </summary>
/// <param name="item">The recurring appointment definition.</param>
/// <param name="dateLimit">A date limit at which the recurring appointments end.</param>
/// <remarks> The date limit may be dateTime.MaxValue which indicates no limit.</remarks>
public void AddNewRecurringAppointments(IRecurringScheduleAppointment item, DateTime dateLimit)
{
string[] rulesArray = item.RecurrenceRule.Split(new char[] { RecurrenceSupport.RuleDelimiter });
DateTime baseDate = DateTime.Parse(rulesArray[0]);
DateTime date = rulesArray[1].Length > 0 ? DateTime.Parse(rulesArray[1]) : dateLimit;
if (item.DateList == null)
{ //if null, then need to create it.
CreateDateListFromItem(item);
//conditionally set terminal date if present in rule.
if (rulesArray[1].Length > 0)
{
item.DateList.TerminalDate = date;
}
}
item.DateList.IsValidRecurrence(date); //this populates DateList up through date
bool needToSort = false;
foreach (DateTime dt in item.DateList)
{ //now go through and add appointments that match the datelist entries
if (dt >= item.DateList.BaseDate && dt <= item.DateList.TerminalDate)
{
AddAppointmentFromItem(item, dt);
needToSort = true;
}
}
if (needToSort)
{
ResetBaseDate(item);
MasterList.SortStartTime();
}
}
private Activity DequeueActivity(bool firstRun)
{
// Load the available activities into the queue if the queue is empty
// or on first run (repeat session situation)
if (!ExecutionQueue.Any() || firstRun)
{
// Add activities based on the execution count which describes
// the overall distribution or weight of different activities
// being executed.
List <Activity> activities = new List <Activity>();
foreach (var item in MasterList.OrderBy(n => n.ExecutionOrder))
{
activities.Add(item);
}
if (Randomize)
{
// If randomize was set for this collection of activities, then shuffle them
activities.Shuffle();
TraceFactory.Logger.Debug("Activities were shuffled");
}
foreach (Activity activity in activities)
{
// Then enqueue each activity onto the execution queue.
ExecutionQueue.Enqueue(activity);
}
}
_currentActivityExecutionCount = 1;
return(ExecutionQueue.Dequeue());
}
/// <summary>
/// Add package info without change Dirty state of itself
/// </summary>
/// <param name="info"></param>
public void AddInSilence(PackageInfo info)
{
if (!Exists(info))
{
MasterList.Add(info);
}
}
public ProgramUI(IConsole consoleForAllReadsAndWrites)
{
_console = consoleForAllReadsAndWrites;
MasterList = new MasterList();
PastCustomerRepo = new PastCustomerRepo();
PotentialCustomerRepo = new PotentialCustomerRepo();
PresentCustomerRepo = new PresentCustomerRepo();
}
/// <summary>
/// Initializes a new instance of the CsDocument class.
/// </summary>
/// <param name="sourceCode">
/// The source code that this document represents.
/// </param>
/// <param name="parser">
/// The parser that is creating this object.
/// </param>
internal CsDocument(SourceCode sourceCode, CsParser parser)
: this(sourceCode, parser, null)
{
Param.AssertNotNull(sourceCode, "sourceCode");
Param.AssertNotNull(parser, "parser");
this.tokens = new MasterList <CsToken>();
}
/// <summary>
/// Add package info and set Dirty state to True
/// </summary>
/// <param name="info"></param>
public void Add(PackageInfo info)
{
if (!Exists(info))
{
MasterList.Add(info);
IsDirty = true;
}
}
public void Remove(PackageInfo info)
{
if (Exists(info))
{
MasterList.Remove(info);
IsDirty = true;
}
}
private void btnDelete_Click(object sender, EventArgs e)
{
if (!isValidView)
{
MessageBox.Show("조회 후 처리해주세요.", "Error");
return;
}
if (this.listDataTypes.SelectedIndex < 0)
{
MessageBox.Show("자료 종류를 선택하지 않았습니다.", "Error");
return;
}
if (this.listDataTimes.SelectedIndex < 0)
{
MessageBox.Show("시간을 선택하지 않았습니다.", "Error");
return;
}
// 자료 종류
MasterList selectedMaster = (MasterList)this.listDataTypes.SelectedItem;
string dataTypeName = selectedMaster.name;
int dataTypeId = selectedMaster.id;
// 자료 시간
string dataTime = (string)this.listDataTimes.SelectedValue;
// 자료일자
DateTime d = this.datePicker.Value;
string dataDate = d.ToString("yyyyMMdd");
Console.WriteLine("자료종류: " + dataTypeId + ":" + dataTypeName);
Console.WriteLine("자료일자: " + dataDate);
Console.WriteLine("자료시간: " + dataTime);
// 확인
DialogResult result = MessageBox.Show("자료명: " + dataTypeName + "\n자료일자: " + dataDate + "\n자료시간: " + dataTime +
"\n\n삭제하시겠습니까? 삭제는 되돌릴 수 없습니다.", "주의", MessageBoxButtons.YesNo, MessageBoxIcon.Warning);
if (result != DialogResult.Yes)
{
return;
}
// 삭제요청
// 등록URL: data/<자료종류>/<자료일자>/<자료시간>
string resource_value = dataTypeId + "/" + dataDate + "/" + dataTime;
HttpRestClient client = new HttpRestClient(HttpRestClient.REST_METHOD_DELETE, "data/" + resource_value);
if (!client.doWorkDialog())
{
client.showErrorDialog();
return;
}
MessageBox.Show("삭제요청이 처리되었습니다.", "완료");
}
/// <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);
}
/// <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);
}
/// <summary>
/// Initializes a new instance of the TypeToken class.
/// </summary>
/// <param name="childTokens">
/// The list of child tokens that form the token.
/// </param>
/// <param name="location">
/// The location of the token 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 TypeToken(MasterList <CsToken> childTokens, CodeLocation location, Reference <ICodePart> parent, bool generated)
: base(CsTokenType.Other, CsTokenClass.Type, location, parent, generated)
{
Param.AssertNotNull(childTokens, "childTokens");
Param.AssertNotNull(location, "location");
Param.AssertNotNull(parent, "parent");
Param.Ignore(generated);
this.childTokens = childTokens;
}
/// <summary>
/// Initializes a new instance of the ConstructorConstraint class.
/// </summary>
/// <param name="childTokens">
/// The list of child tokens that form the token.
/// </param>
/// <param name="location">
/// The location of the token 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 ConstructorConstraint(MasterList<CsToken> childTokens, CodeLocation location, Reference<ICodePart> parent, bool generated)
: base(CsTokenType.Other, CsTokenClass.ConstructorConstraint, location, parent, generated)
{
Param.AssertNotNull(childTokens, "childTokens");
Param.AssertNotNull(location, "location");
Param.AssertNotNull(parent, "parent");
Param.Ignore(generated);
this.childTokens = childTokens;
}
void MasterExecRemove()
{
//_dataService.DeleteLightElement(MasterSelectedItem, (data, error) =>
// {
// if (error != null) { return; } // Report error here
// int updateCount = data;
// });
MasterList.Remove(MasterSelectedItem);
MasterSelectedItem = null;
}
public void RemoveBy(int fid)
{
var pi = SelectBy(fid);
if (pi != null)
{
MasterList.Remove(pi);
IsDirty = true;
}
}
/// <summary>
/// Initializes a new instance of the CsDocument class.
/// </summary>
/// <param name="sourceCode">
/// The source code that this document represents.
/// </param>
/// <param name="parser">
/// The parser that is creating this object.
/// </param>
/// <param name="tokens">
/// The tokens in the document.
/// </param>
internal CsDocument(SourceCode sourceCode, CsParser parser, MasterList <CsToken> tokens)
: base(sourceCode)
{
Param.AssertNotNull(sourceCode, "sourceCode");
Param.AssertNotNull(parser, "parser");
Param.Ignore(tokens);
this.parser = parser;
this.tokens = tokens;
}
public async Task <IActionResult> Create([Bind("MasterListId,Name,Active")] MasterList masterList)
{
if (ModelState.IsValid)
{
_context.Add(masterList);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(masterList));
}
private void CheckSpacing(MasterList<CsToken> tokens, bool v, object p)
{
for (Node<CsToken> tokenNode = tokens.First; tokenNode != null; tokenNode = tokenNode.Next)
{
if (tokenNode.Value.CsTokenClass == CsTokenClass.Whitespace &&
tokenNode.Value.Text.Contains(" "))
{
this.Violate(tokenNode.Value);
}
}
}
private void CheckSpacing(MasterList<CsToken> tokens, bool v, object p)
{
for (Node<CsToken> tokenNode = tokens.First; tokenNode != null; tokenNode = tokenNode.Next)
{
if ((tokenNode.Next == null || tokenNode.Next.Value.CsTokenType == CsTokenType.EndOfLine) &&
tokenNode.Value.CsTokenClass == CsTokenClass.Whitespace)
{
this.Violate(tokenNode.Value);
}
}
}
public string ReturnError()
{
if (MasterList.Contains(MasterWord))
{
return("Occurances of your keyword in the sentence:");
}
else
{
return("The sentence does not contain your keyword. Idiot.");
}
}
public static void DamageCard(int sId, int value)
{
Card target = MasterList.Find(x => x.ServerId == sId);
if (target == null)
{
throw new CardNotFoundException();
}
target.Damage(value);
}
private void CheckSpacing(MasterList <CsToken> tokens)
{
Param.AssertNotNull(tokens, "tokens");
foreach (var token in tokens)
{
if (this.Cancel)
{
break;
}
if (token.Generated)
{
continue;
}
switch (token.CsTokenType)
{
case CsTokenType.WhiteSpace:
this.CheckWhitespace(token as Whitespace);
break;
case CsTokenType.XmlHeader:
XmlHeader header = (XmlHeader)token;
foreach (var xmlChild in header.ChildTokens)
{
this.CheckTabsInComment(xmlChild);
}
break;
case CsTokenType.SingleLineComment:
case CsTokenType.MultiLineComment:
this.CheckTabsInComment(token);
break;
}
switch (token.CsTokenClass)
{
case CsTokenClass.ConstructorConstraint:
this.CheckSpacing(((ConstructorConstraint)token).ChildTokens);
break;
case CsTokenClass.GenericType:
this.CheckGenericSpacing((GenericType)token);
this.CheckSpacing(((TypeToken)token).ChildTokens);
break;
case CsTokenClass.Type:
this.CheckSpacing(((TypeToken)token).ChildTokens);
break;
}
}
}
//AttentionVM attentionVM;
void MasterExecSave()
{
int i = -1;
bool modeChanged = false;
if (MasterCurrentObject.Mode != MasterCurrentObject.OldMode)
{
modeChanged = true;
}
_dataService.UpdateEventDevice(MasterCurrentObject, (updatedCount, error) =>
{
if (error != null)
{
return;
} // Report error here
i = updatedCount;
});
MasterObjectButtonsVisibility = Visibility.Collapsed;
MasterListCurtainVisibility = Visibility.Collapsed;
DetailListCurtainVisibility = Visibility.Collapsed;
if (MasterAddMode)
{
MasterSelectorSelectedItem = null;
MasterList.Add(MasterCurrentObject);
MasterSelectedItem = MasterCurrentObject;
MasterListVisibility = Visibility.Visible;
}
if (MasterEditMode) //in EditMode MasterSelectedItem always not null
{
MasterList[msix] = MasterCurrentObject;
MasterSelectedItem = MasterCurrentObject;
if (!modeChanged)
{
if (savedDsix != -1)
{
DetailSelectedItem = DetailList[savedDsix];
}
}
}
MasterAddMode = false;
MasterEditMode = false;
MasterCurrentObject.IsEditMode = false;
MasterCurrentObject.IsAddMode = false;
MasterRemoveCmd.RaiseCanExecuteChanged();
MasterAddCmd.RaiseCanExecuteChanged();
MessengerInstance.Send("", AppContext.UnBlockUIMsg);
}
private void LoadData()
{
try
{
MasterList.LoadConfig(Core.User);
AddRow();
}
catch (Exception ex)
{
MessageBox.Show($"Load data is error, {ex.ToString()}");
}
}
protected override void Dispose(bool disposing)
{
Param.Ignore(disposing);
base.Dispose(disposing);
if (disposing)
{
this.contents = null;
this.tokens = null;
this.fileHeader = null;
this.parser = null;
}
}
void SyncTrade(string tradeId)
{
syncTradeCount++;
try {
var trade = MasterList.FirstOrDefault(t => t.Id == tradeId);
if (trade != null)
{
SyncTrade(trade);
}
} catch (Exception exc) { Log = exc; } finally {
syncTradeCount--;
}
}
public async Task <IActionResult> Edit(int id, [Bind("MasterListId,Name,Active")] MasterList masterList)
{
if (id != masterList.MasterListId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
var currentActiveList = _context.MasterLists.FirstOrDefault(m => m.Active);
if (currentActiveList != null && masterList.Active)
{
currentActiveList.Active = false;
_context.Update(masterList);
await _context.SaveChangesAsync();
}
}
catch
{
if (!MasterListExists(masterList.MasterListId))
{
return(NotFound());
}
else
{
throw;
}
}
try
{
_context.Update(masterList);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MasterListExists(masterList.MasterListId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(masterList));
}
private void listDataTypes_SelectedIndexChanged(object sender, System.EventArgs e)
{
isValidView = false;
MasterList selectedMaster = (MasterList)this.listDataTypes.SelectedItem;
if (selectedMaster != null && selectedMaster.timeList != null)
{
this.listDataTimes.DataSource = new BindingSource(selectedMaster.timeList, null);
this.listDataTimes.DisplayMember = "name";
this.listDataTimes.ValueMember = "id";
this.listDataTimes.SelectedIndex = -1;
}
}
public void RemovePunctuation(string[] stringArray)
{
foreach (string item in stringArray)
{
string[] newItem = item.Split(Punctuation);
foreach (string foo in newItem)
{
if (foo != "." && foo != "," && foo != "(" && foo != ")" && foo != "!" && foo != "?" && foo != " " && foo != "")
{
MasterList.Add(foo);
}
}
}
}
public MasterListGroupInput Add(MasterListGroupInput inputModel)
{
MasterList entity = mapper.Map <MasterList>(inputModel);
entity.Group = ConstantConfig.MasterListMasterGroup;
entity.CreatedBy = GetCurrentUserLogin();
entity.CreatedDate = DateTime.Now;
entity.ModifiedDate = DateTime.Now;
entity.ModifiedBy = GetCurrentUserLogin();
entity.RecordStatus = ConstantConfig.RecordStatusConfig.Active;
entity.UpdateToken = Guid.NewGuid();
masterListRepository.Add(entity);
return(mapper.Map <MasterListGroupInput>(entity));
}
public MasterListGroupInput GetInputById(EntityId <int> idModel)
{
if (idModel == null)
{
return(null);
}
MasterList entity = masterListRepository.GetAll()
.Where(x => x.Group == ConstantConfig.MasterListMasterGroup && x.Id == idModel.Id).SingleOrDefault();
if (entity == null)
{
return(null);
}
return(mapper.Map <MasterListGroupInput>(entity));
}
/// <summary>
/// Initializes a new instance of the Attribute class.
/// </summary>
/// <param name="childTokens">
/// The list of child tokens for the attribute.
/// </param>
/// <param name="location">
/// The location of the attribute.
/// </param>
/// <param name="parent">
/// The parent of the attribute.
/// </param>
/// <param name="attributeExpressions">
/// The list of attribute expressions within this attribute.
/// </param>
/// <param name="generated">
/// Indicates whether the attribute resides within a block of generated code.
/// </param>
internal Attribute(
MasterList<CsToken> childTokens, CodeLocation location, Reference<ICodePart> parent, IEnumerable<AttributeExpression> attributeExpressions, bool generated)
: base(CsTokenType.Attribute, CsTokenClass.Attribute, location, parent, generated)
{
Param.AssertNotNull(childTokens, "childTokens");
Param.AssertGreaterThanOrEqualTo(childTokens.Count, 2, "childTokens");
Param.AssertNotNull(location, "location");
Param.AssertNotNull(parent, "parent");
Param.AssertNotNull(attributeExpressions, "attributeExpressions");
Param.Ignore(generated);
this.childTokens = childTokens;
this.attributeExpressions = new CodeUnitCollection<AttributeExpression>(this);
this.attributeExpressions.AddRange(attributeExpressions);
}
private void CheckSpacing(MasterList<CsToken> tokens, bool v, object p)
{
for (Node<CsToken> tokenNode = tokens.First; tokenNode != null; tokenNode = tokenNode.Next)
{
if (tokenNode.Previous?.Value.CsTokenType == CsTokenType.EndOfLine &&
tokenNode.Value.CsTokenClass == CsTokenClass.Whitespace)
{
var trimedSpace = tokenNode.Value.Text.TrimStart('\t');
if (trimedSpace.Contains("\t") ||
trimedSpace.Length >= 4)
{
this.Violate(tokenNode.Value);
}
}
}
}
private void CheckCloseCurlyBracket(DocumentRoot root, MasterList<CsToken> tokens, Node<CsToken> tokenNode)
{
Node<CsToken> previous = tokenNode.Previous;
if (((previous != null) && (previous.Value.CsTokenType != CsTokenType.WhiteSpace)) && (previous.Value.CsTokenType != CsTokenType.EndOfLine))
{
base.AddViolation(root, tokenNode.Value.LineNumber, Microsoft.StyleCop.CSharp.Rules.ClosingCurlyBracketsMustBeSpacedCorrectly, new object[0]);
}
Node<CsToken> next = tokenNode.Next;
if (next != null)
{
CsTokenType csTokenType = next.Value.CsTokenType;
if ((((csTokenType != CsTokenType.WhiteSpace) && (csTokenType != CsTokenType.EndOfLine)) && ((csTokenType != CsTokenType.CloseParenthesis) && (csTokenType != CsTokenType.Semicolon))) && (csTokenType != CsTokenType.Comma))
{
base.AddViolation(root, tokenNode.Value.LineNumber, Microsoft.StyleCop.CSharp.Rules.ClosingCurlyBracketsMustBeSpacedCorrectly, new object[0]);
}
if (csTokenType == CsTokenType.WhiteSpace)
{
foreach (CsToken token in tokens.ForwardIterator(tokenNode.Next.Next))
{
CsTokenType type2 = token.CsTokenType;
switch (type2)
{
case CsTokenType.CloseParenthesis:
case CsTokenType.Semicolon:
case CsTokenType.Comma:
{
base.AddViolation(root, tokenNode.Value.LineNumber, Microsoft.StyleCop.CSharp.Rules.ClosingCurlyBracketsMustBeSpacedCorrectly, new object[0]);
continue;
}
}
if (type2 != CsTokenType.WhiteSpace)
{
return;
}
}
}
}
}
private void CheckSymbol(DocumentRoot root, MasterList<CsToken> tokens, Node<CsToken> tokenNode)
{
Node<CsToken> previous = tokenNode.Previous;
if (((previous != null) && (previous.Value.CsTokenType != CsTokenType.WhiteSpace)) && (previous.Value.CsTokenType != CsTokenType.EndOfLine))
{
base.AddViolation(root, tokenNode.Value.LineNumber, Microsoft.StyleCop.CSharp.Rules.SymbolsMustBeSpacedCorrectly, new object[] { tokenNode.Value.Text });
}
Node<CsToken> next = tokenNode.Next;
if (((next != null) && (next.Value.CsTokenType != CsTokenType.WhiteSpace)) && (next.Value.CsTokenType != CsTokenType.EndOfLine))
{
if (previous != null)
{
foreach (CsToken token in tokens.ReverseIterator(previous))
{
if (token.CsTokenType == CsTokenType.Operator)
{
return;
}
if (((token.CsTokenType != CsTokenType.WhiteSpace) && (token.CsTokenType != CsTokenType.EndOfLine)) && (((token.CsTokenType != CsTokenType.SingleLineComment) && (token.CsTokenType != CsTokenType.MultiLineComment)) && (token.CsTokenType != CsTokenType.PreprocessorDirective)))
{
break;
}
}
}
base.AddViolation(root, tokenNode.Value.LineNumber, Microsoft.StyleCop.CSharp.Rules.SymbolsMustBeSpacedCorrectly, new object[] { tokenNode.Value.Text });
}
}
private void CheckKeywordWithoutSpace(DocumentRoot root, MasterList<CsToken> tokens, Node<CsToken> tokenNode)
{
Node<CsToken> next = tokenNode.Next;
if ((next != null) && ((next.Value.CsTokenType == CsTokenType.WhiteSpace) || (next.Value.CsTokenType == CsTokenType.EndOfLine)))
{
foreach (CsToken token in tokens.ForwardIterator(next.Next))
{
if (token.CsTokenType == CsTokenType.OpenParenthesis)
{
base.AddViolation(root, tokenNode.Value.LineNumber, Microsoft.StyleCop.CSharp.Rules.KeywordsMustBeSpacedCorrectly, new object[] { tokenNode.Value.Text });
break;
}
if ((token.CsTokenType != CsTokenType.WhiteSpace) && (token.CsTokenType != CsTokenType.EndOfLine))
{
break;
}
}
}
}
private MasterList<CsToken> GetGenericArgumentList(Reference<ICodePart> genericTypeReference, bool unsafeCode, CsToken name, int startIndex, out int endIndex)
{
Param.AssertNotNull(genericTypeReference, "genericTypeReference");
Param.Ignore(unsafeCode);
Param.Ignore(name);
Param.AssertGreaterThanOrEqualToZero(startIndex, "startIndex");
endIndex = -1;
MasterList<CsToken> genericArgumentListTokens = null;
// Move past whitespace and comments.
int index = startIndex;
while (true)
{
Symbol next = this.symbols.Peek(index);
if (next == null
|| (next.SymbolType != SymbolType.WhiteSpace && next.SymbolType != SymbolType.EndOfLine && next.SymbolType != SymbolType.SingleLineComment
&& next.SymbolType != SymbolType.MultiLineComment && next.SymbolType != SymbolType.PreprocessorDirective))
{
break;
}
++index;
}
// The next symbol should be an opening bracket, if this is a generic.
Symbol symbol = this.symbols.Peek(index);
if (symbol != null && symbol.SymbolType == SymbolType.LessThan)
{
// This might be a generic. Assume that it is and start creating tokens.
genericArgumentListTokens = new MasterList<CsToken>();
// Add the name if one was provided.
if (name != null)
{
genericArgumentListTokens.Add(name);
}
Node<CsToken> openingGenericBracketNode = null;
// Add everything up to the opening bracket into the token list.
for (int i = startIndex; i <= index; ++i)
{
symbol = this.symbols.Peek(i);
Debug.Assert(symbol != null, "The next symbol should not be null");
if (symbol.SymbolType == SymbolType.LessThan)
{
if (openingGenericBracketNode != null)
{
// This is not a generic statement.
return null;
}
Bracket openingGenericBracket = new Bracket(
symbol.Text, CsTokenType.OpenGenericBracket, symbol.Location, genericTypeReference, this.symbols.Generated);
openingGenericBracketNode = genericArgumentListTokens.InsertLast(openingGenericBracket);
}
else
{
genericArgumentListTokens.Add(this.ConvertSymbol(symbol, TokenTypeFromSymbolType(symbol.SymbolType), genericTypeReference));
}
}
// Loop through the rest of the symbols.
while (true)
{
symbol = this.symbols.Peek(++index);
if (symbol == null)
{
// The code ran out before we found the end of the generic.
throw new SyntaxException(this.document.SourceCode, name.LineNumber);
}
else if (symbol.SymbolType == SymbolType.GreaterThan)
{
if (openingGenericBracketNode == null)
{
// This is not a generic statement.
return null;
}
// This is the end of the generic statement. Add the closing bracket to the token list.
Bracket closingGenericBracket = new Bracket(
symbol.Text, CsTokenType.CloseGenericBracket, symbol.Location, genericTypeReference, this.symbols.Generated);
Node<CsToken> closingGenericBracketNode = genericArgumentListTokens.InsertLast(closingGenericBracket);
((Bracket)openingGenericBracketNode.Value).MatchingBracketNode = closingGenericBracketNode;
closingGenericBracket.MatchingBracketNode = openingGenericBracketNode;
endIndex = index;
break;
}
else if (symbol.SymbolType == SymbolType.Out || symbol.SymbolType == SymbolType.In)
{
// Get the in or out keyword.
genericArgumentListTokens.Add(
this.ConvertSymbol(symbol, symbol.SymbolType == SymbolType.In ? CsTokenType.In : CsTokenType.Out, genericTypeReference));
}
else if (symbol.SymbolType == SymbolType.Other)
{
int lastIndex = 0;
Reference<ICodePart> wordReference = new Reference<ICodePart>();
CsToken word = this.GetTypeTokenAux(wordReference, genericTypeReference, unsafeCode, true, false, index, out lastIndex);
if (word == null)
{
throw new SyntaxException(this.document.SourceCode, symbol.LineNumber);
}
// Advance the index to the end of the token.
index = lastIndex;
// Add the token.
genericArgumentListTokens.Add(word);
}
else if (symbol.SymbolType == SymbolType.WhiteSpace || symbol.SymbolType == SymbolType.EndOfLine || symbol.SymbolType == SymbolType.SingleLineComment
|| symbol.SymbolType == SymbolType.MultiLineComment || symbol.SymbolType == SymbolType.PreprocessorDirective)
{
// Add these to the token list.
genericArgumentListTokens.Add(this.ConvertSymbol(symbol, TokenTypeFromSymbolType(symbol.SymbolType), genericTypeReference));
}
else if (symbol.SymbolType == SymbolType.Comma)
{
genericArgumentListTokens.Add(this.ConvertSymbol(symbol, CsTokenType.Comma, genericTypeReference));
}
else if (symbol.SymbolType == SymbolType.OpenSquareBracket)
{
// An attribute on the generic type.
genericArgumentListTokens.Add(this.GetAttribute(genericTypeReference, unsafeCode));
}
else
{
// Any other symbol signifies that this is not a generic statement.
genericArgumentListTokens = null;
break;
}
}
}
return genericArgumentListTokens;
}
/// <summary>
/// Checks a unary symbol for spacing.
/// </summary>
/// <param name="tokens">
/// The master list of tokens.
/// </param>
/// <param name="tokenNode">
/// The token to check.
/// </param>
private void CheckUnarySymbol(MasterList<CsToken> tokens, Node<CsToken> tokenNode)
{
Param.AssertNotNull(tokens, "tokens");
Param.AssertNotNull(tokenNode, "tokenNode");
// These symbols should be preceded by whitespace but not followed by whitespace. They can
// also be preceded by an open paren or an open square bracket.
Node<CsToken> previousNode = tokenNode.Previous;
if (previousNode != null)
{
CsTokenType previousNodeTokenType = previousNode.Value.CsTokenType;
if (previousNodeTokenType != CsTokenType.WhiteSpace && previousNodeTokenType != CsTokenType.EndOfLine
&& previousNodeTokenType != CsTokenType.OpenParenthesis && previousNodeTokenType != CsTokenType.OpenSquareBracket
&& previousNodeTokenType != CsTokenType.CloseParenthesis)
{
this.AddViolation(tokenNode.Value.FindParentElement(), tokenNode.Value.Location, Rules.SymbolsMustBeSpacedCorrectly, tokenNode.Value.Text);
}
// They should not be preceded by whitespace if the whitespace is preceded by a paranthesis.
if (previousNodeTokenType == CsTokenType.WhiteSpace || previousNodeTokenType == CsTokenType.EndOfLine)
{
foreach (CsToken item in tokens.ReverseIterator(previousNode))
{
if (item.CsTokenType == CsTokenType.OpenParenthesis || item.CsTokenType == CsTokenType.OpenSquareBracket)
{
this.AddViolation(tokenNode.Value.FindParentElement(), tokenNode.Value.Location, Rules.SymbolsMustBeSpacedCorrectly, tokenNode.Value.Text);
}
else if (item.CsTokenType == CsTokenType.WhiteSpace)
{
continue;
}
if (item.CsTokenType != CsTokenType.OpenParenthesis && item.CsTokenType != CsTokenType.OpenSquareBracket
&& item.CsTokenType != CsTokenType.WhiteSpace)
{
break;
}
}
}
}
Node<CsToken> nextNode = tokenNode.Next;
if (nextNode != null)
{
CsTokenType tokenType = nextNode.Value.CsTokenType;
if (tokenType == CsTokenType.WhiteSpace || tokenType == CsTokenType.EndOfLine || tokenType == CsTokenType.SingleLineComment
|| tokenType == CsTokenType.MultiLineComment)
{
this.AddViolation(tokenNode.Value.FindParentElement(), tokenNode.Value.Location, Rules.SymbolsMustBeSpacedCorrectly, tokenNode.Value.Text);
}
}
}
private void CheckOpenCurlyBracket(DocumentRoot root, MasterList<CsToken> tokens, Node<CsToken> tokenNode)
{
Node<CsToken> previous = tokenNode.Previous;
if (previous != null)
{
CsTokenType csTokenType = previous.Value.CsTokenType;
if (((csTokenType != CsTokenType.WhiteSpace) && (csTokenType != CsTokenType.EndOfLine)) && (csTokenType != CsTokenType.OpenParenthesis))
{
base.AddViolation(root, tokenNode.Value.LineNumber, Microsoft.StyleCop.CSharp.Rules.OpeningCurlyBracketsMustBeSpacedCorrectly, new object[0]);
}
if (csTokenType == CsTokenType.WhiteSpace)
{
foreach (CsToken token in tokens.ReverseIterator(previous))
{
CsTokenType type2 = token.CsTokenType;
if (type2 == CsTokenType.OpenParenthesis)
{
base.AddViolation(root, tokenNode.Value.LineNumber, Microsoft.StyleCop.CSharp.Rules.OpeningCurlyBracketsMustBeSpacedCorrectly, new object[0]);
}
else if (type2 != CsTokenType.WhiteSpace)
{
break;
}
}
}
}
Node<CsToken> next = tokenNode.Next;
if (((next != null) && (next.Value.CsTokenType != CsTokenType.WhiteSpace)) && (next.Value.CsTokenType != CsTokenType.EndOfLine))
{
base.AddViolation(root, tokenNode.Value.LineNumber, Microsoft.StyleCop.CSharp.Rules.OpeningCurlyBracketsMustBeSpacedCorrectly, new object[0]);
}
}
private void CheckCloseSquareBracket(MasterList<CsToken> tokens, Node<CsToken> tokenNode, Node<CsToken> parentTokenNode)
{
Param.AssertNotNull(tokens, "tokens");
Param.AssertNotNull(tokenNode, "tokenNode");
Param.Ignore(parentTokenNode);
// Close brackets should never be preceded by whitespace.
Node<CsToken> previousNode = tokenNode.Previous;
if (previousNode != null && (previousNode.Value.CsTokenType == CsTokenType.WhiteSpace || previousNode.Value.CsTokenType == CsTokenType.EndOfLine))
{
this.AddViolation(tokenNode.Value.FindParentElement(), tokenNode.Value.Location, Rules.ClosingSquareBracketsMustBeSpacedCorrectly);
}
// Close brackets should be followed either by whitespace, a bracket,
// a paren, a semicolon, a comma, a period, or an increment or decrement symbol.
Node<CsToken> nextNode = tokenNode.Next ?? parentTokenNode.Next;
if (nextNode != null)
{
CsTokenType nextType = nextNode.Value.CsTokenType;
if (nextType != CsTokenType.WhiteSpace && nextType != CsTokenType.EndOfLine && nextType != CsTokenType.CloseParenthesis
&& nextType != CsTokenType.OpenParenthesis && // someDictionary["Test"]();
nextType != CsTokenType.CloseSquareBracket && // someIndexer[someArray[1]] = 2;
nextType != CsTokenType.OpenSquareBracket && // someArray[1][2] = 2;
nextType != CsTokenType.Semicolon && nextType != CsTokenType.Comma && nextType != CsTokenType.CloseGenericBracket && nextNode.Value.Text != "++"
&& nextNode.Value.Text != "--" && nextNode.Value.Text != "?." && nextNode.Value.Text != "?" && !nextNode.Value.Text.StartsWith(".", StringComparison.Ordinal))
{
this.AddViolation(tokenNode.Value.FindParentElement(), tokenNode.Value.Location, Rules.ClosingSquareBracketsMustBeSpacedCorrectly);
}
if (nextType == CsTokenType.WhiteSpace)
{
// If this is followed by whitespace, make sure that the character just
// after the whitespace is not a paren, bracket, comma, or semicolon.
foreach (CsToken item in tokens.ForwardIterator(nextNode.Next))
{
CsTokenType itemType = item.CsTokenType;
if (itemType == CsTokenType.CloseParenthesis || itemType == CsTokenType.OpenParenthesis || itemType == CsTokenType.CloseSquareBracket
|| itemType == CsTokenType.OpenSquareBracket || itemType == CsTokenType.Semicolon || itemType == CsTokenType.Comma)
{
this.AddViolation(tokenNode.Value.FindParentElement(), tokenNode.Value.Location, Rules.ClosingSquareBracketsMustBeSpacedCorrectly);
}
else if (itemType != CsTokenType.WhiteSpace)
{
break;
}
}
}
}
}
private void CheckOpenParen(MasterList<CsToken> tokens, Node<CsToken> tokenNode)
{
Param.AssertNotNull(tokens, "tokens");
Param.AssertNotNull(tokenNode, "tokenNode");
bool firstOnLine = false;
bool lastOnLine = false;
// Open parenthesis should never be preceded by whitespace unless it is the
// first thing on the line or it follows a keyword or it follows a symbol or a number.
Node<CsToken> previousNode = tokenNode.Previous;
if (previousNode != null)
{
if (previousNode.Value.CsTokenType == CsTokenType.WhiteSpace)
{
foreach (CsToken item in tokens.ReverseIterator(previousNode))
{
CsTokenType itemType = item.CsTokenType;
if (itemType == CsTokenType.WhiteSpace)
{
continue;
}
if (itemType == CsTokenType.EndOfLine)
{
firstOnLine = true;
break;
}
if (itemType == CsTokenType.Case || itemType == CsTokenType.Catch || itemType == CsTokenType.CloseSquareBracket || itemType == CsTokenType.Comma
|| itemType == CsTokenType.Equals || itemType == CsTokenType.Fixed || itemType == CsTokenType.For || itemType == CsTokenType.Foreach
|| itemType == CsTokenType.From || ////itemType == CsTokenType.Goto ||
itemType == CsTokenType.Group || itemType == CsTokenType.If || itemType == CsTokenType.In || itemType == CsTokenType.Into
|| itemType == CsTokenType.Join || itemType == CsTokenType.Let || itemType == CsTokenType.Lock || itemType == CsTokenType.MultiLineComment
|| ////itemType == CsTokenType.New ||
itemType == CsTokenType.Number || itemType == CsTokenType.OperatorSymbol || itemType == CsTokenType.OpenCurlyBracket
|| itemType == CsTokenType.OrderBy || itemType == CsTokenType.Return || itemType == CsTokenType.Select || itemType == CsTokenType.Semicolon
|| ////itemType == CsTokenType.SingleLineComment ||
itemType == CsTokenType.Switch || itemType == CsTokenType.Throw || itemType == CsTokenType.Using || itemType == CsTokenType.Where
|| itemType == CsTokenType.While || itemType == CsTokenType.WhileDo || itemType == CsTokenType.Yield || itemType == CsTokenType.LabelColon
|| itemType == CsTokenType.Async || itemType == CsTokenType.By || itemType == CsTokenType.When)
{
break;
}
this.AddViolation(tokenNode.Value.FindParentElement(), previousNode.Value.Location, Rules.OpeningParenthesisMustBeSpacedCorrectly);
}
}
}
// Open parens should never be followed by whitespace unless
// it is the last thing on the line.
Node<CsToken> next = tokenNode.Next;
if (next != null && (next.Value.CsTokenType == CsTokenType.WhiteSpace || next.Value.CsTokenType == CsTokenType.EndOfLine))
{
// Look to see if there is any non whitespace character
// on this line other than a comment.
foreach (CsToken item in tokens.ForwardIterator(next))
{
CsTokenType itemType = item.CsTokenType;
if (itemType == CsTokenType.EndOfLine)
{
lastOnLine = true;
break;
}
else if (itemType != CsTokenType.WhiteSpace && itemType != CsTokenType.SingleLineComment && itemType != CsTokenType.MultiLineComment)
{
this.AddViolation(tokenNode.Value.FindParentElement(), next.Value.Location, Rules.OpeningParenthesisMustBeSpacedCorrectly);
break;
}
}
}
// Open parens cannot be the only thing on the line.
if (firstOnLine && lastOnLine)
{
this.AddViolation(tokenNode.Value.FindParentElement(), tokenNode.Value.Location, Rules.OpeningParenthesisMustBeSpacedCorrectly);
}
}
private void CheckCloseParen(DocumentRoot root, MasterList<CsToken> tokens, Node<CsToken> tokenNode)
{
Node<CsToken> previous = tokenNode.Previous;
if ((previous != null) && ((previous.Value.CsTokenType == CsTokenType.WhiteSpace) || (previous.Value.CsTokenType == CsTokenType.EndOfLine)))
{
base.AddViolation(root, tokenNode.Value.LineNumber, Microsoft.StyleCop.CSharp.Rules.ClosingParenthesisMustBeSpacedCorrectly, new object[0]);
}
Node<CsToken> next = tokenNode.Next;
if (next == null)
{
return;
}
CsTokenType csTokenType = next.Value.CsTokenType;
if (((csTokenType == CsTokenType.WhiteSpace
|| csTokenType == CsTokenType.EndOfLine
|| csTokenType == CsTokenType.CloseParenthesis
|| csTokenType == CsTokenType.OpenParenthesis
|| csTokenType == CsTokenType.CloseSquareBracket
|| csTokenType == CsTokenType.OpenSquareBracket
|| csTokenType == CsTokenType.CloseAttributeBracket
|| csTokenType == CsTokenType.Semicolon
|| csTokenType == CsTokenType.Comma
|| csTokenType == CsTokenType.Other
|| csTokenType == CsTokenType.Base
|| csTokenType == CsTokenType.This
|| csTokenType == CsTokenType.Null
|| csTokenType == CsTokenType.New
|| csTokenType == CsTokenType.Number
|| csTokenType == CsTokenType.String
// Oleg Shuruev added
|| csTokenType == CsTokenType.Typeof)
|| ((csTokenType == CsTokenType.Delegate)
|| ((csTokenType == CsTokenType.OperatorSymbol)
&& (((OperatorSymbol)next.Value).SymbolType == OperatorType.AddressOf))))
|| next.Value.Text.StartsWith(".", StringComparison.Ordinal))
{
goto Label_01C1;
}
bool flag = false;
if (csTokenType == CsTokenType.OperatorSymbol)
{
OperatorSymbol symbol = next.Value as OperatorSymbol;
if ((symbol.SymbolType == OperatorType.Negative) || (symbol.SymbolType == OperatorType.Positive))
{
flag = true;
}
}
if (flag)
{
goto Label_01C1;
}
bool flag2 = false;
if (csTokenType == CsTokenType.LabelColon)
{
foreach (CsToken token in tokens.ReverseIterator(tokenNode.Previous))
{
switch (token.CsTokenType)
{
case CsTokenType.EndOfLine:
goto Label_019E;
case CsTokenType.Case:
flag2 = true;
goto Label_019E;
}
}
}
Label_019E:
if (!flag2)
{
base.AddViolation(root, tokenNode.Value.LineNumber, Microsoft.StyleCop.CSharp.Rules.ClosingParenthesisMustBeSpacedCorrectly, new object[0]);
}
Label_01C1:
if (csTokenType == CsTokenType.WhiteSpace)
{
foreach (CsToken token2 in tokens.ForwardIterator(tokenNode.Next.Next))
{
CsTokenType type3 = token2.CsTokenType;
switch (type3)
{
case CsTokenType.CloseParenthesis:
case CsTokenType.OpenParenthesis:
case CsTokenType.CloseSquareBracket:
case CsTokenType.OpenSquareBracket:
case CsTokenType.Semicolon:
case CsTokenType.Comma:
{
base.AddViolation(root, tokenNode.Value.LineNumber, Microsoft.StyleCop.CSharp.Rules.ClosingParenthesisMustBeSpacedCorrectly, new object[0]);
continue;
}
}
if (type3 != CsTokenType.WhiteSpace)
{
return;
}
}
}
}
/// <summary>
/// Checks to see if the passed in node is the first node on its line.
/// </summary>
/// <param name="tokens">
/// The master list of tokens.
/// </param>
/// <param name="node">
/// The node to check.
/// </param>
/// <returns>
/// True if this node is the first on the line, otherwise false.
/// </returns>
private bool IsTokenFirstNonWhitespaceTokenOnLine(MasterList<CsToken> tokens, Node<CsToken> node)
{
Param.AssertNotNull(tokens, "tokens");
Param.AssertNotNull(node, "node");
Node<CsToken> previousNode = node.Previous;
if (previousNode == null)
{
return true;
}
bool returnValue = true;
foreach (CsToken item in tokens.ReverseIterator(previousNode))
{
if (item.LineNumber != node.Value.LineNumber)
{
break;
}
if (item.CsTokenType != CsTokenType.WhiteSpace)
{
returnValue = false;
break;
}
}
return returnValue;
}
/// <summary>
/// Checks a open bracket for spacing.
/// </summary>
/// <param name="tokens">
/// The list of tokens being parsed.
/// </param>
/// <param name="tokenNode">
/// The token to check.
/// </param>
private void CheckOpenCurlyBracket(MasterList<CsToken> tokens, Node<CsToken> tokenNode)
{
Param.AssertNotNull(tokens, "tokens");
Param.AssertNotNull(tokenNode, "tokenNode");
// Open curly brackets should be preceded either by whitespace, or an open paren.
Node<CsToken> previousNode = tokenNode.Previous;
if (previousNode != null)
{
CsTokenType lastType = previousNode.Value.CsTokenType;
if (lastType != CsTokenType.WhiteSpace && lastType != CsTokenType.EndOfLine && lastType != CsTokenType.OpenParenthesis)
{
this.AddViolation(tokenNode.Value.FindParentElement(), tokenNode.Value.Location, Rules.OpeningCurlyBracketsMustBeSpacedCorrectly);
}
if (lastType == CsTokenType.WhiteSpace)
{
// If this is preceded by whitespace, make sure that the character just
// before the whitespace is not an open paren.
foreach (CsToken item in tokens.ReverseIterator(previousNode))
{
CsTokenType itemType = item.CsTokenType;
if (itemType == CsTokenType.OpenParenthesis)
{
this.AddViolation(tokenNode.Value.FindParentElement(), tokenNode.Value.Location, Rules.OpeningCurlyBracketsMustBeSpacedCorrectly);
}
else if (itemType != CsTokenType.WhiteSpace)
{
break;
}
}
}
}
// Open curly brackets should always be followed by whitespace.
Node<CsToken> nextNode = tokenNode.Next;
if (nextNode != null && nextNode.Value.CsTokenType != CsTokenType.WhiteSpace && nextNode.Value.CsTokenType != CsTokenType.EndOfLine)
{
this.AddViolation(tokenNode.Value.FindParentElement(), tokenNode.Value.Location, Rules.OpeningCurlyBracketsMustBeSpacedCorrectly);
}
}
/// <summary>
/// Checks a member access symbol for spacing.
/// </summary>
/// <param name="tokens">
/// The list of tokens being parsed.
/// </param>
/// <param name="tokenNode">
/// The token to check.
/// </param>
private void CheckMemberAccessSymbol(MasterList<CsToken> tokens, Node<CsToken> tokenNode)
{
Param.AssertNotNull(tokens, "tokens");
Param.AssertNotNull(tokenNode, "tokenNode");
// Member access symbols should not have any whitespace on either side.
Node<CsToken> previousNode = tokenNode.Previous;
if (previousNode != null)
{
CsTokenType previousTokenType = previousNode.Value.CsTokenType;
if (previousTokenType == CsTokenType.WhiteSpace || previousTokenType == CsTokenType.EndOfLine || previousTokenType == CsTokenType.SingleLineComment
|| previousTokenType == CsTokenType.MultiLineComment)
{
if (!this.IsTokenFirstNonWhitespaceTokenOnLine(tokens, tokenNode))
{
this.AddViolation(tokenNode.Value.FindParentElement(), tokenNode.Value.Location, Rules.MemberAccessSymbolsMustBeSpacedCorrectly);
}
}
}
Node<CsToken> nextNode = tokenNode.Next;
if (nextNode != null)
{
CsTokenType tokenType = nextNode.Value.CsTokenType;
if (tokenType == CsTokenType.WhiteSpace || tokenType == CsTokenType.EndOfLine || tokenType == CsTokenType.SingleLineComment
|| tokenType == CsTokenType.MultiLineComment)
{
// Make sure the previous token is not the operator keyword.
if (previousNode != null)
{
foreach (CsToken item in tokens.ReverseIterator(previousNode))
{
CsTokenType itemType = item.CsTokenType;
if (itemType == CsTokenType.Operator)
{
return;
}
else if (itemType != CsTokenType.WhiteSpace && itemType != CsTokenType.EndOfLine && itemType != CsTokenType.SingleLineComment
&& itemType != CsTokenType.MultiLineComment)
{
break;
}
}
}
this.AddViolation(tokenNode.Value.FindParentElement(), tokenNode.Value.Location, Rules.MemberAccessSymbolsMustBeSpacedCorrectly);
}
}
}
/// <summary>
/// Checks a keyword that should not be followed by a space.
/// </summary>
/// <param name="tokens">
/// The list of tokens being parsed.
/// </param>
/// <param name="tokenNode">
/// The token to check.
/// </param>
private void CheckKeywordWithoutSpace(MasterList<CsToken> tokens, Node<CsToken> tokenNode)
{
Param.AssertNotNull(tokens, "tokens");
Param.AssertNotNull(tokenNode, "tokenNode");
// Keywords must not contain any space before the open parenthesis.
Node<CsToken> temp = tokenNode.Next;
if (temp != null && (temp.Value.CsTokenType == CsTokenType.WhiteSpace || temp.Value.CsTokenType == CsTokenType.EndOfLine))
{
// Make sure the next non-whitespace character is not an open parenthesis.
foreach (CsToken nextNonWhitespaceToken in tokens.ForwardIterator(temp.Next))
{
if (nextNonWhitespaceToken.CsTokenType == CsTokenType.OpenParenthesis)
{
this.AddViolation(tokenNode.Value.FindParentElement(), tokenNode.Value.Location, Rules.KeywordsMustBeSpacedCorrectly, tokenNode.Value.Text);
break;
}
else if (nextNonWhitespaceToken.CsTokenType != CsTokenType.WhiteSpace && nextNonWhitespaceToken.CsTokenType != CsTokenType.EndOfLine)
{
break;
}
}
}
}
private void CheckGenericSpacing(MasterList<CsToken> tokens, Node<CsToken> genericTokenNode)
{
Param.AssertNotNull(tokens, "tokens");
Param.AssertNotNull(genericTokenNode, "genericTokenNode");
GenericType generic = genericTokenNode.Value as GenericType;
// Make sure it contains at least one token.
if (generic.ChildTokens.Count > 0)
{
for (Node<CsToken> tokenNode = generic.ChildTokens.First; tokenNode != null; tokenNode = tokenNode.Next)
{
if (this.Cancel)
{
break;
}
// Check whether this token is a generic and if so parse the tokens within
// the generic statement.
if (tokenNode.Value.CsTokenClass == CsTokenClass.GenericType)
{
this.CheckGenericSpacing(tokens, tokenNode);
}
if (!tokenNode.Value.Generated)
{
switch (tokenNode.Value.CsTokenType)
{
case CsTokenType.Comma:
this.CheckSemicolonAndComma(tokens, tokenNode);
break;
case CsTokenType.OpenParenthesis:
this.CheckOpenParen(generic.ChildTokens, tokenNode);
break;
case CsTokenType.CloseParenthesis:
this.CheckCloseParen(generic.ChildTokens, tokenNode);
break;
case CsTokenType.OpenSquareBracket:
this.CheckOpenSquareBracket(tokenNode);
break;
case CsTokenType.CloseSquareBracket:
this.CheckCloseSquareBracket(generic.ChildTokens, tokenNode, genericTokenNode);
break;
case CsTokenType.WhiteSpace:
this.CheckWhitespace(tokenNode);
break;
case CsTokenType.OpenGenericBracket:
this.CheckGenericTokenOpenBracket(tokenNode);
break;
case CsTokenType.CloseGenericBracket:
this.CheckGenericTokenCloseBracket(tokenNode, genericTokenNode);
break;
case CsTokenType.PreprocessorDirective:
this.CheckPreprocessorSpacing(tokenNode.Value);
break;
case CsTokenType.OperatorSymbol:
OperatorSymbol symbol = tokenNode.Value as OperatorSymbol;
if (symbol.SymbolType == OperatorType.MemberAccess || symbol.SymbolType == OperatorType.QualifiedAlias)
{
this.CheckMemberAccessSymbol(generic.ChildTokens, tokenNode);
}
else
{
goto default;
}
break;
case CsTokenType.Other:
case CsTokenType.EndOfLine:
case CsTokenType.In:
case CsTokenType.Out:
// Ignore these.
break;
default:
// There shouldn't be anything else within a generic type token.
Debug.Fail("Unexpected token type.");
break;
}
}
}
}
}
private void CheckMemberAccessSymbol(DocumentRoot root, MasterList<CsToken> tokens, Node<CsToken> tokenNode)
{
Node<CsToken> previous = tokenNode.Previous;
if (previous == null)
{
switch (previous.Value.CsTokenType)
{
case CsTokenType.WhiteSpace:
case CsTokenType.EndOfLine:
case CsTokenType.SingleLineComment:
case CsTokenType.MultiLineComment:
base.AddViolation(root, tokenNode.Value.LineNumber, Microsoft.StyleCop.CSharp.Rules.MemberAccessSymbolsMustBeSpacedCorrectly, new object[0]);
break;
}
}
Node<CsToken> next = tokenNode.Next;
if (next == null)
{
switch (next.Value.CsTokenType)
{
case CsTokenType.WhiteSpace:
case CsTokenType.EndOfLine:
case CsTokenType.SingleLineComment:
case CsTokenType.MultiLineComment:
if (previous != null)
{
foreach (CsToken token in tokens.ReverseIterator(previous))
{
CsTokenType csTokenType = token.CsTokenType;
if (csTokenType == CsTokenType.Operator)
{
return;
}
if (((csTokenType != CsTokenType.WhiteSpace) && (csTokenType != CsTokenType.EndOfLine)) && ((csTokenType != CsTokenType.SingleLineComment) && (csTokenType != CsTokenType.MultiLineComment)))
{
break;
}
}
}
base.AddViolation(root, tokenNode.Value.LineNumber, Microsoft.StyleCop.CSharp.Rules.MemberAccessSymbolsMustBeSpacedCorrectly, new object[0]);
break;
}
}
}
private void CheckSpacing(DocumentRoot root, MasterList<CsToken> tokens, bool type)
{
if (tokens.Count > 0)
{
for (Node<CsToken> node = tokens.First; node != null; node = node.Next)
{
OperatorSymbol symbol;
CsTokenClass class2;
if (base.Cancel)
{
return;
}
if (node.Value.Generated)
{
goto Label_049F;
}
switch (node.Value.CsTokenType)
{
case CsTokenType.OpenParenthesis:
this.CheckOpenParen(root, tokens, node);
goto Label_043E;
case CsTokenType.CloseParenthesis:
this.CheckCloseParen(root, tokens, node);
goto Label_043E;
case CsTokenType.OpenCurlyBracket:
this.CheckOpenCurlyBracket(root, tokens, node);
goto Label_043E;
case CsTokenType.CloseCurlyBracket:
this.CheckCloseCurlyBracket(root, tokens, node);
goto Label_043E;
case CsTokenType.OpenSquareBracket:
this.CheckOpenSquareBracket(root, node);
goto Label_043E;
case CsTokenType.CloseSquareBracket:
this.CheckCloseSquareBracket(root, tokens, node);
goto Label_043E;
case CsTokenType.OperatorSymbol:
symbol = node.Value as OperatorSymbol;
switch (symbol.Category)
{
case OperatorCategory.Relational:
case OperatorCategory.Logical:
case OperatorCategory.Assignment:
case OperatorCategory.Arithmetic:
case OperatorCategory.Shift:
case OperatorCategory.Conditional:
case OperatorCategory.Lambda:
goto Label_03F7;
case OperatorCategory.IncrementDecrement:
goto Label_0402;
case OperatorCategory.Unary:
goto Label_040C;
}
goto Label_043E;
case CsTokenType.BaseColon:
case CsTokenType.WhereColon:
this.CheckSymbol(root, tokens, node);
goto Label_043E;
case CsTokenType.AttributeColon:
case CsTokenType.LabelColon:
this.CheckLabelColon(root, node);
goto Label_043E;
case CsTokenType.Comma:
case CsTokenType.Semicolon:
this.CheckSemicolonAndComma(root, node);
goto Label_043E;
case CsTokenType.NullableTypeSymbol:
this.CheckNullableTypeSymbol(root, node);
goto Label_043E;
case CsTokenType.Catch:
case CsTokenType.Fixed:
case CsTokenType.For:
case CsTokenType.Foreach:
case CsTokenType.From:
case CsTokenType.Group:
case CsTokenType.If:
case CsTokenType.In:
case CsTokenType.Into:
case CsTokenType.Join:
case CsTokenType.Let:
case CsTokenType.Lock:
case CsTokenType.OrderBy:
case CsTokenType.Return:
case CsTokenType.Select:
case CsTokenType.Stackalloc:
case CsTokenType.Switch:
case CsTokenType.Throw:
case CsTokenType.Using:
case CsTokenType.Where:
case CsTokenType.While:
case CsTokenType.WhileDo:
case CsTokenType.Yield:
this.CheckKeywordWithSpace(root, node);
goto Label_043E;
case CsTokenType.Checked:
case CsTokenType.DefaultValue:
case CsTokenType.Sizeof:
case CsTokenType.Typeof:
case CsTokenType.Unchecked:
this.CheckKeywordWithoutSpace(root, tokens, node);
goto Label_043E;
case CsTokenType.New:
this.CheckNewKeywordSpacing(root, tokens, node);
goto Label_043E;
case CsTokenType.Operator:
this.CheckOperatorKeyword(root, node);
goto Label_043E;
case CsTokenType.WhiteSpace:
this.CheckWhitespace(root, node);
goto Label_043E;
case CsTokenType.SingleLineComment:
this.CheckTabsInComment(root, node.Value);
this.CheckSingleLineComment(root, tokens, node);
goto Label_043E;
case CsTokenType.MultiLineComment:
this.CheckTabsInComment(root, node.Value);
goto Label_043E;
case CsTokenType.PreprocessorDirective:
this.CheckPreprocessorSpacing(root, node.Value as Preprocessor);
goto Label_043E;
case CsTokenType.Attribute:
{
Microsoft.StyleCop.CSharp.Attribute attribute = node.Value as Microsoft.StyleCop.CSharp.Attribute;
this.CheckSpacing(root, attribute.ChildTokens, false);
goto Label_043E;
}
case CsTokenType.OpenAttributeBracket:
this.CheckAttributeTokenOpenBracket(root, node);
goto Label_043E;
case CsTokenType.CloseAttributeBracket:
this.CheckAttributeTokenCloseBracket(root, node);
goto Label_043E;
case CsTokenType.XmlHeader:
{
XmlHeader header = (XmlHeader) node.Value;
this.CheckXmlHeaderComment(root, header);
for (Node<CsToken> node2 = header.ChildTokens.First; node2 != null; node2 = node2.Next)
{
this.CheckTabsInComment(root, node2.Value);
}
goto Label_043E;
}
default:
goto Label_043E;
}
Label_03F7:
this.CheckSymbol(root, tokens, node);
goto Label_043E;
Label_0402:
this.CheckIncrementDecrement(root, node);
goto Label_043E;
Label_040C:
if (symbol.SymbolType == OperatorType.Negative)
{
this.CheckNegativeSign(root, node);
}
else if (symbol.SymbolType == OperatorType.Positive)
{
this.CheckPositiveSign(root, node);
}
else
{
this.CheckUnarySymbol(root, node);
}
Label_043E:
class2 = node.Value.CsTokenClass;
if (class2 != CsTokenClass.GenericType)
{
if (class2 == CsTokenClass.Type)
{
goto Label_0487;
}
if (class2 == CsTokenClass.ConstructorConstraint)
{
this.CheckSpacing(root, ((ConstructorConstraint) node.Value).ChildTokens, false);
}
goto Label_049F;
}
this.CheckGenericSpacing(root, node.Value as GenericType);
Label_0487:
this.CheckSpacing(root, ((TypeToken) node.Value).ChildTokens, true);
Label_049F:;
}
}
}
private void CheckNewKeywordSpacing(DocumentRoot root, MasterList<CsToken> tokens, Node<CsToken> tokenNode)
{
Node<CsToken> next = tokenNode.Next;
if (next != null)
{
if ((next.Value.CsTokenType == CsTokenType.WhiteSpace) || (next.Value.CsTokenType == CsTokenType.EndOfLine))
{
foreach (CsToken token in tokens.ForwardIterator(next.Next))
{
if (token.CsTokenType == CsTokenType.OpenSquareBracket)
{
base.AddViolation(root, tokenNode.Value.LineNumber, Microsoft.StyleCop.CSharp.Rules.CodeMustNotContainSpaceAfterNewKeywordInImplicitlyTypedArrayAllocation, new object[0]);
break;
}
if ((token.CsTokenType != CsTokenType.WhiteSpace) && (token.CsTokenType != CsTokenType.EndOfLine))
{
break;
}
}
}
else if (next.Value.CsTokenType != CsTokenType.OpenSquareBracket)
{
base.AddViolation(root, tokenNode.Value.LineNumber, Microsoft.StyleCop.CSharp.Rules.KeywordsMustBeSpacedCorrectly, new object[] { tokenNode.Value.Text });
}
}
}
/// <summary>
/// Checks a close bracket for spacing.
/// </summary>
/// <param name="tokens">
/// The list of tokens being parsed.
/// </param>
/// <param name="tokenNode">
/// The token to check.
/// </param>
private void CheckCloseCurlyBracket(MasterList<CsToken> tokens, Node<CsToken> tokenNode)
{
Param.AssertNotNull(tokens, "tokens");
Param.AssertNotNull(tokenNode, "tokenNode");
// Close curly brackets should always be preceded by whitespace.
Node<CsToken> previousNode = tokenNode.Previous;
if (previousNode != null && previousNode.Value.CsTokenType != CsTokenType.WhiteSpace && previousNode.Value.CsTokenType != CsTokenType.EndOfLine)
{
this.AddViolation(tokenNode.Value.FindParentElement(), tokenNode.Value.Location, Rules.ClosingCurlyBracketsMustBeSpacedCorrectly);
}
// Close curly brackets should be followed either by:
// whitespace
// a close paren
// a dot,
// a semicolon
// open square bracket
// or a comma.
Node<CsToken> nextNode = tokenNode.Next;
if (nextNode != null)
{
CsTokenType nextType = nextNode.Value.CsTokenType;
if (nextType != CsTokenType.WhiteSpace && nextType != CsTokenType.EndOfLine && nextType != CsTokenType.CloseParenthesis && !IsTokenADot(nextNode.Value)
&& nextType != CsTokenType.Semicolon && nextType != CsTokenType.OpenSquareBracket && nextType != CsTokenType.Comma)
{
this.AddViolation(tokenNode.Value.FindParentElement(), tokenNode.Value.Location, Rules.ClosingCurlyBracketsMustBeSpacedCorrectly);
}
if (nextType == CsTokenType.WhiteSpace)
{
// If this is followed by whitespace, make sure that the character just
// after the whitespace is not a close paren, semicolon, comma or dot.
foreach (CsToken item in tokens.ForwardIterator(tokenNode.Next.Next))
{
CsTokenType itemType = item.CsTokenType;
if (itemType == CsTokenType.CloseParenthesis || itemType == CsTokenType.Semicolon || itemType == CsTokenType.Comma || IsTokenADot(item))
{
this.AddViolation(tokenNode.Value.FindParentElement(), tokenNode.Value.Location, Rules.ClosingCurlyBracketsMustBeSpacedCorrectly);
}
else if (itemType != CsTokenType.WhiteSpace)
{
break;
}
}
}
}
}
private void CheckOpenParen(DocumentRoot root, MasterList<CsToken> tokens, Node<CsToken> tokenNode)
{
Node<CsToken> node2;
bool flag = false;
bool flag2 = false;
Node<CsToken> previous = tokenNode.Previous;
if ((previous != null) && (previous.Value.CsTokenType == CsTokenType.WhiteSpace))
{
foreach (CsToken token in tokens.ReverseIterator(previous))
{
switch (token.CsTokenType)
{
case CsTokenType.WhiteSpace:
{
continue;
}
case CsTokenType.EndOfLine:
flag = true;
goto Label_017C;
case CsTokenType.Case:
case CsTokenType.Catch:
case CsTokenType.CloseSquareBracket:
case CsTokenType.Comma:
case CsTokenType.Equals:
case CsTokenType.Fixed:
case CsTokenType.For:
case CsTokenType.Foreach:
case CsTokenType.From:
case CsTokenType.Group:
case CsTokenType.If:
case CsTokenType.In:
case CsTokenType.Into:
case CsTokenType.Join:
case CsTokenType.Let:
case CsTokenType.Lock:
case CsTokenType.MultiLineComment:
case CsTokenType.Number:
case CsTokenType.OperatorSymbol:
case CsTokenType.OpenCurlyBracket:
case CsTokenType.OrderBy:
case CsTokenType.Return:
case CsTokenType.Select:
case CsTokenType.Semicolon:
case CsTokenType.Switch:
case CsTokenType.Throw:
case CsTokenType.Using:
case CsTokenType.Where:
case CsTokenType.While:
case CsTokenType.WhileDo:
case CsTokenType.Yield:
goto Label_017C;
}
base.AddViolation(root, tokenNode.Value.LineNumber, Microsoft.StyleCop.CSharp.Rules.OpeningParenthesisMustBeSpacedCorrectly, new object[0]);
}
}
Label_017C:
node2 = tokenNode.Next;
if ((node2 != null) && ((node2.Value.CsTokenType == CsTokenType.WhiteSpace) || (node2.Value.CsTokenType == CsTokenType.EndOfLine)))
{
foreach (CsToken token2 in tokens.ForwardIterator(node2))
{
CsTokenType csTokenType = token2.CsTokenType;
if (csTokenType == CsTokenType.EndOfLine)
{
flag2 = true;
break;
}
if (((csTokenType != CsTokenType.WhiteSpace) && (csTokenType != CsTokenType.SingleLineComment)) && (csTokenType != CsTokenType.MultiLineComment))
{
base.AddViolation(root, tokenNode.Value.LineNumber, Microsoft.StyleCop.CSharp.Rules.OpeningParenthesisMustBeSpacedCorrectly, new object[0]);
break;
}
}
}
if (flag && flag2)
{
base.AddViolation(root, tokenNode.Value.LineNumber, Microsoft.StyleCop.CSharp.Rules.OpeningParenthesisMustBeSpacedCorrectly, new object[0]);
}
}
private void CheckCloseParen(MasterList<CsToken> tokens, Node<CsToken> tokenNode)
{
Param.AssertNotNull(tokens, "tokens");
Param.AssertNotNull(tokenNode, "tokenNode");
// Close parens should never be preceded by whitespace.
Node<CsToken> previousNode = tokenNode.Previous;
if (previousNode != null)
{
if (previousNode.Value.CsTokenType == CsTokenType.WhiteSpace
|| (previousNode.Value.CsTokenType == CsTokenType.EndOfLine && previousNode.Previous.Value.CsTokenType != CsTokenType.SingleLineComment))
{
this.AddViolation(tokenNode.Value.FindParentElement(), previousNode.Value.Location, Rules.ClosingParenthesisMustBeSpacedCorrectly);
}
}
// Find out what comes after the closing paren.
Node<CsToken> nextNode = tokenNode.Next;
if (nextNode != null)
{
CsTokenType nextType = nextNode.Value.CsTokenType;
CsTokenType nextNextType = nextNode.Next == null ? CsTokenType.Other : nextNode.Next.Value.CsTokenType;
if (tokenNode.Value.Parent is CastExpression)
{
// There should not be any whitespace after the closing parenthesis in a cast expression.
if (nextType == CsTokenType.WhiteSpace)
{
this.AddViolation(tokenNode.Value.FindParentElement(), nextNode.Value.Location, Rules.ClosingParenthesisMustBeSpacedCorrectly);
}
}
else if (nextType == CsTokenType.LabelColon || nextNextType == CsTokenType.LabelColon)
{
// If the next token is a colon, it's allowed to omit the whitespace only if we are in a switch\case statement.
bool followsCase = false;
foreach (CsToken item in tokens.ReverseIterator(tokenNode.Previous))
{
CsTokenType itemType = item.CsTokenType;
if (itemType == CsTokenType.EndOfLine)
{
break;
}
else if (itemType == CsTokenType.Case)
{
followsCase = true;
break;
}
}
if ((followsCase && nextType == CsTokenType.WhiteSpace) || (!followsCase && nextType != CsTokenType.WhiteSpace))
{
this.AddViolation(tokenNode.Value.FindParentElement(), nextNode.Value.Location, Rules.ClosingParenthesisMustBeSpacedCorrectly);
}
}
else if (nextType == CsTokenType.WhiteSpace)
{
// Make sure that the character just after the whitespace is not a paren, bracket, a comma, or a semicolon.
foreach (CsToken item in tokens.ForwardIterator(tokenNode.Next.Next))
{
if (IsAllowedAfterClosingParenthesis(item))
{
this.AddViolation(tokenNode.Value.FindParentElement(), nextNode.Value.Location, Rules.ClosingParenthesisMustBeSpacedCorrectly);
}
else if (item.CsTokenType != CsTokenType.WhiteSpace)
{
break;
}
}
}
else
{
// For all other types, the parenthesis must be followed by whitespace, unless the next character is a paren, bracket, comma, or a semicolon.
if (nextNode.Value.CsTokenType != CsTokenType.EndOfLine && !IsAllowedAfterClosingParenthesis(nextNode.Value))
{
this.AddViolation(tokenNode.Value.FindParentElement(), nextNode.Value.Location, Rules.ClosingParenthesisMustBeSpacedCorrectly);
}
}
}
}
private void CheckSingleLineComment(DocumentRoot root, MasterList<CsToken> tokens, Node<CsToken> tokenNode)
{
if (tokenNode.Value.Text.Length > 2)
{
string text = tokenNode.Value.Text;
if ((((text[2] != ' ') && (text[2] != '\t')) && ((text[2] != '/') && (text[2] != '\\'))) && (((text[1] != '\n') && (text[1] != '\r')) && (((text.Length < 4) || (text[2] != '-')) || (text[3] != '-'))))
{
base.AddViolation(root, tokenNode.Value.LineNumber, Microsoft.StyleCop.CSharp.Rules.SingleLineCommentsMustBeginWithSingleSpace, new object[0]);
}
else if (((text.Length > 3) && ((text[3] == ' ') || (text[3] == '\t'))) && (text[2] != '\\'))
{
bool flag = true;
int num = 0;
foreach (CsToken token in tokens.ReverseIterator(tokenNode.Previous))
{
if (token.CsTokenType == CsTokenType.EndOfLine)
{
if (++num != 2)
{
continue;
}
break;
}
if (token.CsTokenType == CsTokenType.SingleLineComment)
{
flag = false;
break;
}
if (token.CsTokenType != CsTokenType.WhiteSpace)
{
break;
}
}
if (flag)
{
base.AddViolation(root, tokenNode.Value.LineNumber, Microsoft.StyleCop.CSharp.Rules.SingleLineCommentsMustBeginWithSingleSpace, new object[0]);
}
}
}
}
private void CheckSpacing(MasterList<CsToken> tokens, bool type, Node<CsToken> parentTokenNode)
{
Param.AssertNotNull(tokens, "tokens");
Param.Ignore(type);
// Make sure it contains at least one token.
if (tokens.Count > 0)
{
for (Node<CsToken> tokenNode = tokens.First; tokenNode != null; tokenNode = tokenNode.Next)
{
if (this.Cancel)
{
break;
}
if (!tokenNode.Value.Generated)
{
switch (tokenNode.Value.CsTokenType)
{
case CsTokenType.Async:
case CsTokenType.By:
case CsTokenType.Catch:
case CsTokenType.Equals:
case CsTokenType.Fixed:
case CsTokenType.For:
case CsTokenType.Foreach:
case CsTokenType.From:
case CsTokenType.Group:
case CsTokenType.If:
case CsTokenType.In:
case CsTokenType.Into:
case CsTokenType.Join:
case CsTokenType.Let:
case CsTokenType.Lock:
case CsTokenType.On:
case CsTokenType.OrderBy:
case CsTokenType.Return:
case CsTokenType.Select:
case CsTokenType.Stackalloc:
case CsTokenType.Switch:
case CsTokenType.Throw:
case CsTokenType.Using:
case CsTokenType.Where:
case CsTokenType.While:
case CsTokenType.WhileDo:
case CsTokenType.Yield:
// These keywords must be followed by a space before the open parenthesis.
this.CheckKeywordWithSpace(tokenNode);
break;
case CsTokenType.New:
this.CheckNewKeywordSpacing(tokens, tokenNode);
break;
case CsTokenType.Checked:
case CsTokenType.Unchecked:
case CsTokenType.Sizeof:
case CsTokenType.Typeof:
case CsTokenType.DefaultValue:
// These keywords must not contain any space before the open parenthesis.
this.CheckKeywordWithoutSpace(tokens, tokenNode);
break;
case CsTokenType.Comma:
case CsTokenType.Semicolon:
this.CheckSemicolonAndComma(tokens, tokenNode);
break;
case CsTokenType.OpenParenthesis:
this.CheckOpenParen(tokens, tokenNode);
break;
case CsTokenType.CloseParenthesis:
this.CheckCloseParen(tokens, tokenNode);
break;
case CsTokenType.OpenSquareBracket:
this.CheckOpenSquareBracket(tokenNode);
break;
case CsTokenType.CloseSquareBracket:
this.CheckCloseSquareBracket(tokens, tokenNode, parentTokenNode);
break;
case CsTokenType.OpenCurlyBracket:
this.CheckOpenCurlyBracket(tokens, tokenNode);
break;
case CsTokenType.CloseCurlyBracket:
this.CheckCloseCurlyBracket(tokens, tokenNode);
break;
case CsTokenType.OpenAttributeBracket:
this.CheckAttributeTokenOpenBracket(tokenNode);
break;
case CsTokenType.CloseAttributeBracket:
this.CheckAttributeTokenCloseBracket(tokens, tokenNode);
break;
case CsTokenType.BaseColon:
case CsTokenType.WhereColon:
this.CheckSymbol(tokens, tokenNode);
break;
case CsTokenType.AttributeColon:
case CsTokenType.LabelColon:
this.CheckLabelColon(tokenNode);
break;
case CsTokenType.WhiteSpace:
this.CheckWhitespace(tokenNode);
break;
case CsTokenType.XmlHeader:
XmlHeader header = (XmlHeader)tokenNode.Value;
this.CheckXmlHeaderComment(header);
// Look for tabs in the xml header string. Look at
// each sub-token in the header individually to get the
// line numbers correct.
for (Node<CsToken> xmlHeaderToken = header.ChildTokens.First; xmlHeaderToken != null; xmlHeaderToken = xmlHeaderToken.Next)
{
this.CheckTabsInComment(xmlHeaderToken.Value);
}
break;
case CsTokenType.Attribute:
Attribute attribute = tokenNode.Value as StyleCop.CSharp.Attribute;
this.CheckSpacing(attribute.ChildTokens, false, tokenNode);
break;
case CsTokenType.PreprocessorDirective:
this.CheckPreprocessorSpacing(tokenNode.Value as Preprocessor);
break;
case CsTokenType.SingleLineComment:
// Look for tabs in the comment string.
this.CheckTabsInComment(tokenNode.Value);
// Check spacing in the comment.
this.CheckSingleLineComment(tokens, tokenNode);
break;
case CsTokenType.MultiLineComment:
// Look for tabs in the comment string.
this.CheckTabsInComment(tokenNode.Value);
break;
case CsTokenType.NullableTypeSymbol:
this.CheckNullableTypeSymbol(tokenNode);
break;
case CsTokenType.Operator:
this.CheckOperatorKeyword(tokenNode);
break;
case CsTokenType.OperatorSymbol:
OperatorSymbol operatorSymbol = tokenNode.Value as OperatorSymbol;
switch (operatorSymbol.Category)
{
case OperatorCategory.Reference:
switch (operatorSymbol.SymbolType)
{
case OperatorType.QualifiedAlias:
case OperatorType.Pointer:
case OperatorType.MemberAccess:
this.CheckMemberAccessSymbol(tokens, tokenNode);
break;
case OperatorType.AddressOf:
case OperatorType.Dereference:
this.CheckUnsafeAccessSymbols(tokenNode, type, parentTokenNode);
break;
default:
Debug.Fail("Unexpected operator category.");
break;
}
break;
case OperatorCategory.Arithmetic:
case OperatorCategory.Assignment:
case OperatorCategory.Conditional:
case OperatorCategory.Logical:
case OperatorCategory.Relational:
case OperatorCategory.Shift:
case OperatorCategory.Lambda:
// Symbols should have whitespace on both sides except null conditional '?.'
this.CheckSymbol(tokens, tokenNode);
break;
case OperatorCategory.IncrementDecrement:
this.CheckIncrementDecrement(tokenNode);
break;
case OperatorCategory.Unary:
if (operatorSymbol.SymbolType == OperatorType.Negative)
{
this.CheckPositiveOrNegativeSign(tokenNode, false);
}
else if (operatorSymbol.SymbolType == OperatorType.Positive)
{
this.CheckPositiveOrNegativeSign(tokenNode, true);
}
else
{
this.CheckUnarySymbol(tokens, tokenNode);
}
break;
}
break;
}
switch (tokenNode.Value.CsTokenClass)
{
case CsTokenClass.ConstructorConstraint:
this.CheckSpacing(((ConstructorConstraint)tokenNode.Value).ChildTokens, false, tokenNode);
break;
case CsTokenClass.GenericType:
this.CheckGenericSpacing(tokens, tokenNode);
goto case CsTokenClass.Type;
case CsTokenClass.Type:
this.CheckSpacing(((TypeToken)tokenNode.Value).ChildTokens, true, tokenNode);
break;
}
}
}
}
}
/// <summary>
/// Checks the spacing around a 'new' keyword.
/// </summary>
/// <param name="tokens">
/// The token list.
/// </param>
/// <param name="tokenNode">
/// The token node to check.
/// </param>
private void CheckNewKeywordSpacing(MasterList<CsToken> tokens, Node<CsToken> tokenNode)
{
Param.AssertNotNull(tokens, "tokens");
Param.AssertNotNull(tokenNode, "tokenNode");
// The keywords must be followed by a space, unless the next token is an opening square bracket, in which case
// there should be no space.
Node<CsToken> temp = tokenNode.Next;
if (temp != null)
{
if (temp.Value.CsTokenType == CsTokenType.WhiteSpace || temp.Value.CsTokenType == CsTokenType.EndOfLine)
{
// The keyword is followed by whitespace. Make sure the next non-whitespace character is not an opening bracket.
foreach (CsToken nextNonWhitespaceToken in tokens.ForwardIterator(temp.Next))
{
if (nextNonWhitespaceToken.CsTokenType == CsTokenType.OpenSquareBracket)
{
this.AddViolation(
tokenNode.Value.FindParentElement(),
tokenNode.Value.Location,
Rules.CodeMustNotContainSpaceAfterNewKeywordInImplicitlyTypedArrayAllocation);
break;
}
else if (nextNonWhitespaceToken.CsTokenType != CsTokenType.WhiteSpace && nextNonWhitespaceToken.CsTokenType != CsTokenType.EndOfLine)
{
break;
}
}
}
else if (temp.Value.CsTokenType != CsTokenType.OpenSquareBracket)
{
// The keyword is not followed by whitespace.
this.AddViolation(tokenNode.Value.FindParentElement(), tokenNode.Value.Location, Rules.KeywordsMustBeSpacedCorrectly, tokenNode.Value.Text);
}
}
}
/// <summary>
/// Checks a symbol for spacing.
/// </summary>
/// <param name="tokens">
/// The list of tokens being parsed.
/// </param>
/// <param name="tokenNode">
/// The token to check.
/// </param>
private void CheckSymbol(MasterList<CsToken> tokens, Node<CsToken> tokenNode)
{
Param.AssertNotNull(tokens, "tokens");
Param.AssertNotNull(tokenNode, "tokenNode");
OperatorSymbol operatorSymbol = tokenNode.Value as OperatorSymbol;
if (operatorSymbol != null && operatorSymbol.SymbolType == OperatorType.NullConditional)
{
// Symbols should not have whitespace on both sides for operator '?.'.
Node<CsToken> previousNode = tokenNode.Previous;
if (previousNode != null && previousNode.Value.CsTokenType == CsTokenType.WhiteSpace && previousNode.Value.CsTokenType != CsTokenType.EndOfLine)
{
this.AddViolation(tokenNode.Value.FindParentElement(), tokenNode.Value.Location, Rules.SymbolsMustBeSpacedCorrectly, tokenNode.Value.Text);
}
Node<CsToken> nextNode = tokenNode.Next;
if (nextNode != null && nextNode.Value.CsTokenType == CsTokenType.WhiteSpace && nextNode.Value.CsTokenType != CsTokenType.EndOfLine)
{
this.AddViolation(tokenNode.Value.FindParentElement(), tokenNode.Value.Location, Rules.SymbolsMustBeSpacedCorrectly, tokenNode.Value.Text);
}
if (operatorSymbol.Text.Length > 2 || operatorSymbol.Text.Contains("\r") || operatorSymbol.Text.Contains("\n") || operatorSymbol.Text.Contains(" "))
{
this.AddViolation(tokenNode.Value.FindParentElement(), tokenNode.Value.Location, Rules.DoNotSplitNullConditionalOperators, tokenNode.Value.Text);
}
}
else
{
// Symbols should have whitespace on both sides.
Node<CsToken> previousNode = tokenNode.Previous;
if (previousNode != null && previousNode.Value.CsTokenType != CsTokenType.WhiteSpace && previousNode.Value.CsTokenType != CsTokenType.EndOfLine)
{
this.AddViolation(tokenNode.Value.FindParentElement(), tokenNode.Value.Location, Rules.SymbolsMustBeSpacedCorrectly, tokenNode.Value.Text);
}
Node<CsToken> nextNode = tokenNode.Next;
if (nextNode != null && nextNode.Value.CsTokenType != CsTokenType.WhiteSpace && nextNode.Value.CsTokenType != CsTokenType.EndOfLine)
{
// Make sure the previous token is not operator.
if (previousNode != null)
{
foreach (CsToken item in tokens.ReverseIterator(previousNode))
{
if (item.CsTokenType == CsTokenType.Operator)
{
return;
}
else if (item.CsTokenType != CsTokenType.WhiteSpace && item.CsTokenType != CsTokenType.EndOfLine
&& item.CsTokenType != CsTokenType.SingleLineComment && item.CsTokenType != CsTokenType.MultiLineComment
&& item.CsTokenType != CsTokenType.PreprocessorDirective)
{
break;
}
}
}
this.AddViolation(tokenNode.Value.FindParentElement(), tokenNode.Value.LineNumber, Rules.SymbolsMustBeSpacedCorrectly, tokenNode.Value.Text);
}
}
}
