Добавлены функции для работы со строками

Author: aNNiMON

program.own

@@ -180,4 +180,9 @@ class = {
   "div": def(a, b) = a / b
 }
 
-println class.add(2, class.mul(2, 2))
+println class.add(2, class.mul(2, 2))
+
+println split("1/2/3/4/5/6", "/")
+println join(nums, ", ")
+println join(nums, "|", "/")
+println join(nums, ", ", "[", "]")

src/com/annimon/ownlang/lib/modules/functions/std_charat.java

@@ -0,0 +1,17 @@
+package com.annimon.ownlang.lib.modules.functions;
+
+import com.annimon.ownlang.exceptions.ArgumentsMismatchException;
+import com.annimon.ownlang.lib.*;
+
+public final class std_charat implements Function {
+
+    @Override
+    public Value execute(Value... args) {
+        if (args.length != 2) throw new ArgumentsMismatchException("Two arguments expected");
+        
+        final String input = args[0].asString();
+        final int index = (int) args[1].asNumber();
+        
+        return new NumberValue(input.charAt(index));
+    }
+}

src/com/annimon/ownlang/lib/modules/functions/std_indexof.java

@@ -0,0 +1,18 @@
+package com.annimon.ownlang.lib.modules.functions;
+
+import com.annimon.ownlang.exceptions.ArgumentsMismatchException;
+import com.annimon.ownlang.lib.*;
+
+public final class std_indexof implements Function {
+
+    @Override
+    public Value execute(Value... args) {
+        if (args.length < 2 || args.length > 3) throw new ArgumentsMismatchException("Two or three arguments expected");
+        
+        final String input = args[0].asString();
+        final String what = args[1].asString();
+        final int index = (args.length == 3) ? ((int) args[2].asNumber()) : 0;
+        
+        return new NumberValue(input.indexOf(what, index));
+    }
+}

src/com/annimon/ownlang/lib/modules/functions/std_join.java

@@ -0,0 +1,41 @@
+package com.annimon.ownlang.lib.modules.functions;
+
+import com.annimon.ownlang.exceptions.ArgumentsMismatchException;
+import com.annimon.ownlang.exceptions.TypeException;
+import com.annimon.ownlang.lib.*;
+
+public final class std_join implements Function {
+
+    @Override
+    public Value execute(Value... args) {
+        if (args.length < 1) throw new ArgumentsMismatchException("At least one argument expected");
+        if (args[0].type() != Types.ARRAY) {
+            throw new TypeException("Array expected in first argument");
+        }
+        
+        final ArrayValue array = (ArrayValue) args[0];
+        switch (args.length) {
+            case 1:
+                return join(array, "", "", "");
+            case 2:
+                return join(array, args[1].asString(), "", "");
+            case 3:
+                return join(array, args[1].asString(), args[2].asString(), args[2].asString());
+            case 4:
+                return join(array, args[1].asString(), args[2].asString(), args[3].asString());
+            default:
+                throw new ArgumentsMismatchException("Wrong number of arguments");
+        }
+    }
+    
+    private static StringValue join(ArrayValue array, String delimiter, String prefix, String suffix) {
+        final StringBuilder sb = new StringBuilder();
+        for (Value value : array) {
+            if (sb.length() > 0) sb.append(delimiter);
+            else sb.append(prefix);
+            sb.append(value.asString());
+        }
+        sb.append(suffix);
+        return new StringValue(sb.toString());
+    }
+}

src/com/annimon/ownlang/lib/modules/functions/std_lastindexof.java

@@ -0,0 +1,18 @@
+package com.annimon.ownlang.lib.modules.functions;
+
+import com.annimon.ownlang.exceptions.ArgumentsMismatchException;
+import com.annimon.ownlang.lib.*;
+
+public final class std_lastindexof implements Function {
+
+    @Override
+    public Value execute(Value... args) {
+        if (args.length < 2 || args.length > 3) throw new ArgumentsMismatchException("Two or three arguments expected");
+        
+        final String input = args[0].asString();
+        final String what = args[1].asString();
+        final int index = (args.length == 3) ? ((int) args[2].asNumber()) : 0;
+        
+        return new NumberValue(input.lastIndexOf(what, index));
+    }
+}

src/com/annimon/ownlang/lib/modules/functions/std_replace.java

@@ -0,0 +1,18 @@
+package com.annimon.ownlang.lib.modules.functions;
+
+import com.annimon.ownlang.exceptions.ArgumentsMismatchException;
+import com.annimon.ownlang.lib.*;
+
+public final class std_replace implements Function {
+    
+    @Override
+    public Value execute(Value... args) {
+        if (args.length != 3) throw new ArgumentsMismatchException("Three arguments expected");
+        
+        final String input = args[0].asString();
+        final String target = args[1].asString();
+        final String replacement = args[2].asString();
+        
+        return new StringValue(input.replace(target, replacement));
+    }
+}

src/com/annimon/ownlang/lib/modules/functions/std_replaceall.java

@@ -0,0 +1,18 @@
+package com.annimon.ownlang.lib.modules.functions;
+
+import com.annimon.ownlang.exceptions.ArgumentsMismatchException;
+import com.annimon.ownlang.lib.*;
+
+public final class std_replaceall implements Function {
+    
+    @Override
+    public Value execute(Value... args) {
+        if (args.length != 3) throw new ArgumentsMismatchException("Three arguments expected");
+        
+        final String input = args[0].asString();
+        final String regex = args[1].asString();
+        final String replacement = args[2].asString();
+        
+        return new StringValue(input.replaceAll(regex, replacement));
+    }
+}

src/com/annimon/ownlang/lib/modules/functions/std_replacefirst.java

@@ -0,0 +1,18 @@
+package com.annimon.ownlang.lib.modules.functions;
+
+import com.annimon.ownlang.exceptions.ArgumentsMismatchException;
+import com.annimon.ownlang.lib.*;
+
+public final class std_replacefirst implements Function {
+    
+    @Override
+    public Value execute(Value... args) {
+        if (args.length != 3) throw new ArgumentsMismatchException("Three arguments expected");
+        
+        final String input = args[0].asString();
+        final String regex = args[1].asString();
+        final String replacement = args[2].asString();
+        
+        return new StringValue(input.replaceFirst(regex, replacement));
+    }
+}

src/com/annimon/ownlang/lib/modules/functions/std_split.java

@@ -0,0 +1,24 @@
+package com.annimon.ownlang.lib.modules.functions;
+
+import com.annimon.ownlang.exceptions.ArgumentsMismatchException;
+import com.annimon.ownlang.lib.*;
+
+public final class std_split implements Function {
+
+    @Override
+    public Value execute(Value... args) {
+        if (args.length < 2 || args.length > 3) throw new ArgumentsMismatchException("Two or three arguments expected");
+        
+        final String input = args[0].asString();
+        final String regex = args[1].asString();
+        final int limit = (args.length == 3) ? ((int) args[2].asNumber()) : 0;
+        
+        final String[] parts = input.split(regex, limit);
+        final ArrayValue result = new ArrayValue(parts.length);
+        for (int i = 0; i < parts.length; i++) {
+            result.set(i, new StringValue(parts[i]));
+        }
+        
+        return result;
+    }
+}

src/com/annimon/ownlang/lib/modules/functions/std_sprintf.java

@@ -0,0 +1,19 @@
+package com.annimon.ownlang.lib.modules.functions;
+
+import com.annimon.ownlang.exceptions.ArgumentsMismatchException;
+import com.annimon.ownlang.lib.*;
+
+public final class std_sprintf implements Function {
+
+    @Override
+    public Value execute(Value... args) {
+        if (args.length < 1) throw new ArgumentsMismatchException("At least one argument expected");
+        
+        final String format = args[0].asString();
+        final Object[] values = new Object[args.length - 1];
+        for (int i = 1; i < args.length; i++) {
+            values[i - 1] = (args[i].type() == Types.NUMBER) ? args[i].asNumber() : args[i].asString();
+        }
+        return new StringValue(String.format(format, values));
+    }
+}