API tools faq
paste
Advertisement
Guest User

Kod

a guest
Jun 28th, 2016
68
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 15.41 KB | None | 0 0
raw download clone embed print report
  1. package sqript.engine;
  2.  
  3. import java.util.Arrays;
  4. import java.util.HashMap;
  5. import javax.swing.JOptionPane;
  6.  
  7. public abstract class Function {
  8.     private static final HashMap<String, Function> functions = new HashMap<String, Function>();
  9.     public static final String NULL = "NULL",
  10.                                 TRUE = "TRUE",
  11.                                 FALSE = "FALSE";
  12.     private String name;
  13.     public Function(String name) {
  14.         this.name = name;
  15.     }
  16.     public abstract String execute(String[] args, Sqript sc, Sqript parent);
  17.     public static String run(String line, Sqript sc, Sqript parent) {
  18.         String name = line.substring(0, line.indexOf("("));
  19.         String[] args = Operations.splitArgs(line.substring(line.indexOf("(") + 1, line.lastIndexOf(")")), ';');
  20.         for(int i = 0 ; i < args.length ; i++)
  21.             if(args[i].contains("(") && args[i].contains(")")) {
  22.                 args[i] = run(args[i], null, parent);
  23.             }
  24.         try {
  25.             return Function.getFunction(name).execute(args, sc, parent);
  26.         } catch(NullPointerException ex) {
  27.             System.out.println("Function " + name + " isn't declarated.");
  28.             return NULL;
  29.         } catch(NumberFormatException ex) {
  30.             System.out.println("Number error in line:\n\t" + line);
  31.             return NULL;
  32.         }
  33.     }
  34.     public static Function getFunction(String name) {
  35.         try {
  36.             return functions.get(name);
  37.         } catch (Exception e) {
  38.             return null;
  39.         }
  40.     }
  41.     public String getName() {
  42.         return name;
  43.     }
  44.     public static void registerFunction(Function f) {
  45.         functions.put(f.name, f);
  46.     }
  47.     public static void init() {
  48.         registerFunction(new Function("Output.println") {
  49.             public String execute(String[] args, Sqript sc, Sqript parent) {
  50.                 if(args.length == 1) {
  51.                     System.out.println(args[0]);
  52.                     return TRUE;
  53.                 }
  54.                 return FALSE;
  55.             }
  56.         });
  57.         registerFunction(new Function("Input.readLine") {
  58.             public String execute(String[] args, Sqript sc, Sqript parent) {
  59.                 if(args.length == 1) {
  60.                     System.out.println(args[0]);
  61.                     return TRUE;
  62.                 }
  63.                 return FALSE;
  64.             }
  65.         });
  66.         registerFunction(new Function("Math.add") {
  67.             public String execute(String[] args, Sqript sc, Sqript parent) {
  68.                 if(args.length > 1) {
  69.                     float i = 0;
  70.                     for(int j = 0 ; j < args.length ; j++)
  71.                         i+=Float.parseFloat(args[j]);
  72.                     return String.valueOf(i);
  73.                 }
  74.                 return NULL;
  75.             }
  76.         });
  77.         registerFunction(new Function("Math.subtract") {
  78.             public String execute(String[] args, Sqript sc, Sqript parent) {
  79.                 if(args.length > 1) {
  80.                     float i = Float.parseFloat(args[0]);
  81.                     for(int j = 1 ; j < args.length ; j++)
  82.                         i-=Float.parseFloat(args[j]);
  83.                     return String.valueOf(i);
  84.                 }
  85.                 return NULL;
  86.             }
  87.         });
  88.         registerFunction(new Function("Math.multiply") {
  89.             public String execute(String[] args, Sqript sc, Sqript parent) {
  90.                 if(args.length > 1) {
  91.                     float i = 1;
  92.                     for(int j = 0 ; j < args.length ; j++)
  93.                         i*=Float.parseFloat(args[j]);
  94.                     return String.valueOf(i);
  95.                 }
  96.                 return NULL;
  97.             }
  98.         });
  99.         registerFunction(new Function("Math.divide") {
  100.             public String execute(String[] args, Sqript sc, Sqript parent) {
  101.                 if(args.length > 1) {
  102.                     float i = Float.parseFloat(args[0]);
  103.                     for(int j = 1 ; j < args.length ; j++)
  104.                         i/=Float.parseFloat(args[j]);
  105.                     return String.valueOf(i);
  106.                 }
  107.                 return NULL;
  108.             }
  109.         });
  110.         registerFunction(new Function("Math.power") {
  111.             public String execute(String[] args, Sqript sc, Sqript parent) {
  112.                 if(args.length == 2) {
  113.                     return String.valueOf(Math.pow(Float.parseFloat(args[0]), Float.parseFloat(args[1])));
  114.                 }
  115.                 return NULL;
  116.             }
  117.         });
  118.         registerFunction(new Function("Math.root") {
  119.             public String execute(String[] args, Sqript sc, Sqript parent) {
  120.                 if(args.length == 2) {
  121.                     return String.valueOf(Math.pow(Float.parseFloat(args[0]), 1 / Float.parseFloat(args[1])));
  122.                 }
  123.                 return NULL;
  124.             }
  125.         });
  126.         registerFunction(new Function("Math.sqrt") {
  127.             public String execute(String[] args, Sqript sc, Sqript parent) {
  128.                 if(args.length == 1) {
  129.                     return String.valueOf(Math.sqrt(Float.parseFloat(args[0])));
  130.                 }
  131.                 return NULL;
  132.             }
  133.         });
  134.         registerFunction(new Function("Math.toInteger") {
  135.             public String execute(String[] args, Sqript sc, Sqript parent) {
  136.                 if(args.length == 1) {
  137.                     return String.valueOf((int) Float.parseFloat(args[0]));
  138.                 }
  139.                 return NULL;
  140.             }
  141.         });
  142.         registerFunction(new Function("String.build") {
  143.             public String execute(String[] args, Sqript sc, Sqript parent) {
  144.                 if(args.length > 0) {
  145.                     String s = "";
  146.                     for(String d : args)
  147.                         s+=d;
  148.                     return s;
  149.                 }
  150.                 return NULL;
  151.             }
  152.         });
  153.         registerFunction(new Function("String.toLowerCase") {
  154.             public String execute(String[] args, Sqript sc, Sqript parent) {
  155.                 if(args.length == 1) {
  156.                     return args[0].toLowerCase();
  157.                 }
  158.                 return FALSE;
  159.             }
  160.         });
  161.         registerFunction(new Function("String.toUpperCase") {
  162.             public String execute(String[] args, Sqript sc, Sqript parent) {
  163.                 if(args.length == 1) {
  164.                     return args[0].toUpperCase();
  165.                 }
  166.                 return FALSE;
  167.             }
  168.         });
  169.         registerFunction(new Function("Window.message") {
  170.             public String execute(String[] args, Sqript sc, Sqript parent) {
  171.                 if(args.length > 0) {
  172.                     JOptionPane.showMessageDialog(null, args[0], args.length > 1 ? args[1] : "Message", JOptionPane.PLAIN_MESSAGE);
  173.                 }
  174.                 return NULL;
  175.             }
  176.         });
  177.         registerFunction(new Function("Window.input") {
  178.             public String execute(String[] args, Sqript sc, Sqript parent) {
  179.                 if(args.length > 0) {
  180.                     return JOptionPane.showInputDialog(null, args[0], args.length > 1 ? args[1] : "Message", JOptionPane.QUESTION_MESSAGE);
  181.                 }
  182.                 return NULL;
  183.             }
  184.         });
  185.         registerFunction(new Function("function") {
  186.             public String execute(String[] args, final Sqript fScript, Sqript parent) {
  187.                 if(args.length > 0) {
  188.                     registerFunction(new Function(args[0]) {
  189.                         public String execute(String[] args, Sqript sc, Sqript parent) {
  190.                             for(int i = 0 ; i < args.length ; i++) {
  191.                                 fScript.vars.put("args[" + i + "]", args[i]);
  192.                             }
  193.                             fScript.vars.put("args[length]", String.valueOf(args.length));
  194.                             return fScript.execute();
  195.                         }
  196.                     });
  197.                 }
  198.                 return NULL;
  199.             }
  200.         });
  201.         registerFunction(new Function("++") {
  202.             public String execute(String[] args, Sqript sc, Sqript parent) {
  203.                 if(args.length == 1) {
  204.                     String s = String.valueOf(Float.parseFloat(parent.get(args[0])) + 1);
  205.                     parent.put(args[0], s);
  206.                     return s;
  207.                 }
  208.                 return FALSE;
  209.             }
  210.         });
  211.         registerFunction(new Function("--") {
  212.             public String execute(String[] args, Sqript sc, Sqript parent) {
  213.                 if(args.length == 1) {
  214.                     String s = String.valueOf(Float.parseFloat(parent.get(args[0])) - 1);
  215.                     parent.put(args[0], s);
  216.                     return s;
  217.                 }
  218.                 return FALSE;
  219.             }
  220.         });
  221.         registerFunction(new Function("get") {
  222.             public String execute(String[] args, Sqript sc, Sqript parent) {
  223.                 if(args.length > 0) {
  224.                     return parent.get(args[0]);
  225.                 }
  226.                 return NULL;
  227.             }
  228.         });
  229.         registerFunction(new Function("set") {
  230.             public String execute(String[] args, Sqript sc, Sqript parent) {
  231.                 if(args.length > 1) {
  232.                     parent.put(args[0], args[1]);
  233.                     return TRUE;
  234.                 }
  235.                 return FALSE;
  236.             }
  237.         });
  238.         registerFunction(new Function("declare") {
  239.             public String execute(String[] args, Sqript sc, Sqript parent) {
  240.                 if(args.length > 0) {
  241.                     parent.declare(args[0]);
  242.                     return TRUE;
  243.                 }
  244.                 return FALSE;
  245.             }
  246.         });
  247.         registerFunction(new Function("delete") {
  248.             public String execute(String[] args, Sqript sc, Sqript parent) {
  249.                 if(args.length > 0) {
  250.                     parent.delete(args[0]);
  251.                     return TRUE;
  252.                 }
  253.                 return FALSE;
  254.             }
  255.         });
  256.         registerFunction(new Function("Array.get") {
  257.             public String execute(String[] args, Sqript sc, Sqript parent) {
  258.                 if(args.length > 1) {
  259.                     return parent.getArrayElement(args[0], Integer.parseInt(args[1]));
  260.                 }
  261.                 return NULL;
  262.             }
  263.         });
  264.         registerFunction(new Function("Array.set") {
  265.             public String execute(String[] args, Sqript sc, Sqript parent) {
  266.                 if(args.length > 2) {
  267.                     parent.putArrayElement(args[0], Integer.parseInt(args[1]), args[2]);
  268.                     return TRUE;
  269.                 }
  270.                 return FALSE;
  271.             }
  272.         });
  273.         registerFunction(new Function("Array.declare") {
  274.             public String execute(String[] args, Sqript sc, Sqript parent) {
  275.                 if(args.length > 0) {
  276.                     parent.declareArray(args[0]);
  277.                     return TRUE;
  278.                 }
  279.                 return FALSE;
  280.             }
  281.         });
  282.         registerFunction(new Function("if") {
  283.             public String execute(String[] args, Sqript sc, Sqript parent) {
  284.                 if(args.length != 1)
  285.                     return NULL;
  286.                 String[] t = new String[0];
  287.                 String[] f = new String[0];
  288.                 String[] lines = sc.getLines();
  289.                 boolean b = true;
  290.                 for(String line : lines) {
  291.                     if(line.equals("else")) {
  292.                         b = false;
  293.                         continue;
  294.                     }
  295.                     if(b) {
  296.                         t = Arrays.copyOf(b?t:f, (b?t:f).length + 1);
  297.                         t[t.length - 1] = line;
  298.                     }
  299.                     else {
  300.                         f = Arrays.copyOf(b?t:f, (b?t:f).length + 1);
  301.                         f[f.length - 1] = line;
  302.                     }
  303.                 }
  304.                 if(args[0].equals(TRUE))
  305.                     new Sqript(t, parent).execute();
  306.                 else if(args[0].equals(FALSE))
  307.                     new Sqript(f, parent).execute();
  308.                 return NULL;
  309.             }
  310.         });
  311.         registerFunction(new Function("run") {
  312.             public String execute(String[] args, Sqript sc, Sqript parent) {
  313.                 sc.execute();
  314.                 return NULL;
  315.             }
  316.         });
  317.         registerFunction(new Function("LT") {
  318.             public String execute(String[] args, Sqript sc, Sqript parent) {
  319.                 if(args.length == 2) {
  320.                     float a = Float.parseFloat(args[0]);
  321.                     float b = Float.parseFloat(args[1]);
  322.                     return a < b ? TRUE : FALSE;
  323.                 }
  324.                 return FALSE;
  325.             }
  326.         });
  327.         registerFunction(new Function("LE") {
  328.             public String execute(String[] args, Sqript sc, Sqript parent) {
  329.                 if(args.length == 2) {
  330.                     float a = Float.parseFloat(args[0]);
  331.                     float b = Float.parseFloat(args[1]);
  332.                     return a <= b ? TRUE : FALSE;
  333.                 }
  334.                 return FALSE;
  335.             }
  336.         });
  337.         registerFunction(new Function("GT") {
  338.             public String execute(String[] args, Sqript sc, Sqript parent) {
  339.                 if(args.length == 2) {
  340.                     float a = Float.parseFloat(args[0]);
  341.                     float b = Float.parseFloat(args[1]);
  342.                     return a > b ? TRUE : FALSE;
  343.                 }
  344.                 return FALSE;
  345.             }
  346.         });
  347.         registerFunction(new Function("GE") {
  348.             public String execute(String[] args, Sqript sc, Sqript parent) {
  349.                 if(args.length == 2) {
  350.                     float a = Float.parseFloat(args[0]);
  351.                     float b = Float.parseFloat(args[1]);
  352.                     return a >= b ? TRUE : FALSE;
  353.                 }
  354.                 return FALSE;
  355.             }
  356.         });
  357.         registerFunction(new Function("EQ") {
  358.             public String execute(String[] args, Sqript sc, Sqript parent) {
  359.                 if(args.length == 2) {
  360.                     return args[0].equals(args[1]) ? TRUE : FALSE;
  361.                 }
  362.                 return FALSE;
  363.             }
  364.         });
  365.         registerFunction(new Function("NE") {
  366.             public String execute(String[] args, Sqript sc, Sqript parent) {
  367.                 if(args.length == 2) {
  368.                     float a = Float.parseFloat(args[0]);
  369.                     float b = Float.parseFloat(args[1]);
  370.                     return args[0].equals(args[1]) ? TRUE : FALSE;
  371.                 }
  372.                 return FALSE;
  373.             }
  374.         });
  375.     }
  376. }
  377. package sqript.engine;
  378.  
  379. import java.util.Arrays;
  380. import java.util.HashMap;
  381.  
  382. public class Sqript {
  383.     private String[] lines;
  384.     public final HashMap<String, String> vars = new HashMap<String, String>();
  385.     public final HashMap<String, String[]> arrays = new HashMap<String, String[]>();
  386.     private Sqript parent;
  387.     public Sqript(String[] lines, Sqript parent) {
  388.         this.lines = lines;
  389.         this.parent = parent;
  390.     }
  391.     public Sqript getParent() {
  392.         return parent;
  393.     }
  394.     public String[] getLines() {
  395.         return lines;
  396.     }
  397.     public String execute() {
  398.         for(int i = 0 ; i < lines.length ;) {
  399.             String line = lines[i];
  400.             if(line.isEmpty() || line.startsWith("//")) {
  401.                 i++;
  402.                 continue;
  403.             }
  404.             String[] subScript = new String[0];
  405.             while(lines.length > ++i && lines[i].startsWith("\t")) {
  406.                 subScript = Arrays.copyOf(subScript, subScript.length + 1);
  407.                 subScript[subScript.length - 1] = lines[i].substring(1);
  408.             }
  409.             if(line.startsWith("return ") && line.indexOf(" ") + 1 < line.length()) {
  410.                 return line.contains("(") && line.contains(")") ?
  411.                         Function.run(line.substring(line.indexOf(" ") + 1, line.length()), new Sqript(subScript, this), this) :
  412.                         line.substring(line.indexOf(" ") + 1, line.length());
  413.             } else if(line.startsWith("loop ")) {
  414.                 while((line.contains("(") && line.contains(")") ?
  415.                         Function.run(line.substring(line.indexOf(" ") + 1, line.length()), new Sqript(subScript, this), this) :
  416.                         line.substring(line.indexOf(" ") + 1, line.length())).equals("TRUE"))
  417.                     new Sqript(subScript, this).execute();
  418.                 continue;
  419.             }
  420.             Function.run(line, new Sqript(subScript, this), this);
  421.         }
  422.         return Function.NULL;
  423.     }
  424.     public String get(String k) {
  425.         if(vars.containsKey(k))
  426.             return vars.get(k);
  427.         else if(parent != null)
  428.             return parent.get(k);
  429.         else
  430.             return Function.NULL;
  431.     }
  432.     public void put(String k, String v) {
  433.         if(vars.containsKey(k))
  434.             vars.put(k, v);
  435.         else if(parent != null)
  436.             parent.put(k, v);
  437.     }
  438.     public void delete(String k) {
  439.         if(vars.containsKey(k))
  440.             vars.remove(k);
  441.         else if(parent != null)
  442.             parent.delete(k);
  443.     }
  444.     public void declare(String k) {
  445.         vars.put(k, Function.NULL);
  446.     }
  447.     public String getArrayElement(String k, int address) {
  448.         if(arrays.containsKey(k)) {
  449.             String[] array = arrays.get(k);
  450.             if(address < array.length)
  451.                 return array[address] == null ? Function.NULL : array[address];
  452.         }
  453.         else if(parent != null)
  454.             return parent.getArrayElement(k, address);
  455.         return Function.NULL;
  456.     }
  457.     public void putArrayElement(String k, int address, String v) {
  458.         if(arrays.containsKey(k)) {
  459.             String[] array = arrays.get(k);
  460.             if(address > array.length - 1) {
  461.                 array = Arrays.copyOf(array, address + 1);
  462.             }
  463.             array[address] = v;
  464.             arrays.put(k, array);
  465.         }
  466.         else if(parent != null)
  467.             parent.putArrayElement(k, address, v);
  468.     }
  469.     public void declareArray(String k) {
  470.         arrays.put(k, new String[0]);
  471.     }
  472. }
  473. package sqript.engine;
  474.  
  475. import java.util.ArrayList;
  476. import java.util.Arrays;
  477.  
  478. class Operations {
  479.     public static String[] splitArgs(String s, char c) {
  480.         String[] args = new String[0];
  481.         ArrayList<Integer> splitPoints = new ArrayList<Integer>();
  482.         char[] charArray = s.toCharArray();
  483.         int brackets = 0;
  484.         for(int i = 0 ; i < s.length() ; i++)
  485.             if(charArray[i] == c && brackets == 0)
  486.                 splitPoints.add(i);
  487.             else if(charArray[i] == '(')
  488.                 brackets++;
  489.             else if(charArray[i] == ')')
  490.                 brackets--;
  491.         String arg = "";
  492.         int i = 0;
  493.         while(i < s.length()) {
  494.             while(i < s.length() && !splitPoints.contains(i)) {
  495.                 arg = arg + charArray[i];
  496.                 i++;
  497.             }
  498.             i++;
  499.             args = Arrays.copyOf(args, args.length + 1);
  500.             args[args.length - 1] = arg;
  501.             arg = "";
  502.         }
  503.         return args;
  504.     }
  505. }
  506. package sqript.run;
  507.  
  508. import java.io.BufferedReader;
  509. import java.io.File;
  510. import java.io.FileInputStream;
  511. import java.io.IOException;
  512. import java.io.InputStreamReader;
  513. import java.util.Arrays;
  514.  
  515. import sqript.engine.Function;
  516. import sqript.engine.Sqript;
  517.  
  518. public class Run {
  519.     @SuppressWarnings("resource")
  520.     public static void main(String[] args) {
  521.         Function.init();
  522.         try {
  523.             BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(new File("script.sq"))));
  524.             String[] lines = new String[0];
  525.             String s;
  526.             while((s = br.readLine()) != null) {
  527.                 lines = Arrays.copyOf(lines, lines.length + 1);
  528.                 lines[lines.length - 1] = s;
  529.             }
  530.             new Sqript(lines, null).execute();
  531.         } catch (IOException e) {
  532.             e.printStackTrace();
  533.         }
  534.     }
  535.  
  536. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!