Add simple command line parser for TestLauncher

The CommandLineParser is able to parse command line options in the form of
`--option1 param1 param2 --option2 --option3 param3`.
Each option starts with two dashes and any arguments not beginning with `--`
are treated as parameters for the last option that was encountered. So `param1`
and `param2` are parameters for `option1``,  `option2` has no parameters and
`option3` has 1 parameter `param3`.

Currently there is no schema validation or type conversion, so checking that
is left up to the caller. To ease that, `CommandLineParser` provides some
utility functions:
  - `isPresent(String name)` checks if a given option was present on the
    command line
  - `getMissingOptions(String ... names)` returns an array of arguments which
    were not present but should have been according to `names`
  - checkRequiredOptions(String ... names) checks if all options named were
    given and return `false` if any were missing while also printing an error
    message to `System.err` for each missing option.

Furthermore `getParametersFor(String name)` can be used to obtain an Array of
an option's associated parameters and `getFirstParameterFor(String name)`
provides a convenient way to access an option's first parameter. This is
especially useful for single parameter options.

Using this parser, `TstLauncher` has been rewritten to accept the target deep
file and target configuration as command line parameters instead of
uncommenting the corresponding line in `TestLauncher` itself. The new command
line options are:
  - `--deepfile`: the deep configuration file to use `555ExampleProject.deep`
  - `--targetconfig`: the target configuration to use, e.g. `BootFromRam`

Author: zechenturm

src/org/deepjava/launcher/CommandLineParser.java

@@ -0,0 +1,63 @@
+package org.deepjava.launcher;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+
+public class CommandLineParser {
+	private Map<String, ArrayList<String>> parsedArguments = new HashMap<>();
+	private ArrayList<String> currentParameterList = null;
+	
+	public void parse(String[] argv) {
+		for (String arg : argv) {
+			if (isCommandLineOption(arg)) {
+				currentParameterList = new ArrayList<>();
+				parsedArguments.put(strip(arg), currentParameterList);
+			} else {
+				currentParameterList.add(arg);
+			}
+		}
+	}
+	
+	private boolean isCommandLineOption(String arg) {
+		return arg.startsWith("--");
+	}
+	
+	private String strip(String arg) {
+		return arg.substring(2);
+	}
+	
+	public boolean isPresent(String option) {
+		return parsedArguments.containsKey(option);
+	}
+	
+	public ArrayList<String> getParametersFor(String option) {
+		return parsedArguments.get(option);
+	}
+	
+	public String getFirstParameterFor(String option) {
+		return parsedArguments.get(option).get(0);
+	}
+	
+	public String[] getMissingOptions(String ... requiredOptions) {
+		return (String[]) Arrays.stream(requiredOptions).filter(requiredOption -> !parsedArguments.containsKey(requiredOption)).toArray(String[]::new);
+	}
+	
+public boolean checkRequiredOptions(String ... requiredOptions) {
+	String[] missingArgs = getMissingOptions(requiredOptions);
+	if (missingArgs.length == 0)
+		return true;
+	
+		for (String arg : missingArgs)
+			System.err.println("missing required command line argument: --" + arg);
+		return false;
+}
+	
+	// Nur zum testen/demo
+	public static void main(String[] argv) {
+		CommandLineParser p = new CommandLineParser();
+		p.parse(argv);
+		p.parsedArguments.forEach((k, v) -> {System.out.println(k + ": " + v);});
+	}
+}

src/org/deepjava/launcher/TestLauncher.java

@@ -40,16 +40,13 @@
 @SuppressWarnings("unused")
 public class TestLauncher {
 	public static void main(String[] args) {
-//		Launcher.buildAll("555ExampleProject.deep", "BootFromRam", false);
-//		Launcher.buildAll("555ExampleProject.deep", "BootFromFlash", false);
-//		Launcher.buildAll("555junitTarget.deep", "BootFromRam", false);
-//		Launcher.buildAll("5200tinyExampleProject.deep", "BootFromRam", false);
-//		Launcher.buildAll("5200ioExampleProject.deep", "BootFromRam", false);
-//		Launcher.buildAll("5200junitTarget.deep", "BootFromRam", false);
-//		Launcher.buildAll("iMX6ExampleProject.deep", "BootFromRam", false);
-//		Launcher.buildAll("zyboExampleProject.deep", "BootFromRam", false);
-		Launcher.buildAll("microzedExampleProject.deep", "BootFromRam", false);
-//		Launcher.buildAll("microzedjunitTarget.deep", "BootFromRam", false);
+		CommandLineParser p = new CommandLineParser();
+		p.parse(args);
+		if (!p.checkRequiredOptions("deepfile", "targetconfig")) return;
+		String deepFile = p.getFirstParameterFor("deepfile");
+		String targetConfig = p.getFirstParameterFor("targetconfig");
+		Launcher.buildAll(deepFile, targetConfig, false);
+		
 		if (ErrorReporter.reporter.nofErrors == 0) {
 			Programmer programmer = Configuration.getProgrammer();
 			if (programmer != null) {
@@ -82,8 +79,13 @@ public static void main(String[] args) {
 			} else
 				System.out.println("no programmer defined");
 		}
+		
+		if (p.isPresent("interface-files-path")) {
+			System.out.println("generating interface files");
+			String targetPath = p.getFirstParameterFor("interface-files-path");
+			Launcher.createInterfaceFiles(targetPath);
+		}
 
-//		Launcher.createInterfaceFiles("M:/EUser/JCC/org.deepjava.trglib");
 
 		/* DEBUG OUTPRINTS */
 //		System.out.println("%%%%%%%%%%%%%%% Class List %%%%%%%%%%%%%%%"); Linker32.printClassList(false, false, false, true);