backup/EWF
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Cosmetic + Optimization + Assertion + Void-safety

Browse Source 
(no significant interface changes)
This commit is contained in:
jfiat
2009-03-18 15:29:41 +00:00
parent 1359a1ceae
commit 548a320448
13 changed files with 1367 additions and 1273 deletions
Download Patch File Download Diff File Expand all files Collapse all files

836
json/scanner/json_parser.e
View File

@@ -1,398 +1,438 @@
indexing
description: "Parse serialized JSON data"
author: "jvelilla"
date: "2008/08/24"
revision: "Revision 0.1"
class
JSON_PARSER
inherit
JSON_READER
JSON_TOKENS
create
make_parser
feature {NONE} -- Initialize
make_parser (a_json: STRING) is
-- Initialize.
require
json_not_empty: a_json /= Void and then not a_json.is_empty
do
make (a_json)
is_parsed := True
create current_errors.make_empty
end
feature -- Access
is_parsed: BOOLEAN
current_errors: STRING
feature -- Commands
parse_json: JSON_VALUE is
--
do
Result := parse
if extra_elements then
is_parsed := false
end
end
parse: JSON_VALUE is
--
local
c: CHARACTER
do
if is_parsed then
skip_withe_spaces
c := actual
if c.is_equal (j_object_open) then
Result := parse_object
elseif c.is_equal (j_string) then
Result := parse_string
elseif c.is_equal (j_array_open) then
Result := parse_array
elseif c.is_digit or c.is_equal (j_minus) then
Result := parse_number
elseif is_null then
--
Result := create {JSON_NULL}
next;next;next
elseif is_true then
Result := create {JSON_BOOLEAN}.make_boolean (true)
next;next;next
elseif is_false then
Result := create {JSON_BOOLEAN}.make_boolean (false)
next;next;next;next
else
is_parsed := false
current_errors.append ("JSON is not well formed in parse")
Result := void
end
end
end
parse_object: JSON_OBJECT is
-- object
-- {}
-- {"key" : "value" [,]}
local
has_more: BOOLEAN
l_json_string: JSON_STRING
l_value: JSON_VALUE
do
create Result.make
-- check if is an empty object {}
next
skip_withe_spaces
if actual.is_equal (j_object_close) then
--is an empty object
else
-- a complex object {"key" : "value"}
previous
from has_more := true until not has_more
loop
next
skip_withe_spaces
l_json_string := parse_string
next
skip_withe_spaces
if actual.is_equal (':') then
next
skip_withe_spaces
else
is_parsed := false
current_errors.append ("%N Input string is a not well formed JSON, expected: : found: " + actual.out +"%N")
has_more := false
end
l_value := parse
if is_parsed then
Result.put (l_value,l_json_string)
next
skip_withe_spaces
if actual.is_equal (j_object_close) then
has_more := false
elseif not actual.is_equal (',') then
has_more := false
is_parsed := false
current_errors.append ("JSON Object sintactically malformed expected , found: [" + actual.out + "] %N")
end
else
has_more := false
-- explain the error
end
end
end
end
parse_string: JSON_STRING is
--
local
has_more: BOOLEAN
l_json_string: STRING
l_unicode: STRING
do
create l_json_string.make_empty
if actual.is_equal (j_string) then
from
has_more := true
until not has_more
loop
next
if actual.is_equal (j_string) then
has_more := false
elseif actual.is_equal ('%H') then
next
if actual.is_equal ('u') then
create l_unicode.make_from_string ("\u")
l_unicode.append (read_unicode)
if is_a_valid_unicode (l_unicode) then
l_json_string.append (l_unicode)
else
has_more := false
is_parsed := false
current_errors.append ("Input String is not well formed JSON, expected a Unicode value, found [" + actual.out + " ] %N")
end
elseif (not special_characters.has (actual) and not special_controls.has (actual)) or actual.is_equal ('%N') then
has_more := false
is_parsed := false
current_errors.append ("Input String is not well formed JSON, found [" + actual.out + " ] %N")
else
l_json_string.append ("\")
l_json_string.append (actual.out)
end
else
if special_characters.has (actual) and not actual.is_equal ('/') then
has_more := false
is_parsed := false
current_errors.append ("Input String is not well formed JSON, found [" + actual.out + " ] %N")
else
l_json_string.append (actual.out)
end
end
end
create Result.make_json (l_json_string)
else
Result := void
end
end
parse_array: JSON_ARRAY is
-- array
-- []
-- [elements [,]]
local
flag: BOOLEAN
l_value: JSON_VALUE
do
create Result.make_array
--check if is an empty array []
next
skip_withe_spaces
if actual.is_equal (j_array_close) then
--is an empty array
else
previous
from
flag := true
until
not flag
loop
next
skip_withe_spaces
l_value := parse
if is_parsed then
Result.add (l_value)
next
skip_withe_spaces
if not actual.is_equal (j_array_close) and not actual.is_equal (',')then
flag := false
is_parsed := false
current_errors.append ("Array is not well formed JSON, found [" + actual.out + " ] %N")
elseif actual.is_equal (j_array_close) then
flag := false
end
else
flag := false
current_errors.append ("Array is not well formed JSON, found [" + actual.out + " ] %N")
end
end
end
end
parse_number: JSON_NUMBER is
--
local
sb: STRING
flag: BOOLEAN
is_integer: BOOLEAN
do
create sb.make_empty
sb.append (actual.out)
from
flag := true
until not flag
loop
next
if not has_next or close_tokens.has (actual) or actual.is_equal (',')
or actual.is_equal ('%N') or actual.is_equal ('%R') then
flag := false
previous
else
sb.append (actual.out)
end
end
if is_a_valid_number (sb) then
if sb.is_integer then
create Result.make_integer (sb.to_integer)
is_integer := true
elseif sb.is_double and not is_integer then
create Result.make_real (sb.to_double)
end
else
is_parsed := false
current_errors.append ("Expected a number, found: [ " + sb + " ]")
end
end
is_null: BOOLEAN is
--
local
l_null: STRING
l_string: STRING
do
l_null := "null"
l_string := json_substring (index,index + l_null.count - 1)
if l_string.is_equal (l_null) then
Result := true
end
end
is_false: BOOLEAN is
--
local
l_false: STRING
l_string: STRING
do
l_false := "false"
l_string := json_substring (index,index + l_false.count - 1)
if l_string.is_equal (l_false) then
Result := true
end
end
is_true: BOOLEAN is
--
local
l_true: STRING
l_string: STRING
do
l_true := "true"
l_string := json_substring (index,index + l_true.count - 1)
if l_string.is_equal (l_true) then
Result := true
end
end
read_unicode: STRING is
--
local
i: INTEGER
do
create Result.make_empty
from
i := 1
until i > 4 or not has_next
loop
next
Result.append (actual.out)
i := i + 1
end
end
feature {NONE} -- Implementation
is_a_valid_number (a_number: STRING): BOOLEAN is
-- is 'a_number' a valid number based on this regular expression
-- "-?(?: 0|[1-9]\d+)(?: \.\d+)?(?: [eE][+-]?\d+)?\b"?
local
word_set: RX_CHARACTER_SET
regexp: RX_PCRE_REGULAR_EXPRESSION
number_regex: STRING
do
create regexp.make
create word_set.make_empty
a_number.right_adjust
a_number.left_adjust
word_set.add_string ("0123456789.eE+-")
regexp.set_word_set (word_set)
number_regex := "-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?\b"
regexp.compile (number_regex)
if regexp.matches (a_number) then
if a_number.is_equal (regexp.captured_substring (0)) then
Result := true
end
end
end
is_a_valid_unicode (a_unicode: STRING): BOOLEAN is
-- is 'a_unicode' a valid unicode based on this regular expression
-- "\\u[0-9a-fA-F]{4}"
local
regexp: RX_PCRE_REGULAR_EXPRESSION
unicode_regex: STRING
do
create regexp.make
unicode_regex := "\\u[0-9a-fA-F]{4}"
regexp.compile (unicode_regex)
if regexp.matches (a_unicode) then
Result := true
check
is_valid: a_unicode.is_equal (regexp.captured_substring (0))
end
end
end
extra_elements: BOOLEAN is
--has more elements?
do
if has_next then
next
end
from
until
not actual.is_equal (' ') or not actual.is_equal ('%R') or
not actual.is_equal ('%U') or not actual.is_equal ('%T')
or not actual.is_equal ('%N') or not has_next
loop
next
end
if has_next then
Result := True
end
end
end
indexing
description: "Parse serialized JSON data"
author: "jvelilla"
date: "2008/08/24"
revision: "Revision 0.1"
class
JSON_PARSER
inherit
JSON_READER
JSON_TOKENS
create
make_parser
feature {NONE} -- Initialize
make_parser (a_json: STRING) is
-- Initialize.
require
json_not_empty: a_json /= Void and then not a_json.is_empty
do
make (a_json)
is_parsed := True
create errors.make
end
feature -- Status report
is_parsed: BOOLEAN
-- Is parsed?
errors: LINKED_LIST [STRING]
-- Current errors
current_errors: STRING
-- Current errors as string
do
create Result.make_empty
from
errors.start
until
errors.after
loop
Result.append_string (errors.item + "%N")
errors.forth
end
end
feature -- Element change
report_error (e: STRING) is
-- Report error `e'
require
e_not_void: e /= Void
do
errors.force (e)
end
feature -- Commands
parse_json: ?JSON_VALUE is
-- Parse JSON data `representation'
do
Result := parse
if extra_elements then
is_parsed := False
end
end
parse: ?JSON_VALUE is
-- Parse JSON data `representation'
local
c: CHARACTER
do
if is_parsed then
skip_white_spaces
c := actual
inspect c
when j_OBJECT_OPEN then
Result := parse_object
when j_STRING then
Result := parse_string
when j_ARRAY_OPEN then
Result := parse_array
else
if c.is_digit or c = j_MINUS then
Result := parse_number
elseif is_null then
Result := create {JSON_NULL}
next
next
next
elseif is_true then
Result := create {JSON_BOOLEAN}.make_boolean (True)
next
next
next
elseif is_false then
Result := create {JSON_BOOLEAN}.make_boolean (False)
next
next
next
next
else
is_parsed := False
report_error ("JSON is not well formed in parse")
Result := Void
end
end
end
ensure
is_parsed_implies_result_not_void: is_parsed implies Result /= Void
end
parse_object: JSON_OBJECT is
-- object
-- {}
-- {"key" : "value" [,]}
local
has_more: BOOLEAN
l_json_string: ?JSON_STRING
l_value: ?JSON_VALUE
do
create Result.make
-- check if is an empty object {}
next
skip_white_spaces
if actual = j_OBJECT_CLOSE then
--is an empty object
else
-- a complex object {"key" : "value"}
previous
from has_more := True until not has_more loop
next
skip_white_spaces
l_json_string := parse_string
next
skip_white_spaces
if actual = ':' then
next
skip_white_spaces
else
is_parsed := False
report_error ("%N Input string is a not well formed JSON, expected: : found: " + actual.out)
has_more := False
end
l_value := parse
if is_parsed and then (l_value /= Void and l_json_string /= Void) then
Result.put (l_value, l_json_string)
next
skip_white_spaces
if actual = j_OBJECT_CLOSE then
has_more := False
elseif actual /= ',' then
has_more := False
is_parsed := False
report_error ("JSON Object syntactically malformed expected , found: [" + actual.out + "]")
end
else
has_more := False
-- explain the error
end
end
end
end
parse_string: ?JSON_STRING is
-- Parsed string
local
has_more: BOOLEAN
l_json_string: STRING
l_unicode: STRING
c: like actual
do
create l_json_string.make_empty
if actual = j_STRING then
from
has_more := True
until
not has_more
loop
next
c := actual
if c = j_STRING then
has_more := False
elseif c = '%H' then
next
c := actual
if c = 'u' then
create l_unicode.make_from_string ("\u")
l_unicode.append (read_unicode)
c := actual
if is_a_valid_unicode (l_unicode) then
l_json_string.append (l_unicode)
else
has_more := False
is_parsed := False
report_error ("Input String is not well formed JSON, expected a Unicode value, found [" + c.out + " ]")
end
elseif (not is_special_character (c) and not is_special_control (c)) or c = '%N' then
has_more := False
is_parsed := False
report_error ("Input String is not well formed JSON, found [" + c.out + " ]")
else
l_json_string.append ("\")
l_json_string.append (c.out)
end
else
if is_special_character (c) and c /= '/' then
has_more := False
is_parsed := False
report_error ("Input String is not well formed JSON, found [" + c.out + " ]")
else
l_json_string.append_character (c)
end
end
end
create Result.make_json (l_json_string)
else
Result := Void
end
end
parse_array: JSON_ARRAY is
-- array
-- []
-- [elements [,]]
local
flag: BOOLEAN
l_value: ?JSON_VALUE
c: like actual
do
create Result.make_array
--check if is an empty array []
next
skip_white_spaces
if actual = j_array_close then
--is an empty array
else
previous
from
flag := True
until
not flag
loop
next
skip_white_spaces
l_value := parse
if is_parsed and then l_value /= Void then
Result.add (l_value)
next
skip_white_spaces
c := actual
if c = j_ARRAY_CLOSE then
flag := False
elseif c /= ',' then
flag := False
is_parsed := False
report_error ("Array is not well formed JSON, found [" + c.out + " ]")
end
else
flag := False
report_error ("Array is not well formed JSON, found [" + actual.out + " ]")
end
end
end
end
parse_number: ?JSON_NUMBER is
-- Parsed number
local
sb: STRING
flag: BOOLEAN
is_integer: BOOLEAN
c: like actual
do
create sb.make_empty
sb.append_character (actual)
from
flag := True
until
not flag
loop
next
c := actual
if not has_next or is_close_token (c)
or c = ',' or c = '%N' or c = '%R'
then
flag := False
previous
else
sb.append_character (c)
end
end
if is_a_valid_number (sb) then
if sb.is_integer then
create Result.make_integer (sb.to_integer)
is_integer := True
elseif sb.is_double and not is_integer then
create Result.make_real (sb.to_double)
end
else
is_parsed := False
report_error ("Expected a number, found: [ " + sb + " ]")
end
end
is_null: BOOLEAN is
-- Word at index represents null?
local
l_null: STRING
l_string: STRING
do
l_null := null_id
l_string := json_substring (index,index + l_null.count - 1)
if l_string.is_equal (l_null) then
Result := True
end
end
is_false: BOOLEAN is
-- Word at index represents false?
local
l_false: STRING
l_string: STRING
do
l_false := false_id
l_string := json_substring (index, index + l_false.count - 1)
if l_string.is_equal (l_false) then
Result := True
end
end
is_true: BOOLEAN is
-- Word at index represents true?
local
l_true: STRING
l_string: STRING
do
l_true := true_id
l_string := json_substring (index,index + l_true.count - 1)
if l_string.is_equal (l_true) then
Result := True
end
end
read_unicode: STRING is
-- Read unicode and return value
local
i: INTEGER
do
create Result.make_empty
from
i := 1
until
i > 4 or not has_next
loop
next
Result.append_character (actual)
i := i + 1
end
end
feature {NONE} -- Implementation
is_a_valid_number (a_number: STRING): BOOLEAN is
-- is 'a_number' a valid number based on this regular expression
-- "-?(?: 0|[1-9]\d+)(?: \.\d+)?(?: [eE][+-]?\d+)?\b"?
local
word_set: RX_CHARACTER_SET
regexp: RX_PCRE_REGULAR_EXPRESSION
number_regex: STRING
do
create regexp.make
create word_set.make_empty
a_number.right_adjust
a_number.left_adjust
word_set.add_string ("0123456789.eE+-")
regexp.set_word_set (word_set)
number_regex := "-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?\b"
regexp.compile (number_regex)
if regexp.matches (a_number) then
Result := a_number.is_equal (regexp.captured_substring (0))
end
end
is_a_valid_unicode (a_unicode: STRING): BOOLEAN is
-- is 'a_unicode' a valid unicode based on this regular expression
-- "\\u[0-9a-fA-F]{4}"
local
regexp: RX_PCRE_REGULAR_EXPRESSION
unicode_regex: STRING
do
create regexp.make
unicode_regex := "\\u[0-9a-fA-F]{4}"
regexp.compile (unicode_regex)
if regexp.matches (a_unicode) then
Result := True
check
is_valid: a_unicode.is_equal (regexp.captured_substring (0))
end
end
end
extra_elements: BOOLEAN is
-- has more elements?
local
c: like actual
do
if has_next then
next
end
from
c := actual
until
c /= ' ' or c /= '%R' or c /= '%U' or c /= '%T' or c /= '%N' or not has_next
loop
next
end
Result := has_next
end
feature {NONE} -- Constants
false_id: STRING is "false"
true_id: STRING is "false"
null_id: STRING is "null"
end

226
json/scanner/json_reader.e
View File

@@ -1,116 +1,110 @@
indexing
description: "Objects that ..."
author: "jvelilla"
date: "2008/08/24"
revision: "0.1"
class
JSON_READER
create
make
feature -- Initialization
make (a_json: STRING) is
--
do
representation := a_json
index := 1
end
feature -- Commands
read: CHARACTER is
--
do
if not representation.is_empty then
Result := representation.item (index)
end
end
has_next: BOOLEAN is
--
do
if index <= representation.count then
Result := True
end
end
has_previous: BOOLEAN is
--
do
if index >=1 then
Result := True
end
end
next is
--
require
has_more_elements: has_next
do
index := index + 1
ensure
incremented: old index + 1 = index
end
previous is
--
require
not_is_first: has_previous
do
index := index - 1
ensure
incremented: old index - 1 = index
end
skip_withe_spaces is
-- Remove withe spaces
do
from
until (actual /= ' ' and actual /= '%N' and actual /= '%R') or not has_next
loop
next
end
end
json_substring (start_index, end_index: INTEGER_32): STRING is
--
do
Result := representation.substring (start_index, end_index)
end
feature -- Access
representation: STRING
-- Serialized representation of the original JSON string
feature {NONE} -- Implementation
actual: CHARACTER is
-- Current character or '%U' if none
do
if index > representation.count then
Result := '%U'
else
Result := representation.item (index)
end
end
index: INTEGER
-- Actual index
invariant
representation_not_void: representation /= Void
end
indexing
description: "Objects that ..."
author: "jvelilla"
date: "2008/08/24"
revision: "0.1"
class
JSON_READER
create
make
feature {NONE} -- Initialization
make (a_json: STRING) is
-- Initialize Reader
do
representation := a_json
index := 1
end
feature -- Commands
read: CHARACTER is
-- Read character
do
if not representation.is_empty then
Result := representation.item (index)
end
end
next is
-- Move to next index
require
has_more_elements: has_next
do
index := index + 1
ensure
incremented: old index + 1 = index
end
previous is
-- Move to previous index
require
not_is_first: has_previous
do
index := index - 1
ensure
incremented: old index - 1 = index
end
skip_white_spaces is
-- Remove white spaces
local
c: like actual
do
from
c := actual
until
(c /= ' ' and c /= '%N' and c /= '%R') or not has_next
loop
next
c := actual
end
end
json_substring (start_index, end_index: INTEGER_32): STRING is
-- JSON representation between `start_index' and `end_index'
do
Result := representation.substring (start_index, end_index)
end
feature -- Status report
has_next: BOOLEAN is
-- Has a next character?
do
Result := index <= representation.count
end
has_previous: BOOLEAN is
-- Has a previous character?
do
Result := index >= 1
end
feature -- Access
representation: STRING
-- Serialized representation of the original JSON string
feature {NONE} -- Implementation
actual: CHARACTER is
-- Current character or '%U' if none
do
if index > representation.count then
Result := '%U'
else
Result := representation.item (index)
end
end
index: INTEGER
-- Actual index
invariant
representation_not_void: representation /= Void
end

130
json/scanner/json_tokens.e
View File

@@ -1,53 +1,77 @@
indexing
description: ""
author: "jvelilla"
date: "2008/08/24"
revision: "0.1"
class
JSON_TOKENS
feature -- Access
J_OBJECT_OPEN:CHARACTER is '{'
J_ARRAY_OPEN:CHARACTER is '['
J_OBJECT_CLOSE:CHARACTER is '}'
J_ARRAY_CLOSE:CHARACTER is ']'
J_STRING:CHARACTER is '"'
J_PLUS:CHARACTER is '+'
J_MINUS:CHARACTER is '-'
J_DOT:CHARACTER is '.'
open_tokens:ARRAY[CHARACTER] is
-- Characters wich open a type
once
Result:=<<J_OBJECT_OPEN,J_ARRAY_OPEN,J_STRING,J_PLUS,J_MINUS,J_DOT>>
end
close_tokens:ARRAY[CHARACTER] is
-- Characters wich close a type
once
Result:=<<J_OBJECT_CLOSE,J_ARRAY_CLOSE,J_STRING >>
end
special_characters:ARRAY[CHARACTER] is
-- Control Characters
-- %F Form feed
-- %H backslasH
-- %N Newline
-- %R carriage Return
-- %T horizontal Tab
-- %B Backspace
-- / Solidus
-- " Quotation
do
Result:=<<'%F','%H','%N','%R','%T','%B','/','"'>>
end
special_controls:ARRAY[CHARACTER] is
--Control Characters
-- \b\f\n\r\t
do
Result:=<<'b','f','n','r','t'>>
end
end
indexing
description: ""
author: "jvelilla"
date: "2008/08/24"
revision: "0.1"
class
JSON_TOKENS
feature -- Access
j_OBJECT_OPEN: CHARACTER is '{'
j_ARRAY_OPEN: CHARACTER is '['
j_OBJECT_CLOSE: CHARACTER is '}'
j_ARRAY_CLOSE: CHARACTER is ']'
j_STRING: CHARACTER is '"'
j_PLUS: CHARACTER is '+'
j_MINUS: CHARACTER is '-'
j_DOT: CHARACTER is '.'
feature -- Status report
is_open_token (c: CHARACTER): BOOLEAN is
-- Characters which open a type
do
inspect c
when j_OBJECT_OPEN, j_ARRAY_OPEN, j_STRING, j_PLUS, j_MINUS, j_DOT then
Result := True
else
end
end
is_close_token (c: CHARACTER): BOOLEAN is
-- Characters which close a type
do
inspect c
when j_OBJECT_CLOSE, j_ARRAY_CLOSE, j_STRING then
Result := True
else
end
end
is_special_character (c: CHARACTER): BOOLEAN is
-- Control Characters
-- %F Form feed
-- %H backslasH
-- %N Newline
-- %R carriage Return
-- %T horizontal Tab
-- %B Backspace
-- / Solidus
-- " Quotation
do
inspect c
when '%F', '%H', '%N', '%R', '%T', '%B', '/', '"' then
Result := True
else
end
end
is_special_control (c: CHARACTER): BOOLEAN is
--Control Characters
-- \b\f\n\r\t
do
inspect c
when 'b', 'f', 'n', 'r', 't' then
Result := True
else
end
end
end