# # # Nim's Runtime Library # (c) Copyright 2018 Nim contributors # # See the file "copying.txt", included in this # distribution, for details about the copyright. # ## 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. import strutils, lexbase, streams, unicode import std/private/decode_helpers type JsonEventKind* = enum ## enumeration of all events that may occur when parsing 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 TokKind* = enum # must be synchronized with TJsonEventKind! tkError, tkEof, tkString, tkInt, tkFloat, tkTrue, tkFalse, tkNull, tkCurlyLe, tkCurlyRi, tkBracketLe, tkBracketRi, tkColon, tkComma JsonError* = enum ## enumeration that lists all errors that can occur 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 ParserState = enum stateEof, stateStart, stateObject, stateArray, stateExpectArrayComma, stateExpectObjectComma, stateExpectColon, stateExpectValue JsonParser* = object of BaseLexer ## the parser object. a*: string tok*: TokKind kind: JsonEventKind err: JsonError state: seq[ParserState] filename: string rawStringLiterals: bool JsonKindError* = object of ValueError ## raised by the `to` macro if the ## JSON kind is incorrect. JsonParsingError* = object of ValueError ## is raised for a JSON error const errorMessages*: array[JsonError, string] = [ "no error", "invalid token", "string expected", "':' expected", "',' expected", "']' expected", "'}' expected", "'\"' or \"'\" expected", "'*/' expected", "EOF expected", "expression expected" ] tokToStr: array[TokKind, string] = [ "invalid token", "EOF", "string literal", "int literal", "float literal", "true", "false", "null", "{", "}", "[", "]", ":", "," ] proc open*(my: var JsonParser, input: Stream, filename: string; rawStringLiterals = false) = ## 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. lexbase.open(my, input) my.filename = filename my.state = @[stateStart] my.kind = jsonError my.a = "" my.rawStringLiterals = rawStringLiterals proc close*(my: var JsonParser) {.inline.} = ## closes the parser `my` and its associated input stream. lexbase.close(my) proc str*(my: JsonParser): string {.inline.} = ## returns the character data for the events: `jsonInt`, `jsonFloat`, ## `jsonString` assert(my.kind in {jsonInt, jsonFloat, jsonString}) return my.a proc getInt*(my: JsonParser): BiggestInt {.inline.} = ## returns the number for the event: `jsonInt` assert(my.kind == jsonInt) return parseBiggestInt(my.a) proc getFloat*(my: JsonParser): float {.inline.} = ## returns the number for the event: `jsonFloat` assert(my.kind == jsonFloat) return parseFloat(my.a) proc kind*(my: JsonParser): JsonEventKind {.inline.} = ## returns the current event type for the JSON parser return my.kind proc getColumn*(my: JsonParser): int {.inline.} = ## get the current column the parser has arrived at. result = getColNumber(my, my.bufpos) proc getLine*(my: JsonParser): int {.inline.} = ## get the current line the parser has arrived at. result = my.lineNumber proc getFilename*(my: JsonParser): string {.inline.} = ## get the filename of the file that the parser processes. result = my.filename proc errorMsg*(my: JsonParser): string = ## returns a helpful error message for the event `jsonError` assert(my.kind == jsonError) result = "$1($2, $3) Error: $4" % [ my.filename, $getLine(my), $getColumn(my), errorMessages[my.err]] proc errorMsgExpected*(my: JsonParser, e: string): string = ## returns an error message "`e` expected" in the same format as the ## other error messages result = "$1($2, $3) Error: $4" % [ my.filename, $getLine(my), $getColumn(my), e & " expected"] proc parseEscapedUTF16*(buf: cstring, pos: var int): int = result = 0 #UTF-16 escape is always 4 bytes. for _ in 0..3: # if char in '0' .. '9', 'a' .. 'f', 'A' .. 'F' if handleHexChar(buf[pos], result): inc(pos) else: return -1 proc parseString(my: var JsonParser): TokKind = result = tkString var pos = my.bufpos + 1 if my.rawStringLiterals: add(my.a, '"') while true: case my.buf[pos] of '\0': my.err = errQuoteExpected result = tkError break of '"': if my.rawStringLiterals: add(my.a, '"') inc(pos) break of '\\': if my.rawStringLiterals: add(my.a, '\\') case my.buf[pos+1] of '\\', '"', '\'', '/': add(my.a, my.buf[pos+1]) inc(pos, 2) of 'b': add(my.a, '\b') inc(pos, 2) of 'f': add(my.a, '\f') inc(pos, 2) of 'n': add(my.a, '\L') inc(pos, 2) of 'r': add(my.a, '\C') inc(pos, 2) of 't': add(my.a, '\t') inc(pos, 2) of 'v': add(my.a, '\v') inc(pos, 2) of 'u': 
discard """
  output: '''top level statements are executed!
(ival: 10, fval: 2.0)
2.0
my secret
11
12
raising VMQuit
'''
  joinable: "false"
"""

## Example program that demonstrates how to use the
## compiler as an API to embed into your own projects.

import "../../compiler" / [ast, vmdef, vm, nimeval, llstream, lineinfos, options]
import std / [os]

proc initInterpreter(script: string): Interpreter =
  let std = findNimStdLibCompileTime()
  result = createInterpreter(script,