Browse Source

initial commit

master
Yorick van Pelt 8 years ago
commit
4d508f5894
  1. 123
      json.js
  2. 242
      parsec.js
  3. 12
      test.js

123
json.js

@ -0,0 +1,123 @@
var p = require('./parsec')
var c = p.combinators
var s = p.p_string
var f = p.funp
var char = function(ch) {
return c.token(p.p_string.char(ch)) }
var digit = function() {
return c.token(p.p_string.digit()) }
function literal(x, y) {
return c.bind(
c.nxtnxt.apply(null, x.split('').map(char))
, function() { return c.always(y) }) }
function many_str(parser) {
return c.bind(c.many(parser), function(x) { return c.always(x.join('')) }) }
function many1_str(parser) {
return c.bind(c.many1(parser), function(x) { return c.always(x.join('')) }) }
var line_comment = c.nxtnxt(
char('/')
, char('/')
, c.many(c.token(f.not(p.p_string.char('\n'))))
, char('\n'))
var inline_comment_content = c.next(
c.many(c.token(f.not(p.p_string.char('*'))))
, char('*'))
var inline_comment = c.nxtnxt(
char('/')
, char('*')
, c.many1(inline_comment_content)
, char('/'))
var comment = c.either(line_comment, inline_comment)
var opt_space = c.many(c.either(c.token(p.p_string.whitespace()), comment))
function between_whitespace(parser) {
return c.between(opt_space, opt_space, parser) }
function optional(def, parser) {
return c.either(parser, c.always(def)) }
// I was legitimately running out of stack space :-)
var trampoline = function() {
var i = 0
return function trampoline(parser) {
return function(state, cok, cerr, eok, eerr) {
// decrease this number if you get stack overflow errors :P
if (i++ < 15) return parser(state, cok, cerr, eok, eerr)
i=0
process.nextTick(function() { parser(state, cok, cerr, eok, eerr) })} } }()
var string = c.between(
char('"'), char('"')
, many_str(c.either(
c.token(f.not(f.or(s.control(), s.char('"'), s.char('\\'))))
// escaped chars
, c.bind(
char('\\')
, c.choice(
char('"'), char('\\'), char('/'), char('b')
, char('f'), char('n'), char('r'), char('t'))
, function(_, n) { return c.always('"\\/\b\f\n\r\t'['"\\/bfnrt'.indexOf(n)]) }))))
var number = c.bind(
// sign
optional('', char('-'))
// integer part
, c.either(char('0'), many1_str(digit()))
// fractional part
, optional('', c.next(char('.'), many1_str(digit())))
// 'e' part
, optional(0, c.bind(
c.either(char('e'), char('E'))
, c.choice(char('+'), char('-'), c.always('+'))
, many1_str(digit())
, function(_, sign, x) {
return c.always(+(sign+x)) }))
, function(sign, int, frac, exp) {
return c.always(+(sign + int + '.' + frac + 'e' + exp)) })
function array() {
return c.between(
char('['), char(']')
, c.many(c.bind(
c.wrap(value)() // avoid infinite recursion
// separator
, c.either(char(','), c.lookahead(char(']'))) // wrong: [1,2,] will work
, function(a) { return c.always(a) }))) }
function object() {
return c.between(
char('{')
, char('}')
, c.bind(
c.many(c.bind(
between_whitespace(string)
, char(':')
, c.wrap(value)() // avoid infinite recursion
, c.either(char(','), c.lookahead(char('}'))) // wrong: {"1":2,} will work
, function(k, _, v, _) {
return c.always([k, v]) }))
, function(pairs) {
var obj = {}
for (var i = 0; i < pairs.length; i++)
obj[pairs[i][0]] = pairs[i][1]
return c.always(obj)})) }
function value() {
return trampoline(between_whitespace(c.choice(
string
, number
, object()
, array()
, literal('true', true)
, literal('false', false)
, literal('null', null)))) }
module.exports.value = value

242
parsec.js

@ -0,0 +1,242 @@
var errors = function() {
function ParseError(pos, msgs) {
this.msgs = [].concat(msgs)
this.line = pos.line
this.column = pos.column }
ParseError.prototype.show = function() {
return this.msgs.join(', ') +
" at" +
" line: " + this.line +
" column: " + this.column }
ParseError.prototype.combine = function(errs) {
if (!'length' in errs) errs = [errs]
return new CombinedError([this].concat(errs)) }
function CombinedError(errs) {
this.errs = errs ? errs : [] }
CombinedError.prototype.combine = function(errs) {
if (!'length' in errs) errs = [errs]
this.errs = this.errs.concat(errs) }
function unknown_error(pos) {
return new ParseError(pos, "Unknown error") }
function unexpect_error(pos, msg) {
return new ParseError(pos, "Unexpected " + msg) }
function expect_error(pos, msg) {
return new ParseError(pos, "Expected " + msg) }
function merge_errors() {
var a0 = arguments[0]
var ar = Array.prototype.slice.call(arguments, 1)
return ar.length ? a0.combine(ar) : a0 }
return {
Parse: ParseError
, unknown: unknown_error
, unexpect: unexpect_error
, expect: expect_error
, merge: merge_errors }}()
var p_string = function() {
function Parse_String_State(str) {
function Parse_State(pos, line, column) {
this.pos = pos || 0
this.line = line || 1
this.column = column || 1 }
Parse_State.prototype.str = str
Parse_State.prototype.increment = function(c) {
var newline = c == '\n'
return new Parse_State(this.pos+1, newline?this.line+1:this.line, newline?1:this.column+1) }
Parse_State.prototype.getToken = function() {
return this.str[this.pos] }
Parse_State.prototype.length = function() {
return this.str.length }
return Parse_State }
function char(x) {
return function(t) { return x == t }}
function digit() { return function(x){ var cx = x.charCodeAt(0); return cx < 58 && cx > 47 }}
function letter() {
return function(x) {
var cx = x.charCodeAt(0)
return (cx < 91 && cx > 64) || (cx < 123 && cx > 96) }}
function whitespace() {
return function(x) {
return x == ' ' || x == '\t' || x == '\r' || x == '\n' }}
function control() {
return function(x) {
return x.charCodeAt(0) < 32 }}
function run(p, input, cb) {
var str_state = new (Parse_String_State(input))()
function pok(x) {
cb(null, x) }
function perr(err) {
cb(err) }
p(str_state, pok, perr, pok, perr) }
return {
Parse_State: Parse_String_State
, char: char
, digit: digit
, letter: letter
, whitespace: whitespace
, control: control
, run: run }}()
var combinators = function() {
function always(x) {
return function(state, cok, cerr, eok, eerr) {
eok(x, state) }}
// avoiding infinite recursions
function wrap(f) {
return function(x) {
return function(state, cok, cerr, eok, eerr) {
return f(x)(state, cok, cerr, eok, eerr) }}}
function bind_2(p, f) {
return function(state, cok, cerr, eok, eerr) {
function pcok(item, state) {
var q = f(item)
q(state, cok, cerr, cok, cerr) }
function peok(item, state) {
wrap(f)(item)(state, cok, cerr, eok, eerr) }
p(state, pcok, cerr, peok, eerr) }}
function bind() {
var ar = arguments, ari, arn = ar.length - 1
if (arn == 1) return bind_2(arguments[0], arguments[1])
var last = ar[arn]
var res = new Array(arn), resi
return function(state, cok, cerr, eok, eerr) {
ari = resi = 0;
bind(ar[ari++], function bind_arg2(x) {
res[resi++] = x
if (resi == arn) return last.apply(this, res)
else return bind(ar[ari++], bind_arg2) })
(state, cok, cerr, eok, eerr)}}
function next(p, q) {
return bind(p, function() { return q }) }
function nxtnxt() {
var ar = Array.prototype.slice.call(arguments)
return ar.reduceRight(function(p, c) {
return next(c, p) }) }
function never(err) {
return function(state, cok, cerr, eok, eerr) {
eerr(errors.unknown(state)) } }
function either(p, q) {
return function(state, cok, cerr, eok, eerr) {
function p_eerr(err_from_p) {
function q_eerr(err_from_q) {
eerr(errors.merge(err_from_p, err_from_q)) }
q(state, cok, cerr, eok, q_eerr) }
p(state, cok, cerr, eok, p_eerr) } }
function attempt(p) {
return function(state, cok, cerr, eok, eerr) {
p(state, cok, eerr, eok, eerr) }}
function token(consume_p) {
return function(state, cok, cerr, eok, eerr) {
var t = state.getToken()
if (!t) eerr(errors.unexpect(state, 'end of input'))
else if (consume_p(t)) cok(t, state.increment(t))
else eerr(errors.unexpect(state, "token " + t)) } }
function times(n, p) {
if (n == 0) return always(null)
return function (state, cok, cerr, eok, eerr) {
var res = new Array(n)
var resi = 0
function pcok(item, state) {
function peok(item, state) {
while(resi < n) res[resi++] = item
cok(res, state) }
res[resi++] = item
if (resi < n) p(state, pcok, cerr, pcok, eerr)
else if (resi == n) cok(res, state) }
function peok(item, state) {
while(resi < n) res[resi++] = item
eok(res, state) }
p(state, pcok, cerr, peok, eerr) } }
function many(p) {
function many_err() {
throw new TypeError('`many` applied to parser that accepts an empty string') }
function safe_p(state, cok, cerr, eok, eerr) {
p(state, cok, cerr, many_err, eerr) }
return either(
bind(safe_p, wrap(many)(p), function(x, xs) {
return always([x].concat(xs)) })
, always([])) }
function many1(p) {
return bind(p, many(p), function(x, xs) {
return always([x].concat(xs) )})}
function lookahead(p) {
return function(state, cok, cerr, eok, eerr) {
function ok(t) {
eok(t, state) }
p(state, ok, cerr, eok, eerr) } }
function choice(first) {
/* either + varargs */
var ar = Array.prototype.slice.call(arguments, 1)
if (ar.length == 0 && !first) return never
if (ar.length == 0 && first) return first
return either(first, choice.apply(null, ar)) }
function eof() {
return function(state, cok, cerr, eok, eerr) {
if (state.pos == state.length()) eok(null, state)
else eerr(errors.expect(state, "end of input")) } }
function between(open, close, p) {
return bind(open, p, close, function(o, x, c) { return always(x) }) }
return {
always: always
, bind: bind
, next: next
, nxtnxt: nxtnxt
, never: never
, wrap: wrap
, either: either
, attempt: attempt
, many: many
, many1: many1
, times: times
, token: token
, lookahead: lookahead
, choice: choice
, between: between
, eof: eof }}()
var funp = function() {
// functional programming helpers, especially useful with token()
function not(f) {
return function(x) { return !f(x) }}
function and(p, q) {
return function(x) { return p(x) && q(x) }}
function or(p, q) { /* todo more than 2 args */
if (arguments.length > 2) return Array.prototype.slice.call(arguments).reduce(function(p,q){return or(p,q)})
return function(x) { return p(x) || q(x) }}
return {
not: not
, and: and
, or: or }}()
module.exports = {
combinators: combinators
, errors: errors
, p_string: p_string
, funp: funp }

12
test.js

@ -0,0 +1,12 @@
#!/usr/bin/env node
var json = require('./json')
var parsec = require('./parsec')
var fs = require('fs')
//var contents = fs.readFileSync('test.json').toString()
//console.log(contents)
parsec.p_string.run(json.value(), '10 /* */ \n', function(e, x) {
if (e) console.log(e.errs)
else console.log(x)
})
Loading…
Cancel
Save