2020-04-23 00:25:11 +02:00
|
|
|
class CBOR::Decoder
|
|
|
|
@lexer : Lexer
|
2020-04-24 23:43:57 +02:00
|
|
|
getter current_token : Token::T?
|
2020-04-23 00:25:11 +02:00
|
|
|
|
|
|
|
def initialize(input)
|
|
|
|
@lexer = Lexer.new(input)
|
|
|
|
@current_token = @lexer.next_token
|
|
|
|
end
|
|
|
|
|
|
|
|
def read_string : String
|
|
|
|
case token = @current_token
|
|
|
|
when Token::StringT
|
|
|
|
finish_token!
|
|
|
|
token.value
|
|
|
|
when Token::BytesT
|
|
|
|
finish_token!
|
|
|
|
String.new(token.value)
|
|
|
|
else
|
|
|
|
unexpected_token(token, "StringT or BytesT")
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
def read_int
|
|
|
|
read_type(Token::IntT) { |token| token.value }
|
|
|
|
end
|
|
|
|
|
2020-04-24 15:59:16 +02:00
|
|
|
def read_float
|
|
|
|
read_type(Token::FloatT) { |token| token.value }
|
|
|
|
end
|
|
|
|
|
|
|
|
def read_num
|
|
|
|
case token = @current_token
|
|
|
|
when Token::IntT, Token::FloatT
|
|
|
|
token.value
|
|
|
|
else
|
|
|
|
unexpected_token(token, "Token::IntT or Token::FloatT")
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2020-04-23 00:25:11 +02:00
|
|
|
def read_bytes
|
|
|
|
read_type(Token::BytesT) { |token| token.value }
|
|
|
|
end
|
|
|
|
|
2020-04-24 15:59:16 +02:00
|
|
|
def read_tag : Tag
|
2020-04-24 22:46:07 +02:00
|
|
|
read_type(Token::TagT, ignore_tag: false) { |token| token.value }
|
2020-04-24 15:59:16 +02:00
|
|
|
end
|
|
|
|
|
|
|
|
def read_bool : Bool
|
|
|
|
read_type(Token::SimpleValueT) do |token|
|
|
|
|
case token.value
|
|
|
|
when SimpleValue::False
|
|
|
|
false
|
|
|
|
when SimpleValue::True
|
|
|
|
true
|
|
|
|
else
|
|
|
|
unexpected_token(token, "SimpleValue::True or SimpleValue::False")
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2020-04-24 22:50:48 +02:00
|
|
|
def read_nil : Nil
|
|
|
|
read_type(Token::SimpleValueT) do |token|
|
|
|
|
case token.value
|
|
|
|
when SimpleValue::Null,
|
|
|
|
SimpleValue::Undefined
|
|
|
|
nil
|
|
|
|
else
|
|
|
|
unexpected_token(token, "SimpleValue::Null or SimpleValue::Undefined")
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2020-04-24 23:43:57 +02:00
|
|
|
def consume_array(&block)
|
|
|
|
read_type(Token::ArrayT, finish_token: false) do |token|
|
|
|
|
read(token.size) { yield }
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2020-04-25 17:27:01 +02:00
|
|
|
def consume_hash(&block)
|
|
|
|
read_type(Token::MapT, finish_token: false) do |token|
|
|
|
|
read(token.size) { yield }
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2020-04-23 00:25:11 +02:00
|
|
|
private def finish_token!
|
|
|
|
@current_token = @lexer.next_token
|
|
|
|
end
|
|
|
|
|
2020-04-25 17:27:01 +02:00
|
|
|
private def read(size : Int32?, &block)
|
2020-04-24 23:43:57 +02:00
|
|
|
if size
|
2020-04-25 17:27:01 +02:00
|
|
|
finish_token!
|
2020-04-24 23:43:57 +02:00
|
|
|
size.times { yield }
|
|
|
|
else
|
|
|
|
@lexer.until_break do |token|
|
|
|
|
@current_token = token
|
|
|
|
yield
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2020-04-24 15:59:16 +02:00
|
|
|
private macro read_type(type, finish_token = true, ignore_tag = true, &block)
|
|
|
|
# Skip the tag unless the token we want to read is a tag
|
2020-04-24 22:46:07 +02:00
|
|
|
{% if ignore_tag %}
|
2020-04-24 15:59:16 +02:00
|
|
|
if @current_token.is_a?(Token::TagT)
|
|
|
|
finish_token!
|
|
|
|
end
|
|
|
|
{% end %}
|
|
|
|
|
2020-04-23 00:25:11 +02:00
|
|
|
case token = @current_token
|
|
|
|
when {{type}}
|
|
|
|
{% if finish_token %}finish_token!{% end %}
|
|
|
|
{{ block.body }}
|
|
|
|
else
|
|
|
|
unexpected_token(token, {{type.stringify.split("::").last}})
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
private def unexpected_token(token, expected = nil)
|
|
|
|
message = "Unexpected token #{token.class}"
|
|
|
|
message += " expected #{expected}" if expected
|
|
|
|
raise ParseError.new(message)
|
|
|
|
end
|
|
|
|
end
|