Kaelan's Data Language Prototype

data-language-peg.pegjs

/*
Kaelan's Data Language Prototype
*/

JSON_text
  = ws members:member* ws { return members; }

begin_array     = ws "[" ws
begin_member    = ws "{" ws
end_array       = ws "]" ws
end_member      = ws "}" ws
name_separator  = ws "=" ws
value_separator = ws "," ws

ws "whitespace" = [ \t\n\r]*

// ----- 3. Values -----

value
  = false
  / null
  / true
  / number
  / string
  / array
  / member_body
  / reference

false = "false" { return false; }
null  = "null"  { return null;  }
true  = "true"  { return true;  }

DIGIT  = [0-9]
HEXDIG = [0-9a-f]i

inherit
  = "extends"

minus
  = "-"

plus
  = "+"

decimal_point
  = "."

zero
  = "0"

e
  = [eE]

exp
  = e (minus / plus)? DIGIT+

digit1_9
  = [1-9]

quotation_mark
  = '"'

int
  = zero / (digit1_9 DIGIT*)

frac
  = decimal_point DIGIT+

number "number"
  = minus? int frac? exp? { return parseFloat(text()); }

string "string"
  = quotation_mark chars:char* quotation_mark { return chars.join(""); }

identifier
  = values:[a-zA-Z0-9_-]+ { return values.join(""); }

reference = ref:identifier { return { type: 'reference', ref }; }

unescaped
  = [^\0-\x1F\x22\x5C]

escape
  = "\\"

array
  = begin_array
    ws
    values:(
      head:value
      tail:(value_separator v:value { return v; })*
      { return [head].concat(tail); }
    )?
    value_separator?
    ws
    end_array
    { return values !== null ? values : []; }

member_header
    = kind:identifier ws name:identifier ws inherit ws parent_member:identifier
    { return { kind, name, parent_member }; }
	/ kind:identifier ws name:identifier
    { return { kind, name }; }

member_value = ws name:identifier ws name_separator ws value:value ws { return { name, value }; }

member_body = begin_member ws members:member_value+ ws end_member { return members; }

member = head:member_header ws body:member_body {
	return { head, body };
}

char
  = unescaped
  / escape
    sequence:(
        '"'
      / "\\"
      / "/"
      / "b" { return "\b"; }
      / "f" { return "\f"; }
      / "n" { return "\n"; }
      / "r" { return "\r"; }
      / "t" { return "\t"; }
      / "u" digits:$(HEXDIG HEXDIG HEXDIG HEXDIG) {
          return String.fromCharCode(parseInt(digits, 16));
        }
    )
    { return sequence; }

example

kind foo {
    str = "bar"
    numb = 1
    bool = true
    arr = [1,2,3]
    arr2 = [
       1,
       { foo = 1.1 }
    ]
}

kind bar extends foo {
    ref = foo
}