# std/parsejson

Theme:

- Manual
- Standard library
- Index
- Compiler docs
- Fusion docs
- devel, stable

Search:
Source Edit

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, decode_helpers

# Types

    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

    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

    JsonKindError = object of ValueError

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

    JsonParser = object of BaseLexer
      a*: string
      tok*: TokKind

  the parser object. Source Edit

    JsonParsingError = object of ValueError

  is raised for a JSON error Source Edit

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

  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 close(my: var JsonParser) {.inline, ...raises: [IOError, OSError],
                                     tags: [WriteIOEffect], forbids: [].}

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

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

  Source Edit

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  Source Edit

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

  returns the current event type for the JSON parser Source Edit

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

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

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

  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 parseEscapedUTF16(buf: cstring; pos: var int): int {....raises: [], tags: [],
        forbids: [].}

  Source Edit

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

  raises an `EJsonParsingError` exception. Source Edit

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

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