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

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));
+    }
+}

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

@@ -0,0 +1,25 @@
+package com.annimon.ownlang.lib.modules.functions;
+
+import com.annimon.ownlang.exceptions.ArgumentsMismatchException;
+import com.annimon.ownlang.lib.*;
+
+public final class std_substring 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 int startIndex = (int) args[1].asNumber();
+        
+        String result;
+        if (args.length == 2) {
+            result = input.substring(startIndex);
+        } else {
+            final int endIndex = (int) args[2].asNumber();
+            result = input.substring(startIndex, endIndex);
+        }
+        
+        return new StringValue(result);
+    }
+}

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

@@ -0,0 +1,14 @@
+package com.annimon.ownlang.lib.modules.functions;
+
+import com.annimon.ownlang.exceptions.ArgumentsMismatchException;
+import com.annimon.ownlang.lib.*;
+
+public final class std_tochar implements Function {
+
+    @Override
+    public Value execute(Value... args) {
+        if (args.length != 1) throw new ArgumentsMismatchException("One argument expected");
+        
+        return new StringValue(String.valueOf((char) args[0].asNumber()));
+    }
+}

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

@@ -0,0 +1,14 @@
+package com.annimon.ownlang.lib.modules.functions;
+
+import com.annimon.ownlang.exceptions.ArgumentsMismatchException;
+import com.annimon.ownlang.lib.*;
+
+public final class std_tolowercase implements Function {
+
+    @Override
+    public Value execute(Value... args) {
+        if (args.length != 1) throw new ArgumentsMismatchException("One argument expected");
+        
+        return new StringValue(args[0].asString().toLowerCase());
+    }
+}

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

@@ -0,0 +1,14 @@
+package com.annimon.ownlang.lib.modules.functions;
+
+import com.annimon.ownlang.exceptions.ArgumentsMismatchException;
+import com.annimon.ownlang.lib.*;
+
+public final class std_touppercase implements Function {
+
+    @Override
+    public Value execute(Value... args) {
+        if (args.length != 1) throw new ArgumentsMismatchException("One argument expected");
+        
+        return new StringValue(args[0].asString().toUpperCase());
+    }
+}

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

@@ -0,0 +1,14 @@
+package com.annimon.ownlang.lib.modules.functions;
+
+import com.annimon.ownlang.exceptions.ArgumentsMismatchException;
+import com.annimon.ownlang.lib.*;
+
+public final class std_trim implements Function {
+
+    @Override
+    public Value execute(Value... args) {
+        if (args.length != 1) throw new ArgumentsMismatchException("One argument expected");
+        
+        return new StringValue(args[0].asString().trim());
+    }
+}

src/com/annimon/ownlang/lib/modules/std.java

@@ -18,5 +18,21 @@ public final class std implements Module {
         Functions.set("rand", new std_rand());
         Functions.set("sleep", new std_sleep());
         Functions.set("thread", new std_thread());
+        
+        // String
+        Functions.set("sprintf", new std_sprintf());
+        Functions.set("split", new std_split());
+        Functions.set("join", new std_join());
+        Functions.set("indexOf", new std_indexof());
+        Functions.set("lastIndexOf", new std_lastindexof());
+        Functions.set("charAt", new std_charat());
+        Functions.set("toChar", new std_tochar());
+        Functions.set("substring", new std_substring());
+        Functions.set("toLowerCase", new std_tolowercase());
+        Functions.set("toUpperCase", new std_touppercase());
+        Functions.set("trim", new std_trim());
+        Functions.set("replace", new std_replace());
+        Functions.set("replaceAll", new std_replaceall());
+        Functions.set("replaceFirst", new std_replacefirst());
     }
 }