/// <summary>
/// Execute method.
/// </summary>
/// <param name="pipe">NamedPipeServerStream</param>
public override void execute(NamedPipeServerStream pipe)
{
ConfigSerializer configSerializer = new ConfigSerializer();
byte[] messagebuffer = new byte[100];
byte[] originalbuffer = new byte[100];
int i = 0;
do
{
pipe.Read(messagebuffer, 0, messagebuffer.Length);
System.Buffer.BlockCopy(messagebuffer, 0, originalbuffer, i, messagebuffer.Length);
Array.Resize(ref originalbuffer, originalbuffer.Length + 100);
messagebuffer = new byte[100];
i = i + 100;
}while (!pipe.IsMessageComplete);
Config config = new Config();
config = configSerializer.Deserialize(originalbuffer);
config.Format = CLI.CreateFormat(config.EncFormat, ref config);
CLI.runOnce(config);
//Write a "reponse" to the client which is waiting
pipe.WriteByte(68);
}
static int Main(string[] argv)
{
bool help = false;
bool version = false;
bool once = false;
StartClient startClient = StartClient.No;
var config = new Config();
var pipename = "TypeCobol.Server";
var p = new OptionSet()
{
"USAGE",
" " + PROGNAME + " [OPTIONS]... [PIPENAME]",
"",
"VERSION:",
" " + PROGVERSION,
"",
"DESCRIPTION:",
" Run the TypeCobol parser server.",
{ "k|startServer:", "Start the server if not already started, and executes commandline.\n" +
"By default the server is started in window mode\n" +
"'{hidden}' hide the window.", v =>
{
if ("hidden".Equals(v, StringComparison.InvariantCultureIgnoreCase))
{
startClient = StartClient.HiddenWindow;
}
else
{
startClient = StartClient.NormalWindow;
}
} },
{ "1|once", "Parse one set of files and exit. If present, this option does NOT launch the server.", v => once = (v != null) },
{ "i|input=", "{PATH} to an input file to parse. This option can be specified more than once.", v => config.InputFiles.Add(v) },
{ "o|output=", "{PATH} to an ouput file where to generate code. This option can be specified more than once.", v => config.OutputFiles.Add(v) },
{ "d|diagnostics=", "{PATH} to the error diagnostics file.", v => config.ErrorFile = v },
{ "s|skeletons=", "{PATH} to the skeletons files.", v => config.skeletonPath = v },
{ "a|autoremarks", "Enable automatic remarks creation while parsing and generating Cobol", v => config.AutoRemarks = true },
{ "hc|haltonmissingcopy=", "HaltOnMissingCopy will generate a file to list all the absent copies", v => config.HaltOnMissingCopyFilePath = v },
{ "ets|exectostep=", "ExecToStep will execute TypeCobol Compiler until the included given step (Scanner/0, Preprocessor/1, SyntaxCheck/2, SemanticCheck/3, Generate/4)", v => Enum.TryParse(v.ToString(), true, out config.ExecToStep) },
// { "p|pipename=", "{NAME} of the communication pipe to use. Default: "+pipename+".", (string v) => pipename = v },
{ "e|encoding=", "{ENCODING} of the file(s) to parse. It can be one of \"rdz\"(this is the default), \"zos\", or \"utf8\". "
+ "If this option is not present, the parser will attempt to guess the {ENCODING} automatically.",
v => config.Format = CLI.CreateFormat(v, ref config) },
{ "y|intrinsic=", "{PATH} to intrinsic definitions to load.\nThis option can be specified more than once.", v => config.Copies.Add(v) },
{ "c|copies=", "Folder where COBOL copies can be found.\nThis option can be specified more than once.", v => config.CopyFolders.Add(v) },
{ "dp|dependencies=", "Path to folder containing programs to load and to use for parsing a generating the input program.", v => config.Dependencies.Add(v) },
{ "h|help", "Output a usage message and exit.", v => help = (v != null) },
{ "V|version", "Output the version number of " + PROGNAME + " and exit.", v => version = (v != null) },
};
//Add DefaultCopies to running session
var folder = Path.GetDirectoryName(Process.GetCurrentProcess().MainModule.FileName);
config.CopyFolders.Add(folder + @"\DefaultCopies\");
try {
List <string> args;
try {
args = p.Parse(argv);
} catch (OptionException ex) {
return(exit(1, ex.Message));
}
if (help)
{
p.WriteOptionDescriptions(Console.Out);
return(0);
}
if (version)
{
Console.WriteLine(PROGVERSION);
return(0);
}
if (config.OutputFiles.Count == 0 && config.ExecToStep >= ExecutionStep.Generate)
{
config.ExecToStep = ExecutionStep.SemanticCheck; //If there is no given output file, we can't run generation, fallback to SemanticCheck
}
if (config.OutputFiles.Count > 0 && config.InputFiles.Count != config.OutputFiles.Count)
{
return(exit(2, "The number of output files must be equal to the number of input files."));
}
if (args.Count > 0)
{
pipename = args[0];
}
//"startClient" will be true when "-K" is passed as an argument in command line.
if (startClient != StartClient.No && once)
{
pipename = "TypeCobol.Server";
using (NamedPipeClientStream namedPipeClient = new NamedPipeClientStream(pipename))
{
try {
namedPipeClient.Connect(100);
} catch (TimeoutException tEx) {
System.Diagnostics.Process process = new System.Diagnostics.Process();
System.Diagnostics.ProcessStartInfo startInfo = new System.Diagnostics.ProcessStartInfo();
if (startClient == StartClient.NormalWindow)
{
startInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Normal;
}
else
{
startInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden;
}
startInfo.FileName = "cmd.exe";
startInfo.Arguments = @"/c " + folder + Path.DirectorySeparatorChar + "TypeCobol.CLI.exe";
process.StartInfo = startInfo;
process.Start();
namedPipeClient.Connect(1000);
}
namedPipeClient.WriteByte(68);
ConfigSerializer configSerializer = new ConfigSerializer();
var configBytes = configSerializer.Serialize(config);
namedPipeClient.Write(configBytes, 0, configBytes.Length);
//Wait for the response "job is done"
namedPipeClient.ReadByte();
}
}
//option -1
else if (once)
{
CLI.runOnce(config);
}
else
{
runServer(pipename);
}
}
catch (Exception e) {
return(exit(1, e.Message));
}
return(0);
}