From 41d2e529c4d1e55d155912ad825d2d3508c39d05 Mon Sep 17 00:00:00 2001 From: jjenista Date: Tue, 10 Feb 2009 01:00:26 +0000 Subject: [PATCH] java benchmark with disjointness annotations --- .../getpot-java/mergeExamples/Example.java | 202 +++ .../mlp/getpot-java/mergeExamples/GetPot.java | 1546 +++++++++++++++++ .../mlp/getpot-java/mergeExamples/example.pot | 98 ++ .../mlp/getpot-java/mergeExamples/makefile | 28 + .../getpot-java/original/DirectFollow.java | 77 + .../mlp/getpot-java/original/Expand.java | 142 ++ .../mlp/getpot-java/original/Filter.java | 143 ++ .../mlp/getpot-java/original/Flags.java | 58 + .../mlp/getpot-java/original/Follow.java | 82 + .../mlp/getpot-java/original/Get.java | 47 + .../mlp/getpot-java/original/GetPot.java | 1505 ++++++++++++++++ .../mlp/getpot-java/original/InputFile.java | 89 + .../mlp/getpot-java/original/Next.java | 57 + .../mlp/getpot-java/original/Nominus.java | 57 + .../mlp/getpot-java/original/Options.java | 66 + .../mlp/getpot-java/original/Ufo.java | 169 ++ .../mlp/getpot-java/original/Variables.java | 74 + .../mlp/getpot-java/original/example.pot | 98 ++ .../mlp/getpot-java/original/expand.pot | 282 +++ .../Benchmarks/mlp/getpot-java/original/tmp | 0 20 files changed, 4820 insertions(+) create mode 100644 Robust/src/Benchmarks/mlp/getpot-java/mergeExamples/Example.java create mode 100755 Robust/src/Benchmarks/mlp/getpot-java/mergeExamples/GetPot.java create mode 100755 Robust/src/Benchmarks/mlp/getpot-java/mergeExamples/example.pot create mode 100644 Robust/src/Benchmarks/mlp/getpot-java/mergeExamples/makefile create mode 100755 Robust/src/Benchmarks/mlp/getpot-java/original/DirectFollow.java create mode 100644 Robust/src/Benchmarks/mlp/getpot-java/original/Expand.java create mode 100644 Robust/src/Benchmarks/mlp/getpot-java/original/Filter.java create mode 100755 Robust/src/Benchmarks/mlp/getpot-java/original/Flags.java create mode 100755 Robust/src/Benchmarks/mlp/getpot-java/original/Follow.java create mode 100755 Robust/src/Benchmarks/mlp/getpot-java/original/Get.java create mode 100755 Robust/src/Benchmarks/mlp/getpot-java/original/GetPot.java create mode 100755 Robust/src/Benchmarks/mlp/getpot-java/original/InputFile.java create mode 100755 Robust/src/Benchmarks/mlp/getpot-java/original/Next.java create mode 100755 Robust/src/Benchmarks/mlp/getpot-java/original/Nominus.java create mode 100755 Robust/src/Benchmarks/mlp/getpot-java/original/Options.java create mode 100644 Robust/src/Benchmarks/mlp/getpot-java/original/Ufo.java create mode 100755 Robust/src/Benchmarks/mlp/getpot-java/original/Variables.java create mode 100755 Robust/src/Benchmarks/mlp/getpot-java/original/example.pot create mode 100644 Robust/src/Benchmarks/mlp/getpot-java/original/expand.pot create mode 100644 Robust/src/Benchmarks/mlp/getpot-java/original/tmp diff --git a/Robust/src/Benchmarks/mlp/getpot-java/mergeExamples/Example.java b/Robust/src/Benchmarks/mlp/getpot-java/mergeExamples/Example.java new file mode 100644 index 00000000..5a85470a --- /dev/null +++ b/Robust/src/Benchmarks/mlp/getpot-java/mergeExamples/Example.java @@ -0,0 +1,202 @@ +import GetPot.*; +import java.lang.String; + +public class Example { + + public static void main(String args []) { + + + + GetPot cl = disjoint gp1 new GetPot(args, "Flags"); + if( cl.size() == 1 || cl.search("--help", "-h") ) print_help(); + + // does first argument contain 'x', 'X', 'c', 'C', 'k', or 'K' ? + boolean first_f = cl.argument_contains(1, "xX"); + boolean second_f = cl.argument_contains(1, "cCkK"); + + // is there any option starting with '-' containing 'a', 'b', or 'c' ? + boolean abc_f = cl.options_contain("abc"); + + System.printString("first flag = " + first_f); + System.printString("second flag = " + second_f); + System.printString("a, b, or c found = " + abc_f ); + + + + cl = disjoint gp2 new GetPot(args, "DirectFollow"); + + if( cl.size() == 1 || cl.search("--help", "-h") ) print_help("DirectFollow"); + + // Specify, that in case the cursor reaches the end of argument list, + // it is not automatically reset to the start. This way the search + // functions do not wrap around. Instead, they notify an 'not fount' + // in case the option was not in between 'cursor' and the argv.end(). + cl.reset_cursor(); + cl.disable_loop(); + + // check out 'String' versions + String User = cl.direct_follow("You", "-U"); + String User2 = cl.direct_follow("Karl", "-U"); + String User3 = cl.direct_follow("Heinz", "-U"); + + // check out 'double' versions + cl.reset_cursor(); + double Value = cl.direct_follow(3.14, "-V"); + double Value2 = cl.direct_follow(9.81, "-V"); + double Value3 = cl.direct_follow(1.62, "-V"); + + // check out 'integer' versions + cl.reset_cursor(); + int Number = cl.direct_follow(12, "-NUM"); + int Number2 = cl.direct_follow(43, "-NUM"); + int Number3 = cl.direct_follow(64, "-NUM"); + + something(User, User2, User3, Value, Value2, Value3, Number, Number2, Number3); + + + + + + + + cl = disjoint gp3 new GetPot(args, "Filter"); + GetPot ifpot = disjoint gp4 new GetPot("example.pot"); + + // (1) search for multiple options with the same meaning + if( cl.search("--help", "-h", "--hilfe", "--sos") ) { + String Msg = "Example program treating the prefix filtering.\n\n" + + " Using the function .set_prefix(section) only arguments, options \n" + + " variables are considered in the given 'section'\n\n" + + "--help, -h, --hilfe, --sos \n" + + " this page.\n" + + "--nice \n" + + " demonstrates how pseudo function calls can be accomplished.\n\n" + + "please refer to the file 'example.pot' as input file.\n"; + System.printString(Msg); + System.exit(0); + } + + // -- note that the prefix is not considered as a flag + // -- the index in 'argument contains' indicates the position + // of the argument inside the namespace given by prefix + ifpot.set_prefix("group/"); + + System.printString(" -- flags in options / arguments"); + first_f = ifpot.argument_contains(1, "xX"); + second_f = ifpot.argument_contains(1, "cCkK"); + abc_f = ifpot.options_contain("abc"); + System.printString(" Flags in first argument in [flags]\n"); + System.printString(" x or X in arg 1 = " + first_f); + System.printString(" c, C, k or K in arg 1 = " + second_f); + System.printString(" a,b, or c in options = " + abc_f); + System.printString(""); + System.printString(" -- search(), next() and follow()"); + System.printString(""); + System.printString(" found \"--rudimental\" = " + ifpot.search("--rudimental")); + + int Tmp1 = ifpot.next(-1); + int Tmp2 = ifpot.next(-1); + System.printString(" followed by " + Tmp1 + " " + Tmp2); + + String Tmp3 = ifpot.follow("nothing", "--rudimental"); + int Tmp4 = ifpot.next(-1); + System.printString(" rudimental = " + Tmp3 + ", " + Tmp4 + "\n"); + + // -- variables + System.printString(""); + System.printString(" -- variables in section [user-variables]"); + System.printString(""); + ifpot.set_prefix("user-variables/"); + + String variable_names[] = ifpot.get_variable_names(); + for(int i=0; i < variable_names.length ; i++) { + String name = variable_names[i]; + System.printString(" " + name + " \t= "); + System.printString(""+ifpot.call(name, 1e37, 0)); + System.printString("[" + ifpot.call(name, "[1]", 1) + "]\n"); + } + System.printString(""); + + // -- pseudo function calls + if( cl.search("--nice") ) { + System.printString(" -- pseudo function call feature"); + System.printString(""); + ifpot.set_prefix("pseudo-function-calls/"); + ifpot.init_multiple_occurrence(); + + ifpot.search("LE-DEBUT"); + while( 1 + 1 == 2 ) { + String Next = ifpot.next("(no-func)"); + + if( Next.compareTo("(no-func)") == 0 ) break; + else if( Next.compareTo("rectangle") == 0) { + int size_x = ifpot.next(10); + int size_y = ifpot.next(10); + System.printString("\n"); + for(int y=0; y < size_y; y++) { + for(int x=0; x < size_x; x++) { + System.printString("*"); + } + System.printString("\n"); + } + } + else if( Next.compareTo("circle") == 0) { + int radius = ifpot.next(4); + System.printString("\n"); + for(int y=0; y < radius*2 + 1; y++) { + for(int x=0; x < radius*2 + 1; x++) + if( Sqr(x-radius) + Sqr(y-radius) <= Sqr(radius) + && Sqr(x-radius) + Sqr(y-radius) >= Sqr(radius)/4. ) + System.printString("."); + else + System.printString(" "); + System.printString("\n"); + } + } + else if( Next.compareTo("smiley") == 0 ) { + String Mood = ifpot.next("happy"); + if( Mood.compareTo("sad") == 0 ) System.printString(":( "); + else System.printString(":) "); + } + else if( Next.compareTo("new-line") == 0 ) { + int No = ifpot.next(1); + for(int i=0; i value.length ) return new String(""); + else return value[Idx]; + } + + void take(String Value) { + original = Value; + StringTokenizer st = new StringTokenizer(Value); + value = new String[st.countTokens()]; + for(int i =0; st.hasMoreTokens(); i++ ) + value[i] = st.nextToken(); + } + // (*) data memebers + String name; // identifier of variable + String value[]; // value of variable stored in vector + String original; // value of variable as given on command line +} + + +public class GetPot { + String prefix; // prefix indicating section for search + String section; // section for dollar bracket parsing + Vector argv; // String[] + Vector section_list; + int cursor; + Vector idx_nominus; // int[] + int nominus_cursor; + boolean search_loop_f; + boolean search_failed_f; + Vector variables; // class variable + + + // (*) constructor + GetPot(String argv_[], String applicationName) { + prefix = ""; + cursor = 0; + nominus_cursor = -1; + search_loop_f = true; + search_failed_f = false; + + Vector __argv = new Vector(); + idx_nominus = new Vector(); + variables = new Vector(); + section_list = new Vector(); + + // in java the argv[0] does not contain the application name + // => append application name to argv vector by hand + + for(int i=0; i < argv_.length ; i++) { + String copied_str = new String(argv_[i]); + __argv.addElement(copied_str); + } + + argv = new Vector(); + __argv.insertElementAt(applicationName, 0); + __parse_argument_vector(__argv); + } + + GetPot(String FileName) { + prefix = ""; + cursor = 0; + nominus_cursor = -1; + search_loop_f = true; + search_failed_f = false; + + Vector __argv = new Vector(); + idx_nominus = new Vector(); + variables = new Vector(); + section_list = new Vector(); + + __argv = read_in_file(FileName); + + argv = new Vector(); + __argv.insertElementAt(FileName, 0); + __parse_argument_vector(__argv); + } + + void __parse_argument_vector(Vector _argv) { + // build internal database + // 1) array with no-minus arguments (usually used as filenames) + // 2) section label treatment + // 3) variable assignments: + // 'variable name' '=' number | string + int i=0; + section = ""; + Vector section_stack = new Vector(); + if( _argv.size() < 1 ) return; + + + for( ; i < _argv.size(); i++) { + String arg = (String)_argv.elementAt(i); + + if( i == 0 ) { + argv.addElement(arg); + // continue; + } else if( arg.length() == 0) { + // continue; + } else { + + // -- [section] labels + if( arg.length() > 1 && arg.charAt(0) == '[' && arg.charAt(arg.length()-1) == ']' ) { + String name = DBE_expand_string(arg.substring(1, arg.length()-1)); + // String name = arg.substring(1, arg.length()-1); + section = process_section_label(name, section_stack); + // new section --> append to list of sections + if( section_list.indexOf(section) == -1 ) + if( section.length() != 0 ) section_list.addElement(section); + argv.addElement(arg); + } + else { + arg = section + DBE_expand_string(arg); + argv.addElement(arg); + } + + // 1) separate array for nominus arguments + if( arg.charAt(0) != '-' ) + idx_nominus.addElement(new Integer(i)); + + // 2) variables: does _argv[i] contain a '=' operator ? + int k = arg.indexOf('='); + if( k > 0 ) { + variable Var = find_variable(arg.substring(0,k)); + if( Var.name.compareTo("") == 0 ) + variables.addElement(disjoint arg new variable(arg.substring(0,k), + arg.substring(k+1))); + else + Var.take(arg.substring(k+1)); + } + } + } + } + // file parsing + Vector read_in_file(String filename) { + Vector Empty = new Vector(); + + FileInputStream i = new FileInputStream(filename); + //if( i.available() == 0 ) return Empty; + // argv[0] == the filename of the file that was read in + return read_in_stream(new PushbackInputStream(i)); + } + + Vector read_in_stream(PushbackInputStream istr) { + Vector brute_tokens = new Vector(); + String token; + Vector arglist = new Vector(); + + boolean vcontinue = true; + while( 1 + 1 == 2 && vcontinue ) { + if( __skip_whitespace(istr) == -1 ) { + //break; + vcontinue = false; + } else { + token = __get_next_token(istr); + if( token.length() == 0 ) { + //break; + vcontinue = false; + } else { + brute_tokens.addElement(token); + } + } + } + + // for(int i=0; i skip until end of line + do { tmp = istr.read(); if( tmp == -1 ) return -1; } + while( (char)tmp != '\n' ); + + istr.unread(tmp); + //continue; + } + else { + // go back to last mark + istr.unread(tmp); + return 1; + } + } + return 1; + } + + String __get_next_token(PushbackInputStream istr) { + // get next concatinates string token. consider quotes that embrace + // whitespaces + + String token = new String(""); + int tmp0 = 0; + int tmp = 0; + int last_letter = 0; + while(1+1 == 2) { + last_letter = tmp; tmp0 = istr.read(); tmp = tmp0; + if( tmp == -1 + || ((tmp == ' ' || tmp == '\t' || tmp == '\n') && last_letter != '\\') ) { + return token; + } + else if( tmp == '\'' && last_letter != '\\' ) { + // QUOTES: un-backslashed quotes => it's a string + token += __get_string(istr); + //continue; + } + else if( tmp == '{' && last_letter == '$') { + token += '{' + __get_until_closing_bracket(istr); + //continue; + } + else if( tmp == '$' && last_letter == '\\') { + token += tmp; tmp = 0; // so that last_letter will become = 0, not '$'; + //continue; + } + else if( tmp == '\\' && last_letter != '\\') + //continue; // don't append un-backslashed backslashes + token += tmp; + } + + return ""; + } + + String __get_string(PushbackInputStream istr) { + // parse input until next matching ' + + String str = new String(""); + int tmp0 = 0; + int tmp = 0; + int last_letter = 0; + while(1 + 1 == 2) { + last_letter = tmp; tmp0 = istr.read(); tmp = tmp0; + if( tmp0 == -1 ) return str; + // un-backslashed quotes => it's the end of the string + else if( tmp == '\'' && last_letter != '\\') return str; + else if( tmp == '\\' && last_letter != '\\') { + //continue; // don't append + + } else { + str += tmp; + } + } + // return str; + return ""; + } + + String __get_until_closing_bracket(PushbackInputStream istr) { + + // parse input until next matching } + String str = new String(""); + int tmp0 = 0; + int tmp = 0; + int last_letter = 0; + int brackets = 1; + while(1 + 1 == 2) { + last_letter = tmp; tmp0 = istr.read(); tmp = tmp0; + boolean vcontinue = false; + if( tmp == -1 ) return str; + else if( tmp == '{' && last_letter == '$') brackets += 1; + else if( tmp == '}') { + brackets -= 1; + // un-backslashed brackets => it's the end of the string + if( brackets == 0) return str + '}'; + else if( tmp == '\\' && last_letter != '\\') { + //continue; // do not append an unbackslashed backslash + vcontinue = true; + } + } + if( !vcontinue ) { + str += tmp; + } + } + return ""; + } + + String process_section_label(String label, + Vector section_stack) { + String sname = label; + // 1) subsection of actual section ('./' prefix) + if( sname.length() >= 2 && sname.substring(0, 2).compareTo("./") == 0) { + sname = sname.substring(2, sname.length()); + } + // 2) subsection of parent section ('../' prefix) + else if( sname.length() >= 3 && sname.substring(0, 3).compareTo("../") == 0) { + do { + if( section_stack.size() != 0 ) + section_stack.removeElementAt(section_stack.size()-1); + sname = sname.substring(3, sname.length()); + } while( sname.substring(0, 3).compareTo("../") == 0 ); + } + // 3) subsection of the root-section + else { + // a root section + section_stack.removeAllElements(); + } + + if( sname.compareTo("") != 0 ) { + // parse section name for 'slashes' + int i=0; + while( i < sname.length() ) { + if( sname.charAt(i) == '/' ) { + section_stack.addElement(sname.substring(0,i)); + if( i+1 < sname.length()-1 ) + sname = sname.substring(i+1, sname.length()); + i = 0; + } + else + i++; + } + section_stack.addElement(sname); + } + // else: "[]" => back to root section + + String section = new String(""); + if( section_stack.size() != 0 ) + for(int i=0; i< section_stack.size() ; i++) + section += (String)(section_stack.elementAt(i)) + "/"; + return section; + } + // (*) helper functions + int __convert_to_type(String S, int Default) { + int start_i = 0; + if( S.length() >= 2 && S.substring(0,2).compareTo("0x") == 0 ) start_i = 2; + else if( S.length() >=3 && S.substring(0,3).compareTo("-0x") == 0) start_i = 3; + else { + // a normal integer, not a hex number + return Integer.parseInt(S); + } + + // a hexadecimal number + int number = 0; + int i=start_i; + boolean vcontinue = true; + while( i= '0' && c <= '9') digit = c - '0'; + else if( c >= 'a' && c <= 'f') digit = c - 'a'; + else if( c >= 'A' && c <= 'F') digit = c - 'a'; + else { + //break; + vcontinue = false; + } + if( !vcontinue ) { + number *= 16; + number += digit; + } + i++; + } + if( start_i == 2 ) return number; + else return -number; + } + + double __convert_to_type(String S, double Default) { + return (double)Integer.parseInt(S); + } + + void set_prefix(String Prefix) { prefix = Prefix; } + + String __get_remaining_string(String String, String Start) { + // Checks if 'String' begins with 'Start' and returns the remaining String. + // Returns None if String does not begin with Start. + + // note: java.lang.String: substring(a,b) = from a to b-1 + // C++ string: substr(a,b) = from a to a + b + if( Start.compareTo("") == 0 ) return String; + if( String.indexOf(Start) == 0 ) return String.substring(Start.length(), String.length()); + else return ""; + } + + + /////////////////////////////////////////////////////////////////////////////// + // (*) cursor oriented functions + //............................................................................. + // + void disable_loop() { search_loop_f = false; } + void enable_loop() { search_loop_f = true; } + void reset_cursor() { search_failed_f = false; cursor = 0; } + + void init_multiple_occurrence() + { disable_loop(); reset_cursor(); } + + // -- search for a certain argument and set cursor to position + boolean search(String Option) { + int OldCursor = cursor; + String SearchTerm = prefix + Option; + + if( OldCursor >= argv.size() ) OldCursor = argv.size() - 1; + search_failed_f = true; + + // (*) first loop from cursor position until end + for(int c = cursor; c < argv.size(); c++) { + if( ((String)argv.elementAt(c)).compareTo(SearchTerm) == 0 ) + { cursor = c; search_failed_f = false; return true; } + } + if( ! search_loop_f ) return false; + + // (*) second loop from 0 to old cursor position + for(int c = 1; c < OldCursor; c++) { + if( ((String)argv.elementAt(c)).compareTo(SearchTerm) == 0 ) + { cursor = c; search_failed_f = false; return true; } + } + // in case nothing is found the cursor stays where it was + return false; + } + + + boolean search(String P[]) { + for(int i=0; i give them the 'python names' + String getitem(int idx) { + if( idx < argv.size() ) return (String)argv.elementAt(idx) ; + else return new String(""); + } + + int get(int Idx, int Default) { + if( Idx >= argv.size() ) return Default; + return __convert_to_type((String)argv.elementAt(Idx), Default); + } + + double get(int Idx, double Default) { + if( Idx >= argv.size() ) return Default; + return __convert_to_type((String)argv.elementAt(Idx), Default); + } + + String get(int Idx, String Default) { + if( Idx >= argv.size() ) return Default; + else return (String)argv.elementAt(Idx); + } + + int size() { return argv.size(); } + // -- next() function group + int next(int Default) { + if( search_failed_f ) return Default; + cursor++; + if( cursor >= argv.size() ) + { cursor = argv.size(); return Default; } + + if( prefix.compareTo("") == 0) + return __convert_to_type((String)argv.elementAt(cursor), Default); + + String Remain = __get_remaining_string((String)argv.elementAt(cursor), prefix); + + if( Remain.compareTo("") != 0 ) { + return __convert_to_type(Remain, Default); + } else { + return Default; + } + } + + double next(double Default) { + if( search_failed_f ) return Default; + cursor++; + if( cursor >= argv.size() ) + { cursor = argv.size(); return Default; } + + if( prefix.compareTo("") == 0) + return __convert_to_type((String)argv.elementAt(cursor), Default); + + String Remain = __get_remaining_string((String)argv.elementAt(cursor), prefix); + + if( Remain.compareTo("") != 0 ) { + return __convert_to_type(Remain, Default); + } else { + return Default; + } + } + + String next(String Default) { + if( search_failed_f ) return Default; + cursor++; + if( cursor >= argv.size() ) + { cursor = argv.size(); return Default; } + + if( prefix.compareTo("") == 0) + return (String)argv.elementAt(cursor); + + String Remain = __get_remaining_string((String)argv.elementAt(cursor), prefix); + + if( Remain.compareTo("") != 0 ) { + return Remain; + } else { + return Default; + } + } + // -- follow() function group + // distinct option to be searched for + int follow(int Default, String A1) { + if( search(A1) == false ) return Default; + return next(Default); + } + int follow(int Default, String A[]) { + if( search(A) == false ) return Default; + return next(Default); + } + int follow(int Default, String A1, String A2) { + if( search(A1, A2) == false ) return Default; + return next(Default); + } + int follow(int Default, String A1, String A2, String A3) { + if( search(A1, A2, A3) == false ) return Default; + return next(Default); + } + int follow(int Default, String A1, String A2, String A3, String A4) { + if( search(A1, A2, A3, A4) == false ) return Default; + return next(Default); + } + int follow(int Default, String A1, String A2, String A3, String A4, + String A5) { + if( search(A1, A2, A3, A4, A5) == false ) return Default; + return next(Default); + } + int follow(int Default, String A1, String A2, String A3, String A4, + String A5, String A6) { + if( search(A1, A2, A3, A4, A5, A6) == false ) return Default; + return next(Default); + } + + ///////// double + double follow(double Default, String A1) { + if( search(A1) == false ) return Default; + return next(Default); + } + double follow(double Default, String A[]) { + if( search(A) == false ) return Default; + return next(Default); + } + double follow(double Default, String A1, String A2) { + if( search(A1, A2) == false ) return Default; + return next(Default); + } + double follow(double Default, String A1, String A2, String A3) { + if( search(A1, A2, A3) == false ) return Default; + return next(Default); + } + double follow(double Default, String A1, String A2, String A3, String A4) { + if( search(A1, A2, A3, A4) == false ) return Default; + return next(Default); + } + double follow(double Default, String A1, String A2, String A3, String A4, + String A5) { + if( search(A1, A2, A3, A4, A5) == false ) return Default; + return next(Default); + } + double follow(double Default, String A1, String A2, String A3, String A4, + String A5, String A6) { + if( search(A1, A2, A3, A4, A5, A6) == false ) return Default; + return next(Default); + } + ///////// String ... + String follow(String Default, String A1) { + if( search(A1) == false ) return Default; + return next(Default); + } + String follow(String Default, String A[]) { + if( search(A) == false ) return Default; + return next(Default); + } + String follow(String Default, String A1, String A2) { + if( search(A1, A2) == false ) return Default; + return next(Default); + } + String follow(String Default, String A1, String A2, String A3) { + if( search(A1, A2, A3) == false ) return Default; + return next(Default); + } + String follow(String Default, String A1, String A2, String A3, String A4) { + if( search(A1, A2, A3, A4) == false ) return Default; + return next(Default); + } + String follow(String Default, String A1, String A2, String A3, String A4, + String A5) { + if( search(A1, A2, A3, A4, A5) == false ) return Default; + return next(Default); + } + String follow(String Default, String A1, String A2, String A3, String A4, + String A5, String A6) { + if( search(A1, A2, A3, A4, A5, A6) == false ) return Default; + return next(Default); + } + // (*) directly followed arguments + int direct_follow(int Default, String Option) { + String FollowStr = match_starting_string(Option); + if( FollowStr.compareTo("") == 0 ) return Default; + + int Value = __convert_to_type(FollowStr, Default); + if( ++cursor >= argv.size() ) cursor = argv.size(); + return Value; + } + + double direct_follow(double Default, String Option) { + String FollowStr = match_starting_string(Option); + if( FollowStr.compareTo("") == 0 ) return Default; + double Value = __convert_to_type(FollowStr, Default); + if( ++cursor >= argv.size() ) cursor = argv.size(); + return Value; + } + + String direct_follow(String Default, String Option) { + String FollowStr = match_starting_string(Option); + if( FollowStr.compareTo("") == 0) return Default; + if( ++cursor >= argv.size() ) cursor = argv.size(); + return FollowStr; + } + + String match_starting_string(String StartString) { + // pointer to the place where the string after + // the match inside the found argument starts. + // 0 no argument matches the starting string. + int N = StartString.length(); + int OldCursor = cursor; + if( OldCursor >= argv.size() ) OldCursor = argv.size() - 1; + search_failed_f = true; + + // (*) first loop from cursor position until end + for(int c = cursor; c < argv.size(); c++) { + String Arg = (String)argv.elementAt(c); + if( Arg.length() >= N && Arg.substring(0,N).compareTo(StartString) == 0) { + cursor = c; search_failed_f = false; + return ((String)argv.elementAt(c)).substring(N); + } + } + + if( search_loop_f == false ) return ""; + + // (*) second loop from 0 to old cursor position + for(int c = 1; c < OldCursor; c++) { + String Arg = (String)argv.elementAt(c); + if( Arg.length() >= N && Arg.substring(0,N).compareTo(StartString)==0 ) { + cursor = c; search_failed_f = false; + return ((String)argv.elementAt(c)).substring(N); + } + } + return ""; + } + /////////////////////////////////////////////////////////////////////////////// + // (*) search for flags + //............................................................................. + // + boolean options_contain(String FlagList) { + // go through all arguments that start with a '-', but not more than one + for(int i = 0; i 1 && str.charAt(0) == '-' && str.charAt(1) != '-' ) + if( check_flags(str, FlagList) ) return true; + } + return false; + } + + boolean argument_contains(int Idx, String FlagList) { + if( Idx >= argv.size() || Idx < 0) return false; + + if( prefix.compareTo("") == 0 ) + return check_flags((String)argv.elementAt(Idx), FlagList); + + // if a prefix is set, then the argument index is the index + // inside the 'namespace' + // => only check list of arguments that start with prefix + int no_matches = 0; + for(int i=0; i < argv.size(); i++) { + String Remain = __get_remaining_string((String)argv.elementAt(i), prefix); + if( Remain.compareTo("") != 0 ) { + no_matches += 1; + if( no_matches == Idx) + return check_flags(Remain, FlagList); + } + } + // no argument in this namespace + return false; + + } + + boolean check_flags(String Str, String FlagList) { + for(int i=0; i != FlagList.length() ; i++) + if( Str.indexOf(FlagList.charAt(i)) != -1 ) + // one of the flags was found in given string + return true; + return false; + } + /////////////////////////////////////////////////////////////////////////////// + // (*) nominus arguments + String[] nominus_vector() { + String nv[] = new String[idx_nominus.size()]; + int i=0; + for( ; i < idx_nominus.size(); i++) { + Integer e = (Integer)idx_nominus.elementAt(i); + nv[i] = (String)argv.elementAt(e.intValue()); + } + return nv; + } + + String next_nominus() { + if( nominus_cursor >= idx_nominus.size()-1 ) return ""; + int C = ++nominus_cursor; + return (String)argv.elementAt(((Integer)idx_nominus.elementAt(C)).intValue()); + } + + void reset_nominus_cursor() + { nominus_cursor = -1; } + + boolean search_failed() + { return search_failed_f; } + /////////////////////////////////////////////////////////////////////////////// + // (*) variables + // (no operator overloading, => functions with 'python names' for + // operators + int call(String VarName, int Default) { + variable sv = find_variable(VarName); + if( sv.name.compareTo("") == 0 ) return Default; + return __convert_to_type(sv.original, Default); + } + + double call(String VarName, double Default) { + variable sv = find_variable(VarName); + if( sv.name.compareTo("") == 0) return Default; + return __convert_to_type(sv.original, Default); + } + + String call(String VarName, String Default) { + variable sv = find_variable(VarName); + if( sv.name.compareTo("") == 0) return Default; + return sv.original; + } + + int call(String VarName, int Default, int Idx) { + variable sv = find_variable(VarName); + if( sv.name.compareTo("") == 0) return Default; + String element = sv.get_element(Idx); + if( element.compareTo("") == 0) return Default; + return __convert_to_type(element, Default); + } + + double call(String VarName, double Default, int Idx) { + variable sv = find_variable(VarName); + if( sv.name.compareTo("") == 0) return Default; + String element = sv.get_element(Idx); + if( element.compareTo("") == 0) return Default; + return __convert_to_type(element, Default); + } + + String call(String VarName, String Default, int Idx) { + variable sv = find_variable(VarName); + if( sv.name.compareTo("") == 0) return Default; + String element = sv.get_element(Idx); + if( element.compareTo("") == 0) return Default; + return element; + } + + int vector_variable_size(String VarName) { + variable sv = find_variable(VarName); + if( sv.name.compareTo("") == 0) return 0; + return sv.value.length; + } + + variable find_variable(String NameX) { + String Name = prefix + NameX; + for( int i = 0; i < variables.size(); ++i ) { + variable v = (variable)variables.elementAt(i); + if( v.name.compareTo(Name) == 0 ) return v; + } + return disjoint empty new variable("",""); + } + + String[] get_variable_names() { + Vector result = new Vector(); + int length = 0; + for( int i = 0; i < variables.size(); ++i ) { + String Name = ((variable)variables.elementAt(i)).name; + String Tmp = __get_remaining_string(Name, prefix); + if( Tmp != "") { + result.addElement(new String(Tmp)); + length++; + } + } + String end[] = new String[length]; + for( int i = 0; i < result.size(); ++i ) { + String Name = (String)result.elementAt(i); + end[i] = Name; + } + return end; + } + + /////////////////////////////////////////////////////////////////////////////// + // (*) ouput (basically for debugging reasons) + //............................................................................. + // + void print() { + System.printString("argc = " + argv.size() + "\n"); + for(int i=0; i "${x}" "${y}" + // ${& ${section} ${subsection}} -> "${section}" "${subsection}" + // ${Title} -> Nothing, variable expansion + // + // 3) DBE_expression_list(): + // + // builds a vector of unbracketed whitespace separated strings, i.e. + // + // " ${Number}.a ${: Das Marmorbild} AB-${& Author= ${Eichendorf}-1870}" + // + // is split into a vector + // + // [0] ${Number}.a + // [1] ${: Das Marmorbild} + // [2] AB-${& Author= ${Eichendorf}}-1870 + // + // Each sub-expression is expanded using expand(). + //--------------------------------------------------------------------------- + String DBE_expand_string(String str) { + // Parses for closing operators '${ }' and expands them letting + // white spaces and other letters as they are. + String new_string = ""; + int open_brackets = 0; + int first = 0; + for(int i = 0; i 0) { + open_brackets -= 1; + if( open_brackets == 0 ) { + String Replacement = DBE_expand(str.substring(first, i)); + new_string += Replacement; + } + } + else if( open_brackets == 0 ) + new_string += str.charAt(i); + } + return new_string; + } + + Vector DBE_get_expr_list(String str_, int ExpectedNumber) { + // ensures that the resulting vector has the expected number + // of arguments, but they may contain an error message + + String str = str_; + // Separates expressions by non-bracketed whitespaces, expands them + // and puts them into a list. + int i=0; + + // (1) eat initial whitespaces + boolean vcontinue = true; + while( i < str.length() && vcontinue ) { + char tmp = str.charAt(i); + if( tmp != ' ' && tmp != '\t' && tmp != '\n' ) { + //break; + vcontinue = false; + } + i++; + } + + Vector expr_list = new Vector(); + int open_brackets = 0; + Vector start_idx = new Vector(); + int start_new_string = i; + int l = str.length(); + + // (2) search for ${ } expressions ... + while( i < l ) { + char letter = str.charAt(i); + // whitespace -> end of expression + if( (letter == ' ' || letter == '\t' || letter == '\n') && open_brackets == 0) { + expr_list.addElement(str.substring(start_new_string, i)); + boolean no_breakout_f = true; + i++; + while( i < l && no_breakout_f ) { + char tmp = str.charAt(i); + if( tmp != ' ' && tmp != '\t' && tmp != '\n' ) { + no_breakout_f = false; + start_new_string = i; + //break; + } + i++; + } + if( no_breakout_f == true ) { + // end of expression list + if( expr_list.size() < ExpectedNumber ) { + String pre_tmp = "<< ${ }: missing arguments>>"; + for(int ni = expr_list.size(); ni < ExpectedNumber; ni++) + expr_list.addElement(pre_tmp); + } + return expr_list; + } + } + + // dollar-bracket expression + if( str.length() >= i+2 && str.substring(i, i+2).compareTo("${") == 0 ) { + open_brackets++; + start_idx.addElement(new Integer(i+2)); + } + else if( letter == '}' && open_brackets > 0) { + int start = ((Integer)start_idx.elementAt(start_idx.size()-1)).intValue(); + start_idx.removeElementAt(start_idx.size()-1); + String Replacement = DBE_expand(str.substring(start, i)); + if( start - 3 < 0) + str = Replacement + str.substring(i+1); + else + str = str.substring(0, start-2) + Replacement + str.substring(i+1); + l = str.length(); + i = start + Replacement.length() - 3; + open_brackets--; + } + i++; + } + + // end of expression list + expr_list.addElement(str.substring(start_new_string, i)); + + if( expr_list.size() < ExpectedNumber ) { + String pre_tmp = "<< ${ }: missing arguments>>"; + for(int ni = expr_list.size(); ni < ExpectedNumber; ni++) + expr_list.addElement(pre_tmp); + } + return expr_list; + } + + variable DBE_get_variable(String VarName) { + variable ev = disjoint dbe new variable(); + String secure_Prefix = prefix; + + prefix = section; + // (1) first search in currently active section + variable var = find_variable(VarName); + if( var.name != "" ) { prefix = secure_Prefix; return var; } + + // (2) search in root name space + prefix = ""; + var = find_variable(VarName); + if( var.name != "" ) { prefix = secure_Prefix; return var; } + + prefix = secure_Prefix; + + // error occured => variable name == "" + ev.name = ""; + ev.original = "<<${ } variable '" + VarName + "' undefined>>"; + return ev; + } + + String DBE_expand(String expr) { + // ${: } pure text + if( expr.charAt(0) == ':' ) + return expr.substring(1); + + // ${& expr expr ... } text concatination + else if( expr.charAt(0) == '&' ) { + Vector A = DBE_get_expr_list(expr.substring(1), 1); + String result = ""; + for( int i = 0; i < A.size(); ++i ) { + String add = (String)A.elementAt(i); + result += add; + } + return result; + } + + // ${<-> expr expr expr} text replacement + else if( expr.length() >= 3 && expr.substring(0, 3).compareTo("<->") == 0) { + Vector A = DBE_get_expr_list(expr.substring(3), 3); + String Arg0 = (String)A.elementAt(0); + String Arg1 = (String)A.elementAt(1); + String Arg2 = (String)A.elementAt(2); + int L = Arg1.length(); + + boolean vcontinue = true; + while( 1 + 1 == 2 && vcontinue ) { + int tmp = Arg0.indexOf(Arg1); + if( tmp == -1 ) { + //break; + vcontinue = false; + } else + if( tmp == 0 ) Arg0 = Arg2 + Arg0.substring(L); + else Arg0 = Arg0.substring(0, tmp) + Arg2 + Arg0.substring(L+tmp); + } + return Arg0; + } + // ${+ ...}, ${- ...}, ${* ...}, ${/ ...} expressions + else if( expr.charAt(0) == '+' ) { + Vector A = DBE_get_expr_list(expr.substring(1), 2); + + double result = 0.0; + + for( int i = 0; i < A.size(); ++i ) { + String add = (String)A.elementAt(i); + result += __convert_to_type(add, 0.0); + } + + return String.valueOf(result); + } + else if( expr.charAt(0) == '-' ) { + Vector A = DBE_get_expr_list(expr.substring(1), 2); + + double result = __convert_to_type((String)A.elementAt(0), 0.0); + for( int i = 1; i < A.size(); ++i ) { + String sub = (String)A.elementAt(i); + result -= __convert_to_type(sub, 0.0); + } + return String.valueOf(result); + } + else if( expr.charAt(0) == '*' ) { + Vector A = DBE_get_expr_list(expr.substring(1), 2); + + double result = 1.0; + for( int i = 0; i < A.size(); ++i ) { + String mul = (String)A.elementAt(i); + result *= __convert_to_type(mul, 0.0); + } + + return String.valueOf(result); + } + else if( expr.charAt(0) == '/' ) { + Vector A = DBE_get_expr_list(expr.substring(1), 2); + + double result = __convert_to_type((String)A.elementAt(0), 0.0); + if( result == 0 ) return "0.0"; + for( int i = 0; i < A.size(); ++i ) { + double Q = __convert_to_type((String)A.elementAt(i), 0.0); + if( Q == 0.0) return "0.0"; + result /= Q; + } + return String.valueOf(result); + } + + // ${^ ... } power expressions + else if( expr.charAt(0) == '^' ) { + Vector A = DBE_get_expr_list(expr.substring(1), 2); + + double result = __convert_to_type((String)A.elementAt(0), 0.0); + for( int i = 0; i < A.size(); ++i ) { + double p = __convert_to_type((String)A.elementAt(i), 0.0); + result = Math.pow(result, p); + } + + return String.valueOf(result); + } + + // ${== } ${<= } ${>= } comparisons (return the number of the first 'match' + else if(expr.length() >= 2 && + (expr.substring(0,2).compareTo("==") == 0 || + expr.substring(0,2).compareTo(">=") == 0 || + expr.substring(0,2).compareTo("<=") == 0 || + expr.charAt(0) == '>' || + expr.charAt(0) == '<') ) { + // differentiate between two and one sign operators + int op = 0; + // EQ = 0 GEQ = 1 LEQ = 2 GT = 3 LT = 4 + if ( expr.substring(0, 2).compareTo("==") == 0 ) op = 0; + else if ( expr.substring(0, 2).compareTo(">=") == 0 ) op = 1; + else if ( expr.substring(0, 2).compareTo("<=") == 0 ) op = 2; + else if ( expr.charAt(0) == '>' ) op = 3; + else op = 4; + + Vector a = new Vector(); + if ( op >= 3 ) a = DBE_get_expr_list(expr.substring(1), 2); + else a = DBE_get_expr_list(expr.substring(2), 2); + + + String x_orig = (String)a.elementAt(0); + double x = __convert_to_type(x_orig, 1e37); + + for( int i = 1; i < a.size(); ++i ) { + String y_orig = (String)a.elementAt(i); + double y = __convert_to_type(y_orig, 1e37); + + // set the strings as reference if something wasn't a number + if ( x == 1e37 || y == 1e37 ) { + // it's a string comparison + int comparison = x_orig.compareTo(y_orig); + + if( ( op == 0 && comparison == 0) + || (op == 1 && comparison >= 0) + || (op == 2 && comparison <= 0) + || (op == 3 && comparison > 0) + || (op == 4 && comparison < 0) ) { + return (new Integer(i)).toString(); + } + } + else { + // it's a number comparison + if( (op == 0 && x == y) || (op == 1 && x >= y) || + (op == 2 && x <= y) || (op == 3 && x > y) || + (op == 4 && x < y) ) { + return (new Integer(i)).toString(); + } + } + } + // nothing fulfills the condition => return 0 + return "0"; + } + // ${?? expr expr} select + else if( expr.length() >= 2 && expr.substring(0, 2).compareTo("??") == 0) { + Vector a = DBE_get_expr_list(expr.substring(2), 2); + double x = __convert_to_type((String)a.elementAt(0), 1e37); + // last element is always the default argument + if( x == 1e37 || x < 0 || x >= a.size() - 1 ) + return (String)a.elementAt(a.size()-1); + + // round x to closest integer + int rx = (int)Math.rint(x); + return (String)a.elementAt(rx); + } + // ${? expr expr expr} if then else conditions + else if( expr.charAt(0) == '?' ) { + Vector a = DBE_get_expr_list(expr.substring(1), 2); + if( __convert_to_type((String)a.elementAt(0), 0.0) == 1.0 ) + return (String)a.elementAt(1); + else if( a.size() > 2 ) + return (String)a.elementAt(2); + } + // ${! expr} maxro expansion + else if( expr.charAt(0) == '!' ) { + variable Var = DBE_get_variable(expr.substring(1)); + // error + if( Var.name == "" ) return Var.original; + + Vector A = DBE_get_expr_list(Var.original, 2); + return (String)A.elementAt(0); + } + // ${@: } - string subscription + else if( expr.length() >=2 && expr.substring(0,2).compareTo("@:") == 0 ) { + Vector A = DBE_get_expr_list(expr.substring(2), 2); + double x = __convert_to_type((String)A.elementAt(1), 1e37); + + // last element is always the default argument + if( x == 1e37 || x < 0 || x >= (double)((String)A.elementAt(0)).length() - 1) + return "<<1st index out of range>>"; + + if( A.size() > 2 ) { + double y = __convert_to_type((String)A.elementAt(2), 1e37); + if ( y != 1e37 && y > 0 && y <= (double)((String)A.elementAt(0)).length() - 1 && y > x ) { + // note: java.lang.String: substring(a,b) = from a to b - 1 + // C++ string: substr(a,b) = from a to a + b + int rx1 = (int)Math.rint(x); + int rx2 = (int)Math.rint(y + 1.0); + return ((String)A.elementAt(0)).substring(rx1, rx2); + } + else if( y == -1 ) { + int rx = (int)Math.rint(x); + return ((String)A.elementAt(0)).substring(rx); + } + return "<<2nd index out of range>>"; + } + else { + String tmp = (String)A.elementAt(0); + int rx = (int)Math.rint(x); + return (String)tmp.substring(rx, rx+1); + } + } + // ${@ } - vector subscription + else if( expr.charAt(0) == '@' ) { + Vector A = DBE_get_expr_list(expr.substring(1), 2); + variable Var = DBE_get_variable((String)A.elementAt(0)); + // error + if( Var.name == "" ) { + // make a copy of the string if an error occured + // (since the error variable is a static variable inside get_variable()) + return Var.original; + } + + double x = __convert_to_type((String)A.elementAt(1), 1e37); + + // last element is always the default argument + if (x == 1e37 || x < 0 || x >= Var.value.length ) + return "<<1st index out of range>>"; + + if ( A.size() > 2) { + double y = __convert_to_type((String)A.elementAt(2), 1e37); + int begin = (int)Math.rint(x); + int end = 0; + if ( y != 1e37 && y > 0 && y <= Var.value.length && y > x) + end = (int)Math.rint(y + 1.0); + else if( y == -1 ) + end = Var.value.length; + else + return "<<2nd index out of range>>"; + + String result = Var.get_element(begin); + for(int i = begin+1; i < end; i++) + result += " " + Var.get_element(i); + return result; + } + else { + int tmp = (int)Math.rint(x); + return Var.get_element(tmp); + } + } + Vector A = DBE_get_expr_list(expr, 1); + variable B = DBE_get_variable((String)A.elementAt(0)); + + // make a copy of the string if an error occured + // (since the error variable is a static variable inside get_variable()) + if( B.name == "" ) return (String)B.original; + else return B.original; + } + + /////////////////////////////////////////////////////////////////////////////// + // (*) unidentified flying objects + //............................................................................. + // + String[] string_vector_to_string_array(Vector Vec) { + String[] result = new String[Vec.size()]; + for(int i =0; i < Vec.size(); i++ ) + result[i] = (String)Vec.elementAt(i); + return result; + } + + int __search_string_array(String[] Arr, String Str) { + for(int i=0; i < Arr.length ; i++) + if( Str.compareTo(Arr[i]) == 0 ) return i; + return -1; + } + + String[] unidentified_arguments(String KnownArguments[]) { + Vector ufos = new Vector(); + if( argv.size() == 0 ) + return string_vector_to_string_array(ufos); + + // forget about first element (application name) + for( int i = 1; i < argv.size(); ++i ) { + String it = (String)argv.elementAt(i); + // -- argument belongs to prefixed section ? + String arg = __get_remaining_string(it, prefix); + if( arg == "" ) { + //continue; + } else + + // -- check if argument is known + if( __search_string_array(KnownArguments, arg) == -1 ) + ufos.addElement(it); + } + return string_vector_to_string_array(ufos); + } + + + String[] unidentified_options(String KnownOptions[]) { + Vector ufos = new Vector(); + + if( argv.size() == 0 ) + return string_vector_to_string_array(ufos); + + // forget about first element (application name) + for( int i = 1; i < argv.size(); ++i ) { + String it = (String)argv.elementAt(i); + // -- argument belongs to prefixed section ? + String arg = __get_remaining_string(it, prefix); + if( arg == "" ) { + //continue; + } else + // -- argument == option ? + if( arg.length() < 1 || arg.charAt(0) != '-' ) { + //continue; + } else + // -- check if argument is known + if( __search_string_array(KnownOptions, arg) == -1 ) + ufos.addElement(it); + } + return string_vector_to_string_array(ufos); + } + + String unidentified_flags(String KnownFlagList) { + return unidentified_flags(KnownFlagList, -1); + } + + String unidentified_flags(String KFL, int ArgumentNumber) { + // Two modes: + // ArgumentNumber >= 0 check specific argument + // ArgumentNumber == -1 check all options starting with one '-' + // for flags + + String ufos = ""; + Vector known_arguments; + + // (2) iteration over '-' arguments (options) + if( ArgumentNumber == -1 ) { + // iterate over all arguments + if( argv.size() == 0 ) return ufos; + // forget about first element (application name) + for( int j = 1; j < argv.size(); ++j ) { + String it = (String)argv.elementAt(j); + // -- argument belongs to prefixed section ? + String arg = __get_remaining_string(it, prefix); + if( arg == "" ) { + //continue; + } else + + // does arguments start with '-' (but not '--') + if ( arg.length() < 2 ) { + //continue; + } + else if( arg.charAt(0) != '-' ) { + //continue; + } + else if( arg.charAt(1) == '-' ) { + //continue; + } else { + // -- check out if flags inside option are contained in KnownFlagList + for(int i=1; i check it for flags + for(int i=0; i not a nomius + if( arg.charAt(0) == '-' ) { + //continue; + } else + // section ? --> not a real nominus + if( arg.charAt(0) == '[' && arg.charAt(arg.length()-1) == ']' ) { + //continue; + } + // variable definition ? --> not a real nominus + boolean continue_f = false; + int i=0; + while( i quote +latex-formula = '\\kappa\' = \\frac{d}{d s} \\kappa' +# (3) double backslash in quotes = backslash +dos-file = 'C:\\Program Files\\Applications' + +# (*) -------------------------------------------------------------------------- +# examples using the prefix filter (filter.py/.cpp/.java etc.) +#------------------------------------------------------------------------------- +[group] +# playing with pseudo command line arguments: +# note that +# '-x', '3134' and '--rudimental' +# will be known as +# 'flags/-x', 'flags/3234' and 'flags/rudimental'. +# +# Therefore 3134, for example, is **NOT** a number as long, +# as no prefix filter "flags/" is set. +-x 3134 +--rudimental 12 777 + +[other] +# this section will be skipped by the 'next' function when the prefix +# is set +nonsense + + +[user-variables] +# This section contains variables that the user defined himself. +# The GetPot interpreter uses 'get_variable_names()' in order to +# get to know their names. +preview-coefficient = '12 cm' +lateral-side-distance = '2.1 m/s' +control-interval = '0.1 s' +compensation-ratio = '0.4e34 rad/(m*s)' + +[pseudo-function-calls] +# The following code shows how GetPot can be used to emulate +# trivial function calls. Please, note that no syntax checking +# can be provided by this method. +LE-DEBUT +smiley sad +new-line 1 +# draw rectangle width = 40, height = 10 +rectangle 40 10 +new-line 1 +smiley happy +# draw circle radius = 15 +circle 15 +new-line 1 +smiley happy +new-line 2 +LA-FIN + diff --git a/Robust/src/Benchmarks/mlp/getpot-java/mergeExamples/makefile b/Robust/src/Benchmarks/mlp/getpot-java/mergeExamples/makefile new file mode 100644 index 00000000..9b069e5f --- /dev/null +++ b/Robust/src/Benchmarks/mlp/getpot-java/mergeExamples/makefile @@ -0,0 +1,28 @@ +MAIN_CLASS=Example + +PROGRAM=test +SOURCE_FILES=*.java + +BUILDSCRIPT=~/research/Robust/src/buildscript +BSFLAGS= -mainclass $(MAIN_CLASS) -justanalyze -ownership -ownallocdepth 1 -ownwritedots final -enable-assertions + +all: $(PROGRAM).bin + +view: PNGs + eog *.png & + +PNGs: DOTs + d2p *COMPLETE*.dot + +DOTs: $(PROGRAM).bin + +$(PROGRAM).bin: $(SOURCE_FILES) + $(BUILDSCRIPT) $(BSFLAGS) -o $(PROGRAM) $(SOURCE_FILES) + +clean: + rm -f $(PROGRAM).bin + rm -fr tmpbuilddirectory + rm -f *~ + rm -f *.dot + rm -f *.png + rm -f aliases.txt diff --git a/Robust/src/Benchmarks/mlp/getpot-java/original/DirectFollow.java b/Robust/src/Benchmarks/mlp/getpot-java/original/DirectFollow.java new file mode 100755 index 00000000..eddfe91d --- /dev/null +++ b/Robust/src/Benchmarks/mlp/getpot-java/original/DirectFollow.java @@ -0,0 +1,77 @@ +// -*- java -*- +// FILE: DirectFollow.java +// (C) 2001 Frank R. Schaefer +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +////////////////////////////////////////////////////////////////////////////////////// +import GetPot.*; +import java.lang.String; + +public class DirectFollow { + public static void main(String args []) { + GetPot cl = new GetPot(args, "DirectFollow"); + + if( cl.size() == 1 || cl.search("--help", "-h") ) print_help("DirectFollow"); + + // Specify, that in case the cursor reaches the end of argument list, + // it is not automatically reset to the start. This way the search + // functions do not wrap around. Instead, they notify an 'not fount' + // in case the option was not in between 'cursor' and the argv.end(). + cl.reset_cursor(); + cl.disable_loop(); + + // check out 'String' versions + String User = cl.direct_follow("You", "-U"); + String User2 = cl.direct_follow("Karl", "-U"); + String User3 = cl.direct_follow("Heinz", "-U"); + + // check out 'double' versions + cl.reset_cursor(); + double Value = cl.direct_follow(3.14, "-V"); + double Value2 = cl.direct_follow(9.81, "-V"); + double Value3 = cl.direct_follow(1.62, "-V"); + + // check out 'integer' versions + cl.reset_cursor(); + int Number = cl.direct_follow(12, "-NUM"); + int Number2 = cl.direct_follow(43, "-NUM"); + int Number3 = cl.direct_follow(64, "-NUM"); + + something(User, User2, User3, Value, Value2, Value3, Number, Number2, Number3); + } + + static void something(String User, String User2, String User3, + double Value, double Value2, double Value3, + int Number, int Number2, int Number3) { + System.out.println("Users = " + User + ", " + User2 + ", " + User3); + System.out.println("Values = " + Value + ", " + Value2 + ", " + Value3); + System.out.println("Numbers = " + Number + ", " + Number2 + ", " + Number3); + } + + static void print_help(String Application) { + System.out.println(); + System.out.println("Example to use direct_follow()-functions:"); + System.out.println("USAGE:"); + System.out.println("--help, -h get some help about this program."); + System.out.println(); + System.out.println("-Ustring specify user name as string"); + System.out.println("-Vx specify a value given as x"); + System.out.println("-NUMx specify number given as x"); + System.out.println(); + System.out.println("a total amount of three of each is expected."); + System.out.println(); + System.exit(0); + } +} diff --git a/Robust/src/Benchmarks/mlp/getpot-java/original/Expand.java b/Robust/src/Benchmarks/mlp/getpot-java/original/Expand.java new file mode 100644 index 00000000..693b3ece --- /dev/null +++ b/Robust/src/Benchmarks/mlp/getpot-java/original/Expand.java @@ -0,0 +1,142 @@ +// -*- java -*- +// FILE: Expand.java +// (C) 2002 Frank R. Schaefer +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +////////////////////////////////////////////////////////////////////////////////// + +import GetPot.*; +import java.lang.String; + +public class Expand { + public static void main(String args []) { + GetPot cl = new GetPot(args, "Get"); + GetPot ifpot = new GetPot("expand.pot"); + + if( cl.search("--internal-information", "-i") ) { + ifpot.print(); + System.exit(0); + } + + // (*) help display + if( cl.search("--help", "-h", "--hilfe", "--sos") || cl.search("--ok") == false ) { + String msg = "Example how to use GetPot to parse input files.\n\n" + + "USAGE:\n" + + "--ok\n" + + " run the input file parsing.\n" + + "--help, -h, --hilfe, --sos\n" + + " get some help about this program.\n\n" + + "--internal-information, -i\n" + + " show contents of database that was created by file parser.\n" + + "--infile string\n" + + " input file name (default: example.pot)"; + my_print(msg); + System.exit(0); + } + + // (*) example usage + my_print("[1.1]--------------------------------------------------------------------------"); + my_print("Information 0: ", ifpot.call("info0", "nobody")); + + ifpot.set_prefix("1.2/"); + my_print("[1.2]--------------------------------------------------------------------------"); + my_print("Information 0: ", ifpot.call("info0", "(nothing)")); + my_print("Information 1: ", ifpot.call("info1", "(nothing)")); + + ifpot.set_prefix("1.3/"); + my_print("[1.3]--------------------------------------------------------------------------"); + my_print("Information 0: ", ifpot.call("info0", "(nothing)")); + my_print("Information 1: ", ifpot.call("info1", "(nothing)")); + + ifpot.set_prefix("1.4/"); + my_print("[1.4]--------------------------------------------------------------------------"); + my_print("Information 0: ", ifpot.call("info0", "(nothing)")); + my_print("Information 1: ", ifpot.call("info1", "(nothing)")); + + ifpot.set_prefix("2.1/"); + my_print("[2.1]--------------------------------------------------------------------------"); + my_print("Information 0: ", ifpot.call("info0", "(nothing)")); + my_print("Information 1: ", ifpot.call("info1", "(nothing)")); + my_print("Information 2: ", ifpot.call("info2", "(nothing)")); + + ifpot.set_prefix("2.2/"); + my_print("[2.2]--------------------------------------------------------------------------"); + my_print("Information 0: ", ifpot.call("info0", "(nothing)")); + my_print("Information 1: ", ifpot.call("info1", "(nothing)")); + + ifpot.set_prefix("2.3/"); + my_print("[2.3]--------------------------------------------------------------------------"); + my_print("Information 0: ", ifpot.call("info0", "(nothing)")); + my_print("Information 1: ", ifpot.call("info1", "(nothing)")); + my_print("Information 2: ", ifpot.call("info2", "(nothing)")); + + ifpot.set_prefix("3.1/"); + my_print("[3]--------------------------------------------------------------------------"); + my_print("Information 0: ", ifpot.call("info0", "(nothing)")); + my_print("Information 1: ", ifpot.call("info1", "(nothing)")); + my_print("Information 2: ", ifpot.call("info2", "(nothing)")); + my_print("Information 3: ", ifpot.call("info3", "(nothing)")); + my_print("Information 4: ", ifpot.call("info4", "(nothing)")); + my_print("Information 5: ", ifpot.call("info5", "(nothing)")); + my_print("Information 6: ", ifpot.call("info6", "(nothing)")); + my_print("Information 7: ", ifpot.call("info7", "(nothing)")); + + ifpot.set_prefix("3.2/"); + my_print("[3.2]--------------------------------------------------------------------------"); + my_print("Information 0: ", ifpot.call("info0", "(nothing)")); + my_print("Information 1: ", ifpot.call("info1", "(nothing)")); + + ifpot.set_prefix("3.3/"); + my_print("[3.3]--------------------------------------------------------------------------"); + my_print("Information 0: ", ifpot.call("info0", "(nothing)")); + my_print("Information 1: ", ifpot.call("info1", "(nothing)")); + my_print("Information 2: ", ifpot.call("info2", "(nothing)")); + my_print("Information 3: ", ifpot.call("info3", "(nothing)")); + my_print("Information 4: ", ifpot.call("info4", "(nothing)")); + my_print("Information 5: ", ifpot.call("info5", "(nothing)")); + my_print("Information 6: ", ifpot.call("info6", "(nothing)")); + my_print("Information 7: ", ifpot.call("info7", "(nothing)")); + + ifpot.set_prefix("3.4/"); + my_print("[3.4]--------------------------------------------------------------------------"); + my_print("Information 0: ", ifpot.call("info0", "(nothing)")); + my_print("Information 1: ", ifpot.call("info1", "(nothing)")); + my_print("Information 2: ", ifpot.call("info2", "(nothing)")); + + ifpot.set_prefix("3.5/"); + my_print("[3.5]--------------------------------------------------------------------------"); + my_print("Information 0: ", ifpot.call("info0", "(nothing)")); + my_print("Information 1: ", ifpot.call("info1", "(nothing)")); + my_print("Information 2: ", ifpot.call("info2", "(nothing)")); + my_print("Information 3: ", ifpot.call("info3", "(nothing)")); + my_print("Information 4: ", ifpot.call("info4", "(nothing)")); + my_print("Information 5: ", ifpot.call("info5", "(nothing)")); + my_print("Information 6: ", ifpot.call("info6", "(nothing)")); + my_print("Information 7: ", ifpot.call("info7", "(nothing)")); + + ifpot.set_prefix("3.6/"); + my_print("[3.6]--------------------------------------------------------------------------"); + my_print("Information 0: ", ifpot.call("info0", "(nothing)")); + my_print("Information 1: ", ifpot.call("info1", "(nothing)")); + } + + static void my_print(String Str) { + System.out.println(Str); + } + + static void my_print(String Str1, String Str2) { + System.out.println(Str1 + Str2); + } +} diff --git a/Robust/src/Benchmarks/mlp/getpot-java/original/Filter.java b/Robust/src/Benchmarks/mlp/getpot-java/original/Filter.java new file mode 100644 index 00000000..fd18e3ec --- /dev/null +++ b/Robust/src/Benchmarks/mlp/getpot-java/original/Filter.java @@ -0,0 +1,143 @@ +// -*- java -*- +// FILE: Filter.java +// (C) 2002 Frank R. Schaefer +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +/////////////////////////////////////////////////////////////////////////////////// +import GetPot.*; +import java.lang.String; + +public class Filter { + + static double Sqr(double x) { return x*x; } + + + public static void main(String args[]) { + GetPot cl = new GetPot(args, "Filter"); + GetPot ifpot = new GetPot("example.pot"); + + // (1) search for multiple options with the same meaning + if( cl.search("--help", "-h", "--hilfe", "--sos") ) { + String Msg = "Example program treating the prefix filtering.\n\n" + + " Using the function .set_prefix(section) only arguments, options \n" + + " variables are considered in the given 'section'\n\n" + + "--help, -h, --hilfe, --sos \n" + + " this page.\n" + + "--nice \n" + + " demonstrates how pseudo function calls can be accomplished.\n\n" + + "please refer to the file 'example.pot' as input file.\n"; + System.out.println(Msg); + System.exit(0); + } + + // -- note that the prefix is not considered as a flag + // -- the index in 'argument contains' indicates the position + // of the argument inside the namespace given by prefix + ifpot.set_prefix("group/"); + + System.out.println(" -- flags in options / arguments"); + boolean first_f = ifpot.argument_contains(1, "xX"); + boolean second_f = ifpot.argument_contains(1, "cCkK"); + boolean abc_f = ifpot.options_contain("abc"); + System.out.println(" Flags in first argument in [flags]\n"); + System.out.println(" x or X in arg 1 = " + first_f); + System.out.println(" c, C, k or K in arg 1 = " + second_f); + System.out.println(" a,b, or c in options = " + abc_f); + System.out.println(""); + System.out.println(" -- search(), next() and follow()"); + System.out.println(""); + System.out.println(" found \"--rudimental\" = " + ifpot.search("--rudimental")); + + int Tmp1 = ifpot.next(-1); + int Tmp2 = ifpot.next(-1); + System.out.println(" followed by " + Tmp1 + " " + Tmp2); + + String Tmp3 = ifpot.follow("nothing", "--rudimental"); + int Tmp4 = ifpot.next(-1); + System.out.println(" rudimental = " + Tmp3 + ", " + Tmp4 + "\n"); + + // -- variables + System.out.println(""); + System.out.println(" -- variables in section [user-variables]"); + System.out.println(""); + ifpot.set_prefix("user-variables/"); + + String variable_names[] = ifpot.get_variable_names(); + for(int i=0; i < variable_names.length ; i++) { + String name = variable_names[i]; + System.out.print(" " + name + " \t= "); + System.out.print(ifpot.call(name, 1e37, 0)); + System.out.print("[" + ifpot.call(name, "[1]", 1) + "]\n"); + } + System.out.println(""); + + // -- pseudo function calls + if( cl.search("--nice") ) { + System.out.println(" -- pseudo function call feature"); + System.out.println(""); + ifpot.set_prefix("pseudo-function-calls/"); + ifpot.init_multiple_occurrence(); + + ifpot.search("LE-DEBUT"); + while( 1 + 1 == 2 ) { + String Next = ifpot.next("(no-func)"); + + if( Next.compareTo("(no-func)") == 0 ) break; + else if( Next.compareTo("rectangle") == 0) { + int size_x = ifpot.next(10); + int size_y = ifpot.next(10); + System.out.print("\n"); + for(int y=0; y < size_y; y++) { + for(int x=0; x < size_x; x++) { + System.out.print("*"); + } + System.out.print("\n"); + } + } + else if( Next.compareTo("circle") == 0) { + int radius = ifpot.next(4); + System.out.println("\n"); + for(int y=0; y < radius*2 + 1; y++) { + for(int x=0; x < radius*2 + 1; x++) + if( Sqr(x-radius) + Sqr(y-radius) <= Sqr(radius) + && Sqr(x-radius) + Sqr(y-radius) >= Sqr(radius)/4. ) + System.out.print("."); + else + System.out.print(" "); + System.out.print("\n"); + } + } + else if( Next.compareTo("smiley") == 0 ) { + String Mood = ifpot.next("happy"); + if( Mood.compareTo("sad") == 0 ) System.out.print(":( "); + else System.out.print(":) "); + } + else if( Next.compareTo("new-line") == 0 ) { + int No = ifpot.next(1); + for(int i=0; i value.length ) return new String(""); + else return value[Idx]; + } + + void take(String Value) { + original = Value; + StringTokenizer st = new StringTokenizer(Value); + value = new String[st.countTokens()]; + for(int i =0; st.hasMoreTokens(); i++ ) + value[i] = st.nextToken(); + } + // (*) data memebers + String name; // identifier of variable + String value[]; // value of variable stored in vector + String original; // value of variable as given on command line + }; + String prefix; // prefix indicating section for search + String section; // section for dollar bracket parsing + Vector argv; // String[] + Vector section_list; + int cursor; + Vector idx_nominus; // int[] + int nominus_cursor; + boolean search_loop_f; + boolean search_failed_f; + Vector variables; // class variable + + + // (*) constructor + GetPot(String argv_[], String applicationName) { + prefix = ""; + cursor = 0; + nominus_cursor = -1; + search_loop_f = true; + search_failed_f = false; + + Vector __argv = new Vector(); + idx_nominus = new Vector(); + variables = new Vector(); + section_list = new Vector(); + + // in java the argv[0] does not contain the application name + // => append application name to argv vector by hand + + for(int i=0; i < argv_.length ; i++) { + String copied_str = new String(argv_[i]); + __argv.addElement(copied_str); + } + + argv = new Vector(); + __argv.insertElementAt(applicationName, 0); + __parse_argument_vector(__argv); + } + + GetPot(String FileName) { + prefix = ""; + cursor = 0; + nominus_cursor = -1; + search_loop_f = true; + search_failed_f = false; + + Vector __argv = new Vector(); + idx_nominus = new Vector(); + variables = new Vector(); + section_list = new Vector(); + + __argv = read_in_file(FileName); + + argv = new Vector(); + __argv.insertElementAt(FileName, 0); + __parse_argument_vector(__argv); + } + + void __parse_argument_vector(Vector _argv) { + // build internal database + // 1) array with no-minus arguments (usually used as filenames) + // 2) section label treatment + // 3) variable assignments: + // 'variable name' '=' number | string + int i=0; + section = ""; + Vector section_stack = new Vector(); + if( _argv.size() < 1 ) return; + + for(Enumeration arge = _argv.elements(); arge.hasMoreElements() ;i++) { + String arg = (String)arge.nextElement(); + + if( i == 0 ) { argv.addElement(arg); continue; } + if( arg.length() == 0) continue; + + // -- [section] labels + if( arg.length() > 1 && arg.charAt(0) == '[' && arg.charAt(arg.length()-1) == ']' ) { + String name = DBE_expand_string(arg.substring(1, arg.length()-1)); + // String name = arg.substring(1, arg.length()-1); + section = process_section_label(name, section_stack); + // new section --> append to list of sections + if( section_list.indexOf(section) == -1 ) + if( section.length() != 0 ) section_list.addElement(section); + argv.addElement(arg); + } + else { + arg = section + DBE_expand_string(arg); + argv.addElement(arg); + } + + // 1) separate array for nominus arguments + if( arg.charAt(0) != '-' ) + idx_nominus.addElement(new Integer(i)); + + // 2) variables: does _argv[i] contain a '=' operator ? + int k = arg.indexOf('='); + if( k > 0 ) { + variable Var = find_variable(arg.substring(0,k)); + if( Var.name.compareTo("") == 0 ) + variables.addElement(new variable(arg.substring(0,k), + arg.substring(k+1))); + else + Var.take(arg.substring(k+1)); + } + } + } + // file parsing + Vector read_in_file(String filename) { + Vector Empty = new Vector(); + try { + InputStream i = new FileInputStream(filename); + if( i.available() == 0 ) return Empty; + // argv[0] == the filename of the file that was read in + return read_in_stream(new PushbackInputStream(i)); + } + catch(FileNotFoundException ID_10T) { return Empty; } + catch(IOException ID_20T) { return Empty; } + } + + Vector read_in_stream(PushbackInputStream istr) { + Vector brute_tokens = new Vector(); + String token; + Vector arglist = new Vector(); + + while( 1 + 1 == 2 ) { + if( __skip_whitespace(istr) == -1 ) break; + token = __get_next_token(istr); + if( token.length() == 0 ) break; + brute_tokens.addElement(token); + } + + // for(int i=0; i skip until end of line + do { tmp = istr.read(); if( tmp == -1 ) return -1; } + while( (char)tmp != '\n' ); + + istr.unread(tmp); + continue; + } + else { + // go back to last mark + istr.unread(tmp); + return 1; + } + } + } + catch(IOException ID_10T) {} + return 1; + } + + String __get_next_token(PushbackInputStream istr) { + // get next concatinates string token. consider quotes that embrace + // whitespaces + try { + String token = new String(""); + int tmp0 = 0; + char tmp = 0; + char last_letter = 0; + while(1+1 == 2) { + last_letter = tmp; tmp0 = istr.read(); tmp = (char)tmp0; + if( tmp == -1 + || ((tmp == ' ' || tmp == '\t' || tmp == '\n') && last_letter != '\\') ) { + return token; + } + else if( tmp == '\'' && last_letter != '\\' ) { + // QUOTES: un-backslashed quotes => it's a string + token += __get_string(istr); + continue; + } + else if( tmp == '{' && last_letter == '$') { + token += '{' + __get_until_closing_bracket(istr); + continue; + } + else if( tmp == '$' && last_letter == '\\') { + token += tmp; tmp = 0; // so that last_letter will become = 0, not '$'; + continue; + } + else if( tmp == '\\' && last_letter != '\\') + continue; // don't append un-backslashed backslashes + token += tmp; + } + } + catch(IOException ID_10T) {} + return ""; + } + + String __get_string(PushbackInputStream istr) { + // parse input until next matching ' + + try { + String str = new String(""); + int tmp0 = 0; + char tmp = 0; + char last_letter = 0; + while(1 + 1 == 2) { + last_letter = tmp; tmp0 = istr.read(); tmp = (char)tmp0; + if( tmp0 == -1 ) return str; + // un-backslashed quotes => it's the end of the string + else if( tmp == '\'' && last_letter != '\\') return str; + else if( tmp == '\\' && last_letter != '\\') continue; // don't append + + str += tmp; + } + // return str; + } + catch(IOException ID_10T) {} + return ""; + } + + String __get_until_closing_bracket(PushbackInputStream istr) { + try { + // parse input until next matching } + String str = new String(""); + int tmp0 = 0; + char tmp = 0; + char last_letter = 0; + int brackets = 1; + while(1 + 1 == 2) { + last_letter = tmp; tmp0 = istr.read(); tmp = (char)tmp0; + if( tmp == -1 ) return str; + else if( tmp == '{' && last_letter == '$') brackets += 1; + else if( tmp == '}') { + brackets -= 1; + // un-backslashed brackets => it's the end of the string + if( brackets == 0) return str + '}'; + else if( tmp == '\\' && last_letter != '\\') + continue; // do not append an unbackslashed backslash + } + str += tmp; + } + } + catch(IOException ID_10T) {} + return ""; + } + + String process_section_label(String label, + Vector section_stack) { + String sname = label; + // 1) subsection of actual section ('./' prefix) + if( sname.length() >= 2 && sname.substring(0, 2).compareTo("./") == 0) { + sname = sname.substring(2, sname.length()); + } + // 2) subsection of parent section ('../' prefix) + else if( sname.length() >= 3 && sname.substring(0, 3).compareTo("../") == 0) { + do { + if( section_stack.size() != 0 ) + section_stack.removeElementAt(section_stack.size()-1); + sname = sname.substring(3, sname.length()); + } while( sname.substring(0, 3).compareTo("../") == 0 ); + } + // 3) subsection of the root-section + else { + // a root section + section_stack.removeAllElements(); + } + + if( sname.compareTo("") != 0 ) { + // parse section name for 'slashes' + int i=0; + while( i < sname.length() ) { + if( sname.charAt(i) == '/' ) { + section_stack.addElement(sname.substring(0,i)); + if( i+1 < sname.length()-1 ) + sname = sname.substring(i+1, sname.length()); + i = 0; + } + else + i++; + } + section_stack.addElement(sname); + } + // else: "[]" => back to root section + + String section = new String(""); + if( section_stack.size() != 0 ) + for(int i=0; i< section_stack.size() ; i++) + section += (String)(section_stack.elementAt(i)) + "/"; + return section; + } + // (*) helper functions + int __convert_to_type(String S, int Default) { + int start_i = 0; + if( S.length() >= 2 && S.substring(0,2).compareTo("0x") == 0 ) start_i = 2; + else if( S.length() >=3 && S.substring(0,3).compareTo("-0x") == 0) start_i = 3; + else { + // a normal integer, not a hex number + try { return Integer.parseInt(S); } + catch(NumberFormatException ID_10T) { + try { return (int)java.lang.Math.rint(Double.valueOf(S).doubleValue()); } + catch(NumberFormatException ID_20T) { return Default; } + } + } + + // a hexadecimal number + int number = 0; + for(int i=start_i; i= '0' && c <= '9') digit = c - '0'; + else if( c >= 'a' && c <= 'f') digit = c - 'a'; + else if( c >= 'A' && c <= 'F') digit = c - 'a'; + else + break; + number *= 16; + number += digit; + } + if( start_i == 2 ) return number; + else return -number; + } + + double __convert_to_type(String S, double Default) { + try { return Double.valueOf(S).doubleValue(); } + catch(NumberFormatException ID_10T) { return Default; } + } + + void set_prefix(String Prefix) { prefix = Prefix; } + + String __get_remaining_string(String String, String Start) { + // Checks if 'String' begins with 'Start' and returns the remaining String. + // Returns None if String does not begin with Start. + + // note: java.lang.String: substring(a,b) = from a to b-1 + // C++ string: substr(a,b) = from a to a + b + if( Start.compareTo("") == 0 ) return String; + if( String.indexOf(Start) == 0 ) return String.substring(Start.length(), String.length()); + else return ""; + } + + + /////////////////////////////////////////////////////////////////////////////// + // (*) cursor oriented functions + //............................................................................. + // + void disable_loop() { search_loop_f = false; } + void enable_loop() { search_loop_f = true; } + void reset_cursor() { search_failed_f = false; cursor = 0; } + + void init_multiple_occurrence() + { disable_loop(); reset_cursor(); } + + // -- search for a certain argument and set cursor to position + boolean search(String Option) { + int OldCursor = cursor; + String SearchTerm = prefix + Option; + + if( OldCursor >= argv.size() ) OldCursor = argv.size() - 1; + search_failed_f = true; + + // (*) first loop from cursor position until end + for(int c = cursor; c < argv.size(); c++) { + if( ((String)argv.elementAt(c)).compareTo(SearchTerm) == 0 ) + { cursor = c; search_failed_f = false; return true; } + } + if( ! search_loop_f ) return false; + + // (*) second loop from 0 to old cursor position + for(int c = 1; c < OldCursor; c++) { + if( ((String)argv.elementAt(c)).compareTo(SearchTerm) == 0 ) + { cursor = c; search_failed_f = false; return true; } + } + // in case nothing is found the cursor stays where it was + return false; + } + + + boolean search(String P[]) { + for(int i=0; i give them the 'python names' + String getitem(int idx) { + if( idx < argv.size() ) return (String)argv.elementAt(idx) ; + else return new String(""); + } + + int get(int Idx, int Default) { + if( Idx >= argv.size() ) return Default; + return __convert_to_type((String)argv.elementAt(Idx), Default); + } + + double get(int Idx, double Default) { + if( Idx >= argv.size() ) return Default; + return __convert_to_type((String)argv.elementAt(Idx), Default); + } + + String get(int Idx, String Default) { + if( Idx >= argv.size() ) return Default; + else return (String)argv.elementAt(Idx); + } + + int size() { return argv.size(); } + // -- next() function group + int next(int Default) { + if( search_failed_f ) return Default; + cursor++; + if( cursor >= argv.size() ) + { cursor = argv.size(); return Default; } + + if( prefix.compareTo("") == 0) + return __convert_to_type((String)argv.elementAt(cursor), Default); + + String Remain = __get_remaining_string((String)argv.elementAt(cursor), prefix); + + return Remain.compareTo("") != 0 ? __convert_to_type(Remain, Default) : Default; + } + + double next(double Default) { + if( search_failed_f ) return Default; + cursor++; + if( cursor >= argv.size() ) + { cursor = argv.size(); return Default; } + + if( prefix.compareTo("") == 0) + return __convert_to_type((String)argv.elementAt(cursor), Default); + + String Remain = __get_remaining_string((String)argv.elementAt(cursor), prefix); + + return Remain.compareTo("") != 0 ? __convert_to_type(Remain, Default) : Default; + } + + String next(String Default) { + if( search_failed_f ) return Default; + cursor++; + if( cursor >= argv.size() ) + { cursor = argv.size(); return Default; } + + if( prefix.compareTo("") == 0) + return (String)argv.elementAt(cursor); + + String Remain = __get_remaining_string((String)argv.elementAt(cursor), prefix); + + return Remain.compareTo("") != 0 ? Remain : Default; + } + // -- follow() function group + // distinct option to be searched for + int follow(int Default, String A1) { + if( search(A1) == false ) return Default; + return next(Default); + } + int follow(int Default, String A[]) { + if( search(A) == false ) return Default; + return next(Default); + } + int follow(int Default, String A1, String A2) { + if( search(A1, A2) == false ) return Default; + return next(Default); + } + int follow(int Default, String A1, String A2, String A3) { + if( search(A1, A2, A3) == false ) return Default; + return next(Default); + } + int follow(int Default, String A1, String A2, String A3, String A4) { + if( search(A1, A2, A3, A4) == false ) return Default; + return next(Default); + } + int follow(int Default, String A1, String A2, String A3, String A4, + String A5) { + if( search(A1, A2, A3, A4, A5) == false ) return Default; + return next(Default); + } + int follow(int Default, String A1, String A2, String A3, String A4, + String A5, String A6) { + if( search(A1, A2, A3, A4, A5, A6) == false ) return Default; + return next(Default); + } + + ///////// double + double follow(double Default, String A1) { + if( search(A1) == false ) return Default; + return next(Default); + } + double follow(double Default, String A[]) { + if( search(A) == false ) return Default; + return next(Default); + } + double follow(double Default, String A1, String A2) { + if( search(A1, A2) == false ) return Default; + return next(Default); + } + double follow(double Default, String A1, String A2, String A3) { + if( search(A1, A2, A3) == false ) return Default; + return next(Default); + } + double follow(double Default, String A1, String A2, String A3, String A4) { + if( search(A1, A2, A3, A4) == false ) return Default; + return next(Default); + } + double follow(double Default, String A1, String A2, String A3, String A4, + String A5) { + if( search(A1, A2, A3, A4, A5) == false ) return Default; + return next(Default); + } + double follow(double Default, String A1, String A2, String A3, String A4, + String A5, String A6) { + if( search(A1, A2, A3, A4, A5, A6) == false ) return Default; + return next(Default); + } + ///////// String ... + String follow(String Default, String A1) { + if( search(A1) == false ) return Default; + return next(Default); + } + String follow(String Default, String A[]) { + if( search(A) == false ) return Default; + return next(Default); + } + String follow(String Default, String A1, String A2) { + if( search(A1, A2) == false ) return Default; + return next(Default); + } + String follow(String Default, String A1, String A2, String A3) { + if( search(A1, A2, A3) == false ) return Default; + return next(Default); + } + String follow(String Default, String A1, String A2, String A3, String A4) { + if( search(A1, A2, A3, A4) == false ) return Default; + return next(Default); + } + String follow(String Default, String A1, String A2, String A3, String A4, + String A5) { + if( search(A1, A2, A3, A4, A5) == false ) return Default; + return next(Default); + } + String follow(String Default, String A1, String A2, String A3, String A4, + String A5, String A6) { + if( search(A1, A2, A3, A4, A5, A6) == false ) return Default; + return next(Default); + } + // (*) directly followed arguments + int direct_follow(int Default, String Option) { + String FollowStr = match_starting_string(Option); + if( FollowStr.compareTo("") == 0 ) return Default; + + int Value = __convert_to_type(FollowStr, Default); + if( ++cursor >= argv.size() ) cursor = argv.size(); + return Value; + } + + double direct_follow(double Default, String Option) { + String FollowStr = match_starting_string(Option); + if( FollowStr.compareTo("") == 0 ) return Default; + double Value = __convert_to_type(FollowStr, Default); + if( ++cursor >= argv.size() ) cursor = argv.size(); + return Value; + } + + String direct_follow(String Default, String Option) { + String FollowStr = match_starting_string(Option); + if( FollowStr.compareTo("") == 0) return Default; + if( ++cursor >= argv.size() ) cursor = argv.size(); + return FollowStr; + } + + String match_starting_string(String StartString) { + // pointer to the place where the string after + // the match inside the found argument starts. + // 0 no argument matches the starting string. + int N = StartString.length(); + int OldCursor = cursor; + if( OldCursor >= argv.size() ) OldCursor = argv.size() - 1; + search_failed_f = true; + + // (*) first loop from cursor position until end + for(int c = cursor; c < argv.size(); c++) { + String Arg = (String)argv.elementAt(c); + if( Arg.length() >= N && Arg.substring(0,N).compareTo(StartString) == 0) { + cursor = c; search_failed_f = false; + return ((String)argv.elementAt(c)).substring(N); + } + } + + if( search_loop_f == false ) return ""; + + // (*) second loop from 0 to old cursor position + for(int c = 1; c < OldCursor; c++) { + String Arg = (String)argv.elementAt(c); + if( Arg.length() >= N && Arg.substring(0,N).compareTo(StartString)==0 ) { + cursor = c; search_failed_f = false; + return ((String)argv.elementAt(c)).substring(N); + } + } + return ""; + } + /////////////////////////////////////////////////////////////////////////////// + // (*) search for flags + //............................................................................. + // + boolean options_contain(String FlagList) { + // go through all arguments that start with a '-', but not more than one + for(int i = 0; i 1 && str.charAt(0) == '-' && str.charAt(1) != '-' ) + if( check_flags(str, FlagList) ) return true; + } + return false; + } + + boolean argument_contains(int Idx, String FlagList) { + if( Idx >= argv.size() || Idx < 0) return false; + + if( prefix.compareTo("") == 0 ) + return check_flags((String)argv.elementAt(Idx), FlagList); + + // if a prefix is set, then the argument index is the index + // inside the 'namespace' + // => only check list of arguments that start with prefix + int no_matches = 0; + for(int i=0; i < argv.size(); i++) { + String Remain = __get_remaining_string((String)argv.elementAt(i), prefix); + if( Remain.compareTo("") != 0 ) { + no_matches += 1; + if( no_matches == Idx) + return check_flags(Remain, FlagList); + } + } + // no argument in this namespace + return false; + + } + + boolean check_flags(String Str, String FlagList) { + for(int i=0; i != FlagList.length() ; i++) + if( Str.indexOf(FlagList.charAt(i)) != -1 ) + // one of the flags was found in given string + return true; + return false; + } + /////////////////////////////////////////////////////////////////////////////// + // (*) nominus arguments + String[] nominus_vector() { + String nv[] = new String[idx_nominus.size()]; + int i=0; + for(Enumeration inm = idx_nominus.elements() ; inm.hasMoreElements(); i++) { + Integer e = (Integer)inm.nextElement(); + nv[i] = (String)argv.elementAt(e.intValue()); + } + return nv; + } + + String next_nominus() { + if( nominus_cursor >= idx_nominus.size()-1 ) return ""; + int C = ++nominus_cursor; + return (String)argv.elementAt(((Integer)idx_nominus.elementAt(C)).intValue()); + } + + void reset_nominus_cursor() + { nominus_cursor = -1; } + + boolean search_failed() + { return search_failed_f; } + /////////////////////////////////////////////////////////////////////////////// + // (*) variables + // (no operator overloading, => functions with 'python names' for + // operators + int call(String VarName, int Default) { + variable sv = find_variable(VarName); + if( sv.name.compareTo("") == 0 ) return Default; + return __convert_to_type(sv.original, Default); + } + + double call(String VarName, double Default) { + variable sv = find_variable(VarName); + if( sv.name.compareTo("") == 0) return Default; + return __convert_to_type(sv.original, Default); + } + + String call(String VarName, String Default) { + variable sv = find_variable(VarName); + if( sv.name.compareTo("") == 0) return Default; + return sv.original; + } + + int call(String VarName, int Default, int Idx) { + variable sv = find_variable(VarName); + if( sv.name.compareTo("") == 0) return Default; + String element = sv.get_element(Idx); + if( element.compareTo("") == 0) return Default; + return __convert_to_type(element, Default); + } + + double call(String VarName, double Default, int Idx) { + variable sv = find_variable(VarName); + if( sv.name.compareTo("") == 0) return Default; + String element = sv.get_element(Idx); + if( element.compareTo("") == 0) return Default; + return __convert_to_type(element, Default); + } + + String call(String VarName, String Default, int Idx) { + variable sv = find_variable(VarName); + if( sv.name.compareTo("") == 0) return Default; + String element = sv.get_element(Idx); + if( element.compareTo("") == 0) return Default; + return element; + } + + int vector_variable_size(String VarName) { + variable sv = find_variable(VarName); + if( sv.name.compareTo("") == 0) return 0; + return sv.value.length; + } + + variable find_variable(String NameX) { + String Name = prefix + NameX; + for(Enumeration inm = variables.elements() ; inm.hasMoreElements(); ) { + variable v = (variable)inm.nextElement(); + if( v.name.compareTo(Name) == 0 ) return v; + } + return new variable("",""); + } + + String[] get_variable_names() { + Vector result = new Vector(); + int length = 0; + for(Enumeration inm = variables.elements() ; inm.hasMoreElements(); ) { + String Name = ((variable)inm.nextElement()).name; + String Tmp = __get_remaining_string(Name, prefix); + if( Tmp != "") { + result.addElement(new String(Tmp)); + length++; + } + } + String end[] = new String[length]; + int i = 0; + for(Enumeration inm = result.elements() ; inm.hasMoreElements(); i++) { + String Name = (String)inm.nextElement(); + end[i] = Name; + } + return end; + } + + /////////////////////////////////////////////////////////////////////////////// + // (*) ouput (basically for debugging reasons) + //............................................................................. + // + void print() { + System.out.println("argc = " + argv.size() + "\n"); + for(int i=0; i "${x}" "${y}" + // ${& ${section} ${subsection}} -> "${section}" "${subsection}" + // ${Title} -> Nothing, variable expansion + // + // 3) DBE_expression_list(): + // + // builds a vector of unbracketed whitespace separated strings, i.e. + // + // " ${Number}.a ${: Das Marmorbild} AB-${& Author= ${Eichendorf}-1870}" + // + // is split into a vector + // + // [0] ${Number}.a + // [1] ${: Das Marmorbild} + // [2] AB-${& Author= ${Eichendorf}}-1870 + // + // Each sub-expression is expanded using expand(). + //--------------------------------------------------------------------------- + String DBE_expand_string(String str) { + // Parses for closing operators '${ }' and expands them letting + // white spaces and other letters as they are. + String new_string = ""; + int open_brackets = 0; + int first = 0; + for(int i = 0; i 0) { + open_brackets -= 1; + if( open_brackets == 0 ) { + String Replacement = DBE_expand(str.substring(first, i)); + new_string += Replacement; + } + } + else if( open_brackets == 0 ) + new_string += str.charAt(i); + } + return new_string; + } + + Vector DBE_get_expr_list(String str_, int ExpectedNumber) { + // ensures that the resulting vector has the expected number + // of arguments, but they may contain an error message + + String str = str_; + // Separates expressions by non-bracketed whitespaces, expands them + // and puts them into a list. + int i=0; + + // (1) eat initial whitespaces + for(; i < str.length(); i++) { + char tmp = str.charAt(i); + if( tmp != ' ' && tmp != '\t' && tmp != '\n' ) break; + } + + Vector expr_list = new Vector(); + int open_brackets = 0; + Vector start_idx = new Vector(); + int start_new_string = i; + int l = str.length(); + + // (2) search for ${ } expressions ... + while( i < l ) { + char letter = str.charAt(i); + // whitespace -> end of expression + if( (letter == ' ' || letter == '\t' || letter == '\n') && open_brackets == 0) { + expr_list.addElement(str.substring(start_new_string, i)); + boolean no_breakout_f = true; + for(i++; i < l ; i++) { + char tmp = str.charAt(i); + if( tmp != ' ' && tmp != '\t' && tmp != '\n' ) + { no_breakout_f = false; start_new_string = i; break; } + } + if( no_breakout_f == true ) { + // end of expression list + if( expr_list.size() < ExpectedNumber ) { + String pre_tmp = "<< ${ }: missing arguments>>"; + for(int ni = expr_list.size(); ni < ExpectedNumber; ni++) + expr_list.addElement(pre_tmp); + } + return expr_list; + } + } + + // dollar-bracket expression + if( str.length() >= i+2 && str.substring(i, i+2).compareTo("${") == 0 ) { + open_brackets++; + start_idx.addElement(new Integer(i+2)); + } + else if( letter == '}' && open_brackets > 0) { + int start = ((Integer)start_idx.elementAt(start_idx.size()-1)).intValue(); + start_idx.removeElementAt(start_idx.size()-1); + String Replacement = DBE_expand(str.substring(start, i)); + if( start - 3 < 0) + str = Replacement + str.substring(i+1); + else + str = str.substring(0, start-2) + Replacement + str.substring(i+1); + l = str.length(); + i = start + Replacement.length() - 3; + open_brackets--; + } + i++; + } + + // end of expression list + expr_list.addElement(str.substring(start_new_string, i)); + + if( expr_list.size() < ExpectedNumber ) { + String pre_tmp = "<< ${ }: missing arguments>>"; + for(int ni = expr_list.size(); ni < ExpectedNumber; ni++) + expr_list.addElement(pre_tmp); + } + return expr_list; + } + + variable DBE_get_variable(String VarName) { + variable ev = new variable(); + String secure_Prefix = prefix; + + prefix = section; + // (1) first search in currently active section + variable var = find_variable(VarName); + if( var.name != "" ) { prefix = secure_Prefix; return var; } + + // (2) search in root name space + prefix = ""; + var = find_variable(VarName); + if( var.name != "" ) { prefix = secure_Prefix; return var; } + + prefix = secure_Prefix; + + // error occured => variable name == "" + ev.name = ""; + ev.original = "<<${ } variable '" + VarName + "' undefined>>"; + return ev; + } + + String DBE_expand(String expr) { + // ${: } pure text + if( expr.charAt(0) == ':' ) + return expr.substring(1); + + // ${& expr expr ... } text concatination + else if( expr.charAt(0) == '&' ) { + Vector A = DBE_get_expr_list(expr.substring(1), 1); + String result = ""; + for(Enumeration e = A.elements() ; e.hasMoreElements() ; ) { + String add = (String)e.nextElement(); + result += add; + } + return result; + } + + // ${<-> expr expr expr} text replacement + else if( expr.length() >= 3 && expr.substring(0, 3).compareTo("<->") == 0) { + Vector A = DBE_get_expr_list(expr.substring(3), 3); + String Arg0 = (String)A.elementAt(0); + String Arg1 = (String)A.elementAt(1); + String Arg2 = (String)A.elementAt(2); + int L = Arg1.length(); + + while( 1 + 1 == 2 ) { + int tmp = Arg0.indexOf(Arg1); + if( tmp == -1 ) break; + if( tmp == 0 ) Arg0 = Arg2 + Arg0.substring(L); + else Arg0 = Arg0.substring(0, tmp) + Arg2 + Arg0.substring(L+tmp); + } + return Arg0; + } + // ${+ ...}, ${- ...}, ${* ...}, ${/ ...} expressions + else if( expr.charAt(0) == '+' ) { + Vector A = DBE_get_expr_list(expr.substring(1), 2); + + double result = 0.0; + + for(Enumeration e = A.elements() ; e.hasMoreElements() ; ) { + String add = (String)e.nextElement(); + result += __convert_to_type(add, 0.0); + } + + return (new Double(result)).toString(); + } + else if( expr.charAt(0) == '-' ) { + Vector A = DBE_get_expr_list(expr.substring(1), 2); + + Enumeration e = A.elements(); + double result = __convert_to_type((String)e.nextElement(), 0.0); + for(; e.hasMoreElements() ; ) { + String sub = (String)e.nextElement(); + result -= __convert_to_type(sub, 0.0); + } + return (new Double(result)).toString(); + } + else if( expr.charAt(0) == '*' ) { + Vector A = DBE_get_expr_list(expr.substring(1), 2); + + double result = 1.0; + for(Enumeration e = A.elements() ; e.hasMoreElements() ; ) { + String mul = (String)e.nextElement(); + result *= __convert_to_type(mul, 0.0); + } + + return (new Double(result)).toString(); + } + else if( expr.charAt(0) == '/' ) { + Vector A = DBE_get_expr_list(expr.substring(1), 2); + Enumeration e = A.elements(); + double result = __convert_to_type((String)e.nextElement(), 0.0); + if( result == 0 ) return "0.0"; + for(; e.hasMoreElements() ; ) { + double Q = __convert_to_type((String)e.nextElement(), 0.0); + if( Q == 0.0) return "0.0"; + result /= Q; + } + return (new Double(result)).toString(); + } + + // ${^ ... } power expressions + else if( expr.charAt(0) == '^' ) { + Vector A = DBE_get_expr_list(expr.substring(1), 2); + + Enumeration e = A.elements(); + double result = __convert_to_type((String)e.nextElement(), 0.0); + for(; e.hasMoreElements() ; ) { + double p = __convert_to_type((String)e.nextElement(), 0.0); + result = java.lang.Math.pow(result, p); + } + + return (new Double(result)).toString(); + } + + // ${== } ${<= } ${>= } comparisons (return the number of the first 'match' + else if(expr.length() >= 2 && + (expr.substring(0,2).compareTo("==") == 0 || + expr.substring(0,2).compareTo(">=") == 0 || + expr.substring(0,2).compareTo("<=") == 0 || + expr.charAt(0) == '>' || + expr.charAt(0) == '<') ) { + // differentiate between two and one sign operators + int op = 0; + // EQ = 0 GEQ = 1 LEQ = 2 GT = 3 LT = 4 + if ( expr.substring(0, 2).compareTo("==") == 0 ) op = 0; + else if ( expr.substring(0, 2).compareTo(">=") == 0 ) op = 1; + else if ( expr.substring(0, 2).compareTo("<=") == 0 ) op = 2; + else if ( expr.charAt(0) == '>' ) op = 3; + else op = 4; + + Vector a = new Vector(); + if ( op >= 3 ) a = DBE_get_expr_list(expr.substring(1), 2); + else a = DBE_get_expr_list(expr.substring(2), 2); + + Enumeration e = a.elements(); + String x_orig = (String)e.nextElement(); + double x = __convert_to_type(x_orig, 1e37); + int i = 1; + for(; e.hasMoreElements() ; ) { + String y_orig = (String)e.nextElement(); + double y = __convert_to_type(y_orig, 1e37); + + // set the strings as reference if something wasn't a number + if ( x == 1e37 || y == 1e37 ) { + // it's a string comparison + int comparison = x_orig.compareTo(y_orig); + + if( ( op == 0 && comparison == 0) + || (op == 1 && comparison >= 0) + || (op == 2 && comparison <= 0) + || (op == 3 && comparison > 0) + || (op == 4 && comparison < 0) ) { + return (new Integer(i)).toString(); + } + } + else { + // it's a number comparison + if( (op == 0 && x == y) || (op == 1 && x >= y) || + (op == 2 && x <= y) || (op == 3 && x > y) || + (op == 4 && x < y) ) { + return (new Integer(i)).toString(); + } + } + i++; + } + // nothing fulfills the condition => return 0 + return "0"; + } + // ${?? expr expr} select + else if( expr.length() >= 2 && expr.substring(0, 2).compareTo("??") == 0) { + Vector a = DBE_get_expr_list(expr.substring(2), 2); + double x = __convert_to_type((String)a.elementAt(0), 1e37); + // last element is always the default argument + if( x == 1e37 || x < 0 || x >= a.size() - 1 ) + return (String)a.elementAt(a.size()-1); + + // round x to closest integer + int rx = (int)java.lang.Math.rint(x); + return (String)a.elementAt(rx); + } + // ${? expr expr expr} if then else conditions + else if( expr.charAt(0) == '?' ) { + Vector a = DBE_get_expr_list(expr.substring(1), 2); + if( __convert_to_type((String)a.elementAt(0), 0.0) == 1.0 ) + return (String)a.elementAt(1); + else if( a.size() > 2 ) + return (String)a.elementAt(2); + } + // ${! expr} maxro expansion + else if( expr.charAt(0) == '!' ) { + variable Var = DBE_get_variable(expr.substring(1)); + // error + if( Var.name == "" ) return Var.original; + + Vector A = DBE_get_expr_list(Var.original, 2); + return (String)A.elementAt(0); + } + // ${@: } - string subscription + else if( expr.length() >=2 && expr.substring(0,2).compareTo("@:") == 0 ) { + Vector A = DBE_get_expr_list(expr.substring(2), 2); + double x = __convert_to_type((String)A.elementAt(1), 1e37); + + // last element is always the default argument + if( x == 1e37 || x < 0 || x >= (double)((String)A.elementAt(0)).length() - 1) + return "<<1st index out of range>>"; + + if( A.size() > 2 ) { + double y = __convert_to_type((String)A.elementAt(2), 1e37); + if ( y != 1e37 && y > 0 && y <= (double)((String)A.elementAt(0)).length() - 1 && y > x ) { + // note: java.lang.String: substring(a,b) = from a to b - 1 + // C++ string: substr(a,b) = from a to a + b + int rx1 = (int)java.lang.Math.rint(x); + int rx2 = (int)java.lang.Math.rint(y + 1.0); + return ((String)A.elementAt(0)).substring(rx1, rx2); + } + else if( y == -1 ) { + int rx = (int)java.lang.Math.rint(x); + return ((String)A.elementAt(0)).substring(rx); + } + return "<<2nd index out of range>>"; + } + else { + String tmp = (String)A.elementAt(0); + int rx = (int)java.lang.Math.rint(x); + return (String)tmp.substring(rx, rx+1); + } + } + // ${@ } - vector subscription + else if( expr.charAt(0) == '@' ) { + Vector A = DBE_get_expr_list(expr.substring(1), 2); + variable Var = DBE_get_variable((String)A.elementAt(0)); + // error + if( Var.name == "" ) { + // make a copy of the string if an error occured + // (since the error variable is a static variable inside get_variable()) + return Var.original; + } + + double x = __convert_to_type((String)A.elementAt(1), 1e37); + + // last element is always the default argument + if (x == 1e37 || x < 0 || x >= Var.value.length ) + return "<<1st index out of range>>"; + + if ( A.size() > 2) { + double y = __convert_to_type((String)A.elementAt(2), 1e37); + int begin = (int)java.lang.Math.rint(x); + int end = 0; + if ( y != 1e37 && y > 0 && y <= Var.value.length && y > x) + end = (int)java.lang.Math.rint(y + 1.0); + else if( y == -1 ) + end = Var.value.length; + else + return "<<2nd index out of range>>"; + + String result = Var.get_element(begin); + for(int i = begin+1; i < end; i++) + result += " " + Var.get_element(i); + return result; + } + else { + int tmp = (int)java.lang.Math.rint(x); + return Var.get_element(tmp); + } + } + Vector A = DBE_get_expr_list(expr, 1); + variable B = DBE_get_variable((String)A.elementAt(0)); + + // make a copy of the string if an error occured + // (since the error variable is a static variable inside get_variable()) + if( B.name == "" ) return (String)B.original; + else return B.original; + } + + /////////////////////////////////////////////////////////////////////////////// + // (*) unidentified flying objects + //............................................................................. + // + String[] string_vector_to_string_array(Vector Vec) { + String[] result = new String[Vec.size()]; + for(int i =0; i < Vec.size(); i++ ) + result[i] = (String)Vec.elementAt(i); + return result; + } + + int __search_string_array(String[] Arr, String Str) { + for(int i=0; i < Arr.length ; i++) + if( Str.compareTo(Arr[i]) == 0 ) return i; + return -1; + } + + String[] unidentified_arguments(String KnownArguments[]) { + Vector ufos = new Vector(); + Enumeration arge = argv.elements(); + if( arge.hasMoreElements() == false ) + return string_vector_to_string_array(ufos); + + // forget about first element (application name) + String it = (String)arge.nextElement(); + for(; arge.hasMoreElements() ;) { + it = (String)arge.nextElement(); + // -- argument belongs to prefixed section ? + String arg = __get_remaining_string(it, prefix); + if( arg == "" ) continue; + + // -- check if argument is known + if( __search_string_array(KnownArguments, arg) == -1 ) + ufos.addElement(it); + } + return string_vector_to_string_array(ufos); + } + + + String[] unidentified_options(String KnownOptions[]) { + Vector ufos = new Vector(); + + Enumeration arge = argv.elements(); + if( arge.hasMoreElements() == false ) + return string_vector_to_string_array(ufos); + // forget about first element (application name) + String it = (String)arge.nextElement(); + for(; arge.hasMoreElements() ;) { + it = (String)arge.nextElement(); + // -- argument belongs to prefixed section ? + String arg = __get_remaining_string(it, prefix); + if( arg == "" ) continue; + // -- argument == option ? + if( arg.length() < 1 || arg.charAt(0) != '-' ) continue; + // -- check if argument is known + if( __search_string_array(KnownOptions, arg) == -1 ) + ufos.addElement(it); + } + return string_vector_to_string_array(ufos); + } + + String unidentified_flags(String KnownFlagList) { + return unidentified_flags(KnownFlagList, -1); + } + + String unidentified_flags(String KFL, int ArgumentNumber) { + // Two modes: + // ArgumentNumber >= 0 check specific argument + // ArgumentNumber == -1 check all options starting with one '-' + // for flags + + String ufos = ""; + Vector known_arguments; + + // (2) iteration over '-' arguments (options) + if( ArgumentNumber == -1 ) { + // iterate over all arguments + Enumeration arge = argv.elements(); + if( arge.hasMoreElements() == false ) return ufos; + // forget about first element (application name) + String it = (String)arge.nextElement(); + for(; arge.hasMoreElements() ;) { + it = (String)arge.nextElement(); + // -- argument belongs to prefixed section ? + String arg = __get_remaining_string(it, prefix); + if( arg == "" ) continue; + + // does arguments start with '-' (but not '--') + if ( arg.length() < 2 ) continue; + else if( arg.charAt(0) != '-' ) continue; + else if( arg.charAt(1) == '-' ) continue; + + // -- check out if flags inside option are contained in KnownFlagList + for(int i=1; i check it for flags + for(int i=0; i not a nomius + if( arg.charAt(0) == '-' ) continue; + // section ? --> not a real nominus + if( arg.charAt(0) == '[' && arg.charAt(arg.length()-1) == ']' ) continue; + // variable definition ? --> not a real nominus + boolean continue_f = false; + for(int i=0; i"); + + } + + static void print_help() { + System.out.println(); + System.out.println( "Example to use nominus arguments:"); + System.out.println( "USAGE:"); + System.out.println( "--help, -h get some help about this program."); + System.out.println(); + System.out.println( "any option that does not start with '-'"); + System.out.println( "will be printed on screen twice."); + System.out.println(); + System.exit(0); + } +} + + diff --git a/Robust/src/Benchmarks/mlp/getpot-java/original/Options.java b/Robust/src/Benchmarks/mlp/getpot-java/original/Options.java new file mode 100755 index 00000000..9f3d94a0 --- /dev/null +++ b/Robust/src/Benchmarks/mlp/getpot-java/original/Options.java @@ -0,0 +1,66 @@ +// -*- java -*- +// FILE: Options.java Version 0.9.8 +// (C) 2001 Frank R. Schaefer +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +////////////////////////////////////////////////////////////////////////////////////// +import GetPot.*; +import java.lang.String; + +public class Options { + public static void main(String args []) { + GetPot cl = new GetPot(args, "Options"); + + // (1) search for a single option + // ------------------------------- + // check if the '--do-nothing' flag is set and exit if yes + if( cl.search("--do-nothing") ) System.exit(0); + + // (2) search for multiple options with the same meaning + // GetPot Java can treat upto 6 strings, then it needs a String[] + if( cl.search("--help", "-h", "--hilfe", "--sos", "--about", "--what-is") ) + print_help(); + + // does the user want us to be nice ... ? + boolean be_nice_f = cl.search("--nice"); + + + if( cl.search("--beep", "--piepse", "--bip", "--senal-acustica", "-b") ) + System.out.println("(imagine a beep - the '\\a' is a invalid escape character in Java)"); + + System.out.println( "Program terminated."); + if( be_nice_f == true ) + System.out.println( "Have a nice day."); + } + + + static void print_help() { + System.out.println(); + System.out.println("Example to use search()-functions:\n\n"); + System.out.println(); + System.out.println("USAGE:"); + System.out.println("--do-nothing quit without doing anything."); + System.out.println("--nice write a nice phrase on the terminal."); + System.out.println("--help, -h, --hilfe, --sos"); + System.out.println(" get some help about this program."); + System.out.println("--beep, -b, --piepse, --bip, --senal-acustica"); + System.out.println(" get your system to make a beep."); + System.out.println( ); + System.exit(0); + } +} + + + diff --git a/Robust/src/Benchmarks/mlp/getpot-java/original/Ufo.java b/Robust/src/Benchmarks/mlp/getpot-java/original/Ufo.java new file mode 100644 index 00000000..92120e61 --- /dev/null +++ b/Robust/src/Benchmarks/mlp/getpot-java/original/Ufo.java @@ -0,0 +1,169 @@ +// -*- java -*- +// FILE: Ufo.java Version 0.9 +// (C) 2001-2002 Frank R. Schaefer +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +////////////////////////////////////////////////////////////////////////////////////// + +import GetPot.*; +import java.lang.String; + + +public class Ufo { +public static void main(String args []) { + GetPot cl = new GetPot(args, "Ufo"); + String[] ufos = {}; + + if( cl.search("-h", "--help") ) { + print_help(); + System.exit(0); + } + else if( cl.search("--arguments") ) { + // (*) unidentified flying arguments --------------------------------------------- + ufos = cl.unidentified_arguments(new String[]{"--arguments", "-h", "--help", "yes", "no"}); + print("Unidentified Arguments (other than '--arguments', '-h', '--help', 'yes', 'no'):\n"); + } + else if( cl.search("--options") ) { + // (*) unidentified flying options (starting with '-' or '--') ------------------- + ufos = cl.unidentified_options(new String[]{"--options", "-h", "--help", + "yes(ignored anyway)", "no(ignored anyway)"}); + print("Unidentified Options (different from '--options', '-h', '--help'):\n"); + } + else if( cl.search("--flags") ) { + // (*) unidentified flying flags ------------------------------------------------- + + // -- flags in the first argument + String ufo_s = cl.unidentified_flags("xzfjct", 1); + print("-- Unaccepted flags in argument 1:\n"); + for(int i=0; i< ufo_s.length() ; i++) + print(" '" + ufo_s.charAt(i) + "'\n"); + + print("\n Accepted flags: 'x' 'z' 'f' 'j' 'c' 't'\n\n"); + + // -- flags in arguments starting with a single '-' + ufo_s = cl.unidentified_flags("ltrm"); + print("-- Unaccepted flags in options (argument with one '-'):\n"); + for(int k=0; k< ufo_s.length() ; k++) + print(" '" + ufo_s.charAt(k) + "'\n"); + + print("\n Accepted flags in options: 'l' 't' 'r' 'm'\n"); + } + else if( cl.search("--variables") ) { + // (*) unidentified flying variables --------------------------------------------- + ufos = cl.unidentified_variables(new String[]{"x", "y", "z", "length", "height"}); + + print("Unidentified Variables (other than 'x', 'y', 'z', 'length', 'height'):\n"); + } + else if( cl.search("--sections") ) { + // (*) unidentified flying sections ---------------------------------------------- + GetPot ifile = new GetPot("example.pot"); + ufos = ifile.unidentified_sections(new String[]{ + "vehicle/", + "vehicle/tires/", + "vehicle/chassis/", + "vehicle/chassis/doors/", + "group/", + "other/", + "user-variables/", + "pseudo-function-calls/"}); + + print("Unidentified sections in file 'example.pot':\n"); + if( ufos.length == 0 ) + print(" (none) add [..] section labels in file 'example.pot'.\n"); + } + else if( cl.search("--nominuses") ) { + // (*) unidentified flying options (starting with '-' or '--') ------------------- + String tmp[] = new String[2]; + // -- read two filenames for demonstration purposes + tmp[0] = cl.follow("default-in.znf", "-i"); + tmp[1] = cl.follow("default-out.znf", "-o"); + + // -- get any other nominuses not used until now + ufos = cl.unidentified_nominuses(tmp); + + print("Unused Nominus Arguments (other than arguments after -i and -o):\n"); + } + else { + print_help(); + System.exit(0); + } + + // (*) print out unidentified flying objects + for(int i=0; i < ufos.length ; i++) + print(" " + ufos[i] + "\n"); +} + + + static void print_help() { + String msg = + "USAGE: java Ufo [--help] [--arguments] [--options] [--flags] [--sections] \n" + + " [--variables] [--nominuses [-i file] [-o filename]]\n" + + " ... any arguments\n" + + "\n" + + "PURPOSE: \n" + + " Testing the GetPot's ability to detect unknown flying objects\n" + + " (i.e. un-recognized command line arguments). The type of flying\n" + + " object you want to check for is specified through one of the\n" + + " following options:\n" + + "\n" + + " --arguments\n" + + " test all arguments against an internal list of possible arguments.\n" + + "\n" + + " --options\n" + + " test all options (arguments starting with at least one '-') against\n" + + " an internal list of options.\n" + + "\n" + + " --flags\n" + + " test first argument and all options against internal list of flags\n" + + " (i.e. letters in arguments that act as switches)\n" + + "\n" + + " --sections\n" + + " reads the input file 'example.pot' for sections that are\n" + + " unidentified. add some sections yourself to test this feature.\n" + + "\n" + + " --variables\n" + + " tests all variables specified on the command line against a list\n" + + " of specified variables.\n" + + "\n" + + " --nominuses\n" + + " check for unrecognized nominuses. filenames after -i and -o are\n" + + " recognized.\n" + + "\n" + + " Once you specified your mode add any number of command line\n" + + " arguments and watch the output.\n" + + "\n" + + "EXAMPLES:\n" + + " java Ufo yes no -i source.cpp --arguments\n" + + "\n" + + " java Ufo -i source.cpp --force n=13 -xzt --options\n" + + "\n" + + " java Ufo zfd if=source.cpp force n=13 -l -zrt -olp --flags\n" + + "\n" + + " java Ufo zfd x=12 y=234 loength=21 height=21 n=2 --variables\n" + + "\n" + + " java Ufo --sections # (edit file section labels in example.pot)\n" + + "\n" + + " java Ufo n=21 -i in.dat -o out.dat /etc/fstab force --nominuses \n" + + "\n" + + "AUTHOR: (C) 2002 Frank R. Schaefer\n"; + System.out.print(msg); + + } + + static void print(String Str) { + System.out.print(Str); + } + +} diff --git a/Robust/src/Benchmarks/mlp/getpot-java/original/Variables.java b/Robust/src/Benchmarks/mlp/getpot-java/original/Variables.java new file mode 100755 index 00000000..e0007ebf --- /dev/null +++ b/Robust/src/Benchmarks/mlp/getpot-java/original/Variables.java @@ -0,0 +1,74 @@ +// -*- java -*- +// FILE: Variables.java Version 0.9.8 +// (C) 2001 Frank R. Schaefer +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +////////////////////////////////////////////////////////////////////////////////////// +import GetPot.*; +import java.lang.String; + +public class Variables { + public static void main(String args []) { + GetPot cl = new GetPot(args, "Variables"); + if( cl.size() == 1 || cl.search("--help", "-h") ) print_help("java Variables"); + + if( cl.search("--internal-information", "-i") ) { + cl.print(); System.exit(0); + } + // (2) some variables of each type + double A_Number = cl.call("float", 0.); + double An_Integer = cl.call("integer", 0); + String A_String = cl.call("string", "default"); + + double Element1 = cl.call("vector", 0., 0); + String Element2 = cl.call("vector", "default", 1); + int Element3 = cl.call("vector", 0, 2); + + System.out.println("Specified Parameters:"); + System.out.println("float = " + A_Number); + System.out.println("integer = " + An_Integer); + System.out.println("string = " + A_String); + System.out.println(); + System.out.println("Vector elements:"); + System.out.println("Element 0 (double) = " + Element1); + System.out.println("Element 1 (string) = " + Element2); + System.out.println("Element 2 (int) = " + Element3); + } + + static void print_help(String Application) { + System.out.println(); + System.out.println("Example how to use GetPot to parse variables on the command line."); + System.out.println(); + System.out.println("USAGE:"); + System.out.println("--help, -h, --hilfe, --sos"); + System.out.println(" get some help about this program."); + System.out.println("--internal-information, -i"); + System.out.println(" show contents of database that was created by parser."); + System.out.println(); + System.out.println("type a command line like the following:"); + System.out.println(Application + " string=otto.von.bismarck float=3.14 \\"); + System.out.println(" integer=41 vector='1.26 something 0x40'"); + System.out.println(); + System.out.println("the variables that can be specified are:"); + System.out.println(" float a double variable"); + System.out.println(" integer an integer variable"); + System.out.println(" string a string variable"); + System.out.println(" vector a mixed type vector:"); + System.out.println(" element 0 => double "); + System.out.println(" element 1 => string"); + System.out.println(" element 2 => int"); + System.out.println(); + } +} diff --git a/Robust/src/Benchmarks/mlp/getpot-java/original/example.pot b/Robust/src/Benchmarks/mlp/getpot-java/original/example.pot new file mode 100755 index 00000000..f92908bf --- /dev/null +++ b/Robust/src/Benchmarks/mlp/getpot-java/original/example.pot @@ -0,0 +1,98 @@ +# -*- getpot -*- GetPot mode activation for emacs +# +# Example input file to be parsed by 'GetPot' +# +# (C) 2001 Frank R. Schaefer +# License Terms: GNU LGPL +############################################################################ + +# (*) -------------------------------------------------------------------------- +# examples dealing with input file parsing (input-file.py/.cpp/.java etc.) +#------------------------------------------------------------------------------- +clicks = 231 # [1/s] +acceleration = 1.231 # [m/s^2] + +[vehicle] +wheel-base = 2.65 # [m] +initial-xyz = '100. 0.1 5.0' # [m] + + + [./tires] # i.e. vehicle/tires/ + # Coefficients for Pacejka's Magic Formula + # Reference: Bakker, Nyborg, Pacejka: + # "Modelling for Use in Vehicle Dynamics Studies", + # SAE Technical Paper Series 870421, 1988 + B = 3.7976 # [1] + C = 1.25 # [1] + E = -0.5 # [1] + D = 64322.404 # [N] + + [../chassis] # i.e. vehicle/chassis/ + Roh = 1.21 # [kg/m^3] density of air + S = 5.14 # [m^2] reference surface + Cd = 0.45 # [1] air drag coefficient + + [./doors] # i.e. vehicle/chassis/doors/ + number = 777 + locks = 'in place' + +# back to the root name space +[] +webpage = http://getpot.sourceforge.net/index.html + +# some words about quotes and backslashes +# (1) whitespace requires quotes +user = 'Alfons Haeberle' +# (2) backslashed quote => quote +latex-formula = '\\kappa\' = \\frac{d}{d s} \\kappa' +# (3) double backslash in quotes = backslash +dos-file = 'C:\\Program Files\\Applications' + +# (*) -------------------------------------------------------------------------- +# examples using the prefix filter (filter.py/.cpp/.java etc.) +#------------------------------------------------------------------------------- +[group] +# playing with pseudo command line arguments: +# note that +# '-x', '3134' and '--rudimental' +# will be known as +# 'flags/-x', 'flags/3234' and 'flags/rudimental'. +# +# Therefore 3134, for example, is **NOT** a number as long, +# as no prefix filter "flags/" is set. +-x 3134 +--rudimental 12 777 + +[other] +# this section will be skipped by the 'next' function when the prefix +# is set +nonsense + + +[user-variables] +# This section contains variables that the user defined himself. +# The GetPot interpreter uses 'get_variable_names()' in order to +# get to know their names. +preview-coefficient = '12 cm' +lateral-side-distance = '2.1 m/s' +control-interval = '0.1 s' +compensation-ratio = '0.4e34 rad/(m*s)' + +[pseudo-function-calls] +# The following code shows how GetPot can be used to emulate +# trivial function calls. Please, note that no syntax checking +# can be provided by this method. +LE-DEBUT +smiley sad +new-line 1 +# draw rectangle width = 40, height = 10 +rectangle 40 10 +new-line 1 +smiley happy +# draw circle radius = 15 +circle 15 +new-line 1 +smiley happy +new-line 2 +LA-FIN + diff --git a/Robust/src/Benchmarks/mlp/getpot-java/original/expand.pot b/Robust/src/Benchmarks/mlp/getpot-java/original/expand.pot new file mode 100644 index 00000000..b5c3f863 --- /dev/null +++ b/Robust/src/Benchmarks/mlp/getpot-java/original/expand.pot @@ -0,0 +1,282 @@ +# -*- getpot -*- GetPot mode activation for emacs +# +# Example input file to be parsed by 'GetPot': +#------------------------------------------------------------------------------- +# PURPOSE: +# Demonstration of the abilities of the $-Bracket Language in GetPot. +# +# +# (*) STRING OPERATORS: +# +# ${string} variable replacement (possibly recursive): +# replace ${}-expression by content of variable named 'string'. +# +# ${:string} pure strings: +# replace ${}-expression by the string 'string' itself (including +# whitespace). This becomes important in combination with macro +# expansion. It allows ${}-expressions inside strings without +# being parsed directly. +# +# ${& string1 string2 string3 ... } concatination: +# concatinate 'string1', 'string2', 'string3', etc. to one single +# string whithout any kind of whitespace in between. +# +# ${<-> string orginal replacement} replacement: +# replace all occurences of 'original' in 'string' with 'replacement' +# +# (*) ARITHMETIC OPERATORS: +# +# ${+ arg1 arg2 arg3 ...} plus: +# replace ${}-expression by the sum: 'arg1' + 'arg2' + 'arg3' + ... +# +# ${* arg1 arg2 arg3 ...} multiplication: +# replace ${}-expression by the product: 'arg1' * 'arg2' * 'arg3' * ... +# +# ${- arg1 arg2 arg3 ...} substraction: +# replace ${}-expression by: 'arg1' - 'arg2' - 'arg3' - ... +# +# ${/ arg1 arg2 arg3 ...} division: +# replace ${}-expression by: 'arg1' / 'arg2' / 'arg3' / ... +# +# (*) COMPARISON OPERATORS: +# +# ${== arg0 arg1 arg2 ...} equal: +# returns the number of the first argument starting with '1' for 'arg1' +# that is equal to 'arg0'. +# returns '0' in case none is equal. +# ${> arg0 arg1 arg2 ...} greater: +# ${< arg0 arg1 arg2 ...} less: +# ${>= arg0 arg1 arg2 ...} greater or equal: +# ${<= arg0 arg1 arg2 ...} less or equal: +# analogous to ${== }-operator. +# +# (*) CONDITIONAL EXPANSION: +# +# ${? arg0 if-string else-string} if-then statement: +# return 'if-string' in case arg0 == 1 and 'else-string' else. +# +# ${?? arg0 string1 string 2 string3 ...} choice. +# return string0 if arg1 == 1, string1 if arg1 == 2, etc. +# +# (*) VECTOR/STRING SUBSCRIPTION: +# +# ${@: string index} letter: +# return letter number 'index' in 'string'. +# +# ${@: string index1 index2} substrings: +# return substring in 'string' from 'index1' to 'index2' +# +# ${@ variable index} vector element: +# return element number 'index' in 'variable' +# +# ${@ variable index1 index2} sub-vector: +# return sub-vector in 'variable' from element 'index1' to +# element 'index2'. +# +# (*) MAKRO EXPANSION: +# +# ${! variable} expand: +# replacement ${}-expression by the evaluation of the content of 'variable'. +# The variable should be defined with a pure string (${: }) so that expressions +# inside it are not parsed during the assignment. +# +# (C) 2002 Frank R. Schaefer +# License Terms: GNU GPL +################################################################################ + +#------------------------------------------------------------------------------- +# (1) variable replacement ----------------------------------------------------- +#------------------------------------------------------------------------------- +name = GetPot + +[${name}] # meaning: [GetPot] +address = getpot.sourceforge.net +[] +info0 = ${GetPot/address} + +[1.2] # advanced variable replacement ------------------------------------------ +[Philosophy] + boss = 'Dr. Frederique Mouillard' + members = 4 + professors = 3 +[Mechanical-Engineering] + boss = Dr.\ Frieda\ LaBlonde + members = 24 + professors = 5 + +[] +x1 = Mechanical-Engineering +x2 = Philosophy +[1.2] +info0 = '${${x1}/boss}: ${${x1}/professors}/${${x1}/members}' +info1 = '${${x2}/boss}: ${${x2}/professors}/${${x2}/members}' + + +[1.3] # recursive replacements ------------------------------------------------- +# 1.3.1 simple replacements +car = Citroen-2CV +ground-vehicle = car +vehicle = ground-vehicle +object = vehicle +# ${object} --> vehicle +# ${vehicle} --> ground-vehicle +# ${ground-vehicle} --> car +# ${car} --> Citroen-2CV + +# note that even variable names can be composed of ${ } expressions +variable = info0 +${variable} = '${${ ${ ${object}}}}' + +# 1.3.2 conglomerate variable names +[Citroen-2CV] + [./wheels] + [./front] + [./right] + radius = 30 # [cm] + +[1.3] +part = wheels +attribute = radius +position = front/right + +variable = info1 +${variable} = '${${${${${object}}}}/${part}/${position}/${attribute}}' + +[1.4] # dictionaries ----------------------------------------------------------- + +[Nicknames] + BMW = Beamer + Mercedez = Grandpa\'s\ Slide + Volkswagen = Beetle + Citroen-2CV = Deuche +[1.4] +info0 = '${Nicknames/${1.3/info0}}' +my-car = Mercedez +info1 = '${Nicknames/${1.4/my-car}}' + +#------------------------------------------------------------------------------- +# (2) string expressions ------------------------------------------------------- +#------------------------------------------------------------------------------- +[2.1] # pure strings ----------------------------------------------------------- +info0 = ${:even expressions like ${my-car} are left as they are} +info1 = ${:\\-ing (backslashing) works still the same way} +info2 = ${:backslashes allow one to have spaces w/o quotes} + +[2.2] # concatination ---------------------------------------------------------- +info0 = ${& simple concatination without whitespaces results in a mess} +info1 = '${& ${:In France, the } ${1.3/info0} + ${: is called \'La } ${Nicknames/${1.3/info0}} \'} + ' + +[2.3] # replacement ------------------------------------------------------------ +info0 = 'We spell your name \'${<-> Phillip Ph F}\'' +info1 = 'The ${<-> ${Nicknames/Volkswagen} ee ea}s' +car = Nicknames/Citroen-2CV +info2 = 'I switched from ${${car}} to ${${<-> ${car} Citroen-2CV Volkswagen}}' + +#------------------------------------------------------------------------------- +# (3) numeric expressions ------------------------------------------------------ +#------------------------------------------------------------------------------- +[3.1] # basics ----------------------------------------------------------------- +info0 = ${+ 1 1} +x = 4699 y = 14 z = 4 +# don't forget to glue the minus sign to negative numbers +info1 = ${+ ${x} ${y} -2} + +info2 = ${- 10 1} +info3 = ${- ${x} ${y} -2} + +info4 = '${* 12 12}' +info5 = '${* 2 2 ${z}}' + +info6 = '${/ 12 6}' +info7 = '${/ 144 12 3 2}' + +[3.2] # power expressions ------------------------------------------------------ +info0 = '${^ 2 16}' +info1 = '${^ 2 2 2 2}' # ((2^2 = 4)^2 = 16)^2 = 256 + + +[3.3] # comparisons ------------------------------------------------------------ +info0 = ${== 1 2} +info1 = ${== Deuche ${${2.3/car}}} +info2 = ${== 1.0 1.000} +info3 = '${>= 3.14 12} but ${>= 3.14 0.0} and ${>= 3.14 3.140000}' +info4 = '${< 12 3.14} but ${< 3.14 3.141} and ${> Berta Vladimir}' +info5 = '${> 12 3.14} but ${> 3.14 3.141} and ${> Zeppelin Alberta}' + +# which one is right ? --------------------------------------------------------- +# comparison operator return number of first matching in list +info6 = 'The real name for 'Deuche' is number ${== Deuche + ${Nicknames/Volkswagen} + ${Nicknames/Mercedez} + ${Nicknames/Citroen-2CV} + ${Nicknames/BMW}}' + +info7 = 'The first element less than 2 is element number ${> 2 10 1001 3 6 1 9 -10}' + +[3.4] # conditions ------------------------------------------------------------- +guess = Citroen-2CV +info0 = 'Your guess was ${? ${== Citroen-2CV ${guess}} right wrong}' +x = 12 y = 14 +info1 = 'x (=${x}) is ${?${> ${x} ${y}} greater less} than y (=${y})' +[msg] +english = 'Star Wars' +francais = 'La Guerre des Etoiles' +espagnol = 'Las Guerras De la Estrella' +italiano = 'Le Guerre Della Stella' +deutsch = 'Krieg der Beruehmten' +portugues = 'As Guerras Da Estrela' + +[3.4] # choices +domain = .fr +info2 = '${?? ${== ${domain} .de .uk .fr .es .it .pt} + ${msg/deutsch} + ${msg/english} + ${msg/francais} + ${msg/espagnol} + ${msg/italiano} + ${msg/portugues}}' + +[3.5] # vector/string subscription --------------------------------------------- +# (note, that '-1' stands for end of array) +# string subscription ${@: +info0 = '${@: Wasserkraftwerkinstallationsunternehmenspruefstelle 6 10}' +info1 = '${@: Wasserkraftwerkinstallationsunternehmenspruefstelle 4}' +info2 = '${@: Wasserkraftwerkinstallationsunternehmenspruefstelle 40 -1}' +info3 = '${@: Wasserkraftwerkinstallationsunternehmenspruefstelle 0 5}' + +my-vector = 'Cordoba Madrid Buenos-Aires Kairo Moskow Heidelberg + Grenoble Marseille Disneyland' + +# vector subscription ${@: +info4 = ${@ my-vector 4 -1} # element 4 until end +info5 = ${@ info4 3 4} # element 3 and 4 +info6 = ${@ info4 0 3} # element 0 until 3 (3 included) +info7 = ${@ info4 4} # element 4 + + +[3.6] # macro evalutation ------------------------------------------------------ +# Note that the accuracy is horrible :-) ! +# approximation of a sinus (defined as a pure string): +# sin(x) = x -1/6 x^3 + 1/120 x^5 -1/5400 x^7 .... +x2 = ${: ${* ${x} ${x}}} +x4 = ${: ${* ${!x2} ${!x2}}} +x6 = ${: ${* ${!x4} ${!x2}}} +sin = ${: ${* ${x} + ${+ 1 + ${/ ${!x2} -6} + ${/ ${!x4} 120} + ${/ ${!x6} -5040} + } + } + } + +convert = ${/ 3.14 180.0} # [degree] -> [rad] + +x = ${* 30 ${convert}} +info0 = ${!sin} + +x = ${* 60 ${convert}} +info1 = ${!sin} + diff --git a/Robust/src/Benchmarks/mlp/getpot-java/original/tmp b/Robust/src/Benchmarks/mlp/getpot-java/original/tmp new file mode 100644 index 00000000..e69de29b -- 2.34.1