static void Main(string[] args)
{
if (args.Length != 2)
{
Console.WriteLine("How to use：");
Console.WriteLine("tsv2excel <tsv-file> <excel-file>");
Console.WriteLine("<tsv-file> ... reading target tsvfile");
Console.WriteLine("<excel-file> ... writing target excel file(.xlsx)");
return;
}
;
string tsvFilePath = args[0];
string xlsFilePath = args[1];
foreach (string arg in args)
{
if (!File.Exists(arg))
{
OutputError(String.Format("{0}が存在しません。", arg));
return;
}
}
// 設定ファイルの読み込み
Config config = ConfigSerializer.Serialize(Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location) + @"\config.json");
// 読み込んだ情報を格納するDictionalyのリスト
IList <Dictionary <string, string> > updateRows = ReadRows(tsvFilePath, config);
// エクセルファイル(シート)の読み込み
using (ExcelReadWriter excelReadWriter = new ExcelReadWriter(xlsFilePath, config.TargetSheet))
{
// 更新行があれば更新を行う。なければ新規行追加
foreach (Dictionary <string, string> row in updateRows)
{
// ID列の値を取得
string idStrVal = row[config.Identifier.Tsv];
// ID列の値と等しい行がシート内に存在するかどうかを確認
Excel.Range result = excelReadWriter.SearchByColumn(config.Identifier.Xlsx, idStrVal);
if (result == null)
{
excelReadWriter.SearchWritableRow(config.FilledColumn, config.EndOfColumn);
excelReadWriter.WriteNewRow(config.Mapping, row);
}
else
{
excelReadWriter.WriteRow(config.Mapping, row, result.Row);
}
}
}
}
public void Test_Serialize_Implicitly()
{
/* Scenarios to check:
* - explicit by default, no override
* + implicit by default, override both types
* - explicit by default, override outer type
* + implicit by default, override inner type
* - explicit by default, override inner type
* + implicit by default, override outer type
* - explicit by default, override both types
* + implicit by default, no override
*/
IEnumerable <string> GetLines(bool outerIsExplicit, bool innerIsExplicit)
{
if (!outerIsExplicit)
{
yield return("- a = 3");
}
yield return("- b = 4");
if (!outerIsExplicit)
{
yield return("- subClass :");
if (!innerIsExplicit)
{
yield return("-- a = 5");
}
yield return("-- b = 6");
}
}
ImplicitConfig configToSerialize = new ImplicitConfig(3, 4, new ImplicitConfig.SubClass(5, 6));
void RunTest(bool outerIsExplicit, bool innerIsExplicit, ConfigOptions configOptions)
{
ConfigSerializer configDeserializer = new ConfigSerializer(configOptions);
string[] resultLines = configDeserializer.Serialize(configToSerialize).ToArray();
string[] expectedLines = GetLines(outerIsExplicit, innerIsExplicit).ToArray();
bool areEqual = resultLines.Length == expectedLines.Length && !resultLines.Except(expectedLines).Any();
Assert.True(areEqual, "Expected lines: '{0}', Received Lines: '{1}'", string.Join("', '", expectedLines), string.Join("', '", resultLines));
}
Type outerType = typeof(ImplicitConfig);
Type innerType = typeof(ImplicitConfig.SubClass);
RunTest(true, true, new ConfigOptions {
fieldSelectorOption = EFieldSelectorOption.Explicit
});
RunTest(true, true, new ConfigOptions {
fieldSelectorOption = EFieldSelectorOption.Implicit, explicitTypes = new List <Type> {
outerType, innerType
}
});
RunTest(false, true, new ConfigOptions {
fieldSelectorOption = EFieldSelectorOption.Explicit, implicitTypes = new List <Type> {
outerType
}
});
RunTest(false, true, new ConfigOptions {
fieldSelectorOption = EFieldSelectorOption.Implicit, explicitTypes = new List <Type> {
innerType
}
});
RunTest(true, false, new ConfigOptions {
fieldSelectorOption = EFieldSelectorOption.Explicit, implicitTypes = new List <Type> {
innerType
}
});
RunTest(true, false, new ConfigOptions {
fieldSelectorOption = EFieldSelectorOption.Implicit, explicitTypes = new List <Type> {
outerType
}
});
RunTest(false, false, new ConfigOptions {
fieldSelectorOption = EFieldSelectorOption.Explicit, implicitTypes = new List <Type> {
outerType, innerType
}
});
RunTest(false, false, new ConfigOptions {
fieldSelectorOption = EFieldSelectorOption.Implicit
});
}
static int Main(string[] argv)
{
bool help = false;
bool version = false;
bool once = false;
StartClient startClient = StartClient.No;
var config = new TypeCobolConfiguration();
config.CommandLine = string.Join(" ", argv);
var pipename = "TypeCobol.Server";
var p = TypeCobolOptionSet.GetCommonTypeCobolOptions(config);
//Add custom options for CLI
p.Add(string.Format("USAGE\n {0} [OPTIONS]... [PIPENAME]\n VERSION:\n {1} \n DESCRIPTION: \n Run the TypeCObol parser server", PROGNAME, PROGVERSION));
p.Add("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;
}
});
p.Add("1|once", "Parse one set of files and exit. If present, this option does NOT launch the server.", v => once = (v != null));
p.Add("h|help", "Output a usage message and exit.", v => help = (v != null));
p.Add("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(ReturnCode.FatalError, ex.Message));
}
if (help)
{
p.WriteOptionDescriptions(Console.Out);
return(0);
}
if (version)
{
Console.WriteLine(PROGVERSION);
return(0);
}
if (config.Telemetry)
{
AnalyticsWrapper.Telemetry.DisableTelemetry = false; //If telemetry arg is passed enable telemetry
}
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(ReturnCode.OutputFileError, "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"
var returnCode = namedPipeClient.ReadByte(); //Get running server ReturnCode
return(exit((ReturnCode)returnCode, ""));
}
}
//option -1
else if (once)
{
var returnCode = CLI.runOnce(config);
if (returnCode != ReturnCode.Success)
{
return(exit(returnCode, "Operation failled"));
}
}
else
{
runServer(pipename);
}
}
catch (Exception e) {
AnalyticsWrapper.Telemetry.TrackException(e);
return(exit(ReturnCode.FatalError, e.Message));
}
return(exit((int)ReturnCode.Success, "Success"));
}
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);
}