slow_blink 0.0.6 → 0.0.7

data/lib/slow_blink/definition.rb

@@ -24,68 +24,33 @@ module SlowBlink
 
     class Definition
 
-        include Annotatable
-
-        def self.===(other)
-            self == other                
-        end
+        # @return [Type] defined type
+        attr_reader :type
 
         # @macro location
         attr_reader :location
 
-        # @return [NameWithID]
-        attr_reader :nameWithID
+        # @return [String]
+        attr_reader :name
 
-        # @return [Type,ENUMERATION]
-        attr_reader :type
+        # @return [Integer,nil]
+        attr_reader :id
 
-        # @param namespace [Namespace]
-        def namespace=(namespace)
-            @ns = namespace
-        end
-
-        # @param nameWithID [NameWithID]
-        # @param type [ENUMERATION, Type]
-        # @param location [String]
-        def initialize(nameWithID, type, location)
-            @annotes = {}
-            @type = type
-            @location = location
-            @nameWithID = nameWithID
-            @ns = nil
+        def self.===(other)
+            self == other                
         end
 
-        # @api private
-        # Resolve references, enforce constraints, and detect cycles
-        #
-        # @param schema [Schema] schema this definition belongs to
-        # @param stack [nil, Array] objects that depend on this object
-        # @return [true,false] linked?
-        def link(schema, stack=[])
-                     
-            # a definition can resolve to a definition only if there is a dynamic
-            # link somewhere in the chain
-            sf = stack.each
-            begin
-                loop do
-                    if sf.next == self
-                        loop do
-                            begin
-                                f = sf.next
-                                if f.respond_to? "dynamic?".to_sym and f.dynamic?
-                                    return schema
-                                end
-                            rescue StopIteration
-                                raise ParseError.new "#{self.location}: error: invalid cycle detected"
-                            end                                   
-                        end
-                    end
-                end
-            rescue StopIteration
+        # @private
+        def initialize(attr)
+            @location = attr[:loc].freeze
+            @ns = attr[:ns].freeze
+            @name = attr[:name][:name].dup
+            if @ns
+                @name.prepend "#{@ns}::"
             end
-
-            @type.link(schema, @ns, stack << self)
-            
+            @name.freeze
+            @id = attr[:name][:id]
+            @type = SlowBlink.const_get(attr[:type][:class]).new(attr[:type].merge({:table => attr[:table], :ns => attr[:ns], :name => @name}))
         end
 
     end

data/lib/slow_blink/dynamic_group.rb

@@ -0,0 +1,8 @@
+module SlowBlink
+    class DynamicGroup < StaticGroup
+        # @return [Array<Group>] groups that are compatible with this dynamic group
+        def groups
+            @table.values.select{|d|d.is_a? Group and d.id and (d.ancestors.include? @group or d == @group)}
+        end        
+    end
+end

data/lib/slow_blink/enum.rb

@@ -0,0 +1,101 @@
+# @license 
+#   
+#   Copyright (c) 2016 Cameron Harper
+#     
+#   Permission is hereby granted, free of charge, to any person obtaining a copy of
+#   this software and associated documentation files (the "Software"), to deal in
+#   the Software without restriction, including without limitation the rights to
+#   use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+#   the Software, and to permit persons to whom the Software is furnished to do so,
+#   subject to the following conditions:
+#   
+#   The above copyright notice and this permission notice shall be included in all
+#   copies or substantial portions of the Software.
+# 
+#   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+#   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+#   FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+#   COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+#   IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+#   CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+module SlowBlink
+
+    class ENUM < Type
+
+        def self.===(other)
+            self == other                
+        end
+
+        # @return [Array<Sym>]
+        def symbols
+            @symbols.values
+        end
+
+        # @return [String]
+        attr_reader :name
+
+        # @private
+        def initialize(attr)
+
+            @location = attr[:loc]
+            @symbols = {}
+            @name = attr[:name].dup.freeze
+
+            attr[:syms].each do |s|
+
+                if @symbols[s[:name]]
+                    raise ParseError.new "#{s[:loc]}: duplicate symbol name"
+                else
+                    if s[:value]
+                        if s[:value] < 2147483647 and s[:value] > -2147483648                            
+                            if @symbols.values.last
+                                if @symbols.values.map{|sym|sym.value}.include? s[:value]
+                                    raise ParseError.new "#{s[:loc]}: ambiguous enum value"
+                                else
+                                    @symbols[s[:name]] = Sym.new(s)                    
+                                end
+                            else
+                                @symbols[s[:name]] = Sym.new(s)
+                            end
+                        else
+                            raise ParseError.new "#{s[:loc]}: value out of range for an enum"
+                        end                        
+                    else
+                        if @symbols.values.last
+                            if (@symbols.values.last.value + 1) < 2147483647
+                                if @symbols.values.map{|sym|sym.value}.include? s[:value]
+                                    raise ParseError.new "#{s[:loc]}: ambiguous enum value"
+                                else
+                                    @symbols[s[:name]] = Sym.new(s.merge({:implicit => true, :value => @symbols.values.last.value + 1}))
+                                end                                
+                            else
+                                raise ParseError.new "#{s[:loc]}: implicit value out of range for an enum"
+                            end
+                        else
+                            @symbols[s[:name]] = Sym.new(s.merge({:implicit => true, :value => 0}))
+                        end
+                    end
+                end
+
+            end        
+            
+        end
+
+        # @param nameOrVal [String,Integer]
+        # @raise [RangeError] nameOrVal does not resolve to a symbol
+        # @return [Sym]
+        def symbol(nameOrVal)
+            if nameOrVal.kind_of? String
+                if (result = @symbols[nameOrVal]).nil?
+                    raise RangeError
+                end
+            else
+                if (result = @symbols.values.detect{|s|s.value == nameOrVal.to_i}).nil?
+                    raise RangeError
+                end
+            end
+        end
+
+    end
+end

data/lib/slow_blink/field.rb

@@ -23,50 +23,80 @@
 module SlowBlink
 
     class Field
-        
-        include Annotatable
+
+        # @param [Integer]
+        attr_reader :id
+
+        # @param [String]
+        attr_reader :name
 
         # @macro location
         attr_reader :location
 
         # @return [Type]
-        attr_reader :type
+        def type
+            result = nil
+            if @type.is_a? REF
+        
+                ptr = @type.resolve
+                stack = []
+                sequence = @type.sequence?
+                dynamic = @type.dynamic?
 
-        # @return [NameWithID]
-        attr_reader :nameWithID
+                while ptr and ptr.is_a? Definition and ptr.type.is_a? REF do
 
-        # @return [true] field is optional
-        # @return [false] field is mandatory
-        def opt?
-            @opt
+                    if stack.include? ptr
+                        raise ParseError.new "#{ptr.location}: circular reference detected"
+                    else
+                        if ptr.type.dynamic?
+                            # assumption: double dynamic is still dynamic
+                            dynamic = true
+                        end
+                        if ptr.type.sequence?
+                            if sequence
+                                raise ParseError.new "#{ptr.location}: sequence of sequences detected while resolving from '#{@type.location}'"
+                            end
+                            sequence = true                            
+                        end
+                        stack << ptr
+                        ptr = ptr.type.resolve
+                    end
+                end
+
+                if ptr.nil?
+                    if stack.size == 0
+                        stack << @type
+                    end
+                    raise ParseError.new "#{stack.last.location}: reference does not resolve"
+                elsif ptr.is_a? Group
+                    if dynamic
+                        result = DynamicGroup.new(:group => ptr, :sequence => sequence, :table => @table)
+                    else
+                        result = StaticGroup.new(:group => ptr, :sequence => sequence, :table => @table)
+                    end
+                else
+                    result = ptr.type
+                end
+            else
+                result = @type
+            end
+
+            result
         end
 
-        # @param nameWithID [NameWithID]
-        # @param type   [Type]
-        # @param opt    [true,false] field is optional?
-        # @param location [String]
-        def initialize(nameWithID, type, opt, location)
-            @annotes = {}
-            @schema = nil
-            @type = type
-            @opt = opt
-            @location = location
-            @nameWithID = nameWithID
+        # @return [true,false]
+        def optional?
+            @optional
         end
 
-        # @api private
-        #
-        # Resolve references, enforce constraints, and detect cycles
-        #
-        # @param schema [Schema] schema this definition belongs to
-        # @param ns [Namespace] namespace this definition belongs to
-        # @param stack [nil, Array] objects that depend on this object
-        # @return [true,false] linked?
-        def link(schema,ns, stack=[])
-            if @schema.nil?
-                @schema = @type.link(schema, ns, stack << self)
-            end
-            @schema
+        # @private
+        def initialize(attr)        
+            @name = attr[:name][:name].freeze
+            @id = attr[:name][:id]
+            @optional = attr[:opt]
+            @location = attr[:location].freeze
+            @type = SlowBlink.const_get(attr[:type][:class]).new(attr[:type].merge({:table => attr[:table], :ns => attr[:ns]}))
+            @table = attr[:table]
         end
         
     end

data/lib/slow_blink/generate_c/model.rb

@@ -0,0 +1,89 @@
+require 'erb'
+
+module SlowBlink
+
+    module GenerateC
+
+        include SlowBlink
+
+        class Model
+
+            def initialize(schema)
+                @schema = schema
+                @prefix = ""
+                @options = {}
+            end
+
+            def render
+                header = put("groups.h.erb")
+                source = put("groups.c.erb")
+
+                File.write("groups.h", header)
+                File.write("groups.c", source)
+            end            
+
+            private
+
+                def put(filename)
+                    f = File.read(File.expand_path(File.join(File.dirname(__FILE__), filename)))
+                    erb = ERB.new(f, nil, "<>-")
+                    erb.filename = filename
+                    erb.result(binding)
+                end
+
+                def gname(g)
+                    "#{@prefix}#{g.name.gsub("::","_")}"
+                end
+
+                def fname(f)
+                    "_#{f.name}"
+                end
+
+                def value_type(type)
+
+                    out = ""
+
+                    case type.class
+                    when BINARY, STRING, FIXED
+                        out << "struct blink_string"
+                    when U8
+                        out << "uint8_t"                
+                    when U16
+                        out << "uint16_t"                
+                    when U32
+                        out << "uint32_t"                
+                    when U64
+                        out << "uint64_t"                
+                    when I8
+                        out << "int8_t"                
+                    when I16
+                        out << "int16_t"                
+                    when I32
+                        out << "int32_t"                
+                    when I64
+                        out << "int64_t"
+                    when ENUM
+                        out << "const char *"
+                    when FLOATING_POINT
+                        out << "double"                
+                    when DECIMAL
+                        out << "struct blink_decimal"
+                    when BOOLEAN
+                        out << "bool"                    
+                    when StaticGroup
+                        out << "struct #{cname(type.name)} *"
+                    when OBJECT, DynamicGroup
+                        out << "struct base_group *"
+                    else
+                        raise 
+                    end
+
+                    out
+                end
+
+        end
+
+    end
+
+
+end

data/lib/slow_blink/group.rb

@@ -24,133 +24,152 @@ module SlowBlink
 
     class Group
 
-        include Annotatable
-
         def self.===(other)
             self == other                
         end
 
-        # @macro location
-        attr_reader :location
+        # @return [Integer,nil]
+        attr_reader :id
 
-        # @return [NameWithID]
-        attr_reader :nameWithID
+        # @return [String] qualified name
+        attr_reader :name
 
+        # @macro location
+        attr_reader :location
+        
         # @return [Array<Field>]
         def fields
-            @fields.values
-        end
 
-        # @param namespace [Namespace]
-        def namespace=(namespace)
-            @ns = namespace
+            # collect all ancestors
+            ancestors = []
+            ptr = superGroup
+            while ptr do
+                ancestors.unshift ptr
+                ptr = ptr.superGroup
+            end
+
+            result = {}
+
+            ancestors.each do |g|
+                g.rawFields.each do |f|
+                    result[f.name] = f                    
+                end
+            end
+
+            @fields.each do |fn, fv|
+                if result[fn]
+                    raise ParseError.new "#{fv.location}: field name shadowed by supergroup"
+                else
+                    result[fn] = fv
+                end
+            end
+
+            result.values
         end
 
-        # @param nameWithID [NameWithID]
-        # @param superGroup [REF, nil]
-        # @param fields [Array<Field>]
-        # @param location [String]
-        def initialize(nameWithID, superGroup, fields, location)
-            @annotes = {}
-            @schema = nil
-            @superGroup = superGroup
-            @rawFields = fields
-            @location = location
-            @fields = []
-            @nameWithID = nameWithID
-            @ns = nil
+        # @return [Array<Group>] super groups in order of most super
+        def ancestors
+            result = []
+            ptr = superGroup
+            while ptr do
+                result << ptr
+                ptr = ptr.superGroup
+            end
+            result
         end
 
-        # @api private
-        #
-        # Resolve references, enforce constraints, and detect cycles
-        #
-        # @param schema [Schema] schema this definition belongs to
-        # @param stack [nil, Array] objects that depend on this object
-        # @return [true,false] linked?
-        def link(schema,stack=[])
-            
-            if @schema.nil?
-
-                # a definition can resolve to a definition only if there is a dynamic
-                # link somewhere in the chain
-                sf = stack.each
-                begin
-                    loop do
-                        if sf.next == self
-                            loop do
-                                begin
-                                    f = sf.next
-                                    if f.respond_to? "dynamic?".to_sym and f.dynamic?
-                                        return schema
-                                    end
-                                rescue StopIteration
-                                    raise ParseError.new "#{self.location}: error: invalid cycle detected"
-                                end
+        # @return [Group,nil]
+        def superGroup
+
+            result = nil
+
+            if @super
+
+                ptr = @super.resolve
+                stack = []
+                sequence = false
+                dynamic = false
+
+                while ptr and ptr.is_a? Definition and ptr.type.is_a? REF do
+
+                    if stack.include? ptr
+                        raise ParseError.new "#{@super.location}: supergoup circular reference"
+                    else
+                        if ptr.type.dynamic?
+                            dynamic = true
+                        end
+                        if ptr.type.sequence?
+                            if sequence
+                                raise ParseError.new "#{@super.location}: sequence of sequence detected at '#{ptr.type.location}'"
                             end
+                            sequence = true                            
                         end
+                        stack << ptr
+                        ptr = ptr.type.resolve                        
                     end
-                rescue StopIteration
                 end
 
-                error = false
-                @fields = {}
-                if !@superGroup or (@superGroup and @superGroup.link(schema, @ns, stack << self))                    
-                    if !@superGroup or @superGroup.ref.is_a?(Group)
-                        if @superGroup
-                            if @superGroup.dynamic_reference?
-                                Log.error "#{@superGroup.location}: error: reference to supergroup must not be dynamic"
-                                error = true                                
-                            else
-                                @superGroup.ref.fields.each do |f|
-                                    @fields[f.nameWithID.name] = f
-                                end
-                            end
-                        end
-                        if !error
-                            @rawFields.each do |f|
-                                if @fields[f.nameWithID.name]
-                                    Log.error "#{f.location}: error: field names must be unique within a group ('#{f.nameWithID.name}' first appears at #{@fields[f.nameWithID.name].location})"
-                                    error = true
-                                else
-                                    if f.link(schema, @ns, stack.dup << self)                                    
-                                        @fields[f.nameWithID.name] = f
-                                    else
-                                        error = true
-                                    end
-                                end
-                            end
-                        end
-                    else
-                        Log.error "#{@superGroup.location}: error: reference to supergroup must resolve to group definition"
-                        error = true
+                if ptr.nil?
+                    raise ParseError.new "#{@super.location}: supergroup reference '#{@super.ref}' does not resolve"
+                elsif ptr.is_a? Definition
+                    if dynamic
+                        raise ParseError.new "#{@super.location}: supergroup reference cannot resolve dynamic reference to a #{ptr.type.class} makes no sense"
                     end
+                    raise ParseError.new "#{@super.location}: supergroup reference must resolve to a group"
                 else
-                    error = true
+                    if dynamic
+                        raise ParseError.new "#{@super.location}: supergroup reference cannot be dynamic"
+                    end
+                    if sequence
+                        raise ParseError.new "#{@super.location}: supergroup reference cannot be a sequence"
+                    end
+                    if ptr == self
+                        raise ParseError.new "#{@super.location}: supergroup cannot be own group"
+                    end
+                    result = ptr
+                end
+            end
+
+            result
+        end
+
+        # @private
+        def initialize(attr)
+
+            @ns = attr[:ns].freeze
+            @name = attr[:name][:name].dup
+            if @ns
+                @name.prepend "#{@ns}::"
+            end
+            @name.freeze 
+            @id = attr[:name][:id]
+            @location = attr[:name][:loc].freeze
+            @fields = {}
+
+            if attr[:super]
+                @super = REF.new(attr[:super].merge(:table=>attr[:table], :ns=>attr[:ns]))
+                if @super.ref == @name or @super.ref.split("::").last == @name
+                    raise ParseError.new "#{@location}: supergroup cannot be own group"
                 end
+            else
+                @super = nil
+            end
 
-                if !error
-                    @schema = schema
+            attr[:fields].each do |f|
+                if @fields[f[:name][:name]]
+                    raise ParseError.new "#{f[:location]}: duplicate field name"
+                else
+                    @fields[f[:name][:name]] = Field.new(f.merge({:table => attr[:table], :ns => attr[:ns]}))
                 end
-                
             end
-            
-            @schema
-        end
 
-        # @param name [String] name of field
-        # @return [Field] field exists
-        # @return [nil] field does not exist
-        def field(name)
-            @fields[name]
         end
 
-        # @api private
-        # @param superGroup [Group]
-        # @return [true,false]
-        def group_kind_of?(superGroup)
-            (self == superGroup) or (@superGroup and @superGroup.ref.group_kind_of?(superGroup))            
-        end
+        protected
+
+            def rawFields
+                @fields.values
+            end
 
     end
 end

data/lib/slow_blink/message/binary.rb

@@ -25,16 +25,15 @@ module SlowBlink::Message
     class BINARY
 
         # @private
-        def self.from_compact!(input, stack)
-            value = input.getBinary!
-            if value
+        def self.from_compact(input, stack)
+            if value = input.getBinary
                 if !@size or value.size <= @size
                     self.new(value)
                 else
                     raise WeakError8.new "W8: Binary value exceeds maximum size"
                 end
             else
-                value
+                nil
             end               
         end