Jocelyn Fiat
82f832a556
Updated classes with bottom indexing notes related to copyright and license.
507 lines
12 KiB
Plaintext
507 lines
12 KiB
Plaintext
note
|
|
description: "[
|
|
A JSON_STRING represent a string in JSON.
|
|
A string is a collection of zero or more Unicodes characters, wrapped in double
|
|
quotes, using blackslash espaces.
|
|
]"
|
|
author: "$Author$"
|
|
date: "$Date$"
|
|
revision: "$Revision$"
|
|
license: "MIT (see http://www.opensource.org/licenses/mit-license.php)"
|
|
|
|
class
|
|
JSON_STRING
|
|
|
|
inherit
|
|
|
|
JSON_VALUE
|
|
redefine
|
|
is_equal
|
|
end
|
|
|
|
create
|
|
make_from_string, make_from_string_32, make_from_string_general,
|
|
make_from_escaped_json_string,
|
|
make_with_escaped_json, make_json, make_json_from_string_32
|
|
|
|
convert
|
|
make_from_string ({READABLE_STRING_8, STRING_8, IMMUTABLE_STRING_8}),
|
|
make_from_string_32 ({READABLE_STRING_32, STRING_32, IMMUTABLE_STRING_32}),
|
|
make_from_string_general ({READABLE_STRING_GENERAL, STRING_GENERAL, IMMUTABLE_STRING_GENERAL})
|
|
|
|
feature {NONE} -- Initialization
|
|
|
|
make_from_string (s: READABLE_STRING_8)
|
|
-- Initialize from ascii string `s'.
|
|
require
|
|
s_not_void: s /= Void
|
|
do
|
|
make_from_escaped_json_string (escaped_json_string (s))
|
|
end
|
|
|
|
make_from_string_32 (s: READABLE_STRING_32)
|
|
-- Initialize from unicode string `s'.
|
|
require
|
|
s_not_void: s /= Void
|
|
do
|
|
make_from_escaped_json_string (escaped_json_string (s))
|
|
end
|
|
|
|
make_from_string_general (s: READABLE_STRING_GENERAL)
|
|
-- Initialize from string `s'.
|
|
require
|
|
s_not_void: s /= Void
|
|
do
|
|
if attached {READABLE_STRING_8} s as s8 then
|
|
make_from_string (s8)
|
|
else
|
|
make_from_string_32 (s.as_string_32)
|
|
end
|
|
end
|
|
|
|
make_from_escaped_json_string (a_escaped_string: READABLE_STRING_8)
|
|
-- Initialize with `a_escaped_string' already JSON escaped.
|
|
require
|
|
a_escaped_string_not_void: a_escaped_string /= Void
|
|
do
|
|
item := a_escaped_string
|
|
end
|
|
|
|
make_with_escaped_json (a_escaped_string: READABLE_STRING_8)
|
|
-- Initialize with `a_escaped_string' already JSON escaped.
|
|
obsolete
|
|
"Use `make_from_escaped_json_string' Sept/2014"
|
|
require
|
|
a_escaped_string_not_void: a_escaped_string /= Void
|
|
do
|
|
make_from_escaped_json_string (a_escaped_string)
|
|
end
|
|
|
|
make_from_json_string (a_json: JSON_STRING)
|
|
-- Initialize with `a_json' string value.
|
|
do
|
|
make_from_escaped_json_string (a_json.item)
|
|
end
|
|
|
|
make_json (s: READABLE_STRING_8)
|
|
-- Initialize.
|
|
obsolete
|
|
"Use `make_from_string' Sept/2014"
|
|
require
|
|
item_not_void: s /= Void
|
|
do
|
|
make_with_escaped_json (escaped_json_string (s))
|
|
end
|
|
|
|
make_json_from_string_32 (s: READABLE_STRING_32)
|
|
-- Initialize from STRING_32 `s'.
|
|
obsolete
|
|
"Use `make_from_string_32' Sept/2014"
|
|
require
|
|
item_not_void: s /= Void
|
|
do
|
|
make_with_escaped_json (escaped_json_string (s))
|
|
end
|
|
|
|
feature -- Access
|
|
|
|
item: STRING
|
|
-- Contents with escaped entities if any
|
|
|
|
feature -- Conversion
|
|
|
|
unescaped_string_8: STRING_8
|
|
-- Unescaped ascii string from `item'.
|
|
--| note: valid only if `item' does not encode any unicode character.
|
|
local
|
|
s: like item
|
|
do
|
|
s := item
|
|
create Result.make (s.count)
|
|
unescape_to_string_8 (Result)
|
|
end
|
|
|
|
unescaped_string_32: STRING_32
|
|
-- Unescaped uncode string from `item'
|
|
--| some encoders uses UTF-8 , and not the recommended pure json encoding
|
|
--| thus, let's support the UTF-8 encoding during decoding.
|
|
local
|
|
s: READABLE_STRING_8
|
|
do
|
|
s := item
|
|
create Result.make (s.count)
|
|
unescape_to_string_32 (Result)
|
|
end
|
|
|
|
representation: STRING
|
|
-- String representation of `item' with escaped entities if any.
|
|
do
|
|
create Result.make (item.count + 2)
|
|
Result.append_character ('%"')
|
|
Result.append (item)
|
|
Result.append_character ('%"')
|
|
end
|
|
|
|
unescape_to_string_8 (a_output: STRING_8)
|
|
-- Unescape string `item' into `a_output'.
|
|
--| note: valid only if `item' does not encode any unicode character.
|
|
local
|
|
s: like item
|
|
i, n: INTEGER
|
|
c: CHARACTER
|
|
do
|
|
s := item
|
|
n := s.count
|
|
from
|
|
i := 1
|
|
until
|
|
i > n
|
|
loop
|
|
c := s [i]
|
|
if c = '\' then
|
|
if i < n then
|
|
inspect s [i + 1]
|
|
when '%"' then
|
|
a_output.append_character ('%"')
|
|
i := i + 2
|
|
when '\' then
|
|
a_output.append_character ('\')
|
|
i := i + 2
|
|
when '/' then
|
|
a_output.append_character ('/')
|
|
i := i + 2
|
|
when 'b' then
|
|
a_output.append_character ('%B')
|
|
i := i + 2
|
|
when 'f' then
|
|
a_output.append_character ('%F')
|
|
i := i + 2
|
|
when 'n' then
|
|
a_output.append_character ('%N')
|
|
i := i + 2
|
|
when 'r' then
|
|
a_output.append_character ('%R')
|
|
i := i + 2
|
|
when 't' then
|
|
a_output.append_character ('%T')
|
|
i := i + 2
|
|
when 'u' then
|
|
--| Leave unicode \uXXXX unescaped
|
|
a_output.append_character (c) -- '\'
|
|
i := i + 1
|
|
else
|
|
a_output.append_character (c) -- '\'
|
|
i := i + 1
|
|
end
|
|
else
|
|
a_output.append_character (c) -- '\'
|
|
i := i + 1
|
|
end
|
|
else
|
|
a_output.append_character (c)
|
|
i := i + 1
|
|
end
|
|
end
|
|
end
|
|
|
|
unescape_to_string_32 (a_output: STRING_32)
|
|
-- Unescape string `item' into `a_output' string 32.
|
|
--| some encoders uses UTF-8 , and not the recommended pure json encoding
|
|
--| thus, let's support the UTF-8 encoding during decoding.
|
|
local
|
|
s: READABLE_STRING_8
|
|
i, n: INTEGER
|
|
c: NATURAL_32
|
|
ch: CHARACTER_8
|
|
hex: READABLE_STRING_8
|
|
do
|
|
s := item
|
|
n := s.count
|
|
from
|
|
i := 1
|
|
until
|
|
i > n
|
|
loop
|
|
ch := s.item (i)
|
|
if ch = '\' then
|
|
if i < n then
|
|
inspect s [i + 1]
|
|
when '%"' then
|
|
a_output.append_character ('%"')
|
|
i := i + 2
|
|
when '\' then
|
|
a_output.append_character ('\')
|
|
i := i + 2
|
|
when '/' then
|
|
a_output.append_character ('/')
|
|
i := i + 2
|
|
when 'b' then
|
|
a_output.append_character ('%B')
|
|
i := i + 2
|
|
when 'f' then
|
|
a_output.append_character ('%F')
|
|
i := i + 2
|
|
when 'n' then
|
|
a_output.append_character ('%N')
|
|
i := i + 2
|
|
when 'r' then
|
|
a_output.append_character ('%R')
|
|
i := i + 2
|
|
when 't' then
|
|
a_output.append_character ('%T')
|
|
i := i + 2
|
|
when 'u' then
|
|
hex := s.substring (i + 2, i + 5) -- i+2 , i+2+4-1
|
|
if hex.count = 4 then
|
|
a_output.append_code (hexadecimal_to_natural_32 (hex))
|
|
end
|
|
i := i + 6 -- i+2+4
|
|
else
|
|
a_output.append_character (ch) -- '\'
|
|
i := i + 1
|
|
end
|
|
else
|
|
a_output.append_character (ch) -- '\'
|
|
i := i + 1
|
|
end
|
|
else
|
|
c := ch.natural_32_code
|
|
if c <= 0x7F then
|
|
-- 0xxxxxxx
|
|
check
|
|
ch = c.to_character_32
|
|
end
|
|
a_output.append_character (ch)
|
|
elseif c <= 0xDF then
|
|
-- 110xxxxx 10xxxxxx
|
|
i := i + 1
|
|
if i <= n then
|
|
a_output.append_code (((c & 0x1F) |<< 6) | (s.code (i) & 0x3F))
|
|
end
|
|
elseif c <= 0xEF then
|
|
-- 1110xxxx 10xxxxxx 10xxxxxx
|
|
i := i + 2
|
|
if i <= n then
|
|
a_output.append_code (((c & 0xF) |<< 12) | ((s.code (i - 1) & 0x3F) |<< 6) | (s.code (i) & 0x3F))
|
|
end
|
|
elseif c <= 0xF7 then
|
|
-- 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
|
|
i := i + 3
|
|
if i <= n then
|
|
a_output.append_code (((c & 0x7) |<< 18) | ((s.code (i - 2) & 0x3F) |<< 12) | ((s.code (i - 1) & 0x3F) |<< 6) | (s.code (i) & 0x3F))
|
|
end
|
|
end
|
|
i := i + 1
|
|
end
|
|
end
|
|
end
|
|
|
|
feature -- Visitor pattern
|
|
|
|
accept (a_visitor: JSON_VISITOR)
|
|
-- Accept `a_visitor'.
|
|
-- (Call `visit_json_string' procedure on `a_visitor'.)
|
|
do
|
|
a_visitor.visit_json_string (Current)
|
|
end
|
|
|
|
feature -- Comparison
|
|
|
|
is_equal (other: like Current): BOOLEAN
|
|
-- Is JSON_STRING made of same character sequence as `other'
|
|
-- (possibly with a different capacity)?
|
|
do
|
|
Result := item.same_string (other.item)
|
|
end
|
|
|
|
feature -- Change Element
|
|
|
|
append (a_escaped_string: READABLE_STRING_8)
|
|
-- Add JSON escaped string `a_escaped_string'
|
|
require
|
|
a_escaped_string_not_void: a_escaped_string /= Void
|
|
do
|
|
item.append_string (a_escaped_string)
|
|
end
|
|
|
|
append_json_string (a_json_string: JSON_STRING)
|
|
-- Add JSON string `a_json_string'
|
|
require
|
|
a_json_string_not_void: a_json_string /= Void
|
|
do
|
|
append (a_json_string.item)
|
|
end
|
|
|
|
append_string (s: READABLE_STRING_8)
|
|
-- Add ascii string `s'
|
|
require
|
|
s_not_void: s /= Void
|
|
do
|
|
append (escaped_json_string (s))
|
|
end
|
|
|
|
append_string_32 (s: READABLE_STRING_32)
|
|
-- Add unicode string `s'
|
|
require
|
|
s_not_void: s /= Void
|
|
do
|
|
append (escaped_json_string (s))
|
|
end
|
|
|
|
append_string_general (s: READABLE_STRING_GENERAL)
|
|
-- Add unicode string `s'
|
|
require
|
|
s_not_void: s /= Void
|
|
do
|
|
if attached {READABLE_STRING_8} s as s8 then
|
|
append_string (s.as_string_8)
|
|
else
|
|
append_string_32 (s.as_string_32)
|
|
end
|
|
end
|
|
|
|
feature -- Status report
|
|
|
|
hash_code: INTEGER
|
|
-- Hash code value
|
|
do
|
|
Result := item.hash_code
|
|
end
|
|
|
|
feature -- Status report
|
|
|
|
debug_output: STRING
|
|
-- String that should be displayed in debugger to represent `Current'.
|
|
do
|
|
Result := item
|
|
end
|
|
|
|
feature {NONE} -- Implementation
|
|
|
|
is_hexadecimal (s: READABLE_STRING_8): BOOLEAN
|
|
-- Is `s' an hexadecimal value?
|
|
local
|
|
i: INTEGER
|
|
do
|
|
from
|
|
Result := True
|
|
i := 1
|
|
until
|
|
i > s.count or not Result
|
|
loop
|
|
Result := s [i].is_hexa_digit
|
|
i := i + 1
|
|
end
|
|
end
|
|
|
|
hexadecimal_to_natural_32 (s: READABLE_STRING_8): NATURAL_32
|
|
-- Hexadecimal string `s' converted to NATURAL_32 value
|
|
require
|
|
s_not_void: s /= Void
|
|
is_hexadecimal: is_hexadecimal (s)
|
|
local
|
|
i, nb: INTEGER
|
|
char: CHARACTER
|
|
do
|
|
nb := s.count
|
|
if nb >= 2 and then s.item (2) = 'x' then
|
|
i := 3
|
|
else
|
|
i := 1
|
|
end
|
|
from
|
|
until
|
|
i > nb
|
|
loop
|
|
Result := Result * 16
|
|
char := s.item (i)
|
|
if char >= '0' and then char <= '9' then
|
|
Result := Result + (char |-| '0').to_natural_32
|
|
else
|
|
Result := Result + (char.lower |-| 'a' + 10).to_natural_32
|
|
end
|
|
i := i + 1
|
|
end
|
|
end
|
|
|
|
escaped_json_string (s: READABLE_STRING_GENERAL): STRING_8
|
|
-- JSON string with '"' and '\' characters and unicode escaped
|
|
require
|
|
s_not_void: s /= Void
|
|
local
|
|
i, j, n: INTEGER
|
|
uc: CHARACTER_32
|
|
c: CHARACTER_8
|
|
h: STRING_8
|
|
do
|
|
n := s.count
|
|
create Result.make (n + n // 10)
|
|
from
|
|
i := 1
|
|
until
|
|
i > n
|
|
loop
|
|
uc := s.item (i)
|
|
if uc.is_character_8 then
|
|
c := uc.to_character_8
|
|
inspect c
|
|
when '%"' then
|
|
Result.append_string ("\%"")
|
|
when '\' then
|
|
Result.append_string ("\\")
|
|
when '/' then
|
|
-- To avoid issue with Javascript </script> ...
|
|
-- escape only </ to <\/
|
|
if s.valid_index (i - 1) and then s.item (i - 1) = '<' then
|
|
Result.append_string ("\/")
|
|
else
|
|
Result.append_string ("/")
|
|
end
|
|
when '%B' then
|
|
Result.append_string ("\b")
|
|
when '%F' then
|
|
Result.append_string ("\f")
|
|
when '%N' then
|
|
Result.append_string ("\n")
|
|
when '%R' then
|
|
Result.append_string ("\r")
|
|
when '%T' then
|
|
Result.append_string ("\t")
|
|
else
|
|
Result.extend (c)
|
|
end
|
|
else
|
|
Result.append ("\u")
|
|
h := uc.code.to_hex_string
|
|
-- Remove first 0 and keep 4 hexa digit
|
|
from
|
|
j := 1
|
|
until
|
|
h.count = 4 or (j <= h.count and then h.item (j) /= '0')
|
|
loop
|
|
j := j + 1
|
|
end
|
|
h := h.substring (j, h.count)
|
|
from
|
|
until
|
|
h.count >= 4
|
|
loop
|
|
h.prepend_integer (0)
|
|
end
|
|
check
|
|
hexastring_has_4_chars: h.count = 4
|
|
end
|
|
Result.append (h)
|
|
end
|
|
i := i + 1
|
|
end
|
|
end
|
|
|
|
invariant
|
|
item_not_void: item /= Void
|
|
|
|
note
|
|
copyright: "2010-2014, Javier Velilla and others https://github.com/eiffelhub/json."
|
|
license: "https://github.com/eiffelhub/json/blob/master/License.txt"
|
|
end
|