Source file src/go.mongodb.org/mongo-driver/bson/bsonrw/extjson_writer.go

Documentation: go.mongodb.org/mongo-driver/bson/bsonrw

     1  // Copyright (C) MongoDB, Inc. 2017-present.
     2  //
     3  // Licensed under the Apache License, Version 2.0 (the "License"); you may
     4  // not use this file except in compliance with the License. You may obtain
     5  // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
     6  
     7  package bsonrw
     8  
     9  import (
    10  	"bytes"
    11  	"encoding/base64"
    12  	"fmt"
    13  	"io"
    14  	"math"
    15  	"sort"
    16  	"strconv"
    17  	"strings"
    18  	"sync"
    19  	"time"
    20  	"unicode/utf8"
    21  
    22  	"go.mongodb.org/mongo-driver/bson/primitive"
    23  )
    24  
    25  // ExtJSONValueWriterPool is a pool for ExtJSON ValueWriters.
    26  //
    27  // Deprecated: ExtJSONValueWriterPool will not be supported in Go Driver 2.0.
    28  type ExtJSONValueWriterPool struct {
    29  	pool sync.Pool
    30  }
    31  
    32  // NewExtJSONValueWriterPool creates a new pool for ValueWriter instances that write to ExtJSON.
    33  //
    34  // Deprecated: ExtJSONValueWriterPool will not be supported in Go Driver 2.0.
    35  func NewExtJSONValueWriterPool() *ExtJSONValueWriterPool {
    36  	return &ExtJSONValueWriterPool{
    37  		pool: sync.Pool{
    38  			New: func() interface{} {
    39  				return new(extJSONValueWriter)
    40  			},
    41  		},
    42  	}
    43  }
    44  
    45  // Get retrieves a ExtJSON ValueWriter from the pool and resets it to use w as the destination.
    46  //
    47  // Deprecated: ExtJSONValueWriterPool will not be supported in Go Driver 2.0.
    48  func (bvwp *ExtJSONValueWriterPool) Get(w io.Writer, canonical, escapeHTML bool) ValueWriter {
    49  	vw := bvwp.pool.Get().(*extJSONValueWriter)
    50  	if writer, ok := w.(*SliceWriter); ok {
    51  		vw.reset(*writer, canonical, escapeHTML)
    52  		vw.w = writer
    53  		return vw
    54  	}
    55  	vw.buf = vw.buf[:0]
    56  	vw.w = w
    57  	return vw
    58  }
    59  
    60  // Put inserts a ValueWriter into the pool. If the ValueWriter is not a ExtJSON ValueWriter, nothing
    61  // happens and ok will be false.
    62  //
    63  // Deprecated: ExtJSONValueWriterPool will not be supported in Go Driver 2.0.
    64  func (bvwp *ExtJSONValueWriterPool) Put(vw ValueWriter) (ok bool) {
    65  	bvw, ok := vw.(*extJSONValueWriter)
    66  	if !ok {
    67  		return false
    68  	}
    69  
    70  	if _, ok := bvw.w.(*SliceWriter); ok {
    71  		bvw.buf = nil
    72  	}
    73  	bvw.w = nil
    74  
    75  	bvwp.pool.Put(bvw)
    76  	return true
    77  }
    78  
    79  type ejvwState struct {
    80  	mode mode
    81  }
    82  
    83  type extJSONValueWriter struct {
    84  	w   io.Writer
    85  	buf []byte
    86  
    87  	stack      []ejvwState
    88  	frame      int64
    89  	canonical  bool
    90  	escapeHTML bool
    91  	newlines   bool
    92  }
    93  
    94  // NewExtJSONValueWriter creates a ValueWriter that writes Extended JSON to w.
    95  func NewExtJSONValueWriter(w io.Writer, canonical, escapeHTML bool) (ValueWriter, error) {
    96  	if w == nil {
    97  		return nil, errNilWriter
    98  	}
    99  
   100  	// Enable newlines for all Extended JSON value writers created by NewExtJSONValueWriter. We
   101  	// expect these value writers to be used with an Encoder, which should add newlines after
   102  	// encoded Extended JSON documents.
   103  	return newExtJSONWriter(w, canonical, escapeHTML, true), nil
   104  }
   105  
   106  func newExtJSONWriter(w io.Writer, canonical, escapeHTML, newlines bool) *extJSONValueWriter {
   107  	stack := make([]ejvwState, 1, 5)
   108  	stack[0] = ejvwState{mode: mTopLevel}
   109  
   110  	return &extJSONValueWriter{
   111  		w:          w,
   112  		buf:        []byte{},
   113  		stack:      stack,
   114  		canonical:  canonical,
   115  		escapeHTML: escapeHTML,
   116  		newlines:   newlines,
   117  	}
   118  }
   119  
   120  func newExtJSONWriterFromSlice(buf []byte, canonical, escapeHTML bool) *extJSONValueWriter {
   121  	stack := make([]ejvwState, 1, 5)
   122  	stack[0] = ejvwState{mode: mTopLevel}
   123  
   124  	return &extJSONValueWriter{
   125  		buf:        buf,
   126  		stack:      stack,
   127  		canonical:  canonical,
   128  		escapeHTML: escapeHTML,
   129  	}
   130  }
   131  
   132  func (ejvw *extJSONValueWriter) reset(buf []byte, canonical, escapeHTML bool) {
   133  	if ejvw.stack == nil {
   134  		ejvw.stack = make([]ejvwState, 1, 5)
   135  	}
   136  
   137  	ejvw.stack = ejvw.stack[:1]
   138  	ejvw.stack[0] = ejvwState{mode: mTopLevel}
   139  	ejvw.canonical = canonical
   140  	ejvw.escapeHTML = escapeHTML
   141  	ejvw.frame = 0
   142  	ejvw.buf = buf
   143  	ejvw.w = nil
   144  }
   145  
   146  func (ejvw *extJSONValueWriter) advanceFrame() {
   147  	if ejvw.frame+1 >= int64(len(ejvw.stack)) { // We need to grow the stack
   148  		length := len(ejvw.stack)
   149  		if length+1 >= cap(ejvw.stack) {
   150  			// double it
   151  			buf := make([]ejvwState, 2*cap(ejvw.stack)+1)
   152  			copy(buf, ejvw.stack)
   153  			ejvw.stack = buf
   154  		}
   155  		ejvw.stack = ejvw.stack[:length+1]
   156  	}
   157  	ejvw.frame++
   158  }
   159  
   160  func (ejvw *extJSONValueWriter) push(m mode) {
   161  	ejvw.advanceFrame()
   162  
   163  	ejvw.stack[ejvw.frame].mode = m
   164  }
   165  
   166  func (ejvw *extJSONValueWriter) pop() {
   167  	switch ejvw.stack[ejvw.frame].mode {
   168  	case mElement, mValue:
   169  		ejvw.frame--
   170  	case mDocument, mArray, mCodeWithScope:
   171  		ejvw.frame -= 2 // we pop twice to jump over the mElement: mDocument -> mElement -> mDocument/mTopLevel/etc...
   172  	}
   173  }
   174  
   175  func (ejvw *extJSONValueWriter) invalidTransitionErr(destination mode, name string, modes []mode) error {
   176  	te := TransitionError{
   177  		name:        name,
   178  		current:     ejvw.stack[ejvw.frame].mode,
   179  		destination: destination,
   180  		modes:       modes,
   181  		action:      "write",
   182  	}
   183  	if ejvw.frame != 0 {
   184  		te.parent = ejvw.stack[ejvw.frame-1].mode
   185  	}
   186  	return te
   187  }
   188  
   189  func (ejvw *extJSONValueWriter) ensureElementValue(destination mode, callerName string, addmodes ...mode) error {
   190  	switch ejvw.stack[ejvw.frame].mode {
   191  	case mElement, mValue:
   192  	default:
   193  		modes := []mode{mElement, mValue}
   194  		if addmodes != nil {
   195  			modes = append(modes, addmodes...)
   196  		}
   197  		return ejvw.invalidTransitionErr(destination, callerName, modes)
   198  	}
   199  
   200  	return nil
   201  }
   202  
   203  func (ejvw *extJSONValueWriter) writeExtendedSingleValue(key string, value string, quotes bool) {
   204  	var s string
   205  	if quotes {
   206  		s = fmt.Sprintf(`{"$%s":"%s"}`, key, value)
   207  	} else {
   208  		s = fmt.Sprintf(`{"$%s":%s}`, key, value)
   209  	}
   210  
   211  	ejvw.buf = append(ejvw.buf, []byte(s)...)
   212  }
   213  
   214  func (ejvw *extJSONValueWriter) WriteArray() (ArrayWriter, error) {
   215  	if err := ejvw.ensureElementValue(mArray, "WriteArray"); err != nil {
   216  		return nil, err
   217  	}
   218  
   219  	ejvw.buf = append(ejvw.buf, '[')
   220  
   221  	ejvw.push(mArray)
   222  	return ejvw, nil
   223  }
   224  
   225  func (ejvw *extJSONValueWriter) WriteBinary(b []byte) error {
   226  	return ejvw.WriteBinaryWithSubtype(b, 0x00)
   227  }
   228  
   229  func (ejvw *extJSONValueWriter) WriteBinaryWithSubtype(b []byte, btype byte) error {
   230  	if err := ejvw.ensureElementValue(mode(0), "WriteBinaryWithSubtype"); err != nil {
   231  		return err
   232  	}
   233  
   234  	var buf bytes.Buffer
   235  	buf.WriteString(`{"$binary":{"base64":"`)
   236  	buf.WriteString(base64.StdEncoding.EncodeToString(b))
   237  	buf.WriteString(fmt.Sprintf(`","subType":"%02x"}},`, btype))
   238  
   239  	ejvw.buf = append(ejvw.buf, buf.Bytes()...)
   240  
   241  	ejvw.pop()
   242  	return nil
   243  }
   244  
   245  func (ejvw *extJSONValueWriter) WriteBoolean(b bool) error {
   246  	if err := ejvw.ensureElementValue(mode(0), "WriteBoolean"); err != nil {
   247  		return err
   248  	}
   249  
   250  	ejvw.buf = append(ejvw.buf, []byte(strconv.FormatBool(b))...)
   251  	ejvw.buf = append(ejvw.buf, ',')
   252  
   253  	ejvw.pop()
   254  	return nil
   255  }
   256  
   257  func (ejvw *extJSONValueWriter) WriteCodeWithScope(code string) (DocumentWriter, error) {
   258  	if err := ejvw.ensureElementValue(mCodeWithScope, "WriteCodeWithScope"); err != nil {
   259  		return nil, err
   260  	}
   261  
   262  	var buf bytes.Buffer
   263  	buf.WriteString(`{"$code":`)
   264  	writeStringWithEscapes(code, &buf, ejvw.escapeHTML)
   265  	buf.WriteString(`,"$scope":{`)
   266  
   267  	ejvw.buf = append(ejvw.buf, buf.Bytes()...)
   268  
   269  	ejvw.push(mCodeWithScope)
   270  	return ejvw, nil
   271  }
   272  
   273  func (ejvw *extJSONValueWriter) WriteDBPointer(ns string, oid primitive.ObjectID) error {
   274  	if err := ejvw.ensureElementValue(mode(0), "WriteDBPointer"); err != nil {
   275  		return err
   276  	}
   277  
   278  	var buf bytes.Buffer
   279  	buf.WriteString(`{"$dbPointer":{"$ref":"`)
   280  	buf.WriteString(ns)
   281  	buf.WriteString(`","$id":{"$oid":"`)
   282  	buf.WriteString(oid.Hex())
   283  	buf.WriteString(`"}}},`)
   284  
   285  	ejvw.buf = append(ejvw.buf, buf.Bytes()...)
   286  
   287  	ejvw.pop()
   288  	return nil
   289  }
   290  
   291  func (ejvw *extJSONValueWriter) WriteDateTime(dt int64) error {
   292  	if err := ejvw.ensureElementValue(mode(0), "WriteDateTime"); err != nil {
   293  		return err
   294  	}
   295  
   296  	t := time.Unix(dt/1e3, dt%1e3*1e6).UTC()
   297  
   298  	if ejvw.canonical || t.Year() < 1970 || t.Year() > 9999 {
   299  		s := fmt.Sprintf(`{"$numberLong":"%d"}`, dt)
   300  		ejvw.writeExtendedSingleValue("date", s, false)
   301  	} else {
   302  		ejvw.writeExtendedSingleValue("date", t.Format(rfc3339Milli), true)
   303  	}
   304  
   305  	ejvw.buf = append(ejvw.buf, ',')
   306  
   307  	ejvw.pop()
   308  	return nil
   309  }
   310  
   311  func (ejvw *extJSONValueWriter) WriteDecimal128(d primitive.Decimal128) error {
   312  	if err := ejvw.ensureElementValue(mode(0), "WriteDecimal128"); err != nil {
   313  		return err
   314  	}
   315  
   316  	ejvw.writeExtendedSingleValue("numberDecimal", d.String(), true)
   317  	ejvw.buf = append(ejvw.buf, ',')
   318  
   319  	ejvw.pop()
   320  	return nil
   321  }
   322  
   323  func (ejvw *extJSONValueWriter) WriteDocument() (DocumentWriter, error) {
   324  	if ejvw.stack[ejvw.frame].mode == mTopLevel {
   325  		ejvw.buf = append(ejvw.buf, '{')
   326  		return ejvw, nil
   327  	}
   328  
   329  	if err := ejvw.ensureElementValue(mDocument, "WriteDocument", mTopLevel); err != nil {
   330  		return nil, err
   331  	}
   332  
   333  	ejvw.buf = append(ejvw.buf, '{')
   334  	ejvw.push(mDocument)
   335  	return ejvw, nil
   336  }
   337  
   338  func (ejvw *extJSONValueWriter) WriteDouble(f float64) error {
   339  	if err := ejvw.ensureElementValue(mode(0), "WriteDouble"); err != nil {
   340  		return err
   341  	}
   342  
   343  	s := formatDouble(f)
   344  
   345  	if ejvw.canonical {
   346  		ejvw.writeExtendedSingleValue("numberDouble", s, true)
   347  	} else {
   348  		switch s {
   349  		case "Infinity":
   350  			fallthrough
   351  		case "-Infinity":
   352  			fallthrough
   353  		case "NaN":
   354  			s = fmt.Sprintf(`{"$numberDouble":"%s"}`, s)
   355  		}
   356  		ejvw.buf = append(ejvw.buf, []byte(s)...)
   357  	}
   358  
   359  	ejvw.buf = append(ejvw.buf, ',')
   360  
   361  	ejvw.pop()
   362  	return nil
   363  }
   364  
   365  func (ejvw *extJSONValueWriter) WriteInt32(i int32) error {
   366  	if err := ejvw.ensureElementValue(mode(0), "WriteInt32"); err != nil {
   367  		return err
   368  	}
   369  
   370  	s := strconv.FormatInt(int64(i), 10)
   371  
   372  	if ejvw.canonical {
   373  		ejvw.writeExtendedSingleValue("numberInt", s, true)
   374  	} else {
   375  		ejvw.buf = append(ejvw.buf, []byte(s)...)
   376  	}
   377  
   378  	ejvw.buf = append(ejvw.buf, ',')
   379  
   380  	ejvw.pop()
   381  	return nil
   382  }
   383  
   384  func (ejvw *extJSONValueWriter) WriteInt64(i int64) error {
   385  	if err := ejvw.ensureElementValue(mode(0), "WriteInt64"); err != nil {
   386  		return err
   387  	}
   388  
   389  	s := strconv.FormatInt(i, 10)
   390  
   391  	if ejvw.canonical {
   392  		ejvw.writeExtendedSingleValue("numberLong", s, true)
   393  	} else {
   394  		ejvw.buf = append(ejvw.buf, []byte(s)...)
   395  	}
   396  
   397  	ejvw.buf = append(ejvw.buf, ',')
   398  
   399  	ejvw.pop()
   400  	return nil
   401  }
   402  
   403  func (ejvw *extJSONValueWriter) WriteJavascript(code string) error {
   404  	if err := ejvw.ensureElementValue(mode(0), "WriteJavascript"); err != nil {
   405  		return err
   406  	}
   407  
   408  	var buf bytes.Buffer
   409  	writeStringWithEscapes(code, &buf, ejvw.escapeHTML)
   410  
   411  	ejvw.writeExtendedSingleValue("code", buf.String(), false)
   412  	ejvw.buf = append(ejvw.buf, ',')
   413  
   414  	ejvw.pop()
   415  	return nil
   416  }
   417  
   418  func (ejvw *extJSONValueWriter) WriteMaxKey() error {
   419  	if err := ejvw.ensureElementValue(mode(0), "WriteMaxKey"); err != nil {
   420  		return err
   421  	}
   422  
   423  	ejvw.writeExtendedSingleValue("maxKey", "1", false)
   424  	ejvw.buf = append(ejvw.buf, ',')
   425  
   426  	ejvw.pop()
   427  	return nil
   428  }
   429  
   430  func (ejvw *extJSONValueWriter) WriteMinKey() error {
   431  	if err := ejvw.ensureElementValue(mode(0), "WriteMinKey"); err != nil {
   432  		return err
   433  	}
   434  
   435  	ejvw.writeExtendedSingleValue("minKey", "1", false)
   436  	ejvw.buf = append(ejvw.buf, ',')
   437  
   438  	ejvw.pop()
   439  	return nil
   440  }
   441  
   442  func (ejvw *extJSONValueWriter) WriteNull() error {
   443  	if err := ejvw.ensureElementValue(mode(0), "WriteNull"); err != nil {
   444  		return err
   445  	}
   446  
   447  	ejvw.buf = append(ejvw.buf, []byte("null")...)
   448  	ejvw.buf = append(ejvw.buf, ',')
   449  
   450  	ejvw.pop()
   451  	return nil
   452  }
   453  
   454  func (ejvw *extJSONValueWriter) WriteObjectID(oid primitive.ObjectID) error {
   455  	if err := ejvw.ensureElementValue(mode(0), "WriteObjectID"); err != nil {
   456  		return err
   457  	}
   458  
   459  	ejvw.writeExtendedSingleValue("oid", oid.Hex(), true)
   460  	ejvw.buf = append(ejvw.buf, ',')
   461  
   462  	ejvw.pop()
   463  	return nil
   464  }
   465  
   466  func (ejvw *extJSONValueWriter) WriteRegex(pattern string, options string) error {
   467  	if err := ejvw.ensureElementValue(mode(0), "WriteRegex"); err != nil {
   468  		return err
   469  	}
   470  
   471  	var buf bytes.Buffer
   472  	buf.WriteString(`{"$regularExpression":{"pattern":`)
   473  	writeStringWithEscapes(pattern, &buf, ejvw.escapeHTML)
   474  	buf.WriteString(`,"options":"`)
   475  	buf.WriteString(sortStringAlphebeticAscending(options))
   476  	buf.WriteString(`"}},`)
   477  
   478  	ejvw.buf = append(ejvw.buf, buf.Bytes()...)
   479  
   480  	ejvw.pop()
   481  	return nil
   482  }
   483  
   484  func (ejvw *extJSONValueWriter) WriteString(s string) error {
   485  	if err := ejvw.ensureElementValue(mode(0), "WriteString"); err != nil {
   486  		return err
   487  	}
   488  
   489  	var buf bytes.Buffer
   490  	writeStringWithEscapes(s, &buf, ejvw.escapeHTML)
   491  
   492  	ejvw.buf = append(ejvw.buf, buf.Bytes()...)
   493  	ejvw.buf = append(ejvw.buf, ',')
   494  
   495  	ejvw.pop()
   496  	return nil
   497  }
   498  
   499  func (ejvw *extJSONValueWriter) WriteSymbol(symbol string) error {
   500  	if err := ejvw.ensureElementValue(mode(0), "WriteSymbol"); err != nil {
   501  		return err
   502  	}
   503  
   504  	var buf bytes.Buffer
   505  	writeStringWithEscapes(symbol, &buf, ejvw.escapeHTML)
   506  
   507  	ejvw.writeExtendedSingleValue("symbol", buf.String(), false)
   508  	ejvw.buf = append(ejvw.buf, ',')
   509  
   510  	ejvw.pop()
   511  	return nil
   512  }
   513  
   514  func (ejvw *extJSONValueWriter) WriteTimestamp(t uint32, i uint32) error {
   515  	if err := ejvw.ensureElementValue(mode(0), "WriteTimestamp"); err != nil {
   516  		return err
   517  	}
   518  
   519  	var buf bytes.Buffer
   520  	buf.WriteString(`{"$timestamp":{"t":`)
   521  	buf.WriteString(strconv.FormatUint(uint64(t), 10))
   522  	buf.WriteString(`,"i":`)
   523  	buf.WriteString(strconv.FormatUint(uint64(i), 10))
   524  	buf.WriteString(`}},`)
   525  
   526  	ejvw.buf = append(ejvw.buf, buf.Bytes()...)
   527  
   528  	ejvw.pop()
   529  	return nil
   530  }
   531  
   532  func (ejvw *extJSONValueWriter) WriteUndefined() error {
   533  	if err := ejvw.ensureElementValue(mode(0), "WriteUndefined"); err != nil {
   534  		return err
   535  	}
   536  
   537  	ejvw.writeExtendedSingleValue("undefined", "true", false)
   538  	ejvw.buf = append(ejvw.buf, ',')
   539  
   540  	ejvw.pop()
   541  	return nil
   542  }
   543  
   544  func (ejvw *extJSONValueWriter) WriteDocumentElement(key string) (ValueWriter, error) {
   545  	switch ejvw.stack[ejvw.frame].mode {
   546  	case mDocument, mTopLevel, mCodeWithScope:
   547  		var buf bytes.Buffer
   548  		writeStringWithEscapes(key, &buf, ejvw.escapeHTML)
   549  
   550  		ejvw.buf = append(ejvw.buf, []byte(fmt.Sprintf(`%s:`, buf.String()))...)
   551  		ejvw.push(mElement)
   552  	default:
   553  		return nil, ejvw.invalidTransitionErr(mElement, "WriteDocumentElement", []mode{mDocument, mTopLevel, mCodeWithScope})
   554  	}
   555  
   556  	return ejvw, nil
   557  }
   558  
   559  func (ejvw *extJSONValueWriter) WriteDocumentEnd() error {
   560  	switch ejvw.stack[ejvw.frame].mode {
   561  	case mDocument, mTopLevel, mCodeWithScope:
   562  	default:
   563  		return fmt.Errorf("incorrect mode to end document: %s", ejvw.stack[ejvw.frame].mode)
   564  	}
   565  
   566  	// close the document
   567  	if ejvw.buf[len(ejvw.buf)-1] == ',' {
   568  		ejvw.buf[len(ejvw.buf)-1] = '}'
   569  	} else {
   570  		ejvw.buf = append(ejvw.buf, '}')
   571  	}
   572  
   573  	switch ejvw.stack[ejvw.frame].mode {
   574  	case mCodeWithScope:
   575  		ejvw.buf = append(ejvw.buf, '}')
   576  		fallthrough
   577  	case mDocument:
   578  		ejvw.buf = append(ejvw.buf, ',')
   579  	case mTopLevel:
   580  		// If the value writer has newlines enabled, end top-level documents with a newline so that
   581  		// multiple documents encoded to the same writer are separated by newlines. That matches the
   582  		// Go json.Encoder behavior and also works with bsonrw.NewExtJSONValueReader.
   583  		if ejvw.newlines {
   584  			ejvw.buf = append(ejvw.buf, '\n')
   585  		}
   586  		if ejvw.w != nil {
   587  			if _, err := ejvw.w.Write(ejvw.buf); err != nil {
   588  				return err
   589  			}
   590  			ejvw.buf = ejvw.buf[:0]
   591  		}
   592  	}
   593  
   594  	ejvw.pop()
   595  	return nil
   596  }
   597  
   598  func (ejvw *extJSONValueWriter) WriteArrayElement() (ValueWriter, error) {
   599  	switch ejvw.stack[ejvw.frame].mode {
   600  	case mArray:
   601  		ejvw.push(mValue)
   602  	default:
   603  		return nil, ejvw.invalidTransitionErr(mValue, "WriteArrayElement", []mode{mArray})
   604  	}
   605  
   606  	return ejvw, nil
   607  }
   608  
   609  func (ejvw *extJSONValueWriter) WriteArrayEnd() error {
   610  	switch ejvw.stack[ejvw.frame].mode {
   611  	case mArray:
   612  		// close the array
   613  		if ejvw.buf[len(ejvw.buf)-1] == ',' {
   614  			ejvw.buf[len(ejvw.buf)-1] = ']'
   615  		} else {
   616  			ejvw.buf = append(ejvw.buf, ']')
   617  		}
   618  
   619  		ejvw.buf = append(ejvw.buf, ',')
   620  
   621  		ejvw.pop()
   622  	default:
   623  		return fmt.Errorf("incorrect mode to end array: %s", ejvw.stack[ejvw.frame].mode)
   624  	}
   625  
   626  	return nil
   627  }
   628  
   629  func formatDouble(f float64) string {
   630  	var s string
   631  	if math.IsInf(f, 1) {
   632  		s = "Infinity"
   633  	} else if math.IsInf(f, -1) {
   634  		s = "-Infinity"
   635  	} else if math.IsNaN(f) {
   636  		s = "NaN"
   637  	} else {
   638  		// Print exactly one decimalType place for integers; otherwise, print as many are necessary to
   639  		// perfectly represent it.
   640  		s = strconv.FormatFloat(f, 'G', -1, 64)
   641  		if !strings.ContainsRune(s, 'E') && !strings.ContainsRune(s, '.') {
   642  			s += ".0"
   643  		}
   644  	}
   645  
   646  	return s
   647  }
   648  
   649  var hexChars = "0123456789abcdef"
   650  
   651  func writeStringWithEscapes(s string, buf *bytes.Buffer, escapeHTML bool) {
   652  	buf.WriteByte('"')
   653  	start := 0
   654  	for i := 0; i < len(s); {
   655  		if b := s[i]; b < utf8.RuneSelf {
   656  			if htmlSafeSet[b] || (!escapeHTML && safeSet[b]) {
   657  				i++
   658  				continue
   659  			}
   660  			if start < i {
   661  				buf.WriteString(s[start:i])
   662  			}
   663  			switch b {
   664  			case '\\', '"':
   665  				buf.WriteByte('\\')
   666  				buf.WriteByte(b)
   667  			case '\n':
   668  				buf.WriteByte('\\')
   669  				buf.WriteByte('n')
   670  			case '\r':
   671  				buf.WriteByte('\\')
   672  				buf.WriteByte('r')
   673  			case '\t':
   674  				buf.WriteByte('\\')
   675  				buf.WriteByte('t')
   676  			case '\b':
   677  				buf.WriteByte('\\')
   678  				buf.WriteByte('b')
   679  			case '\f':
   680  				buf.WriteByte('\\')
   681  				buf.WriteByte('f')
   682  			default:
   683  				// This encodes bytes < 0x20 except for \t, \n and \r.
   684  				// If escapeHTML is set, it also escapes <, >, and &
   685  				// because they can lead to security holes when
   686  				// user-controlled strings are rendered into JSON
   687  				// and served to some browsers.
   688  				buf.WriteString(`\u00`)
   689  				buf.WriteByte(hexChars[b>>4])
   690  				buf.WriteByte(hexChars[b&0xF])
   691  			}
   692  			i++
   693  			start = i
   694  			continue
   695  		}
   696  		c, size := utf8.DecodeRuneInString(s[i:])
   697  		if c == utf8.RuneError && size == 1 {
   698  			if start < i {
   699  				buf.WriteString(s[start:i])
   700  			}
   701  			buf.WriteString(`\ufffd`)
   702  			i += size
   703  			start = i
   704  			continue
   705  		}
   706  		// U+2028 is LINE SEPARATOR.
   707  		// U+2029 is PARAGRAPH SEPARATOR.
   708  		// They are both technically valid characters in JSON strings,
   709  		// but don't work in JSONP, which has to be evaluated as JavaScript,
   710  		// and can lead to security holes there. It is valid JSON to
   711  		// escape them, so we do so unconditionally.
   712  		// See http://timelessrepo.com/json-isnt-a-javascript-subset for discussion.
   713  		if c == '\u2028' || c == '\u2029' {
   714  			if start < i {
   715  				buf.WriteString(s[start:i])
   716  			}
   717  			buf.WriteString(`\u202`)
   718  			buf.WriteByte(hexChars[c&0xF])
   719  			i += size
   720  			start = i
   721  			continue
   722  		}
   723  		i += size
   724  	}
   725  	if start < len(s) {
   726  		buf.WriteString(s[start:])
   727  	}
   728  	buf.WriteByte('"')
   729  }
   730  
   731  type sortableString []rune
   732  
   733  func (ss sortableString) Len() int {
   734  	return len(ss)
   735  }
   736  
   737  func (ss sortableString) Less(i, j int) bool {
   738  	return ss[i] < ss[j]
   739  }
   740  
   741  func (ss sortableString) Swap(i, j int) {
   742  	oldI := ss[i]
   743  	ss[i] = ss[j]
   744  	ss[j] = oldI
   745  }
   746  
   747  func sortStringAlphebeticAscending(s string) string {
   748  	ss := sortableString([]rune(s))
   749  	sort.Sort(ss)
   750  	return string([]rune(ss))
   751  }
   752  

View as plain text