parser.go

Documentation: github.com/bytedance/sonic/ast

     1  /*
     2   * Copyright 2021 ByteDance Inc.
     3   *
     4   * Licensed under the Apache License, Version 2.0 (the "License");
     5   * you may not use this file except in compliance with the License.
     6   * You may obtain a copy of the License at
     7   *
     8   *     http://www.apache.org/licenses/LICENSE-2.0
     9   *
    10   * Unless required by applicable law or agreed to in writing, software
    11   * distributed under the License is distributed on an "AS IS" BASIS,
    12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13   * See the License for the specific language governing permissions and
    14   * limitations under the License.
    15   */
    16  
    17  package ast
    18  
    19  import (
    20      `fmt`
    21  
    22      `github.com/bytedance/sonic/internal/native/types`
    23      `github.com/bytedance/sonic/internal/rt`
    24  )
    25  
    26  const (
    27      _DEFAULT_NODE_CAP int = 8
    28      _APPEND_GROW_SHIFT = 1
    29  )
    30  
    31  const (
    32      _ERR_NOT_FOUND      types.ParsingError = 33
    33      _ERR_UNSUPPORT_TYPE types.ParsingError = 34
    34  )
    35  
    36  var (
    37      // ErrNotExist means both key and value doesn't exist 
    38      ErrNotExist error = newError(_ERR_NOT_FOUND, "value not exists")
    39  
    40      // ErrUnsupportType means API on the node is unsupported
    41      ErrUnsupportType error = newError(_ERR_UNSUPPORT_TYPE, "unsupported type")
    42  )
    43  
    44  type Parser struct {
    45      p           int
    46      s           string
    47      noLazy      bool
    48      skipValue   bool
    49      dbuf        *byte
    50  }
    51  
    52  /** Parser Private Methods **/
    53  
    54  func (self *Parser) delim() types.ParsingError {
    55      n := len(self.s)
    56      p := self.lspace(self.p)
    57  
    58      /* check for EOF */
    59      if p >= n {
    60          return types.ERR_EOF
    61      }
    62  
    63      /* check for the delimtier */
    64      if self.s[p] != ':' {
    65          return types.ERR_INVALID_CHAR
    66      }
    67  
    68      /* update the read pointer */
    69      self.p = p + 1
    70      return 0
    71  }
    72  
    73  func (self *Parser) object() types.ParsingError {
    74      n := len(self.s)
    75      p := self.lspace(self.p)
    76  
    77      /* check for EOF */
    78      if p >= n {
    79          return types.ERR_EOF
    80      }
    81  
    82      /* check for the delimtier */
    83      if self.s[p] != '{' {
    84          return types.ERR_INVALID_CHAR
    85      }
    86  
    87      /* update the read pointer */
    88      self.p = p + 1
    89      return 0
    90  }
    91  
    92  func (self *Parser) array() types.ParsingError {
    93      n := len(self.s)
    94      p := self.lspace(self.p)
    95  
    96      /* check for EOF */
    97      if p >= n {
    98          return types.ERR_EOF
    99      }
   100  
   101      /* check for the delimtier */
   102      if self.s[p] != '[' {
   103          return types.ERR_INVALID_CHAR
   104      }
   105  
   106      /* update the read pointer */
   107      self.p = p + 1
   108      return 0
   109  }
   110  
   111  func (self *Parser) lspace(sp int) int {
   112      ns := len(self.s)
   113      for ; sp<ns && isSpace(self.s[sp]); sp+=1 {}
   114  
   115      return sp
   116  }
   117  
   118  func (self *Parser) decodeArray(ret *linkedNodes) (Node, types.ParsingError) {
   119      sp := self.p
   120      ns := len(self.s)
   121  
   122      /* check for EOF */
   123      if self.p = self.lspace(sp); self.p >= ns {
   124          return Node{}, types.ERR_EOF
   125      }
   126  
   127      /* check for empty array */
   128      if self.s[self.p] == ']' {
   129          self.p++
   130          return Node{t: types.V_ARRAY}, 0
   131      }
   132  
   133      /* allocate array space and parse every element */
   134      for {
   135          var val Node
   136          var err types.ParsingError
   137  
   138          if self.skipValue {
   139              /* skip the value */
   140              var start int
   141              if start, err = self.skipFast(); err != 0 {
   142                  return Node{}, err
   143              }
   144              if self.p > ns {
   145                  return Node{}, types.ERR_EOF
   146              }
   147              t := switchRawType(self.s[start])
   148              if t == _V_NONE {
   149                  return Node{}, types.ERR_INVALID_CHAR
   150              }
   151              val = newRawNode(self.s[start:self.p], t)
   152          }else{
   153              /* decode the value */
   154              if val, err = self.Parse(); err != 0 {
   155                  return Node{}, err
   156              }
   157          }
   158  
   159          /* add the value to result */
   160          ret.Push(val)
   161          self.p = self.lspace(self.p)
   162  
   163          /* check for EOF */
   164          if self.p >= ns {
   165              return Node{}, types.ERR_EOF
   166          }
   167  
   168          /* check for the next character */
   169          switch self.s[self.p] {
   170              case ',' : self.p++
   171              case ']' : self.p++; return newArray(ret), 0
   172              default:
   173                  // if val.isLazy() {
   174                  //     return newLazyArray(self, ret), 0
   175                  // }
   176                  return Node{}, types.ERR_INVALID_CHAR
   177          }
   178      }
   179  }
   180  
   181  func (self *Parser) decodeObject(ret *linkedPairs) (Node, types.ParsingError) {
   182      sp := self.p
   183      ns := len(self.s)
   184  
   185      /* check for EOF */
   186      if self.p = self.lspace(sp); self.p >= ns {
   187          return Node{}, types.ERR_EOF
   188      }
   189  
   190      /* check for empty object */
   191      if self.s[self.p] == '}' {
   192          self.p++
   193          return Node{t: types.V_OBJECT}, 0
   194      }
   195  
   196      /* decode each pair */
   197      for {
   198          var val Node
   199          var njs types.JsonState
   200          var err types.ParsingError
   201  
   202          /* decode the key */
   203          if njs = self.decodeValue(); njs.Vt != types.V_STRING {
   204              return Node{}, types.ERR_INVALID_CHAR
   205          }
   206  
   207          /* extract the key */
   208          idx := self.p - 1
   209          key := self.s[njs.Iv:idx]
   210  
   211          /* check for escape sequence */
   212          if njs.Ep != -1 {
   213              if key, err = unquote(key); err != 0 {
   214                  return Node{}, err
   215              }
   216          }
   217  
   218          /* expect a ':' delimiter */
   219          if err = self.delim(); err != 0 {
   220              return Node{}, err
   221          }
   222  
   223          
   224          if self.skipValue {
   225              /* skip the value */
   226              var start int
   227              if start, err = self.skipFast(); err != 0 {
   228                  return Node{}, err
   229              }
   230              if self.p > ns {
   231                  return Node{}, types.ERR_EOF
   232              }
   233              t := switchRawType(self.s[start])
   234              if t == _V_NONE {
   235                  return Node{}, types.ERR_INVALID_CHAR
   236              }
   237              val = newRawNode(self.s[start:self.p], t)
   238          } else {
   239              /* decode the value */
   240              if val, err = self.Parse(); err != 0 {
   241                  return Node{}, err
   242              }
   243          }
   244  
   245          /* add the value to result */
   246          // FIXME: ret's address may change here, thus previous referred node in ret may be invalid !!
   247          ret.Push(Pair{Key: key, Value: val})
   248          self.p = self.lspace(self.p)
   249  
   250          /* check for EOF */
   251          if self.p >= ns {
   252              return Node{}, types.ERR_EOF
   253          }
   254  
   255          /* check for the next character */
   256          switch self.s[self.p] {
   257              case ',' : self.p++
   258              case '}' : self.p++; return newObject(ret), 0
   259          default:
   260              // if val.isLazy() {
   261              //     return newLazyObject(self, ret), 0
   262              // }
   263              return Node{}, types.ERR_INVALID_CHAR
   264          }
   265      }
   266  }
   267  
   268  func (self *Parser) decodeString(iv int64, ep int) (Node, types.ParsingError) {
   269      p := self.p - 1
   270      s := self.s[iv:p]
   271  
   272      /* fast path: no escape sequence */
   273      if ep == -1 {
   274          return NewString(s), 0
   275      }
   276  
   277      /* unquote the string */
   278      out, err := unquote(s)
   279  
   280      /* check for errors */
   281      if err != 0 {
   282          return Node{}, err
   283      } else {
   284          return newBytes(rt.Str2Mem(out)), 0
   285      }
   286  }
   287  
   288  /** Parser Interface **/
   289  
   290  func (self *Parser) Pos() int {
   291      return self.p
   292  }
   293  
   294  func (self *Parser) Parse() (Node, types.ParsingError) {
   295      switch val := self.decodeValue(); val.Vt {
   296          case types.V_EOF     : return Node{}, types.ERR_EOF
   297          case types.V_NULL    : return nullNode, 0
   298          case types.V_TRUE    : return trueNode, 0
   299          case types.V_FALSE   : return falseNode, 0
   300          case types.V_STRING  : return self.decodeString(val.Iv, val.Ep)
   301          case types.V_ARRAY:
   302              if p := skipBlank(self.s, self.p); p >= self.p && self.s[p] == ']' {
   303                  self.p = p + 1
   304                  return Node{t: types.V_ARRAY}, 0
   305              }
   306              if self.noLazy {
   307                  return self.decodeArray(new(linkedNodes))
   308              }
   309              return newLazyArray(self), 0
   310          case types.V_OBJECT:
   311              if p := skipBlank(self.s, self.p); p >= self.p && self.s[p] == '}' {
   312                  self.p = p + 1
   313                  return Node{t: types.V_OBJECT}, 0
   314              }
   315              if self.noLazy {
   316                  return self.decodeObject(new(linkedPairs))
   317              }
   318              return newLazyObject(self), 0
   319          case types.V_DOUBLE  : return NewNumber(self.s[val.Ep:self.p]), 0
   320          case types.V_INTEGER : return NewNumber(self.s[val.Ep:self.p]), 0
   321          default              : return Node{}, types.ParsingError(-val.Vt)
   322      }
   323  }
   324  
   325  func (self *Parser) searchKey(match string) types.ParsingError {
   326      ns := len(self.s)
   327      if err := self.object(); err != 0 {
   328          return err
   329      }
   330  
   331      /* check for EOF */
   332      if self.p = self.lspace(self.p); self.p >= ns {
   333          return types.ERR_EOF
   334      }
   335  
   336      /* check for empty object */
   337      if self.s[self.p] == '}' {
   338          self.p++
   339          return _ERR_NOT_FOUND
   340      }
   341  
   342      var njs types.JsonState
   343      var err types.ParsingError
   344      /* decode each pair */
   345      for {
   346  
   347          /* decode the key */
   348          if njs = self.decodeValue(); njs.Vt != types.V_STRING {
   349              return types.ERR_INVALID_CHAR
   350          }
   351  
   352          /* extract the key */
   353          idx := self.p - 1
   354          key := self.s[njs.Iv:idx]
   355  
   356          /* check for escape sequence */
   357          if njs.Ep != -1 {
   358              if key, err = unquote(key); err != 0 {
   359                  return err
   360              }
   361          }
   362  
   363          /* expect a ':' delimiter */
   364          if err = self.delim(); err != 0 {
   365              return err
   366          }
   367  
   368          /* skip value */
   369          if key != match {
   370              if _, err = self.skipFast(); err != 0 {
   371                  return err
   372              }
   373          } else {
   374              return 0
   375          }
   376  
   377          /* check for EOF */
   378          self.p = self.lspace(self.p)
   379          if self.p >= ns {
   380              return types.ERR_EOF
   381          }
   382  
   383          /* check for the next character */
   384          switch self.s[self.p] {
   385          case ',':
   386              self.p++
   387          case '}':
   388              self.p++
   389              return _ERR_NOT_FOUND
   390          default:
   391              return types.ERR_INVALID_CHAR
   392          }
   393      }
   394  }
   395  
   396  func (self *Parser) searchIndex(idx int) types.ParsingError {
   397      ns := len(self.s)
   398      if err := self.array(); err != 0 {
   399          return err
   400      }
   401  
   402      /* check for EOF */
   403      if self.p = self.lspace(self.p); self.p >= ns {
   404          return types.ERR_EOF
   405      }
   406  
   407      /* check for empty array */
   408      if self.s[self.p] == ']' {
   409          self.p++
   410          return _ERR_NOT_FOUND
   411      }
   412  
   413      var err types.ParsingError
   414      /* allocate array space and parse every element */
   415      for i := 0; i < idx; i++ {
   416  
   417          /* decode the value */
   418          if _, err = self.skipFast(); err != 0 {
   419              return err
   420          }
   421  
   422          /* check for EOF */
   423          self.p = self.lspace(self.p)
   424          if self.p >= ns {
   425              return types.ERR_EOF
   426          }
   427  
   428          /* check for the next character */
   429          switch self.s[self.p] {
   430          case ',':
   431              self.p++
   432          case ']':
   433              self.p++
   434              return _ERR_NOT_FOUND
   435          default:
   436              return types.ERR_INVALID_CHAR
   437          }
   438      }
   439  
   440      return 0
   441  }
   442  
   443  func (self *Node) skipNextNode() *Node {
   444      if !self.isLazy() {
   445          return nil
   446      }
   447  
   448      parser, stack := self.getParserAndArrayStack()
   449      ret := &stack.v
   450      sp := parser.p
   451      ns := len(parser.s)
   452  
   453      /* check for EOF */
   454      if parser.p = parser.lspace(sp); parser.p >= ns {
   455          return newSyntaxError(parser.syntaxError(types.ERR_EOF))
   456      }
   457  
   458      /* check for empty array */
   459      if parser.s[parser.p] == ']' {
   460          parser.p++
   461          self.setArray(ret)
   462          return nil
   463      }
   464  
   465      var val Node
   466      /* skip the value */
   467      if start, err := parser.skipFast(); err != 0 {
   468          return newSyntaxError(parser.syntaxError(err))
   469      } else {
   470          t := switchRawType(parser.s[start])
   471          if t == _V_NONE {
   472              return newSyntaxError(parser.syntaxError(types.ERR_INVALID_CHAR))
   473          }
   474          val = newRawNode(parser.s[start:parser.p], t)
   475      }
   476  
   477      /* add the value to result */
   478      ret.Push(val)
   479      self.l++
   480      parser.p = parser.lspace(parser.p)
   481  
   482      /* check for EOF */
   483      if parser.p >= ns {
   484          return newSyntaxError(parser.syntaxError(types.ERR_EOF))
   485      }
   486  
   487      /* check for the next character */
   488      switch parser.s[parser.p] {
   489      case ',':
   490          parser.p++
   491          return ret.At(ret.Len()-1)
   492      case ']':
   493          parser.p++
   494          self.setArray(ret)
   495          return ret.At(ret.Len()-1)
   496      default:
   497          return newSyntaxError(parser.syntaxError(types.ERR_INVALID_CHAR))
   498      }
   499  }
   500  
   501  func (self *Node) skipNextPair() (*Pair) {
   502      if !self.isLazy() {
   503          return nil
   504      }
   505  
   506      parser, stack := self.getParserAndObjectStack()
   507      ret := &stack.v
   508      sp := parser.p
   509      ns := len(parser.s)
   510  
   511      /* check for EOF */
   512      if parser.p = parser.lspace(sp); parser.p >= ns {
   513          return &Pair{"", *newSyntaxError(parser.syntaxError(types.ERR_EOF))}
   514      }
   515  
   516      /* check for empty object */
   517      if parser.s[parser.p] == '}' {
   518          parser.p++
   519          self.setObject(ret)
   520          return nil
   521      }
   522  
   523      /* decode one pair */
   524      var val Node
   525      var njs types.JsonState
   526      var err types.ParsingError
   527  
   528      /* decode the key */
   529      if njs = parser.decodeValue(); njs.Vt != types.V_STRING {
   530          return &Pair{"", *newSyntaxError(parser.syntaxError(types.ERR_INVALID_CHAR))}
   531      }
   532  
   533      /* extract the key */
   534      idx := parser.p - 1
   535      key := parser.s[njs.Iv:idx]
   536  
   537      /* check for escape sequence */
   538      if njs.Ep != -1 {
   539          if key, err = unquote(key); err != 0 {
   540              return &Pair{key, *newSyntaxError(parser.syntaxError(err))}
   541          }
   542      }
   543  
   544      /* expect a ':' delimiter */
   545      if err = parser.delim(); err != 0 {
   546          return &Pair{key, *newSyntaxError(parser.syntaxError(err))}
   547      }
   548  
   549      /* skip the value */
   550      if start, err := parser.skipFast(); err != 0 {
   551          return &Pair{key, *newSyntaxError(parser.syntaxError(err))}
   552      } else {
   553          t := switchRawType(parser.s[start])
   554          if t == _V_NONE {
   555              return &Pair{key, *newSyntaxError(parser.syntaxError(types.ERR_INVALID_CHAR))}
   556          }
   557          val = newRawNode(parser.s[start:parser.p], t)
   558      }
   559  
   560      /* add the value to result */
   561      ret.Push(Pair{Key: key, Value: val})
   562      self.l++
   563      parser.p = parser.lspace(parser.p)
   564  
   565      /* check for EOF */
   566      if parser.p >= ns {
   567          return &Pair{key, *newSyntaxError(parser.syntaxError(types.ERR_EOF))}
   568      }
   569  
   570      /* check for the next character */
   571      switch parser.s[parser.p] {
   572      case ',':
   573          parser.p++
   574          return ret.At(ret.Len()-1)
   575      case '}':
   576          parser.p++
   577          self.setObject(ret)
   578          return ret.At(ret.Len()-1)
   579      default:
   580          return &Pair{key, *newSyntaxError(parser.syntaxError(types.ERR_INVALID_CHAR))}
   581      }
   582  }
   583  
   584  
   585  /** Parser Factory **/
   586  
   587  // Loads parse all json into interface{}
   588  func Loads(src string) (int, interface{}, error) {
   589      ps := &Parser{s: src}
   590      np, err := ps.Parse()
   591  
   592      /* check for errors */
   593      if err != 0 {
   594          return 0, nil, ps.ExportError(err)
   595      } else {
   596          x, err := np.Interface()
   597          if err != nil {
   598              return 0, nil, err
   599          }
   600          return ps.Pos(), x, nil
   601      }
   602  }
   603  
   604  // LoadsUseNumber parse all json into interface{}, with numeric nodes casted to json.Number
   605  func LoadsUseNumber(src string) (int, interface{}, error) {
   606      ps := &Parser{s: src}
   607      np, err := ps.Parse()
   608  
   609      /* check for errors */
   610      if err != 0 {
   611          return 0, nil, err
   612      } else {
   613          x, err := np.InterfaceUseNumber()
   614          if err != nil {
   615              return 0, nil, err
   616          }
   617          return ps.Pos(), x, nil
   618      }
   619  }
   620  
   621  // NewParser returns pointer of new allocated parser
   622  func NewParser(src string) *Parser {
   623      return &Parser{s: src}
   624  }
   625  
   626  // NewParser returns new allocated parser
   627  func NewParserObj(src string) Parser {
   628      return Parser{s: src}
   629  }
   630  
   631  // decodeNumber controls if parser decodes the number values instead of skip them
   632  //   WARN: once you set decodeNumber(true), please set decodeNumber(false) before you drop the parser 
   633  //   otherwise the memory CANNOT be reused
   634  func (self *Parser) decodeNumber(decode bool) {
   635      if !decode && self.dbuf != nil {
   636          types.FreeDbuf(self.dbuf)
   637          self.dbuf = nil
   638          return
   639      }
   640      if decode && self.dbuf == nil {
   641          self.dbuf = types.NewDbuf()
   642      }
   643  }
   644  
   645  // ExportError converts types.ParsingError to std Error
   646  func (self *Parser) ExportError(err types.ParsingError) error {
   647      if err == _ERR_NOT_FOUND {
   648          return ErrNotExist
   649      }
   650      return fmt.Errorf("%q", SyntaxError{
   651          Pos : self.p,
   652          Src : self.s,
   653          Code: err,
   654      }.Description())
   655  }
   656
View as plain text