From f1c606dc19ef745a13304b1ee862d1fd5e244df0 Mon Sep 17 00:00:00 2001 From: kortschak Date: Thu, 24 Jul 2014 20:08:05 +0930 Subject: [PATCH 01/52] Provide standalone converter for 30kmoviesdata.nt --- nquads/quadfix.go | 215 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 215 insertions(+) create mode 100644 nquads/quadfix.go diff --git a/nquads/quadfix.go b/nquads/quadfix.go new file mode 100644 index 0000000..c8c70c7 --- /dev/null +++ b/nquads/quadfix.go @@ -0,0 +1,215 @@ +// +build ignore + +package main + +import ( + "bufio" + "errors" + "fmt" + "io" + "log" + "os" + "strings" + + "github.com/google/cayley/graph" +) + +func main() { + dec := NewDecoder(os.Stdin) + for { + t, err := dec.Unmarshal() + if err != nil { + if err == io.EOF { + return + } + log.Println(err) + } + if t.Object[0] == ':' { + t.Object = "_" + t.Object + } else { + t.Object = fmt.Sprintf(`%q`, t.Object) + } + fmt.Printf("_%s <%s> %s .\n", t.Subject, t.Predicate, t.Object) + } +} + +// Historical N-Quads parser code. +// ------------------------------- + +var ( + ErrAbsentSubject = errors.New("nqauds: absent subject") + ErrAbsentPredicate = errors.New("nqauds: absent predicate") + ErrAbsentObject = errors.New("nqauds: absent object") + ErrUnterminated = errors.New("nqauds: unterminated quad") +) + +func Parse(str string) (*graph.Triple, error) { + // Skip leading whitespace. + str = trimSpace(str) + // Check for a comment + if str != "" && str[0] == '#' { + return nil, nil + } + sub, remainder := getTripleComponent(str) + if sub == "" { + return nil, ErrAbsentSubject + } + str = trimSpace(remainder) + pred, remainder := getTripleComponent(str) + if pred == "" { + return nil, ErrAbsentPredicate + } + str = trimSpace(remainder) + obj, remainder := getTripleComponent(str) + if obj == "" { + return nil, ErrAbsentObject + } + str = trimSpace(remainder) + prov, remainder := getTripleComponent(str) + str = trimSpace(remainder) + if str != "" && str[0] == '.' { + return &graph.Triple{sub, pred, obj, prov}, nil + } + return nil, ErrUnterminated +} + +func isSpace(s uint8) bool { + return s == ' ' || s == '\t' || s == '\r' +} + +func trimSpace(str string) string { + i := 0 + for i < len(str) && isSpace(str[i]) { + i += 1 + } + return str[i:] +} + +func getTripleComponent(str string) (head, tail string) { + if len(str) == 0 { + return "", str + } + if str[0] == '<' { + return getUriPart(str[1:]) + } else if str[0] == '"' { + return getQuotedPart(str[1:]) + } else if str[0] == '.' { + return "", str + } else { + // Technically not part of the spec. But we do it anyway for convenience. + return getUnquotedPart(str) + } +} + +func getUriPart(str string) (head, tail string) { + i := 0 + for i < len(str) && str[i] != '>' { + i += 1 + } + if i == len(str) { + return "", str + } + head = str[0:i] + return head, str[i+1:] +} + +func getQuotedPart(str string) (head, tail string) { + var ( + i int + start int + ) + for i < len(str) && str[i] != '"' { + if str[i] == '\\' { + head += str[start:i] + switch str[i+1] { + case '\\': + head += "\\" + case 'r': + head += "\r" + case 'n': + head += "\n" + case 't': + head += "\t" + case '"': + head += "\"" + default: + return "", str + } + i += 2 + start = i + continue + } + i += 1 + } + if i == len(str) { + return "", str + } + head += str[start:i] + i += 1 + switch { + case strings.HasPrefix(str[i:], "^^<"): + // Ignore type, for now + _, tail = getUriPart(str[i+3:]) + case str[i] == '@': + _, tail = getUnquotedPart(str[i+1:]) + default: + tail = str[i:] + } + + return head, tail +} + +func getUnquotedPart(str string) (head, tail string) { + var ( + i int + initStr = str + start int + ) + for i < len(str) && !isSpace(str[i]) { + if str[i] == '"' { + part, remainder := getQuotedPart(str[i+1:]) + if part == "" { + return part, initStr + } + head += str[start:i] + str = remainder + i = 0 + start = 0 + head += part + } + i += 1 + } + head += str[start:i] + return head, str[i:] +} + +type Decoder struct { + r *bufio.Reader + line []byte +} + +func NewDecoder(r io.Reader) *Decoder { + return &Decoder{r: bufio.NewReader(r)} +} + +func (dec *Decoder) Unmarshal() (*graph.Triple, error) { + dec.line = dec.line[:0] + for { + l, pre, err := dec.r.ReadLine() + if err != nil { + return nil, err + } + dec.line = append(dec.line, l...) + if !pre { + break + } + } + triple, err := Parse(string(dec.line)) + if err != nil { + return nil, fmt.Errorf("failed to parse %q: %v", dec.line, err) + } + if triple == nil { + return dec.Unmarshal() + } + return triple, nil +} From 92d50bb9f7b0e3faae80b4ad5c46d2c28987d05f Mon Sep 17 00:00:00 2001 From: kortschak Date: Thu, 24 Jul 2014 20:33:28 +0930 Subject: [PATCH 02/52] Add parser generation definition --- nquads/actions.rl | 83 +++++++++++++++++++++++++++++++++++++ nquads/nquads.rl | 94 ++++++++++++++++++++++++++++++++++++++++++ nquads/parse.rl | 120 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 297 insertions(+) create mode 100644 nquads/actions.rl create mode 100644 nquads/nquads.rl create mode 100644 nquads/parse.rl diff --git a/nquads/actions.rl b/nquads/actions.rl new file mode 100644 index 0000000..a53fc93 --- /dev/null +++ b/nquads/actions.rl @@ -0,0 +1,83 @@ +// Copyright 2014 The Cayley Authors. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +%%{ + machine quads; + + action Escape { + isEscaped = true + } + + action StartSubject { + subject = p + } + + action StartPredicate { + predicate = p + } + + action StartObject { + object = p + } + + action StartLabel { + label = p + } + + action SetSubject { + if subject < 0 { + panic("unexpected parser state: subject start not set") + } + triple.Subject = unEscape(data[subject:p], isEscaped) + isEscaped = false + } + + action SetPredicate { + if predicate < 0 { + panic("unexpected parser state: predicate start not set") + } + triple.Predicate = unEscape(data[predicate:p], isEscaped) + isEscaped = false + } + + action SetObject { + if object < 0 { + panic("unexpected parser state: object start not set") + } + triple.Object = unEscape(data[object:p], isEscaped) + isEscaped = false + } + + action SetLabel { + if label < 0 { + panic("unexpected parser state: label start not set") + } + triple.Provenance = unEscape(data[label:p], isEscaped) + isEscaped = false + } + + action Return { + return triple, nil + } + + action Comment { + } + + action Error { + if p < len(data) { + return graph.Triple{}, fmt.Errorf("%v: unexpected rune %q at %d", ErrInvalid, data[p], p) + } + return graph.Triple{}, ErrIncomplete + } +}%% diff --git a/nquads/nquads.rl b/nquads/nquads.rl new file mode 100644 index 0000000..1ca056c --- /dev/null +++ b/nquads/nquads.rl @@ -0,0 +1,94 @@ +// Copyright 2014 The Cayley Authors. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Ragel gramar definition derived from http://www.w3.org/TR/n-quads/#sec-grammar. + +%%{ + machine quads; + + alphtype rune; + + PN_CHARS_BASE = [A-Za-z] + | 0x00c0 .. 0x00d6 + | 0x00d8 .. 0x00f6 + | 0x00f8 .. 0x02ff + | 0x0370 .. 0x037d + | 0x037f .. 0x1fff + | 0x200c .. 0x200d + | 0x2070 .. 0x218f + | 0x2c00 .. 0x2fef + | 0x3001 .. 0xd7ff + | 0xf900 .. 0xfdcf + | 0xfdf0 .. 0xfffd + | 0x10000 .. 0x1efff + ; + + PN_CHARS_U = PN_CHARS_BASE | '_' | ':' ; + + PN_CHARS = PN_CHARS_U + | '-' + | [0-9] + | 0xb7 + | 0x0300 .. 0x036f + | 0x203f .. 0x2040 + ; + + ECHAR = ('\\' [tbnrf"'\\]) %Escape ; + + UCHAR = ('\\u' xdigit {4} + | '\\U' xdigit {8}) %Escape + ; + + BLANK_NODE_LABEL = '_:' (PN_CHARS_U | [0-9]) ((PN_CHARS | '.')* PN_CHARS)? ; + + STRING_LITERAL_QUOTE = '"' ( + 0x00 .. 0x09 + | 0x0b .. 0x0c + | 0x0e .. '!' + | '#' .. '[' + | ']' .. '~' + | ECHAR | UCHAR)* + '"' + ; + + IRIREF = '<' ( + '!' .. ';' + | '=' + | '?' .. '[' + | ']' + | '_' + | 'a' .. 'z' + | '~' | UCHAR)* + '>' + ; + + LANGTAG = '@' [a-zA-Z]+ ('-' [a-zA-Z0-9]+)* ; + + whitespace = [ \t] ; + + literal = STRING_LITERAL_QUOTE ('^^' IRIREF | LANGTAG)? ; + + subject = IRIREF | BLANK_NODE_LABEL ; + predicate = IRIREF ; + object = IRIREF | BLANK_NODE_LABEL | literal ; + graphLabel = IRIREF | BLANK_NODE_LABEL ; + + statement := ( + whitespace* subject >StartSubject %SetSubject + whitespace+ predicate >StartPredicate %SetPredicate + whitespace+ object >StartObject %SetObject + (whitespace+ graphLabel >StartLabel %SetLabel)? + whitespace* '.' whitespace* ('#' any*)? >Comment + ) %Return @!Error ; +}%% diff --git a/nquads/parse.rl b/nquads/parse.rl new file mode 100644 index 0000000..fb97e25 --- /dev/null +++ b/nquads/parse.rl @@ -0,0 +1,120 @@ +// GO SOURCE FILE MACHINE GENERATED BY RAGEL; DO NOT EDIT + +// Copyright 2014 The Cayley Authors. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package nquads + +import ( + "bytes" + "errors" + "fmt" + "strconv" + + "github.com/google/cayley/graph" +) + +var ( + ErrInvalid = errors.New("invalid N-Quad") + ErrIncomplete = errors.New("incomplete N-Quad") +) + +%%{ + machine quads; + + include "actions.rl"; + + include "nquads.rl"; + + write data; +}%% + +func parse(data []rune) (graph.Triple, error) { + var ( + cs, p int + pe = len(data) + eof = pe + + subject = -1 + predicate = -1 + object = -1 + label = -1 + + isEscaped bool + + triple graph.Triple + ) + + %%write init; + + %%write exec; + + return graph.Triple{}, ErrInvalid +} + +func unEscape(r []rune, isEscaped bool) string { + if !isEscaped { + return string(r) + } + + buf := bytes.NewBuffer(make([]byte, 0, len(r))) + + for i := 0; i < len(r); { + switch r[i] { + case '\\': + i++ + var c byte + switch r[i] { + case 't': + c = '\t' + case 'b': + c = '\b' + case 'n': + c = '\n' + case 'r': + c = '\r' + case 'f': + c = '\f' + case '"': + c = '"' + case '\'': + c = '\'' + case '\\': + c = '\\' + case 'u': + rc, err := strconv.ParseInt(string(r[i+1:i+5]), 16, 32) + if err != nil { + panic(fmt.Errorf("internal parser error: %v", err)) + } + buf.WriteRune(rune(rc)) + i += 5 + continue + case 'U': + rc, err := strconv.ParseInt(string(r[i+1:i+9]), 16, 32) + if err != nil { + panic(fmt.Errorf("internal parser error: %v", err)) + } + buf.WriteRune(rune(rc)) + i += 9 + continue + } + buf.WriteByte(c) + default: + buf.WriteRune(r[i]) + } + i++ + } + + return buf.String() +} From 22bad1701f94efaba77a1a65863b51fe29ae5af3 Mon Sep 17 00:00:00 2001 From: kortschak Date: Thu, 24 Jul 2014 21:25:14 +0930 Subject: [PATCH 03/52] Generate code for parser G2 code generation used after benchmarking. style benchmark old ns/op new ns/op delta T0 BenchmarkParser 672 5631 +737.95% T1 BenchmarkParser 672 5579 +730.21% G0 BenchmarkParser 672 4049 +502.53% G1 BenchmarkParser 672 3868 +475.60% G2 BenchmarkParser 672 3543 +427.23% F0 and F1 create massive Go source (6.0M) and so were not tested. Invalid tests removed, additional tests for invalid input to be added later. --- nquads/nquads.go | 141 +-- nquads/nquads_test.go | 373 ++++-- nquads/parse.go | 3007 +++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 3316 insertions(+), 205 deletions(-) create mode 100644 nquads/parse.go diff --git a/nquads/nquads.go b/nquads/nquads.go index 7bd4c41..b86bb4f 100644 --- a/nquads/nquads.go +++ b/nquads/nquads.go @@ -19,7 +19,6 @@ import ( "errors" "fmt" "io" - "strings" "github.com/google/cayley/graph" ) @@ -32,143 +31,11 @@ var ( ) func Parse(str string) (*graph.Triple, error) { - // Skip leading whitespace. - str = trimSpace(str) - // Check for a comment - if str != "" && str[0] == '#' { - return nil, nil + t, err := parse([]rune(str)) + if err != nil { + return nil, err } - sub, remainder := getTripleComponent(str) - if sub == "" { - return nil, ErrAbsentSubject - } - str = trimSpace(remainder) - pred, remainder := getTripleComponent(str) - if pred == "" { - return nil, ErrAbsentPredicate - } - str = trimSpace(remainder) - obj, remainder := getTripleComponent(str) - if obj == "" { - return nil, ErrAbsentObject - } - str = trimSpace(remainder) - prov, remainder := getTripleComponent(str) - str = trimSpace(remainder) - if str != "" && str[0] == '.' { - return &graph.Triple{sub, pred, obj, prov}, nil - } - return nil, ErrUnterminated -} - -func isSpace(s uint8) bool { - return s == ' ' || s == '\t' || s == '\r' -} - -func trimSpace(str string) string { - i := 0 - for i < len(str) && isSpace(str[i]) { - i += 1 - } - return str[i:] -} - -func getTripleComponent(str string) (head, tail string) { - if len(str) == 0 { - return "", str - } - if str[0] == '<' { - return getUriPart(str[1:]) - } else if str[0] == '"' { - return getQuotedPart(str[1:]) - } else if str[0] == '.' { - return "", str - } else { - // Technically not part of the spec. But we do it anyway for convenience. - return getUnquotedPart(str) - } -} - -func getUriPart(str string) (head, tail string) { - i := 0 - for i < len(str) && str[i] != '>' { - i += 1 - } - if i == len(str) { - return "", str - } - head = str[0:i] - return head, str[i+1:] -} - -func getQuotedPart(str string) (head, tail string) { - var ( - i int - start int - ) - for i < len(str) && str[i] != '"' { - if str[i] == '\\' { - head += str[start:i] - switch str[i+1] { - case '\\': - head += "\\" - case 'r': - head += "\r" - case 'n': - head += "\n" - case 't': - head += "\t" - case '"': - head += "\"" - default: - return "", str - } - i += 2 - start = i - continue - } - i += 1 - } - if i == len(str) { - return "", str - } - head += str[start:i] - i += 1 - switch { - case strings.HasPrefix(str[i:], "^^<"): - // Ignore type, for now - _, tail = getUriPart(str[i+3:]) - case str[i] == '@': - _, tail = getUnquotedPart(str[i+1:]) - default: - tail = str[i:] - } - - return head, tail -} - -func getUnquotedPart(str string) (head, tail string) { - var ( - i int - initStr = str - start int - ) - for i < len(str) && !isSpace(str[i]) { - if str[i] == '"' { - part, remainder := getQuotedPart(str[i+1:]) - if part == "" { - return part, initStr - } - head += str[start:i] - str = remainder - i = 0 - start = 0 - head += part - } - i += 1 - } - head += str[start:i] - return head, str[i:] + return &t, nil } type Decoder struct { diff --git a/nquads/nquads_test.go b/nquads/nquads_test.go index 8b2fa6b..eb5a548 100644 --- a/nquads/nquads_test.go +++ b/nquads/nquads_test.go @@ -27,93 +27,330 @@ var testNTriples = []struct { expect *graph.Triple err error }{ - // NTriple tests. + // Tests taken from http://www.w3.org/TR/n-quads/ and http://www.w3.org/TR/n-triples/. + + // N-Triples example 1. { - message: "not parse invalid triples", - input: "invalid", - expect: nil, - err: ErrAbsentPredicate, + message: "parse triple with commment", + input: ` . # comments here`, + expect: &graph.Triple{ + Subject: "", + Predicate: "", + Object: "", + Provenance: "", + }, + err: nil, }, { - message: "invalid internal quote", - input: `":103032" "/film/performance/character" "Walter "Teacher" Cole" .`, - expect: nil, - err: ErrUnterminated, + message: "parse triple with blank subject node, literal object and no comment (1)", + input: `_:subject1 "object1" .`, + expect: &graph.Triple{ + Subject: "_:subject1", + Predicate: "", + Object: `"object1"`, + Provenance: "", + }, + err: nil, }, { - message: "not parse comments", - input: "# nominally valid triple .", - expect: nil, - err: nil, - }, - { - message: "parse simple triples", - input: "this is valid .", - expect: &graph.Triple{"this", "is", "valid", ""}, - }, - { - message: "parse quoted triples", - input: `this is "valid too" .`, - expect: &graph.Triple{"this", "is", "valid too", ""}, - }, - { - message: "parse escaped quoted triples", - input: `he said "\"That's all folks\"" .`, - expect: &graph.Triple{"he", "said", `"That's all folks"`, ""}, - }, - { - message: "parse an example real triple", - input: `":/guid/9202a8c04000641f80000000010c843c" "name" "George Morris" .`, - expect: &graph.Triple{":/guid/9202a8c04000641f80000000010c843c", "name", "George Morris", ""}, - }, - { - message: "parse a pathologically spaced triple", - input: "foo is \"\\tA big tough\\r\\nDeal\\\\\" .", - expect: &graph.Triple{"foo", "is", "\tA big tough\r\nDeal\\", ""}, + message: "parse triple with blank subject node, literal object and no comment (2)", + input: `_:subject2 "object2" .`, + expect: &graph.Triple{ + Subject: "_:subject2", + Predicate: "", + Object: `"object2"`, + Provenance: "", + }, + err: nil, }, - // NQuad tests. + // N-Triples example 2. { - message: "parse a simple quad", - input: "this is valid quad .", - expect: &graph.Triple{"this", "is", "valid", "quad"}, - }, - { - message: "parse a quoted quad", - input: `this is valid "quad thing" .`, - expect: &graph.Triple{"this", "is", "valid", "quad thing"}, - }, - { - message: "parse crazy escaped quads", - input: `"\"this" "\"is" "\"valid" "\"quad thing".`, - expect: &graph.Triple{`"this`, `"is`, `"valid`, `"quad thing`}, + message: "parse triple with three IRIREFs", + input: ` .`, + expect: &graph.Triple{ + Subject: "", + Predicate: "", + Object: "", + Provenance: "", + }, + err: nil, }, - // NTriple official tests. + // N-Triples example 3. { - message: "handle simple case with comments", - input: " . # comment", - expect: &graph.Triple{"http://example/s", "http://example/p", "http://example/o", ""}, + message: "parse triple with blank node labelled subject and object and IRIREF predicate (1)", + input: `_:alice _:bob .`, + expect: &graph.Triple{ + Subject: "_:alice", + Predicate: "", + Object: "_:bob", + Provenance: "", + }, + err: nil, }, { - message: "handle simple case with comments", - input: " _:o . # comment", - expect: &graph.Triple{"http://example/s", "http://example/p", "_:o", ""}, + message: "parse triple with blank node labelled subject and object and IRIREF predicate (2)", + input: `_:bob _:alice .`, + expect: &graph.Triple{ + Subject: "_:bob", + Predicate: "", + Object: "_:alice", + Provenance: "", + }, + err: nil, + }, + + // N-Quads example 1. + { + message: "parse quad with commment", + input: ` . # comments here`, + expect: &graph.Triple{ + Subject: "", + Predicate: "", + Object: "", + Provenance: "", + }, + err: nil, }, { - message: "handle simple case with comments", - input: " \"o\" . # comment", - expect: &graph.Triple{"http://example/s", "http://example/p", "o", ""}, + message: "parse quad with blank subject node, literal object, IRIREF predicate and label, and no comment (1)", + input: `_:subject1 "object1" .`, + expect: &graph.Triple{ + Subject: "_:subject1", + Predicate: "", + Object: `"object1"`, + Provenance: "", + }, + err: nil, }, { - message: "handle simple case with comments", - input: " \"o\"^^ . # comment", - expect: &graph.Triple{"http://example/s", "http://example/p", "o", ""}, + message: "parse quad with blank subject node, literal object, IRIREF predicate and label, and no comment (2)", + input: `_:subject2 "object2" .`, + expect: &graph.Triple{ + Subject: "_:subject2", + Predicate: "", + Object: `"object2"`, + Provenance: "", + }, + err: nil, + }, + + // N-Quads example 2. + { + message: "parse quad with all IRIREF parts", + input: ` .`, + expect: &graph.Triple{ + Subject: "", + Predicate: "", + Object: "", + Provenance: "", + }, + err: nil, + }, + + // N-Quads example 3. + { + message: "parse quad with blank node labelled subject and object and IRIREF predicate and label (1)", + input: `_:alice _:bob .`, + expect: &graph.Triple{ + Subject: "_:alice", + Predicate: "", + Object: "_:bob", + Provenance: "", + }, + err: nil, }, { - message: "handle simple case with comments", - input: " \"o\"@en . # comment", - expect: &graph.Triple{"http://example/s", "http://example/p", "o", ""}, + message: "parse quad with blank node labelled subject and object and IRIREF predicate and label (2)", + input: `_:bob _:alice .`, + expect: &graph.Triple{ + Subject: "_:bob", + Predicate: "", + Object: "_:alice", + Provenance: "", + }, + err: nil, + }, + + // N-Triples tests. + { + message: "parse triple with all IRIREF parts", + input: ` .`, + expect: &graph.Triple{ + Subject: "", + Predicate: "", + Object: "", + Provenance: "", + }, + err: nil, + }, + { + message: "parse triple with all IRIREF parts", + input: ` .`, + expect: &graph.Triple{ + Subject: "", + Predicate: "", + Object: "", + Provenance: "", + }, + err: nil, + }, + { + message: "parse triple with IRIREF schema on literal object", + input: ` "1990-07-04"^^ .`, + expect: &graph.Triple{ + Subject: "", + Predicate: "", + Object: `"1990-07-04"^^`, + Provenance: "", + }, + err: nil, + }, + { + message: "parse commented IRIREF in triple", + input: ` .`, + expect: &graph.Triple{ + Subject: "", + Predicate: "", + Object: "", + Provenance: "", + }, + err: nil, + }, + { + message: "parse triple with literal subject", + input: ` "Mona Lisa" .`, + expect: &graph.Triple{ + Subject: "", + Predicate: "", + Object: `"Mona Lisa"`, + Provenance: "", + }, + err: nil, + }, + { + message: "parse triple with all IRIREF parts (1)", + input: ` .`, + expect: &graph.Triple{ + Subject: "", + Predicate: "", + Object: "", + Provenance: "", + }, + err: nil, + }, + { + message: "parse triple with all IRIREF parts (2)", + input: ` .`, + expect: &graph.Triple{ + Subject: "", + Predicate: "", + Object: "", + Provenance: "", + }, + err: nil, + }, + + // N-Quads tests. + { + message: "parse commented IRIREF in quad (1)", + input: ` .`, + expect: &graph.Triple{ + Subject: "", + Predicate: "", + Object: "", + Provenance: "", + }, + err: nil, + }, + { + message: "parse quad with all IRIREF parts", + input: ` .`, + expect: &graph.Triple{ + Subject: "", + Predicate: "", + Object: "", + Provenance: "", + }, + err: nil, + }, + { + message: "parse quad with IRIREF schema on literal object", + input: ` "1990-07-04"^^ .`, + expect: &graph.Triple{ + Subject: "", + Predicate: "", + Object: `"1990-07-04"^^`, + Provenance: "", + }, + err: nil, + }, + { + message: "parse commented IRIREF in quad (2)", + input: ` .`, + expect: &graph.Triple{ + Subject: "", + Predicate: "", + Object: "", + Provenance: "", + }, + err: nil, + }, + { + message: "parse literal object and colon qualified label in quad", + input: ` "Mona Lisa" .`, + expect: &graph.Triple{ + Subject: "", + Predicate: "", + Object: `"Mona Lisa"`, + Provenance: "", + }, + err: nil, + }, + { + message: "parse all IRIREF parts with colon qualified label in quad (1)", + input: ` .`, + expect: &graph.Triple{ + Subject: "", + Predicate: "", + Object: "", + Provenance: "", + }, + err: nil, + }, + { + message: "parse all IRIREF parts with colon qualified label in quad (2)", + input: ` .`, + expect: &graph.Triple{ + Subject: "", + Predicate: "", + Object: "", + Provenance: "", + }, + err: nil, + }, + { + message: "parse all IRIREF parts (quad section - 1)", + input: ` .`, + expect: &graph.Triple{ + Subject: "", + Predicate: "", + Object: "", + Provenance: "", + }, + err: nil, + }, + { + message: "parse all IRIREF parts (quad section - 2)", + input: ` .`, + expect: &graph.Triple{ + Subject: "", + Predicate: "", + Object: "", + Provenance: "", + }, + err: nil, }, } diff --git a/nquads/parse.go b/nquads/parse.go new file mode 100644 index 0000000..f46264d --- /dev/null +++ b/nquads/parse.go @@ -0,0 +1,3007 @@ + +// line 1 "parse.rl" +// GO SOURCE FILE MACHINE GENERATED BY RAGEL; DO NOT EDIT + +// Copyright 2014 The Cayley Authors. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package nquads + +import ( + "bytes" + "errors" + "fmt" + "strconv" + + "github.com/google/cayley/graph" +) + +var ( + ErrInvalid = errors.New("invalid N-Quad") + ErrIncomplete = errors.New("incomplete N-Quad") +) + + +// line 37 "parse.go" +const quads_start int = 1 +const quads_first_final int = 84 +const quads_error int = 0 + +const quads_en_statement int = 1 + + +// line 41 "parse.rl" + + +func parse(data []rune) (graph.Triple, error) { + var ( + cs, p int + pe = len(data) + eof = pe + + subject = -1 + predicate = -1 + object = -1 + label = -1 + + isEscaped bool + + triple graph.Triple + ) + + +// line 65 "parse.go" + { + cs = quads_start + } + +// line 60 "parse.rl" + + +// line 73 "parse.go" + { + if p == pe { + goto _test_eof + } + switch cs { + case 1: + goto st_case_1 + case 0: + goto st_case_0 + case 2: + goto st_case_2 + case 3: + goto st_case_3 + case 4: + goto st_case_4 + case 5: + goto st_case_5 + case 6: + goto st_case_6 + case 7: + goto st_case_7 + case 8: + goto st_case_8 + case 9: + goto st_case_9 + case 10: + goto st_case_10 + case 84: + goto st_case_84 + case 85: + goto st_case_85 + case 11: + goto st_case_11 + case 12: + goto st_case_12 + case 13: + goto st_case_13 + case 14: + goto st_case_14 + case 15: + goto st_case_15 + case 16: + goto st_case_16 + case 17: + goto st_case_17 + case 18: + goto st_case_18 + case 19: + goto st_case_19 + case 20: + goto st_case_20 + case 21: + goto st_case_21 + case 22: + goto st_case_22 + case 23: + goto st_case_23 + case 24: + goto st_case_24 + case 25: + goto st_case_25 + case 26: + goto st_case_26 + case 86: + goto st_case_86 + case 27: + goto st_case_27 + case 28: + goto st_case_28 + case 29: + goto st_case_29 + case 30: + goto st_case_30 + case 31: + goto st_case_31 + case 32: + goto st_case_32 + case 33: + goto st_case_33 + case 34: + goto st_case_34 + case 35: + goto st_case_35 + case 36: + goto st_case_36 + case 37: + goto st_case_37 + case 38: + goto st_case_38 + case 39: + goto st_case_39 + case 40: + goto st_case_40 + case 41: + goto st_case_41 + case 42: + goto st_case_42 + case 43: + goto st_case_43 + case 44: + goto st_case_44 + case 45: + goto st_case_45 + case 46: + goto st_case_46 + case 47: + goto st_case_47 + case 48: + goto st_case_48 + case 49: + goto st_case_49 + case 50: + goto st_case_50 + case 51: + goto st_case_51 + case 52: + goto st_case_52 + case 53: + goto st_case_53 + case 54: + goto st_case_54 + case 55: + goto st_case_55 + case 56: + goto st_case_56 + case 57: + goto st_case_57 + case 58: + goto st_case_58 + case 87: + goto st_case_87 + case 59: + goto st_case_59 + case 60: + goto st_case_60 + case 61: + goto st_case_61 + case 62: + goto st_case_62 + case 63: + goto st_case_63 + case 64: + goto st_case_64 + case 65: + goto st_case_65 + case 66: + goto st_case_66 + case 67: + goto st_case_67 + case 68: + goto st_case_68 + case 69: + goto st_case_69 + case 70: + goto st_case_70 + case 71: + goto st_case_71 + case 72: + goto st_case_72 + case 73: + goto st_case_73 + case 74: + goto st_case_74 + case 75: + goto st_case_75 + case 76: + goto st_case_76 + case 77: + goto st_case_77 + case 78: + goto st_case_78 + case 79: + goto st_case_79 + case 80: + goto st_case_80 + case 81: + goto st_case_81 + case 82: + goto st_case_82 + case 83: + goto st_case_83 + } + goto st_out + st1: + if p++; p == pe { + goto _test_eof1 + } + st_case_1: + switch data[p] { + case 9: + goto st1 + case 32: + goto st1 + case 60: + goto tr2 + case 95: + goto tr3 + } + goto tr0 +tr0: +// line 77 "actions.rl" + + + if p < len(data) { + return graph.Triple{}, fmt.Errorf("%v: unexpected rune %q at %d", ErrInvalid, data[p], p) + } + return graph.Triple{}, ErrIncomplete + + goto st0 +// line 283 "parse.go" +st_case_0: + st0: + cs = 0 + goto _out +tr2: +// line 22 "actions.rl" + + + subject = p + + goto st2 +tr107: +// line 18 "actions.rl" + + + isEscaped = true + + goto st2 + st2: + if p++; p == pe { + goto _test_eof2 + } + st_case_2: +// line 307 "parse.go" + switch data[p] { + case 62: + goto st3 + case 92: + goto st70 + case 95: + goto st2 + case 126: + goto st2 + } + switch { + case data[p] < 61: + if 33 <= data[p] && data[p] <= 59 { + goto st2 + } + case data[p] > 93: + if 97 <= data[p] && data[p] <= 122 { + goto st2 + } + default: + goto st2 + } + goto tr0 +tr108: +// line 18 "actions.rl" + + + isEscaped = true + + goto st3 + st3: + if p++; p == pe { + goto _test_eof3 + } + st_case_3: +// line 343 "parse.go" + switch data[p] { + case 9: + goto tr7 + case 32: + goto tr7 + } + goto tr0 +tr7: +// line 38 "actions.rl" + + + if subject < 0 { + panic("unexpected parser state: subject start not set") + } + triple.Subject = unEscape(data[subject:p], isEscaped) + isEscaped = false + + goto st4 + st4: + if p++; p == pe { + goto _test_eof4 + } + st_case_4: +// line 367 "parse.go" + switch data[p] { + case 9: + goto st4 + case 32: + goto st4 + case 60: + goto tr9 + } + goto tr0 +tr9: +// line 26 "actions.rl" + + + predicate = p + + goto st5 +tr95: +// line 18 "actions.rl" + + + isEscaped = true + + goto st5 + st5: + if p++; p == pe { + goto _test_eof5 + } + st_case_5: +// line 396 "parse.go" + switch data[p] { + case 62: + goto st6 + case 92: + goto st60 + case 95: + goto st5 + case 126: + goto st5 + } + switch { + case data[p] < 61: + if 33 <= data[p] && data[p] <= 59 { + goto st5 + } + case data[p] > 93: + if 97 <= data[p] && data[p] <= 122 { + goto st5 + } + default: + goto st5 + } + goto tr0 +tr96: +// line 18 "actions.rl" + + + isEscaped = true + + goto st6 + st6: + if p++; p == pe { + goto _test_eof6 + } + st_case_6: +// line 432 "parse.go" + switch data[p] { + case 9: + goto tr13 + case 32: + goto tr13 + } + goto tr0 +tr13: +// line 46 "actions.rl" + + + if predicate < 0 { + panic("unexpected parser state: predicate start not set") + } + triple.Predicate = unEscape(data[predicate:p], isEscaped) + isEscaped = false + + goto st7 + st7: + if p++; p == pe { + goto _test_eof7 + } + st_case_7: +// line 456 "parse.go" + switch data[p] { + case 9: + goto st7 + case 32: + goto st7 + case 34: + goto tr15 + case 60: + goto tr16 + case 95: + goto tr17 + } + goto tr0 +tr15: +// line 30 "actions.rl" + + + object = p + + goto st8 +tr73: +// line 18 "actions.rl" + + + isEscaped = true + + goto st8 + st8: + if p++; p == pe { + goto _test_eof8 + } + st_case_8: +// line 489 "parse.go" + switch data[p] { + case 34: + goto st9 + case 92: + goto st46 + } + switch { + case data[p] < 11: + if 0 <= data[p] && data[p] <= 9 { + goto st8 + } + case data[p] > 12: + if 14 <= data[p] && data[p] <= 126 { + goto st8 + } + default: + goto st8 + } + goto tr0 +tr74: +// line 18 "actions.rl" + + + isEscaped = true + + goto st9 + st9: + if p++; p == pe { + goto _test_eof9 + } + st_case_9: +// line 521 "parse.go" + switch data[p] { + case 9: + goto tr21 + case 32: + goto tr21 + case 46: + goto tr22 + case 64: + goto st28 + case 94: + goto st32 + } + goto tr0 +tr21: +// line 54 "actions.rl" + + + if object < 0 { + panic("unexpected parser state: object start not set") + } + triple.Object = unEscape(data[object:p], isEscaped) + isEscaped = false + + goto st10 + st10: + if p++; p == pe { + goto _test_eof10 + } + st_case_10: +// line 551 "parse.go" + switch data[p] { + case 9: + goto st10 + case 32: + goto st10 + case 46: + goto st84 + case 60: + goto tr27 + case 95: + goto tr28 + } + goto tr0 +tr22: +// line 54 "actions.rl" + + + if object < 0 { + panic("unexpected parser state: object start not set") + } + triple.Object = unEscape(data[object:p], isEscaped) + isEscaped = false + + goto st84 +tr33: +// line 62 "actions.rl" + + + if label < 0 { + panic("unexpected parser state: label start not set") + } + triple.Provenance = unEscape(data[label:p], isEscaped) + isEscaped = false + + goto st84 + st84: + if p++; p == pe { + goto _test_eof84 + } + st_case_84: +// line 592 "parse.go" + switch data[p] { + case 9: + goto st84 + case 32: + goto st84 + case 35: + goto tr114 + } + goto st0 +tr114: +// line 74 "actions.rl" + + + + goto st85 + st85: + if p++; p == pe { + goto _test_eof85 + } + st_case_85: +// line 613 "parse.go" + goto st85 +tr27: +// line 34 "actions.rl" + + + label = p + + goto st11 +tr44: +// line 18 "actions.rl" + + + isEscaped = true + + goto st11 + st11: + if p++; p == pe { + goto _test_eof11 + } + st_case_11: +// line 634 "parse.go" + switch data[p] { + case 62: + goto st12 + case 92: + goto st14 + case 95: + goto st11 + case 126: + goto st11 + } + switch { + case data[p] < 61: + if 33 <= data[p] && data[p] <= 59 { + goto st11 + } + case data[p] > 93: + if 97 <= data[p] && data[p] <= 122 { + goto st11 + } + default: + goto st11 + } + goto tr0 +tr45: +// line 18 "actions.rl" + + + isEscaped = true + + goto st12 + st12: + if p++; p == pe { + goto _test_eof12 + } + st_case_12: +// line 670 "parse.go" + switch data[p] { + case 9: + goto tr32 + case 32: + goto tr32 + case 46: + goto tr33 + } + goto tr0 +tr32: +// line 62 "actions.rl" + + + if label < 0 { + panic("unexpected parser state: label start not set") + } + triple.Provenance = unEscape(data[label:p], isEscaped) + isEscaped = false + + goto st13 + st13: + if p++; p == pe { + goto _test_eof13 + } + st_case_13: +// line 696 "parse.go" + switch data[p] { + case 9: + goto st13 + case 32: + goto st13 + case 46: + goto st84 + } + goto tr0 +tr46: +// line 18 "actions.rl" + + + isEscaped = true + + goto st14 + st14: + if p++; p == pe { + goto _test_eof14 + } + st_case_14: +// line 718 "parse.go" + switch data[p] { + case 85: + goto st15 + case 117: + goto st19 + } + goto tr0 + st15: + if p++; p == pe { + goto _test_eof15 + } + st_case_15: + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st16 + } + case data[p] > 70: + if 97 <= data[p] && data[p] <= 102 { + goto st16 + } + default: + goto st16 + } + goto tr0 + st16: + if p++; p == pe { + goto _test_eof16 + } + st_case_16: + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st17 + } + case data[p] > 70: + if 97 <= data[p] && data[p] <= 102 { + goto st17 + } + default: + goto st17 + } + goto tr0 + st17: + if p++; p == pe { + goto _test_eof17 + } + st_case_17: + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st18 + } + case data[p] > 70: + if 97 <= data[p] && data[p] <= 102 { + goto st18 + } + default: + goto st18 + } + goto tr0 + st18: + if p++; p == pe { + goto _test_eof18 + } + st_case_18: + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st19 + } + case data[p] > 70: + if 97 <= data[p] && data[p] <= 102 { + goto st19 + } + default: + goto st19 + } + goto tr0 + st19: + if p++; p == pe { + goto _test_eof19 + } + st_case_19: + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st20 + } + case data[p] > 70: + if 97 <= data[p] && data[p] <= 102 { + goto st20 + } + default: + goto st20 + } + goto tr0 + st20: + if p++; p == pe { + goto _test_eof20 + } + st_case_20: + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st21 + } + case data[p] > 70: + if 97 <= data[p] && data[p] <= 102 { + goto st21 + } + default: + goto st21 + } + goto tr0 + st21: + if p++; p == pe { + goto _test_eof21 + } + st_case_21: + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st22 + } + case data[p] > 70: + if 97 <= data[p] && data[p] <= 102 { + goto st22 + } + default: + goto st22 + } + goto tr0 + st22: + if p++; p == pe { + goto _test_eof22 + } + st_case_22: + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st23 + } + case data[p] > 70: + if 97 <= data[p] && data[p] <= 102 { + goto st23 + } + default: + goto st23 + } + goto tr0 + st23: + if p++; p == pe { + goto _test_eof23 + } + st_case_23: + switch data[p] { + case 62: + goto tr45 + case 92: + goto tr46 + case 95: + goto tr44 + case 126: + goto tr44 + } + switch { + case data[p] < 61: + if 33 <= data[p] && data[p] <= 59 { + goto tr44 + } + case data[p] > 93: + if 97 <= data[p] && data[p] <= 122 { + goto tr44 + } + default: + goto tr44 + } + goto tr0 +tr28: +// line 34 "actions.rl" + + + label = p + + goto st24 + st24: + if p++; p == pe { + goto _test_eof24 + } + st_case_24: +// line 910 "parse.go" + if data[p] == 58 { + goto st25 + } + goto tr0 + st25: + if p++; p == pe { + goto _test_eof25 + } + st_case_25: + if data[p] == 95 { + goto st26 + } + switch { + case data[p] < 895: + switch { + case data[p] < 192: + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 58 { + goto st26 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st26 + } + default: + goto st26 + } + case data[p] > 214: + switch { + case data[p] < 248: + if 216 <= data[p] && data[p] <= 246 { + goto st26 + } + case data[p] > 767: + if 880 <= data[p] && data[p] <= 893 { + goto st26 + } + default: + goto st26 + } + default: + goto st26 + } + case data[p] > 8191: + switch { + case data[p] < 12289: + switch { + case data[p] < 8304: + if 8204 <= data[p] && data[p] <= 8205 { + goto st26 + } + case data[p] > 8591: + if 11264 <= data[p] && data[p] <= 12271 { + goto st26 + } + default: + goto st26 + } + case data[p] > 55295: + switch { + case data[p] < 65008: + if 63744 <= data[p] && data[p] <= 64975 { + goto st26 + } + case data[p] > 65533: + if 65536 <= data[p] && data[p] <= 126975 { + goto st26 + } + default: + goto st26 + } + default: + goto st26 + } + default: + goto st26 + } + goto tr0 + st26: + if p++; p == pe { + goto _test_eof26 + } + st_case_26: + switch data[p] { + case 9: + goto tr32 + case 32: + goto tr32 + case 45: + goto st26 + case 46: + goto tr49 + case 95: + goto st26 + case 183: + goto st26 + } + switch { + case data[p] < 8204: + switch { + case data[p] < 192: + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 58 { + goto st26 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st26 + } + default: + goto st26 + } + case data[p] > 214: + switch { + case data[p] < 248: + if 216 <= data[p] && data[p] <= 246 { + goto st26 + } + case data[p] > 893: + if 895 <= data[p] && data[p] <= 8191 { + goto st26 + } + default: + goto st26 + } + default: + goto st26 + } + case data[p] > 8205: + switch { + case data[p] < 12289: + switch { + case data[p] < 8304: + if 8255 <= data[p] && data[p] <= 8256 { + goto st26 + } + case data[p] > 8591: + if 11264 <= data[p] && data[p] <= 12271 { + goto st26 + } + default: + goto st26 + } + case data[p] > 55295: + switch { + case data[p] < 65008: + if 63744 <= data[p] && data[p] <= 64975 { + goto st26 + } + case data[p] > 65533: + if 65536 <= data[p] && data[p] <= 126975 { + goto st26 + } + default: + goto st26 + } + default: + goto st26 + } + default: + goto st26 + } + goto tr0 +tr49: +// line 62 "actions.rl" + + + if label < 0 { + panic("unexpected parser state: label start not set") + } + triple.Provenance = unEscape(data[label:p], isEscaped) + isEscaped = false + + goto st86 + st86: + if p++; p == pe { + goto _test_eof86 + } + st_case_86: +// line 1092 "parse.go" + switch data[p] { + case 9: + goto st84 + case 32: + goto st84 + case 35: + goto tr114 + case 45: + goto st26 + case 46: + goto st27 + case 95: + goto st26 + case 183: + goto st26 + } + switch { + case data[p] < 8204: + switch { + case data[p] < 192: + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 58 { + goto st26 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st26 + } + default: + goto st26 + } + case data[p] > 214: + switch { + case data[p] < 248: + if 216 <= data[p] && data[p] <= 246 { + goto st26 + } + case data[p] > 893: + if 895 <= data[p] && data[p] <= 8191 { + goto st26 + } + default: + goto st26 + } + default: + goto st26 + } + case data[p] > 8205: + switch { + case data[p] < 12289: + switch { + case data[p] < 8304: + if 8255 <= data[p] && data[p] <= 8256 { + goto st26 + } + case data[p] > 8591: + if 11264 <= data[p] && data[p] <= 12271 { + goto st26 + } + default: + goto st26 + } + case data[p] > 55295: + switch { + case data[p] < 65008: + if 63744 <= data[p] && data[p] <= 64975 { + goto st26 + } + case data[p] > 65533: + if 65536 <= data[p] && data[p] <= 126975 { + goto st26 + } + default: + goto st26 + } + default: + goto st26 + } + default: + goto st26 + } + goto st0 + st27: + if p++; p == pe { + goto _test_eof27 + } + st_case_27: + switch data[p] { + case 45: + goto st26 + case 46: + goto st27 + case 95: + goto st26 + case 183: + goto st26 + } + switch { + case data[p] < 8204: + switch { + case data[p] < 192: + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 58 { + goto st26 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st26 + } + default: + goto st26 + } + case data[p] > 214: + switch { + case data[p] < 248: + if 216 <= data[p] && data[p] <= 246 { + goto st26 + } + case data[p] > 893: + if 895 <= data[p] && data[p] <= 8191 { + goto st26 + } + default: + goto st26 + } + default: + goto st26 + } + case data[p] > 8205: + switch { + case data[p] < 12289: + switch { + case data[p] < 8304: + if 8255 <= data[p] && data[p] <= 8256 { + goto st26 + } + case data[p] > 8591: + if 11264 <= data[p] && data[p] <= 12271 { + goto st26 + } + default: + goto st26 + } + case data[p] > 55295: + switch { + case data[p] < 65008: + if 63744 <= data[p] && data[p] <= 64975 { + goto st26 + } + case data[p] > 65533: + if 65536 <= data[p] && data[p] <= 126975 { + goto st26 + } + default: + goto st26 + } + default: + goto st26 + } + default: + goto st26 + } + goto tr0 + st28: + if p++; p == pe { + goto _test_eof28 + } + st_case_28: + switch { + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st29 + } + case data[p] >= 65: + goto st29 + } + goto tr0 + st29: + if p++; p == pe { + goto _test_eof29 + } + st_case_29: + switch data[p] { + case 9: + goto tr21 + case 32: + goto tr21 + case 45: + goto st30 + case 46: + goto tr22 + } + switch { + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st29 + } + case data[p] >= 65: + goto st29 + } + goto tr0 + st30: + if p++; p == pe { + goto _test_eof30 + } + st_case_30: + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st31 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st31 + } + default: + goto st31 + } + goto tr0 + st31: + if p++; p == pe { + goto _test_eof31 + } + st_case_31: + switch data[p] { + case 9: + goto tr21 + case 32: + goto tr21 + case 45: + goto st30 + case 46: + goto tr22 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st31 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st31 + } + default: + goto st31 + } + goto tr0 + st32: + if p++; p == pe { + goto _test_eof32 + } + st_case_32: + if data[p] == 94 { + goto st33 + } + goto tr0 + st33: + if p++; p == pe { + goto _test_eof33 + } + st_case_33: + if data[p] == 60 { + goto st34 + } + goto tr0 +tr16: +// line 30 "actions.rl" + + + object = p + + goto st34 +tr67: +// line 18 "actions.rl" + + + isEscaped = true + + goto st34 + st34: + if p++; p == pe { + goto _test_eof34 + } + st_case_34: +// line 1379 "parse.go" + switch data[p] { + case 62: + goto st35 + case 92: + goto st36 + case 95: + goto st34 + case 126: + goto st34 + } + switch { + case data[p] < 61: + if 33 <= data[p] && data[p] <= 59 { + goto st34 + } + case data[p] > 93: + if 97 <= data[p] && data[p] <= 122 { + goto st34 + } + default: + goto st34 + } + goto tr0 +tr68: +// line 18 "actions.rl" + + + isEscaped = true + + goto st35 + st35: + if p++; p == pe { + goto _test_eof35 + } + st_case_35: +// line 1415 "parse.go" + switch data[p] { + case 9: + goto tr21 + case 32: + goto tr21 + case 46: + goto tr22 + } + goto tr0 +tr69: +// line 18 "actions.rl" + + + isEscaped = true + + goto st36 + st36: + if p++; p == pe { + goto _test_eof36 + } + st_case_36: +// line 1437 "parse.go" + switch data[p] { + case 85: + goto st37 + case 117: + goto st41 + } + goto tr0 + st37: + if p++; p == pe { + goto _test_eof37 + } + st_case_37: + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st38 + } + case data[p] > 70: + if 97 <= data[p] && data[p] <= 102 { + goto st38 + } + default: + goto st38 + } + goto tr0 + st38: + if p++; p == pe { + goto _test_eof38 + } + st_case_38: + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st39 + } + case data[p] > 70: + if 97 <= data[p] && data[p] <= 102 { + goto st39 + } + default: + goto st39 + } + goto tr0 + st39: + if p++; p == pe { + goto _test_eof39 + } + st_case_39: + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st40 + } + case data[p] > 70: + if 97 <= data[p] && data[p] <= 102 { + goto st40 + } + default: + goto st40 + } + goto tr0 + st40: + if p++; p == pe { + goto _test_eof40 + } + st_case_40: + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st41 + } + case data[p] > 70: + if 97 <= data[p] && data[p] <= 102 { + goto st41 + } + default: + goto st41 + } + goto tr0 + st41: + if p++; p == pe { + goto _test_eof41 + } + st_case_41: + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st42 + } + case data[p] > 70: + if 97 <= data[p] && data[p] <= 102 { + goto st42 + } + default: + goto st42 + } + goto tr0 + st42: + if p++; p == pe { + goto _test_eof42 + } + st_case_42: + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st43 + } + case data[p] > 70: + if 97 <= data[p] && data[p] <= 102 { + goto st43 + } + default: + goto st43 + } + goto tr0 + st43: + if p++; p == pe { + goto _test_eof43 + } + st_case_43: + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st44 + } + case data[p] > 70: + if 97 <= data[p] && data[p] <= 102 { + goto st44 + } + default: + goto st44 + } + goto tr0 + st44: + if p++; p == pe { + goto _test_eof44 + } + st_case_44: + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st45 + } + case data[p] > 70: + if 97 <= data[p] && data[p] <= 102 { + goto st45 + } + default: + goto st45 + } + goto tr0 + st45: + if p++; p == pe { + goto _test_eof45 + } + st_case_45: + switch data[p] { + case 62: + goto tr68 + case 92: + goto tr69 + case 95: + goto tr67 + case 126: + goto tr67 + } + switch { + case data[p] < 61: + if 33 <= data[p] && data[p] <= 59 { + goto tr67 + } + case data[p] > 93: + if 97 <= data[p] && data[p] <= 122 { + goto tr67 + } + default: + goto tr67 + } + goto tr0 +tr75: +// line 18 "actions.rl" + + + isEscaped = true + + goto st46 + st46: + if p++; p == pe { + goto _test_eof46 + } + st_case_46: +// line 1629 "parse.go" + switch data[p] { + case 34: + goto st47 + case 39: + goto st47 + case 85: + goto st48 + case 92: + goto st47 + case 98: + goto st47 + case 102: + goto st47 + case 110: + goto st47 + case 114: + goto st47 + case 116: + goto st47 + case 117: + goto st52 + } + goto tr0 + st47: + if p++; p == pe { + goto _test_eof47 + } + st_case_47: + switch data[p] { + case 34: + goto tr74 + case 92: + goto tr75 + } + switch { + case data[p] < 11: + if 0 <= data[p] && data[p] <= 9 { + goto tr73 + } + case data[p] > 12: + if 14 <= data[p] && data[p] <= 126 { + goto tr73 + } + default: + goto tr73 + } + goto tr0 + st48: + if p++; p == pe { + goto _test_eof48 + } + st_case_48: + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st49 + } + case data[p] > 70: + if 97 <= data[p] && data[p] <= 102 { + goto st49 + } + default: + goto st49 + } + goto tr0 + st49: + if p++; p == pe { + goto _test_eof49 + } + st_case_49: + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st50 + } + case data[p] > 70: + if 97 <= data[p] && data[p] <= 102 { + goto st50 + } + default: + goto st50 + } + goto tr0 + st50: + if p++; p == pe { + goto _test_eof50 + } + st_case_50: + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st51 + } + case data[p] > 70: + if 97 <= data[p] && data[p] <= 102 { + goto st51 + } + default: + goto st51 + } + goto tr0 + st51: + if p++; p == pe { + goto _test_eof51 + } + st_case_51: + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st52 + } + case data[p] > 70: + if 97 <= data[p] && data[p] <= 102 { + goto st52 + } + default: + goto st52 + } + goto tr0 + st52: + if p++; p == pe { + goto _test_eof52 + } + st_case_52: + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st53 + } + case data[p] > 70: + if 97 <= data[p] && data[p] <= 102 { + goto st53 + } + default: + goto st53 + } + goto tr0 + st53: + if p++; p == pe { + goto _test_eof53 + } + st_case_53: + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st54 + } + case data[p] > 70: + if 97 <= data[p] && data[p] <= 102 { + goto st54 + } + default: + goto st54 + } + goto tr0 + st54: + if p++; p == pe { + goto _test_eof54 + } + st_case_54: + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st55 + } + case data[p] > 70: + if 97 <= data[p] && data[p] <= 102 { + goto st55 + } + default: + goto st55 + } + goto tr0 + st55: + if p++; p == pe { + goto _test_eof55 + } + st_case_55: + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st47 + } + case data[p] > 70: + if 97 <= data[p] && data[p] <= 102 { + goto st47 + } + default: + goto st47 + } + goto tr0 +tr17: +// line 30 "actions.rl" + + + object = p + + goto st56 + st56: + if p++; p == pe { + goto _test_eof56 + } + st_case_56: +// line 1833 "parse.go" + if data[p] == 58 { + goto st57 + } + goto tr0 + st57: + if p++; p == pe { + goto _test_eof57 + } + st_case_57: + if data[p] == 95 { + goto st58 + } + switch { + case data[p] < 895: + switch { + case data[p] < 192: + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 58 { + goto st58 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st58 + } + default: + goto st58 + } + case data[p] > 214: + switch { + case data[p] < 248: + if 216 <= data[p] && data[p] <= 246 { + goto st58 + } + case data[p] > 767: + if 880 <= data[p] && data[p] <= 893 { + goto st58 + } + default: + goto st58 + } + default: + goto st58 + } + case data[p] > 8191: + switch { + case data[p] < 12289: + switch { + case data[p] < 8304: + if 8204 <= data[p] && data[p] <= 8205 { + goto st58 + } + case data[p] > 8591: + if 11264 <= data[p] && data[p] <= 12271 { + goto st58 + } + default: + goto st58 + } + case data[p] > 55295: + switch { + case data[p] < 65008: + if 63744 <= data[p] && data[p] <= 64975 { + goto st58 + } + case data[p] > 65533: + if 65536 <= data[p] && data[p] <= 126975 { + goto st58 + } + default: + goto st58 + } + default: + goto st58 + } + default: + goto st58 + } + goto tr0 + st58: + if p++; p == pe { + goto _test_eof58 + } + st_case_58: + switch data[p] { + case 9: + goto tr21 + case 32: + goto tr21 + case 45: + goto st58 + case 46: + goto tr84 + case 95: + goto st58 + case 183: + goto st58 + } + switch { + case data[p] < 8204: + switch { + case data[p] < 192: + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 58 { + goto st58 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st58 + } + default: + goto st58 + } + case data[p] > 214: + switch { + case data[p] < 248: + if 216 <= data[p] && data[p] <= 246 { + goto st58 + } + case data[p] > 893: + if 895 <= data[p] && data[p] <= 8191 { + goto st58 + } + default: + goto st58 + } + default: + goto st58 + } + case data[p] > 8205: + switch { + case data[p] < 12289: + switch { + case data[p] < 8304: + if 8255 <= data[p] && data[p] <= 8256 { + goto st58 + } + case data[p] > 8591: + if 11264 <= data[p] && data[p] <= 12271 { + goto st58 + } + default: + goto st58 + } + case data[p] > 55295: + switch { + case data[p] < 65008: + if 63744 <= data[p] && data[p] <= 64975 { + goto st58 + } + case data[p] > 65533: + if 65536 <= data[p] && data[p] <= 126975 { + goto st58 + } + default: + goto st58 + } + default: + goto st58 + } + default: + goto st58 + } + goto tr0 +tr84: +// line 54 "actions.rl" + + + if object < 0 { + panic("unexpected parser state: object start not set") + } + triple.Object = unEscape(data[object:p], isEscaped) + isEscaped = false + + goto st87 + st87: + if p++; p == pe { + goto _test_eof87 + } + st_case_87: +// line 2015 "parse.go" + switch data[p] { + case 9: + goto st84 + case 32: + goto st84 + case 35: + goto tr114 + case 45: + goto st58 + case 46: + goto st59 + case 95: + goto st58 + case 183: + goto st58 + } + switch { + case data[p] < 8204: + switch { + case data[p] < 192: + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 58 { + goto st58 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st58 + } + default: + goto st58 + } + case data[p] > 214: + switch { + case data[p] < 248: + if 216 <= data[p] && data[p] <= 246 { + goto st58 + } + case data[p] > 893: + if 895 <= data[p] && data[p] <= 8191 { + goto st58 + } + default: + goto st58 + } + default: + goto st58 + } + case data[p] > 8205: + switch { + case data[p] < 12289: + switch { + case data[p] < 8304: + if 8255 <= data[p] && data[p] <= 8256 { + goto st58 + } + case data[p] > 8591: + if 11264 <= data[p] && data[p] <= 12271 { + goto st58 + } + default: + goto st58 + } + case data[p] > 55295: + switch { + case data[p] < 65008: + if 63744 <= data[p] && data[p] <= 64975 { + goto st58 + } + case data[p] > 65533: + if 65536 <= data[p] && data[p] <= 126975 { + goto st58 + } + default: + goto st58 + } + default: + goto st58 + } + default: + goto st58 + } + goto st0 + st59: + if p++; p == pe { + goto _test_eof59 + } + st_case_59: + switch data[p] { + case 45: + goto st58 + case 46: + goto st59 + case 95: + goto st58 + case 183: + goto st58 + } + switch { + case data[p] < 8204: + switch { + case data[p] < 192: + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 58 { + goto st58 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st58 + } + default: + goto st58 + } + case data[p] > 214: + switch { + case data[p] < 248: + if 216 <= data[p] && data[p] <= 246 { + goto st58 + } + case data[p] > 893: + if 895 <= data[p] && data[p] <= 8191 { + goto st58 + } + default: + goto st58 + } + default: + goto st58 + } + case data[p] > 8205: + switch { + case data[p] < 12289: + switch { + case data[p] < 8304: + if 8255 <= data[p] && data[p] <= 8256 { + goto st58 + } + case data[p] > 8591: + if 11264 <= data[p] && data[p] <= 12271 { + goto st58 + } + default: + goto st58 + } + case data[p] > 55295: + switch { + case data[p] < 65008: + if 63744 <= data[p] && data[p] <= 64975 { + goto st58 + } + case data[p] > 65533: + if 65536 <= data[p] && data[p] <= 126975 { + goto st58 + } + default: + goto st58 + } + default: + goto st58 + } + default: + goto st58 + } + goto tr0 +tr97: +// line 18 "actions.rl" + + + isEscaped = true + + goto st60 + st60: + if p++; p == pe { + goto _test_eof60 + } + st_case_60: +// line 2193 "parse.go" + switch data[p] { + case 85: + goto st61 + case 117: + goto st65 + } + goto tr0 + st61: + if p++; p == pe { + goto _test_eof61 + } + st_case_61: + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st62 + } + case data[p] > 70: + if 97 <= data[p] && data[p] <= 102 { + goto st62 + } + default: + goto st62 + } + goto tr0 + st62: + if p++; p == pe { + goto _test_eof62 + } + st_case_62: + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st63 + } + case data[p] > 70: + if 97 <= data[p] && data[p] <= 102 { + goto st63 + } + default: + goto st63 + } + goto tr0 + st63: + if p++; p == pe { + goto _test_eof63 + } + st_case_63: + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st64 + } + case data[p] > 70: + if 97 <= data[p] && data[p] <= 102 { + goto st64 + } + default: + goto st64 + } + goto tr0 + st64: + if p++; p == pe { + goto _test_eof64 + } + st_case_64: + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 70: + if 97 <= data[p] && data[p] <= 102 { + goto st65 + } + default: + goto st65 + } + goto tr0 + st65: + if p++; p == pe { + goto _test_eof65 + } + st_case_65: + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st66 + } + case data[p] > 70: + if 97 <= data[p] && data[p] <= 102 { + goto st66 + } + default: + goto st66 + } + goto tr0 + st66: + if p++; p == pe { + goto _test_eof66 + } + st_case_66: + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st67 + } + case data[p] > 70: + if 97 <= data[p] && data[p] <= 102 { + goto st67 + } + default: + goto st67 + } + goto tr0 + st67: + if p++; p == pe { + goto _test_eof67 + } + st_case_67: + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st68 + } + case data[p] > 70: + if 97 <= data[p] && data[p] <= 102 { + goto st68 + } + default: + goto st68 + } + goto tr0 + st68: + if p++; p == pe { + goto _test_eof68 + } + st_case_68: + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st69 + } + case data[p] > 70: + if 97 <= data[p] && data[p] <= 102 { + goto st69 + } + default: + goto st69 + } + goto tr0 + st69: + if p++; p == pe { + goto _test_eof69 + } + st_case_69: + switch data[p] { + case 62: + goto tr96 + case 92: + goto tr97 + case 95: + goto tr95 + case 126: + goto tr95 + } + switch { + case data[p] < 61: + if 33 <= data[p] && data[p] <= 59 { + goto tr95 + } + case data[p] > 93: + if 97 <= data[p] && data[p] <= 122 { + goto tr95 + } + default: + goto tr95 + } + goto tr0 +tr109: +// line 18 "actions.rl" + + + isEscaped = true + + goto st70 + st70: + if p++; p == pe { + goto _test_eof70 + } + st_case_70: +// line 2385 "parse.go" + switch data[p] { + case 85: + goto st71 + case 117: + goto st75 + } + goto tr0 + st71: + if p++; p == pe { + goto _test_eof71 + } + st_case_71: + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st72 + } + case data[p] > 70: + if 97 <= data[p] && data[p] <= 102 { + goto st72 + } + default: + goto st72 + } + goto tr0 + st72: + if p++; p == pe { + goto _test_eof72 + } + st_case_72: + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st73 + } + case data[p] > 70: + if 97 <= data[p] && data[p] <= 102 { + goto st73 + } + default: + goto st73 + } + goto tr0 + st73: + if p++; p == pe { + goto _test_eof73 + } + st_case_73: + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st74 + } + case data[p] > 70: + if 97 <= data[p] && data[p] <= 102 { + goto st74 + } + default: + goto st74 + } + goto tr0 + st74: + if p++; p == pe { + goto _test_eof74 + } + st_case_74: + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st75 + } + case data[p] > 70: + if 97 <= data[p] && data[p] <= 102 { + goto st75 + } + default: + goto st75 + } + goto tr0 + st75: + if p++; p == pe { + goto _test_eof75 + } + st_case_75: + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st76 + } + case data[p] > 70: + if 97 <= data[p] && data[p] <= 102 { + goto st76 + } + default: + goto st76 + } + goto tr0 + st76: + if p++; p == pe { + goto _test_eof76 + } + st_case_76: + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st77 + } + case data[p] > 70: + if 97 <= data[p] && data[p] <= 102 { + goto st77 + } + default: + goto st77 + } + goto tr0 + st77: + if p++; p == pe { + goto _test_eof77 + } + st_case_77: + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st78 + } + case data[p] > 70: + if 97 <= data[p] && data[p] <= 102 { + goto st78 + } + default: + goto st78 + } + goto tr0 + st78: + if p++; p == pe { + goto _test_eof78 + } + st_case_78: + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st79 + } + case data[p] > 70: + if 97 <= data[p] && data[p] <= 102 { + goto st79 + } + default: + goto st79 + } + goto tr0 + st79: + if p++; p == pe { + goto _test_eof79 + } + st_case_79: + switch data[p] { + case 62: + goto tr108 + case 92: + goto tr109 + case 95: + goto tr107 + case 126: + goto tr107 + } + switch { + case data[p] < 61: + if 33 <= data[p] && data[p] <= 59 { + goto tr107 + } + case data[p] > 93: + if 97 <= data[p] && data[p] <= 122 { + goto tr107 + } + default: + goto tr107 + } + goto tr0 +tr3: +// line 22 "actions.rl" + + + subject = p + + goto st80 + st80: + if p++; p == pe { + goto _test_eof80 + } + st_case_80: +// line 2577 "parse.go" + if data[p] == 58 { + goto st81 + } + goto tr0 + st81: + if p++; p == pe { + goto _test_eof81 + } + st_case_81: + if data[p] == 95 { + goto st82 + } + switch { + case data[p] < 895: + switch { + case data[p] < 192: + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 58 { + goto st82 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st82 + } + default: + goto st82 + } + case data[p] > 214: + switch { + case data[p] < 248: + if 216 <= data[p] && data[p] <= 246 { + goto st82 + } + case data[p] > 767: + if 880 <= data[p] && data[p] <= 893 { + goto st82 + } + default: + goto st82 + } + default: + goto st82 + } + case data[p] > 8191: + switch { + case data[p] < 12289: + switch { + case data[p] < 8304: + if 8204 <= data[p] && data[p] <= 8205 { + goto st82 + } + case data[p] > 8591: + if 11264 <= data[p] && data[p] <= 12271 { + goto st82 + } + default: + goto st82 + } + case data[p] > 55295: + switch { + case data[p] < 65008: + if 63744 <= data[p] && data[p] <= 64975 { + goto st82 + } + case data[p] > 65533: + if 65536 <= data[p] && data[p] <= 126975 { + goto st82 + } + default: + goto st82 + } + default: + goto st82 + } + default: + goto st82 + } + goto tr0 + st82: + if p++; p == pe { + goto _test_eof82 + } + st_case_82: + switch data[p] { + case 9: + goto tr7 + case 32: + goto tr7 + case 45: + goto st82 + case 46: + goto st83 + case 95: + goto st82 + case 183: + goto st82 + } + switch { + case data[p] < 8204: + switch { + case data[p] < 192: + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 58 { + goto st82 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st82 + } + default: + goto st82 + } + case data[p] > 214: + switch { + case data[p] < 248: + if 216 <= data[p] && data[p] <= 246 { + goto st82 + } + case data[p] > 893: + if 895 <= data[p] && data[p] <= 8191 { + goto st82 + } + default: + goto st82 + } + default: + goto st82 + } + case data[p] > 8205: + switch { + case data[p] < 12289: + switch { + case data[p] < 8304: + if 8255 <= data[p] && data[p] <= 8256 { + goto st82 + } + case data[p] > 8591: + if 11264 <= data[p] && data[p] <= 12271 { + goto st82 + } + default: + goto st82 + } + case data[p] > 55295: + switch { + case data[p] < 65008: + if 63744 <= data[p] && data[p] <= 64975 { + goto st82 + } + case data[p] > 65533: + if 65536 <= data[p] && data[p] <= 126975 { + goto st82 + } + default: + goto st82 + } + default: + goto st82 + } + default: + goto st82 + } + goto tr0 + st83: + if p++; p == pe { + goto _test_eof83 + } + st_case_83: + switch data[p] { + case 45: + goto st82 + case 46: + goto st83 + case 95: + goto st82 + case 183: + goto st82 + } + switch { + case data[p] < 8204: + switch { + case data[p] < 192: + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 58 { + goto st82 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st82 + } + default: + goto st82 + } + case data[p] > 214: + switch { + case data[p] < 248: + if 216 <= data[p] && data[p] <= 246 { + goto st82 + } + case data[p] > 893: + if 895 <= data[p] && data[p] <= 8191 { + goto st82 + } + default: + goto st82 + } + default: + goto st82 + } + case data[p] > 8205: + switch { + case data[p] < 12289: + switch { + case data[p] < 8304: + if 8255 <= data[p] && data[p] <= 8256 { + goto st82 + } + case data[p] > 8591: + if 11264 <= data[p] && data[p] <= 12271 { + goto st82 + } + default: + goto st82 + } + case data[p] > 55295: + switch { + case data[p] < 65008: + if 63744 <= data[p] && data[p] <= 64975 { + goto st82 + } + case data[p] > 65533: + if 65536 <= data[p] && data[p] <= 126975 { + goto st82 + } + default: + goto st82 + } + default: + goto st82 + } + default: + goto st82 + } + goto tr0 + st_out: + _test_eof1: cs = 1; goto _test_eof + _test_eof2: cs = 2; goto _test_eof + _test_eof3: cs = 3; goto _test_eof + _test_eof4: cs = 4; goto _test_eof + _test_eof5: cs = 5; goto _test_eof + _test_eof6: cs = 6; goto _test_eof + _test_eof7: cs = 7; goto _test_eof + _test_eof8: cs = 8; goto _test_eof + _test_eof9: cs = 9; goto _test_eof + _test_eof10: cs = 10; goto _test_eof + _test_eof84: cs = 84; goto _test_eof + _test_eof85: cs = 85; goto _test_eof + _test_eof11: cs = 11; goto _test_eof + _test_eof12: cs = 12; goto _test_eof + _test_eof13: cs = 13; goto _test_eof + _test_eof14: cs = 14; goto _test_eof + _test_eof15: cs = 15; goto _test_eof + _test_eof16: cs = 16; goto _test_eof + _test_eof17: cs = 17; goto _test_eof + _test_eof18: cs = 18; goto _test_eof + _test_eof19: cs = 19; goto _test_eof + _test_eof20: cs = 20; goto _test_eof + _test_eof21: cs = 21; goto _test_eof + _test_eof22: cs = 22; goto _test_eof + _test_eof23: cs = 23; goto _test_eof + _test_eof24: cs = 24; goto _test_eof + _test_eof25: cs = 25; goto _test_eof + _test_eof26: cs = 26; goto _test_eof + _test_eof86: cs = 86; goto _test_eof + _test_eof27: cs = 27; goto _test_eof + _test_eof28: cs = 28; goto _test_eof + _test_eof29: cs = 29; goto _test_eof + _test_eof30: cs = 30; goto _test_eof + _test_eof31: cs = 31; goto _test_eof + _test_eof32: cs = 32; goto _test_eof + _test_eof33: cs = 33; goto _test_eof + _test_eof34: cs = 34; goto _test_eof + _test_eof35: cs = 35; goto _test_eof + _test_eof36: cs = 36; goto _test_eof + _test_eof37: cs = 37; goto _test_eof + _test_eof38: cs = 38; goto _test_eof + _test_eof39: cs = 39; goto _test_eof + _test_eof40: cs = 40; goto _test_eof + _test_eof41: cs = 41; goto _test_eof + _test_eof42: cs = 42; goto _test_eof + _test_eof43: cs = 43; goto _test_eof + _test_eof44: cs = 44; goto _test_eof + _test_eof45: cs = 45; goto _test_eof + _test_eof46: cs = 46; goto _test_eof + _test_eof47: cs = 47; goto _test_eof + _test_eof48: cs = 48; goto _test_eof + _test_eof49: cs = 49; goto _test_eof + _test_eof50: cs = 50; goto _test_eof + _test_eof51: cs = 51; goto _test_eof + _test_eof52: cs = 52; goto _test_eof + _test_eof53: cs = 53; goto _test_eof + _test_eof54: cs = 54; goto _test_eof + _test_eof55: cs = 55; goto _test_eof + _test_eof56: cs = 56; goto _test_eof + _test_eof57: cs = 57; goto _test_eof + _test_eof58: cs = 58; goto _test_eof + _test_eof87: cs = 87; goto _test_eof + _test_eof59: cs = 59; goto _test_eof + _test_eof60: cs = 60; goto _test_eof + _test_eof61: cs = 61; goto _test_eof + _test_eof62: cs = 62; goto _test_eof + _test_eof63: cs = 63; goto _test_eof + _test_eof64: cs = 64; goto _test_eof + _test_eof65: cs = 65; goto _test_eof + _test_eof66: cs = 66; goto _test_eof + _test_eof67: cs = 67; goto _test_eof + _test_eof68: cs = 68; goto _test_eof + _test_eof69: cs = 69; goto _test_eof + _test_eof70: cs = 70; goto _test_eof + _test_eof71: cs = 71; goto _test_eof + _test_eof72: cs = 72; goto _test_eof + _test_eof73: cs = 73; goto _test_eof + _test_eof74: cs = 74; goto _test_eof + _test_eof75: cs = 75; goto _test_eof + _test_eof76: cs = 76; goto _test_eof + _test_eof77: cs = 77; goto _test_eof + _test_eof78: cs = 78; goto _test_eof + _test_eof79: cs = 79; goto _test_eof + _test_eof80: cs = 80; goto _test_eof + _test_eof81: cs = 81; goto _test_eof + _test_eof82: cs = 82; goto _test_eof + _test_eof83: cs = 83; goto _test_eof + + _test_eof: {} + if p == eof { + switch cs { + case 85: +// line 70 "actions.rl" + + + return triple, nil + + case 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83: +// line 77 "actions.rl" + + + if p < len(data) { + return graph.Triple{}, fmt.Errorf("%v: unexpected rune %q at %d", ErrInvalid, data[p], p) + } + return graph.Triple{}, ErrIncomplete + + case 84, 86, 87: +// line 74 "actions.rl" + + + +// line 70 "actions.rl" + + + return triple, nil + +// line 2942 "parse.go" + } + } + + _out: {} + } + +// line 62 "parse.rl" + + return graph.Triple{}, ErrInvalid +} + +func unEscape(r []rune, isEscaped bool) string { + if !isEscaped { + return string(r) + } + + buf := bytes.NewBuffer(make([]byte, 0, len(r))) + + for i := 0; i < len(r); { + switch r[i] { + case '\\': + i++ + var c byte + switch r[i] { + case 't': + c = '\t' + case 'b': + c = '\b' + case 'n': + c = '\n' + case 'r': + c = '\r' + case 'f': + c = '\f' + case '"': + c = '"' + case '\'': + c = '\'' + case '\\': + c = '\\' + case 'u': + rc, err := strconv.ParseInt(string(r[i+1:i+5]), 16, 32) + if err != nil { + panic(fmt.Errorf("internal parser error: %v", err)) + } + buf.WriteRune(rune(rc)) + i += 5 + continue + case 'U': + rc, err := strconv.ParseInt(string(r[i+1:i+9]), 16, 32) + if err != nil { + panic(fmt.Errorf("internal parser error: %v", err)) + } + buf.WriteRune(rune(rc)) + i += 9 + continue + } + buf.WriteByte(c) + default: + buf.WriteRune(r[i]) + } + i++ + } + + return buf.String() +} From 59e3d620a5f4e655f0ee4130bf172b961210cbab Mon Sep 17 00:00:00 2001 From: kortschak Date: Fri, 25 Jul 2014 09:19:26 +0930 Subject: [PATCH 04/52] Use more sane quadfix rules --- nquads/quadfix.go | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-) diff --git a/nquads/quadfix.go b/nquads/quadfix.go index c8c70c7..c7025a0 100644 --- a/nquads/quadfix.go +++ b/nquads/quadfix.go @@ -24,12 +24,19 @@ func main() { } log.Println(err) } - if t.Object[0] == ':' { - t.Object = "_" + t.Object + if t.Subject[0] == ':' && t.Subject[1] == '/' { + t.Subject = "<" + t.Subject[1:] + ">" + } else { + t.Subject = "_" + t.Subject + } + if t.Object[0] == ':' && t.Object[1] == '/' { + t.Object = "<" + t.Object[1:] + ">" + } else if t.Object[0] == '/' { + t.Object = "<" + t.Object + ">" } else { t.Object = fmt.Sprintf(`%q`, t.Object) } - fmt.Printf("_%s <%s> %s .\n", t.Subject, t.Predicate, t.Object) + fmt.Printf("%s <%s> %s .\n", t.Subject, t.Predicate, t.Object) } } From dc17ccae800cfc09037034391e5aa57a26d4d1c3 Mon Sep 17 00:00:00 2001 From: kortschak Date: Fri, 25 Jul 2014 10:46:10 +0930 Subject: [PATCH 05/52] Fix unicode handling and add tests We now also return an incomplete triple to aid in debugging - non-nil error means that this is not usable except for manual examination. --- nquads/actions.rl | 8 +++++-- nquads/nquads.go | 6 ++--- nquads/nquads.rl | 10 +++++--- nquads/nquads_test.go | 64 ++++++++++++++++++++++++++++++++++++++++++++++++++- nquads/parse.rl | 1 + 5 files changed, 79 insertions(+), 10 deletions(-) diff --git a/nquads/actions.rl b/nquads/actions.rl index a53fc93..cff580b 100644 --- a/nquads/actions.rl +++ b/nquads/actions.rl @@ -76,8 +76,12 @@ action Error { if p < len(data) { - return graph.Triple{}, fmt.Errorf("%v: unexpected rune %q at %d", ErrInvalid, data[p], p) + if r := data[p]; r < unicode.MaxASCII { + return triple, fmt.Errorf("%v: unexpected rune %q at %d", ErrInvalid, data[p], p) + } else { + return triple, fmt.Errorf("%v: unexpected rune %q (\\u%04x) at %d", ErrInvalid, data[p], data[p], p) + } } - return graph.Triple{}, ErrIncomplete + return triple, ErrIncomplete } }%% diff --git a/nquads/nquads.go b/nquads/nquads.go index b86bb4f..f24b4f2 100644 --- a/nquads/nquads.go +++ b/nquads/nquads.go @@ -30,12 +30,10 @@ var ( ErrUnterminated = errors.New("nqauds: unterminated quad") ) +// Parse returns a valid graph.Triple or a non-nil error. func Parse(str string) (*graph.Triple, error) { t, err := parse([]rune(str)) - if err != nil { - return nil, err - } - return &t, nil + return &t, err } type Decoder struct { diff --git a/nquads/nquads.rl b/nquads/nquads.rl index 1ca056c..990213a 100644 --- a/nquads/nquads.rl +++ b/nquads/nquads.rl @@ -31,7 +31,7 @@ | 0x3001 .. 0xd7ff | 0xf900 .. 0xfdcf | 0xfdf0 .. 0xfffd - | 0x10000 .. 0x1efff + | 0x10000 .. 0xeffff ; PN_CHARS_U = PN_CHARS_BASE | '_' | ':' ; @@ -58,7 +58,9 @@ | 0x0e .. '!' | '#' .. '[' | ']' .. '~' - | ECHAR | UCHAR)* + | 0x80 .. 0x10ffff + | ECHAR + | UCHAR)* '"' ; @@ -69,7 +71,9 @@ | ']' | '_' | 'a' .. 'z' - | '~' | UCHAR)* + | '~' + | 0x80 .. 0x10ffff + | UCHAR)* '>' ; diff --git a/nquads/nquads_test.go b/nquads/nquads_test.go index eb5a548..c2eb3b1 100644 --- a/nquads/nquads_test.go +++ b/nquads/nquads_test.go @@ -15,6 +15,7 @@ package nquads import ( + "fmt" "reflect" "testing" @@ -29,6 +30,31 @@ var testNTriples = []struct { }{ // Tests taken from http://www.w3.org/TR/n-quads/ and http://www.w3.org/TR/n-triples/. + // _:100000 . # example from 30movies + { + message: "parse triple with commment", + input: `_:100000 . # example from 30movies`, + expect: &graph.Triple{ + Subject: "_:100000", + Predicate: "", + Object: "", + Provenance: "", + }, + err: nil, + }, + // _:10011 "Tomás de Torquemada" . # example from 30movies with unicode + { + message: "parse triple with commment", + input: `_:10011 "Tomás de Torquemada" . # example from 30movies with unicode`, + expect: &graph.Triple{ + Subject: "_:10011", + Predicate: "", + Object: `"Tomás de Torquemada"`, + Provenance: "", + }, + err: nil, + }, + // N-Triples example 1. { message: "parse triple with commment", @@ -352,12 +378,48 @@ var testNTriples = []struct { }, err: nil, }, + + // Invalid input. + { + message: "parse empty", + input: ``, + expect: &graph.Triple{}, + err: ErrIncomplete, + }, + { + message: "parse commented", + input: `# comment`, + expect: &graph.Triple{}, + err: fmt.Errorf("%v: unexpected rune '#' at 0", ErrInvalid), + }, + { + message: "parse incomplete quad", + input: ` .`, + expect: &graph.Triple{ + Subject: "", + Predicate: "", + Object: "", + Provenance: "", + }, + err: fmt.Errorf("%v: unexpected rune '.' at 78", ErrInvalid), + }, + { + message: "parse incomplete quad", + input: ` .`, + expect: &graph.Triple{ + Subject: "", + Predicate: "", + Object: "", + Provenance: "", + }, + err: fmt.Errorf("%v: unexpected rune '.' at 78", ErrInvalid), + }, } func TestParse(t *testing.T) { for _, test := range testNTriples { got, err := Parse(test.input) - if err != test.err { + if err != test.err && (err != nil && err.Error() != test.err.Error()) { t.Errorf("Unexpected error when %s: got:%v expect:%v", test.message, err, test.err) } if !reflect.DeepEqual(got, test.expect) { diff --git a/nquads/parse.rl b/nquads/parse.rl index fb97e25..6e73684 100644 --- a/nquads/parse.rl +++ b/nquads/parse.rl @@ -21,6 +21,7 @@ import ( "errors" "fmt" "strconv" + "unicode" "github.com/google/cayley/graph" ) From d76213fb2d49e4e8b1c8ef4126308a77e3090428 Mon Sep 17 00:00:00 2001 From: kortschak Date: Fri, 25 Jul 2014 11:22:24 +0930 Subject: [PATCH 06/52] Handle comments in N-Quad documents and REPL The parser rejects an N-Quad with a comment, so we filter those out ahead of time. This simplifies the grammar and code generated by the parser. --- db/repl.go | 5 +++++ nquads/nquads.go | 20 ++++++++++++++------ nquads/nquads_test.go | 52 +++++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 71 insertions(+), 6 deletions(-) diff --git a/db/repl.go b/db/repl.go index 9b918ed..a42ff6d 100644 --- a/db/repl.go +++ b/db/repl.go @@ -99,6 +99,11 @@ func Repl(ts graph.TripleStore, queryLanguage string, cfg *config.Config) error if len(line) == 0 { continue } + line = bytes.TrimSpace(line) + if len(line) == 0 || line[0] == '#' { + line = line[:0] + continue + } if bytes.HasPrefix(line, []byte(":debug")) { ses.ToggleDebug() fmt.Println("Debug Toggled") diff --git a/nquads/nquads.go b/nquads/nquads.go index f24b4f2..d0570a6 100644 --- a/nquads/nquads.go +++ b/nquads/nquads.go @@ -16,6 +16,7 @@ package nquads import ( "bufio" + "bytes" "errors" "fmt" "io" @@ -47,17 +48,24 @@ func NewDecoder(r io.Reader) *Decoder { func (dec *Decoder) Unmarshal() (*graph.Triple, error) { dec.line = dec.line[:0] + var line []byte for { - l, pre, err := dec.r.ReadLine() - if err != nil { - return nil, err + for { + l, pre, err := dec.r.ReadLine() + if err != nil { + return nil, err + } + dec.line = append(dec.line, l...) + if !pre { + break + } } - dec.line = append(dec.line, l...) - if !pre { + if line = bytes.TrimSpace(dec.line); len(line) != 0 && line[0] != '#' { break } + dec.line = dec.line[:0] } - triple, err := Parse(string(dec.line)) + triple, err := Parse(string(line)) if err != nil { return nil, fmt.Errorf("failed to parse %q: %v", dec.line, err) } diff --git a/nquads/nquads_test.go b/nquads/nquads_test.go index c2eb3b1..328c1e8 100644 --- a/nquads/nquads_test.go +++ b/nquads/nquads_test.go @@ -16,7 +16,9 @@ package nquads import ( "fmt" + "io" "reflect" + "strings" "testing" "github.com/google/cayley/graph" @@ -428,6 +430,56 @@ func TestParse(t *testing.T) { } } +// This is a sample taken from 30kmovies.nq. +// It has intentional defects: +// The second comment is inset one psace and +// the second line after that comment is blank. +var document = `# first 10 lines of 30kmovies.nq +_:100000 . +_:100001 . +_:100002 . +_:100003 . +_:100004 . +_:100005 . +_:100006 . +_:100007 . +_:100008 . +_:100009 . + #last ten lines of 30kmovies.nq + "Bill Fishman" . + + . + "Matthew J. Evans" . + . + "Nina Bonherry" . + . + "Bill Roberts" . + . + "Christopher Ashley" . + . +` + +func TestDecoder(t *testing.T) { + dec := NewDecoder(strings.NewReader(document)) + var n int + for { + triple, err := dec.Unmarshal() + if err != nil { + if err != io.EOF { + t.Fatalf("Failed to read document:", err) + } + break + } + if triple.Subject == "" || triple.Predicate == "" || triple.Object == "" { + t.Errorf("Unexpected triple, got:%v", triple) + } + n++ + } + if n != 20 { + t.Errorf("Unexpected number of triples read, got:%d expect:20", n) + } +} + var result *graph.Triple func BenchmarkParser(b *testing.B) { From 92baa2ecee1f1e7c6090684d31993c1f6cae0804 Mon Sep 17 00:00:00 2001 From: kortschak Date: Fri, 25 Jul 2014 11:35:48 +0930 Subject: [PATCH 07/52] Cleanup unused vars, move unEscape and add tests --- nquads/nquads.go | 65 ++++++++++++++++++++++++++++++++++++++++++++------- nquads/nquads_test.go | 30 ++++++++++++++++++++++++ nquads/parse.rl | 58 --------------------------------------------- 3 files changed, 87 insertions(+), 66 deletions(-) diff --git a/nquads/nquads.go b/nquads/nquads.go index d0570a6..3096baa 100644 --- a/nquads/nquads.go +++ b/nquads/nquads.go @@ -17,20 +17,13 @@ package nquads import ( "bufio" "bytes" - "errors" "fmt" "io" + "strconv" "github.com/google/cayley/graph" ) -var ( - ErrAbsentSubject = errors.New("nqauds: absent subject") - ErrAbsentPredicate = errors.New("nqauds: absent predicate") - ErrAbsentObject = errors.New("nqauds: absent object") - ErrUnterminated = errors.New("nqauds: unterminated quad") -) - // Parse returns a valid graph.Triple or a non-nil error. func Parse(str string) (*graph.Triple, error) { t, err := parse([]rune(str)) @@ -74,3 +67,59 @@ func (dec *Decoder) Unmarshal() (*graph.Triple, error) { } return triple, nil } + +func unEscape(r []rune, isEscaped bool) string { + if !isEscaped { + return string(r) + } + + buf := bytes.NewBuffer(make([]byte, 0, len(r))) + + for i := 0; i < len(r); { + switch r[i] { + case '\\': + i++ + var c byte + switch r[i] { + case 't': + c = '\t' + case 'b': + c = '\b' + case 'n': + c = '\n' + case 'r': + c = '\r' + case 'f': + c = '\f' + case '"': + c = '"' + case '\'': + c = '\'' + case '\\': + c = '\\' + case 'u': + rc, err := strconv.ParseInt(string(r[i+1:i+5]), 16, 32) + if err != nil { + panic(fmt.Errorf("internal parser error: %v", err)) + } + buf.WriteRune(rune(rc)) + i += 5 + continue + case 'U': + rc, err := strconv.ParseInt(string(r[i+1:i+9]), 16, 32) + if err != nil { + panic(fmt.Errorf("internal parser error: %v", err)) + } + buf.WriteRune(rune(rc)) + i += 9 + continue + } + buf.WriteByte(c) + default: + buf.WriteRune(r[i]) + } + i++ + } + + return buf.String() +} diff --git a/nquads/nquads_test.go b/nquads/nquads_test.go index 328c1e8..2f2a39c 100644 --- a/nquads/nquads_test.go +++ b/nquads/nquads_test.go @@ -480,6 +480,36 @@ func TestDecoder(t *testing.T) { } } +var escapeSequenceTests = []struct { + input string + expect string +}{ + {input: `\t`, expect: "\t"}, + {input: `\b`, expect: "\b"}, + {input: `\n`, expect: "\n"}, + {input: `\r`, expect: "\r"}, + {input: `\f`, expect: "\f"}, + {input: `\\`, expect: "\\"}, + {input: `\u00b7`, expect: "·"}, + {input: `\U000000b7`, expect: "·"}, + + {input: `\t\u00b7`, expect: "\t·"}, + {input: `\b\U000000b7`, expect: "\b·"}, + {input: `\u00b7\n`, expect: "·\n"}, + {input: `\U000000b7\r`, expect: "·\r"}, + {input: `\u00b7\f\U000000b7`, expect: "·\f·"}, + {input: `\U000000b7\\\u00b7`, expect: "·\\·"}, +} + +func TestUnescape(t *testing.T) { + for _, test := range escapeSequenceTests { + got := unEscape([]rune(test.input), true) + if got != test.expect { + t.Errorf("Failed to properly unescape %q, got:%q expect:%q", test.input, got, test.expect) + } + } +} + var result *graph.Triple func BenchmarkParser(b *testing.B) { diff --git a/nquads/parse.rl b/nquads/parse.rl index 6e73684..7ace98c 100644 --- a/nquads/parse.rl +++ b/nquads/parse.rl @@ -17,10 +17,8 @@ package nquads import ( - "bytes" "errors" "fmt" - "strconv" "unicode" "github.com/google/cayley/graph" @@ -63,59 +61,3 @@ func parse(data []rune) (graph.Triple, error) { return graph.Triple{}, ErrInvalid } - -func unEscape(r []rune, isEscaped bool) string { - if !isEscaped { - return string(r) - } - - buf := bytes.NewBuffer(make([]byte, 0, len(r))) - - for i := 0; i < len(r); { - switch r[i] { - case '\\': - i++ - var c byte - switch r[i] { - case 't': - c = '\t' - case 'b': - c = '\b' - case 'n': - c = '\n' - case 'r': - c = '\r' - case 'f': - c = '\f' - case '"': - c = '"' - case '\'': - c = '\'' - case '\\': - c = '\\' - case 'u': - rc, err := strconv.ParseInt(string(r[i+1:i+5]), 16, 32) - if err != nil { - panic(fmt.Errorf("internal parser error: %v", err)) - } - buf.WriteRune(rune(rc)) - i += 5 - continue - case 'U': - rc, err := strconv.ParseInt(string(r[i+1:i+9]), 16, 32) - if err != nil { - panic(fmt.Errorf("internal parser error: %v", err)) - } - buf.WriteRune(rune(rc)) - i += 9 - continue - } - buf.WriteByte(c) - default: - buf.WriteRune(r[i]) - } - i++ - } - - return buf.String() -} From c75cef60d15d66c71503e4fc8d9b949b5c47cd59 Mon Sep 17 00:00:00 2001 From: kortschak Date: Fri, 25 Jul 2014 11:37:04 +0930 Subject: [PATCH 08/52] Generate parser code ragel -Z -G2 parse.rl ragel version 6.8 (as previously) --- nquads/parse.go | 235 ++++++++++++++++++++++++++++---------------------------- 1 file changed, 118 insertions(+), 117 deletions(-) diff --git a/nquads/parse.go b/nquads/parse.go index f46264d..a636703 100644 --- a/nquads/parse.go +++ b/nquads/parse.go @@ -19,10 +19,9 @@ package nquads import ( - "bytes" "errors" "fmt" - "strconv" + "unicode" "github.com/google/cayley/graph" ) @@ -33,7 +32,7 @@ var ( ) -// line 37 "parse.go" +// line 36 "parse.go" const quads_start int = 1 const quads_first_final int = 84 const quads_error int = 0 @@ -41,7 +40,7 @@ const quads_error int = 0 const quads_en_statement int = 1 -// line 41 "parse.rl" +// line 40 "parse.rl" func parse(data []rune) (graph.Triple, error) { @@ -61,15 +60,15 @@ func parse(data []rune) (graph.Triple, error) { ) -// line 65 "parse.go" +// line 64 "parse.go" { cs = quads_start } -// line 60 "parse.rl" +// line 59 "parse.rl" -// line 73 "parse.go" +// line 72 "parse.go" { if p == pe { goto _test_eof @@ -274,12 +273,16 @@ tr0: if p < len(data) { - return graph.Triple{}, fmt.Errorf("%v: unexpected rune %q at %d", ErrInvalid, data[p], p) + if r := data[p]; r < unicode.MaxASCII { + return triple, fmt.Errorf("%v: unexpected rune %q at %d", ErrInvalid, data[p], p) + } else { + return triple, fmt.Errorf("%v: unexpected rune %q (\\u%04x) at %d", ErrInvalid, data[p], data[p], p) + } } - return graph.Triple{}, ErrIncomplete + return triple, ErrIncomplete goto st0 -// line 283 "parse.go" +// line 286 "parse.go" st_case_0: st0: cs = 0 @@ -303,7 +306,7 @@ tr107: goto _test_eof2 } st_case_2: -// line 307 "parse.go" +// line 310 "parse.go" switch data[p] { case 62: goto st3 @@ -320,7 +323,12 @@ tr107: goto st2 } case data[p] > 93: - if 97 <= data[p] && data[p] <= 122 { + switch { + case data[p] > 122: + if 128 <= data[p] && data[p] <= 1114111 { + goto st2 + } + case data[p] >= 97: goto st2 } default: @@ -339,7 +347,7 @@ tr108: goto _test_eof3 } st_case_3: -// line 343 "parse.go" +// line 351 "parse.go" switch data[p] { case 9: goto tr7 @@ -363,7 +371,7 @@ tr7: goto _test_eof4 } st_case_4: -// line 367 "parse.go" +// line 375 "parse.go" switch data[p] { case 9: goto st4 @@ -392,7 +400,7 @@ tr95: goto _test_eof5 } st_case_5: -// line 396 "parse.go" +// line 404 "parse.go" switch data[p] { case 62: goto st6 @@ -409,7 +417,12 @@ tr95: goto st5 } case data[p] > 93: - if 97 <= data[p] && data[p] <= 122 { + switch { + case data[p] > 122: + if 128 <= data[p] && data[p] <= 1114111 { + goto st5 + } + case data[p] >= 97: goto st5 } default: @@ -428,7 +441,7 @@ tr96: goto _test_eof6 } st_case_6: -// line 432 "parse.go" +// line 445 "parse.go" switch data[p] { case 9: goto tr13 @@ -452,7 +465,7 @@ tr13: goto _test_eof7 } st_case_7: -// line 456 "parse.go" +// line 469 "parse.go" switch data[p] { case 9: goto st7 @@ -485,7 +498,7 @@ tr73: goto _test_eof8 } st_case_8: -// line 489 "parse.go" +// line 502 "parse.go" switch data[p] { case 34: goto st9 @@ -498,7 +511,12 @@ tr73: goto st8 } case data[p] > 12: - if 14 <= data[p] && data[p] <= 126 { + switch { + case data[p] > 126: + if 128 <= data[p] && data[p] <= 1114111 { + goto st8 + } + case data[p] >= 14: goto st8 } default: @@ -517,7 +535,7 @@ tr74: goto _test_eof9 } st_case_9: -// line 521 "parse.go" +// line 539 "parse.go" switch data[p] { case 9: goto tr21 @@ -547,7 +565,7 @@ tr21: goto _test_eof10 } st_case_10: -// line 551 "parse.go" +// line 569 "parse.go" switch data[p] { case 9: goto st10 @@ -588,7 +606,7 @@ tr33: goto _test_eof84 } st_case_84: -// line 592 "parse.go" +// line 610 "parse.go" switch data[p] { case 9: goto st84 @@ -609,7 +627,7 @@ tr114: goto _test_eof85 } st_case_85: -// line 613 "parse.go" +// line 631 "parse.go" goto st85 tr27: // line 34 "actions.rl" @@ -630,7 +648,7 @@ tr44: goto _test_eof11 } st_case_11: -// line 634 "parse.go" +// line 652 "parse.go" switch data[p] { case 62: goto st12 @@ -647,7 +665,12 @@ tr44: goto st11 } case data[p] > 93: - if 97 <= data[p] && data[p] <= 122 { + switch { + case data[p] > 122: + if 128 <= data[p] && data[p] <= 1114111 { + goto st11 + } + case data[p] >= 97: goto st11 } default: @@ -666,7 +689,7 @@ tr45: goto _test_eof12 } st_case_12: -// line 670 "parse.go" +// line 693 "parse.go" switch data[p] { case 9: goto tr32 @@ -692,7 +715,7 @@ tr32: goto _test_eof13 } st_case_13: -// line 696 "parse.go" +// line 719 "parse.go" switch data[p] { case 9: goto st13 @@ -714,7 +737,7 @@ tr46: goto _test_eof14 } st_case_14: -// line 718 "parse.go" +// line 741 "parse.go" switch data[p] { case 85: goto st15 @@ -887,7 +910,12 @@ tr46: goto tr44 } case data[p] > 93: - if 97 <= data[p] && data[p] <= 122 { + switch { + case data[p] > 122: + if 128 <= data[p] && data[p] <= 1114111 { + goto tr44 + } + case data[p] >= 97: goto tr44 } default: @@ -906,7 +934,7 @@ tr28: goto _test_eof24 } st_case_24: -// line 910 "parse.go" +// line 938 "parse.go" if data[p] == 58 { goto st25 } @@ -973,7 +1001,7 @@ tr28: goto st26 } case data[p] > 65533: - if 65536 <= data[p] && data[p] <= 126975 { + if 65536 <= data[p] && data[p] <= 983039 { goto st26 } default: @@ -1059,7 +1087,7 @@ tr28: goto st26 } case data[p] > 65533: - if 65536 <= data[p] && data[p] <= 126975 { + if 65536 <= data[p] && data[p] <= 983039 { goto st26 } default: @@ -1088,7 +1116,7 @@ tr49: goto _test_eof86 } st_case_86: -// line 1092 "parse.go" +// line 1120 "parse.go" switch data[p] { case 9: goto st84 @@ -1159,7 +1187,7 @@ tr49: goto st26 } case data[p] > 65533: - if 65536 <= data[p] && data[p] <= 126975 { + if 65536 <= data[p] && data[p] <= 983039 { goto st26 } default: @@ -1241,7 +1269,7 @@ tr49: goto st26 } case data[p] > 65533: - if 65536 <= data[p] && data[p] <= 126975 { + if 65536 <= data[p] && data[p] <= 983039 { goto st26 } default: @@ -1375,7 +1403,7 @@ tr67: goto _test_eof34 } st_case_34: -// line 1379 "parse.go" +// line 1407 "parse.go" switch data[p] { case 62: goto st35 @@ -1392,7 +1420,12 @@ tr67: goto st34 } case data[p] > 93: - if 97 <= data[p] && data[p] <= 122 { + switch { + case data[p] > 122: + if 128 <= data[p] && data[p] <= 1114111 { + goto st34 + } + case data[p] >= 97: goto st34 } default: @@ -1411,7 +1444,7 @@ tr68: goto _test_eof35 } st_case_35: -// line 1415 "parse.go" +// line 1448 "parse.go" switch data[p] { case 9: goto tr21 @@ -1433,7 +1466,7 @@ tr69: goto _test_eof36 } st_case_36: -// line 1437 "parse.go" +// line 1470 "parse.go" switch data[p] { case 85: goto st37 @@ -1606,7 +1639,12 @@ tr69: goto tr67 } case data[p] > 93: - if 97 <= data[p] && data[p] <= 122 { + switch { + case data[p] > 122: + if 128 <= data[p] && data[p] <= 1114111 { + goto tr67 + } + case data[p] >= 97: goto tr67 } default: @@ -1625,7 +1663,7 @@ tr75: goto _test_eof46 } st_case_46: -// line 1629 "parse.go" +// line 1667 "parse.go" switch data[p] { case 34: goto st47 @@ -1666,7 +1704,12 @@ tr75: goto tr73 } case data[p] > 12: - if 14 <= data[p] && data[p] <= 126 { + switch { + case data[p] > 126: + if 128 <= data[p] && data[p] <= 1114111 { + goto tr73 + } + case data[p] >= 14: goto tr73 } default: @@ -1829,7 +1872,7 @@ tr17: goto _test_eof56 } st_case_56: -// line 1833 "parse.go" +// line 1876 "parse.go" if data[p] == 58 { goto st57 } @@ -1896,7 +1939,7 @@ tr17: goto st58 } case data[p] > 65533: - if 65536 <= data[p] && data[p] <= 126975 { + if 65536 <= data[p] && data[p] <= 983039 { goto st58 } default: @@ -1982,7 +2025,7 @@ tr17: goto st58 } case data[p] > 65533: - if 65536 <= data[p] && data[p] <= 126975 { + if 65536 <= data[p] && data[p] <= 983039 { goto st58 } default: @@ -2011,7 +2054,7 @@ tr84: goto _test_eof87 } st_case_87: -// line 2015 "parse.go" +// line 2058 "parse.go" switch data[p] { case 9: goto st84 @@ -2082,7 +2125,7 @@ tr84: goto st58 } case data[p] > 65533: - if 65536 <= data[p] && data[p] <= 126975 { + if 65536 <= data[p] && data[p] <= 983039 { goto st58 } default: @@ -2164,7 +2207,7 @@ tr84: goto st58 } case data[p] > 65533: - if 65536 <= data[p] && data[p] <= 126975 { + if 65536 <= data[p] && data[p] <= 983039 { goto st58 } default: @@ -2189,7 +2232,7 @@ tr97: goto _test_eof60 } st_case_60: -// line 2193 "parse.go" +// line 2236 "parse.go" switch data[p] { case 85: goto st61 @@ -2362,7 +2405,12 @@ tr97: goto tr95 } case data[p] > 93: - if 97 <= data[p] && data[p] <= 122 { + switch { + case data[p] > 122: + if 128 <= data[p] && data[p] <= 1114111 { + goto tr95 + } + case data[p] >= 97: goto tr95 } default: @@ -2381,7 +2429,7 @@ tr109: goto _test_eof70 } st_case_70: -// line 2385 "parse.go" +// line 2433 "parse.go" switch data[p] { case 85: goto st71 @@ -2554,7 +2602,12 @@ tr109: goto tr107 } case data[p] > 93: - if 97 <= data[p] && data[p] <= 122 { + switch { + case data[p] > 122: + if 128 <= data[p] && data[p] <= 1114111 { + goto tr107 + } + case data[p] >= 97: goto tr107 } default: @@ -2573,7 +2626,7 @@ tr3: goto _test_eof80 } st_case_80: -// line 2577 "parse.go" +// line 2630 "parse.go" if data[p] == 58 { goto st81 } @@ -2640,7 +2693,7 @@ tr3: goto st82 } case data[p] > 65533: - if 65536 <= data[p] && data[p] <= 126975 { + if 65536 <= data[p] && data[p] <= 983039 { goto st82 } default: @@ -2726,7 +2779,7 @@ tr3: goto st82 } case data[p] > 65533: - if 65536 <= data[p] && data[p] <= 126975 { + if 65536 <= data[p] && data[p] <= 983039 { goto st82 } default: @@ -2808,7 +2861,7 @@ tr3: goto st82 } case data[p] > 65533: - if 65536 <= data[p] && data[p] <= 126975 { + if 65536 <= data[p] && data[p] <= 983039 { goto st82 } default: @@ -2924,9 +2977,13 @@ tr3: if p < len(data) { - return graph.Triple{}, fmt.Errorf("%v: unexpected rune %q at %d", ErrInvalid, data[p], p) + if r := data[p]; r < unicode.MaxASCII { + return triple, fmt.Errorf("%v: unexpected rune %q at %d", ErrInvalid, data[p], p) + } else { + return triple, fmt.Errorf("%v: unexpected rune %q (\\u%04x) at %d", ErrInvalid, data[p], data[p], p) + } } - return graph.Triple{}, ErrIncomplete + return triple, ErrIncomplete case 84, 86, 87: // line 74 "actions.rl" @@ -2938,70 +2995,14 @@ tr3: return triple, nil -// line 2942 "parse.go" +// line 2999 "parse.go" } } _out: {} } -// line 62 "parse.rl" +// line 61 "parse.rl" return graph.Triple{}, ErrInvalid } - -func unEscape(r []rune, isEscaped bool) string { - if !isEscaped { - return string(r) - } - - buf := bytes.NewBuffer(make([]byte, 0, len(r))) - - for i := 0; i < len(r); { - switch r[i] { - case '\\': - i++ - var c byte - switch r[i] { - case 't': - c = '\t' - case 'b': - c = '\b' - case 'n': - c = '\n' - case 'r': - c = '\r' - case 'f': - c = '\f' - case '"': - c = '"' - case '\'': - c = '\'' - case '\\': - c = '\\' - case 'u': - rc, err := strconv.ParseInt(string(r[i+1:i+5]), 16, 32) - if err != nil { - panic(fmt.Errorf("internal parser error: %v", err)) - } - buf.WriteRune(rune(rc)) - i += 5 - continue - case 'U': - rc, err := strconv.ParseInt(string(r[i+1:i+9]), 16, 32) - if err != nil { - panic(fmt.Errorf("internal parser error: %v", err)) - } - buf.WriteRune(rune(rc)) - i += 9 - continue - } - buf.WriteByte(c) - default: - buf.WriteRune(r[i]) - } - i++ - } - - return buf.String() -} From 3995d3dd570a0346ba930c35bb392d5de95f4681 Mon Sep 17 00:00:00 2001 From: kortschak Date: Fri, 25 Jul 2014 11:38:23 +0930 Subject: [PATCH 09/52] Run quadfix on 30kmovies.nt.gz and replace --- 30kmoviedata.nq.gz | Bin 0 -> 3935341 bytes 30kmoviedata.nt.gz | Bin 3903754 -> 0 bytes 2 files changed, 0 insertions(+), 0 deletions(-) create mode 100644 30kmoviedata.nq.gz delete mode 100644 30kmoviedata.nt.gz diff --git a/30kmoviedata.nq.gz b/30kmoviedata.nq.gz new file mode 100644 index 0000000000000000000000000000000000000000..264f81a6d7f3b31ca91602282dbd6da70b7c8533 GIT binary patch literal 3935341 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ν2j8#Ezz33?oDiv4|t-&b899;n(LN%hcl)`pJtZ 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