public string visitOperandExpr(Expression.Operand expr)
{
switch (expr.Value.GetName())
{
case "UNARY":
case "BINARY":
return(((Expression)expr.Value).Accept(this));
case "INTEGER":
return("int");
case "STRING":
return("string");
case "VAR_IDENTIFIER":
var ident = (VarIdentifier)expr.Value;
if (!environment.Contains(ident.Name))
{
ErrorWriter.Write(ident, "Cannot operate on uninitalized variable '{0}'", ident.Name);
return(null);
}
return(environment.GetType(ident.Name));
default:
return(null);
}
}
public string visitBinaryExpr(Expression.Binary expr)
{
var firstType = expr.First.Accept(this);
var secondType = expr.Second.Accept(this);
if (firstType == null || secondType == null)
{
return(null);
}
if (firstType != secondType)
{
ErrorWriter.Write(expr.First, "Cannot operate with {0} and {1}", firstType, secondType);
return(null);
}
// TODO use eval to get types?
var type = expr.Operator.Type;
if (
(type == TokenType.EQUAL ||
type == TokenType.AND ||
type == TokenType.NOT))
{
return("bool");
}
return(expr.First.Accept(this));
}
public bool visitAssignmentStmt(Statement.Assignment stmt)
{
var identifier = stmt.Identifier;
if (!environment.Contains(identifier.Name))
{
ErrorWriter.Write(identifier, "Cannot assign to uninitialized variable '{0}'", identifier.Name);
return(false);
}
var variableType = environment.GetType(identifier.Name);
var initializerType = stmt.Value.Accept(expressionAnalyzer);
if (initializerType == null)
{
return(false);
}
if (initializerType != variableType)
{
ErrorWriter.Write(stmt.Value, "Cannot assign value of type {2} to variable {0} of type {1}", identifier.Name, variableType, initializerType);
return(false);
}
if (environment.isLocked(identifier.Name))
{
ErrorWriter.Write(stmt.Value, "Cannot reassign loop variable {0} during loop", identifier.Name);
return(false);
}
return(true);
}
public bool visitDeclarementStmt(Statement.Declarement stmt)
{
var identifier = stmt.Identifier;
var initializer = stmt.Initializer;
var type = stmt.Type;
var valid = true;
if (environment.Contains(identifier.Name))
{
ErrorWriter.Write(identifier, "Cannot initialize variable '{0}' twice", identifier.Name);
valid = false;
}
if (initializer == null)
{
environment.Declare(identifier.Name, type);
return(valid);
}
var initializerType = initializer.Accept(expressionAnalyzer);
if (initializerType == null)
{
valid = false;
}
else if (initializerType != type)
{
ErrorWriter.Write(stmt.Initializer, "Cannot initialize variable '{0}' of type {1} to type {2}", identifier.Name, type, initializerType);
valid = false;
}
environment.Declare(identifier.Name, type);
return(valid);
}
public bool visitAssertStmt(Statement.Assert stmt)
{
if (stmt.Expression.Accept(expressionAnalyzer) != "bool")
{
ErrorWriter.Write(stmt.Expression, "Cannot assert non-boolean expression");
return(false);
}
return(true);
}
/// <summary>
/// GetRss
/// </summary>
/// <returns></returns>
private static bool GetRss()
{
try
{
#region インスタンス等設定
var req = WebRequest.Create(Constants.RssURL)
as HttpWebRequest;
req.UserAgent = Constants.UserAgent;
req.Accept = Constants.Accept;
req.CookieContainer = new CookieContainer();
req.CookieContainer
.Add((new CookieContainer())
.GetCookies(req.RequestUri));
#endregion
#region 取得し、ファイルに仮保存する
using (var res = (HttpWebResponse)req.GetResponse())
using (var resSt = res.GetResponseStream())
using (var sr = new StreamReader(resSt, Encoding.UTF8))
{
if (File.Exists(Constants.WorkRssFileName) == false)
{
try
{
File.AppendAllText(
path: Constants.WorkRssFileName,
contents: sr.ReadToEnd(),
encoding: Encoding.UTF8);
}
catch (Exception ex)
{
var ew = new ErrorWriter();
ew.Write(ex);
ew.Message();
}
}
}
#endregion
req = null;
return(true);
}
catch (Exception ex)
{
var ew = new ErrorWriter();
ew.Write(ex);
ew.Message();
return(false);
}
}
public bool visitReadStmt(Statement.Read stmt)
{
if (environment.Contains(stmt.Target.Name))
{
return(true);
}
else
{
ErrorWriter.Write(stmt.Target, "Cannot read to uninitialized variable {0}", stmt.Target.Name);
return(false);
}
}
public void Error(String contents, params object[] args)
{
if (enableLevel > 0)
{
return;
}
errorCount++;
ErrorWriter.Write("compiler error: ");
ErrorWriter.WriteLine(contents, args);
}
/// <summary>
/// btnDetail_Click
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btnDetail_Click(object sender, RoutedEventArgs e)
{
try
{
int count = int.Parse(Convert.ToString(((Button)sender).Tag));
var row = dataSource[count];
System.Diagnostics.Process.Start(@"chrome.exe", row.Link);
}
catch (Exception ex)
{
var ew = new ErrorWriter();
ew.Write(ex);
ew.Message();
}
}
public bool visitForStmt(Statement.For stmt)
{
var identifier = stmt.Identifier;
if (!environment.Contains(identifier.Name))
{
ErrorWriter.Write(identifier, "Usage of uninitialized variable '{0}'", identifier.Name);
return(false);
}
if (environment.GetType(identifier.Name) != "int")
{
ErrorWriter.Write(identifier, "Loop variable '{0}' must be of type 'int'", identifier.Name);
return(false);
}
var startType = stmt.RangeStart.Accept(expressionAnalyzer);
if (startType != "int")
{
ErrorWriter.Write(stmt.RangeStart, "Range start must be a number");
return(false);
}
var endType = stmt.RangeEnd.Accept(expressionAnalyzer);
if (endType != "int")
{
ErrorWriter.Write(stmt.RangeEnd, "Range end must be a number");
return(false);
}
var valid = true;
// lock the variable so it can't be modified during the loop
environment.setLock(identifier.Name, true);
foreach (var statement in stmt.Block)
{
valid = statement.Accept(this) && valid;
}
environment.setLock(identifier.Name, false);
return(valid);
}
public void Error(String filename, LexicalPosition pos, String contents, params object[] args)
{
if (enableLevel > 0)
{
return;
}
errorCount++;
if (pos.Column == 0)
{
ErrorWriter.Write("{0}:{1}\terror: ", filename, pos.Line);
}
else
{
ErrorWriter.Write("{0}:{1},{2}\terror: ", filename, pos.Line, pos.Column);
}
ErrorWriter.WriteLine(contents, args);
}
public static int Main(string[] args)
{
try
{
// usage: dotnet run # in production no param is required
// usage: dotnet run [/myProjects/exercism/v3]
if (args.Length > 0)
{
Directory.SetCurrentDirectory(args[0]);
// e.g. /Users/mikedamay/projects/exercism/v3
}
var comparer = ExerciseComparer.CSharpComparer;
var errorWriter = new ErrorWriter(
new ValidationErrorFileHandler(PathNames.Default.Root, Constants.CSharpTrack),
new ErrorJsonParser());;
var reporter = new ReportWriter(new ReportFileHandler(PathNames.Default.Root, Constants.CSharpTrack),
new ReportFormatter());
var compareResults = comparer.CompareExercises();
errorWriter.Write(compareResults.Errors);
if (compareResults.Result == Result.FatalError)
{
throw new Exception("Failed to produce report: " + compareResults.Errors[^ 1].Message);
private void runtimeError(Symbol context, string template, params object[] args)
{
ErrorWriter.Write(context, template, args);
throw new Exception();
}
/// <summary>
/// UpdateRssData
/// <para>This method Update XMLData.</para>
/// <para>UserAgentを指定し、確実に情報を取得する</para>
/// </summary>
/// <returns></returns>
private bool UpdateRssData()
{
#region Get Rss
if (GetRss() == false)
{
return(false);
}
#endregion Get Rss
#region 本番データが無い場合、最も高い可能性は初回の実行と推測される
if (File.Exists(Constants.RssFileName) == false)
{
try
{
File.Move(Constants.WorkRssFileName, Constants.RssFileName);
}
catch (Exception ex)
{
var ew = new ErrorWriter();
ew.Write(ex);
ew.Message();
return(false);
}
return(true);
}
#endregion 本番データが無い場合で最も高い可能性は初回の実行と推測される
#region Check&Save
try
{
#region Load及びItem取得
var workData
= XElement.Load(Constants.WorkRssFileName);
var workElementChannel
= workData.Element(Constants.RssElementChannel);
var originData
= XElement.Load(Constants.RssFileName);
var originElementChannel
= originData.Element(Constants.RssElementChannel);
#endregion Load及びItem取得
#region 最新日比較
//仮じゃないファイル最新Itemの日付と、仮ファイルの最新日を見ていく。
var workDataItems = workElementChannel
.Elements(Constants.RssElementItem)
.OrderBy(x =>
DateTime.Parse(x.Element(Constants.RssElementPubDate).Value.Replace(" JST", string.Empty)));
var originDataFirst = originElementChannel
.Elements(Constants.RssElementItem)
.OrderByDescending(x =>
DateTime.Parse(x.Element(Constants.RssElementPubDate).Value.Replace(" JST", string.Empty)))
.FirstOrDefault();
{
DateTime?work = null;
DateTime?origin = DateTime.Parse(originDataFirst.Element(Constants.RssElementPubDate).Value.Replace(" JST", string.Empty));
try
{
foreach (var nowItem in workDataItems)
{
work = DateTime.Parse(nowItem.Element(Constants.RssElementPubDate).Value.Replace(" JST", string.Empty));
switch (work.Value.CompareTo(origin))
{
case -1:
case 0:
default:
continue;
case 1:
originElementChannel.Add(nowItem);
break;
}
}
}
catch (Exception ex)
{
var ew = new ErrorWriter();
ew.Write(ex);
ew.Message();
}
}
#endregion 最新日比較
#region 保存と削除
originData.Save(Constants.RssFileName, SaveOptions.OmitDuplicateNamespaces);
if (File.Exists(Constants.WorkRssFileName) == true)
{
try
{
File.Delete(Constants.WorkRssFileName);
}
catch (Exception ex)
{
var ew = new ErrorWriter();
ew.Write(ex);
ew.Message();
return(false);
}
return(true);
}
#endregion 保存と削除
return(true);
}
catch (Exception ex)
{
var ew = new ErrorWriter();
ew.Write(ex);
ew.Message();
return(false);
}
#endregion Check&Save
}
/// <summary>
/// ProcessRss
/// </summary>
/// <returns></returns>
private bool CheckAndProcessRss()
{
#region ファイル存在チェック
if (File.Exists(Constants.RssFileName) == false)
{
var ew = new ErrorWriter();
ew.Write(new Exception(Constants.SystemMessageNotExistFileError));
ew.Message();
return(false);
}
#endregion
#region 数宣言&チェック
var originData
= XElement.Load(Constants.RssFileName);
var elementChannel
= originData.Element(Constants.RssElementChannel)
.Elements(Constants.RssElementItem);
#region 更新の是非チェック
//#region MyRegion
////var ptData = ((sv.Content) as DockPanel);
//if (DataSource != null)
//{
// if (DataSource.Count() != 0
// && DateTime.Parse(DataSource.FirstOrDefault().PubDate.Replace(" JST", ""))
// .CompareTo(DateTime.Parse(elementChannel
// .LastOrDefault()
// .Element(Constants.RssElementPubDate)
// .Value.Replace(" JST", ""))) != -1)
// {
// return false;
// }
//}
//#endregion
#endregion 更新の是非チェック
RssDetail work = null;
//int getAmount = DataSource == null ? Constants.DefaultRowCount
int getAmount = DataSource == null ? maxRowCount
: DataSource.Count;
DataSource = new ObservableCollection <RssDetail>();
#endregion 数宣言&チェック
#region クラス化
foreach (var item in elementChannel
.Reverse()
.Skip(nowBlock)
.Take(getAmount)
)
{
try
{
work = new RssDetail();
#region check&save
#region ID
{
{
var result = item.Element(Constants.RssElementPubDate);
if (result != null && result.IsEmpty == false)
{
DateTime id = DateTime.Parse(item.Element(Constants.RssElementPubDate).Value.Replace(" JST", string.Empty));
work.ID = string.Concat(id.Year.ToString("0000")
, id.Month.ToString("00")
, id.Day.ToString("00")
, id.Hour.ToString("00")
, id.Minute.ToString("00")
, id.Second.ToString("00"));
}
}
}
#endregion
#region Title
{
var result = item.Element(Constants.RssElementTitle);
if (result != null && result.IsEmpty == false)
{
work.Title = item.Element(Constants.RssElementTitle).Value;
}
}
#endregion
#region PubDate
{
var result = item.Element(Constants.RssElementPubDate);
if (result != null && result.IsEmpty == false)
{
work.PubDate = item.Element(Constants.RssElementPubDate).Value;
}
}
#endregion
#region categories
{
var result = item.Elements(Constants.RssElementCategories);
if (result != null && result.Count() > 0)
{
foreach (var nowCategories in result)
{
if (nowCategories.IsEmpty == false)
{
work.categories.Add(nowCategories.Value);
}
}
}
}
#endregion
#region Description
{
var result = item.Element(Constants.RssElementDescription);
if (result != null && result.IsEmpty == false)
{
work.Description = item.Element(Constants.RssElementDescription).Value;
if (this.newLine == true)
{
work.Description = work.Description
.Replace(Environment.NewLine, string.Empty)
.Replace("\r", string.Empty)
.Replace("\n", string.Empty);
}
}
}
#endregion
#region Link
{
var result = item.Element(Constants.RssElementLink);
if (result != null && result.IsEmpty == false)
{
work.Link = item.Element(Constants.RssElementLink).Value;
}
}
#endregion
#endregion check&save
DataSource.Add(work);
}
catch (Exception ex)
{
var ew = new ErrorWriter();
ew.Write(ex);
ew.Message();
}
}
#endregion クラス化
#region 成否判定
//失敗用クラスを作ってもいいかもしれない
if (DataSource == null ||
DataSource.Count == 0)
{
return(false);
}
return(true);
#endregion
}
private void announceError(Token token, string template, params object[] args)
{
ErrorWriter.Write(current, template, args);
throw new Exception();
}
private void error(string template, params object[] args)
{
ErrorWriter.Write(line, template, args);
throw new Exception();
}