Subversion Repositories openrisc

// Copyright 2011 The Go Authors. All rights reserved.

// Use of this source code is governed by a BSD-style

// license that can be found in the LICENSE file.

package template

import (

        "bytes"

        "encoding/json"

        "fmt"

        "reflect"

        "strings"

        "unicode/utf8"

)

// nextJSCtx returns the context that determines whether a slash after the

// given run of tokens tokens starts a regular expression instead of a division

// operator: / or /=.

//

// This assumes that the token run does not include any string tokens, comment

// tokens, regular expression literal tokens, or division operators.

//

// This fails on some valid but nonsensical JavaScript programs like

// "x = ++/foo/i" which is quite different than "x++/foo/i", but is not known to

// fail on any known useful programs. It is based on the draft

// JavaScript 2.0 lexical grammar and requires one token of lookbehind:

// http://www.mozilla.org/js/language/js20-2000-07/rationale/syntax.html

func nextJSCtx(s []byte, preceding jsCtx) jsCtx {

        s = bytes.TrimRight(s, "\t\n\f\r \u2028\u2029")

        if len(s) == 0 {

                return preceding

        }

        // All cases below are in the single-byte UTF-8 group.

        switch c, n := s[len(s)-1], len(s); c {

        case '+', '-':

                // ++ and -- are not regexp preceders, but + and - are whether

                // they are used as infix or prefix operators.

                start := n - 1

                // Count the number of adjacent dashes or pluses.

                for start > 0 && s[start-1] == c {

                        start--

                }

                if (n-start)&1 == 1 {

                        // Reached for trailing minus signs since "---" is the

                        // same as "-- -".

                        return jsCtxRegexp

                }

                return jsCtxDivOp

        case '.':

                // Handle "42."

                if n != 1 && '0' <= s[n-2] && s[n-2] <= '9' {

                        return jsCtxDivOp

                }

                return jsCtxRegexp

        // Suffixes for all punctuators from section 7.7 of the language spec

        // that only end binary operators not handled above.

        case ',', '<', '>', '=', '*', '%', '&', '|', '^', '?':

                return jsCtxRegexp

        // Suffixes for all punctuators from section 7.7 of the language spec

        // that are prefix operators not handled above.

        case '!', '~':

                return jsCtxRegexp

        // Matches all the punctuators from section 7.7 of the language spec

        // that are open brackets not handled above.

        case '(', '[':

                return jsCtxRegexp

        // Matches all the punctuators from section 7.7 of the language spec

        // that precede expression starts.

        case ':', ';', '{':

                return jsCtxRegexp

        // CAVEAT: the close punctuators ('}', ']', ')') precede div ops and

        // are handled in the default except for '}' which can precede a

        // division op as in

        //    ({ valueOf: function () { return 42 } } / 2

        // which is valid, but, in practice, developers don't divide object

        // literals, so our heuristic works well for code like

        //    function () { ... }  /foo/.test(x) && sideEffect();

        // The ')' punctuator can precede a regular expression as in

        //     if (b) /foo/.test(x) && ...

        // but this is much less likely than

        //     (a + b) / c

        case '}':

                return jsCtxRegexp

        default:

                // Look for an IdentifierName and see if it is a keyword that

                // can precede a regular expression.

                j := n

                for j > 0 && isJSIdentPart(rune(s[j-1])) {

                        j--

                }

                if regexpPrecederKeywords[string(s[j:])] {

                        return jsCtxRegexp

                }

        }

        // Otherwise is a punctuator not listed above, or

        // a string which precedes a div op, or an identifier

        // which precedes a div op.

        return jsCtxDivOp

}

// regexPrecederKeywords is a set of reserved JS keywords that can precede a

// regular expression in JS source.

var regexpPrecederKeywords = map[string]bool{

        "break":      true,

        "case":       true,

        "continue":   true,

        "delete":     true,

        "do":         true,

        "else":       true,

        "finally":    true,

        "in":         true,

        "instanceof": true,

        "return":     true,

        "throw":      true,

        "try":        true,

        "typeof":     true,

        "void":       true,

}

var jsonMarshalType = reflect.TypeOf((*json.Marshaler)(nil)).Elem()

// indirectToJSONMarshaler returns the value, after dereferencing as many times

// as necessary to reach the base type (or nil) or an implementation of json.Marshal.

func indirectToJSONMarshaler(a interface{}) interface{} {

        v := reflect.ValueOf(a)

        for !v.Type().Implements(jsonMarshalType) && v.Kind() == reflect.Ptr && !v.IsNil() {

                v = v.Elem()

        }

        return v.Interface()

}

// jsValEscaper escapes its inputs to a JS Expression (section 11.14) that has

// neither side-effects nor free variables outside (NaN, Infinity).

func jsValEscaper(args ...interface{}) string {

        var a interface{}

        if len(args) == 1 {

                a = indirectToJSONMarshaler(args[0])

                switch t := a.(type) {

                case JS:

                        return string(t)

                case JSStr:

                        // TODO: normalize quotes.

                        return `"` + string(t) + `"`

                case json.Marshaler:

                        // Do not treat as a Stringer.

                case fmt.Stringer:

                        a = t.String()

                }

        } else {

                for i, arg := range args {

                        args[i] = indirectToJSONMarshaler(arg)

                }

                a = fmt.Sprint(args...)

        }

        // TODO: detect cycles before calling Marshal which loops infinitely on

        // cyclic data. This may be an unacceptable DoS risk.

        b, err := json.Marshal(a)

        if err != nil {

                // Put a space before comment so that if it is flush against

                // a division operator it is not turned into a line comment:

                //     x/{{y}}

                // turning into

                //     x//* error marshalling y:

                //          second line of error message */null

                return fmt.Sprintf(" /* %s */null ", strings.Replace(err.Error(), "*/", "* /", -1))

        }

        // TODO: maybe post-process output to prevent it from containing

        // "", "", or "

        // in case custom marshallers produce output containing those.

        // TODO: Maybe abbreviate \u00ab to \xab to produce more compact output.

        if len(b) == 0 {

                // In, `x=y/{{.}}*z` a json.Marshaler that produces "" should

                // not cause the output `x=y/*z`.

                return " null "

        }

        first, _ := utf8.DecodeRune(b)

        last, _ := utf8.DecodeLastRune(b)

        var buf bytes.Buffer

        // Prevent IdentifierNames and NumericLiterals from running into

        // keywords: in, instanceof, typeof, void

        pad := isJSIdentPart(first) || isJSIdentPart(last)

        if pad {

                buf.WriteByte(' ')

        }

        written := 0

        // Make sure that json.Marshal escapes codepoints U+2028 & U+2029

        // so it falls within the subset of JSON which is valid JS.

        for i := 0; i < len(b); {

                rune, n := utf8.DecodeRune(b[i:])

                repl := ""

                if rune == 0x2028 {

                        repl = `\u2028`

                } else if rune == 0x2029 {

                        repl = `\u2029`

                }

                if repl != "" {

                        buf.Write(b[written:i])

                        buf.WriteString(repl)

                        written = i + n

                }

                i += n

        }

        if buf.Len() != 0 {

                buf.Write(b[written:])

                if pad {

                        buf.WriteByte(' ')

                }

                b = buf.Bytes()

        }

        return string(b)

}

// jsStrEscaper produces a string that can be included between quotes in

// JavaScript source, in JavaScript embedded in an HTML5 




    
powered by: WebSVN 2.1.0

        

                
        

            
            
        
        
            
    

        © copyright 1999-2024
OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.