//--------------------------------------------------------------------
//
// Program Entry Method
//
//---------------------------------------------------------------------
#region Entry
//
// Process command-line arguments.
// Compile and execute the project.
// Returns 0 if successful.
//
static int Main(string[] argsIn)
{
Project.Parameters projectParams = null;
Parameters cspParams = null;
int returnCode = ProcessArgs(
argsIn,
out projectParams,
out cspParams
);
if (returnCode != _rc_success)
{
if (returnCode == _rc_exitAndReturnSuccess)
{
return(_rc_success);
}
else
{
return(returnCode);
}
}
int projectReturnValue = _rc_projectBuildFailed;
try
{
Project project = Project.Build(projectParams);
if (project != null)
{
projectReturnValue = project.ExecuteMain(projectParams.MainClass, projectParams.ProjectArgs);
}
else
{
// Do nothing. If the project didn't build, we expect "Project" to have
// emitted some useful error messages.
}
}
catch (CspProjectException e)
{
if (cspParams.SuppressExceptions)
{
WriteErrorLine(e.Message);
return(_rc_cspProjectException);
}
else
{
throw;
}
}
catch (Exception e)
{
if (cspParams.SuppressExceptions)
{
WriteErrorLine(e.Message);
WriteErrorLine("(To debug, rerun under a debugger, with the -debugMode parameter.)");
return(_rc_projectThrewException);
}
else
{
throw;
}
}
if (cspParams.BreakBeforeExit)
{
// Final breakpoint just before csp.exe quits.
//
// This is useful for seeing the output in the console window.
System.Diagnostics.Debugger.Break();
}
return(projectReturnValue);
}
//--------------------------------------------------------------------
//
// Private Methods
//
//---------------------------------------------------------------------
#region Private Methods
//+-----------------------------------------------------------------------------
//
// Function: ProcessArgs
//
// Synopsis: Processes the command-line arguments and returns a structured
// form in argsOut.
//
// Return value: A return code; if not _rc_success, caller should quit.
// May return _rc_exitAndReturnSuccess, which caller needs
// to translate to _rc_success.
//
//------------------------------------------------------------------------------
static private int ProcessArgs(
string[] argsIn,
out Project.Parameters projParamsOut,
out Parameters cspParamsOut
)
{
projParamsOut = new Project.Parameters();
cspParamsOut = new Parameters();
// Convert argsIn to a list
ArrayList rgsArgs = new ArrayList();
foreach (string arg in argsIn)
{
rgsArgs.Add(arg);
}
ArrayList alSourceFiles = new ArrayList();
ArrayList alReferencedAssemblies = new ArrayList();
bool noBreakBeforeInvoke = false;
bool debugMode = false;
if (rgsArgs.Count > 0)
{
string prefix = GetStandardizedPrefix((string)rgsArgs[0]);
if ((prefix == "-h") ||
(prefix == "-?"))
{
_Usage();
return(_rc_exitAndReturnSuccess);
}
}
//
// Process the arguments (until we hit "--").
//
bool fHitProjectParams = false;
int idxCurrentArg;
for (idxCurrentArg = 0; idxCurrentArg < rgsArgs.Count; idxCurrentArg++)
{
string arg = ((string)rgsArgs[idxCurrentArg]).Trim();
string prefix = GetStandardizedPrefix(arg);
switch (prefix)
{
// response file - a file which contains more arguments for us to parse.
case "-rsp:":
{
string responseFile = arg.Substring(5);
if (!File.Exists(responseFile))
{
WriteErrorLine(String.Format(
"Response file '{0}' not found.", responseFile));
return(_rc_fileNotFound);
}
// Remove this argument - replace it with the new arguments.
rgsArgs.RemoveAt(idxCurrentArg);
GetArgsFromFile(responseFile, idxCurrentArg, ref rgsArgs);
// Make the next iteration use the same index.
idxCurrentArg--;
break;
}
// source file - a .cs file which we will parse and then
// compile.
case "-s:":
{
string sourceFile = arg.Substring(3);
if (!File.Exists(sourceFile))
{
WriteErrorLine(String.Format(
"Source file '{0}' not found.", sourceFile));
return(_rc_fileNotFound);
}
alSourceFiles.Add(sourceFile);
break;
}
case "-r:":
{
alReferencedAssemblies.Add(arg.Substring(3));
break;
}
case "-clrdir:":
{
projParamsOut.ClrDir = arg.Substring(8);
break;
}
case "-debugmode":
{
debugMode = true;
continue;
}
case "-enablecsprime":
{
projParamsOut.EnableCsPrime = true;
continue;
}
case "-nobreakpoint":
{
noBreakBeforeInvoke = true;
continue;
}
case "-main:":
{
if (projParamsOut.MainClass != null)
{
_Usage();
return(_rc_usageError);
}
projParamsOut.MainClass = arg.Substring(6);
continue;
}
case "--":
{
idxCurrentArg++;
fHitProjectParams = true;
break;
}
default:
{
_Usage();
WriteErrorLine(String.Format(
"Unrecognized option: '{0}'", arg));
return(_rc_usageError);
}
}
if (fHitProjectParams)
{
break;
}
}
if (debugMode)
{
if (!noBreakBeforeInvoke)
{
projParamsOut.BreakBeforeInvoke = true;
}
cspParamsOut.SuppressExceptions = false;
cspParamsOut.BreakBeforeExit = true;
// This will leave files in the %temp% directory.
// But seems necessary to get symbols.
projParamsOut.DebugModeHack = true;
}
if (alSourceFiles.Count == 0)
{
_Usage();
return(_rc_usageError);
}
projParamsOut.SourceFiles = (string[])alSourceFiles.ToArray(typeof(string));
projParamsOut.ReferencedAssemblies = (string[])alReferencedAssemblies.ToArray(typeof(string));
// Set projParamsOut.ProjectArgs, to the parameters after the "--".
int idxProjectArgs = idxCurrentArg;
int nProjectArgs = rgsArgs.Count - idxProjectArgs;
if (nProjectArgs < 0)
{
nProjectArgs = 0;
}
projParamsOut.ProjectArgs = new string[nProjectArgs];
if (nProjectArgs > 0)
{
rgsArgs.CopyTo(idxProjectArgs, projParamsOut.ProjectArgs, 0, nProjectArgs);
}
return(_rc_success);
}