path: root/Godeps/_workspace/src/github.com/obscuren/otto/builtin_regexp.go

package otto

import (
    "fmt"
)

// RegExp

func builtinRegExp(call FunctionCall) Value {
    pattern := call.Argument(0)
    flags := call.Argument(1)
    if object := pattern._object(); object != nil {
        if object.class == "RegExp" && flags.IsUndefined() {
            return pattern
        }
    }
    return toValue_object(call.runtime.newRegExp(pattern, flags))
}

func builtinNewRegExp(self *_object, _ Value, argumentList []Value) Value {
    return toValue_object(self.runtime.newRegExp(
        valueOfArrayIndex(argumentList, 0),
        valueOfArrayIndex(argumentList, 1),
    ))
}

func builtinRegExp_toString(call FunctionCall) Value {
    thisObject := call.thisObject()
    source := toString(thisObject.get("source"))
    flags := []byte{}
    if toBoolean(thisObject.get("global")) {
        flags = append(flags, 'g')
    }
    if toBoolean(thisObject.get("ignoreCase")) {
        flags = append(flags, 'i')
    }
    if toBoolean(thisObject.get("multiline")) {
        flags = append(flags, 'm')
    }
    return toValue_string(fmt.Sprintf("/%s/%s", source, flags))
}

func builtinRegExp_exec(call FunctionCall) Value {
    thisObject := call.thisObject()
    target := toString(call.Argument(0))
    match, result := execRegExp(thisObject, target)
    if !match {
        return NullValue()
    }
    return toValue_object(execResultToArray(call.runtime, target, result))
}

func builtinRegExp_test(call FunctionCall) Value {
    thisObject := call.thisObject()
    target := toString(call.Argument(0))
    match, _ := execRegExp(thisObject, target)
    return toValue_bool(match)
}

func builtinRegExp_compile(call FunctionCall) Value {
    // This (useless) function is deprecated, but is here to provide some
    // semblance of compatibility.
    // Caveat emptor: it may not be around for long.
    return UndefinedValue()
}