/// <summary>
/// 実行処理を呼び出し，値を返します
/// </summary>
/// <param name="env">変数環境</param>
/// <returns>式の値</returns>
public ScriptVariable Calculate(ScriptExecutionEnvironment env)
{
ScriptVariable returnValue;
this.Execute(env, out returnValue);
return(returnValue);
}
public ScriptVariable Get(ScriptExecutionEnvironment environment)
{
if (_variable == null)
{
environment.Console.Warn("Cannot use indexer for null variable");
return(null);
}
if (_index == null)
{
environment.Console.Warn("Cannot use null as indexer");
return(null);
}
ListVariable list = _variable as ListVariable;
StringVariable key = _index as StringVariable;
if (list != null && key != null)
{
return(list[key.Value]);
}
int indexInt = _index.ToInteger();
ScriptVariable ret;
if (!_variable.GetIndexedValue(indexInt, out ret))
{
environment.Console.Warn(string.Format("Invalid index : {0}", _index.ToString()));
ret = null;
}
return(ret);
}
public void Set(ScriptExecutionEnvironment environment, ScriptVariable value)
{
if (_variable == null)
{
environment.Console.Warn("Cannot use index for null variable");
return;
}
if (_index == null)
{
environment.Console.Warn("Cannot use null as index");
return;
}
ListVariable list = _variable as ListVariable;
StringVariable key = _index as StringVariable;
if (list != null && key != null)
{
list[key.Value] = value;
return;
}
int indexInt = _index.ToInteger();
if (!_variable.SetIndexedValue(indexInt, value))
{
environment.Console.Warn(string.Format("Invalid index : {0}", _index.ToString()));
}
}
protected override RunControlType ExecuteInternal(ScriptExecutionEnvironment env, out ScriptVariable returnValue)
{
returnValue = null;
if (!this.Do)
{
ScriptVariable condition = this.Condition.Calculate(env);
if (condition == null || !condition.ToBoolean())
{
return(RunControlType.None);
}
}
while (true)
{
RunControlType ctrl = this.Statement.Execute(env, out returnValue);
if (ctrl == RunControlType.Break)
{
return(RunControlType.None);
}
if (ctrl == RunControlType.Return)
{
return(RunControlType.Return);
}
ScriptVariable condition = this.Condition.Calculate(env);
if (condition == null || !condition.ToBoolean())
{
return(RunControlType.None);
}
}
}
public TRunner CleanOutput()
{
ScriptExecutionEnvironment.LogTaskStarted("Cleaning solution outputs");
solution.ForEachProject(
delegate(VSProjectInfo projectInfo)
{
if (projectInfo is VSProjectWithFileInfo)
{
VSProjectWithFileInfo info = (VSProjectWithFileInfo)projectInfo;
string projectOutputPath = GetProjectOutputPath(info);
if (projectOutputPath == null)
{
return;
}
projectOutputPath = Path.Combine(info.ProjectDirectoryPath, projectOutputPath);
DeleteDirectory(projectOutputPath, false);
string projectObjPath = String.Format(
CultureInfo.InvariantCulture,
@"{0}\obj\{1}",
projectInfo.ProjectName,
buildConfiguration);
projectObjPath = Path.Combine(productRootDir, projectObjPath);
DeleteDirectory(projectObjPath, false);
}
});
ScriptExecutionEnvironment.LogTaskFinished();
return(ReturnThisTRunner());
}
protected override RunControlType ExecuteInternal(ScriptExecutionEnvironment env, out ScriptVariable returnValue)
{
if (this.Expression == null)
{
returnValue = null;
return(RunControlType.None);
}
return(this.Expression.Execute(env, out returnValue));
}
/// <summary>
/// 実行時情報を設定しつつ，実行処理を呼び出します．
/// </summary>
/// <param name="env">変数環境</param>
/// <param name="returnValue">式の戻り値</param>
/// <returns>制御情報を返します</returns>
public RunControlType Execute(ScriptExecutionEnvironment env, out ScriptVariable returnValue)
{
env.Console.PushSyntaxStack(this);
try {
return(this.ExecuteInternal(env, out returnValue));
} finally {
env.Console.PopSyntaxStack();
}
}
protected override ScriptVariable CalculateInternal(ScriptExecutionEnvironment env)
{
List <ScriptVariable> ret = new List <ScriptVariable>();
foreach (var elem in this.Elements)
{
ret.Add(elem.Calculate(env));
}
return(new ListVariable(ret));
}
protected override ScriptVariable CalculateInternal(ScriptExecutionEnvironment env)
{
ScriptVariable returnValue = null;
foreach (var expression in this.Expressions)
{
returnValue = expression.Calculate(env);
}
return(returnValue);
}
protected override ScriptVariable CalculateInternal(ScriptExecutionEnvironment env)
{
ScriptVariable returnValue = null;
foreach (var declare in this.Declarations)
{
returnValue = declare.Calculate(env);
}
return(returnValue);
}
protected override ScriptVariable CalculateInternal(ScriptExecutionEnvironment env)
{
ScriptVariable value = null;
if (this.InitialValue != null)
{
value = this.InitialValue.Calculate(env);
}
env.Variables.Declare(this.Identifier, value, this.Property);
return(value == null ? null : value.Clone());
}
protected override RunControlType ExecuteInternal(ScriptExecutionEnvironment env, out ScriptVariable returnValue)
{
if (this.ReturnValue == null)
{
returnValue = null;
}
else
{
this.ReturnValue.Execute(env, out returnValue);
}
return(this.Type);
}
public TRunner PrepareBuildDirectory()
{
ScriptExecutionEnvironment.LogTaskStarted("Preparing the build directory");
string fullBuildDir = MakePathFromRootDir(buildDir);
DeleteDirectory(fullBuildDir, false);
CreateDirectory(fullBuildDir, true);
ScriptExecutionEnvironment.LogTaskFinished();
return(ReturnThisTRunner());
}
public DetergentBuildRunner CompileSolution2(string dotNetVersion)
{
ScriptExecutionEnvironment.LogTaskStarted("Compiling the solution");
string msbuildPath = ScriptExecutionEnvironment.GetDotNetFWDir(dotNetVersion);
ProgramRunner
.AddArgument(MakePathFromRootDir(ProductId) + ".2010.sln")
.AddArgument("/p:Configuration={0}", BuildConfiguration)
.AddArgument("/consoleloggerparameters:NoSummary")
.Run(Path.Combine(msbuildPath, @"msbuild.exe"));
ScriptExecutionEnvironment.LogTaskFinished();
return(this);
}
/// <summary>
/// スクリプトを実行します
/// </summary>
/// <param name="reader">スクリプトの読み込み</param>
/// <param name="env">実行環境</param>
/// <returns></returns>
public string Execute(TextReader reader, ScriptExecutionEnvironment env)
{
try {
List <LexicalElement> tmp = _lexParser.ParseText(reader).ToList();
IList <SyntaxElement> ret = this.StartParse(tmp);
foreach (var syn in ret)
{
ScriptVariable p;
syn.Execute(env, out p);
}
return("");
} catch (ParseException ex) {
return(string.Format("{0}\r\nColumn {1} at Line {2}: {3}", ex.Message, ex.Column, ex.Line, ex.ErrorText));
}
}
public BuildRunner(string productId) : base(productId, @"logs\Flubu.Build.log", 0)
{
this.productId = productId;
productName = productId;
buildProducts = new BuildProductsRegistry <TRunner>(ReturnThisTRunner());
// add CCNet listener
string ccnetListenerFilePath = Environment.GetEnvironmentVariable("CCNetListenerFile");
if (false == String.IsNullOrEmpty(ccnetListenerFilePath))
{
ScriptExecutionEnvironment.AddLogger(new FlubuCCNetListener(
ccnetListenerFilePath));
}
}
protected override ScriptVariable CalculateInternal(ScriptExecutionEnvironment env)
{
ScriptVariable function = this.Function.Calculate(env);
if (function == null)
{
env.Console.Warn("Cannot call null as function");
return(null);
}
List <ScriptVariable> args = new List <ScriptVariable>();
foreach (var param in this.Parameters)
{
args.Add(param.Calculate(env));
}
return(function.Invoke(env, args));
}
protected override ScriptVariable CalculateInternal(ScriptExecutionEnvironment env)
{
ScriptVariable operand = this.Operand.Calculate(env);
switch (this.Operator)
{
case OperatorType.Minus:
return(new NumberVariable(-operand.ToNumber()));
case OperatorType.Plus:
return(new NumberVariable(operand.ToNumber()));
case OperatorType.Not:
return(new BooleanVariable(!operand.ToBoolean()));
}
throw new NotImplementedException(this.Operator.ToString());
}
protected override RunControlType ExecuteInternal(ScriptExecutionEnvironment env, out ScriptVariable returnValue)
{
returnValue = null;
env.Variables.EnterScope();
try {
foreach (var statement in this.Statements)
{
RunControlType ctrl = statement.Execute(env, out returnValue);
if (ctrl != RunControlType.None)
{
return(ctrl);
}
}
} finally {
env.Variables.ExitScope();
}
return(RunControlType.None);
}
public TRunner HudsonFetchBuildVersion()
{
ScriptExecutionEnvironment.LogTaskStarted("Fetching the build version");
if (IsRunningUnderHudson)
{
ScriptExecutionEnvironment.LogMessage("Running under Hudson");
string projectVersionFileName = MakePathFromRootDir(ProductId) + ".ProjectVersion.txt";
if (false == File.Exists(projectVersionFileName))
{
Fail("Project version file ('{0}') is missing.", projectVersionFileName);
}
using (Stream stream = File.Open(projectVersionFileName, FileMode.Open))
{
using (StreamReader reader = new StreamReader(stream))
{
string versionAsString = reader.ReadLine();
BuildVersion = new Version(versionAsString);
}
}
string hudsonBuildNumberString = Environment.GetEnvironmentVariable("BUILD_NUMBER");
int hudsonBuildNumber = int.Parse(hudsonBuildNumberString, CultureInfo.InvariantCulture);
string svnRevisionNumberString = Environment.GetEnvironmentVariable("SVN_REVISION");
int svnRevisionNumber = int.Parse(svnRevisionNumberString, CultureInfo.InvariantCulture);
BuildVersion = new Version(
BuildVersion.Major,
BuildVersion.Minor,
svnRevisionNumber,
hudsonBuildNumber);
Log("Project build version: {0}", BuildVersion);
ScriptExecutionEnvironment.LogTaskFinished();
return(ReturnThisTRunner());
}
return(FetchBuildVersion());
}
/// <summary>
/// Fetches the build version, either from the local version info file or from CCNet
/// (if the build is running under CCNet).
/// </summary>
/// <param name="loadFromFile">If not running under CCNet, fetch version from file or not.</param>
/// <returns>
/// The same instance of this <see cref="TRunner"/>.
/// </returns>
public TRunner FetchBuildVersion(bool loadFromFile)
{
ScriptExecutionEnvironment.LogTaskStarted("Fetching the build version");
if (IsRunningUnderCruiseControl)
{
string ccnetLabel = Environment.GetEnvironmentVariable("CCNetLabel");
Regex ccnetLabelRegex = new Regex(@"(?<version>([0-9]+.){3}[0-9]+)", RegexOptions.ExplicitCapture);
Match match = ccnetLabelRegex.Match(ccnetLabel);
if (false == match.Success)
{
Log(
"CCNet build label '{0}' could not be parsed to extract the build version. Using the default version instead",
ccnetLabel);
}
else
{
BuildVersion = new Version(match.Groups["version"].Value);
}
}
else if (loadFromFile)
{
string projectVersionFileName = MakePathFromRootDir(ProductId) + ".ProjectVersion.txt";
if (false == File.Exists(projectVersionFileName))
{
Fail("Project version file ('{0}') is missing.", projectVersionFileName);
}
using (Stream stream = File.Open(projectVersionFileName, FileMode.Open))
{
using (StreamReader reader = new StreamReader(stream))
{
string versionAsString = reader.ReadLine();
BuildVersion = new Version(versionAsString);
}
}
}
Log("Project build version: {0}", BuildVersion);
ScriptExecutionEnvironment.LogTaskFinished();
return(ReturnThisTRunner());
}
protected override ScriptVariable CalculateInternal(ScriptExecutionEnvironment env)
{
switch (this.Operator)
{
case OperatorType.Condition:
ScriptVariable p1 = this.First.Calculate(env);
if (p1 != null && p1.ToBoolean())
{
return(this.Second.Calculate(env));
}
else
{
return(this.Third.Calculate(env));
}
default:
throw new NotImplementedException(this.Operator.ToString());
}
}
protected override RunControlType ExecuteInternal(ScriptExecutionEnvironment env, out ScriptVariable returnValue)
{
returnValue = null;
env.Variables.EnterScope();
try {
if (this.Initialize != null)
{
this.Initialize.Calculate(env);
}
while (true)
{
if (this.Condition != null)
{
ScriptVariable condition = this.Condition.Calculate(env);
if (condition == null || !condition.ToBoolean())
{
return(RunControlType.None);
}
}
if (this.Statement != null)
{
RunControlType ctrl = this.Statement.Execute(env, out returnValue);
if (ctrl == RunControlType.Break)
{
return(RunControlType.None);
}
if (ctrl == RunControlType.Return)
{
return(RunControlType.Return);
}
}
if (this.Continue != null)
{
this.Continue.Calculate(env);
}
}
} finally { env.Variables.ExitScope(); }
}
protected override ScriptVariable CalculateInternal(ScriptExecutionEnvironment env)
{
ScriptVariable value = null;
if (this.RightValue != null)
{
value = this.RightValue.Calculate(env);
}
IVariableAccessor access = this.Accessor.GetAccessor(env);
if (this.Operator == OperatorType.Substitute)
{
access.Set(env, value == null ? null : value.Clone());
return(value);
}
else
{
ScriptVariable leftValue = access.Get(env);
ScriptVariable returnValue = operate(leftValue, value, this.Operator);
access.Set(env, returnValue);
return(returnValue);
}
}
protected override RunControlType ExecuteInternal(ScriptExecutionEnvironment env, out ScriptVariable returnValue)
{
returnValue = null;
env.Variables.EnterScope();
try {
env.Variables.Declare(this.Identifier, null, VariableStorage.FieldProperty.Default);
ScriptVariable list = this.Enumerator.Calculate(env) ?? new ListVariable();
foreach (var tmp in list.ToList())
{
env.Variables.Set(this.Identifier, tmp);
RunControlType ctrl = this.Statement.Execute(env, out returnValue);
if (ctrl == RunControlType.Break)
{
return(RunControlType.None);
}
if (ctrl == RunControlType.Return)
{
return(RunControlType.Return);
}
}
} finally { env.Variables.ExitScope(); }
return(RunControlType.None);
}
protected override ScriptVariable CalculateInternal(ScriptExecutionEnvironment env)
{
ScriptVariable returnValue = null;
IVariableAccessor access = this.Accessor.GetAccessor(env);
ScriptVariable value = access.Get(env);
switch (this.Operator)
{
case OperatorType.PostInc:
case OperatorType.PostDec:
returnValue = value;
break;
}
value = incOrDec(value);
switch (this.Operator)
{
case OperatorType.PreInc:
case OperatorType.PreDec:
returnValue = value;
break;
}
access.Set(env, value);
return(returnValue);
}
protected override RunControlType ExecuteInternal(ScriptExecutionEnvironment env, out ScriptVariable returnValue)
{
returnValue = null;
ScriptVariable condition = this.Condition.Calculate(env);
if (condition != null && condition.ToBoolean())
{
if (this.Then == null)
{
return(RunControlType.None);
}
RunControlType ctrl = this.Then.Execute(env, out returnValue);
return(ctrl);
}
else
{
if (this.Else == null)
{
return(RunControlType.None);
}
RunControlType ctrl = this.Else.Execute(env, out returnValue);
return(ctrl);
}
}
public override IVariableAccessor GetAccessor(ScriptExecutionEnvironment env)
{
ScriptVariable variable = this.Variable.Calculate(env);
ScriptVariable index;
if (this.Index == null)
{
ListVariable list = variable as ListVariable;
if (list != null)
{
index = new NumberVariable(list.Value.Count);
}
else
{
env.Console.Warn("Cannot use empty index except for List");
return(new NullAccessor());
}
}
else
{
index = this.Index.Calculate(env);
}
return(new IndexedVariableAccessor(variable, index));
}
private void Process_OutputDataReceived(object sender, DataReceivedEventArgs e)
{
ScriptExecutionEnvironment.LogMessage(e.Data);
}
private void Process_ErrorDataReceived(object sender, DataReceivedEventArgs e)
{
ScriptExecutionEnvironment.LogError(e.Data);
}
