# parsejson

- Manual
- Standard library
- Index

Search:
Group by:

This module implements a json parser. It is used and exported by the `json` standard library module, but can also be used in its own right.

# Imports

strutils, lexbase, streams, unicode

# Types

    JsonEventKind = enum
      jsonError,                  ## an error occurred during parsing
      jsonEof,                    ## end of file reached
      jsonString,                 ## a string literal
      jsonInt,                    ## an integer literal
      jsonFloat,                  ## a float literal
      jsonTrue,                   ## the value ``true``
      jsonFalse,                  ## the value ``false``
      jsonNull,                   ## the value ``null``
      jsonObjectStart,            ## start of an object: the ``{`` token
      jsonObjectEnd,              ## end of an object: the ``}`` token
      jsonArrayStart,             ## start of an array: the ``[`` token
      jsonArrayEnd                ## start of an array: the ``]`` token

  enumeration of all events that may occur when parsing Source Edit

    TokKind = enum
      tkError, tkEof, tkString, tkInt, tkFloat, tkTrue, tkFalse, tkNull, tkCurlyLe,
      tkCurlyRi, tkBracketLe, tkBracketRi, tkColon, tkComma

  Source Edit

    JsonError = enum
      errNone,                    ## no error
      errInvalidToken,            ## invalid token
      errStringExpected,          ## string expected
      errColonExpected,           ## ``:`` expected
      errCommaExpected,           ## ``,`` expected
      errBracketRiExpected,       ## ``]`` expected
      errCurlyRiExpected,         ## ``}`` expected
      errQuoteExpected,           ## ``"`` or ``'`` expected
      errEOC_Expected,            ## ``*/`` expected
      errEofExpected,             ## EOF expected
      errExprExpected             ## expr expected

  enumeration that lists all errors that can occur Source Edit

    JsonParser = object of BaseLexer
      a*: string
      tok*: TokKind
      kind: JsonEventKind
      err: JsonError
      state: seq[ParserState]
      filename: string
      rawStringLiterals: bool

  the parser object. Source Edit

    JsonKindError = object of ValueError

  raised by the `to` macro if the JSON kind is incorrect. Source Edit

    JsonParsingError = object of ValueError

  is raised for a JSON error Source Edit

# Consts

    errorMessages: array[JsonError, string] = ["no error", "invalid token",
                                           "string expected", "\':\' expected",
                                           "\',\' expected", "\']\' expected",
                                           "\'}\' expected",
                                           "\'\"\' or \"\'\" expected",
                                           "\'*/\' expected", "EOF expected",
                                           "expression expected"]

  Source Edit

# Procs

    proc open(my: var JsonParser; input: Stream; filename: string; rawStringLiterals = false) {...}{.
        raises: [Defect, IOError, OSError], tags: [ReadIOEffect].}

  initializes the parser with an input stream. `Filename` is only used for nice error messages. If `rawStringLiterals` is true, string literals are kepts with their surrounding quotes and escape sequences in them are left untouched too. Source Edit

    proc close(my: var JsonParser) {...}{.inline, raises: [Exception, IOError, OSError],
                                 tags: [WriteIOEffect].}

  closes the parser `my` and its associated input stream. Source Edit

    proc str(my: JsonParser): string {...}{.inline, raises: [], tags: [].}

  returns the character data for the events: `jsonInt`, `jsonFloat`, `jsonString` Source Edit

    proc getInt(my: JsonParser): BiggestInt {...}{.inline, raises: [ValueError], tags: [].}

  returns the number for the event: `jsonInt` Source Edit

    proc getFloat(my: JsonParser): float {...}{.inline, raises: [ValueError], tags: [].}

  returns the number for the event: `jsonFloat` Source Edit

    proc kind(my: JsonParser): JsonEventKind {...}{.inline, raises: [], tags: [].}

  returns the current event type for the JSON parser Source Edit

    proc getColumn(my: JsonParser): int {...}{.inline, raises: [], tags: [].}

  get the current column the parser has arrived at. Source Edit

    proc getLine(my: JsonParser): int {...}{.inline, raises: [], tags: [].}

  get the current line the parser has arrived at. Source Edit

    proc getFilename(my: JsonParser): string {...}{.inline, raises: [], tags: [].}

  get the filename of the file that the parser processes. Source Edit

    proc errorMsg(my: JsonParser): string {...}{.raises: [ValueError], tags: [].}

  returns a helpful error message for the event `jsonError` Source Edit

    proc errorMsgExpected(my: JsonParser; e: string): string {...}{.raises: [ValueError],
        tags: [].}

  returns an error message "`e` expected" in the same format as the other error messages Source Edit

    proc parseEscapedUTF16(buf: cstring; pos: var int): int {...}{.raises: [], tags: [].}

  Source Edit

    proc getTok(my: var JsonParser): TokKind {...}{.raises: [Defect, IOError, OSError],
                                          tags: [ReadIOEffect].}

  Source Edit

    proc next(my: var JsonParser) {...}{.raises: [Defect, IOError, OSError], tags: [ReadIOEffect].}

  retrieves the first/next event. This controls the parser. Source Edit

    proc raiseParseErr(p: JsonParser; msg: string) {...}{.noinline, noreturn,
        raises: [JsonParsingError, ValueError], tags: [].}

  raises an `EJsonParsingError` exception. Source Edit

    proc eat(p: var JsonParser; tok: TokKind) {...}{.raises: [Defect, IOError, OSError,
        JsonParsingError, ValueError], tags: [ReadIOEffect].}

  Source Edit