(otherwise (problem 'ctm-rejection :expected-datatype-iri (token-position token)
"A datatype qualifier requires an IRI reference, not a Topic identifier.")))))
-(defun excluded-literal-p (text)
- "Recognize unsupported numeric/date literal syntax, without constructing values."
- (labels ((digits (s) (and (plusp (length s)) (every (lambda (c) (find c "0123456789")) s)))
- (numeric (s)
- (let* ((s (if (and (plusp (length s)) (find (char s 0) "+-")) (subseq s 1) s))
- (dot (position #\. s)))
- (if dot (and (or (zerop dot) (digits (subseq s 0 dot))) (digits (subseq s (1+ dot)))) (digits s))))
- (date (s)
- (let* ((s (if (and (plusp (length s)) (char= (char s 0) #\-)) (subseq s 1) s))
- (dash (position #\- s)))
- (and dash (>= dash 4) (digits (subseq s 0 dash))
- (= (length s) (+ dash 6)) (char= (char s (+ dash 3)) #\-)
- (digits (subseq s (1+ dash) (+ dash 3))) (digits (subseq s (+ dash 4)))
- (<= 1 (parse-integer s :start (1+ dash) :end (+ dash 3)) 12)
- (<= 1 (parse-integer s :start (+ dash 4)) 31))))
- (time-literal (s)
- (and (>= (length s) 8) (digits (subseq s 0 2)) (char= (char s 2) #\:)
- (digits (subseq s 3 5)) (char= (char s 5) #\:) (digits (subseq s 6 8))
- (let* ((rest (subseq s 8))
- (end (position-if (lambda (c) (find c "Z+-")) rest))
- (fraction (subseq rest 0 end)) (zone (if end (subseq rest end) "")))
- (and (or (zerop (length fraction))
- (and (char= (char fraction 0) #\.) (digits (subseq fraction 1))))
- (or (member zone '("" "Z") :test #'string=)
- (and (= 6 (length zone)) (find (char zone 0) "+-")
- (digits (subseq zone 1 3)) (char= (char zone 3) #\:)
- (digits (subseq zone 4 6)))))))))
- (or (numeric text) (date text) (string= text "*")
- (let ((tee (position #\T text))) (and tee (date (subseq text 0 tee)) (time-literal (subseq text (1+ tee))))))))
-
(defun read-occurrence-literal (parser)
- ;; The dedicated lexer already preserves multiline strings and escape values.
- ;; Numeric/date sugar is recognized only to report an unsupported construct.
- (unless (parser-lookahead parser)
- (let ((lexer (parser-lexer parser)))
- (skip-layout lexer)
- (let ((c (peek-character lexer)) (start (lexer-cursor lexer)))
- (when (and c (or (find c "0123456789+*")
- (and (find c "-.") (peek-character lexer 1)
- (find (peek-character lexer 1) "0123456789"))))
- (let* ((end (position-if (lambda (c) (or (whitespace-p c) (find c ";@~)")))
- (lexer-text lexer) :start start))
- (text (subseq (lexer-text lexer) start end))
- (text (if (and (plusp (length text)) (char= (char text (1- (length text))) #\.))
- (subseq text 0 (1- (length text))) text)))
- (problem (if (excluded-literal-p text) 'ctm-unsupported 'ctm-rejection)
- (if (excluded-literal-p text) :occurrence-literal-datatype :invalid-occurrence-literal)
- start "Only string and IRI-form Occurrence literals are implemented."))))))
(let ((token (look parser)))
(case (token-kind token)
+ (:integer
+ (consume parser)
+ ;; Numeric-literal value policy: represent the unquoted integer value
+ ;; canonically; qualified quoted strings retain their lexical value.
+ (values (topic-maps.tmdm:canonical-integer-lexical-form (token-value token))
+ (topic-maps.tmdm:integer-datatype)))
+ (:decimal
+ (consume parser)
+ ;; Same value-representation policy as bare integers; token spelling is
+ ;; retained by the lexer, qualified strings remain lexical model data.
+ (values (topic-maps.tmdm:canonical-decimal-lexical-form (token-value token))
+ (topic-maps.tmdm:decimal-datatype)))
+ (:date
+ (consume parser)
+ (values (topic-maps.tmdm:canonical-date-lexical-form (token-value token)) (topic-maps.tmdm:date-datatype)))
+ (:datetime
+ (consume parser)
+ (multiple-value-bind (value reason) (topic-maps.tmdm:canonical-datetime-lexical-form (token-value token))
+ (unless value (problem 'ctm-unsupported
+ (if (eq reason :unsupported-bce-timezone-rollover)
+ :datetime-bce-timezone-rollover :datetime-leap-second-context)
+ (token-position token) "DateTime normalization is outside the supported BCE/leap-second calendar context."))
+ (values value (topic-maps.tmdm:datetime-datatype))))
+ (:excluded-literal
+ (problem 'ctm-unsupported :occurrence-literal-datatype (token-position token)
+ "The separate CTM '*' literal is outside this slice."))
(:string
(consume parser)
(if (punctuation-p parser #\^)
(problem 'ctm-rejection :invalid-datatype-marker (token-position caret) "Expected contiguous '^^'."))
(consume parser)
(let ((datatype (literal-iri-reference parser)))
+ (when (and (string= datatype (topic-maps.tmdm:integer-datatype))
+ (not (topic-maps.tmdm:integer-lexical-p (token-value token))))
+ (problem 'ctm-rejection :invalid-integer-value (token-position token)
+ "Quoted value is not an xsd:integer lexical form."))
+ (when (and (string= datatype (topic-maps.tmdm:decimal-datatype))
+ (not (topic-maps.tmdm:decimal-lexical-p (token-value token))))
+ (problem 'ctm-rejection :invalid-decimal-value (token-position token)
+ "Quoted value is not an xsd:decimal lexical form."))
+ (when (and (string= datatype (topic-maps.tmdm:date-datatype))
+ (not (topic-maps.tmdm:date-lexical-p (token-value token))))
+ (problem 'ctm-rejection :invalid-date-value (token-position token)
+ "Quoted value is not a valid XSD 1.0 date lexical form."))
+ (when (and (string= datatype (topic-maps.tmdm:datetime-datatype))
+ (not (topic-maps.tmdm:datetime-lexical-p (token-value token))))
+ (problem 'ctm-rejection :invalid-datetime-value (token-position token)
+ "Quoted value is not a valid XSD 1.0 dateTime."))
;; TMDM 4.4 requires absolute anyURI content; quoted content is
;; lexical data, never an IRI reference to resolve against the document.
(when (and (string= datatype (topic-maps.tmdm:iri-datatype))
(values (token-value token) (topic-maps.tmdm:string-datatype))))
((:iri :qname) (values (literal-iri-reference parser) (topic-maps.tmdm:iri-datatype)))
(otherwise (problem 'ctm-rejection :expected-occurrence-value (token-position token)
- "Expected a quoted string or IRI-form Occurrence value.")))))
+ "Expected an integer, decimal, date, dateTime, quoted string or IRI-form Occurrence value.")))))
(defun read-identity-tail (parser map topic)
(let ((start (look parser)))