1/*  Part of SWI-Prolog
   2
   3    Author:        Jan Wielemaker
   4    E-mail:        J.Wielemaker@vu.nl
   5    WWW:           http://www.swi-prolog.org
   6    Copyright (c)  2010-2013, University of Amsterdam
   7    All rights reserved.
   8
   9    Redistribution and use in source and binary forms, with or without
  10    modification, are permitted provided that the following conditions
  11    are met:
  12
  13    1. Redistributions of source code must retain the above copyright
  14       notice, this list of conditions and the following disclaimer.
  15
  16    2. Redistributions in binary form must reproduce the above copyright
  17       notice, this list of conditions and the following disclaimer in
  18       the documentation and/or other materials provided with the
  19       distribution.
  20
  21    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  24    FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  25    COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  26    INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  27    BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  28    LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  29    CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30    LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  31    ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  32    POSSIBILITY OF SUCH DAMAGE.
  33*/
  34
  35:- module(rdf_ntriples_old,
  36          [ load_rdf_ntriples/2,        % +File, -Triples
  37            rdf_ntriple_part/4          % +Field, -Value, <DCG>
  38          ]).
  39
  40
  41/** <module> RDF N-triples parser (obsolete)
  42
  43This module parses n-triple files as defined   by the W3C RDF working in
  44http://www.w3.org/TR/rdf-testcases/#ntriples.   This   format     is   a
  45simplified version of the RDF N3 notation   used  in the *.nt files that
  46are used to describe the normative outcome of the RDF test-cases.
  47
  48The returned list terms are of the form
  49
  50        rdf(Subject, Predicate, Object)
  51
  52where
  53
  54        * Subject
  55        is an atom or node(Id) for anonymous nodes
  56        * Predicate
  57        is an atom
  58        * Object
  59        is an atom, node(Id), literal(Atom) or xml(Atom)
  60
  61@deprecated     This library will shortly be replaced with a stub that
  62                calls library(semweb/rdf_ntriples).
  63*/
  64
  65%       load_rdf_ntriples(+Source, -Triples)
  66%
  67%       Load a file or stream to a list of rdf(S,P,O) triples.
  68
  69load_rdf_ntriples(File, Triples) :-
  70    open_nt_file(File, In, Close),
  71    call_cleanup(stream_to_triples(In, Triples), Close).
  72
  73%       open_nt_file(+Input, -Stream, -Close)
  74%
  75%       Open Input, returning Stream and a goal to cleanup Stream if it
  76%       was opened.
  77
  78open_nt_file(stream(Stream), Stream, true) :- !.
  79open_nt_file(Stream, Stream, true) :-
  80    is_stream(Stream),
  81    !.
  82open_nt_file(Spec, Stream, close(Stream)) :-
  83    absolute_file_name(Spec,
  84                       [ access(read),
  85                         extensions([nt,''])
  86                       ], Path),
  87    open(Path, read, Stream).
  88
  89
  90%       rdf_ntriple_part(+Type, -Value, <DCG>)
  91%
  92%       Parse one of the fields of  an   ntriple.  This  is used for the
  93%       SWI-Prolog Sesame (www.openrdf.org) implementation   to  realise
  94%       /servlets/removeStatements. I do not think   public  use of this
  95%       predicate should be stimulated.
  96
  97rdf_ntriple_part(subject, Subject) -->
  98    subject(Subject).
  99rdf_ntriple_part(predicate, Predicate) -->
 100    predicate(Predicate).
 101rdf_ntriple_part(object, Object) -->
 102    predicate(Object).
 103
 104
 105%       stream_to_triples(+Stream, -ListOfTriples)
 106%
 107%       Read Stream, returning all its triples
 108
 109stream_to_triples(In, Triples) :-
 110    read_line_to_codes(In, Line),
 111    (   Line == end_of_file
 112    ->  Triples = []
 113    ;   phrase(line(Triples, Tail), Line),
 114        stream_to_triples(In, Tail)
 115    ).
 116
 117line(Triples, Tail) -->
 118    wss,
 119    (   comment
 120    ->  {Triples = Tail}
 121    ;   triple(Triple)
 122    ->  {Triples = [Triple|Tail]}
 123    ).
 124
 125comment -->
 126    "#",
 127    !,
 128    skip_rest.
 129comment -->
 130    end_of_input.
 131
 132triple(rdf(Subject, Predicate, Object)) -->
 133    subject(Subject), ws, wss,
 134    predicate(Predicate), ws, wss,
 135    object(Object), wss, ".", wss.
 136
 137subject(Subject) -->
 138    uniref(Subject),
 139    !.
 140subject(Subject) -->
 141    node_id(Subject).
 142
 143predicate(Predicate) -->
 144    uniref(Predicate).
 145
 146object(Object) -->
 147    uniref(Object),
 148    !.
 149object(Object) -->
 150    node_id(Object).
 151object(Object) -->
 152    literal(Object).
 153
 154
 155uniref(URI) -->
 156    "<",
 157    escaped_uri_codes(Codes),
 158    ">",
 159    !,
 160    { atom_codes(URI, Codes)
 161    }.
 162
 163node_id(node(Id)) -->                   % anonymous nodes
 164    "_:",
 165    name_start(C0),
 166    name_codes(Codes),
 167    { atom_codes(Id, [C0|Codes])
 168    }.
 169
 170literal(Literal) -->
 171    lang_string(Literal),
 172    !.
 173literal(Literal) -->
 174    xml_string(Literal).
 175
 176
 177%       name_start(-Code)
 178%       name_codes(-ListfCodes)
 179%
 180%       Parse identifier names
 181
 182name_start(C) -->
 183    [C],
 184    { code_type(C, alpha)
 185    }.
 186
 187name_codes([C|T]) -->
 188    [C],
 189    { code_type(C, alnum)
 190    },
 191    !,
 192    name_codes(T).
 193name_codes([]) -->
 194    [].
 195
 196
 197%       escaped_uri_codes(-CodeList)
 198%
 199%       Decode string holding %xx escaped characters.
 200
 201escaped_uri_codes([]) -->
 202    [].
 203escaped_uri_codes([C|T]) -->
 204    "%", [D0,D1],
 205    { code_type(D0, xdigit(V0)),
 206      code_type(D1, xdigit(V1)),
 207      !,
 208      C is V0<<4 + V1
 209    },
 210    escaped_uri_codes(T).
 211escaped_uri_codes([C|T]) -->
 212    "\\u", [D0,D1,D2,D3],
 213    !,
 214    { code_type(D0, xdigit(V0)),
 215      code_type(D1, xdigit(V1)),
 216      code_type(D2, xdigit(V2)),
 217      code_type(D3, xdigit(V3)),
 218      C is V0<<12 + V1<<8 + V2<<4 + V3
 219    },
 220    escaped_uri_codes(T).
 221escaped_uri_codes([C|T]) -->
 222    "\\U", [D0,D1,D2,D3,D4,D5,D6,D7],
 223    !,
 224    { code_type(D0, xdigit(V0)),
 225      code_type(D1, xdigit(V1)),
 226      code_type(D2, xdigit(V2)),
 227      code_type(D3, xdigit(V3)),
 228      code_type(D4, xdigit(V4)),
 229      code_type(D5, xdigit(V5)),
 230      code_type(D6, xdigit(V6)),
 231      code_type(D7, xdigit(V7)),
 232      C is V0<<28 + V1<<24 + V2<<20 + V3<<16 +
 233           V4<<12 + V5<<8 + V6<<4 + V7
 234    },
 235    escaped_uri_codes(T).
 236escaped_uri_codes([C|T]) -->
 237    [C],
 238    escaped_uri_codes(T).
 239
 240
 241%       lang_string()
 242%
 243%       Process a language string
 244
 245lang_string(String) -->
 246    "\"",
 247    string(Codes),
 248    "\"",
 249    !,
 250    { atom_codes(Atom, Codes)
 251    },
 252    (   langsep
 253    ->  language(Lang),
 254        { String = literal(lang(Lang, Atom))
 255        }
 256    ;   "^^"
 257    ->  uniref(Type),
 258        { String = literal(type(Type, Atom))
 259        }
 260    ;   { String = literal(Atom)
 261        }
 262    ).
 263
 264langsep -->
 265    "-".
 266langsep -->
 267    "@".
 268
 269%       xml_string(String)
 270%
 271%       Handle xml"..."
 272
 273xml_string(xml(String)) -->
 274    "xml\"",                        % really no whitespace?
 275    string(Codes),
 276    "\"",
 277    { atom_codes(String, Codes)
 278    }.
 279
 280string([]) -->
 281    [].
 282string([C0|T]) -->
 283    string_char(C0),
 284    string(T).
 285
 286string_char(0'\\) -->
 287    "\\\\".
 288string_char(0'") -->
 289    "\\\"".
 290string_char(10) -->
 291    "\\n".
 292string_char(13) -->
 293    "\\r".
 294string_char(9) -->
 295    "\\t".
 296string_char(C) -->
 297    "\\u",
 298    '4xdigits'(C).
 299string_char(C) -->
 300    "\\U",
 301    '4xdigits'(C0),
 302    '4xdigits'(C1),
 303    { C is C0<<16 + C1
 304    }.
 305string_char(C) -->
 306    [C].
 307
 308'4xdigits'(C) -->
 309    [C0,C1,C2,C3],
 310    { code_type(C0, xdigit(V0)),
 311      code_type(C1, xdigit(V1)),
 312      code_type(C2, xdigit(V2)),
 313      code_type(C3, xdigit(V3)),
 314
 315      C is V0<<12 + V1<<8 + V2<<4 + V3
 316    }.
 317
 318%       language(-Lang)
 319%
 320%       Return xml:lang language identifier.
 321
 322language(Lang) -->
 323    lang_code(C0),
 324    lang_codes(Codes),
 325    { atom_codes(Lang, [C0|Codes])
 326    }.
 327
 328lang_code(C) -->
 329    [C],
 330    { C \== 0'.,
 331      \+ code_type(C, white)
 332    }.
 333
 334lang_codes([C|T]) -->
 335    lang_code(C),
 336    !,
 337    lang_codes(T).
 338lang_codes([]) -->
 339    [].
 340
 341
 342                 /*******************************
 343                 *             BASICS           *
 344                 *******************************/
 345
 346skip_rest(_,[]).
 347
 348ws -->
 349    [C],
 350    { code_type(C, white)
 351    }.
 352
 353end_of_input([], []).
 354
 355
 356wss -->
 357    ws,
 358    !,
 359    wss.
 360wss -->
 361    [].