# parsejson

Dark Mode

- 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               ## end 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 kept 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