std/parsejson

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.

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